Merge 7bfb3af0da into 13f0ebed96

fix(cppcheck): more clang format fix
fix(cppcheck): clang format
2026-02-06 15:47:39 +03:00 · 2026-01-27 21:26:21 +11:00 · 2026-01-26 00:33:27 +01:00 · 2026-01-26 00:27:58 +01:00 · 2026-01-26 00:22:05 +01:00 · 2026-01-26 00:16:16 +01:00
135 changed files with 2287 additions and 9427 deletions
--- a/.gitignore
+++ b/.gitignore
@ -6,6 +6,4 @@ lib/EpdFont/fontsrc
 *.generated.h
 .vs
 build
-**/__pycache__/
-/compile_commands.json
-/.cache
+**/__pycache__/
--- a/README.md
+++ b/README.md
@ -41,9 +41,7 @@ This project is **not affiliated with Xteink**; it's built as a community projec
  - [ ] Full UTF support
 - [x] Screen rotation

-Multi-language support: Read EPUBs in various languages, including English, Spanish, French, German, Italian, Portuguese, Russian, Ukrainian, Polish, Swedish, Norwegian, [and more](./USER_GUIDE.md#supported-languages).
-
-See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint. 
+See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint.

 ## Installing

--- a/USER_GUIDE.md
+++ b/USER_GUIDE.md
@ -81,18 +81,6 @@ See the [webserver docs](./docs/webserver.md) for more information on how to con
 > [!TIP]
 > Advanced users can also manage files programmatically or via the command line using `curl`. See the [webserver docs](./docs/webserver.md) for details.

-### 3.4.1 Calibre Wireless Transfers
-
-CrossPoint supports sending books from Calibre using the CrossPoint Reader device plugin.
-
-1. Install the plugin in Calibre:
-   - Head to https://github.com/crosspoint-reader/calibre-plugins/releases to download the latest version of the crosspoint_reader plugin.
-   - Download the zip file.
-   - Open Calibre → Preferences → Plugins → Load plugin from file → Select the zip file.
-2. On the device: File Transfer → Connect to Calibre → Join a network.
-3. Make sure your computer is on the same WiFi network.
-4. In Calibre, click "Send to device" to transfer books.
-
 ### 3.5 Settings

 The Settings screen allows you to configure the device's behavior. There are a few settings you can adjust:
@ -105,10 +93,6 @@ The Settings screen allows you to configure the device's behavior. There are a f
 - **Sleep Screen Cover Mode**: How to display the book cover when "Cover" sleep screen is selected:
  - "Fit" (default) - Scale the image down to fit centered on the screen, padding with white borders as necessary
  - "Crop" - Scale the image down and crop as necessary to try to to fill the screen (Note: this is experimental and may not work as expected)
- **Sleep Screen Cover Filter**: What filter will be applied to the book cover when "Cover" sleep screen is selected 
-  - "None" (default) - The cover image will be converted to a grayscale image and displayed as it is
-  - "Contrast" - The image will be displayed as a black & white image without grayscale conversion
-  - "Inverted" - The image will be inverted as in white&black and will be displayed without grayscale conversion
 - **Status Bar**: Configure the status bar displayed while reading:
  - "None" - No status bar
  - "No Progress" - Show status bar without reading progress
@ -148,7 +132,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
 - **Reader Paragraph Alignment**: Set the alignment of paragraphs; options are "Justified" (default), "Left", "Center", or "Right".
 - **Time to Sleep**: Set the duration of inactivity before the device automatically goes to sleep.
 - **Refresh Frequency**: Set how often the screen does a full refresh while reading to reduce ghosting.
- **OPDS Browser**: Configure OPDS server settings for browsing and downloading books. Set the server URL (for Calibre Content Server, add `/opds` to the end), and optionally configure username and password for servers requiring authentication. Note: Only HTTP Basic authentication is supported. If using Calibre Content Server with authentication enabled, you must set it to use Basic authentication instead of the default Digest authentication.
+- **Calibre Settings**: Set up integration for accessing a Calibre web library or connecting to Calibre as a wireless device.
 - **Check for updates**: Check for firmware updates over WiFi.

 ### 3.6 Sleep Screen
@ -194,15 +178,6 @@ This feature can be disabled in **[Settings](#35-settings)** to help avoid chang
 * **Return to Home:** Press and **hold** the **Back** button to close the book and return to the **[Home](#31-home-screen)** screen.
 * **Chapter Menu:** Press **Confirm** to open the **[Table of Contents/Chapter Selection](#5-chapter-selection-screen)**.

-### Supported Languages
-
-CrossPoint renders text using the following Unicode character blocks, enabling support for a wide range of languages:
-
-*   **Latin Script (Basic, Supplement, Extended-A):** Covers English, German, French, Spanish, Portuguese, Italian, Dutch, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian, Romanian, Slovak, Slovenian, Turkish, and others.
-*   **Cyrillic Script (Standard and Extended):** Covers Russian, Ukrainian, Belarusian, Bulgarian, Serbian, Macedonian, Kazakh, Kyrgyz, Mongolian, and others.
-
-What is not supported: Chinese, Japanese, Korean, Vietnamese, Hebrew, Arabic and Farsi.
-
 ---

 ## 5. Chapter Selection Screen
--- a/lib/EpdFont/builtinFonts/bookerly_12_bold.h
+++ b/lib/EpdFont/builtinFonts/bookerly_12_bold.h
@ -3,7 +3,6 @@
 * name: bookerly_12_bold
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_12_bold 12 ../builtinFonts/source/Bookerly/Bookerly-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_12_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_12_bolditalic.h
@ -3,7 +3,6 @@
 * name: bookerly_12_bolditalic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_12_bolditalic 12 ../builtinFonts/source/Bookerly/Bookerly-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_12_italic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_12_italic.h
@ -3,7 +3,6 @@
 * name: bookerly_12_italic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_12_italic 12 ../builtinFonts/source/Bookerly/Bookerly-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_12_regular.h
+++ b/lib/EpdFont/builtinFonts/bookerly_12_regular.h
@ -3,7 +3,6 @@
 * name: bookerly_12_regular
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_12_regular 12 ../builtinFonts/source/Bookerly/Bookerly-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_14_bold.h
+++ b/lib/EpdFont/builtinFonts/bookerly_14_bold.h
@ -3,7 +3,6 @@
 * name: bookerly_14_bold
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_14_bold 14 ../builtinFonts/source/Bookerly/Bookerly-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_14_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_14_bolditalic.h
@ -3,7 +3,6 @@
 * name: bookerly_14_bolditalic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_14_bolditalic 14 ../builtinFonts/source/Bookerly/Bookerly-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_14_italic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_14_italic.h
@ -3,7 +3,6 @@
 * name: bookerly_14_italic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_14_italic 14 ../builtinFonts/source/Bookerly/Bookerly-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_14_regular.h
+++ b/lib/EpdFont/builtinFonts/bookerly_14_regular.h
@ -3,7 +3,6 @@
 * name: bookerly_14_regular
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_14_regular 14 ../builtinFonts/source/Bookerly/Bookerly-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_16_bold.h
+++ b/lib/EpdFont/builtinFonts/bookerly_16_bold.h
@ -3,7 +3,6 @@
 * name: bookerly_16_bold
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_16_bold 16 ../builtinFonts/source/Bookerly/Bookerly-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_16_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_16_bolditalic.h
@ -3,7 +3,6 @@
 * name: bookerly_16_bolditalic
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_16_bolditalic 16 ../builtinFonts/source/Bookerly/Bookerly-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_16_italic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_16_italic.h
@ -3,7 +3,6 @@
 * name: bookerly_16_italic
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_16_italic 16 ../builtinFonts/source/Bookerly/Bookerly-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_16_regular.h
+++ b/lib/EpdFont/builtinFonts/bookerly_16_regular.h
@ -3,7 +3,6 @@
 * name: bookerly_16_regular
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_16_regular 16 ../builtinFonts/source/Bookerly/Bookerly-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_18_bold.h
+++ b/lib/EpdFont/builtinFonts/bookerly_18_bold.h
@ -3,7 +3,6 @@
 * name: bookerly_18_bold
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_18_bold 18 ../builtinFonts/source/Bookerly/Bookerly-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_18_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_18_bolditalic.h
@ -3,7 +3,6 @@
 * name: bookerly_18_bolditalic
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_18_bolditalic 18 ../builtinFonts/source/Bookerly/Bookerly-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_18_italic.h
+++ b/lib/EpdFont/builtinFonts/bookerly_18_italic.h
@ -3,7 +3,6 @@
 * name: bookerly_18_italic
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_18_italic 18 ../builtinFonts/source/Bookerly/Bookerly-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/bookerly_18_regular.h
+++ b/lib/EpdFont/builtinFonts/bookerly_18_regular.h
@ -3,7 +3,6 @@
 * name: bookerly_18_regular
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py bookerly_18_regular 18 ../builtinFonts/source/Bookerly/Bookerly-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_12_bold.h
+++ b/lib/EpdFont/builtinFonts/notosans_12_bold.h
@ -3,7 +3,6 @@
 * name: notosans_12_bold
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py notosans_12_bold 12 ../builtinFonts/source/NotoSans/NotoSans-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_12_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/notosans_12_bolditalic.h
@ -3,7 +3,6 @@
 * name: notosans_12_bolditalic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py notosans_12_bolditalic 12 ../builtinFonts/source/NotoSans/NotoSans-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_12_italic.h
+++ b/lib/EpdFont/builtinFonts/notosans_12_italic.h
@ -3,7 +3,6 @@
 * name: notosans_12_italic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py notosans_12_italic 12 ../builtinFonts/source/NotoSans/NotoSans-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_12_regular.h
+++ b/lib/EpdFont/builtinFonts/notosans_12_regular.h
@ -3,7 +3,6 @@
 * name: notosans_12_regular
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py notosans_12_regular 12 ../builtinFonts/source/NotoSans/NotoSans-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_14_bold.h
+++ b/lib/EpdFont/builtinFonts/notosans_14_bold.h
@ -3,7 +3,6 @@
 * name: notosans_14_bold
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py notosans_14_bold 14 ../builtinFonts/source/NotoSans/NotoSans-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_14_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/notosans_14_bolditalic.h
@ -3,7 +3,6 @@
 * name: notosans_14_bolditalic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py notosans_14_bolditalic 14 ../builtinFonts/source/NotoSans/NotoSans-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_14_italic.h
+++ b/lib/EpdFont/builtinFonts/notosans_14_italic.h
@ -3,7 +3,6 @@
 * name: notosans_14_italic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py notosans_14_italic 14 ../builtinFonts/source/NotoSans/NotoSans-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_14_regular.h
+++ b/lib/EpdFont/builtinFonts/notosans_14_regular.h
@ -3,7 +3,6 @@
 * name: notosans_14_regular
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py notosans_14_regular 14 ../builtinFonts/source/NotoSans/NotoSans-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_16_bold.h
+++ b/lib/EpdFont/builtinFonts/notosans_16_bold.h
@ -3,7 +3,6 @@
 * name: notosans_16_bold
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py notosans_16_bold 16 ../builtinFonts/source/NotoSans/NotoSans-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_16_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/notosans_16_bolditalic.h
@ -3,7 +3,6 @@
 * name: notosans_16_bolditalic
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py notosans_16_bolditalic 16 ../builtinFonts/source/NotoSans/NotoSans-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_16_italic.h
+++ b/lib/EpdFont/builtinFonts/notosans_16_italic.h
@ -3,7 +3,6 @@
 * name: notosans_16_italic
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py notosans_16_italic 16 ../builtinFonts/source/NotoSans/NotoSans-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_16_regular.h
+++ b/lib/EpdFont/builtinFonts/notosans_16_regular.h
@ -3,7 +3,6 @@
 * name: notosans_16_regular
 * size: 16
 * mode: 2-bit
- * Command used: fontconvert.py notosans_16_regular 16 ../builtinFonts/source/NotoSans/NotoSans-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_18_bold.h
+++ b/lib/EpdFont/builtinFonts/notosans_18_bold.h
@ -3,7 +3,6 @@
 * name: notosans_18_bold
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py notosans_18_bold 18 ../builtinFonts/source/NotoSans/NotoSans-Bold.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_18_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/notosans_18_bolditalic.h
@ -3,7 +3,6 @@
 * name: notosans_18_bolditalic
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py notosans_18_bolditalic 18 ../builtinFonts/source/NotoSans/NotoSans-BoldItalic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_18_italic.h
+++ b/lib/EpdFont/builtinFonts/notosans_18_italic.h
@ -3,7 +3,6 @@
 * name: notosans_18_italic
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py notosans_18_italic 18 ../builtinFonts/source/NotoSans/NotoSans-Italic.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_18_regular.h
+++ b/lib/EpdFont/builtinFonts/notosans_18_regular.h
@ -3,7 +3,6 @@
 * name: notosans_18_regular
 * size: 18
 * mode: 2-bit
- * Command used: fontconvert.py notosans_18_regular 18 ../builtinFonts/source/NotoSans/NotoSans-Regular.ttf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/notosans_8_regular.h
+++ b/lib/EpdFont/builtinFonts/notosans_8_regular.h
@ -3,7 +3,6 @@
 * name: notosans_8_regular
 * size: 8
 * mode: 1-bit
- * Command used: fontconvert.py notosans_8_regular 8 ../builtinFonts/source/NotoSans/NotoSans-Regular.ttf
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_10_bold.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_10_bold.h
@ -3,7 +3,6 @@
 * name: opendyslexic_10_bold
 * size: 10
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_10_bold 10 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Bold.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_10_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_10_bolditalic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_10_bolditalic
 * size: 10
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_10_bolditalic 10 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-BoldItalic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_10_italic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_10_italic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_10_italic
 * size: 10
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_10_italic 10 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Italic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_10_regular.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_10_regular.h
@ -3,7 +3,6 @@
 * name: opendyslexic_10_regular
 * size: 10
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_10_regular 10 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Regular.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_12_bold.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_12_bold.h
@ -3,7 +3,6 @@
 * name: opendyslexic_12_bold
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_12_bold 12 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Bold.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_12_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_12_bolditalic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_12_bolditalic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_12_bolditalic 12 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-BoldItalic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_12_italic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_12_italic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_12_italic
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_12_italic 12 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Italic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_12_regular.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_12_regular.h
@ -3,7 +3,6 @@
 * name: opendyslexic_12_regular
 * size: 12
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_12_regular 12 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Regular.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_14_bold.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_14_bold.h
@ -3,7 +3,6 @@
 * name: opendyslexic_14_bold
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_14_bold 14 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Bold.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_14_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_14_bolditalic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_14_bolditalic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_14_bolditalic 14 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-BoldItalic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_14_italic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_14_italic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_14_italic
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_14_italic 14 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Italic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_14_regular.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_14_regular.h
@ -3,7 +3,6 @@
 * name: opendyslexic_14_regular
 * size: 14
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_14_regular 14 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Regular.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_8_bold.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_8_bold.h
@ -3,7 +3,6 @@
 * name: opendyslexic_8_bold
 * size: 8
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_8_bold 8 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Bold.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_8_bolditalic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_8_bolditalic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_8_bolditalic
 * size: 8
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_8_bolditalic 8 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-BoldItalic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_8_italic.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_8_italic.h
@ -3,7 +3,6 @@
 * name: opendyslexic_8_italic
 * size: 8
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_8_italic 8 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Italic.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/opendyslexic_8_regular.h
+++ b/lib/EpdFont/builtinFonts/opendyslexic_8_regular.h
@ -3,7 +3,6 @@
 * name: opendyslexic_8_regular
 * size: 8
 * mode: 2-bit
- * Command used: fontconvert.py opendyslexic_8_regular 8 ../builtinFonts/source/OpenDyslexic/OpenDyslexic-Regular.otf --2bit
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/ubuntu_10_bold.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_10_bold.h
@ -3,7 +3,6 @@
 * name: ubuntu_10_bold
 * size: 10
 * mode: 1-bit
- * Command used: fontconvert.py ubuntu_10_bold 10 ../builtinFonts/source/Ubuntu/Ubuntu-Bold.ttf
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/ubuntu_10_regular.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_10_regular.h
@ -3,7 +3,6 @@
 * name: ubuntu_10_regular
 * size: 10
 * mode: 1-bit
- * Command used: fontconvert.py ubuntu_10_regular 10 ../builtinFonts/source/Ubuntu/Ubuntu-Regular.ttf
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/ubuntu_12_bold.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_12_bold.h
@ -3,7 +3,6 @@
 * name: ubuntu_12_bold
 * size: 12
 * mode: 1-bit
- * Command used: fontconvert.py ubuntu_12_bold 12 ../builtinFonts/source/Ubuntu/Ubuntu-Bold.ttf
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/builtinFonts/ubuntu_12_regular.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_12_regular.h
@ -3,7 +3,6 @@
 * name: ubuntu_12_regular
 * size: 12
 * mode: 1-bit
- * Command used: fontconvert.py ubuntu_12_regular 12 ../builtinFonts/source/Ubuntu/Ubuntu-Regular.ttf
 */
 #pragma once
 #include "EpdFontData.h"
--- a/lib/EpdFont/scripts/fontconvert.py
+++ b/lib/EpdFont/scripts/fontconvert.py
@ -270,17 +270,9 @@ for index, glyph in enumerate(all_glyphs):
    glyph_data.extend([b for b in packed])
    glyph_props.append(props)

-print(f"""/**
- * generated by fontconvert.py
- * name: {font_name}
- * size: {size}
- * mode: {'2-bit' if is2Bit else '1-bit'}
- * Command used: {' '.join(sys.argv)}
- */
-#pragma once
-#include "EpdFontData.h"
-""")
-
+print(f"/**\n * generated by fontconvert.py\n * name: {font_name}\n * size: {size}\n * mode: {'2-bit' if is2Bit else '1-bit'}\n */")
+print("#pragma once")
+print("#include \"EpdFontData.h\"\n")
 print(f"static const uint8_t {font_name}Bitmaps[{len(glyph_data)}] = {{")
 for c in chunks(glyph_data, 16):
    print ("    " + " ".join(f"0x{b:02X}," for b in c))
--- a/lib/Epub/Epub.cpp
+++ b/lib/Epub/Epub.cpp
@ -226,8 +226,6 @@ bool Epub::load(const bool buildIfMissing) {
  Serial.printf("[%lu] [EBP] Cache not found, building spine/TOC cache\n", millis());
  setupCacheDir();

-  const uint32_t indexingStart = millis();
-
  // Begin building cache - stream entries to disk immediately
  if (!bookMetadataCache->beginWrite()) {
    Serial.printf("[%lu] [EBP] Could not begin writing cache\n", millis());
@ -235,7 +233,6 @@ bool Epub::load(const bool buildIfMissing) {
  }

  // OPF Pass
-  const uint32_t opfStart = millis();
  BookMetadataCache::BookMetadata bookMetadata;
  if (!bookMetadataCache->beginContentOpfPass()) {
    Serial.printf("[%lu] [EBP] Could not begin writing content.opf pass\n", millis());
@ -249,10 +246,8 @@ bool Epub::load(const bool buildIfMissing) {
    Serial.printf("[%lu] [EBP] Could not end writing content.opf pass\n", millis());
    return false;
  }
-  Serial.printf("[%lu] [EBP] OPF pass completed in %lu ms\n", millis(), millis() - opfStart);

  // TOC Pass - try EPUB 3 nav first, fall back to NCX
-  const uint32_t tocStart = millis();
  if (!bookMetadataCache->beginTocPass()) {
    Serial.printf("[%lu] [EBP] Could not begin writing toc pass\n", millis());
    return false;
@ -281,7 +276,6 @@ bool Epub::load(const bool buildIfMissing) {
    Serial.printf("[%lu] [EBP] Could not end writing toc pass\n", millis());
    return false;
  }
-  Serial.printf("[%lu] [EBP] TOC pass completed in %lu ms\n", millis(), millis() - tocStart);

  // Close the cache files
  if (!bookMetadataCache->endWrite()) {
@ -290,13 +284,10 @@ bool Epub::load(const bool buildIfMissing) {
  }

  // Build final book.bin
-  const uint32_t buildStart = millis();
  if (!bookMetadataCache->buildBookBin(filepath, bookMetadata)) {
    Serial.printf("[%lu] [EBP] Could not update mappings and sizes\n", millis());
    return false;
  }
-  Serial.printf("[%lu] [EBP] buildBookBin completed in %lu ms\n", millis(), millis() - buildStart);
-  Serial.printf("[%lu] [EBP] Total indexing completed in %lu ms\n", millis(), millis() - indexingStart);

  if (!bookMetadataCache->cleanupTmpFiles()) {
    Serial.printf("[%lu] [EBP] Could not cleanup tmp files - ignoring\n", millis());
--- a/lib/Epub/Epub/BookMetadataCache.cpp
+++ b/lib/Epub/Epub/BookMetadataCache.cpp
@ -40,6 +40,7 @@ bool BookMetadataCache::endContentOpfPass() {
 bool BookMetadataCache::beginTocPass() {
  Serial.printf("[%lu] [BMC] Beginning toc pass\n", millis());

+  // Open spine file for reading
  if (!SdMan.openFileForRead("BMC", cachePath + tmpSpineBinFile, spineFile)) {
    return false;
  }
@ -47,41 +48,12 @@ bool BookMetadataCache::beginTocPass() {
    spineFile.close();
    return false;
  }
-
-  if (spineCount >= LARGE_SPINE_THRESHOLD) {
-    spineHrefIndex.clear();
-    spineHrefIndex.reserve(spineCount);
-    spineFile.seek(0);
-    for (int i = 0; i < spineCount; i++) {
-      auto entry = readSpineEntry(spineFile);
-      SpineHrefIndexEntry idx;
-      idx.hrefHash = fnvHash64(entry.href);
-      idx.hrefLen = static_cast<uint16_t>(entry.href.size());
-      idx.spineIndex = static_cast<int16_t>(i);
-      spineHrefIndex.push_back(idx);
-    }
-    std::sort(spineHrefIndex.begin(), spineHrefIndex.end(),
-              [](const SpineHrefIndexEntry& a, const SpineHrefIndexEntry& b) {
-                return a.hrefHash < b.hrefHash || (a.hrefHash == b.hrefHash && a.hrefLen < b.hrefLen);
-              });
-    spineFile.seek(0);
-    useSpineHrefIndex = true;
-    Serial.printf("[%lu] [BMC] Using fast index for %d spine items\n", millis(), spineCount);
-  } else {
-    useSpineHrefIndex = false;
-  }
-
  return true;
 }

 bool BookMetadataCache::endTocPass() {
  tocFile.close();
  spineFile.close();
-
-  spineHrefIndex.clear();
-  spineHrefIndex.shrink_to_fit();
-  useSpineHrefIndex = false;
-
  return true;
 }

@ -152,18 +124,6 @@ bool BookMetadataCache::buildBookBin(const std::string& epubPath, const BookMeta
  // LUTs complete
  // Loop through spines from spine file matching up TOC indexes, calculating cumulative size and writing to book.bin

-  // Build spineIndex->tocIndex mapping in one pass (O(n) instead of O(n*m))
-  std::vector<int16_t> spineToTocIndex(spineCount, -1);
-  tocFile.seek(0);
-  for (int j = 0; j < tocCount; j++) {
-    auto tocEntry = readTocEntry(tocFile);
-    if (tocEntry.spineIndex >= 0 && tocEntry.spineIndex < spineCount) {
-      if (spineToTocIndex[tocEntry.spineIndex] == -1) {
-        spineToTocIndex[tocEntry.spineIndex] = static_cast<int16_t>(j);
-      }
-    }
-  }
-
  ZipFile zip(epubPath);
  // Pre-open zip file to speed up size calculations
  if (!zip.open()) {
@ -173,56 +133,31 @@ bool BookMetadataCache::buildBookBin(const std::string& epubPath, const BookMeta
    tocFile.close();
    return false;
  }
-  // NOTE: We intentionally skip calling loadAllFileStatSlims() here.
-  // For large EPUBs (2000+ chapters), pre-loading all ZIP central directory entries
-  // into memory causes OOM crashes on ESP32-C3's limited ~380KB RAM.
-  // Instead, for large books we use a one-pass batch lookup that scans the ZIP
-  // central directory once and matches against spine targets using hash comparison.
-  // This is O(n*log(m)) instead of O(n*m) while avoiding memory exhaustion.
-  // See: https://github.com/crosspoint-reader/crosspoint-reader/issues/134
-
-  std::vector<uint32_t> spineSizes;
-  bool useBatchSizes = false;
-
-  if (spineCount >= LARGE_SPINE_THRESHOLD) {
-    Serial.printf("[%lu] [BMC] Using batch size lookup for %d spine items\n", millis(), spineCount);
-
-    std::vector<ZipFile::SizeTarget> targets;
-    targets.reserve(spineCount);
-
-    spineFile.seek(0);
-    for (int i = 0; i < spineCount; i++) {
-      auto entry = readSpineEntry(spineFile);
-      std::string path = FsHelpers::normalisePath(entry.href);
-
-      ZipFile::SizeTarget t;
-      t.hash = ZipFile::fnvHash64(path.c_str(), path.size());
-      t.len = static_cast<uint16_t>(path.size());
-      t.index = static_cast<uint16_t>(i);
-      targets.push_back(t);
-    }
-
-    std::sort(targets.begin(), targets.end(), [](const ZipFile::SizeTarget& a, const ZipFile::SizeTarget& b) {
-      return a.hash < b.hash || (a.hash == b.hash && a.len < b.len);
-    });
-
-    spineSizes.resize(spineCount, 0);
-    int matched = zip.fillUncompressedSizes(targets, spineSizes);
-    Serial.printf("[%lu] [BMC] Batch lookup matched %d/%d spine items\n", millis(), matched, spineCount);
-
-    targets.clear();
-    targets.shrink_to_fit();
-
-    useBatchSizes = true;
+  // TODO: For large ZIPs loading the all localHeaderOffsets will crash.
+  //       However not having them loaded is extremely slow. Need a better solution here.
+  //       Perhaps only a cache of spine items or a better way to speedup lookups?
+  if (!zip.loadAllFileStatSlims()) {
+    Serial.printf("[%lu] [BMC] Could not load zip local header offsets for size calculations\n", millis());
+    bookFile.close();
+    spineFile.close();
+    tocFile.close();
+    zip.close();
+    return false;
  }
-
  uint32_t cumSize = 0;
  spineFile.seek(0);
  int lastSpineTocIndex = -1;
  for (int i = 0; i < spineCount; i++) {
    auto spineEntry = readSpineEntry(spineFile);

-    spineEntry.tocIndex = spineToTocIndex[i];
+    tocFile.seek(0);
+    for (int j = 0; j < tocCount; j++) {
+      auto tocEntry = readTocEntry(tocFile);
+      if (tocEntry.spineIndex == i) {
+        spineEntry.tocIndex = j;
+        break;
+      }
+    }

    // Not a huge deal if we don't fine a TOC entry for the spine entry, this is expected behaviour for EPUBs
    // Logging here is for debugging
@ -234,25 +169,16 @@ bool BookMetadataCache::buildBookBin(const std::string& epubPath, const BookMeta
    }
    lastSpineTocIndex = spineEntry.tocIndex;

+    // Calculate size for cumulative size
    size_t itemSize = 0;
-    if (useBatchSizes) {
-      itemSize = spineSizes[i];
-      if (itemSize == 0) {
-        const std::string path = FsHelpers::normalisePath(spineEntry.href);
-        if (!zip.getInflatedFileSize(path.c_str(), &itemSize)) {
-          Serial.printf("[%lu] [BMC] Warning: Could not get size for spine item: %s\n", millis(), path.c_str());
-        }
-      }
+    const std::string path = FsHelpers::normalisePath(spineEntry.href);
+    if (zip.getInflatedFileSize(path.c_str(), &itemSize)) {
+      cumSize += itemSize;
+      spineEntry.cumulativeSize = cumSize;
    } else {
-      const std::string path = FsHelpers::normalisePath(spineEntry.href);
-      if (!zip.getInflatedFileSize(path.c_str(), &itemSize)) {
-        Serial.printf("[%lu] [BMC] Warning: Could not get size for spine item: %s\n", millis(), path.c_str());
-      }
+      Serial.printf("[%lu] [BMC] Warning: Could not get size for spine item: %s\n", millis(), path.c_str());
    }

-    cumSize += itemSize;
-    spineEntry.cumulativeSize = cumSize;
-
    // Write out spine data to book.bin
    writeSpineEntry(bookFile, spineEntry);
  }
@ -322,38 +248,21 @@ void BookMetadataCache::createTocEntry(const std::string& title, const std::stri
    return;
  }

-  int16_t spineIndex = -1;
-
-  if (useSpineHrefIndex) {
-    uint64_t targetHash = fnvHash64(href);
-    uint16_t targetLen = static_cast<uint16_t>(href.size());
-
-    auto it =
-        std::lower_bound(spineHrefIndex.begin(), spineHrefIndex.end(), SpineHrefIndexEntry{targetHash, targetLen, 0},
-                         [](const SpineHrefIndexEntry& a, const SpineHrefIndexEntry& b) {
-                           return a.hrefHash < b.hrefHash || (a.hrefHash == b.hrefHash && a.hrefLen < b.hrefLen);
-                         });
-
-    while (it != spineHrefIndex.end() && it->hrefHash == targetHash && it->hrefLen == targetLen) {
-      spineIndex = it->spineIndex;
+  int spineIndex = -1;
+  // find spine index
+  // TODO: This lookup is slow as need to scan through all items each time. We can't hold it all in memory due to size.
+  //       But perhaps we can load just the hrefs in a vector/list to do an index lookup?
+  spineFile.seek(0);
+  for (int i = 0; i < spineCount; i++) {
+    auto spineEntry = readSpineEntry(spineFile);
+    if (spineEntry.href == href) {
+      spineIndex = i;
      break;
    }
+  }

-    if (spineIndex == -1) {
-      Serial.printf("[%lu] [BMC] createTocEntry: Could not find spine item for TOC href %s\n", millis(), href.c_str());
-    }
-  } else {
-    spineFile.seek(0);
-    for (int i = 0; i < spineCount; i++) {
-      auto spineEntry = readSpineEntry(spineFile);
-      if (spineEntry.href == href) {
-        spineIndex = static_cast<int16_t>(i);
-        break;
-      }
-    }
-    if (spineIndex == -1) {
-      Serial.printf("[%lu] [BMC] createTocEntry: Could not find spine item for TOC href %s\n", millis(), href.c_str());
-    }
+  if (spineIndex == -1) {
+    Serial.printf("[%lu] [BMC] addTocEntry: Could not find spine item for TOC href %s\n", millis(), href.c_str());
  }

  const TocEntry entry(title, href, anchor, level, spineIndex);
--- a/lib/Epub/Epub/BookMetadataCache.h
+++ b/lib/Epub/Epub/BookMetadataCache.h
@ -2,9 +2,7 @@

 #include <SDCardManager.h>

-#include <algorithm>
 #include <string>
-#include <vector>

 class BookMetadataCache {
 public:
@ -55,27 +53,6 @@ class BookMetadataCache {
  FsFile spineFile;
  FsFile tocFile;

-  // Index for fast href→spineIndex lookup (used only for large EPUBs)
-  struct SpineHrefIndexEntry {
-    uint64_t hrefHash;  // FNV-1a 64-bit hash
-    uint16_t hrefLen;   // length for collision reduction
-    int16_t spineIndex;
-  };
-  std::vector<SpineHrefIndexEntry> spineHrefIndex;
-  bool useSpineHrefIndex = false;
-
-  static constexpr uint16_t LARGE_SPINE_THRESHOLD = 400;
-
-  // FNV-1a 64-bit hash function
-  static uint64_t fnvHash64(const std::string& s) {
-    uint64_t hash = 14695981039346656037ull;
-    for (char c : s) {
-      hash ^= static_cast<uint8_t>(c);
-      hash *= 1099511628211ull;
-    }
-    return hash;
-  }
-
  uint32_t writeSpineEntry(FsFile& file, const SpineEntry& entry) const;
  uint32_t writeTocEntry(FsFile& file, const TocEntry& entry) const;
  SpineEntry readSpineEntry(FsFile& file) const;
--- a/lib/Epub/Epub/hyphenation/LanguageRegistry.cpp
+++ b/lib/Epub/Epub/hyphenation/LanguageRegistry.cpp
@ -6,7 +6,6 @@
 #include "HyphenationCommon.h"
 #include "generated/hyph-de.trie.h"
 #include "generated/hyph-en.trie.h"
-#include "generated/hyph-es.trie.h"
 #include "generated/hyph-fr.trie.h"
 #include "generated/hyph-ru.trie.h"

@ -17,16 +16,14 @@ LanguageHyphenator englishHyphenator(en_us_patterns, isLatinLetter, toLowerLatin
 LanguageHyphenator frenchHyphenator(fr_patterns, isLatinLetter, toLowerLatin);
 LanguageHyphenator germanHyphenator(de_patterns, isLatinLetter, toLowerLatin);
 LanguageHyphenator russianHyphenator(ru_ru_patterns, isCyrillicLetter, toLowerCyrillic);
-LanguageHyphenator spanishHyphenator(es_patterns, isLatinLetter, toLowerLatin);

-using EntryArray = std::array<LanguageEntry, 5>;
+using EntryArray = std::array<LanguageEntry, 4>;

 const EntryArray& entries() {
  static const EntryArray kEntries = {{{"english", "en", &englishHyphenator},
                                       {"french", "fr", &frenchHyphenator},
                                       {"german", "de", &germanHyphenator},
-                                       {"russian", "ru", &russianHyphenator},
-                                       {"spanish", "es", &spanishHyphenator}}};
+                                       {"russian", "ru", &russianHyphenator}}};
  return kEntries;
 }

--- a/lib/Epub/Epub/hyphenation/generated/hyph-es.trie.h
+++ b/lib/Epub/Epub/hyphenation/generated/hyph-es.trie.h
@ -1,734 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-#include "../SerializedHyphenationTrie.h"
-
-// Auto-generated by generate_hyphenation_trie.py. Do not edit manually.
-alignas(4) constexpr uint8_t es_trie_data[] = {
-    0x00, 0x00, 0x34, 0xFC, 0x01, 0x04, 0x16, 0x02, 0x0E, 0x0C, 0x02, 0x16, 0x02, 0x0D, 0x0C, 0x22, 0x0F, 0x2C, 0x0F,
-    0x22, 0x0D, 0x2C, 0x0D, 0x0B, 0x16, 0x0B, 0x20, 0x15, 0x16, 0x15, 0x0C, 0x02, 0x0C, 0x17, 0x0E, 0x04, 0x2C, 0x05,
-    0x04, 0x0D, 0x04, 0x21, 0x04, 0x18, 0x0D, 0x04, 0x17, 0x04, 0x0D, 0x17, 0x04, 0x0E, 0x0D, 0x04, 0x0D, 0x21, 0x04,
-    0x0D, 0x21, 0x21, 0x0F, 0x0E, 0x0F, 0x0E, 0x0D, 0x0F, 0x0E, 0x17, 0x33, 0x33, 0x0C, 0x33, 0x16, 0x29, 0x29, 0x0C,
-    0x29, 0x16, 0x21, 0x0C, 0x21, 0x0E, 0x34, 0x0D, 0x3E, 0x36, 0x0D, 0x3F, 0x2B, 0x16, 0x0D, 0x3D, 0x3D, 0x0C, 0x3D,
-    0x16, 0x1F, 0x1F, 0x16, 0x2A, 0x2C, 0x0D, 0x0E, 0x0E, 0x21, 0x1F, 0x0C, 0x2A, 0x0D, 0x2A, 0x0B, 0x2A, 0x0B, 0x0C,
-    0x2A, 0x0B, 0x16, 0x37, 0x20, 0x0C, 0x20, 0x16, 0x35, 0x24, 0x47, 0x47, 0x0C, 0x47, 0x16, 0x20, 0x0B, 0x20, 0x0D,
-    0x0C, 0x20, 0x0D, 0x16, 0x20, 0x20, 0x03, 0x17, 0x0E, 0x0D, 0x23, 0x0E, 0x17, 0x17, 0x17, 0x21, 0x16, 0x0D, 0x18,
-    0x48, 0x49, 0x16, 0x0C, 0x0C, 0x16, 0x0C, 0x16, 0x2D, 0x2B, 0x0E, 0x0D, 0x2B, 0x0E, 0x17, 0x17, 0x2B, 0x34, 0x0B,
-    0x34, 0x0B, 0x0C, 0x34, 0x0B, 0x16, 0x21, 0x20, 0x0D, 0x21, 0x0E, 0x17, 0x20, 0x0D, 0x04, 0x0F, 0x19, 0x0C, 0x0D,
-    0x2E, 0x0F, 0x0E, 0x21, 0x17, 0x0E, 0x2D, 0x0E, 0x2B, 0x0E, 0x22, 0x17, 0x17, 0x0E, 0x22, 0x0D, 0x0E, 0x38, 0x19,
-    0x18, 0x03, 0x0C, 0x22, 0x0B, 0x0E, 0x22, 0x0B, 0x18, 0x40, 0x2A, 0x0C, 0x0C, 0x2A, 0x0C, 0x16, 0x18, 0x0D, 0x0C,
-    0x18, 0x0D, 0x0E, 0x2B, 0x21, 0x2B, 0x17, 0x2A, 0x16, 0x02, 0x33, 0x02, 0x33, 0x0C, 0x02, 0x33, 0x16, 0x35, 0x0E,
-    0x04, 0x0C, 0x20, 0x0C, 0x0C, 0x20, 0x0C, 0x16, 0x2B, 0x0E, 0x0E, 0x2B, 0x0E, 0x18, 0x04, 0x0D, 0x0E, 0x0D, 0x19,
-    0x0E, 0x41, 0x10, 0x2A, 0x20, 0x04, 0x0C, 0x0D, 0x03, 0x0E, 0x16, 0x0D, 0x0E, 0x18, 0x0F, 0x05, 0x0E, 0x07, 0x0E,
-    0xA0, 0x00, 0x51, 0xA0, 0x00, 0x71, 0xA0, 0x00, 0xC3, 0xA3, 0x00, 0x71, 0x74, 0x6E, 0x7A, 0xFD, 0xFD, 0xFD, 0xA1,
-    0x00, 0x71, 0x74, 0xF4, 0xA1, 0x00, 0x71, 0x6E, 0xEF, 0xA3, 0x00, 0x71, 0x74, 0x73, 0x6E, 0xEA, 0xEA, 0xEA, 0xA2,
-    0x00, 0x71, 0x7A, 0x73, 0xE1, 0xE1, 0xA0, 0x00, 0xA2, 0xB6, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68,
-    0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xD1, 0xFD, 0xFD, 0xFD,
-    0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xA0,
-    0x01, 0xD2, 0x21, 0xAD, 0xFD, 0x21, 0xC3, 0xFD, 0x21, 0x6E, 0xFD, 0xA0, 0x05, 0xB1, 0xA0, 0x05, 0xC2, 0xA0, 0x05,
-    0xE2, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x27, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75,
-    0xC3, 0xEC, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xF5, 0x21, 0x6F, 0xF1, 0x21, 0x69, 0xFD, 0x21, 0x6C, 0xFD, 0xA0, 0x05,
-    0x81, 0xA0, 0x06, 0x72, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0xA2, 0x05, 0x81, 0x6F, 0x61, 0xFA, 0xFD, 0xAE, 0x06,
-    0x31, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6C, 0x6D, 0x70, 0x71, 0x73, 0x74, 0x76, 0x7A, 0xED, 0xED, 0xF9, 0xED,
-    0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0xED, 0x21, 0x6E, 0xE1, 0xA0, 0x06, 0x01, 0xA0, 0x06, 0x92,
-    0xA0, 0x06, 0x12, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0xA0, 0x02, 0x51, 0x21, 0x61,
-    0xFD, 0x21, 0xAD, 0xFD, 0x21, 0xC3, 0xFD, 0x21, 0x67, 0xFD, 0x21, 0x6F, 0xFD, 0x28, 0x68, 0x61, 0x65, 0x69, 0x6F,
-    0x75, 0xC3, 0x6C, 0xDA, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xE3, 0xFD, 0x44, 0x75, 0x62, 0x65, 0x6F, 0xFF, 0x65, 0xFF,
-    0x91, 0xFF, 0xC6, 0xFF, 0xEF, 0xA0, 0x04, 0x41, 0xA0, 0x04, 0x52, 0xA0, 0x04, 0x72, 0x25, 0xA1, 0xA9, 0xAD, 0xB3,
-    0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x27, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xEC, 0xEF, 0xEF, 0xEF, 0xEF,
-    0xEF, 0xF5, 0x21, 0x61, 0xF1, 0x21, 0x63, 0xFD, 0x21, 0x73, 0xFD, 0xD8, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66,
-    0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C, 0x72, 0x69, 0x75,
-    0xFE, 0xC5, 0xFE, 0xC8, 0xFE, 0xCE, 0xFE, 0xC8, 0xFE, 0xD7, 0xFE, 0xDC, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE,
-    0xDC, 0xFE, 0xC8, 0xFE, 0xE1, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xEA, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xC8, 0xFE, 0xC8,
-    0xFE, 0xC8, 0xFE, 0xF4, 0xFE, 0xF4, 0xFF, 0xC7, 0xFF, 0xFD, 0x41, 0x6C, 0xFF, 0x45, 0x21, 0x61, 0xFC, 0x21, 0x75,
-    0xFD, 0x41, 0x72, 0xFF, 0x3B, 0x22, 0x6E, 0x75, 0xF9, 0xFC, 0x41, 0x78, 0xFF, 0x32, 0x41, 0x78, 0xFF, 0x34, 0x21,
-    0xB3, 0xFC, 0x41, 0x6E, 0xFF, 0x27, 0xA0, 0x01, 0x52, 0x21, 0x64, 0xFD, 0xA0, 0x06, 0x43, 0x21, 0x61, 0xFD, 0x21,
-    0x65, 0xFA, 0x23, 0x6E, 0x70, 0x76, 0xF4, 0xFA, 0xFD, 0x21, 0x74, 0xEA, 0x21, 0x73, 0xFD, 0x21, 0x6E, 0xFA, 0x21,
-    0x69, 0xED, 0x21, 0x6C, 0xFD, 0x24, 0x61, 0x65, 0x69, 0x6F, 0xEA, 0xF4, 0xF7, 0xFD, 0x21, 0x6E, 0xF7, 0x25, 0x61,
-    0x6F, 0xC3, 0x75, 0x65, 0xBB, 0xC0, 0xC8, 0xCB, 0xFD, 0xA1, 0x00, 0x61, 0x69, 0xF5, 0xA0, 0x07, 0xB1, 0x21, 0x62,
-    0xFD, 0xA0, 0x00, 0xF1, 0x21, 0x68, 0xFD, 0x22, 0x69, 0x6F, 0xFA, 0xFA, 0x21, 0x74, 0xF5, 0x21, 0x6E, 0xFD, 0x21,
-    0x65, 0xFD, 0x24, 0x63, 0x73, 0x72, 0x74, 0xEF, 0xF2, 0xFD, 0xEC, 0xA2, 0x06, 0x01, 0x69, 0x65, 0xE0, 0xF7, 0xA0,
-    0x02, 0x91, 0x21, 0x72, 0xFD, 0x21, 0x65, 0xFA, 0x21, 0x65, 0xFD, 0x22, 0x65, 0x72, 0xF7, 0xFD, 0x21, 0x6E, 0xEF,
-    0x41, 0x6C, 0xFE, 0x6F, 0x22, 0x65, 0x75, 0xF9, 0xFC, 0x21, 0x74, 0xE3, 0x21, 0x73, 0xFD, 0x21, 0xB3, 0xFD, 0x21,
-    0xC3, 0xFD, 0x41, 0x63, 0xFE, 0x5A, 0x21, 0x73, 0xFC, 0x22, 0x65, 0x69, 0xFD, 0xF9, 0x21, 0x64, 0xCB, 0x21, 0x6E,
-    0xFD, 0x21, 0x65, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x61, 0xD3, 0x21, 0x69, 0xFD, 0x21, 0x6F, 0xB9, 0x21, 0x74, 0xFD,
-    0xA7, 0x07, 0x62, 0x63, 0x67, 0x70, 0x6C, 0x72, 0x78, 0x75, 0xBF, 0xCB, 0xD9, 0xE3, 0xF1, 0xF7, 0xFD, 0x42, 0x63,
-    0x74, 0xFF, 0xA2, 0xFF, 0xA2, 0x41, 0x63, 0xFF, 0x9B, 0x22, 0x69, 0x75, 0xF5, 0xFC, 0x41, 0x69, 0xFF, 0x92, 0x21,
-    0x63, 0xFC, 0x21, 0x69, 0xFD, 0x41, 0xA1, 0xFE, 0x0B, 0x21, 0xC3, 0xFC, 0x41, 0x73, 0xFF, 0x81, 0x21, 0x69, 0xFC,
-    0xA4, 0x07, 0x62, 0x64, 0x66, 0x74, 0x78, 0xE3, 0xEF, 0xF6, 0xFD, 0x41, 0x75, 0xFF, 0x8C, 0x21, 0x70, 0xFC, 0x41,
-    0x6F, 0xFD, 0xEB, 0xA2, 0x07, 0x62, 0x6D, 0x74, 0xF9, 0xFC, 0xA0, 0x00, 0xF2, 0x21, 0x69, 0xFD, 0xA0, 0x01, 0x32,
-    0x21, 0x72, 0xFD, 0x21, 0xA9, 0xFD, 0x43, 0x65, 0xC3, 0x74, 0xFF, 0xFA, 0xFF, 0xFD, 0xFF, 0x2A, 0x41, 0x6E, 0xFF,
-    0x20, 0x21, 0xAD, 0xFC, 0x23, 0x65, 0x69, 0xC3, 0xF9, 0xF9, 0xFD, 0x21, 0x64, 0xF9, 0xA3, 0x05, 0x02, 0x6B, 0x70,
-    0x72, 0xD9, 0xE5, 0xFD, 0xA0, 0x07, 0x62, 0xA0, 0x07, 0xA1, 0x21, 0x6C, 0xFD, 0x21, 0x75, 0xFD, 0xA1, 0x07, 0x82,
-    0x67, 0xFD, 0xA0, 0x07, 0x82, 0xC1, 0x07, 0x82, 0x70, 0xFE, 0xFD, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xF2, 0xF7,
-    0xF7, 0xFA, 0xF7, 0xA0, 0x01, 0xA1, 0x21, 0x62, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x75, 0xFD, 0x48, 0x68, 0x61, 0x65,
-    0x69, 0x6F, 0x75, 0xC3, 0x6E, 0xFE, 0xF2, 0xFF, 0x46, 0xFF, 0x7F, 0xFF, 0x95, 0xFF, 0xC6, 0xFF, 0xCF, 0xFF, 0xE9,
-    0xFF, 0xFD, 0xA0, 0x0A, 0x01, 0x21, 0x74, 0xFD, 0x21, 0x75, 0xFD, 0xA2, 0x00, 0x61, 0x6F, 0x61, 0xDE, 0xFD, 0xA0,
-    0x08, 0x12, 0xA0, 0x08, 0x33, 0xC2, 0x07, 0x82, 0x6D, 0x6E, 0xFD, 0x4D, 0xFD, 0x4D, 0xA0, 0x0B, 0x45, 0x23, 0xA1,
-    0xA9, 0xB3, 0xFD, 0xFD, 0xFD, 0x24, 0x61, 0x65, 0x6F, 0xC3, 0xF6, 0xF6, 0xF6, 0xF9, 0x21, 0x73, 0xF7, 0x21, 0x65,
-    0xFD, 0x21, 0x72, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xFD, 0xA1, 0x07, 0x82, 0x6E, 0xFD, 0xA0, 0x08, 0x63, 0xA0,
-    0x08, 0x92, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFA, 0xFD, 0xFD, 0xFD, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F,
-    0x75, 0xC3, 0xFF, 0xB9, 0xFF, 0xBC, 0xFF, 0xBF, 0xFF, 0xEA, 0xFF, 0x70, 0xFF, 0x70, 0xFF, 0xF5, 0x42, 0x73, 0x75,
-    0xFF, 0xEA, 0xFF, 0x96, 0xA0, 0x09, 0x91, 0x21, 0x68, 0xFD, 0xA1, 0x09, 0x81, 0x63, 0xFD, 0x21, 0x6F, 0xFB, 0x21,
-    0x69, 0xFD, 0x21, 0x63, 0xFD, 0x21, 0x65, 0xFD, 0xA2, 0x00, 0x61, 0x65, 0x69, 0xE2, 0xFD, 0xA0, 0x00, 0x61, 0xA0,
-    0x0C, 0xC3, 0x21, 0x75, 0xFD, 0xA0, 0x04, 0x91, 0x21, 0x74, 0xFD, 0x22, 0x64, 0x73, 0xF7, 0xFD, 0x22, 0x6E, 0x73,
-    0xF5, 0xF5, 0x21, 0x6F, 0xFB, 0x22, 0x74, 0x7A, 0xED, 0xED, 0x21, 0x6E, 0xFB, 0x21, 0x61, 0xFD, 0x21, 0x64, 0xFD,
-    0x43, 0x63, 0x65, 0x6E, 0xFF, 0xEF, 0xFD, 0x20, 0xFF, 0xFD, 0x21, 0x6E, 0xD8, 0x23, 0x65, 0x61, 0x69, 0xD8, 0xF3,
-    0xFD, 0x21, 0x6C, 0xF9, 0x41, 0x69, 0xFD, 0x1D, 0xA0, 0x04, 0xA2, 0xA0, 0x04, 0xC2, 0x25, 0xA1, 0xA9, 0xAD, 0xB3,
-    0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x27, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xB3, 0xEF, 0xEF, 0xEF, 0xEF,
-    0xEF, 0xF5, 0x22, 0x6C, 0x6F, 0xDC, 0xF1, 0xA2, 0x00, 0x61, 0x61, 0x69, 0xD4, 0xFB, 0xA0, 0x0D, 0x43, 0x21, 0x69,
-    0xFD, 0x21, 0x72, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x62, 0xF4, 0x21, 0xA1, 0xFD, 0x22, 0xC3, 0x61, 0xFD, 0xFA, 0x23,
-    0x66, 0x6D, 0x72, 0xEF, 0xF2, 0xFB, 0xA0, 0x0D, 0x73, 0x21, 0x62, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x72, 0xFD, 0xA0,
-    0x0D, 0x42, 0x21, 0x69, 0xFD, 0x21, 0x74, 0xFD, 0x21, 0x70, 0xFD, 0x22, 0xA1, 0xB3, 0xF1, 0xFD, 0x21, 0x70, 0xEF,
-    0x21, 0x6F, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x75, 0xFD, 0x21, 0x6D, 0xE3, 0x21, 0xA1, 0xFD, 0x22, 0x61, 0xC3, 0xFA,
-    0xFD, 0x21, 0x6C, 0xFB, 0x21, 0x73, 0xFD, 0x41, 0x70, 0xFE, 0x28, 0x21, 0x73, 0xFC, 0x21, 0x6C, 0xCB, 0x22, 0x69,
-    0x65, 0xFA, 0xFD, 0x45, 0x61, 0xC3, 0x65, 0x69, 0x68, 0xFF, 0xB0, 0xFF, 0xCF, 0xFF, 0xDD, 0xFF, 0xEE, 0xFF, 0xFB,
-    0x21, 0x6E, 0xF0, 0xA0, 0x06, 0xD2, 0x41, 0x69, 0xFB, 0xE3, 0xA0, 0x0E, 0x92, 0x21, 0x65, 0xFD, 0xC3, 0x0D, 0xB3,
-    0x63, 0x72, 0x6A, 0xFF, 0xF6, 0xFB, 0xD9, 0xFF, 0xFD, 0x21, 0x6F, 0xEE, 0x21, 0xAD, 0xFD, 0x43, 0x67, 0x69, 0xC3,
-    0xFB, 0xC7, 0xFF, 0xE8, 0xFF, 0xFD, 0xA0, 0x06, 0xB2, 0xA1, 0x0E, 0x92, 0x61, 0xDB, 0x22, 0x63, 0x72, 0xF8, 0xFB,
-    0x21, 0x65, 0xFB, 0x41, 0x72, 0xFB, 0xAD, 0xA1, 0x0E, 0x92, 0x73, 0xCA, 0x23, 0x65, 0x61, 0x69, 0xC5, 0xFB, 0xC5,
-    0x21, 0x61, 0xBE, 0xC6, 0x0D, 0xB3, 0x72, 0x6C, 0x61, 0x6D, 0x74, 0x6F, 0xFF, 0xD3, 0xFF, 0xEA, 0xFF, 0xED, 0xFF,
-    0xF6, 0xFF, 0xFD, 0xFB, 0x9A, 0xA0, 0x05, 0x71, 0x21, 0x6F, 0xFD, 0x21, 0x64, 0xFD, 0xC3, 0x05, 0x81, 0x64, 0x65,
-    0x75, 0xFC, 0x8E, 0xFF, 0x9D, 0xFF, 0xFD, 0xC1, 0x0E, 0x92, 0x6F, 0xFF, 0x91, 0x43, 0xA1, 0xA9, 0xB3, 0xFF, 0x8B,
-    0xFF, 0x8B, 0xFF, 0x8B, 0x45, 0x61, 0x65, 0x6C, 0x6F, 0xC3, 0xFF, 0x81, 0xFF, 0x81, 0xFF, 0xF0, 0xFF, 0x81, 0xFF,
-    0xF6, 0x42, 0x61, 0x6F, 0xFF, 0x71, 0xFF, 0x71, 0x41, 0x72, 0xFF, 0x8C, 0x21, 0x70, 0xFC, 0x41, 0x72, 0xFF, 0x63,
-    0x21, 0x65, 0xFC, 0x41, 0x61, 0xFB, 0x3B, 0x42, 0x6D, 0x74, 0xFB, 0x37, 0xFF, 0xFC, 0xC7, 0x0D, 0xB3, 0x6E, 0x67,
-    0x6C, 0x7A, 0x6D, 0x63, 0x73, 0xFF, 0xB4, 0xFF, 0x63, 0xFF, 0xD0, 0xFF, 0xE0, 0xFF, 0xEB, 0xFF, 0xF2, 0xFF, 0xF9,
-    0x41, 0x65, 0xFF, 0x5B, 0x41, 0x73, 0xFF, 0x8F, 0x21, 0x65, 0xFC, 0xA2, 0x0D, 0xB3, 0x70, 0x72, 0xF5, 0xFD, 0x42,
-    0x61, 0x65, 0xFF, 0x27, 0xFF, 0x39, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xFF, 0x20, 0xFF, 0x95, 0xFF, 0x20, 0xFF, 0x20,
-    0xA2, 0x0D, 0xB3, 0x72, 0x6C, 0xEC, 0xF3, 0xA0, 0x0D, 0xE3, 0xC1, 0x0D, 0xE3, 0x6E, 0xFA, 0xE8, 0xA0, 0x0E, 0x72,
-    0xA1, 0x05, 0x81, 0x69, 0xFD, 0xA1, 0x0D, 0xE3, 0x6E, 0xFB, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xEA, 0xEA, 0xED,
-    0xFB, 0xEA, 0x41, 0x76, 0xFF, 0x0D, 0x41, 0x6D, 0xFF, 0x09, 0x22, 0x65, 0x6F, 0xF8, 0xFC, 0x48, 0x68, 0x61, 0x65,
-    0x69, 0x6F, 0x75, 0xC3, 0x72, 0xFE, 0xD7, 0xFE, 0xE4, 0xFF, 0x23, 0xFF, 0x8D, 0xFF, 0xB0, 0xFF, 0xCB, 0xFF, 0xE8,
-    0xFF, 0xFB, 0x21, 0x74, 0xE7, 0x21, 0x73, 0xFD, 0x41, 0x70, 0xFB, 0xB0, 0x21, 0xBA, 0xFC, 0x22, 0x75, 0xC3, 0xF9,
-    0xFD, 0xA0, 0x01, 0x11, 0x21, 0x6E, 0xFD, 0x21, 0xAD, 0xFD, 0x22, 0x69, 0xC3, 0xFA, 0xFD, 0x21, 0x64, 0xFB, 0xA2,
-    0x04, 0xA2, 0x63, 0x72, 0xEA, 0xFD, 0x21, 0x6C, 0xE8, 0x21, 0x75, 0xFD, 0x21, 0x62, 0xFD, 0xA1, 0x04, 0xC2, 0x6D,
-    0xFD, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF, 0xFB, 0xFD, 0xE3, 0xFD, 0xE3, 0xFD, 0xE3, 0xFD, 0xE3, 0x47, 0x68,
-    0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xFD, 0x94, 0xFD, 0xD0, 0xFD, 0xD0, 0xFD, 0xD0, 0xFF, 0xDB, 0xFD, 0xD0, 0xFF,
-    0xF0, 0x22, 0xA1, 0xAD, 0xB4, 0xB4, 0x24, 0x61, 0xC3, 0x65, 0x69, 0xAF, 0xFB, 0xAF, 0xAF, 0x21, 0x62, 0xF7, 0xC2,
-    0x01, 0x11, 0x61, 0x6F, 0xFF, 0xA3, 0xFF, 0xA3, 0x21, 0x62, 0xF7, 0x21, 0xAD, 0xFD, 0xA2, 0x04, 0x91, 0x69, 0xC3,
-    0xEE, 0xFD, 0x41, 0x74, 0xFA, 0x1F, 0x21, 0x72, 0xFC, 0x21, 0x6F, 0xFD, 0xA1, 0x0D, 0xB2, 0x62, 0xFD, 0x41, 0x72,
-    0xFE, 0x63, 0x21, 0x61, 0xFC, 0xA1, 0x0D, 0xB2, 0x74, 0xFD, 0xA0, 0x0D, 0xB2, 0xA0, 0x0E, 0xB2, 0x25, 0xA1, 0xA9,
-    0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x27, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xCD, 0xDE, 0xEA,
-    0xEF, 0xEF, 0xEF, 0xF5, 0x42, 0x65, 0x6F, 0xFF, 0x88, 0xFF, 0xF1, 0xC3, 0x00, 0x61, 0x61, 0x6F, 0x72, 0xFD, 0xF4,
-    0xFF, 0x3C, 0xFF, 0xF9, 0x41, 0x72, 0xFB, 0x6B, 0x21, 0x65, 0xFC, 0x41, 0xB3, 0xFB, 0x4A, 0x42, 0x6F, 0xC3, 0xFB,
-    0x46, 0xFF, 0xFC, 0x43, 0x72, 0x69, 0x73, 0xFB, 0x3C, 0xFF, 0xF2, 0xFF, 0xF9, 0x42, 0x73, 0x74, 0xFB, 0x32, 0xFB,
-    0x32, 0x41, 0xAD, 0xFB, 0x48, 0x22, 0x69, 0xC3, 0xF5, 0xFC, 0x21, 0x6D, 0xFB, 0x41, 0x6D, 0xFB, 0x1F, 0x21, 0x72,
-    0xFC, 0x21, 0xAD, 0xFD, 0x22, 0x69, 0xC3, 0xFA, 0xFD, 0x41, 0x76, 0xFB, 0x10, 0x21, 0xA1, 0xFC, 0xA0, 0x04, 0xE2,
-    0x21, 0x70, 0xFD, 0x23, 0x61, 0xC3, 0x75, 0xF3, 0xF7, 0xFD, 0x21, 0x72, 0xF9, 0x41, 0x69, 0xFB, 0x5E, 0x21, 0x64,
-    0xFC, 0x21, 0x6E, 0xFD, 0x41, 0xB1, 0xFA, 0xEF, 0x21, 0xC3, 0xFC, 0x21, 0xBA, 0xFD, 0x23, 0x6F, 0x75, 0xC3, 0xF3,
-    0xFA, 0xFD, 0x41, 0x73, 0xFF, 0x42, 0x21, 0xBA, 0xFC, 0x42, 0x75, 0xC3, 0xFA, 0xF7, 0xFF, 0xFD, 0x41, 0x67, 0xFA,
-    0xD3, 0x41, 0x7A, 0xFE, 0x14, 0x41, 0x6A, 0xFA, 0xC8, 0x23, 0xA9, 0xAD, 0xB3, 0xF4, 0xF8, 0xFC, 0x42, 0x61, 0xC3,
-    0xF9, 0x40, 0xFB, 0x35, 0x42, 0x6D, 0x74, 0xF9, 0x39, 0xF9, 0x39, 0x43, 0x7A, 0x6D, 0x73, 0xFF, 0xF2, 0xFA, 0xAF,
-    0xFF, 0xF9, 0x45, 0x65, 0xC3, 0x69, 0x6F, 0x71, 0xFF, 0xD5, 0xFF, 0xE1, 0xFF, 0xF6, 0xFF, 0xDD, 0xFA, 0xA5, 0x41,
-    0xAD, 0xFF, 0x76, 0x42, 0x69, 0xC3, 0xFF, 0x72, 0xFF, 0xFC, 0x43, 0xA1, 0xA9, 0xB3, 0xFA, 0x8A, 0xFA, 0x8A, 0xFA,
-    0x8A, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xFA, 0x80, 0xFF, 0xF6, 0xFA, 0x80, 0xFA, 0x80, 0x41, 0x65, 0xFA, 0xD8, 0x21,
-    0x72, 0xFC, 0x42, 0x6E, 0x74, 0xFA, 0xA1, 0xFA, 0x6C, 0xA0, 0x00, 0x40, 0x21, 0x74, 0xFD, 0x21, 0x65, 0xFD, 0x42,
-    0xA9, 0xAD, 0xFA, 0x94, 0xFF, 0xFD, 0x22, 0x65, 0xC3, 0xE9, 0xF9, 0x22, 0x61, 0x72, 0xE1, 0xFB, 0x41, 0x67, 0xFF,
-    0x42, 0x41, 0xBA, 0xFF, 0x28, 0x42, 0x75, 0xC3, 0xFF, 0x24, 0xFF, 0xFC, 0xCE, 0x07, 0x62, 0x62, 0x64, 0x66, 0x67,
-    0x63, 0x6A, 0x6C, 0x6E, 0x6D, 0x70, 0x65, 0x71, 0x7A, 0x73, 0xFF, 0x00, 0xFF, 0x1A, 0xFF, 0x27, 0xFF, 0x40, 0xFF,
-    0x57, 0xFF, 0x65, 0xFF, 0x97, 0xFF, 0xAB, 0xFF, 0xBC, 0xFF, 0xEC, 0xFF, 0xF1, 0xFF, 0x33, 0xFF, 0x33, 0xFF, 0xF9,
-    0xA0, 0x05, 0x02, 0x49, 0x6F, 0x63, 0x69, 0x66, 0x67, 0x76, 0x61, 0x73, 0x74, 0xF8, 0x8F, 0xFA, 0x0C, 0xFA, 0x71,
-    0xFA, 0x0C, 0xFA, 0x0C, 0xFA, 0x0C, 0xF8, 0x8F, 0xFA, 0x0C, 0xFA, 0x0C, 0x41, 0x64, 0xF8, 0x73, 0x21, 0x6E, 0xFC,
-    0x21, 0x69, 0xFD, 0xC3, 0x07, 0x62, 0x6E, 0x6D, 0x76, 0xFF, 0xDA, 0xFE, 0xDD, 0xFF, 0xFD, 0x41, 0x6E, 0xF9, 0xF7,
-    0x21, 0x65, 0xFC, 0x41, 0x61, 0xF9, 0xD3, 0x22, 0x69, 0x67, 0xF9, 0xFC, 0xC4, 0x07, 0x62, 0x62, 0x72, 0x63, 0x6A,
-    0xFE, 0xC1, 0xFF, 0xFB, 0xF9, 0xCA, 0xFA, 0x73, 0x42, 0xA1, 0xB3, 0xF9, 0xBB, 0xF9, 0xBB, 0x43, 0x61, 0xC3, 0x6F,
-    0xF9, 0xB4, 0xFF, 0xF9, 0xF9, 0xB4, 0x42, 0x63, 0x71, 0xFF, 0xF6, 0xF9, 0xAA, 0x42, 0x63, 0x71, 0xFF, 0xD0, 0xF9,
-    0xA3, 0x21, 0xAD, 0xF9, 0x22, 0x69, 0xC3, 0xEF, 0xFD, 0xC1, 0x05, 0x81, 0x74, 0xFC, 0x34, 0x41, 0x74, 0xFC, 0x2E,
-    0x21, 0xA1, 0xFC, 0x22, 0x61, 0xC3, 0xF3, 0xFD, 0x42, 0xA9, 0xB3, 0xF8, 0x05, 0xF8, 0x05, 0x48, 0x72, 0x61, 0x73,
-    0x6D, 0x65, 0xC3, 0x64, 0x66, 0xF7, 0xFE, 0xF7, 0xFE, 0xF7, 0xFE, 0xFF, 0x16, 0xF7, 0xFE, 0xFF, 0xF9, 0xF7, 0xFE,
-    0xF9, 0x7B, 0xC1, 0x05, 0x81, 0x72, 0xF7, 0xE5, 0x42, 0xAD, 0xA1, 0xFF, 0xFA, 0xF7, 0xDF, 0x43, 0x69, 0xC3, 0x74,
-    0xFF, 0xDA, 0xFF, 0xF9, 0xF9, 0x55, 0x41, 0xA1, 0xF9, 0x4E, 0x42, 0x61, 0xC3, 0xF9, 0x4A, 0xFF, 0xFC, 0x41, 0x7A,
-    0xF9, 0x40, 0x21, 0xAD, 0xFC, 0x22, 0x69, 0xC3, 0xF9, 0xFD, 0x21, 0x6C, 0xFB, 0x21, 0x69, 0xFD, 0xC5, 0x07, 0x62,
-    0x62, 0x6D, 0x6E, 0x73, 0x74, 0xFF, 0x95, 0xFF, 0xA7, 0xFF, 0xD9, 0xFF, 0xE7, 0xFF, 0xFD, 0x43, 0x61, 0x65, 0x6F,
-    0xF9, 0x1C, 0xF9, 0x1C, 0xF9, 0x1C, 0xC2, 0x07, 0x82, 0x62, 0x6D, 0xF9, 0x15, 0xFF, 0xF6, 0x45, 0xA1, 0xA9, 0xAD,
-    0xB3, 0xBA, 0xFF, 0xF7, 0xF9, 0xF0, 0xF9, 0xF0, 0xF9, 0xF0, 0xF9, 0xF0, 0x46, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3,
-    0xFE, 0xBD, 0xFE, 0xEA, 0xFF, 0x13, 0xFF, 0x2F, 0xFF, 0xCB, 0xFF, 0xF0, 0xA1, 0x00, 0x61, 0x65, 0xED, 0x43, 0x6E,
-    0x72, 0x73, 0xFE, 0xD2, 0xF8, 0xE1, 0xF8, 0xE1, 0xA0, 0x0C, 0x12, 0xA1, 0x0C, 0x12, 0x72, 0xFD, 0x21, 0x6E, 0xF8,
-    0x21, 0xB3, 0xFD, 0x23, 0x61, 0x6F, 0xC3, 0xF2, 0xF5, 0xFD, 0x41, 0x70, 0xF7, 0x45, 0x41, 0x6E, 0xF7, 0x41, 0x21,
-    0x65, 0xFC, 0x21, 0x64, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x22, 0x73, 0x74, 0xEC, 0xFD, 0x41, 0xA9, 0xF8,
-    0xBA, 0x21, 0x65, 0xD6, 0x21, 0x69, 0xFD, 0xC7, 0x0F, 0x93, 0x65, 0x6C, 0x64, 0x6E, 0x72, 0xC3, 0x6D, 0xFF, 0xBE,
-    0xF9, 0x7B, 0xFF, 0xD6, 0xFF, 0xF1, 0xF8, 0x9F, 0xFF, 0xF6, 0xFF, 0xFD, 0x41, 0xA1, 0xFC, 0xEB, 0x21, 0xC3, 0xFC,
-    0x42, 0x70, 0x74, 0xF8, 0xA9, 0xF7, 0x03, 0x22, 0x75, 0x65, 0xF6, 0xF9, 0x41, 0xA1, 0xF8, 0x74, 0x44, 0x61, 0xC3,
-    0x65, 0x6F, 0xF8, 0x70, 0xFF, 0xFC, 0xF8, 0x70, 0xF8, 0x70, 0x21, 0x74, 0xF3, 0x41, 0x65, 0xF6, 0xE3, 0x21, 0x75,
-    0xFC, 0x21, 0x6C, 0xFD, 0x41, 0x61, 0xFA, 0xF6, 0x41, 0x6E, 0xFC, 0xB6, 0x21, 0x65, 0xFC, 0x21, 0x6D, 0xFD, 0x41,
-    0x65, 0xF8, 0x4B, 0x23, 0x63, 0x69, 0x74, 0xEE, 0xF9, 0xFC, 0x41, 0x69, 0xF8, 0x66, 0x21, 0x6D, 0xFC, 0x21, 0xB3,
-    0xFD, 0x21, 0xC3, 0xFD, 0xC6, 0x0F, 0x93, 0x63, 0x73, 0x66, 0x6C, 0x72, 0x74, 0xFF, 0xB7, 0xFF, 0xCD, 0xFF, 0xD7,
-    0xFF, 0xEC, 0xFB, 0x06, 0xFF, 0xFD, 0x41, 0x75, 0xFC, 0x7F, 0x21, 0x63, 0xFC, 0x21, 0x65, 0xFD, 0x41, 0x6D, 0xFF,
-    0x57, 0x21, 0x65, 0xFC, 0x21, 0x6C, 0xAA, 0x21, 0x70, 0xFD, 0x41, 0x74, 0xFF, 0x4A, 0x41, 0x65, 0xF8, 0x29, 0x41,
-    0x6D, 0xF6, 0x7F, 0x21, 0xAD, 0xFC, 0x41, 0x75, 0xF8, 0x1E, 0x44, 0x61, 0x69, 0xC3, 0x72, 0xF8, 0x1A, 0xFF, 0xF5,
-    0xFF, 0xF9, 0xFF, 0xFC, 0x22, 0x70, 0x74, 0xE4, 0xF3, 0xA5, 0x0F, 0x93, 0x6A, 0x6C, 0x6D, 0x6E, 0x73, 0xCB, 0xD2,
-    0xD8, 0xDB, 0xFB, 0x41, 0x69, 0xFC, 0x36, 0x21, 0x70, 0xFC, 0x21, 0x69, 0xFD, 0x21, 0x63, 0xFD, 0x41, 0x63, 0xFA,
-    0x65, 0x21, 0x69, 0xFC, 0x41, 0xAD, 0xF7, 0xCF, 0x42, 0x69, 0xC3, 0xF7, 0xCB, 0xFF, 0xFC, 0x21, 0x64, 0xF9, 0xA3,
-    0x0F, 0x93, 0x63, 0x66, 0x72, 0xE8, 0xEF, 0xFD, 0x41, 0x62, 0xFA, 0xEF, 0xA1, 0x0F, 0x93, 0x72, 0xFC, 0x42, 0xA9,
-    0xB3, 0xF7, 0x9E, 0xF7, 0x9E, 0x42, 0x61, 0xC3, 0xF7, 0x97, 0xFF, 0xF9, 0x21, 0x74, 0xF9, 0x41, 0x74, 0xFF, 0x50,
-    0xA2, 0x0F, 0xC3, 0x73, 0x72, 0xF9, 0xFC, 0xA0, 0x0F, 0xC3, 0xC3, 0x0F, 0xC3, 0x6E, 0x6D, 0x72, 0xFD, 0x8F, 0xFA,
-    0x1F, 0xF7, 0x7F, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xEA, 0xF1, 0xF4, 0xF1, 0xF1, 0x41, 0x79, 0xF8, 0x11, 0x21,
-    0x61, 0xFC, 0x48, 0x69, 0x68, 0x61, 0x65, 0x6F, 0x75, 0xC3, 0x72, 0xFE, 0xC2, 0xF8, 0x91, 0xFF, 0x31, 0xFF, 0x82,
-    0xFF, 0xB1, 0xFF, 0xBE, 0xFF, 0xEE, 0xFF, 0xFD, 0x41, 0x74, 0xF8, 0x78, 0x21, 0x73, 0xFC, 0x41, 0x73, 0xF8, 0x71,
-    0x21, 0x65, 0xFC, 0x22, 0x65, 0x6F, 0xF6, 0xFD, 0x22, 0x62, 0x72, 0xD4, 0xFB, 0x41, 0x73, 0xFD, 0x21, 0x21, 0x61,
-    0xFC, 0x41, 0x61, 0xFD, 0x39, 0x21, 0x72, 0xFC, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x62,
-    0xFD, 0xA3, 0x00, 0x61, 0x75, 0x6F, 0x65, 0xE1, 0xEA, 0xFD, 0x41, 0x70, 0xF6, 0x09, 0x21, 0x6D, 0xFC, 0x41, 0x6A,
-    0xF6, 0x02, 0xA0, 0x05, 0x52, 0x21, 0x74, 0xFD, 0x21, 0xB3, 0xFD, 0x21, 0xC3, 0xFD, 0x22, 0x62, 0x6C, 0xF0, 0xFD,
-    0x22, 0x69, 0x6F, 0xE8, 0xFB, 0x21, 0x65, 0xFB, 0x21, 0x6C, 0xFD, 0xC1, 0x0E, 0xB2, 0x67, 0xF9, 0x8A, 0x41, 0x67,
-    0xF5, 0x63, 0xA1, 0x0E, 0xB2, 0x65, 0xFC, 0x41, 0xB1, 0xF9, 0x7B, 0xA1, 0x0E, 0xB2, 0xC3, 0xFC, 0x43, 0xA1, 0xA9,
-    0xB3, 0xF5, 0x51, 0xF5, 0x51, 0xF5, 0x51, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xF5, 0x47, 0xFF, 0xF6, 0xF5, 0x47, 0xF5,
-    0x47, 0x21, 0x74, 0xF3, 0xC2, 0x0E, 0xB2, 0x64, 0x6E, 0xFA, 0x38, 0xFF, 0xFD, 0xA0, 0x10, 0xD2, 0x25, 0xA1, 0xA9,
-    0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xF9, 0x3A, 0xFB,
-    0x1F, 0xFF, 0xB7, 0xFF, 0xC1, 0xFF, 0xCA, 0xFF, 0xE9, 0xFF, 0xF5, 0x21, 0x73, 0xEA, 0x41, 0x78, 0xF8, 0x7E, 0x21,
-    0xB3, 0xFC, 0x21, 0xC3, 0xFD, 0x22, 0x61, 0x69, 0xF3, 0xFD, 0xC2, 0x00, 0x61, 0x65, 0x72, 0xFF, 0x8C, 0xFF, 0xFB,
-    0x42, 0x61, 0x6F, 0xF6, 0x48, 0xF6, 0x48, 0x21, 0x65, 0xF9, 0x21, 0x6D, 0xFD, 0x41, 0x65, 0xF6, 0x3B, 0x21, 0x65,
-    0xFC, 0x21, 0x6D, 0xFD, 0x22, 0x75, 0x65, 0xF3, 0xFD, 0x41, 0x65, 0xF5, 0x60, 0x21, 0x72, 0xFC, 0x41, 0x6F, 0xF5,
-    0x59, 0x21, 0x72, 0xFC, 0x41, 0x72, 0xFB, 0x39, 0x21, 0x67, 0xFC, 0x21, 0x69, 0xFD, 0x21, 0x70, 0xFD, 0x41, 0x68,
-    0xFB, 0x2C, 0x21, 0x6F, 0xFC, 0x21, 0x63, 0xFD, 0x41, 0x69, 0xF6, 0x72, 0x21, 0x6E, 0xFC, 0x41, 0x72, 0xF6, 0x6B,
-    0x23, 0x6C, 0x6D, 0x65, 0xF2, 0xF9, 0xFC, 0x41, 0xB3, 0xFC, 0x0A, 0x42, 0x6F, 0xC3, 0xFC, 0x06, 0xFF, 0xFC, 0x21,
-    0x73, 0xF9, 0xA0, 0x05, 0x22, 0x21, 0x65, 0xFD, 0x42, 0x6A, 0x6E, 0xFF, 0xFD, 0xF9, 0x78, 0x21, 0x6F, 0xF9, 0x42,
-    0x65, 0x69, 0xFF, 0xFD, 0xF5, 0x0B, 0x24, 0x65, 0x61, 0x69, 0x74, 0xBC, 0xD4, 0xE6, 0xF9, 0x41, 0x74, 0xFF, 0xA2,
-    0xC4, 0x02, 0xB1, 0x62, 0x63, 0x6E, 0x74, 0xFF, 0x9B, 0xFF, 0xA2, 0xFF, 0xF3, 0xFF, 0xFC, 0x41, 0x74, 0xF6, 0xD3,
-    0x21, 0x73, 0xFC, 0xA1, 0x01, 0x82, 0x65, 0xFD, 0x42, 0x6F, 0xC3, 0xF8, 0xA2, 0xFA, 0x85, 0x41, 0x69, 0xF5, 0xE2,
-    0x21, 0x65, 0xFC, 0x41, 0xA9, 0xFD, 0x00, 0x42, 0x65, 0xC3, 0xFC, 0xFC, 0xFF, 0xFC, 0x41, 0x62, 0xF5, 0xB3, 0xA4,
-    0x09, 0xA3, 0x6D, 0x63, 0x6A, 0x72, 0xE3, 0xEE, 0xF5, 0xFC, 0x41, 0xAD, 0xFA, 0xC6, 0x42, 0x69, 0xC3, 0xFA, 0xC2,
-    0xFF, 0xFC, 0xA1, 0x09, 0xA3, 0x6D, 0xF9, 0xA0, 0x09, 0xA3, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xFC, 0x2F, 0xFE, 0xC3,
-    0xF4, 0x14, 0xF4, 0x14, 0xA1, 0x09, 0xA3, 0x6A, 0xF3, 0x43, 0x61, 0xC3, 0x65, 0xF4, 0x02, 0xF5, 0xF7, 0xF4, 0x02,
-    0x21, 0x72, 0xF6, 0x21, 0x65, 0xFD, 0xA1, 0x09, 0xA3, 0x6D, 0xFD, 0xA0, 0x09, 0xD3, 0xC1, 0x09, 0xD3, 0x6A, 0xF6,
-    0x40, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xF7, 0xF7, 0xF7, 0xFA, 0xF7, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75,
-    0xC3, 0xFF, 0x85, 0xFF, 0xA7, 0xFF, 0xBD, 0xFF, 0xC2, 0xFF, 0xD2, 0xFF, 0xE7, 0xFF, 0xF5, 0x41, 0x73, 0xF6, 0x3B,
-    0x42, 0x6C, 0x75, 0xF6, 0x37, 0xFF, 0xFC, 0x41, 0x6C, 0xF6, 0x30, 0x41, 0x72, 0xFF, 0x59, 0x41, 0x6D, 0xF6, 0x28,
-    0x44, 0xA1, 0xAD, 0xB3, 0xBA, 0xFF, 0xF4, 0xF6, 0x27, 0xFF, 0xF8, 0xFF, 0xFC, 0xC5, 0x01, 0x82, 0x61, 0xC3, 0x69,
-    0x6F, 0x75, 0xFF, 0xE0, 0xFF, 0xF3, 0xF6, 0x1A, 0xFF, 0xEB, 0xFF, 0xEF, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF,
-    0xA0, 0xFF, 0xA0, 0xFF, 0xA0, 0xFF, 0xA0, 0xFF, 0xA0, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xFF, 0xDE,
-    0xFF, 0x66, 0xFF, 0x66, 0xFF, 0x66, 0xFF, 0x66, 0xFF, 0x66, 0xFF, 0xF0, 0x42, 0x6E, 0x78, 0xFF, 0x8E, 0xFF, 0xEA,
-    0xA0, 0x01, 0x82, 0x41, 0x72, 0xF5, 0x3F, 0x41, 0x72, 0xF5, 0x0B, 0x22, 0x61, 0x6F, 0xF8, 0xFC, 0x42, 0x6E, 0x70,
-    0xF4, 0xEA, 0xF4, 0xEA, 0x21, 0x65, 0xF9, 0x41, 0x70, 0xF4, 0xE0, 0x22, 0x61, 0x6F, 0xFC, 0xFC, 0x41, 0x61, 0xFA,
-    0xE0, 0x21, 0x75, 0xFC, 0x41, 0x6D, 0xFF, 0x00, 0x21, 0xA1, 0xFC, 0x41, 0x65, 0xF4, 0xBD, 0x22, 0xC3, 0x69, 0xF9,
-    0xFC, 0x41, 0x69, 0xFB, 0x63, 0x21, 0x6C, 0xFC, 0x42, 0x6D, 0x63, 0xF4, 0x9C, 0xF3, 0x1F, 0x22, 0x61, 0x69, 0xF6,
-    0xF9, 0x41, 0x61, 0xFE, 0xDD, 0x21, 0x67, 0xFC, 0x41, 0x6C, 0xF4, 0x89, 0x42, 0x61, 0x69, 0xFB, 0x45, 0xF4, 0xEA,
-    0x43, 0x63, 0x68, 0x6E, 0xF4, 0xEC, 0xFF, 0xD2, 0xF4, 0xFD, 0x21, 0x65, 0xF6, 0x24, 0x61, 0x65, 0x6C, 0x72, 0xE5,
-    0xE8, 0xEC, 0xFD, 0x41, 0x63, 0xF4, 0x85, 0x21, 0x65, 0xFC, 0x41, 0xB3, 0xF4, 0x72, 0x21, 0xC3, 0xFC, 0x41, 0x67,
-    0xF4, 0x5A, 0x21, 0x75, 0xFC, 0x22, 0x6D, 0x72, 0xF6, 0xFD, 0x41, 0x69, 0xF4, 0x6E, 0x41, 0x62, 0xF2, 0xCD, 0x21,
-    0x69, 0xFC, 0x21, 0x76, 0xFD, 0x21, 0x6F, 0xFD, 0xCC, 0x09, 0xA3, 0x62, 0x63, 0x64, 0x67, 0x6C, 0x6E, 0x70, 0x66,
-    0x72, 0x73, 0x74, 0x6D, 0xFF, 0x6B, 0xFF, 0x77, 0xFF, 0x7E, 0xFF, 0x87, 0xFF, 0x95, 0xFF, 0xA8, 0xFF, 0xCC, 0xFF,
-    0xD9, 0xFF, 0xEA, 0xFF, 0xEF, 0xFA, 0x67, 0xFF, 0xFD, 0xC1, 0x02, 0x91, 0x69, 0xF4, 0x16, 0x21, 0x63, 0xFA, 0x21,
-    0x69, 0xFD, 0x41, 0x64, 0xF4, 0x78, 0x22, 0x75, 0x65, 0xFC, 0xAC, 0x41, 0x6F, 0xFA, 0x27, 0x42, 0x63, 0x61, 0xFF,
-    0xFC, 0xF8, 0x70, 0x41, 0x76, 0xF2, 0x79, 0x21, 0xAD, 0xFC, 0x42, 0x69, 0xC3, 0xF4, 0x24, 0xFF, 0xFD, 0x21, 0x75,
-    0xF9, 0xC2, 0x02, 0x91, 0x61, 0x68, 0xFF, 0x7D, 0xFA, 0x12, 0xC6, 0x09, 0xA3, 0x66, 0x6C, 0x6E, 0x71, 0x78, 0x76,
-    0xFF, 0xCF, 0xFF, 0xD6, 0xFF, 0xDF, 0xFF, 0xF4, 0xFF, 0xF7, 0xFE, 0x17, 0x42, 0x6F, 0x61, 0xF2, 0x4A, 0xF2, 0x4A,
-    0x21, 0x75, 0xF9, 0x41, 0x6C, 0xFF, 0x2D, 0x21, 0x61, 0xFC, 0x21, 0x75, 0xFD, 0xC3, 0x09, 0xA3, 0x63, 0x67, 0x6E,
-    0xFF, 0xF3, 0xFF, 0xFD, 0xF3, 0xB3, 0x41, 0x73, 0xFB, 0x5F, 0x44, 0x74, 0x61, 0xC3, 0x65, 0xF3, 0xA3, 0xF2, 0x26,
-    0xF4, 0x1B, 0xF2, 0x26, 0x43, 0x6F, 0x61, 0x6C, 0xF2, 0x19, 0xF2, 0x19, 0xFF, 0xF3, 0x42, 0x63, 0x74, 0xF2, 0x0F,
-    0xF2, 0x0F, 0x21, 0x6E, 0xF9, 0x22, 0x75, 0x65, 0xEC, 0xFD, 0x41, 0x73, 0xF2, 0x00, 0x21, 0x6E, 0xFC, 0x21, 0x65,
-    0xFD, 0x41, 0x6F, 0xF8, 0x25, 0xA4, 0x09, 0xA3, 0x62, 0x63, 0x66, 0x70, 0xC8, 0xED, 0xF9, 0xFC, 0x41, 0x7A, 0xF1,
-    0xE7, 0x21, 0x69, 0xFC, 0x21, 0x6C, 0xFD, 0x21, 0x69, 0xFD, 0xA1, 0x09, 0xA3, 0x74, 0xFD, 0x41, 0x6D, 0xF4, 0x2B,
-    0x21, 0x69, 0xFC, 0xA1, 0x09, 0xD3, 0x6E, 0xFD, 0x41, 0x74, 0xF4, 0x1F, 0x21, 0x69, 0xFC, 0xA1, 0x09, 0xD3, 0x64,
-    0xFD, 0x41, 0x69, 0xF4, 0x16, 0xA1, 0x09, 0xD3, 0x74, 0xFC, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF, 0xE6, 0xFF,
-    0xF2, 0xFD, 0xC7, 0xFD, 0xC7, 0xFF, 0xFB, 0xA0, 0x0C, 0x13, 0x21, 0x67, 0xFD, 0x22, 0x63, 0x74, 0xFA, 0xFA, 0x21,
-    0x70, 0xF5, 0x22, 0x70, 0x6D, 0xF8, 0xFD, 0xA2, 0x05, 0x22, 0x6F, 0x75, 0xF0, 0xFB, 0xA0, 0x0A, 0x92, 0xA0, 0x0A,
-    0xB3, 0xA0, 0x0B, 0x13, 0x23, 0xA1, 0xA9, 0xB3, 0xFD, 0xFD, 0xFD, 0x24, 0x61, 0x65, 0x6F, 0xC3, 0xF6, 0xF6, 0xF6,
-    0xF9, 0xA1, 0x0A, 0xB3, 0x73, 0xF7, 0xA0, 0x0A, 0xE3, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD,
-    0xFD, 0x28, 0x72, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xCD, 0xD4, 0xD7, 0xED, 0xD7, 0xD7, 0xD7, 0xF5, 0x21,
-    0x72, 0xEF, 0x21, 0x65, 0xFD, 0x48, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0x74, 0xFD, 0xE7, 0xFE, 0x87, 0xFE,
-    0xE8, 0xFF, 0x11, 0xFF, 0x55, 0xFF, 0x6D, 0xFF, 0x93, 0xFF, 0xFD, 0x21, 0x6E, 0xE7, 0x58, 0x62, 0x63, 0x64, 0x66,
-    0x67, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x68, 0x61, 0x65,
-    0x69, 0xF2, 0x79, 0xF3, 0xD1, 0xF4, 0x53, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4, 0xC4,
-    0xF4, 0x5A, 0xF7, 0x4E, 0xF4, 0x5A, 0xF9, 0xC2, 0xFB, 0x92, 0xFC, 0x33, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4, 0x5A, 0xF4,
-    0x5A, 0xF4, 0x5A, 0xFC, 0x53, 0xFC, 0xC1, 0xFD, 0xC4, 0xFF, 0xFD, 0x41, 0x63, 0xFC, 0x16, 0xA0, 0x0D, 0x22, 0x21,
-    0x72, 0xFD, 0x21, 0x6F, 0xFD, 0xC3, 0x00, 0x71, 0x2E, 0x69, 0x65, 0xF0, 0x3F, 0xFF, 0xF3, 0xFF, 0xFD, 0xC3, 0x00,
-    0x71, 0x2E, 0x7A, 0x73, 0xF0, 0x33, 0xF0, 0x39, 0xF0, 0x39, 0xC1, 0x00, 0x71, 0x2E, 0xF0, 0x27, 0xD6, 0x00, 0x81,
-    0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77,
-    0x78, 0x79, 0x7A, 0xF0, 0x21, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24,
-    0xF0, 0x24, 0xF3, 0xE6, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF3, 0xE6, 0xF0, 0x24, 0xF0, 0x24, 0xF0,
-    0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0xF0, 0x24, 0x41, 0x74, 0xF0, 0x69, 0x21, 0x70, 0xFC, 0xD7, 0x00, 0x91,
-    0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77,
-    0x78, 0x79, 0x7A, 0x65, 0xEF, 0xD5, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0,
-    0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01,
-    0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xFF, 0xFD, 0x42, 0x6F, 0x70, 0xF3, 0xA8, 0xFF, 0xB1,
-    0x41, 0x6E, 0xFB, 0x50, 0xD8, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
-    0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x69, 0x6F, 0xEF, 0x82, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF,
-    0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE,
-    0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xEF, 0xAE, 0xFF,
-    0xF5, 0xFF, 0xFC, 0x41, 0x74, 0xF1, 0xF3, 0x21, 0x70, 0xFC, 0x41, 0x6F, 0xFC, 0x90, 0x21, 0x6C, 0xFC, 0x41, 0x74,
-    0xF0, 0x5B, 0x41, 0x6D, 0xFA, 0xEF, 0x41, 0x61, 0xEF, 0x9F, 0x21, 0x72, 0xFC, 0x21, 0x74, 0xFD, 0x25, 0x6D, 0x75,
-    0x72, 0x73, 0x6E, 0xE4, 0xEB, 0xEE, 0xF2, 0xFD, 0xA0, 0x02, 0x32, 0x21, 0x61, 0xFD, 0x41, 0x2E, 0xEF, 0x06, 0xA1,
-    0x02, 0x32, 0x73, 0xFC, 0x22, 0x6F, 0x61, 0xF1, 0xFB, 0x41, 0x64, 0xEF, 0x88, 0x23, 0x63, 0x67, 0x72, 0xEB, 0xF7,
-    0xFC, 0x21, 0x6F, 0xE1, 0x41, 0x75, 0xEF, 0x68, 0x21, 0x72, 0xFC, 0x42, 0x64, 0x73, 0xFF, 0xFD, 0xF2, 0xE9, 0x22,
-    0x6C, 0x61, 0xEF, 0xF9, 0x41, 0x6C, 0xEF, 0x64, 0x21, 0x61, 0xFC, 0xA0, 0x07, 0x51, 0x21, 0x61, 0xFD, 0x21, 0x65,
-    0xFD, 0xA1, 0x04, 0x72, 0x72, 0xFD, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF, 0xFB, 0xEF, 0xD7, 0xEF, 0xD7, 0xEF,
-    0xD7, 0xEF, 0xD7, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xEF, 0xC1, 0xEF, 0xC4, 0xEF, 0xC4, 0xEF, 0xC4,
-    0xEF, 0xC4, 0xEF, 0xC4, 0xFF, 0xF0, 0x21, 0x69, 0xEA, 0x21, 0x74, 0xFD, 0x22, 0x66, 0x6E, 0xC3, 0xFD, 0x42, 0x68,
-    0x6F, 0xF2, 0x5F, 0xEF, 0xB4, 0x21, 0x6E, 0xF9, 0xA0, 0x06, 0xF3, 0xA0, 0x07, 0x23, 0x25, 0xA1, 0xA9, 0xAD, 0xB3,
-    0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x48, 0x72, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xF3, 0x4F, 0xF3, 0x26,
-    0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xEF, 0xFF, 0xF5, 0x21, 0x72, 0xE7, 0x21, 0x65, 0xFD, 0x41,
-    0x6C, 0xFA, 0x21, 0x41, 0x6F, 0xF2, 0x6E, 0x24, 0x61, 0x62, 0x63, 0x74, 0xC5, 0xF5, 0xF8, 0xFC, 0x41, 0x6F, 0xEF,
-    0x25, 0x21, 0x63, 0xFC, 0x21, 0x69, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0xA9, 0xFD,
-    0xDC, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77,
-    0x78, 0x79, 0x7A, 0x68, 0x6C, 0x72, 0x6F, 0x61, 0x75, 0x65, 0x69, 0xC3, 0xEE, 0x30, 0xEE, 0x33, 0xEE, 0x39, 0xEE,
-    0x33, 0xEE, 0x42, 0xEE, 0x47, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x47, 0xFD, 0xF1, 0xEE, 0x4C, 0xEE, 0x33, 0xEE, 0x33,
-    0xFD, 0xFD, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xFE, 0x09, 0xFE, 0x0F, 0xFE, 0x5B, 0xFE, 0xAE, 0xFF,
-    0x19, 0xFF, 0x3C, 0xFF, 0x54, 0xFF, 0x9A, 0xFF, 0xE1, 0xFF, 0xFD, 0x41, 0x74, 0xF2, 0xB2, 0x21, 0x6E, 0xFC, 0x21,
-    0x65, 0xFD, 0x21, 0x69, 0xFD, 0xA1, 0x04, 0xA2, 0x6D, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xF1,
-    0x95, 0xF1, 0xD1, 0xF1, 0xD1, 0xFF, 0xFB, 0xF1, 0xD1, 0xF1, 0xD1, 0xF1, 0xD7, 0x21, 0x61, 0xEA, 0xA0, 0x07, 0xC1,
-    0xA0, 0x07, 0xD2, 0xA0, 0x07, 0xF2, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFD, 0xFD, 0xFD, 0xFD, 0xFD, 0x27, 0x68,
-    0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xEC, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xF5, 0x21, 0x6F, 0xF1, 0x21, 0x74, 0xFD,
-    0x42, 0x61, 0x6F, 0xFF, 0xFD, 0xEE, 0xA8, 0x21, 0x6D, 0xF9, 0xA0, 0x05, 0x92, 0x21, 0x65, 0xFD, 0x21, 0x64, 0xFD,
-    0xA0, 0x09, 0x32, 0x21, 0x61, 0xFD, 0x22, 0x72, 0x6C, 0xF7, 0xFD, 0xA0, 0x02, 0x12, 0x21, 0x69, 0xFD, 0x21, 0x63,
-    0xFD, 0x21, 0x75, 0xFD, 0x41, 0x61, 0xEF, 0x4A, 0x22, 0x68, 0x6C, 0xF9, 0xFC, 0x22, 0x61, 0x65, 0xE0, 0xE0, 0x21,
-    0x68, 0xFB, 0x21, 0x74, 0xE3, 0x22, 0x63, 0x72, 0xFA, 0xFD, 0x23, 0xB3, 0xA1, 0xA9, 0xD6, 0xEB, 0xFB, 0x21, 0x6A,
-    0xC0, 0x21, 0x6C, 0xBD, 0x21, 0x74, 0xBA, 0x21, 0x6E, 0xFD, 0x22, 0x6C, 0x65, 0xF7, 0xFD, 0xA0, 0x02, 0x11, 0x21,
-    0x6A, 0xFD, 0x21, 0x69, 0xFD, 0x41, 0x69, 0xFF, 0xA6, 0x21, 0x6E, 0xFC, 0x21, 0x61, 0xFD, 0x41, 0x6D, 0xFF, 0x9C,
-    0x21, 0x61, 0xFC, 0x46, 0x64, 0x65, 0x69, 0x74, 0x67, 0x6E, 0xFF, 0x98, 0xFF, 0xD5, 0xFF, 0xE1, 0xFF, 0xEC, 0xFF,
-    0xF6, 0xFF, 0xFD, 0x42, 0x63, 0x7A, 0xFF, 0x82, 0xFF, 0x82, 0x41, 0x6E, 0xFF, 0x7B, 0x21, 0x65, 0xFC, 0x22, 0x65,
-    0x69, 0xF2, 0xFD, 0x21, 0x64, 0xFB, 0x41, 0x67, 0xFF, 0x6C, 0x21, 0x69, 0xFC, 0x41, 0x72, 0xFF, 0x65, 0x21, 0x74,
-    0xFC, 0x23, 0x65, 0x6C, 0x73, 0xEF, 0xF6, 0xFD, 0xA0, 0x09, 0x12, 0x21, 0x73, 0xFD, 0x41, 0x70, 0xFF, 0x51, 0x21,
-    0xBA, 0xFC, 0x23, 0x61, 0x75, 0xC3, 0xF6, 0xF9, 0xFD, 0x21, 0x6F, 0xDE, 0xC2, 0x09, 0x12, 0x63, 0x64, 0xFF, 0x91,
-    0xFF, 0x91, 0x23, 0xA1, 0xA9, 0xB3, 0xE0, 0xE0, 0xE0, 0x45, 0x61, 0xC3, 0x65, 0x6F, 0x6C, 0xFF, 0xF0, 0xFF, 0xF9,
-    0xFF, 0xD9, 0xFF, 0xD9, 0xFF, 0x81, 0x41, 0x69, 0xFF, 0x84, 0x21, 0x72, 0xFC, 0x41, 0x65, 0xFF, 0x6A, 0x21, 0x63,
-    0xFC, 0x42, 0xA1, 0xA9, 0xFF, 0x12, 0xFF, 0x12, 0x43, 0x61, 0xC3, 0x69, 0xFF, 0x0B, 0xFF, 0xF9, 0xFF, 0x0B, 0x41,
-    0xA9, 0xFF, 0x01, 0x42, 0x65, 0xC3, 0xFE, 0xFD, 0xFF, 0xFC, 0x41, 0x67, 0xFF, 0x0A, 0x21, 0x65, 0xFC, 0x4B, 0x72,
-    0x62, 0x63, 0x64, 0x6C, 0x70, 0x6E, 0x76, 0x78, 0x79, 0x73, 0xFF, 0x5A, 0xFF, 0x91, 0xFF, 0xA5, 0xFF, 0xAC, 0xFF,
-    0xBF, 0xFF, 0xD3, 0xFF, 0xDA, 0xFF, 0xE4, 0xFF, 0x49, 0xFF, 0xF2, 0xFF, 0xFD, 0xA0, 0x08, 0xC3, 0x21, 0x64, 0xFD,
-    0x21, 0x69, 0xFD, 0x21, 0x72, 0xF7, 0x22, 0x72, 0x6F, 0xFA, 0xFD, 0x22, 0x7A, 0x63, 0xEF, 0xEF, 0x21, 0x69, 0xFB,
-    0x21, 0x6C, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x72, 0xFD, 0x23, 0xA1, 0xA9, 0xB3, 0xDE, 0xDE, 0xDE, 0x22, 0x61, 0xC3,
-    0xD7, 0xF9, 0x23, 0x61, 0x65, 0x6F, 0xD2, 0xD2, 0xD2, 0x21, 0xAD, 0xF9, 0x22, 0x69, 0xC3, 0xF1, 0xFD, 0xA0, 0x08,
-    0xF2, 0x21, 0x73, 0xC0, 0x22, 0x61, 0x69, 0xFA, 0xFD, 0x21, 0x75, 0xFB, 0x21, 0xAD, 0xC6, 0x22, 0x69, 0xC3, 0xC3,
-    0xFD, 0x42, 0x76, 0x6E, 0xFF, 0xAD, 0xFF, 0xFB, 0x42, 0x61, 0x69, 0xED, 0xDD, 0xFF, 0xF9, 0x41, 0x6C, 0xFE, 0x80,
-    0x42, 0x72, 0x65, 0xFE, 0x7C, 0xFF, 0xFC, 0x21, 0x67, 0xF9, 0x41, 0x76, 0xFF, 0x91, 0x21, 0x69, 0xFC, 0x21, 0x73,
-    0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x72, 0xFD, 0x41, 0x6C, 0xFF, 0x7E, 0x21, 0x6C, 0xFC, 0x21, 0x6F,
-    0xFD, 0x21, 0x72, 0xFD, 0x41, 0x72, 0xFE, 0x52, 0x43, 0x61, 0x65, 0x74, 0xF1, 0xB9, 0xF1, 0xB9, 0xFF, 0xFC, 0x41,
-    0x73, 0xFF, 0xA0, 0x21, 0x65, 0xFC, 0x41, 0x6E, 0xFF, 0x5C, 0x21, 0x75, 0xFC, 0x21, 0xB3, 0xF9, 0x22, 0xC3, 0x6F,
-    0xFD, 0xF6, 0x4D, 0x62, 0x63, 0x66, 0x67, 0x68, 0x6C, 0x6E, 0x70, 0x72, 0x73, 0x74, 0x79, 0x7A, 0xFF, 0x59, 0xFF,
-    0x6C, 0xFF, 0x85, 0xFF, 0x95, 0xFE, 0x37, 0xFF, 0xA7, 0xFF, 0xB9, 0xFF, 0xCC, 0xFF, 0xD9, 0xFF, 0xE0, 0xFF, 0xEE,
-    0xFF, 0xF5, 0xFF, 0xFB, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xFF, 0x25, 0xFF, 0x47, 0xFF, 0x25, 0xFF, 0x25, 0x21, 0x6A,
-    0xF3, 0x41, 0x6A, 0xFF, 0x43, 0x21, 0xA9, 0xFC, 0x41, 0xB1, 0xFD, 0xEF, 0x21, 0xC3, 0xFC, 0x21, 0xA9, 0xFD, 0x22,
-    0x65, 0xC3, 0xFA, 0xFD, 0x23, 0x65, 0xC3, 0x70, 0xE7, 0xEE, 0xFB, 0x41, 0x6E, 0xFD, 0xD9, 0x21, 0xA9, 0xFC, 0x22,
-    0x65, 0xC3, 0xF9, 0xFD, 0x21, 0x72, 0xFB, 0x21, 0x66, 0xFD, 0xC6, 0x02, 0x11, 0x6E, 0x72, 0x62, 0x64, 0x6D, 0x73,
-    0xFE, 0x04, 0xFE, 0x04, 0xFE, 0x04, 0xFE, 0x04, 0xFE, 0x04, 0xFE, 0x04, 0x46, 0x6E, 0x72, 0x62, 0x64, 0x6D, 0x73,
-    0xFD, 0xEF, 0xFD, 0xEF, 0xFD, 0xEF, 0xFD, 0xEF, 0xFD, 0xEF, 0xFD, 0xEF, 0x21, 0xA1, 0xED, 0xC6, 0x09, 0x12, 0x6E,
-    0x72, 0x62, 0x64, 0x6D, 0x73, 0xFE, 0x31, 0xFE, 0x31, 0xFE, 0x31, 0xFE, 0x31, 0xFE, 0x31, 0xFE, 0x31, 0x42, 0xA1,
-    0xB3, 0xFF, 0xEB, 0xFE, 0x1C, 0x44, 0x61, 0xC3, 0x65, 0x6F, 0xFE, 0x15, 0xFE, 0x35, 0xFE, 0x15, 0xFE, 0x15, 0x44,
-    0x6F, 0x61, 0xC3, 0x68, 0xFE, 0x08, 0xFF, 0xD7, 0xFF, 0xEC, 0xFF, 0xF3, 0x41, 0xA9, 0xFE, 0x85, 0x42, 0x65, 0xC3,
-    0xFE, 0x81, 0xFF, 0xFC, 0xA1, 0x05, 0x92, 0x75, 0xF9, 0x41, 0x66, 0xFD, 0x42, 0x42, 0x63, 0x71, 0xFD, 0x3E, 0xFD,
-    0x3E, 0x22, 0x69, 0x75, 0xF5, 0xF9, 0x41, 0x62, 0xFD, 0xCD, 0x21, 0x6D, 0xFC, 0x21, 0x6F, 0xFD, 0x41, 0x7A, 0xFD,
-    0x28, 0x42, 0x63, 0x6E, 0xFD, 0x75, 0xFF, 0xFC, 0x21, 0x61, 0xF9, 0x21, 0x72, 0xFD, 0x44, 0x61, 0x65, 0x69, 0x75,
-    0xFD, 0x17, 0xFF, 0xFD, 0xFD, 0x9C, 0xFD, 0x7B, 0x41, 0x69, 0xFD, 0x4D, 0x41, 0x69, 0xFD, 0x8B, 0x43, 0x62, 0x63,
-    0x6C, 0xFF, 0xF8, 0xFD, 0x5C, 0xFF, 0xFC, 0x41, 0x73, 0xFC, 0xF8, 0x41, 0x63, 0xFC, 0xF4, 0x22, 0x65, 0x75, 0xF8,
-    0xFC, 0x43, 0x61, 0x69, 0x72, 0xFF, 0xE9, 0xFD, 0x4F, 0xFF, 0xFB, 0x23, 0x63, 0x70, 0x74, 0xB6, 0xCA, 0xF6, 0x42,
-    0x63, 0x74, 0xFC, 0xF1, 0xFC, 0xEE, 0x4A, 0x6D, 0x6E, 0x6F, 0x61, 0xC3, 0x63, 0x71, 0x64, 0x73, 0x72, 0xFF, 0x07,
-    0xFF, 0x1D, 0xFD, 0x24, 0xFF, 0x20, 0xFF, 0x48, 0xFF, 0x74, 0xFF, 0x8C, 0xFF, 0x9C, 0xFF, 0xF2, 0xFF, 0xF9, 0x42,
-    0x72, 0x6F, 0xFD, 0x05, 0xFC, 0xF7, 0x42, 0x61, 0x6F, 0xFC, 0xFE, 0xFC, 0xFE, 0x22, 0x65, 0x69, 0xF2, 0xF9, 0x41,
-    0x74, 0xFC, 0xF2, 0x21, 0x72, 0xFC, 0x41, 0xA1, 0xFC, 0xDD, 0x42, 0x61, 0xC3, 0xFC, 0xD9, 0xFF, 0xFC, 0x42, 0x6E,
-    0x75, 0xFC, 0xE0, 0xFF, 0xF9, 0x41, 0xB3, 0xFD, 0x0D, 0x42, 0x6F, 0xC3, 0xFD, 0x09, 0xFF, 0xFC, 0x21, 0x69, 0xF9,
-    0x21, 0x73, 0xFD, 0x21, 0x75, 0xFD, 0x42, 0x67, 0x6E, 0xFF, 0x6E, 0xFC, 0x74, 0x41, 0x65, 0xFF, 0x75, 0x42, 0x6F,
-    0x72, 0xFC, 0xEE, 0xFF, 0xFC, 0x22, 0x61, 0x70, 0xEE, 0xF9, 0x41, 0x72, 0xFD, 0x0C, 0x41, 0x73, 0xFC, 0x9F, 0x21,
-    0x75, 0xFC, 0x44, 0x65, 0x6C, 0x6F, 0x72, 0xFC, 0x9B, 0xFF, 0x4C, 0xFF, 0xF5, 0xFF, 0xFD, 0x42, 0x63, 0x74, 0xFC,
-    0xEE, 0xFC, 0xEE, 0x21, 0x6E, 0xF9, 0x41, 0x63, 0xFC, 0x8C, 0x41, 0x72, 0xFC, 0x7D, 0xC1, 0x05, 0x92, 0x61, 0xFC,
-    0x97, 0x41, 0x72, 0xFC, 0x91, 0x24, 0x65, 0x61, 0x6C, 0x6F, 0xEE, 0xF2, 0xF6, 0xFC, 0x41, 0x62, 0xFC, 0x20, 0x21,
-    0x69, 0xFC, 0x41, 0x63, 0xFC, 0x5F, 0x41, 0x61, 0xFC, 0x58, 0x22, 0x65, 0x74, 0xF8, 0xFC, 0x42, 0x67, 0x72, 0xFD,
-    0xCE, 0xFC, 0x20, 0x41, 0x78, 0xFC, 0x05, 0x23, 0x65, 0x6F, 0x75, 0xF5, 0xFC, 0xE1, 0x41, 0x65, 0xFC, 0x95, 0x47,
-    0x63, 0x65, 0x66, 0x68, 0x73, 0x74, 0x76, 0xFF, 0xA4, 0xFF, 0xB8, 0xFF, 0xCD, 0xFF, 0xDA, 0xFF, 0xE5, 0xFF, 0xF5,
-    0xFF, 0xFC, 0x41, 0x6E, 0xFC, 0x31, 0x21, 0x65, 0xFC, 0x21, 0x74, 0xFD, 0x47, 0x64, 0x65, 0x67, 0x6C, 0x6D, 0x6E,
-    0x73, 0xFF, 0x30, 0xFF, 0x39, 0xFF, 0x47, 0xFF, 0x5F, 0xFF, 0x74, 0xFF, 0xE0, 0xFF, 0xFD, 0x43, 0x72, 0x73, 0x6E,
-    0xFC, 0x69, 0xFC, 0x69, 0xFC, 0x69, 0x21, 0x61, 0xF6, 0x41, 0x6C, 0xFC, 0x04, 0x21, 0x6C, 0xFC, 0x41, 0x61, 0xFD,
-    0xE7, 0x21, 0x74, 0xFC, 0xA0, 0x09, 0x53, 0x22, 0x63, 0x71, 0xFD, 0xFD, 0x22, 0x73, 0x69, 0xF5, 0xFB, 0xC1, 0x05,
-    0x92, 0x61, 0xFB, 0x98, 0x43, 0x6E, 0x72, 0x73, 0xFB, 0x92, 0xFF, 0xFA, 0xFB, 0x92, 0x43, 0x6E, 0x72, 0x73, 0xFB,
-    0x88, 0xFB, 0x88, 0xFB, 0x88, 0x42, 0xA9, 0xB3, 0xFF, 0xF6, 0xFB, 0x7E, 0x45, 0x72, 0x64, 0x65, 0xC3, 0x6D, 0xFB,
-    0x77, 0xFB, 0x77, 0xFF, 0xE5, 0xFF, 0xF9, 0xFB, 0x77, 0x42, 0x6E, 0x73, 0xFB, 0x67, 0xFB, 0x67, 0x42, 0xA1, 0xAD,
-    0xFB, 0x60, 0xFF, 0xC8, 0x45, 0x69, 0x61, 0x65, 0x6F, 0xC3, 0xFF, 0xE2, 0xFF, 0xF2, 0xFB, 0x59, 0xFB, 0x59, 0xFF,
-    0xF9, 0x41, 0xA1, 0xFB, 0x49, 0x42, 0x61, 0xC3, 0xFB, 0x45, 0xFF, 0xFC, 0x21, 0xB1, 0xF9, 0x41, 0x62, 0xFB, 0x9C,
-    0x47, 0x64, 0x65, 0x62, 0x73, 0x6E, 0xC3, 0x72, 0xFF, 0x81, 0xFF, 0x88, 0xFF, 0x9A, 0xFF, 0x8F, 0xFF, 0xDE, 0xFF,
-    0xF9, 0xFF, 0xFC, 0x46, 0xC3, 0x6F, 0x61, 0x65, 0x69, 0x75, 0xFB, 0x5A, 0xFC, 0x32, 0xFD, 0x07, 0xFE, 0x4E, 0xFF,
-    0x4B, 0xFF, 0xEA, 0x41, 0x69, 0xFB, 0x5F, 0x21, 0x74, 0xFC, 0x21, 0x73, 0xFD, 0x45, 0x63, 0x6E, 0x72, 0x73, 0x69,
-    0xFA, 0xCE, 0xF4, 0xA7, 0xFB, 0x01, 0xFF, 0xE3, 0xFF, 0xFD, 0xA0, 0x11, 0x72, 0x21, 0x63, 0xFD, 0x21, 0xA9, 0xFD,
-    0x22, 0x65, 0xC3, 0xFA, 0xFD, 0x21, 0x6C, 0xFB, 0x21, 0x65, 0xFD, 0xD8, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66,
-    0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x72, 0x65, 0x69,
-    0xE8, 0x5B, 0xE8, 0x5E, 0xE8, 0x64, 0xE8, 0x5E, 0xE8, 0x6D, 0xE8, 0x72, 0xE8, 0x5E, 0xE8, 0x5E, 0xE8, 0x5E, 0xE8,
-    0x5E, 0xE8, 0x72, 0xE8, 0x5E, 0xE8, 0x77, 0xE8, 0x5E, 0xE8, 0x5E, 0xE8, 0x80, 0xE8, 0x5E, 0xE8, 0x5E, 0xE8, 0x5E,
-    0xE8, 0x5E, 0xE8, 0x5E, 0xE8, 0x8A, 0xFF, 0xDC, 0xFF, 0xFD, 0x42, 0x6D, 0x72, 0xF4, 0x38, 0xF3, 0xDE, 0x41, 0x69,
-    0xF3, 0xD3, 0x43, 0x6C, 0x73, 0x74, 0xF9, 0xB2, 0xFF, 0xFC, 0xF9, 0xB2, 0x42, 0x6E, 0x74, 0xF9, 0xA8, 0xF9, 0xA8,
-    0x41, 0x69, 0xEB, 0x9B, 0x21, 0x72, 0xFC, 0x21, 0x61, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x6C, 0xFD, 0x21, 0x69, 0xFD,
-    0x21, 0x6D, 0xFD, 0xDA, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71,
-    0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C, 0x72, 0x65, 0x69, 0x6F, 0x61, 0xE7, 0xDE, 0xE7, 0xE1, 0xE7, 0xE1,
-    0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7,
-    0xE1, 0xE7, 0xE1, 0xF7, 0xB7, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE7, 0xE1, 0xE8, 0x0D, 0xE8, 0x0D,
-    0xFF, 0xCE, 0xFF, 0xD9, 0xFF, 0xE3, 0xFF, 0xFD, 0xD7, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A,
-    0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x75, 0xE7, 0x8D, 0xE7, 0xB9,
-    0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7,
-    0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9, 0xE7, 0xB9,
-    0xE7, 0xB9, 0xF7, 0x41, 0xA0, 0x08, 0xB1, 0x21, 0x2E, 0xFD, 0x49, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0x2E,
-    0x73, 0xE8, 0x4E, 0xE8, 0x51, 0xE8, 0x51, 0xE8, 0x51, 0xE8, 0x51, 0xE8, 0x51, 0xE8, 0x57, 0xFF, 0xFA, 0xFF, 0xFD,
-    0x22, 0x2E, 0x73, 0xDE, 0xE1, 0x21, 0x61, 0xFB, 0x21, 0xAD, 0xFD, 0x23, 0x6F, 0x61, 0xC3, 0xD9, 0xF5, 0xFD, 0x21,
-    0x66, 0xF9, 0xD7, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71,
-    0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x61, 0xE7, 0x0E, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A,
-    0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7,
-    0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xE7, 0x3A, 0xFF, 0xFD, 0x41, 0x73,
-    0xFF, 0x84, 0x42, 0x2E, 0x65, 0xFF, 0x7D, 0xFF, 0xFC, 0x21, 0x6C, 0xF9, 0x42, 0x6F, 0x61, 0xFF, 0x95, 0xFF, 0xFD,
-    0x21, 0x6E, 0xF9, 0x41, 0x72, 0xF9, 0x23, 0x42, 0x65, 0x72, 0xFF, 0xFC, 0xE7, 0x37, 0x21, 0x74, 0xF9, 0x42, 0x6C,
-    0x73, 0xF8, 0x4D, 0xFF, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE7, 0x64, 0xE7, 0x67, 0xE7, 0x67,
-    0xE7, 0x67, 0xE7, 0x67, 0xE7, 0x67, 0xE7, 0x6D, 0x41, 0x6E, 0xF8, 0xFB, 0x21, 0x6F, 0xFC, 0x22, 0x6F, 0x72, 0xE3,
-    0xFD, 0x41, 0x63, 0xE7, 0x04, 0x21, 0x65, 0xFC, 0x41, 0x61, 0xEA, 0x8B, 0x22, 0x6E, 0x67, 0xF9, 0xFC, 0x41, 0x64,
-    0xF7, 0x46, 0x21, 0x72, 0xFC, 0x21, 0x61, 0xFD, 0xDB, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A,
-    0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C, 0x72, 0x6F, 0x61, 0x65, 0x69, 0x75,
-    0xE6, 0x5D, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6,
-    0x60, 0xF6, 0x36, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60, 0xE6, 0x60,
-    0xE6, 0x60, 0xFE, 0xD0, 0xFF, 0x4F, 0xFF, 0xAC, 0xFF, 0xBD, 0xFF, 0xE1, 0xFF, 0xF1, 0xFF, 0xFD, 0x41, 0x2E, 0xE6,
-    0x0C, 0x42, 0x2E, 0x73, 0xE6, 0x08, 0xFF, 0xFC, 0x22, 0x6F, 0x61, 0xF9, 0xF9, 0x21, 0x6C, 0xFB, 0x42, 0x6F, 0x61,
-    0xE6, 0xD5, 0xE6, 0xD5, 0x21, 0x6E, 0xF9, 0x21, 0x61, 0xFD, 0x22, 0x65, 0x6D, 0xF0, 0xFD, 0x41, 0x65, 0xFE, 0x9F,
-    0x21, 0x74, 0xFC, 0x21, 0x6E, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x65, 0xFA, 0x22, 0x6C, 0x69, 0xFA, 0xFD, 0x42, 0x6C,
-    0x62, 0xF7, 0x7C, 0xFF, 0xFB, 0x42, 0x63, 0x6F, 0xE6, 0x55, 0xE6, 0xEB, 0x21, 0x69, 0xF9, 0x41, 0x2E, 0xE8, 0xAA,
-    0x42, 0x2E, 0x73, 0xE8, 0xA6, 0xFF, 0xFC, 0x21, 0x61, 0xF9, 0xA1, 0x04, 0xA2, 0x6C, 0xFD, 0x47, 0x68, 0x61, 0x65,
-    0x69, 0x6F, 0x75, 0xC3, 0xE9, 0x79, 0xE9, 0xB5, 0xE9, 0xB5, 0xE9, 0xB5, 0xFF, 0xFB, 0xE9, 0xB5, 0xE9, 0xBB, 0x43,
-    0x61, 0x69, 0x6F, 0xF5, 0xB9, 0xFF, 0xEA, 0xE9, 0xB0, 0x42, 0x61, 0x74, 0xF5, 0xAF, 0xE6, 0xBD, 0x41, 0x72, 0xE6,
-    0x11, 0x21, 0x65, 0xFC, 0x46, 0x63, 0x6C, 0x6D, 0x70, 0x74, 0x78, 0xF1, 0xA5, 0xFF, 0xBC, 0xFF, 0xE8, 0xFF, 0xF2,
-    0xFF, 0xFD, 0xFF, 0x0D, 0xA0, 0x0A, 0x13, 0x21, 0x65, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0xAD, 0xFD, 0x21, 0xC3, 0xFD,
-    0xA1, 0x06, 0xF3, 0x63, 0xFD, 0x21, 0x69, 0xEC, 0x21, 0x6D, 0xFD, 0x21, 0xAD, 0xFD, 0x22, 0x69, 0xC3, 0xFA, 0xFD,
-    0x21, 0x61, 0xDE, 0x21, 0x69, 0xFD, 0xA2, 0x06, 0xF3, 0x6E, 0x78, 0xF5, 0xFD, 0xA0, 0x0A, 0x43, 0x21, 0x6F, 0xFD,
-    0x21, 0x6D, 0xFD, 0x21, 0x69, 0xFD, 0xA1, 0x07, 0x23, 0x6E, 0xFD, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xF6, 0xA6,
-    0xF6, 0xA6, 0xF6, 0xA6, 0xFF, 0xFB, 0xF6, 0xA6, 0x48, 0x72, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE9, 0xF3,
-    0xE9, 0xCA, 0xF6, 0x93, 0xF6, 0x93, 0xFF, 0xBF, 0xFF, 0xD8, 0xF6, 0x93, 0xFF, 0xF0, 0x21, 0x72, 0xE7, 0x42, 0x65,
-    0x6F, 0xFF, 0xFD, 0xE9, 0x19, 0x43, 0x64, 0x70, 0x73, 0xF0, 0xC5, 0xFF, 0xF9, 0xF1, 0x1F, 0x42, 0x6F, 0x65, 0xE9,
-    0x08, 0xF0, 0xB7, 0x42, 0x6C, 0x6D, 0xF6, 0x93, 0xFF, 0xF9, 0x5B, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A,
-    0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x75, 0x61, 0x65, 0x69, 0x6F,
-    0xE4, 0xDF, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4,
-    0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2,
-    0xE4, 0xE2, 0xE4, 0xE2, 0xE4, 0xE2, 0xFE, 0xF6, 0xFF, 0x10, 0xFF, 0x62, 0xFF, 0xE8, 0xFF, 0xF9, 0xD6, 0x00, 0x41,
-    0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77,
-    0x78, 0x79, 0x7A, 0xE4, 0x8D, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90,
-    0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4,
-    0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0xE4, 0x90, 0x41, 0x6C, 0xF5, 0xF5, 0xD7, 0x00, 0x41, 0x2E, 0x62, 0x63,
-    0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C, 0x72,
-    0x69, 0xE4, 0x44, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47,
-    0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4, 0x47, 0xE4,
-    0x47, 0xE4, 0x47, 0xE4, 0x73, 0xE4, 0x73, 0xFF, 0xFC, 0xD6, 0x00, 0x81, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68,
-    0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xE3, 0xFC, 0xE3, 0xFF,
-    0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3,
-    0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF, 0xE3, 0xFF,
-    0xE3, 0xFF, 0x41, 0x75, 0xF3, 0x6B, 0x41, 0x66, 0xEF, 0x7D, 0xA0, 0x0D, 0x02, 0x21, 0x61, 0xFD, 0x21, 0x65, 0xFD,
-    0x21, 0x72, 0xFD, 0x21, 0xA1, 0xFD, 0x44, 0x6E, 0x70, 0x74, 0xC3, 0xFF, 0xED, 0xF5, 0x4D, 0xF5, 0x4D, 0xFF, 0xFD,
-    0x41, 0x61, 0xFC, 0x4E, 0x21, 0xAD, 0xFC, 0x21, 0xC3, 0xFD, 0x21, 0x67, 0xFD, 0xD9, 0x00, 0x41, 0x2E, 0x62, 0x63,
-    0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C,
-    0x65, 0x69, 0x6F, 0xE3, 0x86, 0xE3, 0x89, 0xE3, 0x8F, 0xE3, 0x89, 0xE3, 0x98, 0xE3, 0x9D, 0xE3, 0x89, 0xE3, 0x89,
-    0xE3, 0x89, 0xE3, 0x9D, 0xE3, 0x89, 0xE3, 0xA2, 0xE3, 0x89, 0xE3, 0x89, 0xE3, 0x89, 0xE3, 0xAB, 0xE3, 0x89, 0xE3,
-    0x89, 0xE3, 0x89, 0xE3, 0x89, 0xE3, 0x89, 0xFF, 0x8A, 0xFF, 0xCF, 0xFF, 0xE6, 0xFF, 0xFD, 0x42, 0x2E, 0x73, 0xE3,
-    0x38, 0xF4, 0x32, 0x21, 0x65, 0xF9, 0x21, 0x6C, 0xFD, 0x21, 0x62, 0xFD, 0x41, 0x2E, 0xE4, 0x07, 0x21, 0x65, 0xFC,
-    0x21, 0x74, 0xFD, 0x48, 0x6C, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE3, 0xAB, 0xE6, 0xEC, 0xE7, 0x28, 0xE7,
-    0x28, 0xE7, 0x28, 0xE7, 0x28, 0xE7, 0x28, 0xE7, 0x2E, 0x21, 0x61, 0xE7, 0x41, 0x6E, 0xE3, 0x8F, 0x21, 0x61, 0xFC,
-    0x47, 0x6F, 0x61, 0x6E, 0x67, 0x6C, 0x73, 0x74, 0xF3, 0xF5, 0xFF, 0xD0, 0xFF, 0xDA, 0xFF, 0xF6, 0xFF, 0xFD, 0xF4,
-    0xA8, 0xFC, 0x8B, 0xA0, 0x05, 0x51, 0x21, 0x61, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xFD, 0xA0, 0x02, 0xB2, 0xCC,
-    0x01, 0xA1, 0x68, 0x62, 0x63, 0x64, 0x66, 0x67, 0x6D, 0x70, 0x71, 0x73, 0x74, 0x76, 0xFF, 0xFD, 0xE4, 0xE9, 0xE4,
-    0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9, 0xE4, 0xE9,
-    0x41, 0x69, 0xE6, 0xCA, 0x44, 0x6E, 0x63, 0x6C, 0x78, 0xFF, 0xCF, 0xEE, 0x79, 0xFF, 0xD5, 0xFF, 0xFC, 0x41, 0x72,
-    0xE8, 0xA2, 0x21, 0x61, 0xFC, 0x21, 0x69, 0xFD, 0xA0, 0x01, 0x12, 0x21, 0x72, 0xFD, 0x21, 0x75, 0xFD, 0xA1, 0x04,
-    0xA2, 0x74, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE6, 0x54, 0xFF, 0xFB, 0xE6, 0x90, 0xE6, 0x90,
-    0xE6, 0x90, 0xE6, 0x90, 0xE6, 0x96, 0x21, 0x69, 0xEA, 0x41, 0x69, 0xE3, 0x9F, 0x44, 0x63, 0x6C, 0x6E, 0x72, 0xEE,
-    0x37, 0xFF, 0xD2, 0xFF, 0xF9, 0xFF, 0xFC, 0x41, 0x74, 0xE6, 0x62, 0x21, 0x6C, 0xFC, 0x43, 0x6E, 0x72, 0x74, 0xF4,
-    0x02, 0xFE, 0xA2, 0xF4, 0x02, 0xDB, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D,
-    0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x65, 0x61, 0x69, 0x75, 0x6F, 0xE2, 0x4B, 0xE2,
-    0x4E, 0xE2, 0x54, 0xE2, 0x4E, 0xE2, 0x5D, 0xE2, 0x62, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x62,
-    0xF2, 0x24, 0xE2, 0x67, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x70, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2, 0x4E, 0xE2,
-    0x4E, 0xE2, 0x4E, 0xFF, 0x50, 0xFF, 0xA0, 0xFF, 0xE2, 0xFF, 0xF3, 0xFF, 0xF6, 0xA0, 0x0B, 0x95, 0x21, 0x6E, 0xFD,
-    0x21, 0x69, 0xFD, 0x21, 0x72, 0xFD, 0xC3, 0x00, 0x71, 0x7A, 0x73, 0x65, 0xE1, 0xF1, 0xE1, 0xF1, 0xFF, 0xFD, 0x41,
-    0x74, 0xED, 0xA2, 0x42, 0x2E, 0x72, 0xE1, 0xDE, 0xFF, 0xFC, 0x43, 0x6D, 0x6E, 0x72, 0xF3, 0x81, 0xF3, 0x81, 0xF1,
-    0x88, 0x45, 0x63, 0x66, 0x6F, 0x74, 0x75, 0xED, 0x98, 0xED, 0x98, 0xFB, 0x31, 0xF3, 0x77, 0xF2, 0xA5, 0xD9, 0x00,
-    0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76,
-    0x77, 0x78, 0x79, 0x7A, 0x6F, 0x61, 0x65, 0xE1, 0xBA, 0xE1, 0xBD, 0xE1, 0xC3, 0xE1, 0xBD, 0xE1, 0xCC, 0xE1, 0xD1,
-    0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xD1, 0xE1, 0xBD, 0xE1, 0xD6, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1,
-    0xBD, 0xFF, 0xCF, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xBD, 0xE1, 0xBD, 0xFF, 0xDF, 0xFF, 0xE6, 0xFF, 0xF0,
-    0xC1, 0x0D, 0x22, 0x6F, 0xE2, 0x8F, 0x42, 0x63, 0x71, 0xFF, 0xFA, 0xF1, 0x1E, 0xC2, 0x00, 0x71, 0x2E, 0x69, 0xE1,
-    0x5F, 0xFF, 0xF9, 0xC2, 0x00, 0x71, 0x2E, 0x65, 0xE1, 0x56, 0xED, 0x24, 0x41, 0x74, 0xFE, 0xB9, 0x21, 0x63, 0xFC,
-    0x21, 0x6E, 0xFD, 0x41, 0x72, 0xE5, 0x49, 0xD8, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B,
-    0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x61, 0x75, 0xE1, 0x3F, 0xE1, 0x6B,
-    0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1,
-    0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B, 0xE1, 0x6B,
-    0xE1, 0x6B, 0xFF, 0xF9, 0xFF, 0xFC, 0x41, 0x70, 0xE2, 0xB2, 0x42, 0x6D, 0x74, 0xFF, 0xFC, 0xEC, 0xBA, 0xD7, 0x00,
-    0x91, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76,
-    0x77, 0x78, 0x79, 0x7A, 0x6F, 0xE0, 0xE9, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15,
-    0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1,
-    0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xE1, 0x15, 0xFF, 0xF9, 0x42, 0x61, 0x6F, 0xF1, 0x95, 0xF1,
-    0x95, 0x21, 0x74, 0xF9, 0x41, 0x61, 0xF4, 0x4F, 0x21, 0x69, 0xFC, 0x21, 0x6D, 0xFD, 0xA0, 0x10, 0x92, 0x21, 0x65,
-    0xFD, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD, 0xA0, 0x10, 0xB2, 0x21, 0x72, 0xFD, 0x21, 0x64, 0xFD, 0x21, 0x6E, 0xFD,
-    0x21, 0x6F, 0xFD, 0x23, 0x65, 0x61, 0x70, 0xE2, 0xEE, 0xFD, 0x44, 0x64, 0x72, 0x6E, 0x74, 0xF1, 0x7E, 0xFF, 0xF9,
-    0xF1, 0x42, 0xF9, 0xFB, 0x41, 0x6E, 0xEB, 0x6F, 0x21, 0x6F, 0xFC, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xFD, 0x41, 0x65,
-    0xEC, 0x1B, 0xA0, 0x06, 0x31, 0x41, 0xB1, 0xE1, 0xF2, 0x21, 0xC3, 0xFC, 0x22, 0x2E, 0x65, 0xF6, 0xFD, 0xA1, 0x04,
-    0xA2, 0x73, 0xFB, 0x41, 0x61, 0xE6, 0x3D, 0x21, 0x74, 0xFC, 0x21, 0x61, 0xFD, 0xA1, 0x04, 0xA2, 0x6C, 0xFD, 0x41,
-    0x6F, 0xE6, 0x2E, 0xA1, 0x04, 0xC2, 0x73, 0xFC, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xE4, 0x2E, 0xE4, 0x2E, 0xFF,
-    0xFB, 0xE4, 0x2E, 0xE4, 0x2E, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE3, 0xDF, 0xE4, 0x1B, 0xE4, 0x1B,
-    0xFF, 0xD3, 0xE4, 0x1B, 0xFF, 0xE2, 0xFF, 0xF0, 0x21, 0x61, 0xEA, 0x23, 0x6E, 0x6C, 0x72, 0xA4, 0xA7, 0xFD, 0x41,
-    0x7A, 0xEB, 0xBB, 0x43, 0x63, 0x65, 0x72, 0xF1, 0x9A, 0xFF, 0xFC, 0xF1, 0x9A, 0x42, 0x71, 0x63, 0xE5, 0xE7, 0xFF,
-    0xAA, 0x41, 0x65, 0xFF, 0xA3, 0x42, 0x64, 0x74, 0xFD, 0x3A, 0xFF, 0xFC, 0xA2, 0x04, 0xA2, 0x72, 0x6E, 0xEE, 0xF9,
-    0x41, 0x65, 0xFD, 0x36, 0x21, 0x69, 0xFC, 0xA1, 0x04, 0xA2, 0x6D, 0xFD, 0xC1, 0x04, 0xA2, 0x72, 0xE1, 0x66, 0x41,
-    0x71, 0xE5, 0xBC, 0xA1, 0x04, 0xC2, 0x72, 0xFC, 0x41, 0x65, 0xE5, 0xB3, 0x21, 0x74, 0xFC, 0xA1, 0x04, 0xC2, 0x73,
-    0xFD, 0x45, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF, 0xEF, 0xFF, 0xFB, 0xE3, 0xB0, 0xE3, 0xB0, 0xE3, 0xB0, 0x47, 0x68,
-    0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE3, 0x61, 0xFF, 0xC2, 0xE3, 0x9D, 0xE3, 0x9D, 0xFF, 0xD0, 0xFF, 0xD5, 0xFF,
-    0xF0, 0x21, 0x69, 0xEA, 0x41, 0x6F, 0xEA, 0x8B, 0xA1, 0x04, 0x52, 0x72, 0xFC, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F,
-    0x75, 0xC3, 0xE0, 0x80, 0xE0, 0x83, 0xFF, 0xFB, 0xE0, 0x83, 0xE0, 0x83, 0xE0, 0x83, 0xE0, 0x89, 0x21, 0x61, 0xEA,
-    0x21, 0x74, 0xFD, 0x41, 0x72, 0xFC, 0x7C, 0x21, 0x70, 0xFC, 0x41, 0x64, 0xFC, 0x75, 0x22, 0x6D, 0x6E, 0xF9, 0xFC,
-    0xA0, 0x0E, 0x13, 0x21, 0x72, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x70, 0xFD, 0xA0, 0x0E, 0x43, 0x21, 0x74, 0xFD, 0x21,
-    0x63, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xD8, 0x22, 0x6C, 0x73, 0xFA, 0xFD, 0x41, 0x2E, 0xE1, 0x38, 0x42, 0x2E,
-    0x73, 0xE1, 0x34, 0xFF, 0xFC, 0x42, 0x61, 0x73, 0xFF, 0xF9, 0xE1, 0xD0, 0x24, 0x69, 0x6F, 0x65, 0x74, 0xC9, 0xD7,
-    0xE9, 0xF9, 0x43, 0x6C, 0x72, 0x73, 0xFF, 0x8D, 0xFF, 0xB2, 0xFF, 0xF7, 0xDB, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64,
-    0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x6C, 0x72, 0x75,
-    0x65, 0x61, 0x69, 0x6F, 0xDF, 0x00, 0xDF, 0x03, 0xDF, 0x03, 0xDF, 0x03, 0xDF, 0x03, 0xDF, 0x03, 0xDF, 0x03, 0xDF,
-    0x03, 0xDF, 0x03, 0xDF, 0x03, 0xEE, 0xD9, 0xDF, 0x03, 0xDF, 0x03, 0xFD, 0xA1, 0xFD, 0xAA, 0xDF, 0x03, 0xDF, 0x03,
-    0xDF, 0x03, 0xDF, 0x03, 0xDF, 0x03, 0xFD, 0xC1, 0xFE, 0x17, 0xFE, 0x66, 0xFE, 0x95, 0xFF, 0x08, 0xFF, 0x13, 0xFF,
-    0xF6, 0x42, 0x6D, 0x72, 0xDF, 0x3C, 0xEA, 0x76, 0x42, 0x65, 0x69, 0xFC, 0xC6, 0xFF, 0xF9, 0xD7, 0x00, 0x41, 0x2E,
-    0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78,
-    0x79, 0x7A, 0x75, 0xDE, 0x9E, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1,
-    0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE,
-    0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xDE, 0xA1, 0xFF, 0xF9, 0xC2, 0x00, 0x71, 0x6E, 0x61, 0xDE, 0x5C, 0xEE,
-    0xD0, 0x41, 0xA1, 0xF0, 0xDB, 0x43, 0x61, 0xC3, 0x65, 0xF0, 0xD7, 0xFF, 0xFC, 0xF0, 0xD7, 0x21, 0x69, 0xF6, 0x21,
-    0x63, 0xFD, 0xA0, 0x0A, 0x72, 0x21, 0x61, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x63, 0xFD, 0x21, 0xAD, 0xFD, 0x22, 0x69,
-    0xC3, 0xEE, 0xFD, 0x21, 0x6E, 0xFB, 0x42, 0x65, 0x72, 0xE2, 0x3D, 0xE9, 0xEC, 0x22, 0x69, 0x74, 0xF6, 0xF9, 0xA0,
-    0x0B, 0xB1, 0x23, 0xA1, 0xA9, 0xAD, 0xFD, 0xFD, 0xFD, 0x24, 0x61, 0xC3, 0x65, 0x6F, 0xF6, 0xF9, 0xF6, 0xF6, 0x43,
-    0x64, 0x6E, 0x72, 0xF5, 0xFA, 0xED, 0xB7, 0xFF, 0xF7, 0x41, 0x6D, 0xEF, 0xA6, 0xD9, 0x00, 0x41, 0x2E, 0x62, 0x63,
-    0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x72,
-    0x65, 0x61, 0x6F, 0xDD, 0xF5, 0xDD, 0xF8, 0xDD, 0xFE, 0xDD, 0xF8, 0xDE, 0x07, 0xDE, 0x0C, 0xDD, 0xF8, 0xDD, 0xF8,
-    0xDD, 0xF8, 0xDD, 0xF8, 0xFF, 0x9F, 0xDD, 0xF8, 0xDE, 0x11, 0xDD, 0xF8, 0xDD, 0xF8, 0xDE, 0x1A, 0xDD, 0xF8, 0xDD,
-    0xF8, 0xDD, 0xF8, 0xDD, 0xF8, 0xDD, 0xF8, 0xDE, 0x24, 0xFF, 0xDA, 0xFF, 0xF2, 0xFF, 0xFC, 0xC4, 0x00, 0x71, 0x74,
-    0x73, 0x6E, 0x61, 0xDD, 0xAD, 0xDD, 0xAD, 0xDD, 0xAD, 0xEE, 0x21, 0xA0, 0x00, 0xD1, 0x21, 0x2E, 0xFD, 0x22, 0x2E,
-    0x73, 0xFA, 0xFD, 0xA0, 0x03, 0x02, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0x22, 0x2E, 0x65, 0xEC, 0xFD, 0x21, 0x6C,
-    0xFB, 0x22, 0x2E, 0x73, 0xEF, 0xF2, 0x21, 0x6E, 0xED, 0x21, 0xB3, 0xFD, 0x21, 0x65, 0xEA, 0x21, 0x6E, 0xFD, 0x23,
-    0x61, 0xC3, 0x6F, 0xEF, 0xF7, 0xFD, 0x21, 0x6C, 0xF9, 0x21, 0x6C, 0xFD, 0x21, 0x73, 0xC9, 0x23, 0x2E, 0x61, 0x65,
-    0xC3, 0xC9, 0xFD, 0x21, 0x72, 0xF9, 0xC6, 0x00, 0x71, 0x7A, 0x73, 0x65, 0x61, 0x69, 0x6F, 0xDD, 0x57, 0xDD, 0x57,
-    0xFF, 0xBF, 0xFF, 0xD2, 0xFF, 0xF0, 0xFF, 0xFD, 0x41, 0x74, 0xDF, 0xF2, 0x21, 0x63, 0xFC, 0x41, 0x76, 0xDE, 0x67,
-    0x44, 0x6E, 0x2E, 0x73, 0x6C, 0xFF, 0xF9, 0xF5, 0xEC, 0xF5, 0xEF, 0xFF, 0xFC, 0x41, 0x65, 0xFA, 0x22, 0x41, 0x76,
-    0xE8, 0xEA, 0xA0, 0x0E, 0xD2, 0xA0, 0x0E, 0xF3, 0xA0, 0x0F, 0x23, 0x25, 0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFD, 0xFD,
-    0xFD, 0xFD, 0xFD, 0x27, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xEC, 0xEF, 0xEF, 0xEF, 0xEF, 0xEF, 0xF5, 0x21,
-    0x6F, 0xF1, 0x21, 0x64, 0xFD, 0x44, 0x6C, 0x6D, 0x72, 0x75, 0xFF, 0xCF, 0xFA, 0x44, 0xFF, 0xD3, 0xFF, 0xFD, 0xA0,
-    0x0F, 0x52, 0xA1, 0x0F, 0x52, 0x73, 0xFD, 0x21, 0x61, 0xFB, 0xA1, 0x04, 0x52, 0x73, 0xFD, 0x47, 0x68, 0x61, 0x65,
-    0x69, 0x6F, 0x75, 0xC3, 0xDD, 0xE5, 0xFF, 0xFB, 0xDD, 0xE8, 0xDD, 0xE8, 0xDD, 0xE8, 0xDD, 0xE8, 0xDD, 0xEE, 0x21,
-    0x65, 0xEA, 0x21, 0x72, 0xFD, 0x42, 0x62, 0x63, 0xFF, 0xFD, 0xF4, 0xB1, 0xA0, 0x0F, 0xF3, 0xA1, 0x06, 0xF3, 0x72,
-    0xFD, 0x41, 0x72, 0xF9, 0xC6, 0xA1, 0x06, 0xF3, 0x6F, 0xFC, 0xA0, 0x10, 0x23, 0x41, 0x2E, 0xF7, 0x64, 0x42, 0x2E,
-    0x73, 0xF7, 0x60, 0xFF, 0xFC, 0x21, 0x74, 0xF9, 0x21, 0x69, 0xFD, 0xA2, 0x07, 0x23, 0x72, 0x76, 0xEC, 0xFD, 0x45,
-    0xA1, 0xA9, 0xAD, 0xB3, 0xBA, 0xFF, 0xF9, 0xEE, 0x03, 0xEE, 0x03, 0xEE, 0x03, 0xEE, 0x03, 0x48, 0x72, 0x68, 0x61,
-    0x65, 0x69, 0x6F, 0x75, 0xC3, 0xE1, 0x50, 0xE1, 0x27, 0xFF, 0xC7, 0xED, 0xF0, 0xFF, 0xD0, 0xED, 0xF0, 0xED, 0xF0,
-    0xFF, 0xF0, 0x21, 0x72, 0xE7, 0xC7, 0x07, 0xB1, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xDD, 0x6A, 0xDD, 0x6D,
-    0xDD, 0x6D, 0xDD, 0x6D, 0xDD, 0x6D, 0xDD, 0x6D, 0xDD, 0x73, 0x21, 0x61, 0xE8, 0x22, 0x65, 0x72, 0xE2, 0xFD, 0xA0,
-    0x11, 0x43, 0x21, 0x6E, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x63, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x65,
-    0xFD, 0x21, 0x6D, 0xFD, 0x21, 0x61, 0xFD, 0x23, 0x70, 0x64, 0x72, 0xE0, 0xFD, 0xFD, 0xDA, 0x00, 0x41, 0x2E, 0x62,
-    0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79,
-    0x7A, 0x61, 0x65, 0x6F, 0x75, 0xDC, 0x19, 0xDC, 0x1C, 0xDC, 0x22, 0xDC, 0x1C, 0xDC, 0x2B, 0xDC, 0x30, 0xDC, 0x1C,
-    0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x30, 0xDC, 0x1C, 0xFE, 0x72, 0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x1C, 0xFE,
-    0xC8, 0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x1C, 0xDC, 0x1C, 0xFE, 0xE8, 0xFF, 0x26, 0xFF, 0x5F, 0xFF, 0xF9,
-    0x41, 0x65, 0xE1, 0x23, 0x41, 0x6E, 0xDF, 0x92, 0x21, 0x69, 0xFC, 0x22, 0x74, 0x64, 0xF5, 0xFD, 0x41, 0x6C, 0xDF,
-    0x86, 0x21, 0x65, 0xFC, 0x21, 0x75, 0xFD, 0x41, 0x62, 0xDF, 0x7C, 0x21, 0x6F, 0xFC, 0x41, 0x72, 0xDF, 0x75, 0x21,
-    0x61, 0xFC, 0x43, 0x63, 0x70, 0x74, 0xFF, 0xF6, 0xDF, 0x6E, 0xFF, 0xFD, 0x41, 0xA1, 0xDF, 0x8F, 0x21, 0xC3, 0xFC,
-    0x21, 0x6C, 0xFD, 0x24, 0x6E, 0x62, 0x6C, 0x74, 0xCF, 0xDB, 0xEC, 0xFD, 0x21, 0xA1, 0xBF, 0x21, 0xC3, 0xFD, 0x21,
-    0x65, 0xFD, 0x21, 0x63, 0xFD, 0x41, 0x2E, 0xE4, 0xB3, 0x42, 0x2E, 0x73, 0xE4, 0xAF, 0xFF, 0xFC, 0x22, 0x6F, 0x61,
-    0xF9, 0xF9, 0x21, 0x72, 0xFB, 0x23, 0x61, 0x6F, 0x65, 0xD8, 0xEA, 0xFD, 0x41, 0x73, 0xDE, 0x49, 0x21, 0x61, 0xFC,
-    0x21, 0x6E, 0xFD, 0x21, 0x69, 0xFD, 0x41, 0x64, 0xE0, 0x00, 0x41, 0x6C, 0xDF, 0xFC, 0x41, 0x69, 0xE9, 0x65, 0x42,
-    0x63, 0x74, 0xDF, 0xF7, 0xFF, 0xFC, 0xA4, 0x0E, 0xB2, 0x6D, 0x6E, 0x74, 0x63, 0xEA, 0xED, 0xF1, 0xF9, 0x41, 0xBA,
-    0xE4, 0x87, 0x41, 0x75, 0xDF, 0xE5, 0xA2, 0x0E, 0xB2, 0xC3, 0x78, 0xF8, 0xFC, 0x41, 0x6E, 0xDF, 0xDA, 0x21, 0x61,
-    0xFC, 0x21, 0x69, 0xFD, 0x21, 0x72, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0xB3, 0xF0, 0x22, 0x6F, 0xC3, 0xED, 0xFD, 0x21,
-    0x69, 0xFB, 0x41, 0x2E, 0xDB, 0x9E, 0x42, 0x2E, 0x73, 0xDB, 0x9A, 0xFF, 0xFC, 0x22, 0x6F, 0x61, 0xF9, 0xF9, 0x41,
-    0xAD, 0xDF, 0xAF, 0x43, 0x69, 0xC3, 0x65, 0xDF, 0xAB, 0xFF, 0xFC, 0xDF, 0xAB, 0x41, 0xA1, 0xDF, 0xA1, 0x43, 0x61,
-    0xC3, 0x6F, 0xDF, 0x9D, 0xFF, 0xFC, 0xDF, 0x9D, 0x41, 0x61, 0xE4, 0x31, 0x21, 0x76, 0xFC, 0x41, 0x74, 0xDD, 0x80,
-    0x41, 0x69, 0xDF, 0x88, 0xA1, 0x0E, 0x92, 0x72, 0xFC, 0x41, 0x76, 0xDF, 0x7F, 0x45, 0x61, 0xC3, 0x65, 0x6F, 0x69,
-    0xDF, 0x7B, 0xDF, 0xF0, 0xDF, 0x7B, 0xFF, 0xF7, 0xFF, 0xFC, 0xC8, 0x0E, 0xB2, 0x62, 0x63, 0x64, 0x67, 0x6A, 0x6C,
-    0x73, 0x74, 0xFF, 0x9E, 0xFF, 0xA9, 0xFF, 0xB7, 0xFF, 0xC0, 0xFF, 0xCE, 0xFF, 0xDC, 0xFF, 0xDF, 0xFF, 0xF0, 0x41,
-    0x65, 0xDF, 0x49, 0x41, 0x69, 0xDD, 0x81, 0x21, 0x63, 0xFC, 0x21, 0x61, 0xFD, 0xA2, 0x0E, 0xB2, 0x63, 0x72, 0xF2,
-    0xFD, 0xC3, 0x0E, 0xB2, 0x72, 0x62, 0x73, 0xDF, 0x34, 0xE1, 0xB9, 0xE0, 0xFB, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F,
-    0x75, 0xC3, 0xDF, 0x28, 0xFF, 0x3B, 0xFF, 0x4E, 0xFF, 0xC4, 0xFF, 0xED, 0xFF, 0xF4, 0xE5, 0xE3, 0x21, 0x73, 0xEA,
-    0x42, 0x73, 0x6E, 0xFE, 0xFB, 0xFF, 0xFD, 0x41, 0x70, 0xE6, 0x22, 0xD8, 0x00, 0x91, 0x2E, 0x62, 0x63, 0x64, 0x66,
-    0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x61, 0x6F,
-    0xDA, 0x54, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA,
-    0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80,
-    0xDA, 0x80, 0xDA, 0x80, 0xDA, 0x80, 0xFF, 0xF5, 0xFF, 0xFC, 0x41, 0x68, 0xEC, 0xA2, 0x21, 0x63, 0xFC, 0xC2, 0x01,
-    0xF2, 0x2E, 0x73, 0xDA, 0x02, 0xFF, 0xFD, 0xC1, 0x01, 0xF2, 0x2E, 0xD9, 0xF9, 0xA0, 0x01, 0xF2, 0x42, 0x61, 0x72,
-    0xF6, 0xB8, 0xDB, 0x22, 0x41, 0x65, 0xDE, 0x04, 0x42, 0x61, 0x6D, 0xDE, 0x00, 0xE5, 0xAF, 0x44, 0x74, 0x6C, 0x63,
-    0x72, 0xFF, 0xEE, 0xFF, 0xF5, 0xEA, 0x58, 0xFF, 0xF9, 0x41, 0x75, 0xEC, 0x56, 0x41, 0x6F, 0xEC, 0x52, 0x22, 0x71,
-    0x63, 0xF8, 0xFC, 0x21, 0x6F, 0xFB, 0x41, 0x6C, 0xEA, 0x9C, 0x41, 0x70, 0xEB, 0x6A, 0x41, 0x62, 0xE5, 0x83, 0x21,
-    0x72, 0xFC, 0x41, 0x63, 0xDA, 0x91, 0x21, 0x69, 0xFC, 0x21, 0x6E, 0xFD, 0x21, 0x63, 0xFD, 0x21, 0xA9, 0xFD, 0xDC,
-    0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x74, 0x76, 0x77, 0x79,
-    0x72, 0x7A, 0x73, 0x6C, 0x78, 0x65, 0x69, 0x61, 0x6F, 0x75, 0xC3, 0xD9, 0xA2, 0xD9, 0xA5, 0xD9, 0xAB, 0xD9, 0xA5,
-    0xD9, 0xB4, 0xD9, 0xB9, 0xD9, 0xA5, 0xD9, 0xA5, 0xD9, 0xA5, 0xD9, 0xB9, 0xD9, 0xA5, 0xD9, 0xBE, 0xD9, 0xA5, 0xD9,
-    0xC7, 0xD9, 0xA5, 0xD9, 0xA5, 0xD9, 0xA5, 0xFF, 0x4E, 0xFF, 0xA0, 0xFF, 0xA9, 0xFF, 0xAF, 0xFF, 0xAF, 0xFF, 0xC4,
-    0xFF, 0xDE, 0xFF, 0xE1, 0xFF, 0xE5, 0xFF, 0xED, 0xFF, 0xFD, 0x42, 0x63, 0x64, 0xFF, 0x62, 0xF8, 0xFA, 0xD7, 0x00,
-    0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6D, 0x6E, 0x70, 0x71, 0x73, 0x74, 0x76, 0x77, 0x78,
-    0x79, 0x7A, 0x6C, 0x72, 0x69, 0xD9, 0x44, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47,
-    0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9,
-    0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x47, 0xD9, 0x73, 0xD9, 0x73, 0xFF, 0xF9, 0x41, 0x73, 0xFE, 0xF3, 0xD7, 0x00,
-    0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76,
-    0x77, 0x78, 0x79, 0x7A, 0x61, 0xD8, 0xF8, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB,
-    0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8,
-    0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xD8, 0xFB, 0xFF, 0xFC, 0x42, 0x6E, 0x72, 0xEA, 0x5D, 0xEA,
-    0x5D, 0xD8, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72,
-    0x73, 0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x65, 0x69, 0xD8, 0xA9, 0xD8, 0xAC, 0xD8, 0xB2, 0xD8, 0xAC, 0xD8, 0xBB,
-    0xD8, 0xC0, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xC0, 0xD8, 0xAC, 0xD8, 0xC5, 0xD8, 0xAC, 0xD8,
-    0xAC, 0xD8, 0xAC, 0xD8, 0xCE, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xD8, 0xAC, 0xFF, 0xF9, 0xF4, 0x61,
-    0xD6, 0x00, 0x41, 0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73,
-    0x74, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xD8, 0x5E, 0xD8, 0x61, 0xD8, 0x67, 0xD8, 0x61, 0xD8, 0x70, 0xD8, 0x75, 0xD8,
-    0x61, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x75, 0xD8, 0x61, 0xD8, 0x7A, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x61,
-    0xD8, 0x83, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x61, 0xD8, 0x61, 0x41, 0x6F, 0xF1, 0x80, 0xD7, 0x00, 0x41,
-    0x2E, 0x62, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77,
-    0x78, 0x79, 0x7A, 0x6F, 0xD8, 0x15, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8,
-    0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18,
-    0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xD8, 0x18, 0xFF, 0xFC, 0xC1, 0x00, 0x41, 0x2E, 0xD7, 0xCD, 0x41,
-    0x73, 0xE8, 0xC1, 0xA0, 0x02, 0x82, 0x21, 0x2E, 0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD, 0x43, 0x65, 0x6F, 0x61, 0xF4,
-    0x80, 0xF4, 0x80, 0xFF, 0xFB, 0x21, 0x6C, 0xF6, 0x21, 0x65, 0xFD, 0x43, 0x65, 0x6F, 0x61, 0xF4, 0x70, 0xF4, 0x70,
-    0xF4, 0x70, 0x21, 0x6C, 0xF6, 0x21, 0x65, 0xFD, 0x21, 0x73, 0xFA, 0x21, 0x6F, 0xFD, 0xA0, 0x02, 0xD2, 0x21, 0x2E,
-    0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD, 0x22, 0x6F, 0x61, 0xFB, 0xFB, 0x21, 0x63, 0xFB, 0x21, 0x69, 0xFD, 0x25, 0x6D,
-    0x74, 0x73, 0x6E, 0x72, 0xD1, 0xD1, 0xE1, 0xE7, 0xFD, 0x23, 0x65, 0x6F, 0x61, 0xE5, 0xE5, 0xE5, 0x21, 0x6C, 0xF9,
-    0x21, 0x73, 0xFD, 0x25, 0x6D, 0x74, 0x73, 0x6E, 0x6F, 0xB9, 0xB9, 0xC9, 0xCF, 0xFD, 0x46, 0x73, 0x69, 0x2E, 0x64,
-    0x6F, 0x72, 0xD7, 0x59, 0xFF, 0x92, 0xD7, 0x59, 0xFF, 0xDD, 0xFF, 0xC1, 0xFF, 0xF5, 0x41, 0x73, 0xFF, 0x86, 0x21,
-    0x6F, 0xFC, 0x45, 0x2E, 0x73, 0x6D, 0x69, 0x6E, 0xD7, 0x3F, 0xE8, 0x39, 0xFF, 0xFD, 0xFF, 0x78, 0xE8, 0x39, 0xA0,
-    0x02, 0xA3, 0x21, 0x2E, 0xFD, 0x23, 0x2E, 0x73, 0x69, 0xFA, 0xFD, 0xE3, 0x42, 0x6F, 0x61, 0xF3, 0xEA, 0xF3, 0xEA,
-    0x21, 0x63, 0xF9, 0x43, 0x65, 0x61, 0x69, 0xFF, 0xEF, 0xF3, 0xE0, 0xFF, 0xFD, 0x41, 0x6F, 0xF3, 0xD6, 0x22, 0x74,
-    0x6D, 0xF2, 0xFC, 0x41, 0x73, 0xFF, 0x76, 0x21, 0x65, 0xFC, 0x21, 0x6F, 0xF9, 0x41, 0x65, 0xFF, 0x6F, 0x21, 0x6C,
-    0xFC, 0x47, 0x61, 0x2E, 0x73, 0x74, 0x6D, 0x64, 0x62, 0xFF, 0xB5, 0xD6, 0xF4, 0xFF, 0xEA, 0xFF, 0xF3, 0xFF, 0xF6,
-    0xFF, 0x6D, 0xFF, 0xFD, 0x21, 0x6D, 0xE0, 0x42, 0x2E, 0x65, 0xD6, 0xDB, 0xFF, 0xFD, 0x21, 0x61, 0xF6, 0xA0, 0x02,
-    0xA2, 0x42, 0x2E, 0x73, 0xFF, 0xFD, 0xFF, 0xA2, 0x42, 0x2E, 0x73, 0xFF, 0x98, 0xFF, 0x9B, 0x23, 0x65, 0x6F, 0x61,
-    0xF2, 0xF2, 0xF9, 0x21, 0x6C, 0xF9, 0x21, 0x65, 0xFD, 0x23, 0x65, 0x6F, 0x61, 0xEC, 0xEC, 0xEC, 0x21, 0x6C, 0xF9,
-    0x21, 0x65, 0xFD, 0x21, 0x73, 0xFA, 0x21, 0x6F, 0xFD, 0x47, 0x61, 0x65, 0x6D, 0x74, 0x73, 0x6E, 0x6F, 0xFF, 0xC2,
-    0xFF, 0xC2, 0xFF, 0xEA, 0xFF, 0xF7, 0xFF, 0xF7, 0xFF, 0xFD, 0xFF, 0x08, 0x44, 0x6D, 0x74, 0x73, 0x6E, 0xFE, 0xDF,
-    0xFE, 0xDF, 0xFE, 0xEF, 0xFE, 0xF5, 0x41, 0x6F, 0xFE, 0xB6, 0x43, 0x6F, 0x61, 0x65, 0xF3, 0x41, 0xF3, 0x41, 0xF3,
-    0x41, 0x42, 0x2E, 0x6C, 0xD6, 0x6F, 0xFF, 0xF6, 0x21, 0x65, 0xF9, 0x41, 0x65, 0xE7, 0x5F, 0x44, 0x2E, 0x6D, 0x6C,
-    0x6E, 0xD6, 0x61, 0xFF, 0xFC, 0xFF, 0xE8, 0xFF, 0xE4, 0x21, 0x65, 0xF3, 0x46, 0x6C, 0x6E, 0x6F, 0x6D, 0x74, 0x73,
-    0xFE, 0xA9, 0xFF, 0xD4, 0xFE, 0x8A, 0xFF, 0xE9, 0xFF, 0xFD, 0xFF, 0xFD, 0x21, 0x6F, 0xED, 0x21, 0x64, 0xFD, 0x47,
-    0x73, 0x69, 0x62, 0x72, 0x64, 0x6F, 0x6E, 0xFF, 0x5D, 0xFE, 0x71, 0xFF, 0x64, 0xFF, 0x98, 0xFF, 0xAE, 0xFE, 0xA0,
-    0xFF, 0xFD, 0x41, 0x67, 0xFE, 0x9B, 0x21, 0x6F, 0xFC, 0x41, 0x63, 0xD6, 0x1E, 0x21, 0x69, 0xFC, 0x41, 0x65, 0xFF,
-    0x06, 0x21, 0x74, 0xFC, 0x45, 0x2E, 0x6C, 0x74, 0x6E, 0x73, 0xD6, 0x0D, 0xFF, 0xEF, 0xFF, 0xF6, 0xE7, 0x07, 0xFF,
-    0xFD, 0x45, 0xB1, 0xA9, 0xAD, 0xA1, 0xB3, 0xFE, 0x30, 0xFE, 0xA4, 0xFF, 0x09, 0xFF, 0xC5, 0xFF, 0xF0, 0xA0, 0x01,
-    0x72, 0xA0, 0x01, 0x92, 0x21, 0xB3, 0xFD, 0x22, 0x75, 0xC3, 0xF7, 0xFD, 0x21, 0x65, 0xF2, 0xA0, 0x02, 0x62, 0x21,
-    0x2E, 0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD, 0x21, 0x6F, 0xFB, 0x21, 0x65, 0xF5, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD,
-    0x21, 0x65, 0xFD, 0x23, 0x2E, 0x73, 0x6D, 0xE6, 0xE9, 0xFD, 0x22, 0x6F, 0x61, 0xE5, 0xF9, 0x21, 0x63, 0xFB, 0x21,
-    0x69, 0xFD, 0x21, 0x67, 0xFD, 0x21, 0xB3, 0xFD, 0x21, 0x61, 0xD4, 0x21, 0xAD, 0xFD, 0x21, 0xC3, 0xFD, 0x21, 0x67,
-    0xFD, 0x41, 0x67, 0xE1, 0x68, 0x23, 0xC3, 0x6F, 0x69, 0xED, 0xF9, 0xFC, 0xA0, 0x00, 0xC2, 0x21, 0x2E, 0xFD, 0x22,
-    0x2E, 0x73, 0xFA, 0xFD, 0x21, 0x65, 0xF8, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x23, 0x2E, 0x73,
-    0x6D, 0xE9, 0xEC, 0xFD, 0x44, 0x2E, 0x6F, 0x61, 0x74, 0xD5, 0x78, 0xFF, 0xE8, 0xFF, 0xF9, 0xF5, 0x24, 0x42, 0x6F,
-    0x61, 0xD9, 0x83, 0xD9, 0x83, 0x21, 0x74, 0xF9, 0x41, 0x6E, 0xF2, 0xAF, 0x43, 0x63, 0x74, 0x65, 0xE7, 0x07, 0xE7,
-    0x07, 0xFD, 0x93, 0x41, 0x74, 0xE6, 0xFD, 0x41, 0x69, 0xE5, 0x70, 0x41, 0x61, 0xD6, 0xF0, 0x21, 0xAD, 0xFC, 0x21,
-    0xC3, 0xFD, 0xA1, 0x04, 0xA2, 0x70, 0xFD, 0x47, 0x68, 0x61, 0x65, 0x69, 0x6F, 0x75, 0xC3, 0xD9, 0x07, 0xD9, 0x43,
-    0xFF, 0xFB, 0xD9, 0x43, 0xD9, 0x43, 0xD9, 0x43, 0xD9, 0x49, 0x21, 0x6F, 0xEA, 0x22, 0x6E, 0x74, 0xD4, 0xFD, 0xA0,
-    0x00, 0x91, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0xA0, 0x0F, 0x72, 0x21, 0x2E, 0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD,
-    0x22, 0x6F, 0x61, 0xFB, 0xFB, 0xA0, 0x03, 0x32, 0x21, 0x2E, 0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD, 0xA0, 0x10, 0xF3,
-    0x21, 0x2E, 0xFD, 0x23, 0x61, 0x2E, 0x73, 0xF5, 0xFA, 0xFD, 0x21, 0x73, 0xEB, 0x22, 0x2E, 0x65, 0xE5, 0xFD, 0x21,
-    0x6C, 0xFB, 0x22, 0x65, 0x61, 0xEE, 0xFD, 0x22, 0x63, 0x64, 0xD3, 0xFB, 0x4D, 0x65, 0x61, 0x2E, 0x78, 0x6C, 0x73,
-    0x63, 0x6D, 0x6E, 0x70, 0x72, 0x6F, 0x69, 0xFE, 0xF1, 0xFE, 0xF6, 0xD4, 0xD5, 0xFF, 0x04, 0xFF, 0x3B, 0xFF, 0x60,
-    0xFF, 0x74, 0xFF, 0x77, 0xFF, 0x7B, 0xFF, 0x85, 0xFF, 0xB5, 0xFF, 0xC0, 0xFF, 0xFB, 0x42, 0x65, 0xC3, 0xFE, 0xC0,
-    0xFE, 0xC6, 0xA0, 0x03, 0x23, 0x21, 0x2E, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x67, 0xFD, 0x43, 0x2E,
-    0x73, 0x69, 0xD4, 0x97, 0xE5, 0x91, 0xFC, 0xD0, 0x21, 0x65, 0xF6, 0x41, 0x73, 0xFE, 0xB1, 0x44, 0x2E, 0x73, 0x69,
-    0x6E, 0xFE, 0xAA, 0xFE, 0xAD, 0xFF, 0xFC, 0xFE, 0xAD, 0x43, 0x2E, 0x74, 0x65, 0xD4, 0x79, 0xFF, 0xEC, 0xFF, 0xF3,
-    0xA0, 0x0C, 0xF1, 0x21, 0x61, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x6C, 0xFD, 0xA0, 0x11, 0x22, 0x21, 0x6E, 0xFD, 0x21,
-    0x61, 0xFD, 0x21, 0x63, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x72, 0xFD, 0x23, 0x6F, 0x69, 0x65, 0xC7, 0xEB, 0xFD, 0x42,
-    0x6F, 0x72, 0xD4, 0x4A, 0xE0, 0x14, 0x45, 0x2E, 0x64, 0x66, 0x67, 0x74, 0xD4, 0x43, 0xFF, 0xF9, 0xF1, 0x94, 0xE5,
-    0xEC, 0xFA, 0x5A, 0x41, 0x65, 0xFC, 0x6C, 0x42, 0x6E, 0x73, 0xFE, 0x56, 0xFE, 0x56, 0x41, 0x6F, 0xFF, 0x9E, 0x41,
-    0x73, 0xFE, 0x48, 0x45, 0x2E, 0x73, 0x6D, 0x69, 0x6E, 0xFE, 0x44, 0xFE, 0x47, 0xFF, 0xF8, 0xFF, 0xFC, 0xFE, 0x47,
-    0x42, 0x61, 0x73, 0xFF, 0xF0, 0xFE, 0x37, 0x43, 0x2E, 0x73, 0x69, 0xFE, 0x2D, 0xFE, 0x30, 0xFF, 0x7F, 0x43, 0x73,
-    0x2E, 0x6E, 0xFE, 0x26, 0xFE, 0x23, 0xFE, 0x26, 0x23, 0xAD, 0xA9, 0xA1, 0xE5, 0xEC, 0xF6, 0x45, 0x6D, 0x2E, 0x73,
-    0x69, 0x6E, 0xFF, 0xC6, 0xFE, 0x12, 0xFE, 0x15, 0xFF, 0x64, 0xFE, 0x15, 0xA0, 0x03, 0x22, 0x21, 0x2E, 0xFD, 0x21,
-    0x65, 0xFD, 0x41, 0x65, 0xFF, 0x32, 0x42, 0x2E, 0x73, 0xFF, 0x2B, 0xFF, 0x2E, 0x23, 0x65, 0x61, 0x6F, 0xF9, 0xF9,
-    0xF9, 0x41, 0x73, 0xFF, 0x20, 0x21, 0x6F, 0xFC, 0x41, 0x68, 0xD7, 0xC2, 0xC2, 0x00, 0xD1, 0x2E, 0x73, 0xFD, 0xDC,
-    0xFD, 0xDF, 0x22, 0x6F, 0x61, 0xF7, 0xF7, 0x4C, 0x6F, 0xC3, 0x65, 0x61, 0x2E, 0x6D, 0x74, 0x6C, 0x73, 0x6E, 0x63,
-    0x69, 0xFF, 0x7B, 0xFF, 0xB5, 0xFF, 0xBC, 0xFF, 0x24, 0xD3, 0xAA, 0xFF, 0xD2, 0xFF, 0xD5, 0xFF, 0xE0, 0xFF, 0xD5,
-    0xFF, 0xEB, 0xFF, 0xEE, 0xFF, 0xFB, 0x41, 0x61, 0xFE, 0xFF, 0x43, 0x65, 0x6F, 0x61, 0xF0, 0x49, 0xF0, 0x49, 0xFB,
-    0xBA, 0x43, 0x2E, 0x61, 0x65, 0xFD, 0x9B, 0xFD, 0xA1, 0xFE, 0xED, 0x43, 0x2E, 0x73, 0x72, 0xFD, 0x91, 0xFD, 0x94,
-    0xFF, 0xF6, 0x48, 0x2E, 0x6D, 0x74, 0x6C, 0x6E, 0x6F, 0x61, 0x65, 0xD3, 0x63, 0xFC, 0xFE, 0xFC, 0xFE, 0xFF, 0xE2,
-    0xFC, 0xE6, 0xFF, 0xF6, 0xFD, 0x8D, 0xE3, 0xDD, 0xA0, 0x05, 0x41, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xFD, 0x21, 0x6E,
-    0xFD, 0x41, 0x6E, 0xFD, 0x65, 0x21, 0xB3, 0xFC, 0x41, 0x65, 0xFE, 0xAD, 0x21, 0x6E, 0xFC, 0x22, 0xC3, 0x6F, 0xF6,
-    0xFD, 0x43, 0x74, 0x61, 0x69, 0xE4, 0xD8, 0xFF, 0xEA, 0xFF, 0xFB, 0x41, 0x72, 0xE4, 0xCE, 0x41, 0x64, 0xFE, 0xBA,
-    0x21, 0x61, 0xFC, 0x21, 0x6E, 0xFD, 0x21, 0x6F, 0xFD, 0x21, 0x69, 0xFD, 0x21, 0x63, 0xFD, 0x42, 0x72, 0x69, 0xE4,
-    0xB7, 0xFF, 0xFD, 0x41, 0x69, 0xE2, 0xB7, 0x41, 0x74, 0xED, 0x7B, 0x43, 0x64, 0x73, 0x74, 0xEA, 0xF2, 0xFF, 0xFC,
-    0xE4, 0xA8, 0x41, 0x73, 0xEC, 0xE8, 0x42, 0x2E, 0x65, 0xD2, 0xF0, 0xFF, 0xFC, 0xA0, 0x08, 0xF1, 0x21, 0x2E, 0xFD,
-    0x22, 0x2E, 0x73, 0xFA, 0xFD, 0x21, 0x6F, 0xFB, 0x21, 0x73, 0xFD, 0x21, 0xAD, 0xFD, 0x53, 0x61, 0x69, 0x73, 0x2E,
-    0x6D, 0x6E, 0x74, 0x72, 0x62, 0x64, 0x6F, 0x63, 0x65, 0x66, 0x67, 0x70, 0x75, 0x6C, 0xC3, 0xFE, 0x25, 0xFE, 0x38,
-    0xFE, 0x59, 0xD2, 0xD2, 0xFE, 0x81, 0xFE, 0x8F, 0xFE, 0x9F, 0xFF, 0x28, 0xFF, 0x4D, 0xFF, 0x6F, 0xFB, 0x0B, 0xFF,
-    0xA7, 0xFF, 0xB1, 0xFF, 0xC8, 0xFF, 0xB1, 0xFF, 0xCF, 0xFF, 0xD7, 0xFF, 0xE5, 0xFF, 0xFD, 0xA0, 0x01, 0xB2, 0x21,
-    0xA1, 0xFD, 0x43, 0xC3, 0x65, 0x73, 0xFF, 0xFD, 0xD2, 0xF0, 0xE3, 0x8C, 0x41, 0x65, 0xEB, 0xDA, 0x21, 0x6C, 0xFC,
-    0x41, 0x65, 0xE4, 0xF6, 0x21, 0x72, 0xFC, 0x21, 0x65, 0xFD, 0x43, 0x2E, 0x63, 0x74, 0xD2, 0x77, 0xFF, 0xF3, 0xFF,
-    0xFD, 0x41, 0x61, 0xD2, 0x6D, 0x21, 0x63, 0xFC, 0x21, 0x6F, 0xFD, 0x41, 0x6F, 0xD5, 0x4C, 0x43, 0x6F, 0x62, 0x69,
-    0xFD, 0xD5, 0xFF, 0xF9, 0xFF, 0xFC, 0xA0, 0x01, 0xB1, 0x21, 0x72, 0xFD, 0x21, 0x62, 0xFD, 0x21, 0x65, 0xFD, 0x43,
-    0x65, 0x6F, 0x72, 0xEC, 0xC5, 0xD6, 0x64, 0xDE, 0x0C, 0x45, 0x2E, 0x68, 0x64, 0x65, 0x74, 0xD2, 0x3F, 0xFF, 0xF3,
-    0xE3, 0xEC, 0xEB, 0xCF, 0xFF, 0xF6, 0xA0, 0x04, 0x13, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0x21, 0x6F, 0xFD, 0x21,
-    0x6D, 0xFD, 0x42, 0x2E, 0x65, 0xFC, 0x44, 0xFF, 0xFD, 0xA0, 0x03, 0xC2, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0x21,
-    0x61, 0xED, 0x22, 0x61, 0x65, 0xEA, 0xEA, 0x46, 0x73, 0x2E, 0x6E, 0x69, 0x62, 0x72, 0xFF, 0xE8, 0xFC, 0x2C, 0xFC,
-    0x2F, 0xFF, 0xF5, 0xFF, 0xF8, 0xFF, 0xFB, 0x45, 0x2E, 0x73, 0x6D, 0x69, 0x6E, 0xFC, 0x19, 0xFC, 0x1C, 0xFD, 0xCD,
-    0xFD, 0x6B, 0xFC, 0x1C, 0x42, 0x73, 0x61, 0xFC, 0x0C, 0xFF, 0xF0, 0x43, 0xA9, 0xA1, 0xAD, 0xFD, 0xD5, 0xFF, 0xD6,
-    0xFF, 0xF9, 0xA0, 0x02, 0xF3, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0x21, 0x6F, 0xFD, 0x21, 0x6D, 0xFD, 0x43, 0x65,
-    0x61, 0x6F, 0xEE, 0x8D, 0xEE, 0x8D, 0xEE, 0x8D, 0x43, 0x2E, 0x73, 0x69, 0xFF, 0xA2, 0xFF, 0xA5, 0xFF, 0xA8, 0x21,
-    0x65, 0xF6, 0xA0, 0x03, 0xE3, 0x21, 0x2E, 0xFD, 0x21, 0x73, 0xFD, 0x24, 0x2E, 0x73, 0x69, 0x6E, 0xF7, 0xFA, 0xFD,
-    0xFA, 0x43, 0x2E, 0x74, 0x65, 0xFF, 0x83, 0xFF, 0xEB, 0xFF, 0xF7, 0x21, 0x6F, 0xEA, 0x41, 0x65, 0xFF, 0x7C, 0x21,
-    0x6E, 0xE0, 0x21, 0x73, 0xDA, 0x25, 0x2E, 0x73, 0x6D, 0x69, 0x6E, 0xD7, 0xDA, 0xF3, 0xFD, 0xDA, 0x22, 0x61, 0x73,
-    0xF5, 0xCF, 0x23, 0x2E, 0x73, 0x69, 0xC7, 0xCA, 0xCD, 0x23, 0x73, 0x2E, 0x6E, 0xC3, 0xC0, 0xC3, 0x23, 0xAD, 0xA9,
-    0xA1, 0xED, 0xF2, 0xF9, 0x45, 0x6D, 0x2E, 0x73, 0x69, 0x6E, 0xFF, 0xCE, 0xFF, 0xB2, 0xFF, 0xB5, 0xFF, 0xB8, 0xFF,
-    0xB5, 0x44, 0x6F, 0xC3, 0x65, 0x61, 0xFF, 0xC5, 0xFF, 0xE9, 0xFF, 0xF0, 0xFF, 0xAB, 0xA0, 0x10, 0x54, 0x21, 0x2E,
-    0xFD, 0x21, 0x65, 0xFD, 0x21, 0x74, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x23, 0x2E, 0x73, 0x6D, 0xEE, 0xF1,
-    0xFD, 0x21, 0x65, 0xF9, 0x42, 0x61, 0x6C, 0xFF, 0x82, 0xFF, 0xFD, 0x42, 0x2E, 0x73, 0xFF, 0x72, 0xFF, 0x75, 0x43,
-    0x2E, 0x61, 0x65, 0xFF, 0x6B, 0xFF, 0xF9, 0xFF, 0x71, 0x43, 0x2E, 0x73, 0x72, 0xFF, 0x61, 0xFF, 0x64, 0xFF, 0xF6,
-    0x43, 0x2E, 0x6F, 0x61, 0xFE, 0xEC, 0xFF, 0xF6, 0xFF, 0xE5, 0x47, 0x73, 0x6D, 0x6E, 0x74, 0x72, 0x62, 0x64, 0xFF,
-    0x5F, 0xFF, 0x69, 0xFE, 0xE5, 0xFF, 0x6C, 0xFF, 0xAB, 0xFF, 0xD4, 0xFF, 0xF6, 0x42, 0x2E, 0x65, 0xFB, 0x09, 0xFC,
-    0x5B, 0x21, 0x64, 0xF9, 0x21, 0x61, 0xFD, 0x21, 0x64, 0xFD, 0x45, 0x2E, 0x65, 0x61, 0x6D, 0x69, 0xFA, 0xF9, 0xFC,
-    0x4B, 0xFA, 0xFF, 0xFB, 0x10, 0xFF, 0xFD, 0x21, 0x72, 0xF0, 0x21, 0x6F, 0xFD, 0x4B, 0xC3, 0x65, 0x2E, 0x6D, 0x74,
-    0x6C, 0x73, 0x6E, 0x6F, 0x61, 0x69, 0xFE, 0xE1, 0xFE, 0xF7, 0xD0, 0xBF, 0xFA, 0x5A, 0xFA, 0x5A, 0xFE, 0xFA, 0xFA,
-    0x5A, 0xFA, 0x42, 0xFC, 0x35, 0xFF, 0xC4, 0xFF, 0xFD, 0x46, 0x2E, 0x6D, 0x74, 0x6C, 0x6E, 0x72, 0xD0, 0x9D, 0xFA,
-    0x38, 0xFA, 0x38, 0xFD, 0x1C, 0xFA, 0x20, 0xFA, 0xCC, 0x41, 0x61, 0xE1, 0x84, 0x21, 0x6C, 0xFC, 0x21, 0x64, 0xFD,
-    0x41, 0x6F, 0xFB, 0x7E, 0x21, 0x74, 0xFC, 0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x21, 0x69, 0xFD, 0x41, 0x2E, 0xE3,
-    0x46, 0x42, 0x2E, 0x73, 0xE3, 0x42, 0xFF, 0xFC, 0x22, 0x6F, 0x61, 0xF9, 0xF9, 0x21, 0x69, 0xFB, 0x23, 0x64, 0x6D,
-    0x63, 0xD7, 0xEA, 0xFD, 0xA0, 0x00, 0x81, 0x21, 0x6F, 0xFD, 0x21, 0x64, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0xA1, 0xFD,
-    0x42, 0x6F, 0x72, 0xD4, 0x62, 0xDC, 0x11, 0xA0, 0x11, 0x92, 0x21, 0x6C, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x69, 0xFD,
-    0x21, 0x72, 0xFD, 0x21, 0x6F, 0xFD, 0x21, 0x74, 0xFD, 0x21, 0x61, 0xFD, 0x44, 0x61, 0x6F, 0x74, 0x75, 0xE0, 0xA2,
-    0xE9, 0x8F, 0xFF, 0xE1, 0xFF, 0xFD, 0x41, 0x6E, 0xE1, 0xC8, 0x42, 0x63, 0x72, 0xE1, 0xC4, 0xE1, 0xC4, 0x42, 0x6D,
-    0x72, 0xD9, 0x69, 0xD4, 0xC3, 0x41, 0x67, 0xD9, 0xBC, 0x42, 0x61, 0x6F, 0xD0, 0x9B, 0xD0, 0x9B, 0x43, 0x61, 0x65,
-    0x6F, 0xD0, 0x94, 0xD0, 0x94, 0xD0, 0x94, 0x21, 0x69, 0xF6, 0x44, 0x61, 0x69, 0x65, 0x6F, 0xD0, 0x87, 0xD0, 0x87,
-    0xD0, 0x87, 0xD0, 0x87, 0x44, 0x6A, 0x67, 0x6C, 0x6D, 0xFF, 0xDF, 0xD9, 0x97, 0xFF, 0xF0, 0xFF, 0xF3, 0x44, 0xA1,
-    0xA9, 0xB3, 0xAD, 0xFF, 0xC7, 0xFF, 0xCE, 0xD8, 0x5C, 0xFF, 0xF3, 0x41, 0x72, 0xDC, 0x2A, 0x21, 0x65, 0xFC, 0x41,
-    0x6D, 0xE2, 0x99, 0x21, 0x75, 0xFC, 0x41, 0x69, 0xD1, 0xE0, 0x44, 0x63, 0x67, 0x6C, 0x6D, 0xFF, 0xF2, 0xD9, 0x83,
-    0xFF, 0xF9, 0xFF, 0xFC, 0x41, 0x74, 0xD2, 0x2C, 0x21, 0xA9, 0xFC, 0x21, 0xC3, 0xFD, 0x41, 0x69, 0xD7, 0xE1, 0x21,
-    0x75, 0xFC, 0x43, 0x63, 0x67, 0x71, 0xD1, 0xB0, 0xFF, 0xF6, 0xFF, 0xFD, 0x43, 0x61, 0xC3, 0x6F, 0xD1, 0xA3, 0xD9,
-    0x2F, 0xD1, 0xA3, 0x41, 0xAD, 0xD1, 0x99, 0x43, 0x65, 0x69, 0xC3, 0xD1, 0x95, 0xD1, 0x95, 0xFF, 0xFC, 0x42, 0x69,
-    0x61, 0xD7, 0x0B, 0xD1, 0x8E, 0x44, 0xA1, 0xAD, 0xA9, 0xB3, 0xD1, 0x84, 0xD1, 0x84, 0xD1, 0x84, 0xD1, 0x84, 0x45,
-    0x61, 0xC3, 0x69, 0x65, 0x6F, 0xD1, 0x77, 0xFF, 0xF3, 0xD1, 0x77, 0xD1, 0x77, 0xD1, 0x77, 0x41, 0x6F, 0xD1, 0xE6,
-    0x25, 0x6A, 0x67, 0x6C, 0x6D, 0x74, 0xC0, 0xCE, 0xD8, 0xEC, 0xFC, 0x41, 0xB3, 0xD1, 0x58, 0x21, 0xC3, 0xFC, 0x21,
-    0x69, 0xFD, 0x41, 0x72, 0xFF, 0x7F, 0x41, 0xA9, 0xD1, 0x4D, 0x43, 0x63, 0x71, 0x73, 0xD1, 0x46, 0xD1, 0x46, 0xD6,
-    0x27, 0x22, 0xC3, 0x69, 0xF2, 0xF6, 0x41, 0x6D, 0xD1, 0xA5, 0x21, 0xA1, 0xFC, 0x22, 0x61, 0xC3, 0xF9, 0xFD, 0x41,
-    0x71, 0xD1, 0x2B, 0x21, 0x73, 0xFC, 0x41, 0x61, 0xD1, 0x35, 0x21, 0x6C, 0xFC, 0x47, 0x62, 0x6E, 0x63, 0x74, 0x67,
-    0x65, 0x70, 0xFF, 0xCC, 0xD8, 0xD5, 0xFF, 0xCF, 0xFF, 0xE1, 0xFF, 0xED, 0xFF, 0xF6, 0xFF, 0xFD, 0x43, 0x72, 0x74,
-    0x63, 0xD1, 0x07, 0xD1, 0x07, 0xD1, 0x07, 0x21, 0x61, 0xF6, 0x42, 0x62, 0x64, 0xD8, 0xB2, 0xFF, 0xFD, 0x41, 0x72,
-    0xD0, 0x12, 0xA0, 0x0D, 0xA1, 0x21, 0x69, 0xFD, 0x21, 0x6C, 0xFD, 0x21, 0x6F, 0xFD, 0x48, 0xC3, 0x61, 0x65, 0x69,
-    0x6F, 0x75, 0x74, 0x70, 0xFE, 0xF9, 0xFF, 0x18, 0xFF, 0x36, 0xFF, 0x80, 0xFF, 0xC6, 0xFF, 0xE9, 0xFF, 0xF0, 0xFF,
-    0xFD, 0x41, 0x72, 0xFA, 0x54, 0x21, 0x74, 0xFC, 0x21, 0x63, 0xFD, 0x21, 0xA9, 0xFD, 0x22, 0x65, 0xC3, 0xFA, 0xFD,
-    0x4F, 0x6F, 0x73, 0x2E, 0x6D, 0x6E, 0x72, 0x64, 0x65, 0x61, 0xC3, 0x63, 0x74, 0x75, 0x78, 0x6C, 0xFC, 0x13, 0xFC,
-    0x2E, 0xCE, 0xA5, 0xFC, 0x46, 0xFC, 0x66, 0xFD, 0xE6, 0xFE, 0x08, 0xFE, 0x22, 0xFE, 0x48, 0xFE, 0x5B, 0xFE, 0x7D,
-    0xFE, 0x8A, 0xFE, 0x8E, 0xFF, 0xD5, 0xFF, 0xFB, 0x43, 0x2E, 0x73, 0x6D, 0xF8, 0x9B, 0xF8, 0x9E, 0xFA, 0x4F, 0xA0,
-    0x03, 0x53, 0x21, 0x2E, 0xFD, 0x22, 0x2E, 0x73, 0xFA, 0xFD, 0xA0, 0x03, 0x84, 0x21, 0x2E, 0xFD, 0x22, 0x2E, 0x73,
-    0xFA, 0xFD, 0x23, 0x65, 0x6F, 0x61, 0xF0, 0xF0, 0xFB, 0x22, 0x2E, 0x6C, 0xE3, 0xF9, 0x21, 0x65, 0xFB, 0x23, 0x65,
-    0x61, 0x6F, 0xE1, 0xE1, 0xE1, 0x23, 0x65, 0x6F, 0x61, 0xDA, 0xDA, 0xDA, 0x21, 0x6C, 0xF9, 0x24, 0x6D, 0x74, 0x6C,
-    0x65, 0xEC, 0xEC, 0xEF, 0xFD, 0x22, 0x2E, 0x6C, 0xC1, 0xED, 0x21, 0x73, 0xFB, 0x21, 0x6F, 0xFD, 0x23, 0x73, 0x6E,
-    0x6F, 0xEC, 0xFD, 0xFA, 0x21, 0x6F, 0xF9, 0x43, 0x73, 0x69, 0x6D, 0xF8, 0x40, 0xF9, 0x8F, 0xFF, 0xFD, 0x21, 0xA1,
-    0xF6, 0x43, 0x6F, 0x61, 0xC3, 0xF8, 0x33, 0xFF, 0x95, 0xFF, 0xFD, 0x41, 0x69, 0xF9, 0x78, 0x21, 0x74, 0xFC, 0x41,
-    0x73, 0xF8, 0xEC, 0x42, 0x2E, 0x65, 0xF8, 0xE5, 0xFF, 0xFC, 0x21, 0x6C, 0xF9, 0x43, 0x69, 0x61, 0x65, 0xFF, 0xEF,
-    0xFF, 0xFD, 0xF8, 0x1C, 0x41, 0x61, 0xEA, 0xAB, 0x42, 0x6F, 0x69, 0xCE, 0x5D, 0xCE, 0xBE, 0x21, 0x6D, 0xF9, 0x41,
-    0x69, 0xCE, 0xB4, 0x21, 0x6D, 0xFC, 0x21, 0xA1, 0xFD, 0x22, 0x61, 0xC3, 0xF3, 0xFD, 0x44, 0x6D, 0x74, 0x6C, 0x6F,
-    0xF6, 0xB8, 0xFF, 0xE3, 0xFF, 0xFB, 0xE7, 0x2D, 0xC3, 0x02, 0x91, 0x61, 0xC3, 0x65, 0xCF, 0xCC, 0xD7, 0x58, 0xCF,
-    0xCC, 0x21, 0x69, 0xF4, 0x21, 0x63, 0xFD, 0xC1, 0x05, 0x81, 0x61, 0xCE, 0x3D, 0x21, 0x69, 0xFA, 0x21, 0x63, 0xFD,
-    0x21, 0xAD, 0xFD, 0xA0, 0x02, 0xB1, 0x21, 0x74, 0xFD, 0x21, 0x73, 0xFD, 0x21, 0xA9, 0xFD, 0x23, 0x62, 0x65, 0xC3,
-    0xF4, 0xFA, 0xFD, 0x21, 0x62, 0xED, 0x21, 0x6C, 0xEA, 0x21, 0x6D, 0xE7, 0x21, 0x69, 0xE7, 0x21, 0x70, 0xFD, 0x21,
-    0x73, 0xFD, 0x25, 0xAD, 0xA1, 0xA9, 0xBA, 0xB3, 0xEE, 0xF1, 0xE1, 0xF4, 0xFD, 0x22, 0x74, 0x69, 0xD0, 0xD0, 0x21,
-    0x6E, 0xCE, 0x21, 0x65, 0xFD, 0x22, 0x73, 0x72, 0xF5, 0xFD, 0x25, 0x69, 0xC3, 0x61, 0x65, 0x75, 0xCC, 0xE5, 0xD6,
-    0xFB, 0xD9, 0x41, 0x75, 0xEA, 0x4B, 0xA0, 0x0B, 0xE3, 0x22, 0x75, 0x74, 0xFD, 0xFD, 0x22, 0x73, 0x64, 0xFB, 0xF8,
-    0xA0, 0x0C, 0x63, 0x21, 0x72, 0xFD, 0xA0, 0x0C, 0x93, 0x21, 0x2E, 0xFD, 0x23, 0x6E, 0x6F, 0x6D, 0xEF, 0xF7, 0xFD,
-    0x41, 0x73, 0xEA, 0x44, 0x21, 0xA9, 0xFC, 0xA0, 0x0A, 0x12, 0x21, 0x72, 0xFD, 0x21, 0x61, 0xFD, 0x21, 0x73, 0xFD,
-    0xA0, 0x0C, 0x42, 0x21, 0x6F, 0xFD, 0x21, 0x6E, 0xFD, 0x21, 0x67, 0xFD, 0x21, 0x65, 0xFD, 0x24, 0x69, 0xC3, 0x65,
-    0x72, 0xD7, 0xE2, 0xEE, 0xFD, 0x21, 0x72, 0xF7, 0x42, 0x65, 0x72, 0xFF, 0xFD, 0xCE, 0x2D, 0x41, 0x72, 0xFC, 0xB4,
-    0x21, 0x74, 0xFC, 0x21, 0x73, 0xFD, 0x21, 0x75, 0xFD, 0x41, 0x72, 0xCD, 0xC6, 0x21, 0x65, 0xFC, 0x21, 0x69, 0xFD,
-    0x21, 0x6E, 0xFD, 0x21, 0x65, 0xFD, 0x4A, 0x69, 0xC3, 0x68, 0x66, 0x6D, 0x74, 0x6F, 0x61, 0x64, 0x67, 0xFF, 0x2D,
-    0xFF, 0x3C, 0xFF, 0x7F, 0xFD, 0xF7, 0xFF, 0x8A, 0xFF, 0xDC, 0xE9, 0x9F, 0xE9, 0x9F, 0xFF, 0xED, 0xFF, 0xFD, 0x41,
-    0x65, 0xD8, 0x86, 0x43, 0x6E, 0x2E, 0x73, 0xD8, 0x7E, 0xF7, 0x21, 0xF7, 0x24, 0x42, 0x6F, 0x61, 0xFF, 0xF6, 0xF7,
-    0x1D, 0x42, 0x2E, 0x73, 0xF8, 0xC5, 0xF8, 0xC8, 0x22, 0x6F, 0x61, 0xF9, 0xF9, 0x41, 0x2E, 0xEE, 0x81, 0x21, 0x73,
-    0xFC, 0x21, 0x65, 0xFD, 0x44, 0x6E, 0x72, 0x2E, 0x73, 0xFF, 0xF1, 0xFF, 0xFD, 0xF7, 0x72, 0xF7, 0x75, 0x41, 0x61,
-    0xDE, 0x29, 0x41, 0x72, 0xF8, 0xA1, 0x42, 0x2E, 0x73, 0xF7, 0x5D, 0xF7, 0x60, 0x4A, 0x67, 0x64, 0x73, 0x6E, 0x62,
-    0x63, 0x61, 0x74, 0x65, 0x6F, 0xFE, 0x65, 0xFE, 0x84, 0xFE, 0xAB, 0xFF, 0x9A, 0xFF, 0xB9, 0xFF, 0xC7, 0xFF, 0xE4,
-    0xFF, 0xF1, 0xFF, 0xF5, 0xFF, 0xF9, 0x41, 0x69, 0xFB, 0xFC, 0x21, 0x72, 0xFC, 0x21, 0x65, 0xFD, 0x41, 0x74, 0xFD,
-    0x68, 0xA0, 0x11, 0xB2, 0x42, 0x64, 0x74, 0xFF, 0xFD, 0xFC, 0x01, 0x21, 0x69, 0xF9, 0x21, 0x73, 0xFD, 0x21, 0x72,
-    0xFD, 0x21, 0x65, 0xFD, 0x21, 0x76, 0xFD, 0x21, 0x69, 0xFD, 0x23, 0x74, 0x6C, 0x6E, 0xDD, 0xE0, 0xFD, 0x5C, 0x62,
-    0x2E, 0x63, 0x64, 0x66, 0x67, 0x68, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x70, 0x71, 0x72, 0x73, 0x74, 0x76, 0x77, 0x78,
-    0x79, 0x7A, 0xC3, 0x6F, 0x61, 0x65, 0x69, 0x75, 0xCD, 0x5C, 0xDB, 0x8C, 0xDD, 0xF1, 0xE3, 0xC6, 0xE4, 0x43, 0xE5,
-    0xC4, 0xE7, 0x42, 0xE7, 0x94, 0xE7, 0xDD, 0xE8, 0x9B, 0xE9, 0xD6, 0xEA, 0x67, 0xED, 0x21, 0xED, 0x83, 0xEE, 0x2C,
-    0xF0, 0x08, 0xF2, 0x7F, 0xF2, 0xDD, 0xF3, 0x29, 0xF3, 0x78, 0xF3, 0xC3, 0xF4, 0x0C, 0xF6, 0x24, 0xF7, 0x4C, 0xF9,
-    0x4F, 0xFD, 0x7C, 0xFF, 0xB0, 0xFF, 0xF9,
-};
-
-constexpr SerializedHyphenationPatterns es_patterns = {
-    es_trie_data,
-    sizeof(es_trie_data),
-};
--- a/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
+++ b/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
@ -40,23 +40,6 @@ bool matches(const char* tag_name, const char* possible_tags[], const int possib
  return false;
 }

-// flush the contents of partWordBuffer to currentTextBlock
-void ChapterHtmlSlimParser::flushPartWordBuffer() {
-  // determine font style
-  EpdFontFamily::Style fontStyle = EpdFontFamily::REGULAR;
-  if (boldUntilDepth < depth && italicUntilDepth < depth) {
-    fontStyle = EpdFontFamily::BOLD_ITALIC;
-  } else if (boldUntilDepth < depth) {
-    fontStyle = EpdFontFamily::BOLD;
-  } else if (italicUntilDepth < depth) {
-    fontStyle = EpdFontFamily::ITALIC;
-  }
-  // flush the buffer
-  partWordBuffer[partWordBufferIndex] = '\0';
-  currentTextBlock->addWord(partWordBuffer, fontStyle);
-  partWordBufferIndex = 0;
-}
-
 // start a new text block if needed
 void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::Style style) {
  if (currentTextBlock) {
@ -84,42 +67,38 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
  if (strcmp(name, "table") == 0) {
    // Add placeholder text
    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
+    if (self->currentTextBlock) {
+      self->currentTextBlock->addWord("[Table omitted]", EpdFontFamily::ITALIC);
+    }

-    self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
-    // Advance depth before processing character data (like you would for a element with text)
+    // Skip table contents
+    self->skipUntilDepth = self->depth;
    self->depth += 1;
-    self->characterData(userData, "[Table omitted]", strlen("[Table omitted]"));
-
-    // Skip table contents (skip until parent as we pre-advanced depth above)
-    self->skipUntilDepth = self->depth - 1;
    return;
  }

  if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
    // TODO: Start processing image tags
-    std::string alt = "[Image]";
+    std::string alt;
    if (atts != nullptr) {
      for (int i = 0; atts[i]; i += 2) {
        if (strcmp(atts[i], "alt") == 0) {
-          if (strlen(atts[i + 1]) > 0) {
-            alt = "[Image: " + std::string(atts[i + 1]) + "]";
-          }
-          break;
+          alt = "[Image: " + std::string(atts[i + 1]) + "]";
        }
      }
+      Serial.printf("[%lu] [EHP] Image alt: %s\n", millis(), alt.c_str());
+
+      self->startNewTextBlock(TextBlock::CENTER_ALIGN);
+      self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
+      self->depth += 1;
+      self->characterData(userData, alt.c_str(), alt.length());
+
+    } else {
+      // Skip for now
+      self->skipUntilDepth = self->depth;
+      self->depth += 1;
+      return;
    }
-
-    Serial.printf("[%lu] [EHP] Image alt: %s\n", millis(), alt.c_str());
-
-    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
-    self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
-    // Advance depth before processing character data (like you would for a element with text)
-    self->depth += 1;
-    self->characterData(userData, alt.c_str(), alt.length());
-
-    // Skip table contents (skip until parent as we pre-advanced depth above)
-    self->skipUntilDepth = self->depth - 1;
-    return;
  }

  if (matches(name, SKIP_TAGS, NUM_SKIP_TAGS)) {
@ -144,43 +123,21 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
  if (matches(name, HEADER_TAGS, NUM_HEADER_TAGS)) {
    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
    self->boldUntilDepth = std::min(self->boldUntilDepth, self->depth);
-    self->depth += 1;
-    return;
-  }
-
-  if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
+  } else if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
    if (strcmp(name, "br") == 0) {
-      if (self->partWordBufferIndex > 0) {
-        // flush word preceding <br/> to currentTextBlock before calling startNewTextBlock
-        self->flushPartWordBuffer();
-      }
      self->startNewTextBlock(self->currentTextBlock->getStyle());
-      self->depth += 1;
-      return;
+    } else {
+      self->startNewTextBlock((TextBlock::Style)self->paragraphAlignment);
+      if (strcmp(name, "li") == 0) {
+        self->currentTextBlock->addWord("\xe2\x80\xa2", EpdFontFamily::REGULAR);
+      }
    }
-
-    self->startNewTextBlock(static_cast<TextBlock::Style>(self->paragraphAlignment));
-    if (strcmp(name, "li") == 0) {
-      self->currentTextBlock->addWord("\xe2\x80\xa2", EpdFontFamily::REGULAR);
-    }
-
-    self->depth += 1;
-    return;
-  }
-
-  if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
+  } else if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
    self->boldUntilDepth = std::min(self->boldUntilDepth, self->depth);
-    self->depth += 1;
-    return;
-  }
-
-  if (matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS)) {
+  } else if (matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS)) {
    self->italicUntilDepth = std::min(self->italicUntilDepth, self->depth);
-    self->depth += 1;
-    return;
  }

-  // Unprocessed tag, just increasing depth and continue forward
  self->depth += 1;
 }

@ -192,11 +149,22 @@ void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char
    return;
  }

+  EpdFontFamily::Style fontStyle = EpdFontFamily::REGULAR;
+  if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+    fontStyle = EpdFontFamily::BOLD_ITALIC;
+  } else if (self->boldUntilDepth < self->depth) {
+    fontStyle = EpdFontFamily::BOLD;
+  } else if (self->italicUntilDepth < self->depth) {
+    fontStyle = EpdFontFamily::ITALIC;
+  }
+
  for (int i = 0; i < len; i++) {
    if (isWhitespace(s[i])) {
      // Currently looking at whitespace, if there's anything in the partWordBuffer, flush it
      if (self->partWordBufferIndex > 0) {
-        self->flushPartWordBuffer();
+        self->partWordBuffer[self->partWordBufferIndex] = '\0';
+        self->currentTextBlock->addWord(self->partWordBuffer, fontStyle);
+        self->partWordBufferIndex = 0;
      }
      // Skip the whitespace char
      continue;
@ -218,7 +186,9 @@ void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char

    // If we're about to run out of space, then cut the word off and start a new one
    if (self->partWordBufferIndex >= MAX_WORD_SIZE) {
-      self->flushPartWordBuffer();
+      self->partWordBuffer[self->partWordBufferIndex] = '\0';
+      self->currentTextBlock->addWord(self->partWordBuffer, fontStyle);
+      self->partWordBufferIndex = 0;
    }

    self->partWordBuffer[self->partWordBufferIndex++] = s[i];
@ -246,11 +216,21 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
    // text styling needs to be overhauled to fix it.
    const bool shouldBreakText =
        matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS) || matches(name, HEADER_TAGS, NUM_HEADER_TAGS) ||
-        matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) ||
-        strcmp(name, "table") == 0 || matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS) || self->depth == 1;
+        matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) || self->depth == 1;

    if (shouldBreakText) {
-      self->flushPartWordBuffer();
+      EpdFontFamily::Style fontStyle = EpdFontFamily::REGULAR;
+      if (self->boldUntilDepth < self->depth && self->italicUntilDepth < self->depth) {
+        fontStyle = EpdFontFamily::BOLD_ITALIC;
+      } else if (self->boldUntilDepth < self->depth) {
+        fontStyle = EpdFontFamily::BOLD;
+      } else if (self->italicUntilDepth < self->depth) {
+        fontStyle = EpdFontFamily::ITALIC;
+      }
+
+      self->partWordBuffer[self->partWordBufferIndex] = '\0';
+      self->currentTextBlock->addWord(self->partWordBuffer, fontStyle);
+      self->partWordBufferIndex = 0;
    }
  }

--- a/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h
+++ b/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h
@ -39,7 +39,6 @@ class ChapterHtmlSlimParser {
  bool hyphenationEnabled;

  void startNewTextBlock(TextBlock::Style style);
-  void flushPartWordBuffer();
  void makePages();
  // XML callbacks
  static void XMLCALL startElement(void* userData, const XML_Char* name, const XML_Char** atts);
--- a/lib/Epub/Epub/parsers/ContentOpfParser.cpp
+++ b/lib/Epub/Epub/parsers/ContentOpfParser.cpp
@ -38,9 +38,6 @@ ContentOpfParser::~ContentOpfParser() {
  if (SdMan.exists((cachePath + itemCacheFile).c_str())) {
    SdMan.remove((cachePath + itemCacheFile).c_str());
  }
-  itemIndex.clear();
-  itemIndex.shrink_to_fit();
-  useItemIndex = false;
 }

 size_t ContentOpfParser::write(const uint8_t data) { return write(&data, 1); }
@ -132,15 +129,6 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
          "[%lu] [COF] Couldn't open temp items file for reading. This is probably going to be a fatal error.\n",
          millis());
    }
-
-    // Sort item index for binary search if we have enough items
-    if (self->itemIndex.size() >= LARGE_SPINE_THRESHOLD) {
-      std::sort(self->itemIndex.begin(), self->itemIndex.end(), [](const ItemIndexEntry& a, const ItemIndexEntry& b) {
-        return a.idHash < b.idHash || (a.idHash == b.idHash && a.idLen < b.idLen);
-      });
-      self->useItemIndex = true;
-      Serial.printf("[%lu] [COF] Using fast index for %zu manifest items\n", millis(), self->itemIndex.size());
-    }
    return;
  }

@ -192,15 +180,6 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
      }
    }

-    // Record index entry for fast lookup later
-    if (self->tempItemStore) {
-      ItemIndexEntry entry;
-      entry.idHash = fnvHash(itemId);
-      entry.idLen = static_cast<uint16_t>(itemId.size());
-      entry.fileOffset = static_cast<uint32_t>(self->tempItemStore.position());
-      self->itemIndex.push_back(entry);
-    }
-
    // Write items down to SD card
    serialization::writeString(self->tempItemStore, itemId);
    serialization::writeString(self->tempItemStore, href);
@ -236,50 +215,19 @@ void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name
      for (int i = 0; atts[i]; i += 2) {
        if (strcmp(atts[i], "idref") == 0) {
          const std::string idref = atts[i + 1];
+          // Resolve the idref to href using items map
+          // TODO: This lookup is slow as need to scan through all items each time.
+          //       It can take up to 200ms per item when getting to 1500 items.
+          self->tempItemStore.seek(0);
+          std::string itemId;
          std::string href;
-          bool found = false;
-
-          if (self->useItemIndex) {
-            // Fast path: binary search
-            uint32_t targetHash = fnvHash(idref);
-            uint16_t targetLen = static_cast<uint16_t>(idref.size());
-
-            auto it = std::lower_bound(self->itemIndex.begin(), self->itemIndex.end(),
-                                       ItemIndexEntry{targetHash, targetLen, 0},
-                                       [](const ItemIndexEntry& a, const ItemIndexEntry& b) {
-                                         return a.idHash < b.idHash || (a.idHash == b.idHash && a.idLen < b.idLen);
-                                       });
-
-            // Check for match (may need to check a few due to hash collisions)
-            while (it != self->itemIndex.end() && it->idHash == targetHash) {
-              self->tempItemStore.seek(it->fileOffset);
-              std::string itemId;
-              serialization::readString(self->tempItemStore, itemId);
-              if (itemId == idref) {
-                serialization::readString(self->tempItemStore, href);
-                found = true;
-                break;
-              }
-              ++it;
+          while (self->tempItemStore.available()) {
+            serialization::readString(self->tempItemStore, itemId);
+            serialization::readString(self->tempItemStore, href);
+            if (itemId == idref) {
+              self->cache->createSpineEntry(href);
+              break;
            }
-          } else {
-            // Slow path: linear scan (for small manifests, keeps original behavior)
-            // TODO: This lookup is slow as need to scan through all items each time.
-            //       It can take up to 200ms per item when getting to 1500 items.
-            self->tempItemStore.seek(0);
-            std::string itemId;
-            while (self->tempItemStore.available()) {
-              serialization::readString(self->tempItemStore, itemId);
-              serialization::readString(self->tempItemStore, href);
-              if (itemId == idref) {
-                found = true;
-                break;
-              }
-            }
-          }
-
-          if (found && self->cache) {
-            self->cache->createSpineEntry(href);
          }
        }
      }
--- a/lib/Epub/Epub/parsers/ContentOpfParser.h
+++ b/lib/Epub/Epub/parsers/ContentOpfParser.h
@ -1,9 +1,6 @@
 #pragma once
 #include <Print.h>

-#include <algorithm>
-#include <vector>
-
 #include "Epub.h"
 #include "expat.h"

@ -31,27 +28,6 @@ class ContentOpfParser final : public Print {
  FsFile tempItemStore;
  std::string coverItemId;

-  // Index for fast idref→href lookup (used only for large EPUBs)
-  struct ItemIndexEntry {
-    uint32_t idHash;      // FNV-1a hash of itemId
-    uint16_t idLen;       // length for collision reduction
-    uint32_t fileOffset;  // offset in .items.bin
-  };
-  std::vector<ItemIndexEntry> itemIndex;
-  bool useItemIndex = false;
-
-  static constexpr uint16_t LARGE_SPINE_THRESHOLD = 400;
-
-  // FNV-1a hash function
-  static uint32_t fnvHash(const std::string& s) {
-    uint32_t hash = 2166136261u;
-    for (char c : s) {
-      hash ^= static_cast<uint8_t>(c);
-      hash *= 16777619u;
-    }
-    return hash;
-  }
-
  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
  static void characterData(void* userData, const XML_Char* s, int len);
  static void endElement(void* userData, const XML_Char* name);
--- a/lib/GfxRenderer/GfxRenderer.cpp
+++ b/lib/GfxRenderer/GfxRenderer.cpp
@ -12,19 +12,20 @@ void GfxRenderer::rotateCoordinates(const int x, const int y, int* rotatedX, int
      // Logical portrait (480x800) → panel (800x480)
      // Rotation: 90 degrees clockwise
      *rotatedX = y;
-      *rotatedY = HalDisplay::DISPLAY_HEIGHT - 1 - x;
+      *rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x;
      break;
    }
    case LandscapeClockwise: {
-      // Logical landscape (800x480) rotated 180 degrees (swap top/bottom and left/right)
-      *rotatedX = HalDisplay::DISPLAY_WIDTH - 1 - x;
-      *rotatedY = HalDisplay::DISPLAY_HEIGHT - 1 - y;
+      // Logical landscape (800x480) rotated 180 degrees (swap top/bottom and
+      // left/right)
+      *rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - x;
+      *rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - y;
      break;
    }
    case PortraitInverted: {
      // Logical portrait (480x800) → panel (800x480)
      // Rotation: 90 degrees counter-clockwise
-      *rotatedX = HalDisplay::DISPLAY_WIDTH - 1 - y;
+      *rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - y;
      *rotatedY = x;
      break;
    }
@ -38,7 +39,7 @@ void GfxRenderer::rotateCoordinates(const int x, const int y, int* rotatedX, int
 }

 void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();

  // Early return if no framebuffer is set
  if (!frameBuffer) {
@ -51,13 +52,14 @@ void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
  rotateCoordinates(x, y, &rotatedX, &rotatedY);

  // Bounds checking against physical panel dimensions
-  if (rotatedX < 0 || rotatedX >= HalDisplay::DISPLAY_WIDTH || rotatedY < 0 || rotatedY >= HalDisplay::DISPLAY_HEIGHT) {
+  if (rotatedX < 0 || rotatedX >= EInkDisplay::DISPLAY_WIDTH || rotatedY < 0 ||
+      rotatedY >= EInkDisplay::DISPLAY_HEIGHT) {
    Serial.printf("[%lu] [GFX] !! Outside range (%d, %d) -> (%d, %d)\n", millis(), x, y, rotatedX, rotatedY);
    return;
  }

  // Calculate byte position and bit position
-  const uint16_t byteIndex = rotatedY * HalDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
+  const uint16_t byteIndex = rotatedY * EInkDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
  const uint8_t bitPosition = 7 - (rotatedX % 8);  // MSB first

  if (state) {
@ -68,7 +70,7 @@ void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
 }

 bool GfxRenderer::readPixel(const int x, const int y) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer) {
    return false;
  }
@ -78,11 +80,12 @@ bool GfxRenderer::readPixel(const int x, const int y) const {
  rotateCoordinates(x, y, &rotatedX, &rotatedY);

  // Bounds checking against physical panel dimensions
-  if (rotatedX < 0 || rotatedX >= HalDisplay::DISPLAY_WIDTH || rotatedY < 0 || rotatedY >= HalDisplay::DISPLAY_HEIGHT) {
+  if (rotatedX < 0 || rotatedX >= EInkDisplay::DISPLAY_WIDTH || rotatedY < 0 ||
+      rotatedY >= EInkDisplay::DISPLAY_HEIGHT) {
    return false;
  }

-  const uint16_t byteIndex = rotatedY * HalDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
+  const uint16_t byteIndex = rotatedY * EInkDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
  const uint8_t bitPosition = 7 - (rotatedX % 8);

  // Bit cleared = black, bit set = white
@ -166,7 +169,7 @@ void GfxRenderer::drawRect(const int x, const int y, const int width, const int
 }

 void GfxRenderer::fillRect(const int x, const int y, const int width, const int height, const bool state) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer) {
    return;
  }
@ -192,8 +195,8 @@ void GfxRenderer::fillRect(const int x, const int y, const int width, const int
      const uint8_t mask = 1 << physXBit;

      for (int sx = x1; sx <= x2; sx++) {
-        const int physY = HalDisplay::DISPLAY_HEIGHT - 1 - sx;
-        const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + physXByte;
+        const int physY = EInkDisplay::DISPLAY_HEIGHT - 1 - sx;
+        const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + physXByte;

        if (state) {
          frameBuffer[byteIndex] &= ~mask;  // Black
@ -208,14 +211,14 @@ void GfxRenderer::fillRect(const int x, const int y, const int width, const int
  // Optimized path for PortraitInverted
  if (orientation == PortraitInverted) {
    for (int sy = y1; sy <= y2; sy++) {
-      const int physX = HalDisplay::DISPLAY_WIDTH - 1 - sy;
+      const int physX = EInkDisplay::DISPLAY_WIDTH - 1 - sy;
      const uint8_t physXByte = physX / 8;
      const uint8_t physXBit = 7 - (physX % 8);
      const uint8_t mask = 1 << physXBit;

      for (int sx = x1; sx <= x2; sx++) {
        const int physY = sx;
-        const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + physXByte;
+        const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + physXByte;

        if (state) {
          frameBuffer[byteIndex] &= ~mask;
@ -231,7 +234,7 @@ void GfxRenderer::fillRect(const int x, const int y, const int width, const int
  if (orientation == LandscapeCounterClockwise) {
    for (int sy = y1; sy <= y2; sy++) {
      const int physY = sy;
-      const uint16_t rowOffset = physY * HalDisplay::DISPLAY_WIDTH_BYTES;
+      const uint16_t rowOffset = physY * EInkDisplay::DISPLAY_WIDTH_BYTES;

      // Fill full bytes where possible
      const int physX1 = x1;
@ -284,6 +287,7 @@ void GfxRenderer::fillRectDithered(const int x, const int y, const int width, co
  }

  // Use ordered dithering (Bayer matrix 2x2)
+  // Gray levels: 0x00=black, 0x55=25%, 0xAA=50%, 0xD5=75%, 0xFF=white
  const int screenWidth = getScreenWidth();
  const int screenHeight = getScreenHeight();

@ -294,8 +298,11 @@ void GfxRenderer::fillRectDithered(const int x, const int y, const int width, co

  if (x1 > x2 || y1 > y2) return;

-  int threshold = (grayLevel * 4) / 255;
+  // Determine threshold based on gray level
+  // Lower gray = more black pixels, higher gray = more white pixels
+  int threshold = (grayLevel * 4) / 255;  // 0-4 range

+  // 2x2 Bayer matrix thresholds: 0, 2, 3, 1
  for (int sy = y1; sy <= y2; sy++) {
    for (int sx = x1; sx <= x2; sx++) {
      int bayerValue;
@ -310,6 +317,7 @@ void GfxRenderer::fillRectDithered(const int x, const int y, const int width, co
      else
        bayerValue = 1;

+      // Draw black if bayer value < threshold (inverted for darker = more black)
      bool isBlack = bayerValue >= threshold;
      drawPixel(sx, sy, isBlack);
    }
@ -324,26 +332,32 @@ void GfxRenderer::drawRoundedRect(const int x, const int y, const int width, con
  }

  int r = std::min(radius, std::min(width / 2, height / 2));
+
+  // Draw 4 corner arcs using midpoint circle algorithm
  int cx, cy;
  int px = 0, py = r;
  int d = 1 - r;

  while (px <= py) {
+    // Top-left corner
    cx = x + r;
    cy = y + r;
    drawPixel(cx - py, cy - px, state);
    drawPixel(cx - px, cy - py, state);

+    // Top-right corner
    cx = x + width - 1 - r;
    cy = y + r;
    drawPixel(cx + py, cy - px, state);
    drawPixel(cx + px, cy - py, state);

+    // Bottom-left corner
    cx = x + r;
    cy = y + height - 1 - r;
    drawPixel(cx - py, cy + px, state);
    drawPixel(cx - px, cy + py, state);

+    // Bottom-right corner
    cx = x + width - 1 - r;
    cy = y + height - 1 - r;
    drawPixel(cx + py, cy + px, state);
@ -358,10 +372,11 @@ void GfxRenderer::drawRoundedRect(const int x, const int y, const int width, con
    px++;
  }

-  drawLine(x + r, y, x + width - 1 - r, y, state);
-  drawLine(x + r, y + height - 1, x + width - 1 - r, y + height - 1, state);
-  drawLine(x, y + r, x, y + height - 1 - r, state);
-  drawLine(x + width - 1, y + r, x + width - 1, y + height - 1 - r, state);
+  // Draw straight edges
+  drawLine(x + r, y, x + width - 1 - r, y, state);                            // Top
+  drawLine(x + r, y + height - 1, x + width - 1 - r, y + height - 1, state);  // Bottom
+  drawLine(x, y + r, x, y + height - 1 - r, state);                           // Left
+  drawLine(x + width - 1, y + r, x + width - 1, y + height - 1 - r, state);   // Right
 }

 void GfxRenderer::fillRoundedRect(const int x, const int y, const int width, const int height, const int radius,
@ -372,19 +387,27 @@ void GfxRenderer::fillRoundedRect(const int x, const int y, const int width, con
  }

  int r = std::min(radius, std::min(width / 2, height / 2));
+
+  // Fill the center rectangle
  fillRect(x + r, y, width - 2 * r, height, state);
+
+  // Fill left and right rectangles (excluding corners)
  fillRect(x, y + r, r, height - 2 * r, state);
  fillRect(x + width - r, y + r, r, height - 2 * r, state);

+  // Fill corners using circle algorithm
  int px = 0, py = r;
  int d = 1 - r;

  while (px <= py) {
+    // Fill horizontal lines for each corner
+    // Top-left and top-right
    drawLine(x + r - py, y + r - px, x + r, y + r - px, state);
    drawLine(x + width - 1 - r, y + r - px, x + width - 1 - r + py, y + r - px, state);
    drawLine(x + r - px, y + r - py, x + r, y + r - py, state);
    drawLine(x + width - 1 - r, y + r - py, x + width - 1 - r + px, y + r - py, state);

+    // Bottom-left and bottom-right
    drawLine(x + r - py, y + height - 1 - r + px, x + r, y + height - 1 - r + px, state);
    drawLine(x + width - 1 - r, y + height - 1 - r + px, x + width - 1 - r + py, y + height - 1 - r + px, state);
    drawLine(x + r - px, y + height - 1 - r + py, x + r, y + height - 1 - r + py, state);
@ -419,29 +442,37 @@ void GfxRenderer::fillRoundedRectDithered(const int x, const int y, const int wi

  const int screenWidth = getScreenWidth();
  const int screenHeight = getScreenHeight();
+
  int threshold = (grayLevel * 4) / 255;

+  // Check if a point is inside the rounded rectangle
  auto isInside = [&](int px, int py) -> bool {
+    // Check corners
    if (px < x + r && py < y + r) {
+      // Top-left corner
      int dx = px - (x + r);
      int dy = py - (y + r);
      return (dx * dx + dy * dy) <= r * r;
    }
    if (px >= x + width - r && py < y + r) {
+      // Top-right corner
      int dx = px - (x + width - 1 - r);
      int dy = py - (y + r);
      return (dx * dx + dy * dy) <= r * r;
    }
    if (px < x + r && py >= y + height - r) {
+      // Bottom-left corner
      int dx = px - (x + r);
      int dy = py - (y + height - 1 - r);
      return (dx * dx + dy * dy) <= r * r;
    }
    if (px >= x + width - r && py >= y + height - r) {
+      // Bottom-right corner
      int dx = px - (x + width - 1 - r);
      int dy = py - (y + height - 1 - r);
      return (dx * dx + dy * dy) <= r * r;
    }
+    // Inside the non-corner region
    return px >= x && px < x + width && py >= y && py < y + height;
  };

@ -473,26 +504,11 @@ void GfxRenderer::fillRoundedRectDithered(const int x, const int y, const int wi
 }

 void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, const int width, const int height) const {
+  // TODO: Rotate bits
  int rotatedX = 0;
  int rotatedY = 0;
  rotateCoordinates(x, y, &rotatedX, &rotatedY);
-  // Rotate origin corner
-  switch (orientation) {
-    case Portrait:
-      rotatedY = rotatedY - height;
-      break;
-    case PortraitInverted:
-      rotatedX = rotatedX - width;
-      break;
-    case LandscapeClockwise:
-      rotatedY = rotatedY - height;
-      rotatedX = rotatedX - width;
-      break;
-    case LandscapeCounterClockwise:
-      break;
-  }
-  // TODO: Rotate bits
-  display.drawImage(bitmap, rotatedX, rotatedY, width, height);
+  einkDisplay.drawImage(bitmap, rotatedX, rotatedY, width, height);
 }

 void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight,
@ -596,7 +612,7 @@ void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, con
 }

 void GfxRenderer::draw2BitImage(const uint8_t data[], int x, int y, int w, int h) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer) {
    return;
  }
@ -629,8 +645,8 @@ void GfxRenderer::draw2BitImage(const uint8_t data[], int x, int y, int w, int h
        // 2=LightGray, 3=White -> Treat as White
        if (val < 2) {
          // In Portrait: physical Y = DISPLAY_HEIGHT - 1 - screenX
-          const int physY = HalDisplay::DISPLAY_HEIGHT - 1 - screenX;
-          const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
+          const int physY = EInkDisplay::DISPLAY_HEIGHT - 1 - screenX;
+          const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
          const uint8_t bitPosition = 7 - (physX % 8);
          frameBuffer[byteIndex] &= ~(1 << bitPosition);  // Clear bit = black
        }
@ -656,9 +672,9 @@ void GfxRenderer::draw2BitImage(const uint8_t data[], int x, int y, int w, int h
        if (val < 3) {
          // PortraitInverted: physical X = DISPLAY_WIDTH - 1 - screenY
          // physical Y = screenX
-          const int physX = HalDisplay::DISPLAY_WIDTH - 1 - screenY;
+          const int physX = EInkDisplay::DISPLAY_WIDTH - 1 - screenY;
          const int physY = screenX;
-          const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
+          const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
          const uint8_t bitPosition = 7 - (physX % 8);
          frameBuffer[byteIndex] &= ~(1 << bitPosition);
        }
@ -684,13 +700,13 @@ void GfxRenderer::draw2BitImage(const uint8_t data[], int x, int y, int w, int h
        if (val < 3) {
          int physX, physY;
          if (orientation == LandscapeClockwise) {
-            physX = HalDisplay::DISPLAY_WIDTH - 1 - screenX;
-            physY = HalDisplay::DISPLAY_HEIGHT - 1 - screenY;
+            physX = EInkDisplay::DISPLAY_WIDTH - 1 - screenX;
+            physY = EInkDisplay::DISPLAY_HEIGHT - 1 - screenY;
          } else {
            physX = screenX;
            physY = screenY;
          }
-          const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
+          const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
          const uint8_t bitPosition = 7 - (physX % 8);
          frameBuffer[byteIndex] &= ~(1 << bitPosition);
        }
@ -1045,7 +1061,7 @@ void GfxRenderer::fillPolygon(const int* xPoints, const int* yPoints, int numPoi
 }

 uint8_t* GfxRenderer::captureRegion(int x, int y, int width, int height, size_t* outSize) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer || width <= 0 || height <= 0) {
    if (outSize) *outSize = 0;
    return nullptr;
@ -1101,7 +1117,7 @@ uint8_t* GfxRenderer::captureRegion(int x, int y, int width, int height, size_t*
      rotateCoordinates(screenX, screenY, &physX, &physY);

      // Read pixel from framebuffer
-      const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
+      const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + (physX / 8);
      const uint8_t bitPosition = 7 - (physX % 8);
      const bool isBlack = !(frameBuffer[byteIndex] & (1 << bitPosition));

@ -1117,7 +1133,7 @@ uint8_t* GfxRenderer::captureRegion(int x, int y, int width, int height, size_t*
 }

 void GfxRenderer::restoreRegion(const uint8_t* buffer, int x, int y, int width, int height) const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer || !buffer || width <= 0 || height <= 0) {
    return;
  }
@ -1142,8 +1158,8 @@ void GfxRenderer::restoreRegion(const uint8_t* buffer, int x, int y, int width,
        if (screenX < 0 || screenX >= getScreenWidth()) continue;

        const bool isBlack = !(srcRow[col / 8] & (1 << (7 - (col % 8))));
-        const int physY = HalDisplay::DISPLAY_HEIGHT - 1 - screenX;
-        const uint16_t byteIndex = physY * HalDisplay::DISPLAY_WIDTH_BYTES + physXByte;
+        const int physY = EInkDisplay::DISPLAY_HEIGHT - 1 - screenX;
+        const uint16_t byteIndex = physY * EInkDisplay::DISPLAY_WIDTH_BYTES + physXByte;

        if (isBlack) {
          frameBuffer[byteIndex] &= ~mask;
@ -1168,20 +1184,22 @@ void GfxRenderer::restoreRegion(const uint8_t* buffer, int x, int y, int width,
  }
 }

-void GfxRenderer::clearScreen(const uint8_t color) const { display.clearScreen(color); }
+void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }

 void GfxRenderer::invertScreen() const {
-  uint8_t* buffer = display.getFrameBuffer();
+  uint8_t* buffer = einkDisplay.getFrameBuffer();
  if (!buffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in invertScreen\n", millis());
    return;
  }
-  for (int i = 0; i < HalDisplay::BUFFER_SIZE; i++) {
+  for (int i = 0; i < EInkDisplay::BUFFER_SIZE; i++) {
    buffer[i] = ~buffer[i];
  }
 }

-void GfxRenderer::displayBuffer(const HalDisplay::RefreshMode refreshMode) const { display.displayBuffer(refreshMode); }
+void GfxRenderer::displayBuffer(const EInkDisplay::RefreshMode refreshMode) const {
+  einkDisplay.displayBuffer(refreshMode);
+}

 std::string GfxRenderer::truncatedText(const int fontId, const char* text, const int maxWidth,
                                       const EpdFontFamily::Style style) const {
@ -1201,13 +1219,13 @@ int GfxRenderer::getScreenWidth() const {
    case Portrait:
    case PortraitInverted:
      // 480px wide in portrait logical coordinates
-      return HalDisplay::DISPLAY_HEIGHT;
+      return EInkDisplay::DISPLAY_HEIGHT;
    case LandscapeClockwise:
    case LandscapeCounterClockwise:
      // 800px wide in landscape logical coordinates
-      return HalDisplay::DISPLAY_WIDTH;
+      return EInkDisplay::DISPLAY_WIDTH;
  }
-  return HalDisplay::DISPLAY_HEIGHT;
+  return EInkDisplay::DISPLAY_HEIGHT;
 }

 int GfxRenderer::getScreenHeight() const {
@ -1215,13 +1233,13 @@ int GfxRenderer::getScreenHeight() const {
    case Portrait:
    case PortraitInverted:
      // 800px tall in portrait logical coordinates
-      return HalDisplay::DISPLAY_WIDTH;
+      return EInkDisplay::DISPLAY_WIDTH;
    case LandscapeClockwise:
    case LandscapeCounterClockwise:
      // 480px tall in landscape logical coordinates
-      return HalDisplay::DISPLAY_HEIGHT;
+      return EInkDisplay::DISPLAY_HEIGHT;
  }
-  return HalDisplay::DISPLAY_WIDTH;
+  return EInkDisplay::DISPLAY_WIDTH;
 }

 int GfxRenderer::getSpaceWidth(const int fontId) const {
@ -1425,18 +1443,17 @@ void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y
  }
 }

-uint8_t* GfxRenderer::getFrameBuffer() const { return display.getFrameBuffer(); }
+uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }

-size_t GfxRenderer::getBufferSize() { return HalDisplay::BUFFER_SIZE; }
+size_t GfxRenderer::getBufferSize() { return EInkDisplay::BUFFER_SIZE; }

-// unused
-// void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); }
+void GfxRenderer::grayscaleRevert() const { einkDisplay.grayscaleRevert(); }

-void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(display.getFrameBuffer()); }
+void GfxRenderer::copyGrayscaleLsbBuffers() const { einkDisplay.copyGrayscaleLsbBuffers(einkDisplay.getFrameBuffer()); }

-void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(display.getFrameBuffer()); }
+void GfxRenderer::copyGrayscaleMsbBuffers() const { einkDisplay.copyGrayscaleMsbBuffers(einkDisplay.getFrameBuffer()); }

-void GfxRenderer::displayGrayBuffer() const { display.displayGrayBuffer(); }
+void GfxRenderer::displayGrayBuffer() const { einkDisplay.displayGrayBuffer(); }

 void GfxRenderer::freeBwBufferChunks() {
  for (auto& bwBufferChunk : bwBufferChunks) {
@ -1455,7 +1472,7 @@ void GfxRenderer::freeBwBufferChunks() {
 * allocation failed.
 */
 bool GfxRenderer::storeBwBuffer() {
-  const uint8_t* frameBuffer = display.getFrameBuffer();
+  const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in storeBwBuffer\n", millis());
    return false;
@ -1512,7 +1529,7 @@ void GfxRenderer::restoreBwBuffer() {
    return;
  }

-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (!frameBuffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in restoreBwBuffer\n", millis());
    freeBwBufferChunks();
@ -1531,7 +1548,7 @@ void GfxRenderer::restoreBwBuffer() {
    memcpy(frameBuffer + offset, bwBufferChunks[i], BW_BUFFER_CHUNK_SIZE);
  }

-  display.cleanupGrayscaleBuffers(frameBuffer);
+  einkDisplay.cleanupGrayscaleBuffers(frameBuffer);

  freeBwBufferChunks();
  Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
@ -1542,9 +1559,9 @@ void GfxRenderer::restoreBwBuffer() {
 * Use this when BW buffer was re-rendered instead of stored/restored.
 */
 void GfxRenderer::cleanupGrayscaleWithFrameBuffer() const {
-  uint8_t* frameBuffer = display.getFrameBuffer();
+  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  if (frameBuffer) {
-    display.cleanupGrayscaleBuffers(frameBuffer);
+    einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
  }
 }

--- a/lib/GfxRenderer/GfxRenderer.h
+++ b/lib/GfxRenderer/GfxRenderer.h
@ -1,7 +1,7 @@
 #pragma once

+#include <EInkDisplay.h>
 #include <EpdFontFamily.h>
-#include <HalDisplay.h>

 #include <map>

@ -23,11 +23,11 @@ class GfxRenderer {

 private:
  static constexpr size_t BW_BUFFER_CHUNK_SIZE = 8000;  // 8KB chunks to allow for non-contiguous memory
-  static constexpr size_t BW_BUFFER_NUM_CHUNKS = HalDisplay::BUFFER_SIZE / BW_BUFFER_CHUNK_SIZE;
-  static_assert(BW_BUFFER_CHUNK_SIZE * BW_BUFFER_NUM_CHUNKS == HalDisplay::BUFFER_SIZE,
+  static constexpr size_t BW_BUFFER_NUM_CHUNKS = EInkDisplay::BUFFER_SIZE / BW_BUFFER_CHUNK_SIZE;
+  static_assert(BW_BUFFER_CHUNK_SIZE * BW_BUFFER_NUM_CHUNKS == EInkDisplay::BUFFER_SIZE,
                "BW buffer chunking does not line up with display buffer size");

-  HalDisplay& display;
+  EInkDisplay& einkDisplay;
  RenderMode renderMode;
  Orientation orientation;
  uint8_t* bwBufferChunks[BW_BUFFER_NUM_CHUNKS] = {nullptr};
@ -38,7 +38,7 @@ class GfxRenderer {
  void rotateCoordinates(int x, int y, int* rotatedX, int* rotatedY) const;

 public:
-  explicit GfxRenderer(HalDisplay& halDisplay) : display(halDisplay), renderMode(BW), orientation(Portrait) {}
+  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), renderMode(BW), orientation(Portrait) {}
  ~GfxRenderer() { freeBwBufferChunks(); }

  static constexpr int VIEWABLE_MARGIN_TOP = 9;
@ -57,7 +57,7 @@ class GfxRenderer {
  // Screen ops
  int getScreenWidth() const;
  int getScreenHeight() const;
-  void displayBuffer(HalDisplay::RefreshMode refreshMode = HalDisplay::FAST_REFRESH) const;
+  void displayBuffer(EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH) const;
  // EXPERIMENTAL: Windowed update - display only a rectangular region
  void displayWindow(int x, int y, int width, int height) const;
  void invertScreen() const;
@ -76,9 +76,10 @@ class GfxRenderer {
  void drawImage(const uint8_t bitmap[], int x, int y, int width, int height) const;
  void drawBitmap(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight, float cropX = 0,
                  float cropY = 0) const;
-  void drawBitmap1Bit(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight) const;
-  void drawTransparentBitmap(const Bitmap& bitmap, int x, int y, int w, int h) const;
-  void drawRoundedBitmap(const Bitmap& bitmap, int x, int y, int w, int h, int radius) const;
+  void drawBitmap1Bit(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight) const;
+  void drawTransparentBitmap(const Bitmap& bitmap, const int x, const int y, const int w, const int h) const;
+  void drawRoundedBitmap(const Bitmap& bitmap, const int x, const int y, const int w, const int h,
+                         const int radius) const;
  void draw2BitImage(const uint8_t data[], int x, int y, int w, int h) const;
  void fillPolygon(const int* xPoints, const int* yPoints, int numPoints, bool state = true) const;

--- a/lib/KOReaderSync/KOReaderDocumentId.cpp
+++ b/lib/KOReaderSync/KOReaderDocumentId.cpp
@ -33,10 +33,10 @@ std::string KOReaderDocumentId::calculateFromFilename(const std::string& filePat

 size_t KOReaderDocumentId::getOffset(int i) {
  // Offset = 1024 << (2*i)
-  // For i = -1: KOReader uses a value of 0
+  // For i = -1: 1024 >> 2 = 256
  // For i >= 0: 1024 << (2*i)
  if (i < 0) {
-    return 0;
+    return CHUNK_SIZE >> (-2 * i);
  }
  return CHUNK_SIZE << (2 * i);
 }
--- a/lib/ThemeEngine/include/BasicElements.h
+++ b/lib/ThemeEngine/include/BasicElements.h
@ -11,22 +11,6 @@

 namespace ThemeEngine {

-// Safe integer parsing (no exceptions)
-inline int parseIntSafe(const std::string& s, int defaultVal = 0) {
-  if (s.empty()) return defaultVal;
-  char* end;
-  long val = strtol(s.c_str(), &end, 10);
-  return (end != s.c_str()) ? static_cast<int>(val) : defaultVal;
-}
-
-// Safe float parsing (no exceptions)
-inline float parseFloatSafe(const std::string& s, float defaultVal = 0.0f) {
-  if (s.empty()) return defaultVal;
-  char* end;
-  float val = strtof(s.c_str(), &end);
-  return (end != s.c_str()) ? val : defaultVal;
-}
-
 // --- Container ---
 class Container : public UIElement {
 protected:
@ -40,17 +24,16 @@ class Container : public UIElement {

 public:
  explicit Container(const std::string& id) : UIElement(id), bgColorExpr(Expression::parse("0xFF")) {}
-  virtual ~Container() = default;
+  virtual ~Container() {
+    for (auto child : children) delete child;
+  }

  Container* asContainer() override { return this; }

  ElementType getType() const override { return ElementType::Container; }
-  const char* getTypeName() const override { return "Container"; }

  void addChild(UIElement* child) { children.push_back(child); }

-  void clearChildren() { children.clear(); }
-
  const std::vector<UIElement*>& getChildren() const { return children; }

  void setBackgroundColorExpr(const std::string& expr) {
@ -104,7 +87,55 @@ class Container : public UIElement {
    }
  }

-  void draw(const GfxRenderer& renderer, const ThemeContext& context) override;
+  void draw(const GfxRenderer& renderer, const ThemeContext& context) override {
+    if (!isVisible(context)) return;
+
+    if (hasBg) {
+      std::string colStr = context.evaluatestring(bgColorExpr);
+      uint8_t color = Color::parse(colStr).value;
+      // Use dithered fill for grayscale values, solid fill for black/white
+      // Use rounded rect if borderRadius > 0
+      if (color == 0x00) {
+        if (borderRadius > 0) {
+          renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, true);
+        } else {
+          renderer.fillRect(absX, absY, absW, absH, true);
+        }
+      } else if (color >= 0xF0) {
+        if (borderRadius > 0) {
+          renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, false);
+        } else {
+          renderer.fillRect(absX, absY, absW, absH, false);
+        }
+      } else {
+        if (borderRadius > 0) {
+          renderer.fillRoundedRectDithered(absX, absY, absW, absH, borderRadius, color);
+        } else {
+          renderer.fillRectDithered(absX, absY, absW, absH, color);
+        }
+      }
+    }
+
+    // Handle dynamic border expression
+    bool drawBorder = border;
+    if (hasBorderExpr()) {
+      drawBorder = context.evaluateBool(borderExpr.rawExpr);
+    }
+
+    if (drawBorder) {
+      if (borderRadius > 0) {
+        renderer.drawRoundedRect(absX, absY, absW, absH, borderRadius, true);
+      } else {
+        renderer.drawRect(absX, absY, absW, absH, true);
+      }
+    }
+
+    for (auto child : children) {
+      child->draw(renderer, context);
+    }
+
+    markClean();
+  }
 };

 // --- Rectangle ---
@ -112,12 +143,10 @@ class Rectangle : public UIElement {
  bool fill = false;
  Expression fillExpr;  // Dynamic fill based on expression
  Expression colorExpr;
-  int borderRadius = 0;

 public:
  explicit Rectangle(const std::string& id) : UIElement(id), colorExpr(Expression::parse("0x00")) {}
  ElementType getType() const override { return ElementType::Rectangle; }
-  const char* getTypeName() const override { return "Rectangle"; }

  void setFill(bool f) {
    fill = f;
@ -134,12 +163,26 @@ class Rectangle : public UIElement {
    markDirty();
  }

-  void setBorderRadius(int r) {
-    borderRadius = r;
-    markDirty();
-  }
+  void draw(const GfxRenderer& renderer, const ThemeContext& context) override {
+    if (!isVisible(context)) return;

-  void draw(const GfxRenderer& renderer, const ThemeContext& context) override;
+    std::string colStr = context.evaluatestring(colorExpr);
+    uint8_t color = Color::parse(colStr).value;
+    bool black = (color == 0x00);
+
+    bool shouldFill = fill;
+    if (!fillExpr.empty()) {
+      shouldFill = context.evaluateBool(fillExpr.rawExpr);
+    }
+
+    if (shouldFill) {
+      renderer.fillRect(absX, absY, absW, absH, black);
+    } else {
+      renderer.drawRect(absX, absY, absW, absH, black);
+    }
+
+    markClean();
+  }
 };

 // --- Label ---
@ -158,7 +201,6 @@ class Label : public UIElement {
 public:
  explicit Label(const std::string& id) : UIElement(id), colorExpr(Expression::parse("0x00")) {}
  ElementType getType() const override { return ElementType::Label; }
-  const char* getTypeName() const override { return "Label"; }

  void setText(const std::string& expr) {
    textExpr = Expression::parse(expr);
@ -189,7 +231,132 @@ class Label : public UIElement {
    markDirty();
  }

-  void draw(const GfxRenderer& renderer, const ThemeContext& context) override;
+  void draw(const GfxRenderer& renderer, const ThemeContext& context) override {
+    if (!isVisible(context)) return;
+
+    std::string finalText = context.evaluatestring(textExpr);
+    if (finalText.empty()) {
+      markClean();
+      return;
+    }
+
+    std::string colStr = context.evaluatestring(colorExpr);
+    uint8_t color = Color::parse(colStr).value;
+    bool black = (color == 0x00);
+
+    int textWidth = renderer.getTextWidth(fontId, finalText.c_str());
+    int lineHeight = renderer.getLineHeight(fontId);
+
+    // Split text into lines based on width
+    std::vector<std::string> lines;
+    if (absW > 0 && textWidth > absW && maxLines > 1) {
+      // Logic to wrap text
+      std::string remaining = finalText;
+      while (!remaining.empty() && (int)lines.size() < maxLines) {
+        // If it fits, add entire line
+        if (renderer.getTextWidth(fontId, remaining.c_str()) <= absW) {
+          lines.push_back(remaining);
+          break;
+        }
+
+        // Binary search for cut point
+        int len = remaining.length();
+        int cut = len;
+
+        // Find split point
+        // Optimistic start: approximate chars that fit
+        int avgCharWidth = renderer.getTextWidth(fontId, "a");
+        if (avgCharWidth < 1) avgCharWidth = 8;
+        int approxChars = absW / avgCharWidth;
+        if (approxChars < 1) approxChars = 1;
+        if (approxChars >= len) approxChars = len - 1;
+
+        // Refine from approxChars
+        int w = renderer.getTextWidth(fontId, remaining.substr(0, approxChars).c_str());
+        if (w < absW) {
+          // Grow
+          for (int i = approxChars; i <= len; i++) {
+            if (renderer.getTextWidth(fontId, remaining.substr(0, i).c_str()) > absW) {
+              cut = i - 1;
+              break;
+            }
+            cut = i;
+          }
+        } else {
+          // Shrink
+          for (int i = approxChars; i > 0; i--) {
+            if (renderer.getTextWidth(fontId, remaining.substr(0, i).c_str()) <= absW) {
+              cut = i;
+              break;
+            }
+          }
+        }
+
+        // Find last space before cut
+        if (cut < (int)remaining.length()) {
+          int space = -1;
+          for (int i = cut; i > 0; i--) {
+            if (remaining[i] == ' ') {
+              space = i;
+              break;
+            }
+          }
+          if (space != -1) cut = space;
+        }
+
+        std::string line = remaining.substr(0, cut);
+
+        // If we're at the last allowed line but still have more text
+        if ((int)lines.size() == maxLines - 1 && cut < (int)remaining.length()) {
+          if (ellipsis) {
+            line = renderer.truncatedText(fontId, remaining.c_str(), absW);
+          }
+          lines.push_back(line);
+          break;
+        }
+
+        lines.push_back(line);
+        // Advance
+        if (cut < (int)remaining.length()) {
+          // Skip the space if check
+          if (remaining[cut] == ' ') cut++;
+          remaining = remaining.substr(cut);
+        } else {
+          remaining = "";
+        }
+      }
+    } else {
+      // Single line handling (truncate if needed)
+      if (ellipsis && textWidth > absW && absW > 0) {
+        finalText = renderer.truncatedText(fontId, finalText.c_str(), absW);
+      }
+      lines.push_back(finalText);
+    }
+
+    // Draw lines
+    int totalTextHeight = lines.size() * lineHeight;
+    int startY = absY;
+
+    // Vertical centering
+    if (absH > 0 && totalTextHeight < absH) {
+      startY = absY + (absH - totalTextHeight) / 2;
+    }
+
+    for (size_t i = 0; i < lines.size(); i++) {
+      int lineWidth = renderer.getTextWidth(fontId, lines[i].c_str());
+      int drawX = absX;
+
+      if (alignment == Alignment::Center && absW > 0) {
+        drawX = absX + (absW - lineWidth) / 2;
+      } else if (alignment == Alignment::Right && absW > 0) {
+        drawX = absX + absW - lineWidth;
+      }
+
+      renderer.drawText(fontId, drawX, startY + i * lineHeight, lines[i].c_str(), black);
+    }
+
+    markClean();
+  }
 };

 // --- BitmapElement ---
@ -204,7 +371,6 @@ class BitmapElement : public UIElement {
    cacheable = true;  // Bitmaps benefit from caching
  }
  ElementType getType() const override { return ElementType::Bitmap; }
-  const char* getTypeName() const override { return "Bitmap"; }

  void setSrc(const std::string& src) {
    srcExpr = Expression::parse(src);
@ -250,7 +416,6 @@ class ProgressBar : public UIElement {
  {}

  ElementType getType() const override { return ElementType::ProgressBar; }
-  const char* getTypeName() const override { return "ProgressBar"; }

  void setValue(const std::string& expr) {
    valueExpr = Expression::parse(expr);
@ -279,8 +444,8 @@ class ProgressBar : public UIElement {
    std::string valStr = context.evaluatestring(valueExpr);
    std::string maxStr = context.evaluatestring(maxExpr);

-    int value = parseIntSafe(valStr, 0);
-    int maxVal = parseIntSafe(maxStr, 100);
+    int value = valStr.empty() ? 0 : std::stoi(valStr);
+    int maxVal = maxStr.empty() ? 100 : std::stoi(maxStr);
    if (maxVal <= 0) maxVal = 100;

    float ratio = static_cast<float>(value) / static_cast<float>(maxVal);
@ -319,7 +484,6 @@ class Divider : public UIElement {
  explicit Divider(const std::string& id) : UIElement(id), colorExpr(Expression::parse("0x00")) {}

  ElementType getType() const override { return ElementType::Divider; }
-  const char* getTypeName() const override { return "Divider"; }

  void setColorExpr(const std::string& expr) {
    colorExpr = Expression::parse(expr);
@ -367,7 +531,6 @@ class BatteryIcon : public UIElement {
  }

  ElementType getType() const override { return ElementType::BatteryIcon; }
-  const char* getTypeName() const override { return "BatteryIcon"; }

  void setValue(const std::string& expr) {
    valueExpr = Expression::parse(expr);
@ -383,7 +546,7 @@ class BatteryIcon : public UIElement {
    if (!isVisible(context)) return;

    std::string valStr = context.evaluatestring(valueExpr);
-    int percentage = parseIntSafe(valStr, 0);
+    int percentage = valStr.empty() ? 0 : std::stoi(valStr);

    std::string colStr = context.evaluatestring(colorExpr);
    uint8_t color = Color::parse(colStr).value;
--- a/lib/ThemeEngine/include/LayoutElements.h
+++ b/lib/ThemeEngine/include/LayoutElements.h
@ -12,18 +12,13 @@ namespace ThemeEngine {
 // --- HStack: Horizontal Stack Layout ---
 // Children are arranged horizontally with optional spacing
 class HStack : public Container {
- public:
-  enum class VAlign { Top, Center, Bottom };
-
- private:
  int spacing = 0;  // Gap between children
  int padding = 0;  // Internal padding
-  VAlign vAlign = VAlign::Top;
+  bool centerVertical = false;

 public:
  HStack(const std::string& id) : Container(id) {}
  ElementType getType() const override { return ElementType::HStack; }
-  const char* getTypeName() const override { return "HStack"; }

  void setSpacing(int s) {
    spacing = s;
@ -33,18 +28,8 @@ class HStack : public Container {
    padding = p;
    markDirty();
  }
-  void setVAlign(VAlign a) {
-    vAlign = a;
-    markDirty();
-  }
-  void setVAlignFromString(const std::string& s) {
-    if (s == "center" || s == "Center") {
-      vAlign = VAlign::Center;
-    } else if (s == "bottom" || s == "Bottom") {
-      vAlign = VAlign::Bottom;
-    } else {
-      vAlign = VAlign::Top;
-    }
+  void setCenterVertical(bool c) {
+    centerVertical = c;
    markDirty();
  }

@ -62,34 +47,13 @@ class HStack : public Container {
      int childW = child->getAbsW();
      int childH = child->getAbsH();

-      // Extract child's own Y offset (from first layout pass)
-      int childYOffset = child->getAbsY() - (absY + padding);
-
-      // Calculate base position based on vertical alignment
+      // Re-layout with proper position
      int childY = absY + padding;
-      if (childH < availableH) {
-        switch (vAlign) {
-          case VAlign::Center:
-            childY = absY + padding + (availableH - childH) / 2;
-            break;
-          case VAlign::Bottom:
-            childY = absY + padding + (availableH - childH);
-            break;
-          case VAlign::Top:
-          default:
-            childY = absY + padding;
-            break;
-        }
+      if (centerVertical && childH < availableH) {
+        childY = absY + padding + (availableH - childH) / 2;
      }

-      // Add child's own Y offset to the calculated position
-      childY += childYOffset;
-
-      // Only do second layout pass if position changed from first pass
-      int firstPassY = child->getAbsY();
-      if (childY != firstPassY) {
-        child->layout(context, currentX, childY, childW, childH);
-      }
+      child->layout(context, currentX, childY, childW, childH);
      currentX += childW + spacing;
      availableW -= (childW + spacing);
      if (availableW < 0) availableW = 0;
@ -100,18 +64,13 @@ class HStack : public Container {
 // --- VStack: Vertical Stack Layout ---
 // Children are arranged vertically with optional spacing
 class VStack : public Container {
- public:
-  enum class HAlign { Left, Center, Right };
-
- private:
  int spacing = 0;
  int padding = 0;
-  HAlign hAlign = HAlign::Left;
+  bool centerHorizontal = false;

 public:
  VStack(const std::string& id) : Container(id) {}
  ElementType getType() const override { return ElementType::VStack; }
-  const char* getTypeName() const override { return "VStack"; }

  void setSpacing(int s) {
    spacing = s;
@ -121,18 +80,8 @@ class VStack : public Container {
    padding = p;
    markDirty();
  }
-  void setHAlign(HAlign a) {
-    hAlign = a;
-    markDirty();
-  }
-  void setHAlignFromString(const std::string& s) {
-    if (s == "center" || s == "Center") {
-      hAlign = HAlign::Center;
-    } else if (s == "right" || s == "Right") {
-      hAlign = HAlign::Right;
-    } else {
-      hAlign = HAlign::Left;
-    }
+  void setCenterHorizontal(bool c) {
+    centerHorizontal = c;
    markDirty();
  }

@ -149,34 +98,12 @@ class VStack : public Container {
      int childW = child->getAbsW();
      int childH = child->getAbsH();

-      // Extract child's own X offset (from first layout pass)
-      int childXOffset = child->getAbsX() - (absX + padding);
-
-      // Calculate base position based on horizontal alignment
      int childX = absX + padding;
-      if (childW < availableW) {
-        switch (hAlign) {
-          case HAlign::Center:
-            childX = absX + padding + (availableW - childW) / 2;
-            break;
-          case HAlign::Right:
-            childX = absX + padding + (availableW - childW);
-            break;
-          case HAlign::Left:
-          default:
-            childX = absX + padding;
-            break;
-        }
+      if (centerHorizontal && childW < availableW) {
+        childX = absX + padding + (availableW - childW) / 2;
      }

-      // Add child's own X offset to the calculated position
-      childX += childXOffset;
-
-      // Only do second layout pass if position changed from first pass
-      int firstPassX = child->getAbsX();
-      if (childX != firstPassX) {
-        child->layout(context, childX, currentY, childW, childH);
-      }
+      child->layout(context, childX, currentY, childW, childH);
      currentY += childH + spacing;
      availableH -= (childH + spacing);
      if (availableH < 0) availableH = 0;
@ -195,7 +122,6 @@ class Grid : public Container {
 public:
  Grid(const std::string& id) : Container(id) {}
  ElementType getType() const override { return ElementType::Grid; }
-  const char* getTypeName() const override { return "Grid"; }

  void setColumns(int c) {
    columns = c > 0 ? c : 1;
@ -219,10 +145,8 @@ class Grid : public Container {

    if (children.empty()) return;

-    // Guard against division by zero
-    int cols = columns > 0 ? columns : 1;
-    int availableW = absW - 2 * padding - (cols - 1) * colSpacing;
-    int cellW = availableW / cols;
+    int availableW = absW - 2 * padding - (columns - 1) * colSpacing;
+    int cellW = availableW / columns;
    int availableH = absH - 2 * padding;

    int row = 0, col = 0;
@ -238,7 +162,7 @@ class Grid : public Container {
      if (childH > maxRowHeight) maxRowHeight = childH;

      col++;
-      if (col >= cols) {
+      if (col >= columns) {
        col = 0;
        row++;
        currentY += maxRowHeight + rowSpacing;
@ -258,7 +182,7 @@ class Badge : public UIElement {
  int fontId = 0;
  int paddingH = 8;  // Horizontal padding
  int paddingV = 4;  // Vertical padding
-  int borderRadius = 0;
+  int cornerRadius = 0;

 public:
  Badge(const std::string& id) : UIElement(id) {
@ -267,7 +191,6 @@ class Badge : public UIElement {
  }

  ElementType getType() const override { return ElementType::Badge; }
-  const char* getTypeName() const override { return "Badge"; }

  void setText(const std::string& expr) {
    textExpr = Expression::parse(expr);
@ -294,11 +217,6 @@ class Badge : public UIElement {
    markDirty();
  }

-  void setBorderRadius(int r) {
-    borderRadius = r;
-    markDirty();
-  }
-
  void draw(const GfxRenderer& renderer, const ThemeContext& context) override {
    if (!isVisible(context)) return;

@ -308,59 +226,29 @@ class Badge : public UIElement {
      return;
    }

-    // Calculate badge size based on text content - always auto-sizes
+    // Calculate badge size based on text
    int textW = renderer.getTextWidth(fontId, text.c_str());
    int textH = renderer.getLineHeight(fontId);
    int badgeW = textW + 2 * paddingH;
    int badgeH = textH + 2 * paddingV;

-    // Badge always auto-sizes to content
-    int drawW = badgeW;
-    int drawH = badgeH;
-
-    // Position the badge within its container
-    // If absW/absH are set, use them as bounding box for alignment
-    int drawX = absX;
-    int drawY = absY;
-
-    // Right-align badge within bounding box if width is specified
-    if (absW > 0 && absW > drawW) {
-      drawX = absX + absW - drawW;
-    }
-    // Vertically center badge within bounding box if height is specified
-    if (absH > 0 && absH > drawH) {
-      drawY = absY + (absH - drawH) / 2;
-    }
+    // Use absX, absY as position, but we may auto-size
+    if (absW == 0) absW = badgeW;
+    if (absH == 0) absH = badgeH;

    // Draw background
    std::string bgStr = context.evaluatestring(bgColorExpr);
    uint8_t bgColor = Color::parse(bgStr).value;
-    if (borderRadius > 0) {
-      if (bgColor == 0x00) {
-        renderer.fillRoundedRect(drawX, drawY, drawW, drawH, borderRadius, true);
-      } else if (bgColor >= 0xF0) {
-        renderer.fillRoundedRect(drawX, drawY, drawW, drawH, borderRadius, false);
-      } else {
-        renderer.fillRoundedRectDithered(drawX, drawY, drawW, drawH, borderRadius, bgColor);
-      }
-    } else {
-      renderer.fillRect(drawX, drawY, drawW, drawH, bgColor == 0x00);
-    }
+    renderer.fillRect(absX, absY, absW, absH, bgColor == 0x00);

-    // Draw border for contrast (only if not black background)
-    if (bgColor != 0x00) {
-      if (borderRadius > 0) {
-        renderer.drawRoundedRect(drawX, drawY, drawW, drawH, borderRadius, true);
-      } else {
-        renderer.drawRect(drawX, drawY, drawW, drawH, true);
-      }
-    }
+    // Draw border for contrast
+    renderer.drawRect(absX, absY, absW, absH, bgColor != 0x00);

-    // Draw text centered within the badge
+    // Draw text centered
    std::string fgStr = context.evaluatestring(fgColorExpr);
    uint8_t fgColor = Color::parse(fgStr).value;
-    int textX = drawX + paddingH;
-    int textY = drawY + paddingV;
+    int textX = absX + (absW - textW) / 2;
+    int textY = absY + (absH - textH) / 2;
    renderer.drawText(fontId, textX, textY, text.c_str(), fgColor == 0x00);

    markClean();
@ -368,28 +256,22 @@ class Badge : public UIElement {
 };

 // --- Toggle: On/Off Switch ---
-// Fully themable toggle with track and knob
-// Supports rounded or square appearance based on BorderRadius
 class Toggle : public UIElement {
-  Expression valueExpr;      // Boolean expression for on/off state
-  Expression onColorExpr;    // Track color when ON
-  Expression offColorExpr;   // Track color when OFF
-  Expression knobColorExpr;  // Knob color (optional, defaults to opposite of track)
+  Expression valueExpr;  // Boolean expression
+  Expression onColorExpr;
+  Expression offColorExpr;
  int trackWidth = 44;
  int trackHeight = 24;
  int knobSize = 20;
-  int borderRadius = 0;  // 0 = square, >0 = rounded (use trackHeight/2 for pill shape)
-  int knobRadius = 0;    // Knob corner radius

 public:
  Toggle(const std::string& id) : UIElement(id) {
    valueExpr = Expression::parse("false");
    onColorExpr = Expression::parse("0x00");   // Black when on
-    offColorExpr = Expression::parse("0xCC");  // Light gray when off
+    offColorExpr = Expression::parse("0xFF");  // White when off
  }

  ElementType getType() const override { return ElementType::Toggle; }
-  const char* getTypeName() const override { return "Toggle"; }

  void setValue(const std::string& expr) {
    valueExpr = Expression::parse(expr);
@ -403,10 +285,6 @@ class Toggle : public UIElement {
    offColorExpr = Expression::parse(expr);
    markDirty();
  }
-  void setKnobColor(const std::string& expr) {
-    knobColorExpr = Expression::parse(expr);
-    markDirty();
-  }
  void setTrackWidth(int w) {
    trackWidth = w;
    markDirty();
@ -419,109 +297,30 @@ class Toggle : public UIElement {
    knobSize = s;
    markDirty();
  }
-  void setBorderRadius(int r) {
-    borderRadius = r;
-    markDirty();
-  }
-  void setKnobRadius(int r) {
-    knobRadius = r;
-    markDirty();
-  }

  void draw(const GfxRenderer& renderer, const ThemeContext& context) override {
    if (!isVisible(context)) return;

-    // Evaluate the value - handle simple variable references directly
-    bool isOn = false;
-    std::string rawExpr = valueExpr.rawExpr;
+    bool isOn = context.evaluateBool(valueExpr.rawExpr);

-    // If it's a simple {variable} reference, resolve it directly
-    if (rawExpr.size() > 2 && rawExpr.front() == '{' && rawExpr.back() == '}') {
-      std::string varName = rawExpr.substr(1, rawExpr.size() - 2);
-      // Trim whitespace
-      size_t start = varName.find_first_not_of(" \t");
-      size_t end = varName.find_last_not_of(" \t");
-      if (start != std::string::npos) {
-        varName = varName.substr(start, end - start + 1);
-      }
-      isOn = context.getAnyAsBool(varName, false);
-    } else {
-      isOn = context.evaluateBool(rawExpr);
-    }
-
-    // Get track color based on state
+    // Get colors
    std::string colorStr = isOn ? context.evaluatestring(onColorExpr) : context.evaluatestring(offColorExpr);
    uint8_t trackColor = Color::parse(colorStr).value;

-    // Calculate track position (centered vertically in bounding box)
+    // Draw track
    int trackX = absX;
    int trackY = absY + (absH - trackHeight) / 2;
+    renderer.fillRect(trackX, trackY, trackWidth, trackHeight, trackColor == 0x00);
+    renderer.drawRect(trackX, trackY, trackWidth, trackHeight, true);

-    // Calculate effective border radius (capped at half height for pill shape)
-    int effectiveRadius = borderRadius;
-    if (effectiveRadius > trackHeight / 2) {
-      effectiveRadius = trackHeight / 2;
-    }
-
-    // Draw track
-    if (effectiveRadius > 0) {
-      // Rounded track
-      if (trackColor == 0x00) {
-        renderer.fillRoundedRect(trackX, trackY, trackWidth, trackHeight, effectiveRadius, true);
-      } else if (trackColor >= 0xF0) {
-        renderer.fillRoundedRect(trackX, trackY, trackWidth, trackHeight, effectiveRadius, false);
-        renderer.drawRoundedRect(trackX, trackY, trackWidth, trackHeight, effectiveRadius, true);
-      } else {
-        renderer.fillRoundedRectDithered(trackX, trackY, trackWidth, trackHeight, effectiveRadius, trackColor);
-        renderer.drawRoundedRect(trackX, trackY, trackWidth, trackHeight, effectiveRadius, true);
-      }
-    } else {
-      // Square track
-      if (trackColor == 0x00) {
-        renderer.fillRect(trackX, trackY, trackWidth, trackHeight, true);
-      } else if (trackColor >= 0xF0) {
-        renderer.fillRect(trackX, trackY, trackWidth, trackHeight, false);
-        renderer.drawRect(trackX, trackY, trackWidth, trackHeight, true);
-      } else {
-        renderer.fillRectDithered(trackX, trackY, trackWidth, trackHeight, trackColor);
-        renderer.drawRect(trackX, trackY, trackWidth, trackHeight, true);
-      }
-    }
-
-    // Calculate knob position
+    // Draw knob
    int knobMargin = (trackHeight - knobSize) / 2;
    int knobX = isOn ? (trackX + trackWidth - knobSize - knobMargin) : (trackX + knobMargin);
    int knobY = trackY + knobMargin;

-    // Determine knob color
-    bool knobBlack;
-    if (!knobColorExpr.empty()) {
-      std::string knobStr = context.evaluatestring(knobColorExpr);
-      uint8_t knobColor = Color::parse(knobStr).value;
-      knobBlack = (knobColor == 0x00);
-    } else {
-      // Default: knob is opposite color of track
-      knobBlack = (trackColor >= 0x80);
-    }
-
-    // Calculate effective knob radius
-    int effectiveKnobRadius = knobRadius;
-    if (effectiveKnobRadius > knobSize / 2) {
-      effectiveKnobRadius = knobSize / 2;
-    }
-
-    // Draw knob
-    if (effectiveKnobRadius > 0) {
-      renderer.fillRoundedRect(knobX, knobY, knobSize, knobSize, effectiveKnobRadius, knobBlack);
-      if (!knobBlack) {
-        renderer.drawRoundedRect(knobX, knobY, knobSize, knobSize, effectiveKnobRadius, true);
-      }
-    } else {
-      renderer.fillRect(knobX, knobY, knobSize, knobSize, knobBlack);
-      if (!knobBlack) {
-        renderer.drawRect(knobX, knobY, knobSize, knobSize, true);
-      }
-    }
+    // Knob is opposite color of track
+    renderer.fillRect(knobX, knobY, knobSize, knobSize, trackColor != 0x00);
+    renderer.drawRect(knobX, knobY, knobSize, knobSize, true);

    markClean();
  }
@ -538,7 +337,6 @@ class TabBar : public Container {
 public:
  TabBar(const std::string& id) : Container(id) {}
  ElementType getType() const override { return ElementType::TabBar; }
-  const char* getTypeName() const override { return "TabBar"; }

  void setSelected(const std::string& expr) {
    selectedExpr = Expression::parse(expr);
@ -597,7 +395,15 @@ class TabBar : public Container {
    // Draw selection indicator
    if (showIndicator && !children.empty()) {
      std::string selStr = context.evaluatestring(selectedExpr);
-      int selectedIdx = parseIntSafe(selStr, 0);
+      int selectedIdx = 0;
+      if (!selStr.empty()) {
+        // Try to parse as number
+        try {
+          selectedIdx = std::stoi(selStr);
+        } catch (...) {
+          selectedIdx = 0;
+        }
+      }

      if (selectedIdx >= 0 && selectedIdx < static_cast<int>(children.size())) {
        UIElement* tab = children[selectedIdx];
@ -608,6 +414,9 @@ class TabBar : public Container {
      }
    }

+    // Draw bottom border
+    renderer.drawLine(absX, absY + absH - 1, absX + absW - 1, absY + absH - 1, true);
+
    markClean();
  }
 };
@ -628,7 +437,6 @@ class Icon : public UIElement {
  }

  ElementType getType() const override { return ElementType::Icon; }
-  const char* getTypeName() const override { return "Icon"; }

  void setSrc(const std::string& expr) {
    srcExpr = Expression::parse(expr);
@ -661,7 +469,6 @@ class ScrollIndicator : public UIElement {
  }

  ElementType getType() const override { return ElementType::ScrollIndicator; }
-  const char* getTypeName() const override { return "ScrollIndicator"; }

  void setPosition(const std::string& expr) {
    positionExpr = Expression::parse(expr);
@ -688,9 +495,9 @@ class ScrollIndicator : public UIElement {
    std::string totalStr = context.evaluatestring(totalExpr);
    std::string visStr = context.evaluatestring(visibleExpr);

-    float position = parseFloatSafe(posStr, 0.0f);
-    int total = parseIntSafe(totalStr, 1);
-    int visible = parseIntSafe(visStr, 1);
+    float position = posStr.empty() ? 0 : std::stof(posStr);
+    int total = totalStr.empty() ? 1 : std::stoi(totalStr);
+    int visible = visStr.empty() ? 1 : std::stoi(visStr);

    if (total <= visible) {
      // No need to show scrollbar
--- a/lib/ThemeEngine/include/ListElement.h
+++ b/lib/ThemeEngine/include/ListElement.h
@ -34,7 +34,6 @@ class List : public Container {
  List(const std::string& id) : Container(id) {}

  ElementType getType() const override { return ElementType::List; }
-  const char* getTypeName() const override { return "List"; }

  void setSource(const std::string& s) {
    source = s;
--- a/lib/ThemeEngine/include/ThemeContext.h
+++ b/lib/ThemeEngine/include/ThemeContext.h
@ -1,7 +1,5 @@
 #pragma once

-#include <cctype>
-#include <cstdlib>
 #include <functional>
 #include <map>
 #include <string>
@ -84,36 +82,6 @@ class ThemeContext {
    return start < s.length();
  }

-  // Helper to check if string is a hex number (0x..)
-  static bool isHexNumber(const std::string& s) {
-    if (s.size() < 3) return false;
-    if (!(s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))) return false;
-    for (size_t i = 2; i < s.length(); i++) {
-      char c = s[i];
-      if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) return false;
-    }
-    return true;
-  }
-
-  static int parseInt(const std::string& s) {
-    if (isHexNumber(s)) {
-      return static_cast<int>(std::strtol(s.c_str(), nullptr, 16));
-    }
-    if (isNumber(s)) {
-      return static_cast<int>(std::strtol(s.c_str(), nullptr, 10));
-    }
-    return 0;
-  }
-
-  static bool coerceBool(const std::string& s) {
-    std::string v = trim(s);
-    if (v.empty()) return false;
-    if (v == "true" || v == "1") return true;
-    if (v == "false" || v == "0") return false;
-    if (isHexNumber(v) || isNumber(v)) return parseInt(v) != 0;
-    return true;
-  }
-
 public:
  explicit ThemeContext(const ThemeContext* parent = nullptr) : parent(parent) {}

@ -121,20 +89,6 @@ class ThemeContext {
  void setInt(const std::string& key, int value) { ints[key] = value; }
  void setBool(const std::string& key, bool value) { bools[key] = value; }

-  // Helper to populate list data efficiently
-  void setListItem(const std::string& listName, int index, const std::string& property, const std::string& value) {
-    strings[listName + "." + std::to_string(index) + "." + property] = value;
-  }
-  void setListItem(const std::string& listName, int index, const std::string& property, int value) {
-    ints[listName + "." + std::to_string(index) + "." + property] = value;
-  }
-  void setListItem(const std::string& listName, int index, const std::string& property, bool value) {
-    bools[listName + "." + std::to_string(index) + "." + property] = value;
-  }
-  void setListItem(const std::string& listName, int index, const std::string& property, const char* value) {
-    strings[listName + "." + std::to_string(index) + "." + property] = value;
-  }
-
  std::string getString(const std::string& key, const std::string& defaultValue = "") const {
    auto it = strings.find(key);
    if (it != strings.end()) return it->second;
@ -182,34 +136,6 @@ class ThemeContext {
    return "";
  }

-  bool getAnyAsBool(const std::string& key, bool defaultValue = false) const {
-    auto bit = bools.find(key);
-    if (bit != bools.end()) return bit->second;
-
-    auto iit = ints.find(key);
-    if (iit != ints.end()) return iit->second != 0;
-
-    auto sit = strings.find(key);
-    if (sit != strings.end()) return coerceBool(sit->second);
-
-    if (parent) return parent->getAnyAsBool(key, defaultValue);
-    return defaultValue;
-  }
-
-  int getAnyAsInt(const std::string& key, int defaultValue = 0) const {
-    auto iit = ints.find(key);
-    if (iit != ints.end()) return iit->second;
-
-    auto bit = bools.find(key);
-    if (bit != bools.end()) return bit->second ? 1 : 0;
-
-    auto sit = strings.find(key);
-    if (sit != strings.end()) return parseInt(sit->second);
-
-    if (parent) return parent->getAnyAsInt(key, defaultValue);
-    return defaultValue;
-  }
-
  // Evaluate a complex boolean expression
  // Supports: !, &&, ||, ==, !=, <, >, <=, >=, parentheses
  bool evaluateBool(const std::string& expression) const {
@ -222,233 +148,96 @@ class ThemeContext {

    // Handle {var} wrapper
    if (expr.size() > 2 && expr.front() == '{' && expr.back() == '}') {
-      expr = trim(expr.substr(1, expr.size() - 2));
+      expr = expr.substr(1, expr.size() - 2);
    }

-    struct Token {
-      enum Type { Identifier, Number, String, Op, LParen, RParen, End };
-      Type type;
-      std::string text;
-    };
+    // Handle negation
+    if (!expr.empty() && expr[0] == '!') {
+      return !evaluateBool(expr.substr(1));
+    }

-    struct Tokenizer {
-      const std::string& s;
-      size_t pos = 0;
-      Token peeked{Token::End, ""};
-      bool hasPeek = false;
-
-      explicit Tokenizer(const std::string& input) : s(input) {}
-
-      static std::string trimCopy(const std::string& in) {
-        size_t start = in.find_first_not_of(" \t\n\r");
-        if (start == std::string::npos) return "";
-        size_t end = in.find_last_not_of(" \t\n\r");
-        return in.substr(start, end - start + 1);
+    // Handle parentheses
+    if (!expr.empty() && expr[0] == '(') {
+      int depth = 1;
+      size_t closePos = 1;
+      while (closePos < expr.length() && depth > 0) {
+        if (expr[closePos] == '(') depth++;
+        if (expr[closePos] == ')') depth--;
+        closePos++;
      }
+      if (closePos <= expr.length()) {
+        std::string inner = expr.substr(1, closePos - 2);
+        std::string rest = trim(expr.substr(closePos));
+        bool innerResult = evaluateBool(inner);

-      void skipWs() {
-        while (pos < s.size() && (s[pos] == ' ' || s[pos] == '\t' || s[pos] == '\n' || s[pos] == '\r')) {
-          pos++;
+        // Check for && or ||
+        if (rest.length() >= 2 && rest.substr(0, 2) == "&&") {
+          return innerResult && evaluateBool(rest.substr(2));
        }
+        if (rest.length() >= 2 && rest.substr(0, 2) == "||") {
+          return innerResult || evaluateBool(rest.substr(2));
+        }
+        return innerResult;
      }
+    }

-      Token readToken() {
-        skipWs();
-        if (pos >= s.size()) return {Token::End, ""};
-        char c = s[pos];
+    // Handle && and || (lowest precedence)
+    size_t andPos = expr.find("&&");
+    size_t orPos = expr.find("||");

-        if (c == '(') {
-          pos++;
-          return {Token::LParen, "("};
-        }
-        if (c == ')') {
-          pos++;
-          return {Token::RParen, ")"};
-        }
+    // Process || first (lower precedence than &&)
+    if (orPos != std::string::npos && (andPos == std::string::npos || orPos < andPos)) {
+      return evaluateBool(expr.substr(0, orPos)) || evaluateBool(expr.substr(orPos + 2));
+    }
+    if (andPos != std::string::npos) {
+      return evaluateBool(expr.substr(0, andPos)) && evaluateBool(expr.substr(andPos + 2));
+    }

-        if (c == '{') {
-          size_t end = s.find('}', pos + 1);
-          std::string inner;
-          if (end == std::string::npos) {
-            inner = s.substr(pos + 1);
-            pos = s.size();
-          } else {
-            inner = s.substr(pos + 1, end - pos - 1);
-            pos = end + 1;
-          }
-          return {Token::Identifier, trimCopy(inner)};
-        }
+    // Handle comparisons
+    size_t eqPos = expr.find("==");
+    if (eqPos != std::string::npos) {
+      std::string left = trim(expr.substr(0, eqPos));
+      std::string right = trim(expr.substr(eqPos + 2));
+      return compareValues(left, right) == 0;
+    }

-        if (c == '"' || c == '\'') {
-          char quote = c;
-          pos++;
-          std::string out;
-          while (pos < s.size()) {
-            char ch = s[pos++];
-            if (ch == '\\' && pos < s.size()) {
-              out.push_back(s[pos++]);
-              continue;
-            }
-            if (ch == quote) break;
-            out.push_back(ch);
-          }
-          return {Token::String, out};
-        }
+    size_t nePos = expr.find("!=");
+    if (nePos != std::string::npos) {
+      std::string left = trim(expr.substr(0, nePos));
+      std::string right = trim(expr.substr(nePos + 2));
+      return compareValues(left, right) != 0;
+    }

-        // Operators
-        if (pos + 1 < s.size()) {
-          std::string two = s.substr(pos, 2);
-          if (two == "&&" || two == "||" || two == "==" || two == "!=" || two == "<=" || two == ">=") {
-            pos += 2;
-            return {Token::Op, two};
-          }
-        }
-        if (c == '!' || c == '<' || c == '>') {
-          pos++;
-          return {Token::Op, std::string(1, c)};
-        }
+    size_t gePos = expr.find(">=");
+    if (gePos != std::string::npos) {
+      std::string left = trim(expr.substr(0, gePos));
+      std::string right = trim(expr.substr(gePos + 2));
+      return compareValues(left, right) >= 0;
+    }

-        // Number (decimal or hex)
-        if (isdigit(c) || (c == '-' && pos + 1 < s.size() && isdigit(s[pos + 1]))) {
-          size_t start = pos;
-          pos++;
-          if (pos + 1 < s.size() && s[start] == '0' && (s[pos] == 'x' || s[pos] == 'X')) {
-            pos++;  // consume x
-            while (pos < s.size() && isxdigit(s[pos])) pos++;
-          } else {
-            while (pos < s.size() && isdigit(s[pos])) pos++;
-          }
-          return {Token::Number, s.substr(start, pos - start)};
-        }
+    size_t lePos = expr.find("<=");
+    if (lePos != std::string::npos) {
+      std::string left = trim(expr.substr(0, lePos));
+      std::string right = trim(expr.substr(lePos + 2));
+      return compareValues(left, right) <= 0;
+    }

-        // Identifier
-        if (isalpha(c) || c == '_' || c == '.') {
-          size_t start = pos;
-          pos++;
-          while (pos < s.size()) {
-            char ch = s[pos];
-            if (isalnum(ch) || ch == '_' || ch == '.') {
-              pos++;
-              continue;
-            }
-            break;
-          }
-          return {Token::Identifier, s.substr(start, pos - start)};
-        }
+    size_t gtPos = expr.find('>');
+    if (gtPos != std::string::npos) {
+      std::string left = trim(expr.substr(0, gtPos));
+      std::string right = trim(expr.substr(gtPos + 1));
+      return compareValues(left, right) > 0;
+    }

-        // Unknown char, skip
-        pos++;
-        return readToken();
-      }
+    size_t ltPos = expr.find('<');
+    if (ltPos != std::string::npos) {
+      std::string left = trim(expr.substr(0, ltPos));
+      std::string right = trim(expr.substr(ltPos + 1));
+      return compareValues(left, right) < 0;
+    }

-      Token next() {
-        if (hasPeek) {
-          hasPeek = false;
-          return peeked;
-        }
-        return readToken();
-      }
-
-      Token peek() {
-        if (!hasPeek) {
-          peeked = readToken();
-          hasPeek = true;
-        }
-        return peeked;
-      }
-    };
-
-    Tokenizer tz(expr);
-
-    std::function<bool()> parseOr;
-    std::function<bool()> parseAnd;
-    std::function<bool()> parseNot;
-    std::function<bool()> parseComparison;
-    std::function<std::string()> parseValue;
-
-    parseValue = [&]() -> std::string {
-      Token t = tz.next();
-      if (t.type == Token::LParen) {
-        bool inner = parseOr();
-        Token close = tz.next();
-        if (close.type != Token::RParen) {
-          // best-effort: no-op
-        }
-        return inner ? "true" : "false";
-      }
-      if (t.type == Token::String) {
-        return "'" + t.text + "'";
-      }
-      if (t.type == Token::Number) {
-        return t.text;
-      }
-      if (t.type == Token::Identifier) {
-        return t.text;
-      }
-      return "";
-    };
-
-    auto isComparisonOp = [](const Token& t) {
-      if (t.type != Token::Op) return false;
-      return t.text == "==" || t.text == "!=" || t.text == "<" || t.text == ">" || t.text == "<=" || t.text == ">=";
-    };
-
-    parseComparison = [&]() -> bool {
-      std::string left = parseValue();
-      Token op = tz.peek();
-      if (isComparisonOp(op)) {
-        tz.next();
-        std::string right = parseValue();
-        int cmp = compareValues(left, right);
-        if (op.text == "==") return cmp == 0;
-        if (op.text == "!=") return cmp != 0;
-        if (op.text == "<") return cmp < 0;
-        if (op.text == ">") return cmp > 0;
-        if (op.text == "<=") return cmp <= 0;
-        if (op.text == ">=") return cmp >= 0;
-        return false;
-      }
-      return coerceBool(resolveValue(left));
-    };
-
-    parseNot = [&]() -> bool {
-      Token t = tz.peek();
-      if (t.type == Token::Op && t.text == "!") {
-        tz.next();
-        return !parseNot();
-      }
-      return parseComparison();
-    };
-
-    parseAnd = [&]() -> bool {
-      bool value = parseNot();
-      while (true) {
-        Token t = tz.peek();
-        if (t.type == Token::Op && t.text == "&&") {
-          tz.next();
-          value = value && parseNot();
-          continue;
-        }
-        break;
-      }
-      return value;
-    };
-
-    parseOr = [&]() -> bool {
-      bool value = parseAnd();
-      while (true) {
-        Token t = tz.peek();
-        if (t.type == Token::Op && t.text == "||") {
-          tz.next();
-          value = value || parseAnd();
-          continue;
-        }
-        break;
-      }
-      return value;
-    };
-
-    return parseOr();
+    // Simple variable lookup
+    return getBool(expr, false);
  }

  // Compare two values (handles variables, numbers, strings)
@ -457,9 +246,9 @@ class ThemeContext {
    std::string rightVal = resolveValue(right);

    // Try numeric comparison
-    if ((isNumber(leftVal) || isHexNumber(leftVal)) && (isNumber(rightVal) || isHexNumber(rightVal))) {
-      int l = parseInt(leftVal);
-      int r = parseInt(rightVal);
+    if (isNumber(leftVal) && isNumber(rightVal)) {
+      int l = std::stoi(leftVal);
+      int r = std::stoi(rightVal);
      return (l < r) ? -1 : (l > r) ? 1 : 0;
    }

@ -483,7 +272,7 @@ class ThemeContext {
    if (isNumber(v)) return v;

    // Check for hex color literals (0x00, 0xFF, etc.)
-    if (isHexNumber(v)) {
+    if (v.size() > 2 && v[0] == '0' && (v[1] == 'x' || v[1] == 'X')) {
      return v;
    }

@ -493,18 +282,13 @@ class ThemeContext {
    }

    // Check for boolean literals
-    if (v == "true" || v == "false" || v == "1" || v == "0") {
+    if (v == "true" || v == "false") {
      return v;
    }

    // Try to look up as variable
-    std::string varName = v;
-    if (varName.size() >= 2 && varName.front() == '{' && varName.back() == '}') {
-      varName = trim(varName.substr(1, varName.size() - 2));
-    }
-
-    if (hasKey(varName)) {
-      return getAnyAsString(varName);
+    if (hasKey(v)) {
+      return getAnyAsString(v);
    }

    // Return as literal if not found as variable
--- a/lib/ThemeEngine/include/ThemeManager.h
+++ b/lib/ThemeEngine/include/ThemeManager.h
@ -26,7 +26,6 @@ struct ScreenCache {
  uint32_t contextHash = 0;  // Hash of context data to detect changes
  bool valid = false;

-  ScreenCache() = default;
  ~ScreenCache() {
    if (buffer) {
      free(buffer);
@ -34,37 +33,6 @@ struct ScreenCache {
    }
  }

-  // Prevent double-free from copy
-  ScreenCache(const ScreenCache&) = delete;
-  ScreenCache& operator=(const ScreenCache&) = delete;
-
-  // Allow move
-  ScreenCache(ScreenCache&& other) noexcept
-      : buffer(other.buffer),
-        bufferSize(other.bufferSize),
-        screenName(std::move(other.screenName)),
-        contextHash(other.contextHash),
-        valid(other.valid) {
-    other.buffer = nullptr;
-    other.bufferSize = 0;
-    other.valid = false;
-  }
-
-  ScreenCache& operator=(ScreenCache&& other) noexcept {
-    if (this != &other) {
-      if (buffer) free(buffer);
-      buffer = other.buffer;
-      bufferSize = other.bufferSize;
-      screenName = std::move(other.screenName);
-      contextHash = other.contextHash;
-      valid = other.valid;
-      other.buffer = nullptr;
-      other.bufferSize = 0;
-      other.valid = false;
-    }
-    return *this;
-  }
-
  void invalidate() { valid = false; }
 };

@ -130,7 +98,6 @@ class ThemeManager {

  // Asset caching
  const std::vector<uint8_t>* getCachedAsset(const std::string& path);
-  void cacheAsset(const std::string& path, std::vector<uint8_t>&& data);
  const ProcessedAsset* getProcessedAsset(const std::string& path, GfxRenderer::Orientation orientation,
                                          int targetW = 0, int targetH = 0);
  void cacheProcessedAsset(const std::string& path, const ProcessedAsset& asset, int targetW = 0, int targetH = 0);
--- a/lib/ThemeEngine/include/ThemeTypes.h
+++ b/lib/ThemeEngine/include/ThemeTypes.h
@ -17,17 +17,10 @@ struct Dimension {
  static Dimension parse(const std::string& str) {
    if (str.empty()) return Dimension(0, DimensionUnit::PIXELS);

-    auto safeParseInt = [](const std::string& s) {
-      char* end = nullptr;
-      long v = std::strtol(s.c_str(), &end, 10);
-      if (!end || end == s.c_str()) return 0;
-      return static_cast<int>(v);
-    };
-
    if (str.back() == '%') {
-      return Dimension(safeParseInt(str.substr(0, str.length() - 1)), DimensionUnit::PERCENT);
+      return Dimension(std::stoi(str.substr(0, str.length() - 1)), DimensionUnit::PERCENT);
    }
-    return Dimension(safeParseInt(str), DimensionUnit::PIXELS);
+    return Dimension(std::stoi(str), DimensionUnit::PIXELS);
  }

  int resolve(int parentSize) const {
@ -52,8 +45,7 @@ struct Color {
    if (str.size() > 2 && str.substr(0, 2) == "0x") {
      return Color((uint8_t)std::strtol(str.c_str(), nullptr, 16));
    }
-    // Safe fallback using strtol (returns 0 on error, no exception)
-    return Color((uint8_t)std::strtol(str.c_str(), nullptr, 10));
+    return Color((uint8_t)std::stoi(str));
  }
 };

--- a/lib/ThemeEngine/include/UIElement.h
+++ b/lib/ThemeEngine/include/UIElement.h
@ -29,10 +29,6 @@ class UIElement {
  // Recomputed every layout pass
  int absX = 0, absY = 0, absW = 0, absH = 0;

-  // Layout caching - track last params to skip redundant layout
-  int lastParentX = -1, lastParentY = -1, lastParentW = -1, lastParentH = -1;
-  bool layoutValid = false;
-
  // Caching support
  bool cacheable = false;   // Set true for expensive elements like bitmaps
  bool cacheValid = false;  // Is the cached render still valid?
@ -88,7 +84,6 @@ class UIElement {
  virtual void markDirty() {
    dirty = true;
    cacheValid = false;
-    layoutValid = false;
  }

  void markClean() { dirty = false; }
@ -102,18 +97,6 @@ class UIElement {

  // Calculate absolute position based on parent
  virtual void layout(const ThemeContext& context, int parentX, int parentY, int parentW, int parentH) {
-    // Skip layout if params unchanged and layout is still valid
-    if (layoutValid && parentX == lastParentX && parentY == lastParentY && parentW == lastParentW &&
-        parentH == lastParentH) {
-      return;
-    }
-
-    lastParentX = parentX;
-    lastParentY = parentY;
-    lastParentW = parentW;
-    lastParentH = parentH;
-    layoutValid = true;
-
    int newX = parentX + x.resolve(parentW);
    int newY = parentY + y.resolve(parentH);
    int newW = width.resolve(parentW);
@ -167,7 +150,6 @@ class UIElement {
  };

  virtual ElementType getType() const { return ElementType::Base; }
-  virtual const char* getTypeName() const { return "UIElement"; }

  int getLayoutHeight() const { return absH; }
  int getLayoutWidth() const { return absW; }
--- a/lib/ThemeEngine/src/BasicElements.cpp
+++ b/lib/ThemeEngine/src/BasicElements.cpp
@ -9,213 +9,6 @@

 namespace ThemeEngine {

-// --- Container ---
-void Container::draw(const GfxRenderer& renderer, const ThemeContext& context) {
-  if (!isVisible(context)) return;
-
-  if (hasBg) {
-    std::string colStr = context.evaluatestring(bgColorExpr);
-    uint8_t color = Color::parse(colStr).value;
-    // Use dithered fill for grayscale values, solid fill for black/white
-    // Use rounded rect if borderRadius > 0
-    if (color == 0x00) {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, true);
-      } else {
-        renderer.fillRect(absX, absY, absW, absH, true);
-      }
-    } else if (color >= 0xF0) {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, false);
-      } else {
-        renderer.fillRect(absX, absY, absW, absH, false);
-      }
-    } else {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRectDithered(absX, absY, absW, absH, borderRadius, color);
-      } else {
-        renderer.fillRectDithered(absX, absY, absW, absH, color);
-      }
-    }
-  }
-
-  // Handle dynamic border expression
-  bool drawBorder = border;
-  if (hasBorderExpr()) {
-    drawBorder = context.evaluateBool(borderExpr.rawExpr);
-  }
-
-  if (drawBorder) {
-    if (borderRadius > 0) {
-      renderer.drawRoundedRect(absX, absY, absW, absH, borderRadius, true);
-    } else {
-      renderer.drawRect(absX, absY, absW, absH, true);
-    }
-  }
-
-  for (auto child : children) {
-    child->draw(renderer, context);
-  }
-
-  markClean();
-}
-
-// --- Rectangle ---
-void Rectangle::draw(const GfxRenderer& renderer, const ThemeContext& context) {
-  if (!isVisible(context)) return;
-
-  std::string colStr = context.evaluatestring(colorExpr);
-  uint8_t color = Color::parse(colStr).value;
-
-  bool shouldFill = fill;
-  if (!fillExpr.empty()) {
-    shouldFill = context.evaluateBool(fillExpr.rawExpr);
-  }
-
-  if (shouldFill) {
-    // Use dithered fill for grayscale values, solid fill for black/white
-    // Use rounded rect if borderRadius > 0
-    if (color == 0x00) {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, true);
-      } else {
-        renderer.fillRect(absX, absY, absW, absH, true);
-      }
-    } else if (color >= 0xF0) {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRect(absX, absY, absW, absH, borderRadius, false);
-      } else {
-        renderer.fillRect(absX, absY, absW, absH, false);
-      }
-    } else {
-      if (borderRadius > 0) {
-        renderer.fillRoundedRectDithered(absX, absY, absW, absH, borderRadius, color);
-      } else {
-        renderer.fillRectDithered(absX, absY, absW, absH, color);
-      }
-    }
-  } else {
-    // Draw border
-    bool black = (color == 0x00);
-    if (borderRadius > 0) {
-      renderer.drawRoundedRect(absX, absY, absW, absH, borderRadius, black);
-    } else {
-      renderer.drawRect(absX, absY, absW, absH, black);
-    }
-  }
-
-  markClean();
-}
-
-// --- Label ---
-void Label::draw(const GfxRenderer& renderer, const ThemeContext& context) {
-  if (!isVisible(context)) return;
-
-  std::string finalStr = context.evaluatestring(textExpr);
-
-  if (finalStr.empty()) {
-    markClean();
-    return;
-  }
-
-  std::string colStr = context.evaluatestring(colorExpr);
-  uint8_t color = Color::parse(colStr).value;
-  bool black = (color == 0x00);
-
-  int textWidth = renderer.getTextWidth(fontId, finalStr.c_str());
-  int lineHeight = renderer.getLineHeight(fontId);
-
-  std::vector<std::string> lines;
-  lines.reserve(maxLines);  // Pre-allocate to avoid reallocations
-  if (absW > 0 && textWidth > absW && maxLines > 1) {
-    // Logic to wrap text
-    std::string remaining = finalStr;
-    while (!remaining.empty() && (int)lines.size() < maxLines) {
-      // If it fits, add entire line
-      if (renderer.getTextWidth(fontId, remaining.c_str()) <= absW) {
-        lines.push_back(remaining);
-        break;
-      }
-
-      // Binary search for maximum characters that fit (O(log n) instead of O(n))
-      int len = remaining.length();
-      int lo = 1, hi = len;
-      while (lo < hi) {
-        int mid = (lo + hi + 1) / 2;
-        if (renderer.getTextWidth(fontId, remaining.substr(0, mid).c_str()) <= absW) {
-          lo = mid;
-        } else {
-          hi = mid - 1;
-        }
-      }
-      int cut = lo;
-
-      // Find last space before cut
-      if (cut < (int)remaining.length()) {
-        int space = -1;
-        for (int i = cut; i > 0; i--) {
-          if (remaining[i] == ' ') {
-            space = i;
-            break;
-          }
-        }
-        if (space != -1) cut = space;
-      }
-
-      std::string line = remaining.substr(0, cut);
-
-      // If we're at the last allowed line but still have more text
-      if ((int)lines.size() == maxLines - 1 && cut < (int)remaining.length()) {
-        if (ellipsis) {
-          line = renderer.truncatedText(fontId, remaining.c_str(), absW);
-        }
-        lines.push_back(line);
-        break;
-      }
-
-      lines.push_back(line);
-      // Advance
-      if (cut < (int)remaining.length()) {
-        // Skip the space if check
-        if (remaining[cut] == ' ') cut++;
-        remaining = remaining.substr(cut);
-      } else {
-        remaining = "";
-      }
-    }
-  } else {
-    // Single line handling (truncate if needed)
-    if (ellipsis && textWidth > absW && absW > 0) {
-      finalStr = renderer.truncatedText(fontId, finalStr.c_str(), absW);
-    }
-    lines.push_back(finalStr);
-  }
-
-  // Draw lines
-  int totalTextHeight = lines.size() * lineHeight;
-  int startY = absY;
-
-  // Vertical centering
-  if (absH > 0 && totalTextHeight < absH) {
-    startY = absY + (absH - totalTextHeight) / 2;
-  }
-
-  for (size_t i = 0; i < lines.size(); i++) {
-    int lineWidth = renderer.getTextWidth(fontId, lines[i].c_str());
-    int drawX = absX;
-
-    if (alignment == Alignment::Center && absW > 0) {
-      drawX = absX + (absW - lineWidth) / 2;
-    } else if (alignment == Alignment::Right && absW > 0) {
-      drawX = absX + absW - lineWidth;
-    }
-
-    renderer.drawText(fontId, drawX, startY + i * lineHeight, lines[i].c_str(), black);
-  }
-
-  markClean();
-}
-
 // --- BitmapElement ---
 void BitmapElement::draw(const GfxRenderer& renderer, const ThemeContext& context) {
  if (!isVisible(context)) {
@ -229,87 +22,98 @@ void BitmapElement::draw(const GfxRenderer& renderer, const ThemeContext& contex
    return;
  }

+  // Resolve simplified or relative paths
  if (path.find('/') == std::string::npos || (path.length() > 0 && path[0] != '/')) {
    path = ThemeManager::get().getAssetPath(path);
  }

-  // Fast path: use cached 1-bit render
+  // 1. Check if we have a cached 1-bit render
  const ProcessedAsset* processed = ThemeManager::get().getProcessedAsset(path, renderer.getOrientation(), absW, absH);
  if (processed && processed->w == absW && processed->h == absH) {
-    renderer.restoreRegion(processed->data.data(), absX, absY, absW, absH);
+    const int rowBytes = (absW + 7) / 8;
+    for (int y = 0; y < absH; y++) {
+      const uint8_t* srcRow = processed->data.data() + y * rowBytes;
+      for (int x = 0; x < absW; x++) {
+        // Cached 1-bit data: 0=Black, 1=White
+        bool isBlack = !(srcRow[x / 8] & (1 << (7 - (x % 8))));
+        // Draw opaque (true=black, false=white)
+        renderer.drawPixel(absX + x, absY + y, isBlack);
+      }
+    }
    markClean();
    return;
  }

-  // Helper to draw bitmap with centering and optional rounded corners
-  auto drawBmp = [&](Bitmap& bmp) {
-    int drawX = absX;
-    int drawY = absY;
-    if (bmp.getWidth() < absW) drawX += (absW - bmp.getWidth()) / 2;
-    if (bmp.getHeight() < absH) drawY += (absH - bmp.getHeight()) / 2;
-    if (borderRadius > 0) {
-      renderer.drawRoundedBitmap(bmp, drawX, drawY, absW, absH, borderRadius);
-    } else {
-      renderer.drawBitmap(bmp, drawX, drawY, absW, absH);
-    }
-  };
-
  bool drawSuccess = false;

-  // Try RAM cache first
-  const std::vector<uint8_t>* cachedData = ThemeManager::get().getCachedAsset(path);
-  if (cachedData && !cachedData->empty()) {
-    Bitmap bmp(cachedData->data(), cachedData->size());
-    if (bmp.parseHeaders() == BmpReaderError::Ok) {
-      drawBmp(bmp);
-      drawSuccess = true;
-    }
-  }
-
-  // Fallback: load from SD card
-  if (!drawSuccess && path.length() > 0 && path[0] == '/') {
+  // 2. Try Streaming (Absolute paths, large images)
+  if (path.length() > 0 && path[0] == '/') {
    FsFile file;
    if (SdMan.openFileForRead("HOME", path, file)) {
-      size_t fileSize = file.size();
-      if (fileSize > 0 && fileSize < 100000) {
-        std::vector<uint8_t> fileData(fileSize);
-        if (file.read(fileData.data(), fileSize) == fileSize) {
-          ThemeManager::get().cacheAsset(path, std::move(fileData));
-          const std::vector<uint8_t>* newCachedData = ThemeManager::get().getCachedAsset(path);
-          if (newCachedData && !newCachedData->empty()) {
-            Bitmap bmp(newCachedData->data(), newCachedData->size());
-            if (bmp.parseHeaders() == BmpReaderError::Ok) {
-              drawBmp(bmp);
-              drawSuccess = true;
-            }
-          }
-        }
-      } else {
-        Bitmap bmp(file, true);
-        if (bmp.parseHeaders() == BmpReaderError::Ok) {
-          drawBmp(bmp);
-          drawSuccess = true;
+      Bitmap bmp(file, true);  // (file, dithering=true)
+      if (bmp.parseHeaders() == BmpReaderError::Ok) {
+        // Center logic
+        int drawX = absX;
+        int drawY = absY;
+        if (bmp.getWidth() < absW) drawX += (absW - bmp.getWidth()) / 2;
+        if (bmp.getHeight() < absH) drawY += (absH - bmp.getHeight()) / 2;
+
+        if (borderRadius > 0) {
+          renderer.drawRoundedBitmap(bmp, drawX, drawY, absW, absH, borderRadius);
+        } else {
+          renderer.drawBitmap(bmp, drawX, drawY, absW, absH);
        }
+        drawSuccess = true;
      }
      file.close();
    }
  }

-  // Cache rendered result for fast subsequent draws using captureRegion
-  if (drawSuccess && absW * absH <= 40000) {
-    size_t capturedSize = 0;
-    uint8_t* captured = renderer.captureRegion(absX, absY, absW, absH, &capturedSize);
-    if (captured && capturedSize > 0) {
-      ProcessedAsset asset;
-      asset.w = absW;
-      asset.h = absH;
-      asset.orientation = renderer.getOrientation();
-      asset.data.assign(captured, captured + capturedSize);
-      free(captured);
-      ThemeManager::get().cacheProcessedAsset(path, asset, absW, absH);
+  // 3. Fallback to RAM Cache (Standard method)
+  if (!drawSuccess) {
+    const std::vector<uint8_t>* data = ThemeManager::get().getCachedAsset(path);
+    if (data && !data->empty()) {
+      Bitmap bmp(data->data(), data->size());
+      if (bmp.parseHeaders() == BmpReaderError::Ok) {
+        int drawX = absX;
+        int drawY = absY;
+        if (bmp.getWidth() < absW) drawX += (absW - bmp.getWidth()) / 2;
+        if (bmp.getHeight() < absH) drawY += (absH - bmp.getHeight()) / 2;
+
+        if (borderRadius > 0) {
+          renderer.drawRoundedBitmap(bmp, drawX, drawY, absW, absH, borderRadius);
+        } else {
+          renderer.drawBitmap(bmp, drawX, drawY, absW, absH);
+        }
+        drawSuccess = true;
+      }
    }
  }

+  // 4. Cache result if successful
+  if (drawSuccess) {
+    ProcessedAsset asset;
+    asset.w = absW;
+    asset.h = absH;
+    asset.orientation = renderer.getOrientation();
+
+    const int rowBytes = (absW + 7) / 8;
+    asset.data.resize(rowBytes * absH, 0xFF);  // Initialize to 0xFF (White)
+
+    for (int y = 0; y < absH; y++) {
+      uint8_t* dstRow = asset.data.data() + y * rowBytes;
+      for (int x = 0; x < absW; x++) {
+        // Read precise pixel state from framebuffer
+        bool isBlack = renderer.readPixel(absX + x, absY + y);
+        if (isBlack) {
+          // Clear bit for black (0)
+          dstRow[x / 8] &= ~(1 << (7 - (x % 8)));
+        }
+      }
+    }
+    ThemeManager::get().cacheProcessedAsset(path, asset, absW, absH);
+  }
+
  markClean();
 }

@ -345,13 +149,6 @@ void List::draw(const GfxRenderer& renderer, const ThemeContext& context) {
  int itemW = getItemWidth();
  int itemH = getItemHeight();

-  // Pre-allocate string buffers to avoid repeated allocations
-  std::string prefix;
-  prefix.reserve(source.length() + 16);
-  std::string key;
-  key.reserve(source.length() + 32);
-  char numBuf[12];
-
  // Handle different layout modes
  if (direction == Direction::Horizontal || layoutMode == LayoutMode::Grid) {
    // Horizontal or Grid layout
@ -360,37 +157,26 @@ void List::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    int currentX = absX;
    int currentY = absY;

-    // For grid, calculate item width based on columns only if not explicitly set
-    if (layoutMode == LayoutMode::Grid && columns > 1 && itemWidth == 0) {
+    // For grid, calculate item width based on columns
+    if (layoutMode == LayoutMode::Grid && columns > 1) {
      int totalSpacing = (columns - 1) * spacing;
      itemW = (absW - totalSpacing) / columns;
    }

    for (int i = 0; i < count; ++i) {
-      // Build prefix efficiently: "source.i."
-      prefix.clear();
-      prefix += source;
-      prefix += '.';
-      snprintf(numBuf, sizeof(numBuf), "%d", i);
-      prefix += numBuf;
-      prefix += '.';
-
      // Create item context with scoped variables
      ThemeContext itemContext(&context);
+      std::string prefix = source + "." + std::to_string(i) + ".";

-      // Standard list item variables - include all properties for full flexibility
-      std::string nameVal = context.getString(prefix + "Name");
-      itemContext.setString("Item.Name", nameVal);
+      // Standard list item variables
      itemContext.setString("Item.Title", context.getString(prefix + "Title"));
-      itemContext.setString("Item.Value", context.getAnyAsString(prefix + "Value"));
-      itemContext.setString("Item.Type", context.getString(prefix + "Type"));
-      itemContext.setString("Item.ValueLabel", context.getString(prefix + "ValueLabel"));
-      itemContext.setString("Item.BgColor", context.getString(prefix + "BgColor"));
+      itemContext.setString("Item.Value", context.getString(prefix + "Value"));
      itemContext.setBool("Item.Selected", context.getBool(prefix + "Selected"));
-      itemContext.setBool("Item.Value", context.getBool(prefix + "Value"));
      itemContext.setString("Item.Icon", context.getString(prefix + "Icon"));
      itemContext.setString("Item.Image", context.getString(prefix + "Image"));
      itemContext.setString("Item.Progress", context.getString(prefix + "Progress"));
+      itemContext.setInt("Item.Index", i);
+      itemContext.setInt("Item.Count", count);

      // Viewport check
      if (direction == Direction::Horizontal) {
@ -413,12 +199,6 @@ void List::draw(const GfxRenderer& renderer, const ThemeContext& context) {
        }
        if (currentY > absY + absH) break;
      }
-      itemContext.setInt("Item.Index", i);
-      itemContext.setInt("Item.Count", count);
-      // ValueIndex may not exist for all item types, so check first
-      if (context.hasKey(prefix + "ValueIndex")) {
-        itemContext.setInt("Item.ValueIndex", context.getInt(prefix + "ValueIndex"));
-      }

      // Layout and draw
      itemTemplate->layout(itemContext, currentX, currentY, itemW, itemH);
@ -455,36 +235,18 @@ void List::draw(const GfxRenderer& renderer, const ThemeContext& context) {
        break;
      }

-      // Build prefix efficiently: "source.i."
-      prefix.clear();
-      prefix += source;
-      prefix += '.';
-      snprintf(numBuf, sizeof(numBuf), "%d", i);
-      prefix += numBuf;
-      prefix += '.';
-
      // Create item context with scoped variables
      ThemeContext itemContext(&context);
+      std::string prefix = source + "." + std::to_string(i) + ".";

-      // Standard list item variables - include all properties for full flexibility
-      std::string nameVal = context.getString(prefix + "Name");
-      itemContext.setString("Item.Name", nameVal);
      itemContext.setString("Item.Title", context.getString(prefix + "Title"));
-      itemContext.setString("Item.Value", context.getAnyAsString(prefix + "Value"));
-      itemContext.setString("Item.Type", context.getString(prefix + "Type"));
-      itemContext.setString("Item.ValueLabel", context.getString(prefix + "ValueLabel"));
-      itemContext.setString("Item.BgColor", context.getString(prefix + "BgColor"));
+      itemContext.setString("Item.Value", context.getString(prefix + "Value"));
      itemContext.setBool("Item.Selected", context.getBool(prefix + "Selected"));
-      itemContext.setBool("Item.Value", context.getBool(prefix + "Value"));
      itemContext.setString("Item.Icon", context.getString(prefix + "Icon"));
      itemContext.setString("Item.Image", context.getString(prefix + "Image"));
      itemContext.setString("Item.Progress", context.getString(prefix + "Progress"));
      itemContext.setInt("Item.Index", i);
      itemContext.setInt("Item.Count", count);
-      // ValueIndex may not exist for all item types, so check first
-      if (context.hasKey(prefix + "ValueIndex")) {
-        itemContext.setInt("Item.ValueIndex", context.getInt(prefix + "ValueIndex"));
-      }

      // Layout and draw the template for this item
      itemTemplate->layout(itemContext, absX, currentY, absW, itemH);
--- a/lib/ThemeEngine/src/IniParser.cpp
+++ b/lib/ThemeEngine/src/IniParser.cpp
@ -21,8 +21,11 @@ void IniParser::trim(std::string& s) {

 std::map<std::string, std::map<std::string, std::string>> IniParser::parse(Stream& stream) {
  std::map<std::string, std::map<std::string, std::string>> sections;
-  std::string currentSection;
-  String line;
+  // stream check not strictly possible like file, can rely on available()
+
+  std::string currentSection = "";
+  String line;  // Use Arduino String for easy file reading, then convert to
+                // std::string

  while (stream.available()) {
    line = stream.readStringUntil('\n');
@ -30,7 +33,7 @@ std::map<std::string, std::map<std::string, std::string>> IniParser::parse(Strea
    trim(sLine);

    if (sLine.empty() || sLine[0] == ';' || sLine[0] == '#') {
-      continue;
+      continue;  // Skip comments and empty lines
    }

    if (sLine.front() == '[' && sLine.back() == ']') {
@ -62,7 +65,7 @@ std::map<std::string, std::map<std::string, std::string>> IniParser::parseString
  std::map<std::string, std::map<std::string, std::string>> sections;
  std::stringstream ss(content);
  std::string line;
-  std::string currentSection;
+  std::string currentSection = "";

  while (std::getline(ss, line)) {
    trim(line);
--- a/lib/ThemeEngine/src/LayoutElements.cpp
+++ b/lib/ThemeEngine/src/LayoutElements.cpp
@ -22,23 +22,13 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {

  std::string colStr = context.evaluatestring(colorExpr);
  uint8_t color = Color::parse(colStr).value;
-  // Draw as black if color is dark (< 0x80), as white if light
-  // This allows grayscale colors to render visibly
-  bool black = (color < 0x80);
+  bool black = (color == 0x00);

-  // iconSize determines the actual drawn icon size
-  // absW/absH determine the bounding box for centering
-  int drawSize = iconSize;
-  int boundW = absW > 0 ? absW : iconSize;
-  int boundH = absH > 0 ? absH : iconSize;
-
-  // Center the icon within its bounding box
-  int iconX = absX + (boundW - drawSize) / 2;
-  int iconY = absY + (boundH - drawSize) / 2;
-  int w = drawSize;
-  int h = drawSize;
-  int cx = iconX + w / 2;
-  int cy = iconY + h / 2;
+  // Use absW/absH if set, otherwise use iconSize
+  int w = absW > 0 ? absW : iconSize;
+  int h = absH > 0 ? absH : iconSize;
+  int cx = absX + w / 2;
+  int cy = absY + h / 2;

  // 1. Try to load as a theme asset (exact match or .bmp extension)
  std::string path = iconName;
@ -55,14 +45,13 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
  if (data && !data->empty()) {
    Bitmap bmp(data->data(), data->size());
    if (bmp.parseHeaders() == BmpReaderError::Ok) {
-      renderer.drawTransparentBitmap(bmp, iconX, iconY, w, h);
+      renderer.drawTransparentBitmap(bmp, absX, absY, w, h);
      markClean();
      return;
    }
  }

  // 2. Built-in icons (simple geometric shapes) as fallback
-  // All icons use iconX, iconY, w, h, cx, cy for proper centering
  if (iconName == "heart" || iconName == "favorite") {
    // Simple heart shape approximation
    int s = w / 4;
@ -77,8 +66,8 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    // Book icon
    int bw = w * 2 / 3;
    int bh = h * 3 / 4;
-    int bx = iconX + (w - bw) / 2;
-    int by = iconY + (h - bh) / 2;
+    int bx = absX + (w - bw) / 2;
+    int by = absY + (h - bh) / 2;
    renderer.drawRect(bx, by, bw, bh, black);
    renderer.drawLine(bx + bw / 3, by, bx + bw / 3, by + bh - 1, black);
    // Pages
@ -88,8 +77,8 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    // Folder icon
    int fw = w * 3 / 4;
    int fh = h * 2 / 3;
-    int fx = iconX + (w - fw) / 2;
-    int fy = iconY + (h - fh) / 2;
+    int fx = absX + (w - fw) / 2;
+    int fy = absY + (h - fh) / 2;
    // Tab
    renderer.fillRect(fx, fy, fw / 3, fh / 6, black);
    // Body
@ -104,15 +93,15 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    renderer.drawRect(cx - ir, cy - ir, ir * 2, ir * 2, black);
    // Teeth
    int t = r / 3;
-    renderer.fillRect(cx - t / 2, iconY, t, r - ir, black);
+    renderer.fillRect(cx - t / 2, absY, t, r - ir, black);
    renderer.fillRect(cx - t / 2, cy + r, t, r - ir, black);
-    renderer.fillRect(iconX, cy - t / 2, r - ir, t, black);
+    renderer.fillRect(absX, cy - t / 2, r - ir, t, black);
    renderer.fillRect(cx + r, cy - t / 2, r - ir, t, black);
  } else if (iconName == "transfer" || iconName == "arrow" || iconName == "send") {
    // Arrow pointing right
    int aw = w / 2;
    int ah = h / 3;
-    int ax = iconX + w / 4;
+    int ax = absX + w / 4;
    int ay = cy - ah / 2;
    // Shaft
    renderer.fillRect(ax, ay, aw, ah, black);
@ -125,8 +114,8 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    // Device/tablet icon
    int dw = w * 2 / 3;
    int dh = h * 3 / 4;
-    int dx = iconX + (w - dw) / 2;
-    int dy = iconY + (h - dh) / 2;
+    int dx = absX + (w - dw) / 2;
+    int dy = absY + (h - dh) / 2;
    renderer.drawRect(dx, dy, dw, dh, black);
    // Screen
    renderer.drawRect(dx + 2, dy + 2, dw - 4, dh - 8, black);
@ -136,18 +125,18 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
    // Battery icon
    int bw = w * 3 / 4;
    int bh = h / 2;
-    int bx = iconX + (w - bw) / 2;
-    int by = iconY + (h - bh) / 2;
+    int bx = absX + (w - bw) / 2;
+    int by = absY + (h - bh) / 2;
    renderer.drawRect(bx, by, bw - 3, bh, black);
    renderer.fillRect(bx + bw - 3, by + bh / 4, 3, bh / 2, black);
  } else if (iconName == "check" || iconName == "checkmark") {
-    // Checkmark - use iconX/iconY for proper centering
-    int x1 = iconX + w / 4;
+    // Checkmark
+    int x1 = absX + w / 4;
    int y1 = cy;
    int x2 = cx;
-    int y2 = iconY + h * 3 / 4;
-    int x3 = iconX + w * 3 / 4;
-    int y3 = iconY + h / 4;
+    int y2 = absY + h * 3 / 4;
+    int x3 = absX + w * 3 / 4;
+    int y3 = absY + h / 4;
    renderer.drawLine(x1, y1, x2, y2, black);
    renderer.drawLine(x2, y2, x3, y3, black);
    // Thicken
@ -174,18 +163,11 @@ void Icon::draw(const GfxRenderer& renderer, const ThemeContext& context) {
      renderer.drawLine(cx, cy + s - i, cx - s + i, cy, black);
      renderer.drawLine(cx, cy + s - i, cx + s - i, cy, black);
    }
-  } else if (iconName == "right") {
-    // Right arrow
-    int s = w / 3;
-    for (int i = 0; i < s; i++) {
-      renderer.drawLine(cx + s - i, cy, cx, cy - s + i, black);
-      renderer.drawLine(cx + s - i, cy, cx, cy + s - i, black);
-    }
  } else {
    // Unknown icon - draw placeholder
-    renderer.drawRect(iconX, iconY, w, h, black);
-    renderer.drawLine(iconX, iconY, iconX + w - 1, iconY + h - 1, black);
-    renderer.drawLine(iconX + w - 1, iconY, iconX, iconY + h - 1, black);
+    renderer.drawRect(absX, absY, w, h, black);
+    renderer.drawLine(absX, absY, absX + w - 1, absY + h - 1, black);
+    renderer.drawLine(absX + w - 1, absY, absX, absY + h - 1, black);
  }

  markClean();
--- a/lib/ThemeEngine/src/ThemeManager.cpp
+++ b/lib/ThemeEngine/src/ThemeManager.cpp
@ -3,7 +3,6 @@
 #include <SDCardManager.h>

 #include <algorithm>
-#include <cstdlib>
 #include <map>
 #include <vector>

@ -13,7 +12,9 @@

 namespace ThemeEngine {

-void ThemeManager::begin() {}
+void ThemeManager::begin() {
+  // Default fonts or setup
+}

 void ThemeManager::registerFont(const std::string& name, int id) { fontMap[name] = id; }

@ -62,7 +63,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
    const std::string& key = kv.first;
    const std::string& val = kv.second;

-    // Common properties
+    // ========== Common properties ==========
    if (key == "X")
      elem->setX(Dimension::parse(val));
    else if (key == "Y")
@ -76,7 +77,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
    else if (key == "Cacheable")
      elem->setCacheable(val == "true" || val == "1");

-    // Rectangle properties
+    // ========== Rectangle properties ==========
    else if (key == "Fill") {
      if (elemType == UIElement::ElementType::Rectangle) {
        auto rect = static_cast<Rectangle*>(elem);
@ -104,7 +105,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    }

-    // Container properties
+    // ========== Container properties ==========
    else if (key == "Border") {
      if (auto c = elem->asContainer()) {
        if (val.find('{') != std::string::npos) {
@ -116,42 +117,36 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
    } else if (key == "Padding") {
      if (elemType == UIElement::ElementType::Container || elemType == UIElement::ElementType::HStack ||
          elemType == UIElement::ElementType::VStack || elemType == UIElement::ElementType::Grid) {
-        static_cast<Container*>(elem)->setPadding(parseIntSafe(val));
+        static_cast<Container*>(elem)->setPadding(std::stoi(val));
      } else if (elemType == UIElement::ElementType::TabBar) {
-        static_cast<TabBar*>(elem)->setPadding(parseIntSafe(val));
+        static_cast<TabBar*>(elem)->setPadding(std::stoi(val));
      }
    } else if (key == "BorderRadius") {
      if (elemType == UIElement::ElementType::Container || elemType == UIElement::ElementType::HStack ||
          elemType == UIElement::ElementType::VStack || elemType == UIElement::ElementType::Grid) {
-        static_cast<Container*>(elem)->setBorderRadius(parseIntSafe(val));
+        static_cast<Container*>(elem)->setBorderRadius(std::stoi(val));
      } else if (elemType == UIElement::ElementType::Bitmap) {
-        static_cast<BitmapElement*>(elem)->setBorderRadius(parseIntSafe(val));
-      } else if (elemType == UIElement::ElementType::Rectangle) {
-        static_cast<Rectangle*>(elem)->setBorderRadius(parseIntSafe(val));
-      } else if (elemType == UIElement::ElementType::Badge) {
-        static_cast<Badge*>(elem)->setBorderRadius(parseIntSafe(val));
-      } else if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setBorderRadius(parseIntSafe(val));
+        static_cast<BitmapElement*>(elem)->setBorderRadius(std::stoi(val));
      }
    } else if (key == "Spacing") {
      if (elemType == UIElement::ElementType::HStack) {
-        static_cast<HStack*>(elem)->setSpacing(parseIntSafe(val));
+        static_cast<HStack*>(elem)->setSpacing(std::stoi(val));
      } else if (elemType == UIElement::ElementType::VStack) {
-        static_cast<VStack*>(elem)->setSpacing(parseIntSafe(val));
+        static_cast<VStack*>(elem)->setSpacing(std::stoi(val));
      } else if (elemType == UIElement::ElementType::List) {
-        static_cast<List*>(elem)->setSpacing(parseIntSafe(val));
+        static_cast<List*>(elem)->setSpacing(std::stoi(val));
      }
-    } else if (key == "VAlign") {
+    } else if (key == "CenterVertical") {
      if (elemType == UIElement::ElementType::HStack) {
-        static_cast<HStack*>(elem)->setVAlignFromString(val);
+        static_cast<HStack*>(elem)->setCenterVertical(val == "true" || val == "1");
      }
-    } else if (key == "HAlign") {
+    } else if (key == "CenterHorizontal") {
      if (elemType == UIElement::ElementType::VStack) {
-        static_cast<VStack*>(elem)->setHAlignFromString(val);
+        static_cast<VStack*>(elem)->setCenterHorizontal(val == "true" || val == "1");
      }
    }

-    // Label properties
+    // ========== Label properties ==========
    else if (key == "Text") {
      if (elemType == UIElement::ElementType::Label) {
        static_cast<Label*>(elem)->setText(val);
@ -181,7 +176,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    } else if (key == "MaxLines") {
      if (elemType == UIElement::ElementType::Label) {
-        static_cast<Label*>(elem)->setMaxLines(parseIntSafe(val));
+        static_cast<Label*>(elem)->setMaxLines(std::stoi(val));
      }
    } else if (key == "Ellipsis") {
      if (elemType == UIElement::ElementType::Label) {
@ -189,7 +184,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    }

-    // Bitmap/Icon properties
+    // ========== Bitmap/Icon properties ==========
    else if (key == "Src") {
      if (elemType == UIElement::ElementType::Bitmap) {
        auto b = static_cast<BitmapElement*>(elem);
@ -211,11 +206,11 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    } else if (key == "IconSize") {
      if (elemType == UIElement::ElementType::Icon) {
-        static_cast<Icon*>(elem)->setIconSize(parseIntSafe(val));
+        static_cast<Icon*>(elem)->setIconSize(std::stoi(val));
      }
    }

-    // List properties
+    // ========== List properties ==========
    else if (key == "Source") {
      if (elemType == UIElement::ElementType::List) {
        static_cast<List*>(elem)->setSource(val);
@ -226,11 +221,11 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    } else if (key == "ItemHeight") {
      if (elemType == UIElement::ElementType::List) {
-        static_cast<List*>(elem)->setItemHeight(parseIntSafe(val));
+        static_cast<List*>(elem)->setItemHeight(std::stoi(val));
      }
    } else if (key == "ItemWidth") {
      if (elemType == UIElement::ElementType::List) {
-        static_cast<List*>(elem)->setItemWidth(parseIntSafe(val));
+        static_cast<List*>(elem)->setItemWidth(std::stoi(val));
      }
    } else if (key == "Direction") {
      if (elemType == UIElement::ElementType::List) {
@ -238,21 +233,21 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    } else if (key == "Columns") {
      if (elemType == UIElement::ElementType::List) {
-        static_cast<List*>(elem)->setColumns(parseIntSafe(val));
+        static_cast<List*>(elem)->setColumns(std::stoi(val));
      } else if (elemType == UIElement::ElementType::Grid) {
-        static_cast<Grid*>(elem)->setColumns(parseIntSafe(val));
+        static_cast<Grid*>(elem)->setColumns(std::stoi(val));
      }
    } else if (key == "RowSpacing") {
      if (elemType == UIElement::ElementType::Grid) {
-        static_cast<Grid*>(elem)->setRowSpacing(parseIntSafe(val));
+        static_cast<Grid*>(elem)->setRowSpacing(std::stoi(val));
      }
    } else if (key == "ColSpacing") {
      if (elemType == UIElement::ElementType::Grid) {
-        static_cast<Grid*>(elem)->setColSpacing(parseIntSafe(val));
+        static_cast<Grid*>(elem)->setColSpacing(std::stoi(val));
      }
    }

-    // ProgressBar properties
+    // ========== ProgressBar properties ==========
    else if (key == "Value") {
      if (elemType == UIElement::ElementType::ProgressBar) {
        static_cast<ProgressBar*>(elem)->setValue(val);
@ -286,18 +281,18 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    }

-    // Divider properties
+    // ========== Divider properties ==========
    else if (key == "Horizontal") {
      if (elemType == UIElement::ElementType::Divider) {
        static_cast<Divider*>(elem)->setHorizontal(val == "true" || val == "1");
      }
    } else if (key == "Thickness") {
      if (elemType == UIElement::ElementType::Divider) {
-        static_cast<Divider*>(elem)->setThickness(parseIntSafe(val));
+        static_cast<Divider*>(elem)->setThickness(std::stoi(val));
      }
    }

-    // Toggle properties
+    // ========== Toggle properties ==========
    else if (key == "OnColor") {
      if (elemType == UIElement::ElementType::Toggle) {
        static_cast<Toggle*>(elem)->setOnColor(val);
@ -306,42 +301,34 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      if (elemType == UIElement::ElementType::Toggle) {
        static_cast<Toggle*>(elem)->setOffColor(val);
      }
-    } else if (key == "KnobColor") {
-      if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setKnobColor(val);
-      }
    } else if (key == "TrackWidth") {
      if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setTrackWidth(parseIntSafe(val));
+        static_cast<Toggle*>(elem)->setTrackWidth(std::stoi(val));
      } else if (elemType == UIElement::ElementType::ScrollIndicator) {
-        static_cast<ScrollIndicator*>(elem)->setTrackWidth(parseIntSafe(val));
+        static_cast<ScrollIndicator*>(elem)->setTrackWidth(std::stoi(val));
      }
    } else if (key == "TrackHeight") {
      if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setTrackHeight(parseIntSafe(val));
+        static_cast<Toggle*>(elem)->setTrackHeight(std::stoi(val));
      }
    } else if (key == "KnobSize") {
      if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setKnobSize(parseIntSafe(val));
-      }
-    } else if (key == "KnobRadius") {
-      if (elemType == UIElement::ElementType::Toggle) {
-        static_cast<Toggle*>(elem)->setKnobRadius(parseIntSafe(val));
+        static_cast<Toggle*>(elem)->setKnobSize(std::stoi(val));
      }
    }

-    // TabBar properties
+    // ========== TabBar properties ==========
    else if (key == "Selected") {
      if (elemType == UIElement::ElementType::TabBar) {
        static_cast<TabBar*>(elem)->setSelected(val);
      }
    } else if (key == "TabSpacing") {
      if (elemType == UIElement::ElementType::TabBar) {
-        static_cast<TabBar*>(elem)->setTabSpacing(parseIntSafe(val));
+        static_cast<TabBar*>(elem)->setTabSpacing(std::stoi(val));
      }
    } else if (key == "IndicatorHeight") {
      if (elemType == UIElement::ElementType::TabBar) {
-        static_cast<TabBar*>(elem)->setIndicatorHeight(parseIntSafe(val));
+        static_cast<TabBar*>(elem)->setIndicatorHeight(std::stoi(val));
      }
    } else if (key == "ShowIndicator") {
      if (elemType == UIElement::ElementType::TabBar) {
@ -349,7 +336,7 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    }

-    // ScrollIndicator properties
+    // ========== ScrollIndicator properties ==========
    else if (key == "Position") {
      if (elemType == UIElement::ElementType::ScrollIndicator) {
        static_cast<ScrollIndicator*>(elem)->setPosition(val);
@ -364,14 +351,14 @@ void ThemeManager::applyProperties(UIElement* elem, const std::map<std::string,
      }
    }

-    // Badge properties
+    // ========== Badge properties ==========
    else if (key == "PaddingH") {
      if (elemType == UIElement::ElementType::Badge) {
-        static_cast<Badge*>(elem)->setPaddingH(parseIntSafe(val));
+        static_cast<Badge*>(elem)->setPaddingH(std::stoi(val));
      }
    } else if (key == "PaddingV") {
      if (elemType == UIElement::ElementType::Badge) {
-        static_cast<Badge*>(elem)->setPaddingV(parseIntSafe(val));
+        static_cast<Badge*>(elem)->setPaddingV(std::stoi(val));
      }
    }
  }
@ -396,12 +383,9 @@ const std::vector<uint8_t>* ThemeManager::getCachedAsset(const std::string& path
  return nullptr;
 }

-void ThemeManager::cacheAsset(const std::string& path, std::vector<uint8_t>&& data) {
-  assetCache[path] = std::move(data);
-}
-
 const ProcessedAsset* ThemeManager::getProcessedAsset(const std::string& path, GfxRenderer::Orientation orientation,
                                                      int targetW, int targetH) {
+  // Include dimensions in cache key for scaled images
  std::string cacheKey = path;
  if (targetW > 0 && targetH > 0) {
    cacheKey += ":" + std::to_string(targetW) + "x" + std::to_string(targetH);
@ -430,8 +414,8 @@ void ThemeManager::clearAssetCaches() {
 }

 void ThemeManager::unloadTheme() {
-  for (auto& kv : elements) {
-    delete kv.second;
+  for (auto it = elements.begin(); it != elements.end(); ++it) {
+    delete it->second;
  }
  elements.clear();
  clearAssetCaches();
@ -472,23 +456,30 @@ void ThemeManager::loadTheme(const std::string& themeName) {
      if (SdMan.openFileForRead("Theme", path, file)) {
        sections = IniParser::parse(file);
        file.close();
+        Serial.println("[ThemeManager] Loaded Default theme from SD card");
      }
    } else {
+      Serial.println("[ThemeManager] Using embedded Default theme");
      sections = IniParser::parseString(getDefaultThemeIni());
    }
    currentThemeName = "Default";
  } else {
    std::string path = "/themes/" + themeName + "/theme.ini";
+    Serial.printf("[ThemeManager] Checking path: %s\n", path.c_str());

    if (!SdMan.exists(path.c_str())) {
+      Serial.printf("[ThemeManager] Theme %s not found, using Default\n", themeName.c_str());
      sections = IniParser::parseString(getDefaultThemeIni());
      currentThemeName = "Default";
    } else {
      FsFile file;
      if (SdMan.openFileForRead("Theme", path, file)) {
+        Serial.printf("[ThemeManager] Parsing theme file...\n");
        sections = IniParser::parse(file);
        file.close();
+        Serial.printf("[ThemeManager] Parsed %d sections from %s\n", (int)sections.size(), themeName.c_str());
      } else {
+        Serial.printf("[ThemeManager] Failed to open %s, using Default\n", path.c_str());
        sections = IniParser::parseString(getDefaultThemeIni());
        currentThemeName = "Default";
      }
@ -496,27 +487,26 @@ void ThemeManager::loadTheme(const std::string& themeName) {
  }

  // Read theme configuration from [Global] section
-  navBookCount = 1;
+  navBookCount = 1;  // Default
  if (sections.count("Global")) {
    const auto& global = sections.at("Global");
    if (global.count("NavBookCount")) {
-      navBookCount = parseIntSafe(global.at("NavBookCount"));
+      navBookCount = std::stoi(global.at("NavBookCount"));
      if (navBookCount < 1) navBookCount = 1;
-      if (navBookCount > 10) navBookCount = 10;
+      if (navBookCount > 10) navBookCount = 10;  // Reasonable max
    }
  }

-  // Pass 1: Create elements
+  // Pass 1: Creation
  for (const auto& sec : sections) {
-    const std::string& id = sec.first;
+    std::string id = sec.first;
    const std::map<std::string, std::string>& props = sec.second;

    if (id == "Global") continue;

    auto it = props.find("Type");
    if (it == props.end()) continue;
-
-    const std::string& type = it->second;
+    std::string type = it->second;
    if (type.empty()) continue;

    UIElement* elem = createElement(id, type);
@ -525,10 +515,10 @@ void ThemeManager::loadTheme(const std::string& themeName) {
    }
  }

-  // Pass 2: Apply properties and wire parent relationships
+  // Pass 2: Properties & Parent Wiring
  std::vector<List*> lists;
  for (const auto& sec : sections) {
-    const std::string& id = sec.first;
+    std::string id = sec.first;
    if (id == "Global") continue;
    if (elements.find(id) == elements.end()) continue;

@ -539,85 +529,44 @@ void ThemeManager::loadTheme(const std::string& themeName) {
      lists.push_back(static_cast<List*>(elem));
    }

-    // Wire parent relationship (fallback if Children not specified)
    if (sec.second.count("Parent")) {
-      const std::string& parentId = sec.second.at("Parent");
+      std::string parentId = sec.second.at("Parent");
      if (elements.count(parentId)) {
        UIElement* parent = elements[parentId];
        if (auto c = parent->asContainer()) {
-          const auto& children = c->getChildren();
-          if (std::find(children.begin(), children.end(), elem) == children.end()) {
-            c->addChild(elem);
-          }
+          c->addChild(elem);
        }
-      }
-    }
-
-    // Children property - explicit ordering
-    if (sec.second.count("Children")) {
-      if (auto c = elem->asContainer()) {
-        c->clearChildren();
-
-        std::string s = sec.second.at("Children");
-        size_t pos = 0;
-
-        auto processChild = [&](const std::string& childName) {
-          std::string childId = childName;
-          size_t start = childId.find_first_not_of(" ");
-          size_t end = childId.find_last_not_of(" ");
-          if (start == std::string::npos) return;
-          childId = childId.substr(start, end - start + 1);
-
-          if (elements.count(childId)) {
-            c->addChild(elements[childId]);
-          }
-        };
-
-        while ((pos = s.find(',')) != std::string::npos) {
-          processChild(s.substr(0, pos));
-          s.erase(0, pos + 1);
-        }
-        processChild(s);
+      } else {
+        Serial.printf("[ThemeManager] WARN: Parent %s not found for %s\n", parentId.c_str(), id.c_str());
      }
    }
  }

-  // Pass 3: Resolve list templates
-  for (auto* l : lists) {
+  // Pass 3: Resolve List Templates
+  for (auto l : lists) {
    l->resolveTemplate(elements);
  }
+
+  Serial.printf("[ThemeManager] Theme loaded with %d elements\n", (int)elements.size());
 }

 void ThemeManager::renderScreen(const std::string& screenName, const GfxRenderer& renderer,
                                const ThemeContext& context) {
  if (elements.count(screenName) == 0) {
+    Serial.printf("[ThemeManager] Screen '%s' not found\n", screenName.c_str());
    return;
  }

  UIElement* root = elements[screenName];
+
  root->layout(context, 0, 0, renderer.getScreenWidth(), renderer.getScreenHeight());
+
  root->draw(renderer, context);
 }

 void ThemeManager::renderScreenOptimized(const std::string& screenName, const GfxRenderer& renderer,
                                         const ThemeContext& context, const ThemeContext* prevContext) {
-  if (elements.count(screenName) == 0) {
-    return;
-  }
-
-  UIElement* root = elements[screenName];
-
-  // Layout uses internal caching - will skip if params unchanged
-  root->layout(context, 0, 0, renderer.getScreenWidth(), renderer.getScreenHeight());
-
-  // If no previous context provided, do full draw
-  if (!prevContext) {
-    root->draw(renderer, context);
-    return;
-  }
-
-  // Draw elements - dirty tracking is handled internally by each element
-  root->draw(renderer, context);
+  renderScreen(screenName, renderer, context);
 }

 }  // namespace ThemeEngine
--- a/lib/Xtc/Xtc.cpp
+++ b/lib/Xtc/Xtc.cpp
@ -7,6 +7,7 @@

 #include "Xtc.h"

+#include <FsHelpers.h>
 #include <HardwareSerial.h>
 #include <SDCardManager.h>

@ -86,15 +87,6 @@ std::string Xtc::getTitle() const {
  return filepath.substr(lastSlash, lastDot - lastSlash);
 }

-std::string Xtc::getAuthor() const {
-  if (!loaded || !parser) {
-    return "";
-  }
-
-  // Try to get author from XTC metadata
-  return parser->getAuthor();
-}
-
 bool Xtc::hasChapters() const {
  if (!loaded || !parser) {
    return false;
--- a/lib/Xtc/Xtc.h
+++ b/lib/Xtc/Xtc.h
@ -56,7 +56,6 @@ class Xtc {

  // Metadata
  std::string getTitle() const;
-  std::string getAuthor() const;
  bool hasChapters() const;
  const std::vector<xtc::ChapterInfo>& getChapters() const;

--- a/lib/Xtc/Xtc/XtcParser.cpp
+++ b/lib/Xtc/Xtc/XtcParser.cpp
@ -47,21 +47,8 @@ XtcError XtcParser::open(const char* filepath) {
    return m_lastError;
  }

-  // Read title & author if available
-  if (m_header.hasMetadata) {
-    m_lastError = readTitle();
-    if (m_lastError != XtcError::OK) {
-      Serial.printf("[%lu] [XTC] Failed to read title: %s\n", millis(), errorToString(m_lastError));
-      m_file.close();
-      return m_lastError;
-    }
-    m_lastError = readAuthor();
-    if (m_lastError != XtcError::OK) {
-      Serial.printf("[%lu] [XTC] Failed to read author: %s\n", millis(), errorToString(m_lastError));
-      m_file.close();
-      return m_lastError;
-    }
-  }
+  // Read title if available
+  readTitle();

  // Read page table
  m_lastError = readPageTable();
@ -137,34 +124,24 @@ XtcError XtcParser::readHeader() {
 }

 XtcError XtcParser::readTitle() {
-  constexpr auto titleOffset = 0x38;
-  if (!m_file.seek(titleOffset)) {
+  // Title is usually at offset 0x38 (56) for 88-byte headers
+  // Read title as null-terminated UTF-8 string
+  if (m_header.titleOffset == 0) {
+    m_header.titleOffset = 0x38;  // Default offset
+  }
+
+  if (!m_file.seek(m_header.titleOffset)) {
    return XtcError::READ_ERROR;
  }

  char titleBuf[128] = {0};
-  m_file.read(titleBuf, sizeof(titleBuf) - 1);
+  m_file.read(reinterpret_cast<uint8_t*>(titleBuf), sizeof(titleBuf) - 1);
  m_title = titleBuf;

  Serial.printf("[%lu] [XTC] Title: %s\n", millis(), m_title.c_str());
  return XtcError::OK;
 }

-XtcError XtcParser::readAuthor() {
-  // Read author as null-terminated UTF-8 string with max length 64, directly following title
-  constexpr auto authorOffset = 0xB8;
-  if (!m_file.seek(authorOffset)) {
-    return XtcError::READ_ERROR;
-  }
-
-  char authorBuf[64] = {0};
-  m_file.read(authorBuf, sizeof(authorBuf) - 1);
-  m_author = authorBuf;
-
-  Serial.printf("[%lu] [XTC] Author: %s\n", millis(), m_author.c_str());
-  return XtcError::OK;
-}
-
 XtcError XtcParser::readPageTable() {
  if (m_header.pageTableOffset == 0) {
    Serial.printf("[%lu] [XTC] Page table offset is 0, cannot read\n", millis());
--- a/lib/Xtc/Xtc/XtcParser.h
+++ b/lib/Xtc/Xtc/XtcParser.h
@ -67,9 +67,8 @@ class XtcParser {
                             std::function<void(const uint8_t* data, size_t size, size_t offset)> callback,
                             size_t chunkSize = 1024);

-  // Get title/author from metadata
+  // Get title from metadata
  std::string getTitle() const { return m_title; }
-  std::string getAuthor() const { return m_author; }

  bool hasChapters() const { return m_hasChapters; }
  const std::vector<ChapterInfo>& getChapters() const { return m_chapters; }
@ -87,7 +86,6 @@ class XtcParser {
  std::vector<PageInfo> m_pageTable;
  std::vector<ChapterInfo> m_chapters;
  std::string m_title;
-  std::string m_author;
  uint16_t m_defaultWidth;
  uint16_t m_defaultHeight;
  uint8_t m_bitDepth;  // 1 = XTC/XTG (1-bit), 2 = XTCH/XTH (2-bit)
@ -98,7 +96,6 @@ class XtcParser {
  XtcError readHeader();
  XtcError readPageTable();
  XtcError readTitle();
-  XtcError readAuthor();
  XtcError readChapters();
 };

--- a/lib/Xtc/Xtc/XtcTypes.h
+++ b/lib/Xtc/Xtc/XtcTypes.h
@ -38,16 +38,14 @@ struct XtcHeader {
  uint8_t versionMajor;      // 0x04: Format version major (typically 1) (together with minor = 1.0)
  uint8_t versionMinor;      // 0x05: Format version minor (typically 0)
  uint16_t pageCount;        // 0x06: Total page count
-  uint8_t readDirection;     // 0x08: Reading direction (0-2)
-  uint8_t hasMetadata;       // 0x09: Has metadata (0-1)
-  uint8_t hasThumbnails;     // 0x0A: Has thumbnails (0-1)
-  uint8_t hasChapters;       // 0x0B: Has chapters (0-1)
-  uint32_t currentPage;      // 0x0C: Current page (1-based) (0-65535)
-  uint64_t metadataOffset;   // 0x10: Metadata offset (0 if unused)
+  uint32_t flags;            // 0x08: Flags/reserved
+  uint32_t headerSize;       // 0x0C: Size of header section (typically 88)
+  uint32_t reserved1;        // 0x10: Reserved
+  uint32_t tocOffset;        // 0x14: TOC offset (0 if unused) - 4 bytes, not 8!
  uint64_t pageTableOffset;  // 0x18: Page table offset
  uint64_t dataOffset;       // 0x20: First page data offset
-  uint64_t thumbOffset;      // 0x28: Thumbnail offset
-  uint32_t chapterOffset;    // 0x30: Chapter data offset
+  uint64_t reserved2;        // 0x28: Reserved
+  uint32_t titleOffset;      // 0x30: Title string offset
  uint32_t padding;          // 0x34: Padding to 56 bytes
 };
 #pragma pack(pop)
--- a/lib/ZipFile/ZipFile.cpp
+++ b/lib/ZipFile/ZipFile.cpp
@ -4,8 +4,6 @@
 #include <SDCardManager.h>
 #include <miniz.h>

-#include <algorithm>
-
 bool inflateOneShot(const uint8_t* inputBuf, const size_t deflatedSize, uint8_t* outputBuf, const size_t inflatedSize) {
  // Setup inflator
  const auto inflator = static_cast<tinfl_decompressor*>(malloc(sizeof(tinfl_decompressor)));
@ -76,10 +74,6 @@ bool ZipFile::loadAllFileStatSlims() {
    file.seekCur(m + k);
  }

-  // Set cursor to start of central directory for sequential access
-  lastCentralDirPos = zipDetails.centralDirOffset;
-  lastCentralDirPosValid = true;
-
  if (!wasOpen) {
    close();
  }
@ -108,35 +102,15 @@ bool ZipFile::loadFileStatSlim(const char* filename, FileStatSlim* fileStat) {
    return false;
  }

-  // Phase 1: Try scanning from cursor position first
-  uint32_t startPos = lastCentralDirPosValid ? lastCentralDirPos : zipDetails.centralDirOffset;
-  uint32_t wrapPos = zipDetails.centralDirOffset;
-  bool wrapped = false;
-  bool found = false;
-
-  file.seek(startPos);
+  file.seek(zipDetails.centralDirOffset);

  uint32_t sig;
  char itemName[256];
+  bool found = false;

-  while (true) {
-    uint32_t entryStart = file.position();
-
-    if (file.read(&sig, 4) != 4 || sig != 0x02014b50) {
-      // End of central directory
-      if (!wrapped && lastCentralDirPosValid && startPos != zipDetails.centralDirOffset) {
-        // Wrap around to beginning
-        file.seek(zipDetails.centralDirOffset);
-        wrapped = true;
-        continue;
-      }
-      break;
-    }
-
-    // If we've wrapped and reached our start position, stop
-    if (wrapped && entryStart >= startPos) {
-      break;
-    }
+  while (file.available()) {
+    file.read(&sig, 4);
+    if (sig != 0x02014b50) break;  // End of list

    file.seekCur(6);
    file.read(&fileStat->method, 2);
@ -149,25 +123,15 @@ bool ZipFile::loadFileStatSlim(const char* filename, FileStatSlim* fileStat) {
    file.read(&k, 2);
    file.seekCur(8);
    file.read(&fileStat->localHeaderOffset, 4);
+    file.read(itemName, nameLen);
+    itemName[nameLen] = '\0';

-    if (nameLen < 256) {
-      file.read(itemName, nameLen);
-      itemName[nameLen] = '\0';
-
-      if (strcmp(itemName, filename) == 0) {
-        // Found it! Update cursor to next entry
-        file.seekCur(m + k);
-        lastCentralDirPos = file.position();
-        lastCentralDirPosValid = true;
-        found = true;
-        break;
-      }
-    } else {
-      // Name too long, skip it
-      file.seekCur(nameLen);
+    if (strcmp(itemName, filename) == 0) {
+      found = true;
+      break;
    }

-    // Skip extra field + comment
+    // Skip the rest of this entry (extra field + comment)
    file.seekCur(m + k);
  }

@ -289,8 +253,6 @@ bool ZipFile::close() {
  if (file) {
    file.close();
  }
-  lastCentralDirPos = 0;
-  lastCentralDirPosValid = false;
  return true;
 }

@ -304,80 +266,6 @@ bool ZipFile::getInflatedFileSize(const char* filename, size_t* size) {
  return true;
 }

-int ZipFile::fillUncompressedSizes(std::vector<SizeTarget>& targets, std::vector<uint32_t>& sizes) {
-  if (targets.empty()) {
-    return 0;
-  }
-
-  const bool wasOpen = isOpen();
-  if (!wasOpen && !open()) {
-    return 0;
-  }
-
-  if (!loadZipDetails()) {
-    if (!wasOpen) {
-      close();
-    }
-    return 0;
-  }
-
-  file.seek(zipDetails.centralDirOffset);
-
-  int matched = 0;
-  uint32_t sig;
-  char itemName[256];
-
-  while (file.available()) {
-    file.read(&sig, 4);
-    if (sig != 0x02014b50) break;
-
-    file.seekCur(6);
-    uint16_t method;
-    file.read(&method, 2);
-    file.seekCur(8);
-    uint32_t compressedSize, uncompressedSize;
-    file.read(&compressedSize, 4);
-    file.read(&uncompressedSize, 4);
-    uint16_t nameLen, m, k;
-    file.read(&nameLen, 2);
-    file.read(&m, 2);
-    file.read(&k, 2);
-    file.seekCur(8);
-    uint32_t localHeaderOffset;
-    file.read(&localHeaderOffset, 4);
-
-    if (nameLen < 256) {
-      file.read(itemName, nameLen);
-      itemName[nameLen] = '\0';
-
-      uint64_t hash = fnvHash64(itemName, nameLen);
-      SizeTarget key = {hash, nameLen, 0};
-
-      auto it = std::lower_bound(targets.begin(), targets.end(), key, [](const SizeTarget& a, const SizeTarget& b) {
-        return a.hash < b.hash || (a.hash == b.hash && a.len < b.len);
-      });
-
-      while (it != targets.end() && it->hash == hash && it->len == nameLen) {
-        if (it->index < sizes.size()) {
-          sizes[it->index] = uncompressedSize;
-          matched++;
-        }
-        ++it;
-      }
-    } else {
-      file.seekCur(nameLen);
-    }
-
-    file.seekCur(m + k);
-  }
-
-  if (!wasOpen) {
-    close();
-  }
-
-  return matched;
-}
-
 uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const bool trailingNullByte) {
  const bool wasOpen = isOpen();
  if (!wasOpen && !open()) {
--- a/lib/ZipFile/ZipFile.h
+++ b/lib/ZipFile/ZipFile.h
@ -3,7 +3,6 @@

 #include <string>
 #include <unordered_map>
-#include <vector>

 class ZipFile {
 public:
@ -20,33 +19,12 @@ class ZipFile {
    bool isSet;
  };

-  // Target for batch uncompressed size lookup (sorted by hash, then len)
-  struct SizeTarget {
-    uint64_t hash;   // FNV-1a 64-bit hash of normalized path
-    uint16_t len;    // Length of path for collision reduction
-    uint16_t index;  // Caller's index (e.g. spine index)
-  };
-
-  // FNV-1a 64-bit hash computed from char buffer (no std::string allocation)
-  static uint64_t fnvHash64(const char* s, size_t len) {
-    uint64_t hash = 14695981039346656037ull;
-    for (size_t i = 0; i < len; i++) {
-      hash ^= static_cast<uint8_t>(s[i]);
-      hash *= 1099511628211ull;
-    }
-    return hash;
-  }
-
 private:
  const std::string& filePath;
  FsFile file;
  ZipDetails zipDetails = {0, 0, false};
  std::unordered_map<std::string, FileStatSlim> fileStatSlimCache;

-  // Cursor for sequential central-dir scanning optimization
-  uint32_t lastCentralDirPos = 0;
-  bool lastCentralDirPosValid = false;
-
  bool loadFileStatSlim(const char* filename, FileStatSlim* fileStat);
  long getDataOffset(const FileStatSlim& fileStat);
  bool loadZipDetails();
@ -61,10 +39,6 @@ class ZipFile {
  bool close();
  bool loadAllFileStatSlims();
  bool getInflatedFileSize(const char* filename, size_t* size);
-  // Batch lookup: scan ZIP central dir once and fill sizes for matching targets.
-  // targets must be sorted by (hash, len). sizes[target.index] receives uncompressedSize.
-  // Returns number of targets matched.
-  int fillUncompressedSizes(std::vector<SizeTarget>& targets, std::vector<uint32_t>& sizes);
  // Due to the memory required to run each of these, it is recommended to not preopen the zip file for multiple
  // These functions will open and close the zip as needed
  uint8_t* readFileToMemory(const char* filename, size_t* size = nullptr, bool trailingNullByte = false);
--- a/lib/hal/HalDisplay.cpp
+++ b/lib/hal/HalDisplay.cpp
@ -1,51 +0,0 @@
-#include <HalDisplay.h>
-#include <HalGPIO.h>
-
-#define SD_SPI_MISO 7
-
-HalDisplay::HalDisplay() : einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY) {}
-
-HalDisplay::~HalDisplay() {}
-
-void HalDisplay::begin() { einkDisplay.begin(); }
-
-void HalDisplay::clearScreen(uint8_t color) const { einkDisplay.clearScreen(color); }
-
-void HalDisplay::drawImage(const uint8_t* imageData, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
-                           bool fromProgmem) const {
-  einkDisplay.drawImage(imageData, x, y, w, h, fromProgmem);
-}
-
-EInkDisplay::RefreshMode convertRefreshMode(HalDisplay::RefreshMode mode) {
-  switch (mode) {
-    case HalDisplay::FULL_REFRESH:
-      return EInkDisplay::FULL_REFRESH;
-    case HalDisplay::HALF_REFRESH:
-      return EInkDisplay::HALF_REFRESH;
-    case HalDisplay::FAST_REFRESH:
-    default:
-      return EInkDisplay::FAST_REFRESH;
-  }
-}
-
-void HalDisplay::displayBuffer(HalDisplay::RefreshMode mode) { einkDisplay.displayBuffer(convertRefreshMode(mode)); }
-
-void HalDisplay::refreshDisplay(HalDisplay::RefreshMode mode, bool turnOffScreen) {
-  einkDisplay.refreshDisplay(convertRefreshMode(mode), turnOffScreen);
-}
-
-void HalDisplay::deepSleep() { einkDisplay.deepSleep(); }
-
-uint8_t* HalDisplay::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
-
-void HalDisplay::copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer) {
-  einkDisplay.copyGrayscaleBuffers(lsbBuffer, msbBuffer);
-}
-
-void HalDisplay::copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer) { einkDisplay.copyGrayscaleLsbBuffers(lsbBuffer); }
-
-void HalDisplay::copyGrayscaleMsbBuffers(const uint8_t* msbBuffer) { einkDisplay.copyGrayscaleMsbBuffers(msbBuffer); }
-
-void HalDisplay::cleanupGrayscaleBuffers(const uint8_t* bwBuffer) { einkDisplay.cleanupGrayscaleBuffers(bwBuffer); }
-
-void HalDisplay::displayGrayBuffer() { einkDisplay.displayGrayBuffer(); }
--- a/lib/hal/HalDisplay.h
+++ b/lib/hal/HalDisplay.h
@ -1,52 +0,0 @@
-#pragma once
-#include <Arduino.h>
-#include <EInkDisplay.h>
-
-class HalDisplay {
- public:
-  // Constructor with pin configuration
-  HalDisplay();
-
-  // Destructor
-  ~HalDisplay();
-
-  // Refresh modes
-  enum RefreshMode {
-    FULL_REFRESH,  // Full refresh with complete waveform
-    HALF_REFRESH,  // Half refresh (1720ms) - balanced quality and speed
-    FAST_REFRESH   // Fast refresh using custom LUT
-  };
-
-  // Initialize the display hardware and driver
-  void begin();
-
-  // Display dimensions
-  static constexpr uint16_t DISPLAY_WIDTH = EInkDisplay::DISPLAY_WIDTH;
-  static constexpr uint16_t DISPLAY_HEIGHT = EInkDisplay::DISPLAY_HEIGHT;
-  static constexpr uint16_t DISPLAY_WIDTH_BYTES = DISPLAY_WIDTH / 8;
-  static constexpr uint32_t BUFFER_SIZE = DISPLAY_WIDTH_BYTES * DISPLAY_HEIGHT;
-
-  // Frame buffer operations
-  void clearScreen(uint8_t color = 0xFF) const;
-  void drawImage(const uint8_t* imageData, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
-                 bool fromProgmem = false) const;
-
-  void displayBuffer(RefreshMode mode = RefreshMode::FAST_REFRESH);
-  void refreshDisplay(RefreshMode mode = RefreshMode::FAST_REFRESH, bool turnOffScreen = false);
-
-  // Power management
-  void deepSleep();
-
-  // Access to frame buffer
-  uint8_t* getFrameBuffer() const;
-
-  void copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer);
-  void copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer);
-  void copyGrayscaleMsbBuffers(const uint8_t* msbBuffer);
-  void cleanupGrayscaleBuffers(const uint8_t* bwBuffer);
-
-  void displayGrayBuffer();
-
- private:
-  EInkDisplay einkDisplay;
-};
--- a/lib/hal/HalGPIO.cpp
+++ b/lib/hal/HalGPIO.cpp
@ -1,55 +0,0 @@
-#include <HalGPIO.h>
-#include <SPI.h>
-#include <esp_sleep.h>
-
-void HalGPIO::begin() {
-  inputMgr.begin();
-  SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS);
-  pinMode(BAT_GPIO0, INPUT);
-  pinMode(UART0_RXD, INPUT);
-}
-
-void HalGPIO::update() { inputMgr.update(); }
-
-bool HalGPIO::isPressed(uint8_t buttonIndex) const { return inputMgr.isPressed(buttonIndex); }
-
-bool HalGPIO::wasPressed(uint8_t buttonIndex) const { return inputMgr.wasPressed(buttonIndex); }
-
-bool HalGPIO::wasAnyPressed() const { return inputMgr.wasAnyPressed(); }
-
-bool HalGPIO::wasReleased(uint8_t buttonIndex) const { return inputMgr.wasReleased(buttonIndex); }
-
-bool HalGPIO::wasAnyReleased() const { return inputMgr.wasAnyReleased(); }
-
-unsigned long HalGPIO::getHeldTime() const { return inputMgr.getHeldTime(); }
-
-void HalGPIO::startDeepSleep() {
-  esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
-  // Ensure that the power button has been released to avoid immediately turning back on if you're holding it
-  while (inputMgr.isPressed(BTN_POWER)) {
-    delay(50);
-    inputMgr.update();
-  }
-  // Enter Deep Sleep
-  esp_deep_sleep_start();
-}
-
-int HalGPIO::getBatteryPercentage() const {
-  static const BatteryMonitor battery = BatteryMonitor(BAT_GPIO0);
-  return battery.readPercentage();
-}
-
-bool HalGPIO::isUsbConnected() const {
-  // U0RXD/GPIO20 reads HIGH when USB is connected
-  return digitalRead(UART0_RXD) == HIGH;
-}
-
-bool HalGPIO::isWakeupByPowerButton() const {
-  const auto wakeupCause = esp_sleep_get_wakeup_cause();
-  const auto resetReason = esp_reset_reason();
-  if (isUsbConnected()) {
-    return wakeupCause == ESP_SLEEP_WAKEUP_GPIO;
-  } else {
-    return (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED) && (resetReason == ESP_RST_POWERON);
-  }
-}
--- a/lib/hal/HalGPIO.h
+++ b/lib/hal/HalGPIO.h
@ -1,61 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-#include <BatteryMonitor.h>
-#include <InputManager.h>
-
-// Display SPI pins (custom pins for XteinkX4, not hardware SPI defaults)
-#define EPD_SCLK 8   // SPI Clock
-#define EPD_MOSI 10  // SPI MOSI (Master Out Slave In)
-#define EPD_CS 21    // Chip Select
-#define EPD_DC 4     // Data/Command
-#define EPD_RST 5    // Reset
-#define EPD_BUSY 6   // Busy
-
-#define SPI_MISO 7  // SPI MISO, shared between SD card and display (Master In Slave Out)
-
-#define BAT_GPIO0 0  // Battery voltage
-
-#define UART0_RXD 20  // Used for USB connection detection
-
-class HalGPIO {
-#if CROSSPOINT_EMULATED == 0
-  InputManager inputMgr;
-#endif
-
- public:
-  HalGPIO() = default;
-
-  // Start button GPIO and setup SPI for screen and SD card
-  void begin();
-
-  // Button input methods
-  void update();
-  bool isPressed(uint8_t buttonIndex) const;
-  bool wasPressed(uint8_t buttonIndex) const;
-  bool wasAnyPressed() const;
-  bool wasReleased(uint8_t buttonIndex) const;
-  bool wasAnyReleased() const;
-  unsigned long getHeldTime() const;
-
-  // Setup wake up GPIO and enter deep sleep
-  void startDeepSleep();
-
-  // Get battery percentage (range 0-100)
-  int getBatteryPercentage() const;
-
-  // Check if USB is connected
-  bool isUsbConnected() const;
-
-  // Check if wakeup was caused by power button press
-  bool isWakeupByPowerButton() const;
-
-  // Button indices
-  static constexpr uint8_t BTN_BACK = 0;
-  static constexpr uint8_t BTN_CONFIRM = 1;
-  static constexpr uint8_t BTN_LEFT = 2;
-  static constexpr uint8_t BTN_RIGHT = 3;
-  static constexpr uint8_t BTN_UP = 4;
-  static constexpr uint8_t BTN_DOWN = 5;
-  static constexpr uint8_t BTN_POWER = 6;
-};
--- a/platformio.ini
+++ b/platformio.ini
@ -2,7 +2,7 @@
 default_envs = default

 [crosspoint]
-version = 0.16.0
+version = 0.15.0

 [base]
 platform = espressif32 @ 6.12.0
--- a/src/CrossPointSettings.cpp
+++ b/src/CrossPointSettings.cpp
@ -11,18 +11,10 @@
 // Initialize the static instance
 CrossPointSettings CrossPointSettings::instance;

-void readAndValidate(FsFile& file, uint8_t& member, const uint8_t maxValue) {
-  uint8_t tempValue;
-  serialization::readPod(file, tempValue);
-  if (tempValue < maxValue) {
-    member = tempValue;
-  }
-}
-
 namespace {
 constexpr uint8_t SETTINGS_FILE_VERSION = 1;
 // Increment this when adding new persisted settings fields
-constexpr uint8_t SETTINGS_COUNT = 24;  // 23 upstream + themeName
+constexpr uint8_t SETTINGS_COUNT = 21;
 constexpr char SETTINGS_FILE[] = "/.crosspoint/settings.bin";
 }  // namespace

@ -57,11 +49,7 @@ bool CrossPointSettings::saveToFile() const {
  serialization::writePod(outputFile, hideBatteryPercentage);
  serialization::writePod(outputFile, longPressChapterSkip);
  serialization::writePod(outputFile, hyphenationEnabled);
-  serialization::writeString(outputFile, std::string(opdsUsername));
-  serialization::writeString(outputFile, std::string(opdsPassword));
-  serialization::writePod(outputFile, sleepScreenCoverFilter);
  serialization::writeString(outputFile, std::string(themeName));
-  // New fields added at end for backward compatibility
  outputFile.close();

  Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
@ -88,35 +76,35 @@ bool CrossPointSettings::loadFromFile() {
  // load settings that exist (support older files with fewer fields)
  uint8_t settingsRead = 0;
  do {
-    readAndValidate(inputFile, sleepScreen, SLEEP_SCREEN_MODE_COUNT);
+    serialization::readPod(inputFile, sleepScreen);
    if (++settingsRead >= fileSettingsCount) break;
    serialization::readPod(inputFile, extraParagraphSpacing);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, shortPwrBtn, SHORT_PWRBTN_COUNT);
+    serialization::readPod(inputFile, shortPwrBtn);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, statusBar, STATUS_BAR_MODE_COUNT);
+    serialization::readPod(inputFile, statusBar);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, orientation, ORIENTATION_COUNT);
+    serialization::readPod(inputFile, orientation);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, frontButtonLayout, FRONT_BUTTON_LAYOUT_COUNT);
+    serialization::readPod(inputFile, frontButtonLayout);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, sideButtonLayout, SIDE_BUTTON_LAYOUT_COUNT);
+    serialization::readPod(inputFile, sideButtonLayout);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, fontFamily, FONT_FAMILY_COUNT);
+    serialization::readPod(inputFile, fontFamily);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, fontSize, FONT_SIZE_COUNT);
+    serialization::readPod(inputFile, fontSize);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, lineSpacing, LINE_COMPRESSION_COUNT);
+    serialization::readPod(inputFile, lineSpacing);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, paragraphAlignment, PARAGRAPH_ALIGNMENT_COUNT);
+    serialization::readPod(inputFile, paragraphAlignment);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, sleepTimeout, SLEEP_TIMEOUT_COUNT);
+    serialization::readPod(inputFile, sleepTimeout);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, refreshFrequency, REFRESH_FREQUENCY_COUNT);
+    serialization::readPod(inputFile, refreshFrequency);
    if (++settingsRead >= fileSettingsCount) break;
    serialization::readPod(inputFile, screenMargin);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, sleepScreenCoverMode, SLEEP_SCREEN_COVER_MODE_COUNT);
+    serialization::readPod(inputFile, sleepScreenCoverMode);
    if (++settingsRead >= fileSettingsCount) break;
    {
      std::string urlStr;
@ -127,28 +115,12 @@ bool CrossPointSettings::loadFromFile() {
    if (++settingsRead >= fileSettingsCount) break;
    serialization::readPod(inputFile, textAntiAliasing);
    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, hideBatteryPercentage, HIDE_BATTERY_PERCENTAGE_COUNT);
+    serialization::readPod(inputFile, hideBatteryPercentage);
    if (++settingsRead >= fileSettingsCount) break;
    serialization::readPod(inputFile, longPressChapterSkip);
    if (++settingsRead >= fileSettingsCount) break;
    serialization::readPod(inputFile, hyphenationEnabled);
    if (++settingsRead >= fileSettingsCount) break;
-    {
-      std::string usernameStr;
-      serialization::readString(inputFile, usernameStr);
-      strncpy(opdsUsername, usernameStr.c_str(), sizeof(opdsUsername) - 1);
-      opdsUsername[sizeof(opdsUsername) - 1] = '\0';
-    }
-    if (++settingsRead >= fileSettingsCount) break;
-    {
-      std::string passwordStr;
-      serialization::readString(inputFile, passwordStr);
-      strncpy(opdsPassword, passwordStr.c_str(), sizeof(opdsPassword) - 1);
-      opdsPassword[sizeof(opdsPassword) - 1] = '\0';
-    }
-    if (++settingsRead >= fileSettingsCount) break;
-    readAndValidate(inputFile, sleepScreenCoverFilter, SLEEP_SCREEN_COVER_FILTER_COUNT);
-    if (++settingsRead >= fileSettingsCount) break;
    {
      std::string themeStr;
      serialization::readString(inputFile, themeStr);
@ -156,7 +128,6 @@ bool CrossPointSettings::loadFromFile() {
      themeName[sizeof(themeName) - 1] = '\0';
    }
    if (++settingsRead >= fileSettingsCount) break;
-    // New fields added at end for backward compatibility
  } while (false);

  inputFile.close();
--- a/src/CrossPointSettings.h
+++ b/src/CrossPointSettings.h
@ -15,31 +15,18 @@ class CrossPointSettings {
  CrossPointSettings(const CrossPointSettings&) = delete;
  CrossPointSettings& operator=(const CrossPointSettings&) = delete;

-  enum SLEEP_SCREEN_MODE { DARK = 0, LIGHT = 1, CUSTOM = 2, COVER = 3, BLANK = 4, SLEEP_SCREEN_MODE_COUNT };
-  enum SLEEP_SCREEN_COVER_MODE { FIT = 0, CROP = 1, SLEEP_SCREEN_COVER_MODE_COUNT };
-  enum SLEEP_SCREEN_COVER_FILTER {
-    NO_FILTER = 0,
-    BLACK_AND_WHITE = 1,
-    INVERTED_BLACK_AND_WHITE = 2,
-    SLEEP_SCREEN_COVER_FILTER_COUNT
-  };
+  // Should match with SettingsActivity text
+  enum SLEEP_SCREEN_MODE { DARK = 0, LIGHT = 1, CUSTOM = 2, COVER = 3, BLANK = 4 };
+  enum SLEEP_SCREEN_COVER_MODE { FIT = 0, CROP = 1 };

  // Status bar display type enum
-  enum STATUS_BAR_MODE {
-    NONE = 0,
-    NO_PROGRESS = 1,
-    FULL = 2,
-    FULL_WITH_PROGRESS_BAR = 3,
-    ONLY_PROGRESS_BAR = 4,
-    STATUS_BAR_MODE_COUNT
-  };
+  enum STATUS_BAR_MODE { NONE = 0, NO_PROGRESS = 1, FULL = 2 };

  enum ORIENTATION {
-    PORTRAIT = 0,       // 480x800 logical coordinates (current default)
-    LANDSCAPE_CW = 1,   // 800x480 logical coordinates, rotated 180° (swap top/bottom)
-    INVERTED = 2,       // 480x800 logical coordinates, inverted
-    LANDSCAPE_CCW = 3,  // 800x480 logical coordinates, native panel orientation
-    ORIENTATION_COUNT
+    PORTRAIT = 0,      // 480x800 logical coordinates (current default)
+    LANDSCAPE_CW = 1,  // 800x480 logical coordinates, rotated 180° (swap top/bottom)
+    INVERTED = 2,      // 480x800 logical coordinates, inverted
+    LANDSCAPE_CCW = 3  // 800x480 logical coordinates, native panel orientation
  };

  // Front button layout options
@ -49,60 +36,37 @@ class CrossPointSettings {
    BACK_CONFIRM_LEFT_RIGHT = 0,
    LEFT_RIGHT_BACK_CONFIRM = 1,
    LEFT_BACK_CONFIRM_RIGHT = 2,
-    BACK_CONFIRM_RIGHT_LEFT = 3,
-    FRONT_BUTTON_LAYOUT_COUNT
+    BACK_CONFIRM_RIGHT_LEFT = 3
  };

  // Side button layout options
  // Default: Previous, Next
  // Swapped: Next, Previous
-  enum SIDE_BUTTON_LAYOUT { PREV_NEXT = 0, NEXT_PREV = 1, SIDE_BUTTON_LAYOUT_COUNT };
+  enum SIDE_BUTTON_LAYOUT { PREV_NEXT = 0, NEXT_PREV = 1 };

  // Font family options
-  enum FONT_FAMILY { BOOKERLY = 0, NOTOSANS = 1, OPENDYSLEXIC = 2, FONT_FAMILY_COUNT };
+  enum FONT_FAMILY { BOOKERLY = 0, NOTOSANS = 1, OPENDYSLEXIC = 2 };
  // Font size options
-  enum FONT_SIZE { SMALL = 0, MEDIUM = 1, LARGE = 2, EXTRA_LARGE = 3, FONT_SIZE_COUNT };
-  enum LINE_COMPRESSION { TIGHT = 0, NORMAL = 1, WIDE = 2, LINE_COMPRESSION_COUNT };
-  enum PARAGRAPH_ALIGNMENT {
-    JUSTIFIED = 0,
-    LEFT_ALIGN = 1,
-    CENTER_ALIGN = 2,
-    RIGHT_ALIGN = 3,
-    PARAGRAPH_ALIGNMENT_COUNT
-  };
+  enum FONT_SIZE { SMALL = 0, MEDIUM = 1, LARGE = 2, EXTRA_LARGE = 3 };
+  enum LINE_COMPRESSION { TIGHT = 0, NORMAL = 1, WIDE = 2 };
+  enum PARAGRAPH_ALIGNMENT { JUSTIFIED = 0, LEFT_ALIGN = 1, CENTER_ALIGN = 2, RIGHT_ALIGN = 3 };

  // Auto-sleep timeout options (in minutes)
-  enum SLEEP_TIMEOUT {
-    SLEEP_1_MIN = 0,
-    SLEEP_5_MIN = 1,
-    SLEEP_10_MIN = 2,
-    SLEEP_15_MIN = 3,
-    SLEEP_30_MIN = 4,
-    SLEEP_TIMEOUT_COUNT
-  };
+  enum SLEEP_TIMEOUT { SLEEP_1_MIN = 0, SLEEP_5_MIN = 1, SLEEP_10_MIN = 2, SLEEP_15_MIN = 3, SLEEP_30_MIN = 4 };

  // E-ink refresh frequency (pages between full refreshes)
-  enum REFRESH_FREQUENCY {
-    REFRESH_1 = 0,
-    REFRESH_5 = 1,
-    REFRESH_10 = 2,
-    REFRESH_15 = 3,
-    REFRESH_30 = 4,
-    REFRESH_FREQUENCY_COUNT
-  };
+  enum REFRESH_FREQUENCY { REFRESH_1 = 0, REFRESH_5 = 1, REFRESH_10 = 2, REFRESH_15 = 3, REFRESH_30 = 4 };

  // Short power button press actions
-  enum SHORT_PWRBTN { IGNORE = 0, SLEEP = 1, PAGE_TURN = 2, SHORT_PWRBTN_COUNT };
+  enum SHORT_PWRBTN { IGNORE = 0, SLEEP = 1, PAGE_TURN = 2 };

  // Hide battery percentage
-  enum HIDE_BATTERY_PERCENTAGE { HIDE_NEVER = 0, HIDE_READER = 1, HIDE_ALWAYS = 2, HIDE_BATTERY_PERCENTAGE_COUNT };
+  enum HIDE_BATTERY_PERCENTAGE { HIDE_NEVER = 0, HIDE_READER = 1, HIDE_ALWAYS = 2 };

  // Sleep screen settings
  uint8_t sleepScreen = DARK;
  // Sleep screen cover mode settings
  uint8_t sleepScreenCoverMode = FIT;
-  // Sleep screen cover filter
-  uint8_t sleepScreenCoverFilter = NO_FILTER;
  // Status bar settings
  uint8_t statusBar = FULL;
  // Text rendering settings
@ -111,7 +75,8 @@ class CrossPointSettings {
  // Short power button click behaviour
  uint8_t shortPwrBtn = IGNORE;
  // EPUB reading orientation settings
-  // 0 = portrait (default), 1 = landscape clockwise, 2 = inverted, 3 = landscape counter-clockwise
+  // 0 = portrait (default), 1 = landscape clockwise, 2 = inverted, 3 =
+  // landscape counter-clockwise
  uint8_t orientation = PORTRAIT;
  // Button layouts
  uint8_t frontButtonLayout = BACK_CONFIRM_LEFT_RIGHT;
@ -131,13 +96,10 @@ class CrossPointSettings {
  uint8_t screenMargin = 5;
  // OPDS browser settings
  char opdsServerUrl[128] = "";
-  char opdsUsername[64] = "";
-  char opdsPassword[64] = "";
  // Hide battery percentage
  uint8_t hideBatteryPercentage = HIDE_NEVER;
  // Long-press chapter skip on side buttons
  uint8_t longPressChapterSkip = 1;
-  // Theme name (theme-engine addition)
  char themeName[64] = "Default";

  ~CrossPointSettings() = default;
--- a/src/MappedInputManager.cpp
+++ b/src/MappedInputManager.cpp
@ -2,77 +2,103 @@

 #include "CrossPointSettings.h"

-namespace {
-using ButtonIndex = uint8_t;
-
-struct FrontLayoutMap {
-  ButtonIndex back;
-  ButtonIndex confirm;
-  ButtonIndex left;
-  ButtonIndex right;
-};
-
-struct SideLayoutMap {
-  ButtonIndex pageBack;
-  ButtonIndex pageForward;
-};
-
-// Order matches CrossPointSettings::FRONT_BUTTON_LAYOUT.
-constexpr FrontLayoutMap kFrontLayouts[] = {
-    {HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM, HalGPIO::BTN_LEFT, HalGPIO::BTN_RIGHT},
-    {HalGPIO::BTN_LEFT, HalGPIO::BTN_RIGHT, HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM},
-    {HalGPIO::BTN_CONFIRM, HalGPIO::BTN_LEFT, HalGPIO::BTN_BACK, HalGPIO::BTN_RIGHT},
-    {HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM, HalGPIO::BTN_RIGHT, HalGPIO::BTN_LEFT},
-};
-
-// Order matches CrossPointSettings::SIDE_BUTTON_LAYOUT.
-constexpr SideLayoutMap kSideLayouts[] = {
-    {HalGPIO::BTN_UP, HalGPIO::BTN_DOWN},
-    {HalGPIO::BTN_DOWN, HalGPIO::BTN_UP},
-};
-}  // namespace
-
-bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint8_t) const) const {
+decltype(InputManager::BTN_BACK) MappedInputManager::mapButton(const Button button) const {
  const auto frontLayout = static_cast<CrossPointSettings::FRONT_BUTTON_LAYOUT>(SETTINGS.frontButtonLayout);
  const auto sideLayout = static_cast<CrossPointSettings::SIDE_BUTTON_LAYOUT>(SETTINGS.sideButtonLayout);
-  const auto& front = kFrontLayouts[frontLayout];
-  const auto& side = kSideLayouts[sideLayout];

  switch (button) {
    case Button::Back:
-      return (gpio.*fn)(front.back);
+      switch (frontLayout) {
+        case CrossPointSettings::LEFT_RIGHT_BACK_CONFIRM:
+          return InputManager::BTN_LEFT;
+        case CrossPointSettings::LEFT_BACK_CONFIRM_RIGHT:
+          return InputManager::BTN_CONFIRM;
+        case CrossPointSettings::BACK_CONFIRM_LEFT_RIGHT:
+          /* fall through */
+        case CrossPointSettings::BACK_CONFIRM_RIGHT_LEFT:
+          /* fall through */
+        default:
+          return InputManager::BTN_BACK;
+      }
    case Button::Confirm:
-      return (gpio.*fn)(front.confirm);
+      switch (frontLayout) {
+        case CrossPointSettings::LEFT_RIGHT_BACK_CONFIRM:
+          return InputManager::BTN_RIGHT;
+        case CrossPointSettings::LEFT_BACK_CONFIRM_RIGHT:
+          return InputManager::BTN_LEFT;
+        case CrossPointSettings::BACK_CONFIRM_LEFT_RIGHT:
+          /* fall through */
+        case CrossPointSettings::BACK_CONFIRM_RIGHT_LEFT:
+          /* fall through */
+        default:
+          return InputManager::BTN_CONFIRM;
+      }
    case Button::Left:
-      return (gpio.*fn)(front.left);
+      switch (frontLayout) {
+        case CrossPointSettings::LEFT_RIGHT_BACK_CONFIRM:
+          /* fall through */
+        case CrossPointSettings::LEFT_BACK_CONFIRM_RIGHT:
+          return InputManager::BTN_BACK;
+        case CrossPointSettings::BACK_CONFIRM_RIGHT_LEFT:
+          return InputManager::BTN_RIGHT;
+        case CrossPointSettings::BACK_CONFIRM_LEFT_RIGHT:
+          /* fall through */
+        default:
+          return InputManager::BTN_LEFT;
+      }
    case Button::Right:
-      return (gpio.*fn)(front.right);
+      switch (frontLayout) {
+        case CrossPointSettings::LEFT_RIGHT_BACK_CONFIRM:
+          return InputManager::BTN_CONFIRM;
+        case CrossPointSettings::BACK_CONFIRM_RIGHT_LEFT:
+          return InputManager::BTN_LEFT;
+        case CrossPointSettings::BACK_CONFIRM_LEFT_RIGHT:
+          /* fall through */
+        case CrossPointSettings::LEFT_BACK_CONFIRM_RIGHT:
+          /* fall through */
+        default:
+          return InputManager::BTN_RIGHT;
+      }
    case Button::Up:
-      return (gpio.*fn)(HalGPIO::BTN_UP);
+      return InputManager::BTN_UP;
    case Button::Down:
-      return (gpio.*fn)(HalGPIO::BTN_DOWN);
+      return InputManager::BTN_DOWN;
    case Button::Power:
-      return (gpio.*fn)(HalGPIO::BTN_POWER);
+      return InputManager::BTN_POWER;
    case Button::PageBack:
-      return (gpio.*fn)(side.pageBack);
+      switch (sideLayout) {
+        case CrossPointSettings::NEXT_PREV:
+          return InputManager::BTN_DOWN;
+        case CrossPointSettings::PREV_NEXT:
+          /* fall through */
+        default:
+          return InputManager::BTN_UP;
+      }
    case Button::PageForward:
-      return (gpio.*fn)(side.pageForward);
+      switch (sideLayout) {
+        case CrossPointSettings::NEXT_PREV:
+          return InputManager::BTN_UP;
+        case CrossPointSettings::PREV_NEXT:
+          /* fall through */
+        default:
+          return InputManager::BTN_DOWN;
+      }
  }

-  return false;
+  return InputManager::BTN_BACK;
 }

-bool MappedInputManager::wasPressed(const Button button) const { return mapButton(button, &HalGPIO::wasPressed); }
+bool MappedInputManager::wasPressed(const Button button) const { return inputManager.wasPressed(mapButton(button)); }

-bool MappedInputManager::wasReleased(const Button button) const { return mapButton(button, &HalGPIO::wasReleased); }
+bool MappedInputManager::wasReleased(const Button button) const { return inputManager.wasReleased(mapButton(button)); }

-bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &HalGPIO::isPressed); }
+bool MappedInputManager::isPressed(const Button button) const { return inputManager.isPressed(mapButton(button)); }

-bool MappedInputManager::wasAnyPressed() const { return gpio.wasAnyPressed(); }
+bool MappedInputManager::wasAnyPressed() const { return inputManager.wasAnyPressed(); }

-bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); }
+bool MappedInputManager::wasAnyReleased() const { return inputManager.wasAnyReleased(); }

-unsigned long MappedInputManager::getHeldTime() const { return gpio.getHeldTime(); }
+unsigned long MappedInputManager::getHeldTime() const { return inputManager.getHeldTime(); }

 MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const char* confirm, const char* previous,
                                                         const char* next) const {
@ -83,10 +109,8 @@ MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const
      return {previous, next, back, confirm};
    case CrossPointSettings::LEFT_BACK_CONFIRM_RIGHT:
      return {previous, back, confirm, next};
-    case CrossPointSettings::BACK_CONFIRM_RIGHT_LEFT:
-      return {back, confirm, next, previous};
    case CrossPointSettings::BACK_CONFIRM_LEFT_RIGHT:
    default:
      return {back, confirm, previous, next};
  }
-}
+}
--- a/src/MappedInputManager.h
+++ b/src/MappedInputManager.h
@ -1,6 +1,6 @@
 #pragma once

-#include <HalGPIO.h>
+#include <InputManager.h>

 class MappedInputManager {
 public:
@ -13,7 +13,7 @@ class MappedInputManager {
    const char* btn4;
  };

-  explicit MappedInputManager(HalGPIO& gpio) : gpio(gpio) {}
+  explicit MappedInputManager(InputManager& inputManager) : inputManager(inputManager) {}

  bool wasPressed(Button button) const;
  bool wasReleased(Button button) const;
@ -24,7 +24,6 @@ class MappedInputManager {
  Labels mapLabels(const char* back, const char* confirm, const char* previous, const char* next) const;

 private:
-  HalGPIO& gpio;
-
-  bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const;
+  InputManager& inputManager;
+  decltype(InputManager::BTN_BACK) mapButton(Button button) const;
 };
--- a/src/RecentBooksStore.cpp
+++ b/src/RecentBooksStore.cpp
@ -7,23 +7,22 @@
 #include <algorithm>

 namespace {
-constexpr uint8_t RECENT_BOOKS_FILE_VERSION = 2;
+constexpr uint8_t RECENT_BOOKS_FILE_VERSION = 1;
 constexpr char RECENT_BOOKS_FILE[] = "/.crosspoint/recent.bin";
 constexpr int MAX_RECENT_BOOKS = 10;
 }  // namespace

 RecentBooksStore RecentBooksStore::instance;

-void RecentBooksStore::addBook(const std::string& path, const std::string& title, const std::string& author) {
+void RecentBooksStore::addBook(const std::string& path) {
  // Remove existing entry if present
-  auto it =
-      std::find_if(recentBooks.begin(), recentBooks.end(), [&](const RecentBook& book) { return book.path == path; });
+  auto it = std::find(recentBooks.begin(), recentBooks.end(), path);
  if (it != recentBooks.end()) {
    recentBooks.erase(it);
  }

  // Add to front
-  recentBooks.insert(recentBooks.begin(), {path, title, author});
+  recentBooks.insert(recentBooks.begin(), path);

  // Trim to max size
  if (recentBooks.size() > MAX_RECENT_BOOKS) {
@ -47,9 +46,7 @@ bool RecentBooksStore::saveToFile() const {
  serialization::writePod(outputFile, count);

  for (const auto& book : recentBooks) {
-    serialization::writeString(outputFile, book.path);
-    serialization::writeString(outputFile, book.title);
-    serialization::writeString(outputFile, book.author);
+    serialization::writeString(outputFile, book);
  }

  outputFile.close();
@ -66,41 +63,24 @@ bool RecentBooksStore::loadFromFile() {
  uint8_t version;
  serialization::readPod(inputFile, version);
  if (version != RECENT_BOOKS_FILE_VERSION) {
-    if (version == 1) {
-      // Old version, just read paths
-      uint8_t count;
-      serialization::readPod(inputFile, count);
-      recentBooks.clear();
-      recentBooks.reserve(count);
-      for (uint8_t i = 0; i < count; i++) {
-        std::string path;
-        serialization::readString(inputFile, path);
-        // Title and author will be empty, they will be filled when the book is
-        // opened again
-        recentBooks.push_back({path, "", ""});
-      }
-    } else {
-      Serial.printf("[%lu] [RBS] Deserialization failed: Unknown version %u\n", millis(), version);
-      inputFile.close();
-      return false;
-    }
-  } else {
-    uint8_t count;
-    serialization::readPod(inputFile, count);
+    Serial.printf("[%lu] [RBS] Deserialization failed: Unknown version %u\n", millis(), version);
+    inputFile.close();
+    return false;
+  }

-    recentBooks.clear();
-    recentBooks.reserve(count);
+  uint8_t count;
+  serialization::readPod(inputFile, count);

-    for (uint8_t i = 0; i < count; i++) {
-      std::string path, title, author;
-      serialization::readString(inputFile, path);
-      serialization::readString(inputFile, title);
-      serialization::readString(inputFile, author);
-      recentBooks.push_back({path, title, author});
-    }
+  recentBooks.clear();
+  recentBooks.reserve(count);
+
+  for (uint8_t i = 0; i < count; i++) {
+    std::string path;
+    serialization::readString(inputFile, path);
+    recentBooks.push_back(path);
  }

  inputFile.close();
-  Serial.printf("[%lu] [RBS] Recent books loaded from file (%d entries)\n", millis(), recentBooks.size());
+  Serial.printf("[%lu] [RBS] Recent books loaded from file (%d entries)\n", millis(), count);
  return true;
 }
--- a/src/RecentBooksStore.h
+++ b/src/RecentBooksStore.h
@ -2,19 +2,11 @@
 #include <string>
 #include <vector>

-struct RecentBook {
-  std::string path;
-  std::string title;
-  std::string author;
-
-  bool operator==(const RecentBook& other) const { return path == other.path; }
-};
-
 class RecentBooksStore {
  // Static instance
  static RecentBooksStore instance;

-  std::vector<RecentBook> recentBooks;
+  std::vector<std::string> recentBooks;

 public:
  ~RecentBooksStore() = default;
@ -22,11 +14,11 @@ class RecentBooksStore {
  // Get singleton instance
  static RecentBooksStore& getInstance() { return instance; }

-  // Add a book to the recent list (moves to front if already exists)
-  void addBook(const std::string& path, const std::string& title, const std::string& author);
+  // Add a book path to the recent list (moves to front if already exists)
+  void addBook(const std::string& path);

-  // Get the list of recent books (most recent first)
-  const std::vector<RecentBook>& getBooks() const { return recentBooks; }
+  // Get the list of recent book paths (most recent first)
+  const std::vector<std::string>& getBooks() const { return recentBooks; }

  // Get the count of recent books
  int getCount() const { return static_cast<int>(recentBooks.size()); }
--- a/src/ScreenComponents.cpp
+++ b/src/ScreenComponents.cpp
@ -42,17 +42,6 @@ void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left,
  renderer.fillRect(x + 2, y + 2, filledWidth, batteryHeight - 4);
 }

-void ScreenComponents::drawBookProgressBar(const GfxRenderer& renderer, const size_t bookProgress) {
-  int vieweableMarginTop, vieweableMarginRight, vieweableMarginBottom, vieweableMarginLeft;
-  renderer.getOrientedViewableTRBL(&vieweableMarginTop, &vieweableMarginRight, &vieweableMarginBottom,
-                                   &vieweableMarginLeft);
-
-  const int progressBarMaxWidth = renderer.getScreenWidth() - vieweableMarginLeft - vieweableMarginRight;
-  const int progressBarY = renderer.getScreenHeight() - vieweableMarginBottom - BOOK_PROGRESS_BAR_HEIGHT;
-  const int barWidth = progressBarMaxWidth * bookProgress / 100;
-  renderer.fillRect(vieweableMarginLeft, progressBarY, barWidth, BOOK_PROGRESS_BAR_HEIGHT, true);
-}
-
 int ScreenComponents::drawTabBar(const GfxRenderer& renderer, const int y, const std::vector<TabInfo>& tabs) {
  constexpr int tabPadding = 20;      // Horizontal padding between tabs
  constexpr int leftMargin = 20;      // Left margin for first tab
--- a/src/ScreenComponents.h
+++ b/src/ScreenComponents.h
@ -13,10 +13,7 @@ struct TabInfo {

 class ScreenComponents {
 public:
-  static const int BOOK_PROGRESS_BAR_HEIGHT = 4;
-
  static void drawBattery(const GfxRenderer& renderer, int left, int top, bool showPercentage = true);
-  static void drawBookProgressBar(const GfxRenderer& renderer, size_t bookProgress);

  // Draw a horizontal tab bar with underline indicator for selected tab
  // Returns the height of the tab bar (for positioning content below)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Brackyt	d4026e0f33	Merge `7bfb3af0da` into `13f0ebed96`	2026-01-27 21:26:21 +11:00
Brackyt	7bfb3af0da	fix(cppcheck): more clang format fix	2026-01-26 00:33:27 +01:00
Brackyt	e6f6f14b37	fix(cppcheck): clang format	2026-01-26 00:27:58 +01:00
Brackyt	a4310bf2c3	fix(cppcheck): resolve style and performance issues - Remove unused HomeActivity::restoreCoverBuffer - Use initialization lists in constructors - Mark single-argument constructors as explicit	2026-01-26 00:22:05 +01:00
Brackyt	75cc861bd0	feat: expose detailed book metadata in HomeActivity	2026-01-26 00:16:16 +01:00
Brackyt	72de88c3bf	fix: support upscaling for bitmap render	2026-01-25 21:16:23 +01:00
Brackyt	302b37061e	feat: border radius on bitmap	2026-01-25 21:10:10 +01:00
Brackyt	8fa674f26d	feat: draw icons with transparent background	2026-01-25 20:35:31 +01:00
Brackyt	12e34643e2	fix: covers not displaying when too large because of ram and transparency	2026-01-25 20:17:41 +01:00
Brackyt	e294ad1e06	default theme closer to reality	2026-01-25 19:52:54 +01:00
Brackyt	e0edb15ba9	feat: multiline support	2026-01-25 19:52:44 +01:00
Brackyt	ec315eafb5	fix: rendering correctly + alpha channel	2026-01-25 18:49:42 +01:00
Brackyt	ed3ecfb3af	feat: better icon loading for themes	2026-01-25 18:19:23 +01:00
Brackyt	f6469c48ba	fix: reset clang correctly	2026-01-25 17:48:57 +01:00
Brackyt	bf353e7d83	fix: set default theme to original crosspoint ui + add small font + battery icon	2026-01-25 17:43:10 +01:00
Brackyt	29daf3f866	fix: make home navigation work for all themes	2026-01-25 16:42:00 +01:00
Brackyt	1f5a436abb	fix: theme switching works and restarts	2026-01-25 16:41:31 +01:00
Brackyt	52596c5863	- rounded rects - background fill - border radius - container paddings - fix navigation in home	2026-01-25 15:23:03 +01:00
Brackyt	28c925e70e	fix: - text no showing if clipping out of screen - inner child dimensions setting 0 for height - navigation to home menus was skipping transfer	2026-01-25 14:32:28 +01:00
Brackyt	e16ce04cdc	refactor: Enhance Bitmap handling and introduce ThemeEngine ## Summary - Refactored Bitmap class to improve memory management and streamline methods. - Introduced ThemeEngine with foundational classes for UI elements, layout management, and theme parsing. - Added support for dynamic themes and improved rendering capabilities in the HomeActivity and settings screens. This update lays the groundwork for a more flexible theming system, allowing for easier customization and management of UI elements across the application.	2026-01-25 01:39:08 +01:00