2025-12-19 07:37:41 +03:00
80 changed files with 11463 additions and 20141 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -1,2 +0,0 @@
 github: [daveallie]
 ko_fi: daveallie
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -1,54 +0,0 @@
 name: Bug Report
 description: Report an issue or unexpected behavior
 title: "Short, descriptive title of the issue"
 labels: ["bug", "triage"]
 body:
  - type: markdown
    attributes:
      value: |
        Thanks for taking the time to report this bug! Please fill out the details below.
  - type: input
    id: version
    attributes:
      label: Affected Version
      description: What version of the project/library are you using? (e.g., v1.2.3, master branch commit SHA)
      placeholder: Ex. v1.2.3
    validations:
      required: true
  - type: textarea
    id: bug-description
    attributes:
      label: Describe the Bug
      description: A clear and concise description of what the bug is.
      placeholder:
    validations:
      required: true
  - type: textarea
    id: steps-to-reproduce
    attributes:
      label: Steps to Reproduce
      description: Clearly list the steps necessary to reproduce the unexpected behavior.
      placeholder: |
        1. Go to '...'
        2. Select '...'
        3. Crash
    validations:
      required: true
  - type: textarea
    id: expected-behavior
    attributes:
      label: Expected Behavior
      description: A clear and concise description of what you expected to happen.
    validations:
      required: true
  - type: textarea
    id: logs
    attributes:
      label: Relevant Log Output/Screenshots
      description: If applicable, error messages, or log output to help explain your problem. You can drag and drop images here.
      render: shell
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,9 +0,0 @@
 ## Summary
 * **What is the goal of this PR?** (e.g., Fixes a bug in the user authentication module, Implements the new feature for 
  file uploading.)
 * **What changes are included?**
 ## Additional Context
 * Add any other information that might be helpful for the reviewer (e.g., performance implications, potential risks, specific areas to focus on).
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -1,43 +0,0 @@
 name: CI
 'on':
  push:
    branches: [master]
  pull_request:
 jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions/cache@v5
        with:
          path: |
            ~/.cache/pip
            ~/.platformio/.cache
          key: ${{ runner.os }}-pio
      - uses: actions/setup-python@v6
        with:
          python-version: '3.14'
      - name: Install PlatformIO Core
        run: pip install --upgrade platformio
      - name: Install clang-format-21
        run: |
          wget https://apt.llvm.org/llvm.sh
          chmod +x llvm.sh
          sudo ./llvm.sh 21
          sudo apt-get update
          sudo apt-get install -y clang-format-21
      - name: Run cppcheck
        run: pio check --fail-on-defect medium --fail-on-defect high
      - name: Run clang-format
        run: PATH="/usr/lib/llvm-21/bin:$PATH" ./bin/clang-format-fix && git diff --exit-code || (echo "Please run 'bin/clang-format-fix' to fix formatting issues" && exit 1)
      - name: Build CrossPoint
        run: pio run
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -1,40 +0,0 @@
 name: Compile Release
 on:
  push:
    tags:
      - '*'
 jobs:
  build-release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          submodules: recursive
      - uses: actions/cache@v5
        with:
          path: |
            ~/.cache/pip
            ~/.platformio/.cache
          key: ${{ runner.os }}-pio
      - uses: actions/setup-python@v6
        with:
          python-version: '3.14'
      - name: Install PlatformIO Core
        run: pip install --upgrade platformio
      - name: Build CrossPoint
        run: pio run -e gh_release
      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: CrossPoint-${{ github.ref_name }}
          path: |
            .pio/build/gh_release/bootloader.bin
            .pio/build/gh_release/firmware.bin
            .pio/build/gh_release/firmware.elf
            .pio/build/gh_release/firmware.map
            .pio/build/gh_release/partitions.bin
--- a/.gitignore
+++ b/.gitignore
@ -1,5 +1,3 @@
 .pio
 .idea
 .DS_Store
 .vscode
 lib/EpdFont/fontsrc
--- a/README.md
+++ b/README.md
@ -6,7 +6,7 @@ Built using **PlatformIO** and targeting the **ESP32-C3** microcontroller.
 CrossPoint Reader is a purpose-built firmware designed to be a drop-in, fully open-source replacement for the official 
 Xteink firmware. It aims to match or improve upon the standard EPUB reading experience.
-![](./docs/images/cover.jpg)
+![](./docs/cover.jpg)
 ## Motivation
@ -59,10 +59,6 @@ back to the other partition using the "Swap boot partition" button here https://
 See [Development](#development) below.
 ## Usage
 See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint.
 ## Development
 ### Prerequisites
@ -131,9 +127,6 @@ EPUB file will reset the reading progress.
 Contributions are very welcome!
 If you're looking for a way to help out, take a look at the [ideas discussion board](https://github.com/daveallie/crosspoint-reader/discussions/categories/ideas).
 If there's something there you'd like to work on, leave a comment so that we can avoid duplicated effort.
 ### To submit a contribution:
 1. Fork the repo
--- a/USER_GUIDE.md
+++ b/USER_GUIDE.md
@ -1,78 +0,0 @@
 # CrossPoint User Guide
 Welcome to the **CrossPoint** firmware. This guide outlines the hardware controls, navigation, and reading features of 
 the device.
 ## 1. Hardware Overview
 The device utilises the standard buttons on the Xtink X4 in the same layout:
 ### Button Layout
 | Location        | Buttons                                    |
 |-----------------|--------------------------------------------|
 | **Bottom Edge** | **Back**, **Confirm**, **Left**, **Right** |
 | **Right Side**  | **Power**, **Volume Up**, **Volume Down**  |
 ---
 ## 2. Power & Startup
 ### Power On / Off
 To turn the device on or off, **press and hold the Power button for 1 full second**.
 ### First Launch
 Upon turning the device on for the first time, you will be placed on the **Book Selection Screen** (File Browser).
 > **Note:** On subsequent restarts, the firmware will automatically reopen the last book you were reading.
 ---
 ## 3. Book Selection
 The Home Screen acts as a folder and file browser.
 * **Navigate List:** Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to move the selection cursor up 
  and down through folders and books.
 * **Open Selection:** Press **Confirm** to open a folder or read a selected book.
 ---
 ## 4. Reading Mode
 Once you have opened a book, the button layout changes to facilitate reading.
 ### Page Turning
 | Action            | Buttons                              |
 |-------------------|--------------------------------------|
 | **Previous Page** | Press **Left** _or_ **Volume Up**    |
 | **Next Page**     | Press **Right** _or_ **Volume Down** |
 ### Chapter Navigation
 * **Next Chapter:** Press and **hold** the **Right** (or **Volume Down**) button briefly, then release.
 * **Previous Chapter:** Press and **hold** the **Left** (or **Volume Up**) button briefly, then release.
 ### System Navigation
 * **Return to Home:** Press **Back** to close the book and return to the Book Selection screen.
 * **Chapter Menu:** Press **Confirm** to open the Table of Contents/Chapter Selection screen.
 ---
 ## 5. Chapter Selection Screen
 Accessible by pressing **Confirm** while inside a book.
 1.  Use **Left** (or **Volume Up**), or **Right** (or **Volume Down**) to highlight the desired chapter.
 2.  Press **Confirm** to jump to that chapter.
 3.  *Alternatively, press **Back** to cancel and return to your current page.*
 ---
 ## 6. Current Limitations & Roadmap
 Please note that this firmware is currently in active development. The following features are **not yet supported** but
 are planned for future updates:
 * **Images:** Embedded images in e-books will not render.
 * **Text Formatting:** There are currently no settings to adjust font type, size, line spacing, or margins.
--- a/docs/comparison.md
+++ b/docs/comparison.md
@ -1,19 +0,0 @@
 # CrossPoint vs XTOS
 Below is like for like comparison of CrossPoint (version 0.5.1) and XTOS (version 3.1.1). CrossPoint is on the left, 
 XTOS is on the right. CrossPoint does not currently support all features of XTOS, so this comparison is just of key 
 features which both firmwares support.
 ## EPUB reading
 ![](./images/comparison/reading-1.jpg)
 ![](./images/comparison/reading-2.jpg)
 ![](./images/comparison/reading-3.jpg)
 ## Menus
 ![](./images/comparison/menu.jpg)
 ![](./images/comparison/chapter-menu.jpg)
--- a/docs/images/cover.jpg
+++ b/docs/images/cover.jpg
--- a/docs/images/comparison/chapter-menu.jpg
+++ b/docs/images/comparison/chapter-menu.jpg
--- a/docs/images/comparison/menu.jpg
+++ b/docs/images/comparison/menu.jpg
--- a/docs/images/comparison/reading-1.jpg
+++ b/docs/images/comparison/reading-1.jpg
--- a/docs/images/comparison/reading-2.jpg
+++ b/docs/images/comparison/reading-2.jpg
--- a/docs/images/comparison/reading-3.jpg
+++ b/docs/images/comparison/reading-3.jpg
--- a/lib/EpdFont/builtinFonts/babyblue.h
+++ b/lib/EpdFont/builtinFonts/babyblue.h
@ -0,0 +1,505 @@
 /**
 * generated by fontconvert.py
 * name: babyblue
 * size: 8
 * mode: 1-bit
 */
 #pragma once
 #include "EpdFontData.h"
 static const uint8_t babyblueBitmaps[3140] = {
    0xFF, 0xFF, 0x30, 0xFF, 0xFF, 0xF0, 0x36, 0x1B, 0x0D, 0x9F, 0xFF, 0xF9, 0xB3, 0xFF, 0xFF, 0x36, 0x1B, 0x0D, 0x80,
    0x18, 0x18, 0x7E, 0xFF, 0xDB, 0xD8, 0xFE, 0x7F, 0x9B, 0xDB, 0xFF, 0x7E, 0x18, 0x00, 0x71, 0x9F, 0x73, 0x6C, 0x6F,
    0x8F, 0xE0, 0xFF, 0x83, 0xF8, 0xFB, 0x1B, 0x63, 0x7C, 0xC7, 0x00, 0x38, 0x3E, 0x1B, 0x0D, 0x87, 0xC3, 0xEF, 0xBF,
    0x8E, 0xCF, 0x7F, 0x1E, 0xC0, 0xFF, 0x37, 0xEC, 0xCC, 0xCC, 0xCC, 0xCC, 0x67, 0x20, 0xCE, 0x73, 0x33, 0x33, 0x33,
    0x33, 0x6C, 0x80, 0x32, 0xFF, 0xDE, 0xFE, 0x30, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0xBF, 0x00, 0xFF,
    0xC0, 0x30, 0x0C, 0x31, 0xC6, 0x18, 0xE3, 0x1C, 0x63, 0x8C, 0x00, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
    0xC7, 0x7E, 0x3C, 0x19, 0xDF, 0xFD, 0x8C, 0x63, 0x18, 0xC6, 0x3C, 0x7E, 0xE7, 0x83, 0x07, 0x0E, 0x1C, 0x38, 0x70,
    0xFE, 0xFF, 0x7E, 0xFF, 0xC3, 0x07, 0x3E, 0x3E, 0x07, 0x03, 0x83, 0xFF, 0x7E, 0x0E, 0x1E, 0x3E, 0x76, 0xE6, 0xFF,
    0xFF, 0x06, 0x06, 0x06, 0x06, 0x7F, 0xFF, 0x06, 0x0F, 0xDF, 0xC1, 0x83, 0x87, 0xFD, 0xF0, 0x3E, 0x7F, 0xE3, 0xC0,
    0xFC, 0xFE, 0xE7, 0xC3, 0xC7, 0x7E, 0x3C, 0xFF, 0xFF, 0xC0, 0xE0, 0xE0, 0x60, 0x70, 0x30, 0x18, 0x1C, 0x0C, 0x06,
    0x00, 0x3C, 0x7E, 0x66, 0x66, 0x7E, 0x7E, 0xE7, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7F,
    0x3F, 0x07, 0x3E, 0x7C, 0xB0, 0x03, 0xB0, 0x03, 0xF8, 0x06, 0x3D, 0xF7, 0x8F, 0x0F, 0x87, 0x03, 0xFF, 0xFF, 0x00,
    0xFF, 0xFF, 0x81, 0xE1, 0xF0, 0xF1, 0xEF, 0xBC, 0x40, 0x38, 0xFB, 0xBE, 0x30, 0xE3, 0x8E, 0x18, 0x30, 0x00, 0xC0,
    0x0F, 0xE0, 0x7F, 0xC3, 0x83, 0x9D, 0xE7, 0xEF, 0xCF, 0x73, 0x3D, 0x8C, 0xF6, 0x33, 0xD8, 0xDB, 0x3F, 0xC6, 0x7E,
    0x0C, 0x03, 0x18, 0x18, 0x7F, 0xE0, 0xFF, 0x00, 0x38, 0xFB, 0xBE, 0x3C, 0x7F, 0xFF, 0xE3, 0xC7, 0x8C, 0xFC, 0xFE,
    0xC7, 0xC7, 0xFE, 0xFE, 0xC7, 0xC7, 0xFE, 0xFC, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x06, 0x03, 0x01, 0x83, 0x7F, 0x9F,
    0x80, 0xFC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0xFF, 0xFF, 0x06, 0x0F, 0xDF, 0xB0, 0x60, 0xFD,
    0xFC, 0xFF, 0xFF, 0x06, 0x0F, 0xDF, 0xB0, 0x60, 0xC1, 0x80, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x7E, 0x3F, 0x07, 0x83,
    0x7F, 0x9F, 0x80, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xF0, 0x0C, 0x30, 0xC3,
    0x0C, 0x38, 0xF3, 0xFD, 0xE0, 0xC3, 0xC7, 0xCE, 0xDC, 0xF8, 0xF8, 0xDC, 0xCC, 0xC6, 0xC3, 0xC1, 0x83, 0x06, 0x0C,
    0x18, 0x30, 0x60, 0xFD, 0xFC, 0xE1, 0xF8, 0x7F, 0x3F, 0xCF, 0xFF, 0xF7, 0xBD, 0xEF, 0x7B, 0xCC, 0xF3, 0x30, 0xC3,
    0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F, 0x07, 0x87, 0x7F,
    0x1F, 0x00, 0xFE, 0xFF, 0xC3, 0xC3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F,
    0x37, 0x9F, 0x7F, 0x1F, 0xC0, 0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x7D, 0xFF, 0x1F, 0x87,
    0xC3, 0xC1, 0xC3, 0xFE, 0xF8, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC3, 0xC3, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0xC3, 0xC3, 0xC3, 0xE7, 0x66, 0x7E, 0x3C, 0x3C, 0x3C, 0x18, 0x83, 0x0F, 0x0C,
    0x3C, 0x30, 0xF1, 0xE7, 0x67, 0x99, 0xBF, 0xE3, 0xCF, 0x0F, 0x3C, 0x3C, 0xF0, 0x61, 0x80, 0x80, 0xF8, 0x77, 0x38,
    0xFC, 0x1E, 0x07, 0x83, 0xF1, 0xCE, 0xE1, 0xB0, 0x30, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18,
    0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE, 0xFF, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xFE, 0x81, 0xC1,
    0x83, 0x83, 0x83, 0x06, 0x06, 0x0C, 0x0C, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFE, 0x18, 0x3C, 0x7E, 0x66, 0xE7,
    0xC3, 0x83, 0xFF, 0xFF, 0x9D, 0x80, 0x7D, 0xFE, 0x1B, 0xFF, 0xF8, 0xFF, 0xBF, 0xC1, 0x83, 0xE7, 0xEC, 0xF8, 0xF1,
    0xE7, 0xFD, 0xF0, 0x3C, 0xFF, 0x9E, 0x0C, 0x18, 0x9F, 0x9E, 0x06, 0x0C, 0xFB, 0xFE, 0x78, 0xF1, 0xE3, 0x7E, 0x7C,
    0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x3B, 0xD9, 0xFF, 0xB1, 0x8C, 0x63, 0x18, 0x3E, 0xFF, 0x9E, 0x3C,
    0x78, 0xDF, 0x9F, 0x06, 0x0D, 0xF3, 0xC0, 0xC3, 0x0F, 0xBF, 0xEF, 0x3C, 0xF3, 0xCF, 0x30, 0xFB, 0xFF, 0xF0, 0x6D,
    0x36, 0xDB, 0x6D, 0xBD, 0x00, 0xC3, 0x0C, 0xF7, 0xFB, 0xCE, 0x3C, 0xDB, 0x30, 0xFF, 0xFF, 0xF0, 0x7F, 0xBF, 0xFC,
    0xCF, 0x33, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, 0x7B, 0xFC, 0xF3, 0xCF, 0x3C, 0xF3, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7,
    0x7E, 0x3C, 0x79, 0xFB, 0x3E, 0x3C, 0x79, 0xFF, 0x7C, 0xC1, 0x82, 0x00, 0x3C, 0xFF, 0x9E, 0x3C, 0x78, 0xDF, 0x9F,
    0x06, 0x0C, 0x10, 0x77, 0xF7, 0x8C, 0x63, 0x18, 0x7D, 0xFF, 0x1F, 0xE7, 0xF0, 0xFF, 0xBE, 0x63, 0x3D, 0xE6, 0x31,
    0x8C, 0x71, 0xC0, 0x8F, 0x3C, 0xF3, 0xCF, 0x3F, 0xDE, 0x83, 0xC3, 0xC7, 0x66, 0x66, 0x6E, 0x3C, 0x18, 0x80, 0xF3,
    0x3D, 0xFD, 0xFE, 0x7F, 0x9F, 0xE3, 0x30, 0xCC, 0x83, 0xC7, 0x6E, 0x3C, 0x38, 0x7C, 0xE6, 0xC3, 0x83, 0xC7, 0x66,
    0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0xFF, 0xFC, 0x71, 0xC7, 0x1C, 0x3F, 0x7F, 0x19, 0xCC, 0x63, 0x3B,
    0x98, 0x61, 0x8C, 0x63, 0x1C, 0x40, 0xFF, 0xFF, 0xFF, 0xF8, 0x83, 0x87, 0x0C, 0x30, 0xE1, 0xC7, 0x38, 0xC3, 0x0C,
    0x63, 0x08, 0x00, 0x79, 0xFF, 0xE3, 0xC0, 0xF2, 0xFF, 0xFE, 0x18, 0x30, 0xF3, 0xFF, 0xFB, 0x36, 0x6E, 0x7E, 0x78,
    0x60, 0xC1, 0x00, 0x3C, 0x7E, 0x66, 0x60, 0xFC, 0xFC, 0x30, 0x72, 0xFF, 0xFE, 0x83, 0xFF, 0x7E, 0x66, 0x66, 0x7E,
    0xFE, 0x83, 0x83, 0xE7, 0x7E, 0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0x18, 0x18, 0xFF, 0xFC, 0xBF, 0xF8, 0x3C, 0x7E, 0x66,
    0x7E, 0x7C, 0xEE, 0xC7, 0xC3, 0x77, 0x3E, 0x0C, 0x66, 0x66, 0x7C, 0x38, 0x9E, 0xE6, 0x3F, 0x1F, 0xEF, 0xFF, 0xFF,
    0xF3, 0xFC, 0x3F, 0x3F, 0xFF, 0xDF, 0xDF, 0xE3, 0xF0, 0x77, 0xFF, 0xFF, 0xBC, 0x36, 0xFF, 0xF6, 0xCD, 0xCD, 0x8D,
    0x80, 0xFF, 0xFF, 0x03, 0x03, 0x03, 0x3F, 0x1F, 0xEF, 0xFF, 0xFB, 0xF6, 0xFF, 0xBF, 0xEF, 0xDB, 0xF7, 0xDF, 0xE3,
    0xF0, 0xFF, 0xFF, 0x6F, 0xFF, 0x60, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0xFE, 0xFF, 0x77, 0xE6, 0x77, 0x73,
    0xFF, 0x77, 0xEF, 0x7F, 0xB8, 0x7F, 0x00, 0xCF, 0x3C, 0xF3, 0xCF, 0x3F, 0xFE, 0xC3, 0x0C, 0x20, 0x7F, 0xFF, 0xFE,
    0xFE, 0xFE, 0x7E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x16, 0xB0, 0x63, 0xEC, 0x37, 0xFB, 0x33, 0x30, 0x7B,
    0xFC, 0xF3, 0xFD, 0xE0, 0x99, 0xF9, 0xF9, 0xB7, 0xFF, 0xB6, 0x00, 0x30, 0x07, 0x03, 0xF0, 0x7B, 0x0E, 0x31, 0xC3,
    0x38, 0x37, 0x60, 0xEE, 0x1D, 0xE3, 0xBF, 0x33, 0xF6, 0x06, 0x30, 0x67, 0x0E, 0xF1, 0xCB, 0x38, 0x37, 0x03, 0xEF,
    0x1D, 0xF3, 0x9F, 0x70, 0xEE, 0x0E, 0xC1, 0xF0, 0x70, 0x6F, 0x8E, 0xB9, 0xCB, 0xB8, 0xFF, 0x07, 0xE6, 0x1C, 0xE3,
    0x9E, 0x73, 0xFE, 0x3F, 0xC0, 0x60, 0x30, 0x60, 0xC1, 0x87, 0x1C, 0x30, 0x60, 0xC6, 0xD9, 0xE1, 0x80, 0x30, 0x70,
    0x61, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x18, 0x70, 0xC1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF,
    0x1E, 0x3C, 0x60, 0x38, 0xF9, 0xB1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x3C, 0xF9, 0xE1, 0xC7,
    0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x6C, 0xD8, 0xE3, 0xEE, 0xF8, 0xF1, 0xFF, 0xFF, 0x8F, 0x1E, 0x30,
    0x38, 0xF9, 0xF1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x0F, 0xF8, 0x7F, 0xC7, 0xC0, 0x36, 0x03,
    0xB0, 0x19, 0xF9, 0xFF, 0xCF, 0xE0, 0xE3, 0x06, 0x1F, 0xB0, 0xFE, 0x3F, 0x3F, 0xF8, 0x78, 0x0C, 0x06, 0x03, 0x01,
    0x83, 0x7F, 0x9F, 0x86, 0x01, 0x83, 0x81, 0x80, 0x30, 0x70, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF,
    0xE0, 0x0C, 0x38, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x18, 0x78, 0xF7, 0xFF, 0xF8, 0x30,
    0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x3C, 0x7B, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1, 0x83, 0xF7, 0xF0, 0x9D, 0x36,
    0xDB, 0x6D, 0xB6, 0x7A, 0x6D, 0xB6, 0xDB, 0x6C, 0x6F, 0xB6, 0x66, 0x66, 0x66, 0x66, 0x60, 0xBB, 0x66, 0x66, 0x66,
    0x66, 0x66, 0x7E, 0x3F, 0x98, 0xEC, 0x3F, 0xDF, 0xED, 0x86, 0xC7, 0x7F, 0x3F, 0x00, 0x1E, 0x3E, 0x3C, 0xC3, 0xE3,
    0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x18, 0x0E, 0x03, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0,
    0xF0, 0xEF, 0xE3, 0xE0, 0x0C, 0x0E, 0x06, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0,
    0x1C, 0x1F, 0x0D, 0x87, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x1E, 0x1F, 0x0F, 0x07,
    0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x36, 0x1B, 0x0F, 0x8F, 0xEE, 0x3E, 0x0F, 0x07,
    0x83, 0xC1, 0xE1, 0xDF, 0xC7, 0xC0, 0x8F, 0xF7, 0x9E, 0xFF, 0x30, 0x1F, 0xCF, 0xF7, 0x3D, 0x9F, 0x6E, 0xDF, 0x37,
    0x8D, 0xC7, 0xFF, 0xB7, 0xC0, 0x30, 0x38, 0x18, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x0C,
    0x1C, 0x18, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x0C,
    0x1C, 0x18, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC0, 0xFC, 0xFE, 0xC7, 0xC3, 0xC7, 0xFE,
    0xFC, 0xC0, 0xC0, 0x38, 0xFB, 0xB6, 0x6D, 0xDB, 0x37, 0x67, 0xE7, 0xFF, 0x70, 0x30, 0x70, 0x63, 0xEF, 0xF0, 0xDF,
    0xFF, 0xC7, 0xFD, 0xF8, 0x0C, 0x38, 0x63, 0xEF, 0xF0, 0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x18, 0x78, 0xF3, 0xEF, 0xF0,
    0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x3C, 0xF9, 0xE3, 0xEF, 0xF0, 0xDF, 0xFF, 0xC7, 0xFD, 0xF8, 0x3C, 0x79, 0xF7, 0xF8,
    0x6F, 0xFF, 0xE3, 0xFE, 0xFC, 0x18, 0x78, 0xF0, 0xC7, 0xDF, 0xE1, 0xBF, 0xFF, 0x8F, 0xFB, 0xF0, 0x7F, 0xEF, 0xFF,
    0x86, 0x37, 0xFF, 0xFF, 0xFC, 0x61, 0xFF, 0xF7, 0xFE, 0x3C, 0xFF, 0x9E, 0x0C, 0x18, 0x9F, 0x9E, 0x18, 0x18, 0xE1,
    0x80, 0x30, 0x38, 0x18, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x0C, 0x1C, 0x18, 0x3C, 0x7E, 0xE7, 0xFF,
    0xFF, 0xC0, 0x7E, 0x3F, 0x18, 0x3C, 0x3C, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x3C, 0x3C, 0x3C, 0x7E,
    0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x9D, 0xA6, 0xDB, 0x6D, 0x80, 0x7F, 0x4D, 0xB6, 0xDB, 0x00, 0x6F, 0xB4, 0x66,
    0x66, 0x66, 0x60, 0xBB, 0x46, 0x66, 0x66, 0x66, 0x3E, 0x3E, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C,
    0x3D, 0xF7, 0x9E, 0xFF, 0x3C, 0xF3, 0xCF, 0x3C, 0xC0, 0x30, 0x38, 0x18, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E,
    0x3C, 0x0C, 0x1C, 0x18, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x3C, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3,
    0xC3, 0xC7, 0x7E, 0x3C, 0x1E, 0x3E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3C, 0x3C, 0x3C, 0x7E,
    0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x18, 0xFF, 0xFF, 0x10, 0x18, 0x3F, 0x7F, 0xEF, 0xDF, 0xFB, 0xF7, 0xFE,
    0xFC, 0x61, 0xC3, 0x23, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x18, 0xE3, 0x23, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80,
    0x31, 0xE7, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x79, 0xE8, 0xF3, 0xCF, 0x3C, 0xF3, 0xFD, 0xE0, 0x0C, 0x1C,
    0x18, 0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0xC1, 0x83, 0xE7, 0xEE, 0xF8, 0xF1, 0xE7,
    0xFD, 0xF3, 0x06, 0x08, 0x00, 0x3C, 0x3C, 0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0x7C,
    0xF8, 0xE3, 0xEE, 0xF8, 0xF1, 0xFF, 0xFF, 0x8F, 0x1E, 0x30, 0x7C, 0xF9, 0xF7, 0xF8, 0x6F, 0xFF, 0xE3, 0xFE, 0xFC,
    0x6C, 0xF8, 0xE1, 0xC7, 0xDD, 0xF1, 0xE3, 0xFF, 0xFF, 0x1E, 0x3C, 0x60, 0x6C, 0xF8, 0xE3, 0xEF, 0xF0, 0xDF, 0xFF,
    0xC7, 0xFD, 0xF8, 0x38, 0x7C, 0xEE, 0xC6, 0xC6, 0xFE, 0xFE, 0xC6, 0xC6, 0xC6, 0x0C, 0x0C, 0x0F, 0x07, 0x7C, 0xFE,
    0x86, 0x7E, 0xFE, 0xC6, 0xFE, 0x7E, 0x06, 0x0C, 0x0F, 0x0F, 0x0C, 0x0E, 0x06, 0x07, 0xE7, 0xFF, 0x0F, 0x01, 0x80,
    0xC0, 0x60, 0x30, 0x6F, 0xF3, 0xF0, 0x0C, 0x38, 0x61, 0xE7, 0xFC, 0xF0, 0x60, 0xC4, 0xFC, 0xF0, 0x0C, 0x0F, 0x07,
    0x87, 0xE7, 0xFF, 0x0F, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x6F, 0xF3, 0xF0, 0x18, 0x78, 0xF1, 0xE7, 0xFC, 0xF0, 0x60,
    0xC4, 0xFC, 0xF0, 0x0C, 0x06, 0x0F, 0xCF, 0xFE, 0x1E, 0x03, 0x01, 0x80, 0xC0, 0x60, 0xDF, 0xE7, 0xE0, 0x18, 0x30,
    0xF3, 0xFE, 0x78, 0x30, 0x62, 0x7E, 0x78, 0x1E, 0x0F, 0x03, 0x07, 0xE7, 0xFF, 0x0F, 0x01, 0x80, 0xC0, 0x60, 0x30,
    0x6F, 0xF3, 0xF0, 0x3C, 0x78, 0x61, 0xE7, 0xFC, 0xF0, 0x60, 0xC4, 0xFC, 0xF0, 0x78, 0x78, 0x30, 0xFC, 0xFE, 0xC7,
    0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0x01, 0x83, 0xC1, 0xE7, 0xC7, 0xE7, 0x33, 0x19, 0x8C, 0xC6, 0x3F, 0x0F,
    0x80, 0x7E, 0x3F, 0x98, 0xEC, 0x3F, 0xDF, 0xED, 0x86, 0xC7, 0x7F, 0x3F, 0x00, 0x06, 0x1F, 0x1F, 0x3E, 0x7E, 0xE6,
    0xC6, 0xC6, 0xC6, 0x7E, 0x3E, 0x3C, 0x7B, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1, 0x83, 0xF7, 0xF0, 0x3C, 0x3C, 0x3C,
    0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x66, 0xFC, 0xF7, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0,
    0x66, 0x7E, 0x3C, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x18, 0x33, 0xFF, 0xFC, 0x18, 0x3F, 0x7E, 0xC1,
    0x83, 0xF7, 0xF0, 0x18, 0x18, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0xFE, 0xFE, 0xC0, 0xC0, 0xFC, 0xFC,
    0xC0, 0xC0, 0xFC, 0xFE, 0x06, 0x0C, 0x0F, 0x0F, 0x3C, 0x7E, 0xE7, 0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x06, 0x0C, 0x0F,
    0x07, 0x3C, 0x78, 0x67, 0xFF, 0xF8, 0x30, 0x7E, 0xFD, 0x83, 0x07, 0xEF, 0xE0, 0x3C, 0x3C, 0x18, 0x3C, 0x7E, 0xE7,
    0xFF, 0xFF, 0xC0, 0x7E, 0x3F, 0x0C, 0x0F, 0x07, 0x87, 0xE7, 0xFF, 0x0F, 0x01, 0x8F, 0xC7, 0xE0, 0xF0, 0x6F, 0xF3,
    0xF0, 0x18, 0x78, 0xF1, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6, 0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x36, 0x1F, 0x07, 0x07,
    0xE7, 0xFF, 0x0F, 0x01, 0x8F, 0xC7, 0xE0, 0xF0, 0x6F, 0xF3, 0xF0, 0x36, 0x7C, 0x71, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6,
    0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x0C, 0x06, 0x0F, 0xCF, 0xFE, 0x1E, 0x03, 0x1F, 0x8F, 0xC1, 0xE0, 0xDF, 0xE7,
    0xE0, 0x18, 0x30, 0xFB, 0xFE, 0x78, 0xF1, 0xE3, 0x7E, 0x7C, 0x18, 0x37, 0xCF, 0x00, 0x3F, 0x3F, 0xF8, 0x78, 0x0C,
    0x7E, 0x3F, 0x07, 0x83, 0x7F, 0x9F, 0x83, 0x00, 0xC1, 0xC0, 0xE0, 0x18, 0x30, 0x61, 0xF7, 0xFC, 0xF1, 0xE3, 0xC6,
    0xFC, 0xF8, 0x30, 0x6F, 0x9E, 0x00, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3,
    0x31, 0xE7, 0xB0, 0xC3, 0xEF, 0xFB, 0xCF, 0x3C, 0xF3, 0xCC, 0x61, 0xBF, 0xFF, 0xFD, 0x86, 0x7F, 0x9F, 0xE6, 0x19,
    0x86, 0x61, 0x98, 0x60, 0x61, 0xF3, 0xE3, 0xE7, 0xEE, 0xD9, 0xB3, 0x66, 0xCD, 0x98, 0x7F, 0xEC, 0xC6, 0x31, 0x8C,
    0x63, 0x18, 0xC6, 0x00, 0x7F, 0xEC, 0x86, 0x31, 0x8C, 0x63, 0x18, 0xFF, 0x66, 0x66, 0x66, 0x66, 0x66, 0xFF, 0x46,
    0x66, 0x66, 0x66, 0x9F, 0xDC, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0xC6, 0x00, 0x9F, 0xDC, 0x86, 0x31, 0x8C, 0x63, 0x18,
    0x66, 0x66, 0x66, 0x66, 0x66, 0x6C, 0xF6, 0x66, 0x46, 0x66, 0x66, 0x66, 0x6C, 0xF6, 0xEF, 0xFF, 0xFF, 0xBF, 0xFF,
    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xE3, 0xF3, 0xFF, 0xDE, 0xDE, 0xE7, 0xBD, 0xEF, 0x7B, 0xDE, 0xC6, 0x33, 0x10,
    0x0C, 0x3C, 0x78, 0x60, 0xC1, 0x83, 0x06, 0x0D, 0x1B, 0x37, 0xE7, 0x80, 0x6F, 0xB4, 0x66, 0x66, 0x66, 0x66, 0x6C,
    0x80, 0xC3, 0xC7, 0xCE, 0xDC, 0xF8, 0xF8, 0xDC, 0xCC, 0xC6, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0xC3, 0x0C, 0xF7, 0xFB,
    0xCE, 0x3C, 0xDB, 0x37, 0x0E, 0x71, 0x80, 0x8F, 0x7F, 0xBC, 0xE3, 0xCD, 0xB3, 0x30, 0xE1, 0x86, 0x0C, 0x18, 0x30,
    0x60, 0xC1, 0x83, 0x07, 0xEF, 0xE0, 0x7A, 0x6D, 0xB6, 0xDB, 0x6C, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xFD,
    0xFD, 0xC1, 0xC7, 0x0C, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0xEF, 0xEC, 0x0D, 0x9B, 0x36, 0x6C, 0x18, 0x30, 0x60,
    0xC1, 0xFB, 0xF8, 0x3F, 0xFF, 0xCC, 0xCC, 0xCC, 0xC0, 0xC1, 0x83, 0x06, 0x0C, 0xD9, 0xB0, 0x60, 0xFD, 0xFC, 0xCC,
    0xCC, 0xFF, 0xCC, 0xCC, 0x60, 0x60, 0x78, 0x78, 0xF0, 0xE0, 0x60, 0x60, 0x7E, 0x7F, 0x66, 0x67, 0xFE, 0x66, 0x66,
    0x0C, 0x1C, 0x18, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x18, 0x63, 0x8C, 0x7B, 0xFC, 0xF3,
    0xCF, 0x3C, 0xF3, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0x7B, 0xFC,
    0xF3, 0xCF, 0x3C, 0xF3, 0x70, 0xE7, 0x18, 0x3C, 0x3C, 0x18, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7,
    0xC3, 0x79, 0xE3, 0x1E, 0xFF, 0x3C, 0xF3, 0xCF, 0x3C, 0xC0, 0x81, 0x83, 0x05, 0xE7, 0xEC, 0xD9, 0xB3, 0x66, 0xCD,
    0x98, 0xC3, 0xE3, 0xF3, 0xF3, 0xFB, 0xDF, 0xCF, 0xCF, 0xC7, 0xC3, 0x03, 0x03, 0x03, 0x7B, 0xFC, 0xF3, 0xCF, 0x3C,
    0xF3, 0x0C, 0x31, 0x84, 0x3E, 0x1F, 0x0F, 0x8F, 0xEE, 0x3E, 0x0F, 0x07, 0x83, 0xC1, 0xE1, 0xDF, 0xC7, 0xC0, 0x3C,
    0x3C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x36, 0x1F, 0x07, 0x07, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1,
    0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x36, 0x3E, 0x1C, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x1B, 0x1F, 0x8D,
    0x87, 0xC7, 0xF7, 0x1F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xEF, 0xE3, 0xE0, 0x1E, 0x3E, 0x3C, 0x3C, 0x7E, 0xE7, 0xC3,
    0xC3, 0xC7, 0x7E, 0x3C, 0x3F, 0xFB, 0xFF, 0xF9, 0xC1, 0x86, 0x0C, 0x3F, 0x61, 0xFB, 0x0C, 0x18, 0x60, 0xC7, 0x03,
    0xFF, 0x0F, 0xFC, 0x3D, 0xE3, 0xFF, 0xB9, 0xCF, 0x87, 0xFC, 0x3F, 0xE3, 0x85, 0xFF, 0xE7, 0xBE, 0x18, 0x38, 0x30,
    0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x33, 0x98, 0xEF, 0xEF, 0x18, 0xC6, 0x30, 0xFE, 0xFF,
    0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0x38, 0x1C, 0x38, 0x30, 0x77, 0xF7, 0x8C, 0x63, 0x18, 0xE3, 0xB9,
    0x80, 0x3C, 0x3C, 0x18, 0xFE, 0xFF, 0xC3, 0xC7, 0xFE, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xF7, 0x98, 0xEF, 0xEF, 0x18,
    0xC6, 0x30, 0x18, 0x70, 0xC3, 0xEF, 0xF8, 0xFC, 0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x18, 0x70, 0xC3, 0xEF, 0xF8,
    0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0x18, 0x78, 0xF3, 0xEF, 0xF8, 0xFC, 0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x18, 0x78,
    0xF3, 0xEF, 0xF8, 0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0x7D, 0xFF, 0x1F, 0x87, 0xC3, 0xC1, 0xC3, 0xFE, 0xF8, 0xC0, 0xC7,
    0x0C, 0x00, 0x7D, 0xFF, 0x1F, 0xE7, 0xF0, 0xFF, 0xBE, 0x18, 0x18, 0xE1, 0x80, 0x3C, 0x78, 0x63, 0xEF, 0xF8, 0xFC,
    0x3E, 0x1E, 0x0E, 0x1F, 0xF7, 0xC0, 0x3C, 0x78, 0x63, 0xEF, 0xF8, 0xFF, 0x3F, 0x87, 0xFD, 0xF0, 0xFF, 0xFF, 0xC6,
    0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x01, 0x83, 0x81, 0x80, 0x63, 0x3D, 0xE6, 0x31, 0x8C, 0x71,
    0xCC, 0x37, 0x30, 0x3C, 0x3C, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x0D, 0xB6, 0xFF,
    0xF1, 0x86, 0x18, 0x61, 0xC3, 0x80, 0xFF, 0xFF, 0x18, 0x18, 0x7E, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x63, 0x3D, 0xE6,
    0x73, 0xCC, 0x71, 0xC0, 0x1E, 0x3E, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3D, 0xF7,
    0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x3C, 0x3C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C,
    0x79, 0xE8, 0xF3, 0xCF, 0x3C, 0xF3, 0xFD, 0xE0, 0x36, 0x3E, 0x1C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
    0x7E, 0x3C, 0x6D, 0xF3, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x18, 0x3C, 0x3C, 0xDB, 0xC3, 0xC3, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x31, 0xE7, 0xAF, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0x1E, 0x3E, 0x3C, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x3D, 0xF7, 0xA3, 0xCF, 0x3C, 0xF3, 0xCF, 0xF7, 0x80, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7E, 0x3C, 0x18, 0x30, 0x3C, 0x1C, 0x8D, 0x9B, 0x36, 0x6C, 0xD9, 0xBF, 0x3E,
    0x0C, 0x30, 0x78, 0x70, 0x03, 0x00, 0x1E, 0x00, 0x78, 0x20, 0xC3, 0xC3, 0x0F, 0x0C, 0x3C, 0x79, 0xD9, 0xE6, 0x6F,
    0xF8, 0xF3, 0xC3, 0xCF, 0x0F, 0x3C, 0x18, 0x60, 0x0C, 0x07, 0x81, 0xE2, 0x03, 0xCC, 0xF7, 0xF7, 0xF9, 0xFE, 0x7F,
    0x8C, 0xC3, 0x30, 0x18, 0x3C, 0x3C, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x3C,
    0x83, 0xC7, 0x66, 0x6E, 0x3C, 0x3C, 0x18, 0x18, 0x18, 0x70, 0x60, 0x3C, 0x3C, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0x18,
    0x18, 0x18, 0x18, 0x18, 0x0C, 0x1C, 0x18, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE, 0xFF, 0x0C, 0x38,
    0x67, 0xFF, 0xE3, 0x8E, 0x38, 0xE1, 0xFB, 0xF8, 0x0C, 0x0C, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xFE,
    0xFF, 0x18, 0x33, 0xFF, 0xF1, 0xC7, 0x1C, 0x70, 0xFD, 0xFC, 0x3C, 0x3C, 0x18, 0xFF, 0xFF, 0x07, 0x0E, 0x1C, 0x38,
    0x70, 0xE0, 0xFE, 0xFF, 0x3C, 0x78, 0x67, 0xFF, 0xE3, 0x8E, 0x38, 0xE1, 0xFB, 0xF8, 0x1E, 0x3F, 0x73, 0xFE, 0xFE,
    0xFE, 0xFE, 0x62, 0x3F, 0x1E,
 };
 static const EpdGlyph babyblueGlyphs[] = {
    {0, 0, 5, 0, 0, 0, 0},          //
    {2, 10, 3, 1, 10, 3, 0},        // !
    {4, 5, 5, 1, 11, 3, 3},         // "
    {9, 11, 10, 0, 11, 13, 6},      // #
    {8, 14, 9, 0, 12, 14, 19},      // $
    {11, 11, 13, 1, 11, 16, 33},    // %
    {9, 11, 11, 1, 11, 13, 49},     // &
    {2, 4, 3, 1, 11, 1, 62},        // '
    {4, 15, 5, 1, 11, 8, 63},       // (
    {4, 15, 5, 1, 11, 8, 71},       // )
    {6, 6, 6, 0, 11, 5, 79},        // *
    {8, 8, 9, 0, 9, 8, 84},         // +
    {2, 5, 3, 1, 3, 2, 92},         // ,
    {5, 2, 5, 0, 5, 2, 94},         // -
    {2, 2, 3, 1, 2, 1, 96},         // .
    {6, 11, 6, 0, 11, 9, 97},       // /
    {8, 11, 9, 0, 11, 11, 106},     // 0
    {5, 11, 6, 1, 11, 7, 117},      // 1
    {8, 11, 9, 0, 11, 11, 124},     // 2
    {8, 11, 10, 1, 11, 11, 135},    // 3
    {8, 11, 9, 0, 11, 11, 146},     // 4
    {7, 11, 9, 1, 11, 10, 157},     // 5
    {8, 11, 9, 0, 11, 11, 167},     // 6
    {9, 11, 10, 0, 11, 13, 178},    // 7
    {8, 11, 9, 0, 11, 11, 191},     // 8
    {8, 11, 9, 0, 11, 11, 202},     // 9
    {2, 8, 3, 1, 8, 2, 213},        // :
    {2, 11, 3, 1, 8, 3, 215},       // ;
    {7, 8, 9, 1, 9, 7, 218},        // <
    {8, 5, 9, 0, 8, 5, 225},        // =
    {7, 8, 7, 0, 9, 7, 230},        // >
    {7, 11, 9, 1, 11, 10, 237},     // ?
    {14, 15, 15, 0, 11, 27, 247},   // @
    {7, 10, 9, 1, 10, 9, 274},      // A
    {8, 10, 10, 1, 10, 10, 283},    // B
    {9, 10, 11, 1, 10, 12, 293},    // C
    {8, 10, 10, 1, 10, 10, 305},    // D
    {7, 10, 9, 1, 10, 9, 315},      // E
    {7, 10, 9, 1, 10, 9, 324},      // F
    {9, 10, 11, 1, 10, 12, 333},    // G
    {8, 10, 10, 1, 10, 10, 345},    // H
    {2, 10, 3, 1, 10, 3, 355},      // I
    {6, 10, 6, 0, 10, 8, 358},      // J
    {8, 10, 10, 1, 10, 10, 366},    // K
    {7, 10, 9, 1, 10, 9, 376},      // L
    {10, 10, 12, 1, 10, 13, 385},   // M
    {8, 10, 10, 1, 10, 10, 398},    // N
    {9, 10, 11, 1, 10, 12, 408},    // O
    {8, 10, 10, 1, 10, 10, 420},    // P
    {9, 10, 11, 1, 10, 12, 430},    // Q
    {8, 10, 10, 1, 10, 10, 442},    // R
    {7, 10, 9, 1, 10, 9, 452},      // S
    {8, 10, 9, 0, 10, 10, 461},     // T
    {8, 10, 10, 1, 10, 10, 471},    // U
    {8, 10, 10, 1, 10, 10, 481},    // V
    {14, 10, 15, 0, 10, 18, 491},   // W
    {10, 10, 11, 0, 10, 13, 509},   // X
    {8, 10, 10, 1, 10, 10, 522},    // Y
    {8, 10, 9, 0, 10, 10, 532},     // Z
    {4, 14, 5, 1, 10, 7, 542},      // [
    {7, 10, 7, 0, 10, 9, 549},      // <backslash>
    {4, 14, 4, 0, 10, 7, 558},      // ]
    {8, 7, 9, 0, 11, 7, 565},       // ^
    {8, 2, 9, 0, -2, 2, 572},       // _
    {3, 3, 3, 0, 11, 2, 574},       // `
    {7, 8, 7, 0, 8, 7, 576},        // a
    {7, 10, 9, 1, 10, 9, 583},      // b
    {7, 8, 7, 0, 8, 7, 592},        // c
    {7, 10, 7, 0, 10, 9, 599},      // d
    {8, 8, 9, 0, 8, 8, 608},        // e
    {5, 11, 5, 0, 11, 7, 616},      // f
    {7, 12, 7, 0, 8, 11, 623},      // g
    {6, 10, 7, 1, 10, 8, 634},      // h
    {2, 10, 3, 1, 10, 3, 642},      // i
    {3, 14, 3, 0, 10, 6, 645},      // j
    {6, 10, 7, 1, 10, 8, 651},      // k
    {2, 10, 3, 1, 10, 3, 659},      // l
    {10, 8, 12, 1, 8, 10, 662},     // m
    {6, 8, 7, 1, 8, 6, 672},        // n
    {8, 8, 9, 0, 8, 8, 678},        // o
    {7, 11, 9, 1, 8, 10, 686},      // p
    {7, 11, 7, 0, 8, 10, 696},      // q
    {5, 8, 6, 1, 8, 5, 706},        // r
    {7, 8, 7, 0, 8, 7, 711},        // s
    {5, 10, 5, 0, 10, 7, 718},      // t
    {6, 8, 7, 1, 8, 6, 725},        // u
    {8, 8, 9, 0, 8, 8, 731},        // v
    {10, 8, 11, 0, 8, 10, 739},     // w
    {8, 8, 9, 0, 8, 8, 749},        // x
    {8, 11, 9, 0, 8, 11, 757},      // y
    {7, 8, 7, 0, 8, 7, 768},        // z
    {5, 15, 5, 0, 11, 10, 775},     // {
    {2, 15, 3, 1, 11, 4, 785},      // |
    {6, 15, 6, 0, 11, 12, 789},     // }
    {9, 3, 10, 0, 7, 4, 801},       // ~
    {2, 12, 4, 2, 8, 3, 805},       // ¡
    {7, 13, 7, 0, 10, 12, 808},     // ¢
    {8, 10, 9, 0, 10, 10, 820},     // £
    {8, 8, 9, 0, 9, 8, 830},        // ¤
    {8, 10, 9, 0, 10, 10, 838},     // ¥
    {2, 15, 3, 1, 11, 4, 848},      // ¦
    {8, 15, 9, 0, 11, 15, 852},     // §
    {5, 3, 5, 0, 11, 2, 867},       // ¨
    {10, 11, 11, 0, 11, 14, 869},   // ©
    {5, 6, 5, 0, 11, 4, 883},       // ª
    {7, 7, 9, 1, 8, 7, 887},        // «
    {8, 5, 9, 0, 8, 5, 894},        // ¬
    {10, 11, 11, 0, 11, 14, 899},   // ®
    {8, 2, 9, 0, 12, 2, 913},       // ¯
    {4, 5, 5, 1, 11, 3, 915},       // °
    {8, 9, 9, 0, 9, 9, 918},        // ±
    {5, 8, 5, 0, 11, 5, 927},       // ²
    {5, 6, 5, 0, 11, 4, 932},       // ³
    {3, 3, 4, 1, 11, 2, 936},       // ´
    {6, 12, 9, 2, 8, 9, 938},       // µ
    {8, 14, 9, 0, 10, 14, 947},     // ¶
    {2, 2, 3, 1, 6, 1, 961},        // ·
    {4, 4, 4, 0, 0, 2, 962},        // ¸
    {4, 7, 4, 0, 12, 4, 964},       // ¹
    {6, 6, 6, 0, 11, 5, 968},       // º
    {7, 7, 9, 1, 8, 7, 973},        // »
    {12, 12, 13, 0, 12, 18, 980},   // ¼
    {12, 11, 13, 0, 11, 17, 998},   // ½
    {12, 11, 13, 0, 11, 17, 1015},  // ¾
    {7, 12, 9, 1, 8, 11, 1032},     // ¿
    {7, 13, 9, 1, 13, 12, 1043},    // À
    {7, 13, 9, 1, 13, 12, 1055},    // Á
    {7, 13, 9, 1, 13, 12, 1067},    // Â
    {7, 13, 9, 1, 13, 12, 1079},    // Ã
    {7, 12, 9, 1, 12, 11, 1091},    // Ä
    {7, 13, 9, 1, 13, 12, 1102},    // Å
    {13, 11, 14, 0, 11, 18, 1114},  // Æ
    {9, 14, 11, 1, 10, 16, 1132},   // Ç
    {7, 13, 9, 1, 13, 12, 1148},    // È
    {7, 13, 9, 1, 13, 12, 1160},    // É
    {7, 13, 9, 1, 13, 12, 1172},    // Ê
    {7, 12, 9, 1, 12, 11, 1184},    // Ë
    {3, 13, 3, 0, 13, 5, 1195},     // Ì
    {3, 13, 4, 1, 13, 5, 1200},     // Í
    {4, 13, 4, 0, 13, 7, 1205},     // Î
    {4, 12, 4, 0, 12, 6, 1212},     // Ï
    {9, 10, 10, 0, 10, 12, 1218},   // Ð
    {8, 13, 10, 1, 13, 13, 1230},   // Ñ
    {9, 13, 11, 1, 13, 15, 1243},   // Ò
    {9, 13, 11, 1, 13, 15, 1258},   // Ó
    {9, 13, 11, 1, 13, 15, 1273},   // Ô
    {9, 13, 11, 1, 13, 15, 1288},   // Õ
    {9, 12, 11, 1, 12, 14, 1303},   // Ö
    {6, 6, 7, 1, 8, 5, 1317},       // ×
    {10, 10, 11, 0, 10, 13, 1322},  // Ø
    {8, 13, 10, 1, 13, 13, 1335},   // Ù
    {8, 13, 10, 1, 13, 13, 1348},   // Ú
    {8, 13, 10, 1, 13, 13, 1361},   // Û
    {8, 12, 10, 1, 12, 12, 1374},   // Ü
    {8, 13, 10, 1, 13, 13, 1386},   // Ý
    {8, 10, 10, 1, 10, 10, 1399},   // Þ
    {7, 11, 9, 1, 11, 10, 1409},    // ß
    {7, 11, 7, 0, 11, 10, 1419},    // à
    {7, 11, 7, 0, 11, 10, 1429},    // á
    {7, 11, 7, 0, 11, 10, 1439},    // â
    {7, 11, 7, 0, 11, 10, 1449},    // ã
    {7, 10, 7, 0, 10, 9, 1459},     // ä
    {7, 12, 7, 0, 12, 11, 1468},    // å
    {12, 8, 13, 0, 8, 12, 1479},    // æ
    {7, 12, 7, 0, 8, 11, 1491},     // ç
    {8, 11, 9, 0, 11, 11, 1502},    // è
    {8, 11, 9, 0, 11, 11, 1513},    // é
    {8, 11, 9, 0, 11, 11, 1524},    // ê
    {8, 10, 9, 0, 10, 10, 1535},    // ë
    {3, 11, 3, 0, 11, 5, 1545},     // ì
    {3, 11, 4, 1, 11, 5, 1550},     // í
    {4, 11, 4, 0, 11, 6, 1555},     // î
    {4, 10, 4, 0, 10, 5, 1561},     // ï
    {8, 11, 9, 0, 11, 11, 1566},    // ð
    {6, 11, 7, 1, 11, 9, 1577},     // ñ
    {8, 11, 9, 0, 11, 11, 1586},    // ò
    {8, 11, 9, 0, 11, 11, 1597},    // ó
    {8, 11, 9, 0, 11, 11, 1608},    // ô
    {8, 11, 9, 0, 11, 11, 1619},    // õ
    {8, 10, 9, 0, 10, 10, 1630},    // ö
    {8, 6, 9, 0, 8, 6, 1640},       // ÷
    {8, 8, 9, 0, 8, 8, 1646},       // ø
    {6, 11, 7, 1, 11, 9, 1654},     // ù
    {6, 11, 7, 1, 11, 9, 1663},     // ú
    {6, 11, 7, 1, 11, 9, 1672},     // û
    {6, 10, 7, 1, 10, 8, 1681},     // ü
    {8, 14, 9, 0, 11, 14, 1689},    // ý
    {7, 13, 9, 1, 10, 12, 1703},    // þ
    {8, 13, 9, 0, 10, 13, 1715},    // ÿ
    {7, 12, 9, 1, 12, 11, 1728},    // Ā
    {7, 10, 7, 0, 10, 9, 1739},     // ā
    {7, 13, 9, 1, 13, 12, 1748},    // Ă
    {7, 11, 7, 0, 11, 10, 1760},    // ă
    {8, 14, 10, 1, 10, 14, 1770},   // Ą
    {8, 12, 9, 0, 8, 12, 1784},     // ą
    {9, 13, 11, 1, 13, 15, 1796},   // Ć
    {7, 11, 7, 0, 11, 10, 1811},    // ć
    {9, 13, 11, 1, 13, 15, 1821},   // Ĉ
    {7, 11, 7, 0, 11, 10, 1836},    // ĉ
    {9, 12, 11, 1, 12, 14, 1846},   // Ċ
    {7, 10, 7, 0, 10, 9, 1860},     // ċ
    {9, 13, 11, 1, 13, 15, 1869},   // Č
    {7, 11, 7, 0, 11, 10, 1884},    // č
    {8, 13, 10, 1, 13, 13, 1894},   // Ď
    {9, 11, 10, 0, 11, 13, 1907},   // ď
    {9, 10, 10, 0, 10, 12, 1920},   // Đ
    {8, 11, 9, 0, 11, 11, 1932},    // đ
    {7, 12, 9, 1, 12, 11, 1943},    // Ē
    {8, 10, 9, 0, 10, 10, 1954},    // ē
    {7, 13, 9, 1, 13, 12, 1964},    // Ĕ
    {8, 11, 9, 0, 11, 11, 1976},    // ĕ
    {7, 12, 9, 1, 12, 11, 1987},    // Ė
    {8, 10, 9, 0, 10, 10, 1998},    // ė
    {8, 14, 10, 1, 10, 14, 2008},   // Ę
    {8, 12, 9, 0, 8, 12, 2022},     // ę
    {7, 13, 9, 1, 13, 12, 2034},    // Ě
    {8, 11, 9, 0, 11, 11, 2046},    // ě
    {9, 13, 11, 1, 13, 15, 2057},   // Ĝ
    {7, 15, 7, 0, 11, 14, 2072},    // ĝ
    {9, 13, 11, 1, 13, 15, 2086},   // Ğ
    {7, 15, 7, 0, 11, 14, 2101},    // ğ
    {9, 12, 11, 1, 12, 14, 2115},   // Ġ
    {7, 14, 7, 0, 10, 13, 2129},    // ġ
    {9, 14, 11, 1, 10, 16, 2142},   // Ģ
    {7, 15, 7, 0, 11, 14, 2158},    // ģ
    {8, 13, 10, 1, 13, 13, 2172},   // Ĥ
    {6, 13, 7, 1, 13, 10, 2185},    // ĥ
    {10, 10, 11, 0, 10, 13, 2195},  // Ħ
    {7, 11, 7, 0, 11, 10, 2208},    // ħ
    {5, 13, 5, 0, 13, 9, 2218},     // Ĩ
    {5, 11, 5, 0, 11, 7, 2227},     // ĩ
    {4, 12, 4, 0, 12, 6, 2234},     // Ī
    {4, 10, 4, 0, 10, 5, 2240},     // ī
    {5, 13, 5, 0, 13, 9, 2245},     // Ĭ
    {5, 11, 5, 0, 11, 7, 2254},     // ĭ
    {4, 14, 4, 0, 10, 7, 2261},     // Į
    {4, 14, 4, 0, 10, 7, 2268},     // į
    {2, 12, 3, 1, 12, 3, 2275},     // İ
    {2, 8, 3, 1, 8, 2, 2278},       // ı
    {8, 10, 10, 1, 10, 10, 2280},   // Ĳ
    {5, 14, 6, 1, 10, 9, 2290},     // ĳ
    {7, 13, 7, 0, 13, 12, 2299},    // Ĵ
    {4, 15, 4, 0, 11, 8, 2311},     // ĵ
    {8, 14, 10, 1, 10, 14, 2319},   // Ķ
    {6, 14, 7, 1, 10, 11, 2333},    // ķ
    {6, 8, 7, 1, 8, 6, 2344},       // ĸ
    {7, 13, 9, 1, 13, 12, 2350},    // Ĺ
    {3, 13, 4, 1, 13, 5, 2362},     // ĺ
    {7, 14, 9, 1, 10, 13, 2367},    // Ļ
    {4, 14, 4, 0, 10, 7, 2380},     // ļ
    {7, 11, 9, 1, 11, 10, 2387},    // Ľ
    {4, 11, 5, 1, 11, 6, 2397},     // ľ
    {7, 10, 9, 1, 10, 9, 2403},     // Ŀ
    {4, 10, 5, 1, 10, 5, 2412},     // ŀ
    {8, 10, 9, 0, 10, 10, 2417},    // Ł
    {4, 10, 4, 0, 10, 5, 2427},     // ł
    {8, 13, 10, 1, 13, 13, 2432},   // Ń
    {6, 12, 7, 1, 12, 9, 2445},     // ń
    {8, 14, 10, 1, 10, 14, 2454},   // Ņ
    {6, 12, 7, 1, 8, 9, 2468},      // ņ
    {8, 13, 10, 1, 13, 13, 2477},   // Ň
    {6, 11, 7, 1, 11, 9, 2490},     // ň
    {7, 11, 7, 0, 11, 10, 2499},    // ŉ
    {8, 13, 10, 1, 10, 13, 2509},   // Ŋ
    {6, 12, 7, 1, 8, 9, 2522},      // ŋ
    {9, 12, 11, 1, 12, 14, 2531},   // Ō
    {8, 10, 9, 0, 10, 10, 2545},    // ō
    {9, 13, 11, 1, 13, 15, 2555},   // Ŏ
    {8, 11, 9, 0, 11, 11, 2570},    // ŏ
    {9, 13, 11, 1, 13, 15, 2581},   // Ő
    {8, 11, 9, 0, 11, 11, 2596},    // ő
    {13, 11, 15, 1, 11, 18, 2607},  // Œ
    {13, 8, 14, 0, 8, 13, 2625},    // œ
    {8, 13, 10, 1, 13, 13, 2638},   // Ŕ
    {5, 11, 6, 1, 11, 7, 2651},     // ŕ
    {8, 14, 10, 1, 10, 14, 2658},   // Ŗ
    {5, 12, 6, 1, 8, 8, 2672},      // ŗ
    {8, 13, 10, 1, 13, 13, 2680},   // Ř
    {5, 11, 6, 1, 11, 7, 2693},     // ř
    {7, 13, 9, 1, 13, 12, 2700},    // Ś
    {7, 11, 7, 0, 11, 10, 2712},    // ś
    {7, 13, 9, 1, 13, 12, 2722},    // Ŝ
    {7, 11, 7, 0, 11, 10, 2734},    // ŝ
    {7, 14, 9, 1, 10, 13, 2744},    // Ş
    {7, 12, 7, 0, 8, 11, 2757},     // ş
    {7, 13, 9, 1, 13, 12, 2768},    // Š
    {7, 11, 7, 0, 11, 10, 2780},    // š
    {9, 14, 10, 0, 10, 16, 2790},   // Ţ
    {5, 14, 5, 0, 10, 9, 2806},     // ţ
    {8, 13, 9, 0, 13, 13, 2815},    // Ť
    {6, 11, 6, 0, 11, 9, 2828},     // ť
    {8, 10, 9, 0, 10, 10, 2837},    // Ŧ
    {5, 10, 5, 0, 10, 7, 2847},     // ŧ
    {8, 13, 10, 1, 13, 13, 2854},   // Ũ
    {6, 11, 7, 1, 11, 9, 2867},     // ũ
    {8, 12, 10, 1, 12, 12, 2876},   // Ū
    {6, 10, 7, 1, 10, 8, 2888},     // ū
    {8, 13, 10, 1, 13, 13, 2896},   // Ŭ
    {6, 11, 7, 1, 11, 9, 2909},     // ŭ
    {8, 13, 10, 1, 13, 13, 2918},   // Ů
    {6, 11, 7, 1, 11, 9, 2931},     // ů
    {8, 13, 10, 1, 13, 13, 2940},   // Ű
    {6, 11, 7, 1, 11, 9, 2953},     // ű
    {8, 14, 10, 1, 10, 14, 2962},   // Ų
    {7, 12, 9, 1, 8, 11, 2976},     // ų
    {14, 13, 15, 0, 13, 23, 2987},  // Ŵ
    {10, 11, 11, 0, 11, 14, 3010},  // ŵ
    {8, 13, 10, 1, 13, 13, 3024},   // Ŷ
    {8, 14, 9, 0, 11, 14, 3037},    // ŷ
    {8, 12, 10, 1, 12, 12, 3051},   // Ÿ
    {8, 13, 9, 0, 13, 13, 3063},    // Ź
    {7, 11, 7, 0, 11, 10, 3076},    // ź
    {8, 12, 9, 0, 12, 12, 3086},    // Ż
    {7, 10, 7, 0, 10, 9, 3098},     // ż
    {8, 13, 9, 0, 13, 13, 3107},    // Ž
    {7, 11, 7, 0, 11, 10, 3120},    // ž
    {8, 10, 9, 0, 10, 10, 3130},    // €
 };
 static const EpdUnicodeInterval babyblueIntervals[] = {
    {0x20, 0x7E, 0x0}, {0xA1, 0xAC, 0x5F}, {0xAE, 0xFF, 0x6B}, {0x100, 0x17E, 0xBD}, {0x20AC, 0x20AC, 0x13C},
 };
 static const EpdFontData babyblue = {
    babyblueBitmaps, babyblueGlyphs, babyblueIntervals, 5, 17, 13, -4, false,
 };
--- a/lib/EpdFont/builtinFonts/bookerly_2b.h
+++ b/lib/EpdFont/builtinFonts/bookerly_2b.h
--- a/lib/EpdFont/builtinFonts/bookerly_bold_2b.h
+++ b/lib/EpdFont/builtinFonts/bookerly_bold_2b.h
--- a/lib/EpdFont/builtinFonts/bookerly_bold_italic_2b.h
+++ b/lib/EpdFont/builtinFonts/bookerly_bold_italic_2b.h
--- a/lib/EpdFont/builtinFonts/bookerly_italic_2b.h
+++ b/lib/EpdFont/builtinFonts/bookerly_italic_2b.h
--- a/lib/EpdFont/builtinFonts/pixelarial14.h
+++ b/lib/EpdFont/builtinFonts/pixelarial14.h
@ -8,67 +8,67 @@
 #include "EpdFontData.h"
 static const uint8_t pixelarial14Bitmaps[1145] = {
-    0xFF, 0xFF, 0xFA, 0xC0, 0xFF, 0xFF, 0xFB, 0x18, 0x63, 0x0C, 0x63, 0x98, 0xCF, 0xFF, 0xFF, 0x9C, 0xE3, 0x18, 0xFF,
+    0xFF, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xFF, 0x1C, 0x63, 0x8C, 0xF7, 0x98, 0xCF, 0xFF, 0xFF, 0xDC, 0xE7, 0xFE, 0xFF,
-    0xFF, 0xFB, 0x9C, 0x63, 0x0C, 0x60, 0x30, 0xF3, 0xF7, 0xBF, 0x1F, 0x1F, 0x9B, 0x37, 0xEF, 0xFB, 0xC3, 0x00, 0x70,
+    0xFF, 0xFB, 0x9C, 0x63, 0x0C, 0x60, 0x30, 0xF3, 0xFF, 0xBF, 0x1F, 0x9F, 0x9B, 0x37, 0xEF, 0xFB, 0xE3, 0x00, 0x70,
-    0x67, 0xCE, 0x36, 0x61, 0xB3, 0x0D, 0xB0, 0x7D, 0x81, 0xDD, 0xC0, 0xDE, 0x07, 0x98, 0xEC, 0xC6, 0x66, 0x33, 0xF3,
+    0x67, 0xCF, 0x37, 0x61, 0xBB, 0x0D, 0xF0, 0x7D, 0x81, 0xDD, 0xC0, 0xDF, 0x07, 0x98, 0xFC, 0xC7, 0x66, 0x7B, 0xF3,
-    0x07, 0x00, 0x3E, 0x0F, 0xE1, 0x8C, 0x31, 0x86, 0x60, 0xFC, 0x1E, 0x03, 0xE0, 0xC7, 0x98, 0xF3, 0x0E, 0x7F, 0xE7,
+    0x07, 0x00, 0x3E, 0x0F, 0xE1, 0x8C, 0x31, 0x86, 0x60, 0xFC, 0x1F, 0x07, 0xE4, 0xC7, 0x98, 0xF3, 0x0E, 0x7F, 0xF7,
-    0xE6, 0xFF, 0xE0, 0x37, 0x66, 0xCC, 0xCC, 0xCC, 0xCC, 0xC6, 0x67, 0x30, 0xCE, 0x66, 0x33, 0x33, 0x33, 0x33, 0x36,
+    0xE6, 0xFF, 0xF0, 0x37, 0x66, 0xCC, 0xCC, 0xCC, 0xCC, 0xC6, 0x67, 0x30, 0xCE, 0x66, 0x33, 0x33, 0x33, 0x33, 0x36,
-    0x6E, 0xC0, 0x6F, 0xF6, 0xFB, 0x08, 0x0C, 0x06, 0x03, 0x0F, 0xFF, 0xFC, 0x60, 0x30, 0x18, 0x04, 0x00, 0xBF, 0xC0,
+    0x6E, 0xC0, 0x6F, 0xF6, 0xFF, 0x08, 0x0E, 0x07, 0x03, 0x8F, 0xFF, 0xFC, 0x70, 0x38, 0x1C, 0x0E, 0x00, 0xFF, 0xC0,
-    0x03, 0xEF, 0x80, 0xB0, 0x18, 0x61, 0x8C, 0x30, 0xC7, 0x18, 0x61, 0x8E, 0x30, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3,
+    0xFB, 0xFF, 0x80, 0xF0, 0x1C, 0x73, 0xCC, 0x30, 0xC7, 0x18, 0x61, 0x8E, 0x30, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3,
    0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x37, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x30, 0x7E, 0xFF, 0xC3, 0xC3,
-    0x03, 0x03, 0x07, 0x06, 0x18, 0x38, 0x70, 0xFF, 0xFF, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x3F, 0x3F, 0x03, 0x03, 0xC3,
+    0x03, 0x03, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xFF, 0xFF, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x3F, 0x3F, 0x03, 0x03, 0xC3,
-    0xC3, 0xFF, 0x7E, 0x03, 0x03, 0x83, 0xC3, 0x63, 0x31, 0x99, 0xCC, 0xC6, 0xC3, 0x7F, 0xFF, 0xE0, 0x60, 0x30, 0x7F,
+    0xC3, 0xFF, 0x7E, 0x03, 0x03, 0x83, 0xC3, 0xE3, 0x31, 0x99, 0xCD, 0xC6, 0xC3, 0x7F, 0xFF, 0xE0, 0x60, 0x30, 0x7F,
    0x7F, 0xE0, 0xC0, 0xFE, 0xFF, 0xC3, 0x03, 0x03, 0xC3, 0xC7, 0xFE, 0x7E, 0x7E, 0xFF, 0xC3, 0xC0, 0xC0, 0xFE, 0xFF,
-    0xE3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFF, 0xFF, 0x07, 0x06, 0x06, 0x0E, 0x18, 0x18, 0x18, 0x38, 0x30, 0x30, 0x30,
+    0xE3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFF, 0xFF, 0x07, 0x06, 0x06, 0x1E, 0x1C, 0x1C, 0x1C, 0x38, 0x30, 0x30, 0x30,
    0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0xC7,
-    0xFF, 0x7B, 0x03, 0x03, 0xC7, 0xFE, 0x78, 0xB0, 0x00, 0x2C, 0xB0, 0x00, 0x2F, 0xF0, 0x03, 0x03, 0x1E, 0x7E, 0xF0,
+    0xFF, 0x7F, 0x03, 0x03, 0xC7, 0xFE, 0x7C, 0xF0, 0x00, 0x3C, 0xF0, 0x00, 0x3F, 0xF0, 0x03, 0x03, 0x1E, 0x7E, 0xF0,
-    0xC0, 0x70, 0x3E, 0x0F, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFE, 0x80, 0xC0, 0x70, 0x7E, 0x0F, 0x03, 0x1E, 0x7C,
+    0xF0, 0x70, 0x7E, 0x1F, 0x03, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0x70, 0x7E, 0x1F, 0x0F, 0x1E, 0x7E,
-    0xF0, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x07, 0x0E, 0x18, 0x30, 0x30, 0x30, 0x10, 0x30, 0x3F, 0x87, 0xFE, 0xEF,
+    0xF0, 0xC0, 0x7E, 0xFF, 0xC3, 0xC3, 0x03, 0x07, 0x1E, 0x1C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0x87, 0xFE, 0xFF,
-    0x7D, 0xF3, 0xF1, 0xBF, 0x1B, 0xF3, 0xBF, 0xFF, 0xDF, 0xE6, 0x00, 0x7F, 0x03, 0xF0, 0x06, 0x00, 0xF0, 0x1B, 0x01,
+    0x7D, 0xFB, 0xF1, 0xBF, 0x1B, 0xF3, 0xBF, 0xFF, 0xDF, 0xE6, 0x00, 0x7F, 0x03, 0xF0, 0x06, 0x01, 0xF0, 0x1F, 0x01,
-    0xB0, 0x1B, 0x03, 0xB8, 0x31, 0x83, 0x18, 0x7F, 0xE7, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x30, 0xFF, 0x7F, 0xF0, 0x78,
+    0xF0, 0x1F, 0x03, 0xB8, 0x31, 0x87, 0xFC, 0x7F, 0xE7, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x30, 0xFF, 0x7F, 0xF0, 0x78,
-    0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x7F, 0xFF, 0xF0, 0x3F, 0x0F, 0xF3, 0x87, 0x60, 0x3C, 0x01, 0x80,
+    0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x7F, 0xFF, 0xF0, 0x3F, 0x0F, 0xF3, 0x87, 0xE0, 0x3C, 0x01, 0x80,
-    0x30, 0x06, 0x00, 0xC0, 0x18, 0x0F, 0x87, 0x3F, 0xC3, 0xF0, 0xFF, 0x1F, 0xF3, 0x07, 0x60, 0x3C, 0x07, 0x80, 0xF0,
+    0x30, 0x06, 0x00, 0xC0, 0x18, 0x0F, 0x87, 0xBF, 0xC3, 0xF0, 0xFF, 0x1F, 0xF3, 0x07, 0xE0, 0x3C, 0x07, 0x80, 0xF0,
-    0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x07, 0x7F, 0xCF, 0xF0, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFF, 0xFF, 0x80, 0xC0,
+    0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x07, 0xFF, 0xCF, 0xF0, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFF, 0xFF, 0x80, 0xC0,
    0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0xFB, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C,
    0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x1F, 0xC0, 0x3C, 0x03, 0xE0, 0x77, 0xFE,
    0x3F, 0x80, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x18, 0xFF, 0xFF,
-    0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07, 0x8F, 0x1F, 0xF7, 0x80, 0xC0, 0x78, 0x3B, 0x0E, 0x61,
+    0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07, 0x8F, 0x1F, 0xF7, 0xC0, 0xC0, 0x78, 0x3F, 0x0E, 0x61,
-    0x8C, 0x61, 0x9C, 0x3F, 0x87, 0xB0, 0xE3, 0x18, 0x63, 0x0E, 0x60, 0xEC, 0x06, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
+    0x8C, 0x61, 0xBC, 0x3F, 0x87, 0xB8, 0xE3, 0x1C, 0x63, 0x0E, 0x60, 0xFC, 0x06, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
    0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x1F, 0xFF, 0xF8, 0xC0, 0x3E, 0x07, 0xE0, 0x7E, 0x07, 0xF1, 0xBF, 0x1B, 0xFB,
-    0xBD, 0xB3, 0xDB, 0x3D, 0xB3, 0xCF, 0x3C, 0x63, 0xC6, 0x30, 0xC1, 0xF0, 0xFC, 0x7E, 0x3F, 0x1F, 0xCF, 0x67, 0xBB,
+    0xBD, 0xF3, 0xDF, 0x3D, 0xF3, 0xDF, 0x3C, 0x63, 0xC6, 0x30, 0xC1, 0xF0, 0xFC, 0x7E, 0x3F, 0x1F, 0xEF, 0x77, 0xBB,
    0xC7, 0xE3, 0xF1, 0xF8, 0x7C, 0x18, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0,
    0x3C, 0x03, 0xE0, 0x77, 0xFE, 0x3F, 0x80, 0xFF, 0x7F, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0xFF, 0xFE, 0xC0, 0x60, 0x30,
-    0x18, 0x0C, 0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x36, 0xE3,
+    0x18, 0x0C, 0x00, 0x3F, 0x87, 0xFE, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x37, 0xE3,
    0xE7, 0xFF, 0x3F, 0x70, 0xFF, 0x9F, 0xFF, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xFF, 0xFF, 0xFC, 0xC6, 0x18, 0xE3, 0x0E,
-    0x60, 0xEC, 0x06, 0x7F, 0x7F, 0xF0, 0x78, 0x3C, 0x07, 0xC1, 0xFE, 0x0F, 0x01, 0xE0, 0xF0, 0x7F, 0xF7, 0xF0, 0xFF,
+    0x60, 0xFC, 0x06, 0x7F, 0x7F, 0xF0, 0x78, 0x3C, 0x07, 0xE1, 0xFE, 0x0F, 0x01, 0xE0, 0xF0, 0x7F, 0xF7, 0xF0, 0xFF,
-    0xFF, 0xC6, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
+    0xFF, 0xC7, 0x03, 0x81, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x81, 0xC0, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
-    0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xC0, 0x3C, 0x03, 0xE0, 0x76, 0x06, 0x60, 0x67, 0x1C,
+    0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xC0, 0x3C, 0x03, 0xE0, 0x76, 0x06, 0x60, 0x67, 0x1E,
-    0x31, 0x83, 0x18, 0x1B, 0x01, 0xB0, 0x0F, 0x00, 0x60, 0x06, 0x00, 0xC1, 0x81, 0xE1, 0xF0, 0xF8, 0xD8, 0xEC, 0x6C,
+    0x31, 0x83, 0xB8, 0x1F, 0x01, 0xF0, 0x1F, 0x00, 0x60, 0x06, 0x00, 0xC1, 0x81, 0xE1, 0xF0, 0xF8, 0xD8, 0xEC, 0x6C,
-    0x66, 0x36, 0x33, 0x1B, 0x19, 0xDD, 0xDC, 0x6C, 0x78, 0x36, 0x3C, 0x1B, 0x1E, 0x0F, 0x8F, 0x03, 0x03, 0x01, 0x81,
+    0x66, 0x36, 0x33, 0x1B, 0x19, 0xDD, 0xFC, 0x6C, 0x7C, 0x36, 0x3E, 0x1B, 0x1F, 0x0F, 0x8F, 0x03, 0x83, 0x01, 0xC1,
-    0x80, 0xC0, 0x7C, 0x39, 0x86, 0x30, 0xC3, 0x30, 0x7E, 0x07, 0x80, 0xF0, 0x33, 0x0E, 0x31, 0x86, 0x70, 0xEC, 0x06,
+    0x80, 0xC0, 0x7C, 0x3D, 0x86, 0x30, 0xC3, 0x30, 0x7E, 0x07, 0x80, 0xF8, 0x33, 0x0E, 0x71, 0x86, 0x70, 0xFC, 0x06,
-    0xC0, 0x3E, 0x07, 0x70, 0xE3, 0x18, 0x31, 0x83, 0xB8, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06,
+    0xC0, 0x3E, 0x07, 0x71, 0xE3, 0x18, 0x31, 0x83, 0xF8, 0x1F, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06,
-    0x00, 0xFF, 0xFF, 0xF8, 0x0E, 0x01, 0x80, 0x30, 0x0E, 0x03, 0x80, 0xC0, 0x30, 0x06, 0x01, 0xC0, 0x7F, 0xEF, 0xFE,
+    0x00, 0xFF, 0xFF, 0xFC, 0x0E, 0x01, 0x80, 0x30, 0x0E, 0x07, 0x80, 0xE0, 0x30, 0x06, 0x01, 0xC0, 0x7F, 0xFF, 0xFE,
-    0xFF, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0xE0, 0xC3, 0x0E, 0x18, 0x61, 0x87, 0x0C, 0x30, 0xC3, 0x86, 0x18, 0xFD, 0xB6,
+    0xFF, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0xE0, 0xC3, 0x0E, 0x18, 0x61, 0x87, 0x0C, 0x30, 0xC3, 0x87, 0x1C, 0xFD, 0xB6,
-    0xDB, 0x6D, 0xB6, 0xDF, 0xE0, 0x30, 0xF1, 0xE3, 0xC7, 0x9D, 0xF1, 0x80, 0xFF, 0xDF, 0xFC, 0xCE, 0x73, 0x00, 0x7C,
+    0xDB, 0x6D, 0xB6, 0xDF, 0xE0, 0x30, 0xF1, 0xF3, 0xE7, 0xDD, 0xF1, 0x80, 0xFF, 0xFF, 0xFC, 0xCE, 0x73, 0x00, 0x7E,
-    0x7E, 0xC3, 0x83, 0x3F, 0x3F, 0x63, 0xC3, 0xC7, 0xFF, 0x7B, 0xC0, 0xC0, 0xDC, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0x7E, 0xC3, 0xC3, 0x3F, 0x7F, 0x63, 0xE3, 0xC7, 0xFF, 0x7F, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xE3, 0xFF, 0xFE, 0x78, 0xF3, 0x1E, 0x3C, 0x18, 0x30, 0x60, 0xC7, 0xFD, 0xE0, 0x03, 0x03, 0x7B, 0x7B, 0xC7,
+    0xC3, 0xE3, 0xFF, 0xFE, 0x78, 0xFB, 0x1E, 0x3C, 0x18, 0x30, 0x60, 0xC7, 0xFD, 0xF0, 0x03, 0x03, 0x7B, 0x7F, 0xC7,
-    0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7B, 0x7C, 0x7E, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0xC0, 0xC3, 0xFF, 0x7E,
+    0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0x7E, 0x7E, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0xC0, 0xC3, 0xFF, 0x7E,
-    0x39, 0xEF, 0xBE, 0x61, 0x86, 0x18, 0x61, 0x86, 0x18, 0x60, 0x7B, 0x7B, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
+    0x3D, 0xEF, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x18, 0x60, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7,
-    0xFF, 0x7B, 0x03, 0xC3, 0xFF, 0x7E, 0xC0, 0xC0, 0xDC, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0xFF, 0x7F, 0x03, 0xC3, 0xFF, 0x7E, 0xC0, 0xC0, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xFB, 0xFF, 0xFF, 0xC0, 0x33, 0x13, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xE0, 0xC0, 0xC0, 0xC3, 0xC3, 0xC6, 0xCE,
+    0xFF, 0xFF, 0xFF, 0xC0, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xE0, 0xC0, 0xC0, 0xC3, 0xC3, 0xC6, 0xDE,
-    0xF8, 0xF0, 0xF8, 0xCE, 0xC6, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xC0, 0x98, 0xCF, 0x9E, 0xE7, 0x3E, 0x73, 0xC6, 0x3C,
+    0xFC, 0xF8, 0xFC, 0xEE, 0xC6, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xC0, 0xF9, 0xEF, 0xDE, 0xE7, 0x3E, 0x73, 0xC6, 0x3C,
-    0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0x9C, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+    0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0x7C, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0x9C, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
+    0xC3, 0x7E, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0x7E, 0xFE, 0xFE, 0xE3, 0xE3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xE3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x7B, 0x7B, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7B,
+    0xC3, 0xE3, 0xFF, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0x7B, 0x7F, 0xC7, 0xC7, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F,
-    0x03, 0x03, 0x03, 0x03, 0x9B, 0xEE, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x00, 0x78, 0xF3, 0x1E, 0x3F, 0x8F, 0x81,
+    0x03, 0x03, 0x03, 0x03, 0xFB, 0xFE, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x00, 0x78, 0xFB, 0x1E, 0x3F, 0x8F, 0x81,
-    0x83, 0xC7, 0xFD, 0xE0, 0x61, 0x8F, 0xBE, 0x61, 0x86, 0x18, 0x61, 0x86, 0x1E, 0x78, 0x83, 0xC3, 0xC3, 0xC3, 0xC3,
+    0x83, 0xC7, 0xFD, 0xF0, 0x61, 0x8F, 0xBF, 0x61, 0x86, 0x18, 0x61, 0x86, 0x1E, 0x7C, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
-    0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7B, 0x80, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0x18, 0xD8, 0x6C, 0x3E, 0x0C, 0x06, 0x00,
+    0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7F, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x3E, 0x0E, 0x07, 0x00,
-    0x84, 0x3C, 0x63, 0xC6, 0x3E, 0xF7, 0x7B, 0x67, 0xB6, 0x7B, 0x67, 0xB6, 0x7B, 0xC3, 0x18, 0x31, 0x80, 0x83, 0xC3,
+    0xC6, 0x3C, 0x63, 0xC6, 0x3F, 0xF7, 0x7F, 0x67, 0xF6, 0x7F, 0x67, 0xF6, 0x7B, 0xE3, 0x18, 0x31, 0x80, 0xC3, 0xC3,
-    0x66, 0x66, 0x7E, 0x38, 0x38, 0x7E, 0x66, 0xE7, 0xC3, 0x80, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0x18, 0xD8, 0x6C, 0x36,
+    0x66, 0x66, 0x7E, 0x3C, 0x3C, 0x7E, 0x66, 0xE7, 0xC3, 0xC1, 0xE0, 0xF0, 0x7C, 0x76, 0x33, 0xB8, 0xD8, 0x6C, 0x36,
-    0x1F, 0x06, 0x03, 0x01, 0x83, 0xC1, 0xC0, 0xFF, 0xFF, 0x06, 0x0E, 0x18, 0x18, 0x30, 0x30, 0x70, 0xFF, 0xFF, 0x37,
+    0x1F, 0x07, 0x03, 0x81, 0xC3, 0xE1, 0xC0, 0xFF, 0xFF, 0x06, 0x1E, 0x1C, 0x1C, 0x30, 0x30, 0x70, 0xFF, 0xFF, 0x37,
-    0x66, 0x66, 0x66, 0xCE, 0x66, 0x66, 0x67, 0x30, 0xFF, 0xFF, 0xFF, 0xC0, 0xCE, 0x66, 0x66, 0x66, 0x37, 0x66, 0x66,
+    0x66, 0x66, 0x6E, 0xCE, 0x66, 0x66, 0x67, 0x30, 0xFF, 0xFF, 0xFF, 0xC0, 0xCE, 0x66, 0x66, 0x67, 0x37, 0x66, 0x66,
-    0x6E, 0xC0, 0xC3, 0x99, 0xFF, 0xF9, 0xB8, 0x30, 0xDB, 0x66, 0xC0, 0x6D, 0xBD, 0x00, 0x7B, 0xEF, 0x3C, 0xF2, 0xC0,
+    0x6E, 0xC0, 0xC3, 0x9B, 0xFF, 0xF9, 0xB8, 0x30, 0xDB, 0x66, 0xC0, 0x6D, 0xBD, 0x80, 0x7F, 0xEF, 0x3C, 0xF3, 0xC0,
-    0x79, 0xE7, 0x9E, 0xF2, 0xC0,
+    0x7D, 0xF7, 0xDF, 0xF3, 0xC0,
 };
 static const EpdGlyph pixelarial14Glyphs[] = {
--- a/lib/EpdFont/builtinFonts/ubuntu_10.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_10.h
--- a/lib/EpdFont/builtinFonts/ubuntu_bold_10.h
+++ b/lib/EpdFont/builtinFonts/ubuntu_bold_10.h
--- a/lib/EpdFont/scripts/fontconvert.py
+++ b/lib/EpdFont/scripts/fontconvert.py
@ -54,7 +54,7 @@ intervals = [
    # (0x0370, 0x03FF),
    ### Cyrillic ###
    # Russian, Ukrainian, Bulgarian, etc.
-    (0x0400, 0x04FF),
+    # (0x0400, 0x04FF),
    ### Math Symbols (common subset) ###
    # General math operators
    (0x2200, 0x22FF),
@ -176,7 +176,7 @@ for i_start, i_end in intervals:
                px = 0
        if is2Bit:
-            # 0-3 white, 4-7 light grey, 8-11 dark grey, 12-15 black
+            # 0 = white, 15 black, 8+ dark grey, 7- light grey
            # Downsample to 2-bit bitmap
            pixels2b = []
            px = 0
@ -187,11 +187,11 @@ for i_start, i_end in intervals:
                    bm = pixels4g[y * pitch + (x // 2)]
                    bm = (bm >> ((x % 2) * 4)) & 0xF
-                    if bm >= 12:
+                    if bm == 15:
                        px += 3
                    elif bm >= 8:
                        px += 2
-                    elif bm >= 4:
+                    elif bm > 0:
                        px += 1
                    if (y * bitmap.width + x) % 4 == 3:
@ -211,7 +211,7 @@ for i_start, i_end in intervals:
            #     print(line)
            # print('')
        else:
-            # Downsample to 1-bit bitmap - treat any 2+ as black
+            # Downsample to 1-bit bitmap - treat any non-zero as black
            pixelsbw = []
            px = 0
            pitch = (bitmap.width // 2) + (bitmap.width % 2)
@ -219,7 +219,7 @@ for i_start, i_end in intervals:
                for x in range(bitmap.width):
                    px = px << 1
                    bm = pixels4g[y * pitch + (x // 2)]
-                    px += 1 if ((x & 1) == 0 and bm & 0xE > 0) or ((x & 1) == 1 and bm & 0xE0 > 0) else 0
+                    px += 1 if ((x & 1) == 0 and bm & 0xF > 0) or ((x & 1) == 1 and bm & 0xF0 > 0) else 0
                    if (y * bitmap.width + x) % 8 == 7:
                        pixelsbw.append(px)
--- a/lib/Epub/Epub.cpp
+++ b/lib/Epub/Epub.cpp
@ -7,195 +7,250 @@
 #include <map>
 #include "Epub/FsHelpers.h"
 #include "Epub/parsers/ContainerParser.h"
 #include "Epub/parsers/ContentOpfParser.h"
 #include "Epub/parsers/TocNcxParser.h"
-bool Epub::findContentOpfFile(std::string* contentOpfFile) const {
+bool Epub::findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile) {
-  const auto containerPath = "META-INF/container.xml";
+  // open up the meta data to find where the content.opf file lives
-  size_t containerSize;
+  size_t s;
-
+  const auto metaInfo = reinterpret_cast<char*>(zip.readFileToMemory("META-INF/container.xml", &s, true));
-  // Get file size without loading it all into heap
+  if (!metaInfo) {
-  if (!getItemSize(containerPath, &containerSize)) {
+    Serial.printf("[%lu] [EBP] Could not find META-INF/container.xml\n", millis());
    Serial.printf("[%lu] [EBP] Could not find or size META-INF/container.xml\n", millis());
    return false;
  }
-  ContainerParser containerParser(containerSize);
+  // parse the meta data
  tinyxml2::XMLDocument metaDataDoc;
  const auto result = metaDataDoc.Parse(metaInfo);
  free(metaInfo);
-  if (!containerParser.setup()) {
+  if (result != tinyxml2::XML_SUCCESS) {
    Serial.printf("[%lu] [EBP] Could not parse META-INF/container.xml. Error: %d\n", millis(), result);
    return false;
  }
-  // Stream read (reusing your existing stream logic)
+  const auto container = metaDataDoc.FirstChildElement("container");
-  if (!readItemContentsToStream(containerPath, containerParser, 512)) {
+  if (!container) {
-    Serial.printf("[%lu] [EBP] Could not read META-INF/container.xml\n", millis());
+    Serial.printf("[%lu] [EBP] Could not find container element in META-INF/container.xml\n", millis());
    containerParser.teardown();
    return false;
  }
-  // Extract the result
+  const auto rootfiles = container->FirstChildElement("rootfiles");
-  if (containerParser.fullPath.empty()) {
+  if (!rootfiles) {
-    Serial.printf("[%lu] [EBP] Could not find valid rootfile in container.xml\n", millis());
+    Serial.printf("[%lu] [EBP] Could not find rootfiles element in META-INF/container.xml\n", millis());
    containerParser.teardown();
    return false;
  }
-  *contentOpfFile = std::move(containerParser.fullPath);
+  // find the root file that has the media-type="application/oebps-package+xml"
-
+  auto rootfile = rootfiles->FirstChildElement("rootfile");
-  containerParser.teardown();
+  while (rootfile) {
-  return true;
+    const char* mediaType = rootfile->Attribute("media-type");
-}
+    if (mediaType && strcmp(mediaType, "application/oebps-package+xml") == 0) {
-
+      const char* full_path = rootfile->Attribute("full-path");
-bool Epub::parseContentOpf(const std::string& contentOpfFilePath) {
+      if (full_path) {
-  size_t contentOpfSize;
+        contentOpfFile = full_path;
-  if (!getItemSize(contentOpfFilePath, &contentOpfSize)) {
+        return true;
-    Serial.printf("[%lu] [EBP] Could not get size of content.opf\n", millis());
+      }
    return false;
  }
  ContentOpfParser opfParser(getBasePath(), contentOpfSize);
  if (!opfParser.setup()) {
    Serial.printf("[%lu] [EBP] Could not setup content.opf parser\n", millis());
    return false;
  }
  if (!readItemContentsToStream(contentOpfFilePath, opfParser, 1024)) {
    Serial.printf("[%lu] [EBP] Could not read content.opf\n", millis());
    opfParser.teardown();
    return false;
  }
  // Grab data from opfParser into epub
  title = opfParser.title;
  if (!opfParser.coverItemId.empty() && opfParser.items.count(opfParser.coverItemId) > 0) {
    coverImageItem = opfParser.items.at(opfParser.coverItemId);
  }
  if (!opfParser.tocNcxPath.empty()) {
    tocNcxItem = opfParser.tocNcxPath;
  }
  for (auto& spineRef : opfParser.spineRefs) {
    if (opfParser.items.count(spineRef)) {
      spine.emplace_back(spineRef, opfParser.items.at(spineRef));
    }
    rootfile = rootfile->NextSiblingElement("rootfile");
  }
-  Serial.printf("[%lu] [EBP] Successfully parsed content.opf\n", millis());
+  Serial.printf("[%lu] [EBP] Could not get path to content.opf file\n", millis());
  return false;
 }
-  opfParser.teardown();
+bool Epub::parseContentOpf(ZipFile& zip, std::string& content_opf_file) {
  // read in the content.opf file and parse it
  auto contents = reinterpret_cast<char*>(zip.readFileToMemory(content_opf_file.c_str(), nullptr, true));
  // parse the contents
  tinyxml2::XMLDocument doc;
  auto result = doc.Parse(contents);
  free(contents);
  if (result != tinyxml2::XML_SUCCESS) {
    Serial.printf("[%lu] [EBP] Error parsing content.opf - %s\n", millis(),
                  tinyxml2::XMLDocument::ErrorIDToName(result));
    return false;
  }
  auto package = doc.FirstChildElement("package");
  if (!package) package = doc.FirstChildElement("opf:package");
  if (!package) {
    Serial.printf("[%lu] [EBP] Could not find package element in content.opf\n", millis());
    return false;
  }
  // get the metadata - title and cover image
  auto metadata = package->FirstChildElement("metadata");
  if (!metadata) metadata = package->FirstChildElement("opf:metadata");
  if (!metadata) {
    Serial.printf("[%lu] [EBP] Missing metadata\n", millis());
    return false;
  }
  auto titleEl = metadata->FirstChildElement("dc:title");
  if (!titleEl) {
    Serial.printf("[%lu] [EBP] Missing title\n", millis());
    return false;
  }
  this->title = titleEl->GetText();
  auto cover = metadata->FirstChildElement("meta");
  if (!cover) cover = metadata->FirstChildElement("opf:meta");
  while (cover && cover->Attribute("name") && strcmp(cover->Attribute("name"), "cover") != 0) {
    cover = cover->NextSiblingElement("meta");
  }
  if (!cover) {
    Serial.printf("[%lu] [EBP] Missing cover\n", millis());
  }
  auto coverItem = cover ? cover->Attribute("content") : nullptr;
  // read the manifest and spine
  // the manifest gives us the names of the files
  // the spine gives us the order of the files
  // we can then read the files in the order they are in the spine
  auto manifest = package->FirstChildElement("manifest");
  if (!manifest) manifest = package->FirstChildElement("opf:manifest");
  if (!manifest) {
    Serial.printf("[%lu] [EBP] Missing manifest\n", millis());
    return false;
  }
  // create a mapping from id to file name
  auto item = manifest->FirstChildElement("item");
  if (!item) item = manifest->FirstChildElement("opf:item");
  std::map<std::string, std::string> items;
  while (item) {
    std::string itemId = item->Attribute("id");
    std::string href = contentBasePath + item->Attribute("href");
    // grab the cover image
    if (coverItem && itemId == coverItem) {
      coverImageItem = href;
    }
    // grab the ncx file
    if (itemId == "ncx" || itemId == "ncxtoc") {
      tocNcxItem = href;
    }
    items[itemId] = href;
    auto nextItem = item->NextSiblingElement("item");
    if (!nextItem) nextItem = item->NextSiblingElement("opf:item");
    item = nextItem;
  }
  // find the spine
  auto spineEl = package->FirstChildElement("spine");
  if (!spineEl) spineEl = package->FirstChildElement("opf:spine");
  if (!spineEl) {
    Serial.printf("[%lu] [EBP] Missing spine\n", millis());
    return false;
  }
  // read the spine
  auto itemref = spineEl->FirstChildElement("itemref");
  if (!itemref) itemref = spineEl->FirstChildElement("opf:itemref");
  while (itemref) {
    auto id = itemref->Attribute("idref");
    if (items.find(id) != items.end()) {
      spine.emplace_back(id, items[id]);
    }
    auto nextItemRef = itemref->NextSiblingElement("itemref");
    if (!nextItemRef) nextItemRef = itemref->NextSiblingElement("opf:itemref");
    itemref = nextItemRef;
  }
  return true;
 }
-bool Epub::parseTocNcxFile() {
+bool Epub::parseTocNcxFile(const ZipFile& zip) {
  // the ncx file should have been specified in the content.opf file
  if (tocNcxItem.empty()) {
    Serial.printf("[%lu] [EBP] No ncx file specified\n", millis());
    return false;
  }
-  size_t tocSize;
+  const auto ncxData = reinterpret_cast<char*>(zip.readFileToMemory(tocNcxItem.c_str(), nullptr, true));
-  if (!getItemSize(tocNcxItem, &tocSize)) {
+  if (!ncxData) {
-    Serial.printf("[%lu] [EBP] Could not get size of toc ncx\n", millis());
+    Serial.printf("[%lu] [EBP] Could not find %s\n", millis(), tocNcxItem.c_str());
    return false;
  }
-  TocNcxParser ncxParser(contentBasePath, tocSize);
+  // Parse the Toc contents
  tinyxml2::XMLDocument doc;
  const auto result = doc.Parse(ncxData);
  free(ncxData);
-  if (!ncxParser.setup()) {
+  if (result != tinyxml2::XML_SUCCESS) {
-    Serial.printf("[%lu] [EBP] Could not setup toc ncx parser\n", millis());
+    Serial.printf("[%lu] [EBP] Error parsing toc %s\n", millis(), tinyxml2::XMLDocument::ErrorIDToName(result));
    return false;
  }
-  if (!readItemContentsToStream(tocNcxItem, ncxParser, 1024)) {
+  const auto ncx = doc.FirstChildElement("ncx");
-    Serial.printf("[%lu] [EBP] Could not read toc ncx stream\n", millis());
+  if (!ncx) {
-    ncxParser.teardown();
+    Serial.printf("[%lu] [EBP] Could not find first child ncx in toc\n", millis());
    return false;
  }
-  this->toc = std::move(ncxParser.toc);
+  const auto navMap = ncx->FirstChildElement("navMap");
  if (!navMap) {
    Serial.printf("[%lu] [EBP] Could not find navMap child in ncx\n", millis());
    return false;
  }
-  Serial.printf("[%lu] [EBP] Parsed %d TOC items\n", millis(), this->toc.size());
+  recursivelyParseNavMap(navMap->FirstChildElement("navPoint"));
  ncxParser.teardown();
  return true;
 }
 void Epub::recursivelyParseNavMap(tinyxml2::XMLElement* element) {
  // Fills toc map
  while (element) {
    std::string navTitle = element->FirstChildElement("navLabel")->FirstChildElement("text")->FirstChild()->Value();
    const auto content = element->FirstChildElement("content");
    std::string href = contentBasePath + content->Attribute("src");
    // split the href on the # to get the href and the anchor
    const size_t pos = href.find('#');
    std::string anchor;
    if (pos != std::string::npos) {
      anchor = href.substr(pos + 1);
      href = href.substr(0, pos);
    }
    toc.emplace_back(navTitle, href, anchor, 0);
    tinyxml2::XMLElement* nestedNavPoint = element->FirstChildElement("navPoint");
    if (nestedNavPoint) {
      recursivelyParseNavMap(nestedNavPoint);
    }
    element = element->NextSiblingElement("navPoint");
  }
 }
 // load in the meta data for the epub file
 bool Epub::load() {
  Serial.printf("[%lu] [EBP] Loading ePub: %s\n", millis(), filepath.c_str());
  ZipFile zip("/sd" + filepath);
-  std::string contentOpfFilePath;
+  std::string contentOpfFile;
-  if (!findContentOpfFile(&contentOpfFilePath)) {
+  if (!findContentOpfFile(zip, contentOpfFile)) {
-    Serial.printf("[%lu] [EBP] Could not find content.opf in zip\n", millis());
+    Serial.printf("[%lu] [EBP] Could not open ePub\n", millis());
    return false;
  }
-  Serial.printf("[%lu] [EBP] Found content.opf at: %s\n", millis(), contentOpfFilePath.c_str());
+  contentBasePath = contentOpfFile.substr(0, contentOpfFile.find_last_of('/') + 1);
-  contentBasePath = contentOpfFilePath.substr(0, contentOpfFilePath.find_last_of('/') + 1);
+  if (!parseContentOpf(zip, contentOpfFile)) {
  if (!parseContentOpf(contentOpfFilePath)) {
    Serial.printf("[%lu] [EBP] Could not parse content.opf\n", millis());
    return false;
  }
-  if (!parseTocNcxFile()) {
+  if (!parseTocNcxFile(zip)) {
    Serial.printf("[%lu] [EBP] Could not parse toc\n", millis());
    return false;
  }
  initializeSpineItemSizes();
  Serial.printf("[%lu] [EBP] Loaded ePub: %s\n", millis(), filepath.c_str());
  return true;
 }
 void Epub::initializeSpineItemSizes() {
  setupCacheDir();
  size_t spineItemsCount = getSpineItemsCount();
  size_t cumSpineItemSize = 0;
  if (SD.exists((getCachePath() + "/spine_size.bin").c_str())) {
    File f = SD.open((getCachePath() + "/spine_size.bin").c_str());
    uint8_t data[4];
    for (size_t i = 0; i < spineItemsCount; i++) {
      f.read(data, 4);
      cumSpineItemSize = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
      cumulativeSpineItemSize.emplace_back(cumSpineItemSize);
      // Serial.printf("[%lu] [EBP] Loading item %d size %u to %u %u\n", millis(),
      //     i, cumSpineItemSize, data[1], data[0]);
    }
    f.close();
  } else {
    File f = SD.open((getCachePath() + "/spine_size.bin").c_str(), FILE_WRITE);
    uint8_t data[4];
    // determine size of spine items
    for (size_t i = 0; i < spineItemsCount; i++) {
      std::string spineItem = getSpineItem(i);
      size_t s = 0;
      getItemSize(spineItem, &s);
      cumSpineItemSize += s;
      cumulativeSpineItemSize.emplace_back(cumSpineItemSize);
      // and persist to cache
      data[0] = cumSpineItemSize & 0xFF;
      data[1] = (cumSpineItemSize >> 8) & 0xFF;
      data[2] = (cumSpineItemSize >> 16) & 0xFF;
      data[3] = (cumSpineItemSize >> 24) & 0xFF;
      // Serial.printf("[%lu] [EBP] Persisting item %d size %u to %u %u\n", millis(),
      //     i, cumSpineItemSize, data[1], data[0]);
      f.write(data, 4);
    }
    f.close();
  }
  Serial.printf("[%lu] [EBP] Book size: %lu\n", millis(), cumSpineItemSize);
 }
 bool Epub::clearCache() const {
  if (!SD.exists(cachePath.c_str())) {
    Serial.printf("[%lu] [EPB] Cache does not exist, no action needed\n", millis());
@ -289,17 +344,8 @@ bool Epub::readItemContentsToStream(const std::string& itemHref, Print& out, con
  return zip.readFileToStream(path.c_str(), out, chunkSize);
 }
 bool Epub::getItemSize(const std::string& itemHref, size_t* size) const {
  const ZipFile zip("/sd" + filepath);
  const std::string path = normalisePath(itemHref);
  return zip.getInflatedFileSize(path.c_str(), size);
 }
 int Epub::getSpineItemsCount() const { return spine.size(); }
 size_t Epub::getCumulativeSpineItemSize(const int spineIndex) const { return cumulativeSpineItemSize.at(spineIndex); }
 std::string& Epub::getSpineItem(const int spineIndex) {
  if (spineIndex < 0 || spineIndex >= spine.size()) {
    Serial.printf("[%lu] [EBP] getSpineItem index:%d is out of range\n", millis(), spineIndex);
@ -345,16 +391,6 @@ int Epub::getTocIndexForSpineIndex(const int spineIndex) const {
  }
  Serial.printf("[%lu] [EBP] TOC item not found\n", millis());
-  return -1;
+  // not found - default to first item
-}
+  return 0;
 size_t Epub::getBookSize() const { return getCumulativeSpineItemSize(getSpineItemsCount() - 1); }
 // Calculate progress in book
 uint8_t Epub::calculateProgress(const int currentSpineIndex, const float currentSpineRead) {
  size_t prevChapterSize = (currentSpineIndex >= 1) ? getCumulativeSpineItemSize(currentSpineIndex - 1) : 0;
  size_t curChapterSize = getCumulativeSpineItemSize(currentSpineIndex) - prevChapterSize;
  size_t bookSize = getBookSize();
  size_t sectionProgSize = currentSpineRead * curChapterSize;
  return round(static_cast<float>(prevChapterSize + sectionProgSize) / bookSize * 100.0);
 }
--- a/lib/Epub/Epub.h
+++ b/lib/Epub/Epub.h
@ -1,14 +1,23 @@
 #pragma once
 #include <Print.h>
 #include <tinyxml2.h>
 #include <string>
 #include <unordered_map>
 #include <vector>
 #include "Epub/EpubTocEntry.h"
 class ZipFile;
 class EpubTocEntry {
 public:
  std::string title;
  std::string href;
  std::string anchor;
  int level;
  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
 };
 class Epub {
  // the title read from the EPUB meta data
  std::string title;
@ -20,8 +29,6 @@ class Epub {
  std::string filepath;
  // the spine of the EPUB file
  std::vector<std::pair<std::string, std::string>> spine;
  // the file size of the spine items (proxy to book progress)
  std::vector<size_t> cumulativeSpineItemSize;
  // the toc of the EPUB file
  std::vector<EpubTocEntry> toc;
  // the base path for items in the EPUB file
@ -29,10 +36,11 @@ class Epub {
  // Uniq cache key based on filepath
  std::string cachePath;
-  bool findContentOpfFile(std::string* contentOpfFile) const;
+  // find the path for the content.opf file
-  bool parseContentOpf(const std::string& contentOpfFilePath);
+  static bool findContentOpfFile(const ZipFile& zip, std::string& contentOpfFile);
-  bool parseTocNcxFile();
+  bool parseContentOpf(ZipFile& zip, std::string& content_opf_file);
-  void initializeSpineItemSizes();
+  bool parseTocNcxFile(const ZipFile& zip);
  void recursivelyParseNavMap(tinyxml2::XMLElement* element);
 public:
  explicit Epub(std::string filepath, const std::string& cacheDir) : filepath(std::move(filepath)) {
@ -51,15 +59,10 @@ class Epub {
  uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
                                   bool trailingNullByte = false) const;
  bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;
  bool getItemSize(const std::string& itemHref, size_t* size) const;
  std::string& getSpineItem(int spineIndex);
  int getSpineItemsCount() const;
-  size_t getCumulativeSpineItemSize(const int spineIndex) const;
+  EpubTocEntry& getTocItem(int tocTndex);
  EpubTocEntry& getTocItem(int tocIndex);
  int getTocItemsCount() const;
  int getSpineIndexForTocIndex(int tocIndex) const;
  int getTocIndexForSpineIndex(int spineIndex) const;
  size_t getBookSize() const;
  uint8_t calculateProgress(const int currentSpineIndex, const float currentSpineRead);
 };
--- a/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
+++ b/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
@ -1,11 +1,11 @@
-#include "ChapterHtmlSlimParser.h"
+#include "EpubHtmlParserSlim.h"
 #include <GfxRenderer.h>
 #include <HardwareSerial.h>
 #include <expat.h>
-#include "../Page.h"
+#include "Page.h"
-#include "../htmlEntities.h"
+#include "htmlEntities.h"
 const char* HEADER_TAGS[] = {"h1", "h2", "h3", "h4", "h5", "h6"};
 constexpr int NUM_HEADER_TAGS = sizeof(HEADER_TAGS) / sizeof(HEADER_TAGS[0]);
@ -25,7 +25,7 @@ constexpr int NUM_IMAGE_TAGS = sizeof(IMAGE_TAGS) / sizeof(IMAGE_TAGS[0]);
 const char* SKIP_TAGS[] = {"head", "table"};
 constexpr int NUM_SKIP_TAGS = sizeof(SKIP_TAGS) / sizeof(SKIP_TAGS[0]);
-bool isWhitespace(const char c) { return c == ' ' || c == '\r' || c == '\n' || c == '\t'; }
+bool isWhitespace(const char c) { return c == ' ' || c == '\r' || c == '\n'; }
 // given the start and end of a tag, check to see if it matches a known tag
 bool matches(const char* tag_name, const char* possible_tags[], const int possible_tag_count) {
@ -38,7 +38,7 @@ bool matches(const char* tag_name, const char* possible_tags[], const int possib
 }
 // start a new text block if needed
-void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
+void EpubHtmlParserSlim::startNewTextBlock(const TextBlock::BLOCK_STYLE style) {
  if (currentTextBlock) {
    // already have a text block running and it is empty - just reuse it
    if (currentTextBlock->isEmpty()) {
@ -48,11 +48,11 @@ void ChapterHtmlSlimParser::startNewTextBlock(const TextBlock::BLOCK_STYLE style
    makePages();
  }
-  currentTextBlock.reset(new ParsedText(style, extraParagraphSpacing));
+  currentTextBlock.reset(new ParsedText(style));
 }
-void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
+void XMLCALL EpubHtmlParserSlim::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
-  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
+  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
  (void)atts;
  // Middle of skip
@ -62,7 +62,23 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
  }
  if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
-    // TODO: Start processing image tags
+    // const char* src = element.Attribute("src");
    // if (src) {
    //   // don't leave an empty text block in the list
    //   // const BLOCK_STYLE style = currentTextBlock->get_style();
    //   if (currentTextBlock->isEmpty()) {
    //     delete currentTextBlock;
    //     currentTextBlock = nullptr;
    //   }
    //   // TODO: Fix this
    //   // blocks.push_back(new ImageBlock(m_base_path + src));
    //   // start a new text block - with the same style as before
    //   // startNewTextBlock(style);
    // } else {
    //   // ESP_LOGE(TAG, "Could not find src attribute");
    // }
    // start skip
    self->skipUntilDepth = self->depth;
    self->depth += 1;
    return;
@ -75,18 +91,6 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
    return;
  }
  // Skip blocks with role="doc-pagebreak" and epub:type="pagebreak"
  if (atts != nullptr) {
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "role") == 0 && strcmp(atts[i + 1], "doc-pagebreak") == 0 ||
          strcmp(atts[i], "epub:type") == 0 && strcmp(atts[i + 1], "pagebreak") == 0) {
        self->skipUntilDepth = self->depth;
        self->depth += 1;
        return;
      }
    }
  }
  if (matches(name, HEADER_TAGS, NUM_HEADER_TAGS)) {
    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
    self->boldUntilDepth = min(self->boldUntilDepth, self->depth);
@ -105,8 +109,8 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
  self->depth += 1;
 }
-void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char* s, const int len) {
+void XMLCALL EpubHtmlParserSlim::characterData(void* userData, const XML_Char* s, const int len) {
-  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
+  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
  // Middle of skip
  if (self->skipUntilDepth < self->depth) {
@ -145,8 +149,8 @@ void XMLCALL ChapterHtmlSlimParser::characterData(void* userData, const XML_Char
  }
 }
-void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* name) {
+void XMLCALL EpubHtmlParserSlim::endElement(void* userData, const XML_Char* name) {
-  auto* self = static_cast<ChapterHtmlSlimParser*>(userData);
+  auto* self = static_cast<EpubHtmlParserSlim*>(userData);
  (void)name;
  if (self->partWordBufferIndex > 0) {
@ -192,7 +196,7 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
  }
 }
-bool ChapterHtmlSlimParser::parseAndBuildPages() {
+bool EpubHtmlParserSlim::parseAndBuildPages() {
  startNewTextBlock(TextBlock::JUSTIFIED);
  const XML_Parser parser = XML_ParserCreate(nullptr);
@ -257,21 +261,7 @@ bool ChapterHtmlSlimParser::parseAndBuildPages() {
  return true;
 }
-void ChapterHtmlSlimParser::addLineToPage(std::shared_ptr<TextBlock> line) {
+void EpubHtmlParserSlim::makePages() {
  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
  if (currentPageNextY + lineHeight > pageHeight) {
    completePageFn(std::move(currentPage));
    currentPage.reset(new Page());
    currentPageNextY = marginTop;
  }
  currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
  currentPageNextY += lineHeight;
 }
 void ChapterHtmlSlimParser::makePages() {
  if (!currentTextBlock) {
    Serial.printf("[%lu] [EHP] !! No text block to make pages for !!\n", millis());
    return;
@ -283,11 +273,23 @@ void ChapterHtmlSlimParser::makePages() {
  }
  const int lineHeight = renderer.getLineHeight(fontId) * lineCompression;
-  currentTextBlock->layoutAndExtractLines(
+  const int pageHeight = GfxRenderer::getScreenHeight() - marginTop - marginBottom;
-      renderer, fontId, marginLeft + marginRight,
+
-      [this](const std::shared_ptr<TextBlock>& textBlock) { addLineToPage(textBlock); });
+  // Long running task, make sure to let other things happen
-  // Extra paragraph spacing if enabled
+  vTaskDelay(1);
-  if (extraParagraphSpacing) {
+
-    currentPageNextY += lineHeight / 2;
+  const auto lines = currentTextBlock->layoutAndExtractLines(renderer, fontId, marginLeft + marginRight);
  for (auto&& line : lines) {
    if (currentPageNextY + lineHeight > pageHeight) {
      completePageFn(std::move(currentPage));
      currentPage.reset(new Page());
      currentPageNextY = marginTop;
    }
    currentPage->elements.push_back(std::make_shared<PageLine>(line, marginLeft, currentPageNextY));
    currentPageNextY += lineHeight;
  }
  // add some extra line between blocks
  currentPageNextY += lineHeight / 2;
 }
--- a/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h
+++ b/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.h
@ -6,15 +6,15 @@
 #include <functional>
 #include <memory>
-#include "../ParsedText.h"
+#include "ParsedText.h"
-#include "../blocks/TextBlock.h"
+#include "blocks/TextBlock.h"
 class Page;
 class GfxRenderer;
 #define MAX_WORD_SIZE 200
-class ChapterHtmlSlimParser {
+class EpubHtmlParserSlim {
  const char* filepath;
  GfxRenderer& renderer;
  std::function<void(std::unique_ptr<Page>)> completePageFn;
@ -35,7 +35,6 @@ class ChapterHtmlSlimParser {
  int marginRight;
  int marginBottom;
  int marginLeft;
  bool extraParagraphSpacing;
  void startNewTextBlock(TextBlock::BLOCK_STYLE style);
  void makePages();
@ -45,10 +44,10 @@ class ChapterHtmlSlimParser {
  static void XMLCALL endElement(void* userData, const XML_Char* name);
 public:
-  explicit ChapterHtmlSlimParser(const char* filepath, GfxRenderer& renderer, const int fontId,
+  explicit EpubHtmlParserSlim(const char* filepath, GfxRenderer& renderer, const int fontId,
-                                 const float lineCompression, const int marginTop, const int marginRight,
+                              const float lineCompression, const int marginTop, const int marginRight,
-                                 const int marginBottom, const int marginLeft, const bool extraParagraphSpacing,
+                              const int marginBottom, const int marginLeft,
-                                 const std::function<void(std::unique_ptr<Page>)>& completePageFn)
+                              const std::function<void(std::unique_ptr<Page>)>& completePageFn)
      : filepath(filepath),
        renderer(renderer),
        fontId(fontId),
@ -57,9 +56,7 @@ class ChapterHtmlSlimParser {
        marginRight(marginRight),
        marginBottom(marginBottom),
        marginLeft(marginLeft),
        extraParagraphSpacing(extraParagraphSpacing),
        completePageFn(completePageFn) {}
-  ~ChapterHtmlSlimParser() = default;
+  ~EpubHtmlParserSlim() = default;
  bool parseAndBuildPages();
  void addLineToPage(std::shared_ptr<TextBlock> line);
 };
--- a/lib/Epub/Epub/EpubTocEntry.h
+++ b/lib/Epub/Epub/EpubTocEntry.h
@ -1,13 +0,0 @@
 #pragma once
 #include <string>
 class EpubTocEntry {
 public:
  std::string title;
  std::string href;
  std::string anchor;
  int level;
  EpubTocEntry(std::string title, std::string href, std::string anchor, const int level)
      : title(std::move(title)), href(std::move(href)), anchor(std::move(anchor)), level(level) {}
 };
--- a/lib/Epub/Epub/Page.cpp
+++ b/lib/Epub/Epub/Page.cpp
@ -3,9 +3,7 @@
 #include <HardwareSerial.h>
 #include <Serialization.h>
 namespace {
 constexpr uint8_t PAGE_FILE_VERSION = 3;
 }
 void PageLine::render(GfxRenderer& renderer, const int fontId) { block->render(renderer, fontId, xPos, yPos); }
--- a/lib/Epub/Epub/ParsedText.cpp
+++ b/lib/Epub/Epub/ParsedText.cpp
@ -4,7 +4,6 @@
 #include <algorithm>
 #include <cmath>
 #include <functional>
 #include <limits>
 #include <vector>
@ -18,10 +17,10 @@ void ParsedText::addWord(std::string word, const EpdFontStyle fontStyle) {
 }
 // Consumes data to minimize memory usage
-void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId, const int horizontalMargin,
+std::list<std::shared_ptr<TextBlock>> ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fontId,
-                                       const std::function<void(std::shared_ptr<TextBlock>)>& processLine) {
+                                                                        const int horizontalMargin) {
  if (words.empty()) {
-    return;
+    return {};
  }
  const size_t totalWordCount = words.size();
@ -31,12 +30,6 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
  std::vector<uint16_t> wordWidths;
  wordWidths.reserve(totalWordCount);
  // add em-space at the beginning of first word in paragraph to indent
  if (!extraParagraphSpacing) {
    std::string& first_word = words.front();
    first_word.insert(0, "\xe2\x80\x83");
  }
  auto wordsIt = words.begin();
  auto wordStylesIt = wordStyles.begin();
@ -106,6 +99,8 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
    currentWordIndex = nextBreakIndex;
  }
  std::list<std::shared_ptr<TextBlock>> lines;
  // Initialize iterators for consumption
  auto wordStartIt = words.begin();
  auto wordStyleStartIt = wordStyles.begin();
@ -128,8 +123,7 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
    }
    // Calculate spacing
-    int spareSpace = pageWidth - lineWordWidthSum;
+    const int spareSpace = pageWidth - lineWordWidthSum;
    int spacing = spaceWidth;
    const bool isLastLine = lineBreak == totalWordCount;
@ -159,7 +153,7 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
    std::list<EpdFontStyle> lineWordStyles;
    lineWordStyles.splice(lineWordStyles.begin(), wordStyles, wordStyleStartIt, wordStyleEndIt);
-    processLine(
+    lines.push_back(
        std::make_shared<TextBlock>(std::move(lineWords), std::move(lineXPos), std::move(lineWordStyles), style));
    // Update pointers/indices for the next line
@ -168,4 +162,6 @@ void ParsedText::layoutAndExtractLines(const GfxRenderer& renderer, const int fo
    wordWidthIndex += lineWordCount;
    lastBreakAt = lineBreak;
  }
  return lines;
 }
--- a/lib/Epub/Epub/ParsedText.h
+++ b/lib/Epub/Epub/ParsedText.h
@ -3,7 +3,6 @@
 #include <EpdFontFamily.h>
 #include <cstdint>
 #include <functional>
 #include <list>
 #include <memory>
 #include <string>
@ -16,17 +15,15 @@ class ParsedText {
  std::list<std::string> words;
  std::list<EpdFontStyle> wordStyles;
  TextBlock::BLOCK_STYLE style;
  bool extraParagraphSpacing;
 public:
-  explicit ParsedText(const TextBlock::BLOCK_STYLE style, const bool extraParagraphSpacing)
+  explicit ParsedText(const TextBlock::BLOCK_STYLE style) : style(style) {}
      : style(style), extraParagraphSpacing(extraParagraphSpacing) {}
  ~ParsedText() = default;
  void addWord(std::string word, EpdFontStyle fontStyle);
  void setStyle(const TextBlock::BLOCK_STYLE style) { this->style = style; }
  TextBlock::BLOCK_STYLE getStyle() const { return style; }
  bool isEmpty() const { return words.empty(); }
-  void layoutAndExtractLines(const GfxRenderer& renderer, int fontId, int horizontalMargin,
+  std::list<std::shared_ptr<TextBlock>> layoutAndExtractLines(const GfxRenderer& renderer, int fontId,
-                             const std::function<void(std::shared_ptr<TextBlock>)>& processLine);
+                                                              int horizontalMargin);
 };
--- a/lib/Epub/Epub/Section.cpp
+++ b/lib/Epub/Epub/Section.cpp
@ -5,13 +5,11 @@
 #include <fstream>
 #include "EpubHtmlParserSlim.h"
 #include "FsHelpers.h"
 #include "Page.h"
 #include "parsers/ChapterHtmlSlimParser.h"
-namespace {
+constexpr uint8_t SECTION_FILE_VERSION = 4;
 constexpr uint8_t SECTION_FILE_VERSION = 5;
 }
 void Section::onPageComplete(std::unique_ptr<Page> page) {
  const auto filePath = cachePath + "/page_" + std::to_string(pageCount) + ".bin";
@ -26,8 +24,7 @@ void Section::onPageComplete(std::unique_ptr<Page> page) {
 }
 void Section::writeCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
-                                 const int marginRight, const int marginBottom, const int marginLeft,
+                                 const int marginRight, const int marginBottom, const int marginLeft) const {
                                 const bool extraParagraphSpacing) const {
  std::ofstream outputFile(("/sd" + cachePath + "/section.bin").c_str());
  serialization::writePod(outputFile, SECTION_FILE_VERSION);
  serialization::writePod(outputFile, fontId);
@ -36,14 +33,12 @@ void Section::writeCacheMetadata(const int fontId, const float lineCompression,
  serialization::writePod(outputFile, marginRight);
  serialization::writePod(outputFile, marginBottom);
  serialization::writePod(outputFile, marginLeft);
  serialization::writePod(outputFile, extraParagraphSpacing);
  serialization::writePod(outputFile, pageCount);
  outputFile.close();
 }
 bool Section::loadCacheMetadata(const int fontId, const float lineCompression, const int marginTop,
-                                const int marginRight, const int marginBottom, const int marginLeft,
+                                const int marginRight, const int marginBottom, const int marginLeft) {
                                const bool extraParagraphSpacing) {
  if (!SD.exists(cachePath.c_str())) {
    return false;
  }
@ -68,18 +63,15 @@ bool Section::loadCacheMetadata(const int fontId, const float lineCompression, c
    int fileFontId, fileMarginTop, fileMarginRight, fileMarginBottom, fileMarginLeft;
    float fileLineCompression;
    bool fileExtraParagraphSpacing;
    serialization::readPod(inputFile, fileFontId);
    serialization::readPod(inputFile, fileLineCompression);
    serialization::readPod(inputFile, fileMarginTop);
    serialization::readPod(inputFile, fileMarginRight);
    serialization::readPod(inputFile, fileMarginBottom);
    serialization::readPod(inputFile, fileMarginLeft);
    serialization::readPod(inputFile, fileExtraParagraphSpacing);
    if (fontId != fileFontId || lineCompression != fileLineCompression || marginTop != fileMarginTop ||
-        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft ||
+        marginRight != fileMarginRight || marginBottom != fileMarginBottom || marginLeft != fileMarginLeft) {
        extraParagraphSpacing != fileExtraParagraphSpacing) {
      inputFile.close();
      Serial.printf("[%lu] [SCT] Deserialization failed: Parameters do not match\n", millis());
      clearCache();
@ -115,8 +107,7 @@ bool Section::clearCache() const {
 }
 bool Section::persistPageDataToSD(const int fontId, const float lineCompression, const int marginTop,
-                                  const int marginRight, const int marginBottom, const int marginLeft,
+                                  const int marginRight, const int marginBottom, const int marginLeft) {
                                  const bool extraParagraphSpacing) {
  const auto localPath = epub->getSpineItem(spineIndex);
  // TODO: Should we get rid of this file all together?
@ -136,9 +127,9 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
  const auto sdTmpHtmlPath = "/sd" + tmpHtmlPath;
-  ChapterHtmlSlimParser visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
+  EpubHtmlParserSlim visitor(sdTmpHtmlPath.c_str(), renderer, fontId, lineCompression, marginTop, marginRight,
-                                marginBottom, marginLeft, extraParagraphSpacing,
+                             marginBottom, marginLeft,
-                                [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
+                             [this](std::unique_ptr<Page> page) { this->onPageComplete(std::move(page)); });
  success = visitor.parseAndBuildPages();
  SD.remove(tmpHtmlPath.c_str());
@ -147,7 +138,7 @@ bool Section::persistPageDataToSD(const int fontId, const float lineCompression,
    return false;
  }
-  writeCacheMetadata(fontId, lineCompression, marginTop, marginRight, marginBottom, marginLeft, extraParagraphSpacing);
+  writeCacheMetadata(fontId, lineCompression, marginTop, marginRight, marginBottom, marginLeft);
  return true;
 }
--- a/lib/Epub/Epub/Section.h
+++ b/lib/Epub/Epub/Section.h
@ -13,7 +13,7 @@ class Section {
  std::string cachePath;
  void writeCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                          int marginLeft, bool extraParagraphSpacing) const;
+                          int marginLeft) const;
  void onPageComplete(std::unique_ptr<Page> page);
 public:
@ -26,10 +26,10 @@ class Section {
  }
  ~Section() = default;
  bool loadCacheMetadata(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                         int marginLeft, bool extraParagraphSpacing);
+                         int marginLeft);
  void setupCacheDir() const;
  bool clearCache() const;
  bool persistPageDataToSD(int fontId, float lineCompression, int marginTop, int marginRight, int marginBottom,
-                           int marginLeft, bool extraParagraphSpacing);
+                           int marginLeft);
  std::unique_ptr<Page> loadPageFromSD() const;
 };
--- a/lib/Epub/Epub/parsers/ContainerParser.cpp
+++ b/lib/Epub/Epub/parsers/ContainerParser.cpp
@ -1,96 +0,0 @@
 #include "ContainerParser.h"
 #include <HardwareSerial.h>
 bool ContainerParser::setup() {
  parser = XML_ParserCreate(nullptr);
  if (!parser) {
    Serial.printf("[%lu] [CTR] Couldn't allocate memory for parser\n", millis());
    return false;
  }
  XML_SetUserData(parser, this);
  XML_SetElementHandler(parser, startElement, endElement);
  return true;
 }
 bool ContainerParser::teardown() {
  if (parser) {
    XML_ParserFree(parser);
    parser = nullptr;
  }
  return true;
 }
 size_t ContainerParser::write(const uint8_t data) { return write(&data, 1); }
 size_t ContainerParser::write(const uint8_t* buffer, const size_t size) {
  if (!parser) return 0;
  const uint8_t* currentBufferPos = buffer;
  auto remainingInBuffer = size;
  while (remainingInBuffer > 0) {
    void* const buf = XML_GetBuffer(parser, 1024);
    if (!buf) {
      Serial.printf("[%lu] [CTR] Couldn't allocate buffer\n", millis());
      return 0;
    }
    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
    memcpy(buf, currentBufferPos, toRead);
    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
      Serial.printf("[%lu] [CTR] Parse error: %s\n", millis(), XML_ErrorString(XML_GetErrorCode(parser)));
      return 0;
    }
    currentBufferPos += toRead;
    remainingInBuffer -= toRead;
    remainingSize -= toRead;
  }
  return size;
 }
 void XMLCALL ContainerParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
  auto* self = static_cast<ContainerParser*>(userData);
  // Simple state tracking to ensure we are looking at the valid schema structure
  if (self->state == START && strcmp(name, "container") == 0) {
    self->state = IN_CONTAINER;
    return;
  }
  if (self->state == IN_CONTAINER && strcmp(name, "rootfiles") == 0) {
    self->state = IN_ROOTFILES;
    return;
  }
  if (self->state == IN_ROOTFILES && strcmp(name, "rootfile") == 0) {
    const char* mediaType = nullptr;
    const char* path = nullptr;
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "media-type") == 0) {
        mediaType = atts[i + 1];
      } else if (strcmp(atts[i], "full-path") == 0) {
        path = atts[i + 1];
      }
    }
    // Check if this is the standard OEBPS package
    if (mediaType && path && strcmp(mediaType, "application/oebps-package+xml") == 0) {
      self->fullPath = path;
    }
  }
 }
 void XMLCALL ContainerParser::endElement(void* userData, const XML_Char* name) {
  auto* self = static_cast<ContainerParser*>(userData);
  if (self->state == IN_ROOTFILES && strcmp(name, "rootfiles") == 0) {
    self->state = IN_CONTAINER;
  } else if (self->state == IN_CONTAINER && strcmp(name, "container") == 0) {
    self->state = START;
  }
 }
--- a/lib/Epub/Epub/parsers/ContainerParser.h
+++ b/lib/Epub/Epub/parsers/ContainerParser.h
@ -1,32 +0,0 @@
 #pragma once
 #include <Print.h>
 #include <string>
 #include "expat.h"
 class ContainerParser final : public Print {
  enum ParserState {
    START,
    IN_CONTAINER,
    IN_ROOTFILES,
  };
  size_t remainingSize;
  XML_Parser parser = nullptr;
  ParserState state = START;
  static void startElement(void* userData, const XML_Char* name, const XML_Char** atts);
  static void endElement(void* userData, const XML_Char* name);
 public:
  std::string fullPath;
  explicit ContainerParser(const size_t xmlSize) : remainingSize(xmlSize) {}
  bool setup();
  bool teardown();
  size_t write(uint8_t) override;
  size_t write(const uint8_t* buffer, size_t size) override;
 };
--- a/lib/Epub/Epub/parsers/ContentOpfParser.cpp
+++ b/lib/Epub/Epub/parsers/ContentOpfParser.cpp
@ -1,191 +0,0 @@
 #include "ContentOpfParser.h"
 #include <HardwareSerial.h>
 #include <ZipFile.h>
 namespace {
 constexpr const char MEDIA_TYPE_NCX[] = "application/x-dtbncx+xml";
 }
 bool ContentOpfParser::setup() {
  parser = XML_ParserCreate(nullptr);
  if (!parser) {
    Serial.printf("[%lu] [COF] Couldn't allocate memory for parser\n", millis());
    return false;
  }
  XML_SetUserData(parser, this);
  XML_SetElementHandler(parser, startElement, endElement);
  XML_SetCharacterDataHandler(parser, characterData);
  return true;
 }
 bool ContentOpfParser::teardown() {
  if (parser) {
    XML_ParserFree(parser);
    parser = nullptr;
  }
  return true;
 }
 size_t ContentOpfParser::write(const uint8_t data) { return write(&data, 1); }
 size_t ContentOpfParser::write(const uint8_t* buffer, const size_t size) {
  if (!parser) return 0;
  const uint8_t* currentBufferPos = buffer;
  auto remainingInBuffer = size;
  while (remainingInBuffer > 0) {
    void* const buf = XML_GetBuffer(parser, 1024);
    if (!buf) {
      Serial.printf("[%lu] [COF] Couldn't allocate memory for buffer\n", millis());
      XML_ParserFree(parser);
      parser = nullptr;
      return 0;
    }
    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
    memcpy(buf, currentBufferPos, toRead);
    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
      Serial.printf("[%lu] [COF] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
                    XML_ErrorString(XML_GetErrorCode(parser)));
      XML_ParserFree(parser);
      parser = nullptr;
      return 0;
    }
    currentBufferPos += toRead;
    remainingInBuffer -= toRead;
    remainingSize -= toRead;
  }
  return size;
 }
 void XMLCALL ContentOpfParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
  auto* self = static_cast<ContentOpfParser*>(userData);
  (void)atts;
  if (self->state == START && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
    self->state = IN_PACKAGE;
    return;
  }
  if (self->state == IN_PACKAGE && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
    self->state = IN_METADATA;
    return;
  }
  if (self->state == IN_METADATA && strcmp(name, "dc:title") == 0) {
    self->state = IN_BOOK_TITLE;
    return;
  }
  if (self->state == IN_PACKAGE && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
    self->state = IN_MANIFEST;
    return;
  }
  if (self->state == IN_PACKAGE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
    self->state = IN_SPINE;
    return;
  }
  if (self->state == IN_METADATA && (strcmp(name, "meta") == 0 || strcmp(name, "opf:meta") == 0)) {
    bool isCover = false;
    std::string coverItemId;
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "name") == 0 && strcmp(atts[i + 1], "cover") == 0) {
        isCover = true;
      } else if (strcmp(atts[i], "content") == 0) {
        coverItemId = atts[i + 1];
      }
    }
    if (isCover) {
      self->coverItemId = coverItemId;
    }
    return;
  }
  if (self->state == IN_MANIFEST && (strcmp(name, "item") == 0 || strcmp(name, "opf:item") == 0)) {
    std::string itemId;
    std::string href;
    std::string mediaType;
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "id") == 0) {
        itemId = atts[i + 1];
      } else if (strcmp(atts[i], "href") == 0) {
        href = self->baseContentPath + atts[i + 1];
      } else if (strcmp(atts[i], "media-type") == 0) {
        mediaType = atts[i + 1];
      }
    }
    self->items[itemId] = href;
    if (mediaType == MEDIA_TYPE_NCX) {
      if (self->tocNcxPath.empty()) {
        self->tocNcxPath = href;
      } else {
        Serial.printf("[%lu] [COF] Warning: Multiple NCX files found in manifest. Ignoring duplicate: %s\n", millis(),
                      href.c_str());
      }
    }
    return;
  }
  if (self->state == IN_SPINE && (strcmp(name, "itemref") == 0 || strcmp(name, "opf:itemref") == 0)) {
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "idref") == 0) {
        self->spineRefs.emplace_back(atts[i + 1]);
        break;
      }
    }
    return;
  }
 }
 void XMLCALL ContentOpfParser::characterData(void* userData, const XML_Char* s, const int len) {
  auto* self = static_cast<ContentOpfParser*>(userData);
  if (self->state == IN_BOOK_TITLE) {
    self->title.append(s, len);
    return;
  }
 }
 void XMLCALL ContentOpfParser::endElement(void* userData, const XML_Char* name) {
  auto* self = static_cast<ContentOpfParser*>(userData);
  (void)name;
  if (self->state == IN_SPINE && (strcmp(name, "spine") == 0 || strcmp(name, "opf:spine") == 0)) {
    self->state = IN_PACKAGE;
    return;
  }
  if (self->state == IN_MANIFEST && (strcmp(name, "manifest") == 0 || strcmp(name, "opf:manifest") == 0)) {
    self->state = IN_PACKAGE;
    return;
  }
  if (self->state == IN_BOOK_TITLE && strcmp(name, "dc:title") == 0) {
    self->state = IN_METADATA;
    return;
  }
  if (self->state == IN_METADATA && (strcmp(name, "metadata") == 0 || strcmp(name, "opf:metadata") == 0)) {
    self->state = IN_PACKAGE;
    return;
  }
  if (self->state == IN_PACKAGE && (strcmp(name, "package") == 0 || strcmp(name, "opf:package") == 0)) {
    self->state = START;
    return;
  }
 }
--- a/lib/Epub/Epub/parsers/ContentOpfParser.h
+++ b/lib/Epub/Epub/parsers/ContentOpfParser.h
@ -1,43 +0,0 @@
 #pragma once
 #include <Print.h>
 #include <map>
 #include "Epub.h"
 #include "expat.h"
 class ContentOpfParser final : public Print {
  enum ParserState {
    START,
    IN_PACKAGE,
    IN_METADATA,
    IN_BOOK_TITLE,
    IN_MANIFEST,
    IN_SPINE,
  };
  const std::string& baseContentPath;
  size_t remainingSize;
  XML_Parser parser = nullptr;
  ParserState state = START;
  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);
 public:
  std::string title;
  std::string tocNcxPath;
  std::string coverItemId;
  std::map<std::string, std::string> items;
  std::vector<std::string> spineRefs;
  explicit ContentOpfParser(const std::string& baseContentPath, const size_t xmlSize)
      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
  bool setup();
  bool teardown();
  size_t write(uint8_t) override;
  size_t write(const uint8_t* buffer, size_t size) override;
 };
--- a/lib/Epub/Epub/parsers/TocNcxParser.cpp
+++ b/lib/Epub/Epub/parsers/TocNcxParser.cpp
@ -1,165 +0,0 @@
 #include "TocNcxParser.h"
 #include <HardwareSerial.h>
 bool TocNcxParser::setup() {
  parser = XML_ParserCreate(nullptr);
  if (!parser) {
    Serial.printf("[%lu] [TOC] Couldn't allocate memory for parser\n", millis());
    return false;
  }
  XML_SetUserData(parser, this);
  XML_SetElementHandler(parser, startElement, endElement);
  XML_SetCharacterDataHandler(parser, characterData);
  return true;
 }
 bool TocNcxParser::teardown() {
  if (parser) {
    XML_ParserFree(parser);
    parser = nullptr;
  }
  return true;
 }
 size_t TocNcxParser::write(const uint8_t data) { return write(&data, 1); }
 size_t TocNcxParser::write(const uint8_t* buffer, const size_t size) {
  if (!parser) return 0;
  const uint8_t* currentBufferPos = buffer;
  auto remainingInBuffer = size;
  while (remainingInBuffer > 0) {
    void* const buf = XML_GetBuffer(parser, 1024);
    if (!buf) {
      Serial.printf("[%lu] [TOC] Couldn't allocate memory for buffer\n", millis());
      return 0;
    }
    const auto toRead = remainingInBuffer < 1024 ? remainingInBuffer : 1024;
    memcpy(buf, currentBufferPos, toRead);
    if (XML_ParseBuffer(parser, static_cast<int>(toRead), remainingSize == toRead) == XML_STATUS_ERROR) {
      Serial.printf("[%lu] [TOC] Parse error at line %lu: %s\n", millis(), XML_GetCurrentLineNumber(parser),
                    XML_ErrorString(XML_GetErrorCode(parser)));
      return 0;
    }
    currentBufferPos += toRead;
    remainingInBuffer -= toRead;
    remainingSize -= toRead;
  }
  return size;
 }
 void XMLCALL TocNcxParser::startElement(void* userData, const XML_Char* name, const XML_Char** atts) {
  // NOTE: We rely on navPoint label and content coming before any nested navPoints, this will be fine:
  // <navPoint>
  //   <navLabel><text>Chapter 1</text></navLabel>
  //   <content src="ch1.html"/>
  //   <navPoint> ...nested... </navPoint>
  // </navPoint>
  //
  // This will NOT:
  // <navPoint>
  //   <navPoint> ...nested... </navPoint>
  //   <navLabel><text>Chapter 1</text></navLabel>
  //   <content src="ch1.html"/>
  // </navPoint>
  auto* self = static_cast<TocNcxParser*>(userData);
  if (self->state == START && strcmp(name, "ncx") == 0) {
    self->state = IN_NCX;
    return;
  }
  if (self->state == IN_NCX && strcmp(name, "navMap") == 0) {
    self->state = IN_NAV_MAP;
    return;
  }
  // Handles both top-level and nested navPoints
  if ((self->state == IN_NAV_MAP || self->state == IN_NAV_POINT) && strcmp(name, "navPoint") == 0) {
    self->state = IN_NAV_POINT;
    self->currentDepth++;
    self->currentLabel.clear();
    self->currentSrc.clear();
    return;
  }
  if (self->state == IN_NAV_POINT && strcmp(name, "navLabel") == 0) {
    self->state = IN_NAV_LABEL;
    return;
  }
  if (self->state == IN_NAV_LABEL && strcmp(name, "text") == 0) {
    self->state = IN_NAV_LABEL_TEXT;
    return;
  }
  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
    for (int i = 0; atts[i]; i += 2) {
      if (strcmp(atts[i], "src") == 0) {
        self->currentSrc = atts[i + 1];
        break;
      }
    }
    return;
  }
 }
 void XMLCALL TocNcxParser::characterData(void* userData, const XML_Char* s, const int len) {
  auto* self = static_cast<TocNcxParser*>(userData);
  if (self->state == IN_NAV_LABEL_TEXT) {
    self->currentLabel.append(s, len);
  }
 }
 void XMLCALL TocNcxParser::endElement(void* userData, const XML_Char* name) {
  auto* self = static_cast<TocNcxParser*>(userData);
  if (self->state == IN_NAV_LABEL_TEXT && strcmp(name, "text") == 0) {
    self->state = IN_NAV_LABEL;
    return;
  }
  if (self->state == IN_NAV_LABEL && strcmp(name, "navLabel") == 0) {
    self->state = IN_NAV_POINT;
    return;
  }
  if (self->state == IN_NAV_POINT && strcmp(name, "navPoint") == 0) {
    self->currentDepth--;
    if (self->currentDepth == 0) {
      self->state = IN_NAV_MAP;
    }
    return;
  }
  if (self->state == IN_NAV_POINT && strcmp(name, "content") == 0) {
    // At this point (end of content tag), we likely have both Label (from previous tags) and Src.
    // This is the safest place to push the data, assuming <navLabel> always comes before <content>.
    // NCX spec says navLabel comes before content.
    if (!self->currentLabel.empty() && !self->currentSrc.empty()) {
      std::string href = self->baseContentPath + self->currentSrc;
      std::string anchor;
      const size_t pos = href.find('#');
      if (pos != std::string::npos) {
        anchor = href.substr(pos + 1);
        href = href.substr(0, pos);
      }
      // Push to vector
      self->toc.emplace_back(self->currentLabel, href, anchor, self->currentDepth);
      // Clear them so we don't re-add them if there are weird XML structures
      self->currentLabel.clear();
      self->currentSrc.clear();
    }
  }
 }
--- a/lib/Epub/Epub/parsers/TocNcxParser.h
+++ b/lib/Epub/Epub/parsers/TocNcxParser.h
@ -1,37 +0,0 @@
 #pragma once
 #include <Print.h>
 #include <string>
 #include <vector>
 #include "Epub/EpubTocEntry.h"
 #include "expat.h"
 class TocNcxParser final : public Print {
  enum ParserState { START, IN_NCX, IN_NAV_MAP, IN_NAV_POINT, IN_NAV_LABEL, IN_NAV_LABEL_TEXT, IN_CONTENT };
  const std::string& baseContentPath;
  size_t remainingSize;
  XML_Parser parser = nullptr;
  ParserState state = START;
  std::string currentLabel;
  std::string currentSrc;
  size_t currentDepth = 0;
  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);
 public:
  std::vector<EpubTocEntry> toc;
  explicit TocNcxParser(const std::string& baseContentPath, const size_t xmlSize)
      : baseContentPath(baseContentPath), remainingSize(xmlSize) {}
  bool setup();
  bool teardown();
  size_t write(uint8_t) override;
  size_t write(const uint8_t* buffer, size_t size) override;
 };
--- a/lib/GfxRenderer/Bitmap.cpp
+++ b/lib/GfxRenderer/Bitmap.cpp
@ -1,189 +0,0 @@
 #include "Bitmap.h"
 #include <cstdlib>
 #include <cstring>
 uint16_t Bitmap::readLE16(File& f) {
  const int c0 = f.read();
  const int c1 = f.read();
  const auto b0 = static_cast<uint8_t>(c0 < 0 ? 0 : c0);
  const auto b1 = static_cast<uint8_t>(c1 < 0 ? 0 : c1);
  return static_cast<uint16_t>(b0) | (static_cast<uint16_t>(b1) << 8);
 }
 uint32_t Bitmap::readLE32(File& f) {
  const int c0 = f.read();
  const int c1 = f.read();
  const int c2 = f.read();
  const int c3 = f.read();
  const auto b0 = static_cast<uint8_t>(c0 < 0 ? 0 : c0);
  const auto b1 = static_cast<uint8_t>(c1 < 0 ? 0 : c1);
  const auto b2 = static_cast<uint8_t>(c2 < 0 ? 0 : c2);
  const auto b3 = static_cast<uint8_t>(c3 < 0 ? 0 : c3);
  return static_cast<uint32_t>(b0) | (static_cast<uint32_t>(b1) << 8) | (static_cast<uint32_t>(b2) << 16) |
         (static_cast<uint32_t>(b3) << 24);
 }
 const char* Bitmap::errorToString(BmpReaderError err) {
  switch (err) {
    case BmpReaderError::Ok:
      return "Ok";
    case BmpReaderError::FileInvalid:
      return "FileInvalid";
    case BmpReaderError::SeekStartFailed:
      return "SeekStartFailed";
    case BmpReaderError::NotBMP:
      return "NotBMP (missing 'BM')";
    case BmpReaderError::DIBTooSmall:
      return "DIBTooSmall (<40 bytes)";
    case BmpReaderError::BadPlanes:
      return "BadPlanes (!= 1)";
    case BmpReaderError::UnsupportedBpp:
      return "UnsupportedBpp (expected 1, 2, 8, 24, or 32)";
    case BmpReaderError::UnsupportedCompression:
      return "UnsupportedCompression (expected BI_RGB or BI_BITFIELDS for 32bpp)";
    case BmpReaderError::BadDimensions:
      return "BadDimensions";
    case BmpReaderError::PaletteTooLarge:
      return "PaletteTooLarge";
    case BmpReaderError::SeekPixelDataFailed:
      return "SeekPixelDataFailed";
    case BmpReaderError::BufferTooSmall:
      return "BufferTooSmall";
    case BmpReaderError::OomRowBuffer:
      return "OomRowBuffer";
    case BmpReaderError::ShortReadRow:
      return "ShortReadRow";
  }
  return "Unknown";
 }
 BmpReaderError Bitmap::parseHeaders() {
  if (!file) return BmpReaderError::FileInvalid;
  if (!file.seek(0)) return BmpReaderError::SeekStartFailed;
  // --- BMP FILE HEADER ---
  const uint16_t bfType = readLE16(file);
  if (bfType != 0x4D42) return BmpReaderError::NotBMP;
  file.seek(8, SeekCur);
  bfOffBits = readLE32(file);
  // --- DIB HEADER ---
  const uint32_t biSize = readLE32(file);
  if (biSize < 40) return BmpReaderError::DIBTooSmall;
  width = static_cast<int32_t>(readLE32(file));
  const auto rawHeight = static_cast<int32_t>(readLE32(file));
  topDown = rawHeight < 0;
  height = topDown ? -rawHeight : rawHeight;
  const uint16_t planes = readLE16(file);
  bpp = readLE16(file);
  const uint32_t comp = readLE32(file);
  const bool validBpp = bpp == 1 || bpp == 2 || bpp == 8 || bpp == 24 || bpp == 32;
  if (planes != 1) return BmpReaderError::BadPlanes;
  if (!validBpp) return BmpReaderError::UnsupportedBpp;
  // Allow BI_RGB (0) for all, and BI_BITFIELDS (3) for 32bpp which is common for BGRA masks.
  if (!(comp == 0 || (bpp == 32 && comp == 3))) return BmpReaderError::UnsupportedCompression;
  file.seek(12, SeekCur);  // biSizeImage, biXPelsPerMeter, biYPelsPerMeter
  const uint32_t colorsUsed = readLE32(file);
  if (colorsUsed > 256u) return BmpReaderError::PaletteTooLarge;
  file.seek(4, SeekCur);  // biClrImportant
  if (width <= 0 || height <= 0) return BmpReaderError::BadDimensions;
  // Pre-calculate Row Bytes to avoid doing this every row
  rowBytes = (width * bpp + 31) / 32 * 4;
  for (int i = 0; i < 256; i++) paletteLum[i] = static_cast<uint8_t>(i);
  if (colorsUsed > 0) {
    for (uint32_t i = 0; i < colorsUsed; i++) {
      uint8_t rgb[4];
      file.read(rgb, 4);  // Read B, G, R, Reserved in one go
      paletteLum[i] = (77u * rgb[2] + 150u * rgb[1] + 29u * rgb[0]) >> 8;
    }
  }
  if (!file.seek(bfOffBits)) {
    return BmpReaderError::SeekPixelDataFailed;
  }
  return BmpReaderError::Ok;
 }
 // packed 2bpp output, 0 = black, 1 = dark gray, 2 = light gray, 3 = white
 BmpReaderError Bitmap::readRow(uint8_t* data, uint8_t* rowBuffer) const {
  // Note: rowBuffer should be pre-allocated by the caller to size 'rowBytes'
  if (file.read(rowBuffer, rowBytes) != rowBytes) return BmpReaderError::ShortReadRow;
  uint8_t* outPtr = data;
  uint8_t currentOutByte = 0;
  int bitShift = 6;
  // Helper lambda to pack 2bpp color into the output stream
  auto packPixel = [&](uint8_t lum) {
    uint8_t color = (lum >> 6);  // Simple 2-bit reduction: 0-255 -> 0-3
    currentOutByte |= (color << bitShift);
    if (bitShift == 0) {
      *outPtr++ = currentOutByte;
      currentOutByte = 0;
      bitShift = 6;
    } else {
      bitShift -= 2;
    }
  };
  switch (bpp) {
    case 8: {
      for (int x = 0; x < width; x++) {
        packPixel(paletteLum[rowBuffer[x]]);
      }
      break;
    }
    case 24: {
      const uint8_t* p = rowBuffer;
      for (int x = 0; x < width; x++) {
        uint8_t lum = (77u * p[2] + 150u * p[1] + 29u * p[0]) >> 8;
        packPixel(lum);
        p += 3;
      }
      break;
    }
    case 1: {
      for (int x = 0; x < width; x++) {
        uint8_t lum = (rowBuffer[x >> 3] & (0x80 >> (x & 7))) ? 0xFF : 0x00;
        packPixel(lum);
      }
      break;
    }
    case 32: {
      const uint8_t* p = rowBuffer;
      for (int x = 0; x < width; x++) {
        uint8_t lum = (77u * p[2] + 150u * p[1] + 29u * p[0]) >> 8;
        packPixel(lum);
        p += 4;
      }
      break;
    }
  }
  // Flush remaining bits if width is not a multiple of 4
  if (bitShift != 6) *outPtr = currentOutByte;
  return BmpReaderError::Ok;
 }
 BmpReaderError Bitmap::rewindToData() const {
  if (!file.seek(bfOffBits)) {
    return BmpReaderError::SeekPixelDataFailed;
  }
  return BmpReaderError::Ok;
 }
--- a/lib/GfxRenderer/Bitmap.h
+++ b/lib/GfxRenderer/Bitmap.h
@ -1,52 +0,0 @@
 #pragma once
 #include <FS.h>
 enum class BmpReaderError : uint8_t {
  Ok = 0,
  FileInvalid,
  SeekStartFailed,
  NotBMP,
  DIBTooSmall,
  BadPlanes,
  UnsupportedBpp,
  UnsupportedCompression,
  BadDimensions,
  PaletteTooLarge,
  SeekPixelDataFailed,
  BufferTooSmall,
  OomRowBuffer,
  ShortReadRow,
 };
 class Bitmap {
 public:
  static const char* errorToString(BmpReaderError err);
  explicit Bitmap(File& file) : file(file) {}
  BmpReaderError parseHeaders();
  BmpReaderError readRow(uint8_t* data, uint8_t* rowBuffer) const;
  BmpReaderError rewindToData() const;
  int getWidth() const { return width; }
  int getHeight() const { return height; }
  bool isTopDown() const { return topDown; }
  bool hasGreyscale() const { return bpp > 1; }
  int getRowBytes() const { return rowBytes; }
 private:
  static uint16_t readLE16(File& f);
  static uint32_t readLE32(File& f);
  File& file;
  int width = 0;
  int height = 0;
  bool topDown = false;
  uint32_t bfOffBits = 0;
  uint16_t bpp = 0;
  int rowBytes = 0;
  uint8_t paletteLum[256] = {};
 };
--- a/lib/GfxRenderer/GfxRenderer.cpp
+++ b/lib/GfxRenderer/GfxRenderer.cpp
@ -119,66 +119,6 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co
  einkDisplay.drawImage(bitmap, y, x, height, width);
 }
 void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth,
                             const int maxHeight) const {
  float scale = 1.0f;
  bool isScaled = false;
  if (maxWidth > 0 && bitmap.getWidth() > maxWidth) {
    scale = static_cast<float>(maxWidth) / static_cast<float>(bitmap.getWidth());
    isScaled = true;
  }
  if (maxHeight > 0 && bitmap.getHeight() > maxHeight) {
    scale = std::min(scale, static_cast<float>(maxHeight) / static_cast<float>(bitmap.getHeight()));
    isScaled = true;
  }
  const uint8_t outputRowSize = (bitmap.getWidth() + 3) / 4;
  auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize));
  auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
  for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) {
    // The BMP's (0, 0) is the bottom-left corner (if the height is positive, top-left if negative).
    // Screen's (0, 0) is the top-left corner.
    int screenY = y + (bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY);
    if (isScaled) {
      screenY = std::floor(screenY * scale);
    }
    if (screenY >= getScreenHeight()) {
      break;
    }
    if (bitmap.readRow(outputRow, rowBytes) != BmpReaderError::Ok) {
      Serial.printf("[%lu] [GFX] Failed to read row %d from bitmap\n", millis(), bmpY);
      free(outputRow);
      free(rowBytes);
      return;
    }
    for (int bmpX = 0; bmpX < bitmap.getWidth(); bmpX++) {
      int screenX = x + bmpX;
      if (isScaled) {
        screenX = std::floor(screenX * scale);
      }
      if (screenX >= getScreenWidth()) {
        break;
      }
      const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
      if (renderMode == BW && val < 3) {
        drawPixel(screenX, screenY);
      } else if (renderMode == GRAYSCALE_MSB && (val == 1 || val == 2)) {
        drawPixel(screenX, screenY, false);
      } else if (renderMode == GRAYSCALE_LSB && val == 1) {
        drawPixel(screenX, screenY, false);
      }
    }
  }
  free(outputRow);
  free(rowBytes);
 }
 void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }
 void GfxRenderer::invertScreen() const {
@ -192,19 +132,13 @@ void GfxRenderer::displayBuffer(const EInkDisplay::RefreshMode refreshMode) cons
  einkDisplay.displayBuffer(refreshMode);
 }
-void GfxRenderer::displayWindow(const int x, const int y, const int width, const int height) const {
+// TODO: Support partial window update
-  // Rotate coordinates from portrait (480x800) to landscape (800x480)
+// void GfxRenderer::flushArea(const int x, const int y, const int width, const int height) const {
-  // Rotation: 90 degrees clockwise
+//   const int rotatedX = y;
-  // Portrait coordinates: (x, y) with dimensions (width, height)
+//   const int rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x;
-  // Landscape coordinates: (rotatedX, rotatedY) with dimensions (rotatedWidth, rotatedHeight)
+//
-
+//   einkDisplay.displayBuffer(EInkDisplay::FAST_REFRESH, rotatedX, rotatedY, height, width);
-  const int rotatedX = y;
+// }
  const int rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x - width + 1;
  const int rotatedWidth = height;
  const int rotatedHeight = width;
  einkDisplay.displayWindow(rotatedX, rotatedY, rotatedWidth, rotatedHeight);
 }
 // Note: Internal driver treats screen in command orientation, this library treats in portrait orientation
 int GfxRenderer::getScreenWidth() { return EInkDisplay::DISPLAY_HEIGHT; }
@ -228,9 +162,11 @@ int GfxRenderer::getLineHeight(const int fontId) const {
  return fontMap.at(fontId).getData(REGULAR)->advanceY;
 }
-uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
+uint8_t *GfxRenderer::getFrameBuffer() const {
  return einkDisplay.getFrameBuffer();
 }
-size_t GfxRenderer::getBufferSize() { return EInkDisplay::BUFFER_SIZE; }
+void GfxRenderer::swapBuffers() const { einkDisplay.swapBuffers(); }
 void GfxRenderer::grayscaleRevert() const { einkDisplay.grayscaleRevert(); }
@ -240,90 +176,6 @@ void GfxRenderer::copyGrayscaleMsbBuffers() const { einkDisplay.copyGrayscaleMsb
 void GfxRenderer::displayGrayBuffer() const { einkDisplay.displayGrayBuffer(); }
 void GfxRenderer::freeBwBufferChunks() {
  for (auto& bwBufferChunk : bwBufferChunks) {
    if (bwBufferChunk) {
      free(bwBufferChunk);
      bwBufferChunk = nullptr;
    }
  }
 }
 /**
 * This should be called before grayscale buffers are populated.
 * A `restoreBwBuffer` call should always follow the grayscale render if this method was called.
 * Uses chunked allocation to avoid needing 48KB of contiguous memory.
 */
 void GfxRenderer::storeBwBuffer() {
  const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  // Allocate and copy each chunk
  for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
    // Check if any chunks are already allocated
    if (bwBufferChunks[i]) {
      Serial.printf("[%lu] [GFX] !! BW buffer chunk %zu already stored - this is likely a bug, freeing chunk\n",
                    millis(), i);
      free(bwBufferChunks[i]);
      bwBufferChunks[i] = nullptr;
    }
    const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
    bwBufferChunks[i] = static_cast<uint8_t*>(malloc(BW_BUFFER_CHUNK_SIZE));
    if (!bwBufferChunks[i]) {
      Serial.printf("[%lu] [GFX] !! Failed to allocate BW buffer chunk %zu (%zu bytes)\n", millis(), i,
                    BW_BUFFER_CHUNK_SIZE);
      // Free previously allocated chunks
      freeBwBufferChunks();
      return;
    }
    memcpy(bwBufferChunks[i], frameBuffer + offset, BW_BUFFER_CHUNK_SIZE);
  }
  Serial.printf("[%lu] [GFX] Stored BW buffer in %zu chunks (%zu bytes each)\n", millis(), BW_BUFFER_NUM_CHUNKS,
                BW_BUFFER_CHUNK_SIZE);
 }
 /**
 * This can only be called if `storeBwBuffer` was called prior to the grayscale render.
 * It should be called to restore the BW buffer state after grayscale rendering is complete.
 * Uses chunked restoration to match chunked storage.
 */
 void GfxRenderer::restoreBwBuffer() {
  // Check if any all chunks are allocated
  bool missingChunks = false;
  for (const auto& bwBufferChunk : bwBufferChunks) {
    if (!bwBufferChunk) {
      missingChunks = true;
      break;
    }
  }
  if (missingChunks) {
    freeBwBufferChunks();
    return;
  }
  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
  for (size_t i = 0; i < BW_BUFFER_NUM_CHUNKS; i++) {
    // Check if chunk is missing
    if (!bwBufferChunks[i]) {
      Serial.printf("[%lu] [GFX] !! BW buffer chunks not stored - this is likely a bug\n", millis());
      freeBwBufferChunks();
      return;
    }
    const size_t offset = i * BW_BUFFER_CHUNK_SIZE;
    memcpy(frameBuffer + offset, bwBufferChunks[i], BW_BUFFER_CHUNK_SIZE);
  }
  einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
  freeBwBufferChunks();
  Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
 }
 void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp, int* x, const int* y,
                             const bool pixelState, const EpdFontStyle style) const {
  const EpdGlyph* glyph = fontFamily.getGlyph(cp, style);
@ -357,20 +209,14 @@ void GfxRenderer::renderChar(const EpdFontFamily& fontFamily, const uint32_t cp,
        if (is2Bit) {
          const uint8_t byte = bitmap[pixelPosition / 4];
          const uint8_t bit_index = (3 - pixelPosition % 4) * 2;
          // the direct bit from the font is 0 -> white, 1 -> light gray, 2 -> dark gray, 3 -> black
          // we swap this to better match the way images and screen think about colors:
          // 0 -> black, 1 -> dark grey, 2 -> light grey, 3 -> white
          const uint8_t bmpVal = 3 - (byte >> bit_index) & 0x3;
-          if (renderMode == BW && bmpVal < 3) {
+          const uint8_t val = (byte >> bit_index) & 0x3;
-            // Black (also paints over the grays in BW mode)
+          if (fontRenderMode == BW && val > 0) {
            drawPixel(screenX, screenY, pixelState);
-          } else if (renderMode == GRAYSCALE_MSB && (bmpVal == 1 || bmpVal == 2)) {
+          } else if (fontRenderMode == GRAYSCALE_MSB && val == 1) {
-            // Light gray (also mark the MSB if it's going to be a dark gray too)
+            // TODO: Not sure how this anti-aliasing goes on black backgrounds
            // We have to flag pixels in reverse for the gray buffers, as 0 leave alone, 1 update
            drawPixel(screenX, screenY, false);
-          } else if (renderMode == GRAYSCALE_LSB && bmpVal == 1) {
+          } else if (fontRenderMode == GRAYSCALE_LSB && val == 2) {
            // Dark gray
            drawPixel(screenX, screenY, false);
          }
        } else {
--- a/lib/GfxRenderer/GfxRenderer.h
+++ b/lib/GfxRenderer/GfxRenderer.h
@ -2,32 +2,22 @@
 #include <EInkDisplay.h>
 #include <EpdFontFamily.h>
 #include <FS.h>
 #include <map>
 #include "Bitmap.h"
 class GfxRenderer {
 public:
-  enum RenderMode { BW, GRAYSCALE_LSB, GRAYSCALE_MSB };
+  enum FontRenderMode { BW, GRAYSCALE_LSB, GRAYSCALE_MSB };
 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 = 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");
  EInkDisplay& einkDisplay;
-  RenderMode renderMode;
+  FontRenderMode fontRenderMode;
  uint8_t* bwBufferChunks[BW_BUFFER_NUM_CHUNKS] = {nullptr};
  std::map<int, EpdFontFamily> fontMap;
  void renderChar(const EpdFontFamily& fontFamily, uint32_t cp, int* x, const int* y, bool pixelState,
                  EpdFontStyle style) const;
  void freeBwBufferChunks();
 public:
-  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), renderMode(BW) {}
+  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), fontRenderMode(BW) {}
  ~GfxRenderer() = default;
  // Setup
@ -37,8 +27,6 @@ class GfxRenderer {
  static int getScreenWidth();
  static int getScreenHeight();
  void displayBuffer(EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH) const;
  // EXPERIMENTAL: Windowed update - display only a rectangular region (portrait coordinates)
  void displayWindow(int x, int y, int width, int height) const;
  void invertScreen() const;
  void clearScreen(uint8_t color = 0xFF) const;
@ -48,25 +36,20 @@ class GfxRenderer {
  void drawRect(int x, int y, int width, int height, bool state = true) const;
  void fillRect(int x, int y, int width, int height, bool state = true) const;
  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) const;
  // Text
  int getTextWidth(int fontId, const char* text, EpdFontStyle style = REGULAR) const;
  void drawCenteredText(int fontId, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
  void drawText(int fontId, int x, int y, const char* text, bool black = true, EpdFontStyle style = REGULAR) const;
  void setFontRenderMode(const FontRenderMode mode) { this->fontRenderMode = mode; }
  int getSpaceWidth(int fontId) const;
  int getLineHeight(int fontId) const;
-  // Grayscale functions
+  // Low level functions
-  void setRenderMode(const RenderMode mode) { this->renderMode = mode; }
+  uint8_t* getFrameBuffer() const;
  void swapBuffers() const;
  void grayscaleRevert() const;
  void copyGrayscaleLsbBuffers() const;
  void copyGrayscaleMsbBuffers() const;
  void displayGrayBuffer() const;
  void storeBwBuffer();
  void restoreBwBuffer();
  // Low level functions
  uint8_t* getFrameBuffer() const;
  static size_t getBufferSize();
  void grayscaleRevert() const;
 };
--- a/lib/ZipFile/ZipFile.cpp
+++ b/lib/ZipFile/ZipFile.cpp
@ -40,7 +40,7 @@ bool ZipFile::loadFileStat(const char* filename, mz_zip_archive_file_stat* fileS
  // find the file
  mz_uint32 fileIndex = 0;
  if (!mz_zip_reader_locate_file_v2(&zipArchive, filename, nullptr, 0, &fileIndex)) {
-    Serial.printf("[%lu] [ZIP] Could not find file %s\n", millis(), filename);
+    Serial.printf("[%lu] [ZIP] Could not find file %s\n", millis, filename);
    mz_zip_reader_end(&zipArchive);
    return false;
  }
@ -82,16 +82,6 @@ long ZipFile::getDataOffset(const mz_zip_archive_file_stat& fileStat) const {
  return fileOffset + localHeaderSize + filenameLength + extraOffset;
 }
 bool ZipFile::getInflatedFileSize(const char* filename, size_t* size) const {
  mz_zip_archive_file_stat fileStat;
  if (!loadFileStat(filename, &fileStat)) {
    return false;
  }
  *size = static_cast<size_t>(fileStat.m_uncomp_size);
  return true;
 }
 uint8_t* ZipFile::readFileToMemory(const char* filename, size_t* size, const bool trailingNullByte) const {
  mz_zip_archive_file_stat fileStat;
  if (!loadFileStat(filename, &fileStat)) {
@ -278,14 +268,7 @@ bool ZipFile::readFileToStream(const char* filename, Print& out, const size_t ch
      // Write output chunk
      if (outBytes > 0) {
        processedOutputBytes += outBytes;
-        if (out.write(outputBuffer + outputCursor, outBytes) != outBytes) {
+        out.write(outputBuffer + outputCursor, outBytes);
          Serial.printf("[%lu] [ZIP] Failed to write all output bytes to stream\n", millis());
          fclose(file);
          free(outputBuffer);
          free(fileReadBuffer);
          free(inflator);
          return false;
        }
        // Update output position in buffer (with wraparound)
        outputCursor = (outputCursor + outBytes) & (TINFL_LZ_DICT_SIZE - 1);
      }
--- a/lib/ZipFile/ZipFile.h
+++ b/lib/ZipFile/ZipFile.h
@ -14,7 +14,6 @@ class ZipFile {
 public:
  explicit ZipFile(std::string filePath) : filePath(std::move(filePath)) {}
  ~ZipFile() = default;
  bool getInflatedFileSize(const char* filename, size_t* size) const;
  uint8_t* readFileToMemory(const char* filename, size_t* size = nullptr, bool trailingNullByte = false) const;
  bool readFileToStream(const char* filename, Print& out, size_t chunkSize) const;
 };
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 98a5aa1f8969ccd317c9b45bf0fa84b6c82e167f
+Subproject commit 7e0dce916706da7d80ec225fade191aea6b87fb6
--- a/platformio.ini
+++ b/platformio.ini
@ -1,5 +1,5 @@
 [platformio]
-crosspoint_version = 0.7.0
+crosspoint_version = 0.4.0
 default_envs = default
 [base]
@ -8,9 +8,6 @@ board = esp32-c3-devkitm-1
 framework = arduino
 monitor_speed = 115200
 upload_speed = 921600
 check_tool = cppcheck
 check_skip_packages = yes
 check_severity = medium, high
 board_upload.flash_size = 16MB
 board_upload.maximum_size = 16777216
@ -20,7 +17,6 @@ build_flags =
  -DARDUINO_USB_MODE=1
  -DARDUINO_USB_CDC_ON_BOOT=1
  -DMINIZ_NO_ZLIB_COMPATIBLE_NAMES=1
  -DEINK_DISPLAY_SINGLE_BUFFER_MODE=1
 # https://libexpat.github.io/doc/api/latest/#XML_GE
  -DXML_GE=0
  -DXML_CONTEXT_BYTES=1024
@ -33,6 +29,7 @@ board_build.partitions = partitions.csv
 ; Libraries
 lib_deps =
  https://github.com/leethomason/tinyxml2.git#11.0.0
  BatteryMonitor=symlink://open-x4-sdk/libs/hardware/BatteryMonitor
  InputManager=symlink://open-x4-sdk/libs/hardware/InputManager
  EInkDisplay=symlink://open-x4-sdk/libs/display/EInkDisplay
--- a/src/CrossPointSettings.cpp
+++ b/src/CrossPointSettings.cpp
@ -1,67 +0,0 @@
 #include "CrossPointSettings.h"
 #include <HardwareSerial.h>
 #include <SD.h>
 #include <Serialization.h>
 #include <cstdint>
 #include <fstream>
 // Initialize the static instance
 CrossPointSettings CrossPointSettings::instance;
 namespace {
 constexpr uint8_t SETTINGS_FILE_VERSION = 1;
 constexpr uint8_t SETTINGS_COUNT = 2;
 constexpr char SETTINGS_FILE[] = "/sd/.crosspoint/settings.bin";
 }  // namespace
 bool CrossPointSettings::saveToFile() const {
  // Make sure the directory exists
  SD.mkdir("/.crosspoint");
  std::ofstream outputFile(SETTINGS_FILE);
  serialization::writePod(outputFile, SETTINGS_FILE_VERSION);
  serialization::writePod(outputFile, SETTINGS_COUNT);
  serialization::writePod(outputFile, whiteSleepScreen);
  serialization::writePod(outputFile, extraParagraphSpacing);
  outputFile.close();
  Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
  return true;
 }
 bool CrossPointSettings::loadFromFile() {
  if (!SD.exists(SETTINGS_FILE + 3)) {  // +3 to skip "/sd" prefix
    Serial.printf("[%lu] [CPS] Settings file does not exist, using defaults\n", millis());
    return false;
  }
  std::ifstream inputFile(SETTINGS_FILE);
  uint8_t version;
  serialization::readPod(inputFile, version);
  if (version != SETTINGS_FILE_VERSION) {
    Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
    inputFile.close();
    return false;
  }
  uint8_t fileSettingsCount = 0;
  serialization::readPod(inputFile, fileSettingsCount);
  // load settings that exist
  switch (fileSettingsCount) {
    case 1:
      serialization::readPod(inputFile, whiteSleepScreen);
      break;
    case 2:
      serialization::readPod(inputFile, whiteSleepScreen);
      serialization::readPod(inputFile, extraParagraphSpacing);
      break;
  }
  inputFile.close();
  Serial.printf("[%lu] [CPS] Settings loaded from file\n", millis());
  return true;
 }
--- a/src/CrossPointSettings.h
+++ b/src/CrossPointSettings.h
@ -1,34 +0,0 @@
 #pragma once
 #include <cstdint>
 #include <iosfwd>
 class CrossPointSettings {
 private:
  // Private constructor for singleton
  CrossPointSettings() = default;
  // Static instance
  static CrossPointSettings instance;
 public:
  // Delete copy constructor and assignment
  CrossPointSettings(const CrossPointSettings&) = delete;
  CrossPointSettings& operator=(const CrossPointSettings&) = delete;
  // Sleep screen settings
  uint8_t whiteSleepScreen = 0;
  // Text rendering settings
  uint8_t extraParagraphSpacing = 1;
  ~CrossPointSettings() = default;
  // Get singleton instance
  static CrossPointSettings& getInstance() { return instance; }
  bool saveToFile() const;
  bool loadFromFile();
 };
 // Helper macro to access settings
 #define SETTINGS CrossPointSettings::getInstance()
--- a/src/CrossPointState.cpp
+++ b/src/CrossPointState.cpp
@ -6,12 +6,8 @@
 #include <fstream>
 namespace {
 constexpr uint8_t STATE_FILE_VERSION = 1;
 constexpr char STATE_FILE[] = "/sd/.crosspoint/state.bin";
 }  // namespace
 CrossPointState CrossPointState::instance;
 bool CrossPointState::saveToFile() const {
  std::ofstream outputFile(STATE_FILE);
--- a/src/CrossPointState.h
+++ b/src/CrossPointState.h
@ -3,20 +3,11 @@
 #include <string>
 class CrossPointState {
  // Static instance
  static CrossPointState instance;
 public:
  std::string openEpubPath;
  ~CrossPointState() = default;
  // Get singleton instance
  static CrossPointState& getInstance() { return instance; }
  bool saveToFile() const;
  bool loadFromFile();
 };
 // Helper macro to access settings
 #define APP_STATE CrossPointState::getInstance()
--- a/src/activities/Activity.h
+++ b/src/activities/Activity.h
@ -1,18 +0,0 @@
 #pragma once
 #include <InputManager.h>
 class GfxRenderer;
 class Activity {
 protected:
  GfxRenderer& renderer;
  InputManager& inputManager;
 public:
  explicit Activity(GfxRenderer& renderer, InputManager& inputManager)
      : renderer(renderer), inputManager(inputManager) {}
  virtual ~Activity() = default;
  virtual void onEnter() {}
  virtual void onExit() {}
  virtual void loop() {}
 };
--- a/src/activities/ActivityWithSubactivity.cpp
+++ b/src/activities/ActivityWithSubactivity.cpp
@ -1,21 +0,0 @@
 #include "ActivityWithSubactivity.h"
 void ActivityWithSubactivity::exitActivity() {
  if (subActivity) {
    subActivity->onExit();
    subActivity.reset();
  }
 }
 void ActivityWithSubactivity::enterNewActivity(Activity* activity) {
  subActivity.reset(activity);
  subActivity->onEnter();
 }
 void ActivityWithSubactivity::loop() {
  if (subActivity) {
    subActivity->loop();
  }
 }
 void ActivityWithSubactivity::onExit() { exitActivity(); }
--- a/src/activities/ActivityWithSubactivity.h
+++ b/src/activities/ActivityWithSubactivity.h
@ -1,17 +0,0 @@
 #pragma once
 #include <memory>
 #include "Activity.h"
 class ActivityWithSubactivity : public Activity {
 protected:
  std::unique_ptr<Activity> subActivity = nullptr;
  void exitActivity();
  void enterNewActivity(Activity* activity);
 public:
  explicit ActivityWithSubactivity(GfxRenderer& renderer, InputManager& inputManager)
      : Activity(renderer, inputManager) {}
  void loop() override;
  void onExit() override;
 };
--- a/src/activities/boot_sleep/BootActivity.h
+++ b/src/activities/boot_sleep/BootActivity.h
@ -1,8 +0,0 @@
 #pragma once
 #include "../Activity.h"
 class BootActivity final : public Activity {
 public:
  explicit BootActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
  void onEnter() override;
 };
--- a/src/activities/boot_sleep/SleepActivity.cpp
+++ b/src/activities/boot_sleep/SleepActivity.cpp
@ -1,87 +0,0 @@
 #include "SleepActivity.h"
 #include <GfxRenderer.h>
 #include "CrossPointSettings.h"
 #include "SD.h"
 #include "config.h"
 #include "images/CrossLarge.h"
 void SleepActivity::onEnter() {
  // Look for sleep.bmp on the root of the sd card to determine if we should
  // render a custom sleep screen instead of the default.
  auto file = SD.open("/sleep.bmp");
  if (file) {
    Bitmap bitmap(file);
    if (bitmap.parseHeaders() == BmpReaderError::Ok) {
      renderCustomSleepScreen(bitmap);
      return;
    }
  }
  renderDefaultSleepScreen();
 }
 void SleepActivity::renderDefaultSleepScreen() const {
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
  renderer.clearScreen();
  renderer.drawImage(CrossLarge, (pageWidth - 128) / 2, (pageHeight - 128) / 2, 128, 128);
  renderer.drawCenteredText(UI_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, BOLD);
  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "SLEEPING");
  // Apply white screen if enabled in settings
  if (!SETTINGS.whiteSleepScreen) {
    renderer.invertScreen();
  }
  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
 }
 void SleepActivity::renderCustomSleepScreen(const Bitmap& bitmap) const {
  int x, y;
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
  if (bitmap.getWidth() > pageWidth || bitmap.getHeight() > pageHeight) {
    // image will scale, make sure placement is right
    const float ratio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
    const float screenRatio = static_cast<float>(pageWidth) / static_cast<float>(pageHeight);
    if (ratio > screenRatio) {
      // image wider than viewport ratio, scaled down image needs to be centered vertically
      x = 0;
      y = (pageHeight - pageWidth / ratio) / 2;
    } else {
      // image taller than viewport ratio, scaled down image needs to be centered horizontally
      x = (pageWidth - pageHeight * ratio) / 2;
      y = 0;
    }
  } else {
    // center the image
    x = (pageWidth - bitmap.getWidth()) / 2;
    y = (pageHeight - bitmap.getHeight()) / 2;
  }
  renderer.clearScreen();
  renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
  if (bitmap.hasGreyscale()) {
    bitmap.rewindToData();
    renderer.clearScreen(0x00);
    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
    renderer.copyGrayscaleLsbBuffers();
    bitmap.rewindToData();
    renderer.clearScreen(0x00);
    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
    renderer.copyGrayscaleMsbBuffers();
    renderer.displayGrayBuffer();
    renderer.setRenderMode(GfxRenderer::BW);
  }
 }
--- a/src/activities/boot_sleep/SleepActivity.h
+++ b/src/activities/boot_sleep/SleepActivity.h
@ -1,14 +0,0 @@
 #pragma once
 #include "../Activity.h"
 class Bitmap;
 class SleepActivity final : public Activity {
 public:
  explicit SleepActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
  void onEnter() override;
 private:
  void renderDefaultSleepScreen() const;
  void renderCustomSleepScreen(const Bitmap& bitmap) const;
 };
--- a/src/activities/home/HomeActivity.cpp
+++ b/src/activities/home/HomeActivity.cpp
@ -1,103 +0,0 @@
 #include "HomeActivity.h"
 #include <GfxRenderer.h>
 #include <SD.h>
 #include "config.h"
 namespace {
 constexpr int menuItemCount = 2;
 }
 void HomeActivity::taskTrampoline(void* param) {
  auto* self = static_cast<HomeActivity*>(param);
  self->displayTaskLoop();
 }
 void HomeActivity::onEnter() {
  renderingMutex = xSemaphoreCreateMutex();
  selectorIndex = 0;
  // Trigger first update
  updateRequired = true;
  xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
              2048,               // Stack size
              this,               // Parameters
              1,                  // Priority
              &displayTaskHandle  // Task handle
  );
 }
 void HomeActivity::onExit() {
  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
  xSemaphoreTake(renderingMutex, portMAX_DELAY);
  if (displayTaskHandle) {
    vTaskDelete(displayTaskHandle);
    displayTaskHandle = nullptr;
  }
  vSemaphoreDelete(renderingMutex);
  renderingMutex = nullptr;
 }
 void HomeActivity::loop() {
  const bool prevPressed =
      inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT);
  const bool nextPressed =
      inputManager.wasPressed(InputManager::BTN_DOWN) || inputManager.wasPressed(InputManager::BTN_RIGHT);
  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
    if (selectorIndex == 0) {
      onReaderOpen();
    } else if (selectorIndex == 1) {
      onSettingsOpen();
    }
  } else if (prevPressed) {
    selectorIndex = (selectorIndex + menuItemCount - 1) % menuItemCount;
    updateRequired = true;
  } else if (nextPressed) {
    selectorIndex = (selectorIndex + 1) % menuItemCount;
    updateRequired = true;
  }
 }
 void HomeActivity::displayTaskLoop() {
  while (true) {
    if (updateRequired) {
      updateRequired = false;
      xSemaphoreTake(renderingMutex, portMAX_DELAY);
      render();
      xSemaphoreGive(renderingMutex);
    }
    vTaskDelay(10 / portTICK_PERIOD_MS);
  }
 }
 void HomeActivity::render() const {
  renderer.clearScreen();
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
  renderer.drawCenteredText(READER_FONT_ID, 10, "CrossPoint Reader", true, BOLD);
  // Draw selection
  renderer.fillRect(0, 60 + selectorIndex * 30 + 2, pageWidth - 1, 30);
  renderer.drawText(UI_FONT_ID, 20, 60, "Read", selectorIndex != 0);
  renderer.drawText(UI_FONT_ID, 20, 90, "Settings", selectorIndex != 1);
  renderer.drawRect(25, pageHeight - 40, 106, 40);
  renderer.drawText(UI_FONT_ID, 25 + (105 - renderer.getTextWidth(UI_FONT_ID, "Back")) / 2, pageHeight - 35, "Back");
  renderer.drawRect(130, pageHeight - 40, 106, 40);
  renderer.drawText(UI_FONT_ID, 130 + (105 - renderer.getTextWidth(UI_FONT_ID, "Confirm")) / 2, pageHeight - 35,
                    "Confirm");
  renderer.drawRect(245, pageHeight - 40, 106, 40);
  renderer.drawText(UI_FONT_ID, 245 + (105 - renderer.getTextWidth(UI_FONT_ID, "Left")) / 2, pageHeight - 35, "Left");
  renderer.drawRect(350, pageHeight - 40, 106, 40);
  renderer.drawText(UI_FONT_ID, 350 + (105 - renderer.getTextWidth(UI_FONT_ID, "Right")) / 2, pageHeight - 35, "Right");
  renderer.displayBuffer();
 }
--- a/src/activities/home/HomeActivity.h
+++ b/src/activities/home/HomeActivity.h
@ -1,29 +0,0 @@
 #pragma once
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <freertos/task.h>
 #include <functional>
 #include "../Activity.h"
 class HomeActivity final : public Activity {
  TaskHandle_t displayTaskHandle = nullptr;
  SemaphoreHandle_t renderingMutex = nullptr;
  int selectorIndex = 0;
  bool updateRequired = false;
  const std::function<void()> onReaderOpen;
  const std::function<void()> onSettingsOpen;
  static void taskTrampoline(void* param);
  [[noreturn]] void displayTaskLoop();
  void render() const;
 public:
  explicit HomeActivity(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onReaderOpen,
                        const std::function<void()>& onSettingsOpen)
      : Activity(renderer, inputManager), onReaderOpen(onReaderOpen), onSettingsOpen(onSettingsOpen) {}
  void onEnter() override;
  void onExit() override;
  void loop() override;
 };
--- a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp
+++ b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp
@ -1,107 +0,0 @@
 #include "EpubReaderChapterSelectionActivity.h"
 #include <GfxRenderer.h>
 #include <SD.h>
 #include "config.h"
 constexpr int PAGE_ITEMS = 24;
 constexpr int SKIP_PAGE_MS = 700;
 void EpubReaderChapterSelectionActivity::taskTrampoline(void* param) {
  auto* self = static_cast<EpubReaderChapterSelectionActivity*>(param);
  self->displayTaskLoop();
 }
 void EpubReaderChapterSelectionActivity::onEnter() {
  if (!epub) {
    return;
  }
  renderingMutex = xSemaphoreCreateMutex();
  selectorIndex = currentSpineIndex;
  // Trigger first update
  updateRequired = true;
  xTaskCreate(&EpubReaderChapterSelectionActivity::taskTrampoline, "EpubReaderChapterSelectionActivityTask",
              2048,               // Stack size
              this,               // Parameters
              1,                  // Priority
              &displayTaskHandle  // Task handle
  );
 }
 void EpubReaderChapterSelectionActivity::onExit() {
  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
  xSemaphoreTake(renderingMutex, portMAX_DELAY);
  if (displayTaskHandle) {
    vTaskDelete(displayTaskHandle);
    displayTaskHandle = nullptr;
  }
  vSemaphoreDelete(renderingMutex);
  renderingMutex = nullptr;
 }
 void EpubReaderChapterSelectionActivity::loop() {
  const bool prevReleased =
      inputManager.wasReleased(InputManager::BTN_UP) || inputManager.wasReleased(InputManager::BTN_LEFT);
  const bool nextReleased =
      inputManager.wasReleased(InputManager::BTN_DOWN) || inputManager.wasReleased(InputManager::BTN_RIGHT);
  const bool skipPage = inputManager.getHeldTime() > SKIP_PAGE_MS;
  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
    onSelectSpineIndex(selectorIndex);
  } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
    onGoBack();
  } else if (prevReleased) {
    if (skipPage) {
      selectorIndex =
          ((selectorIndex / PAGE_ITEMS - 1) * PAGE_ITEMS + epub->getSpineItemsCount()) % epub->getSpineItemsCount();
    } else {
      selectorIndex = (selectorIndex + epub->getSpineItemsCount() - 1) % epub->getSpineItemsCount();
    }
    updateRequired = true;
  } else if (nextReleased) {
    if (skipPage) {
      selectorIndex = ((selectorIndex / PAGE_ITEMS + 1) * PAGE_ITEMS) % epub->getSpineItemsCount();
    } else {
      selectorIndex = (selectorIndex + 1) % epub->getSpineItemsCount();
    }
    updateRequired = true;
  }
 }
 void EpubReaderChapterSelectionActivity::displayTaskLoop() {
  while (true) {
    if (updateRequired) {
      updateRequired = false;
      xSemaphoreTake(renderingMutex, portMAX_DELAY);
      renderScreen();
      xSemaphoreGive(renderingMutex);
    }
    vTaskDelay(10 / portTICK_PERIOD_MS);
  }
 }
 void EpubReaderChapterSelectionActivity::renderScreen() {
  renderer.clearScreen();
  const auto pageWidth = renderer.getScreenWidth();
  renderer.drawCenteredText(READER_FONT_ID, 10, "Select Chapter", true, BOLD);
  const auto pageStartIndex = selectorIndex / PAGE_ITEMS * PAGE_ITEMS;
  renderer.fillRect(0, 60 + (selectorIndex % PAGE_ITEMS) * 30 + 2, pageWidth - 1, 30);
  for (int i = pageStartIndex; i < epub->getSpineItemsCount() && i < pageStartIndex + PAGE_ITEMS; i++) {
    const int tocIndex = epub->getTocIndexForSpineIndex(i);
    if (tocIndex == -1) {
      renderer.drawText(UI_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, "Unnamed", i != selectorIndex);
    } else {
      auto item = epub->getTocItem(tocIndex);
      renderer.drawText(UI_FONT_ID, 20 + (item.level - 1) * 15, 60 + (i % PAGE_ITEMS) * 30, item.title.c_str(),
                        i != selectorIndex);
    }
  }
  renderer.displayBuffer();
 }
--- a/src/activities/reader/EpubReaderChapterSelectionActivity.h
+++ b/src/activities/reader/EpubReaderChapterSelectionActivity.h
@ -1,38 +0,0 @@
 #pragma once
 #include <Epub.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <freertos/task.h>
 #include <memory>
 #include "../Activity.h"
 class EpubReaderChapterSelectionActivity final : public Activity {
  std::shared_ptr<Epub> epub;
  TaskHandle_t displayTaskHandle = nullptr;
  SemaphoreHandle_t renderingMutex = nullptr;
  int currentSpineIndex = 0;
  int selectorIndex = 0;
  bool updateRequired = false;
  const std::function<void()> onGoBack;
  const std::function<void(int newSpineIndex)> onSelectSpineIndex;
  static void taskTrampoline(void* param);
  [[noreturn]] void displayTaskLoop();
  void renderScreen();
 public:
  explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, InputManager& inputManager,
                                              const std::shared_ptr<Epub>& epub, const int currentSpineIndex,
                                              const std::function<void()>& onGoBack,
                                              const std::function<void(int newSpineIndex)>& onSelectSpineIndex)
      : Activity(renderer, inputManager),
        epub(epub),
        currentSpineIndex(currentSpineIndex),
        onGoBack(onGoBack),
        onSelectSpineIndex(onSelectSpineIndex) {}
  void onEnter() override;
  void onExit() override;
  void loop() override;
 };
--- a/src/activities/reader/ReaderActivity.cpp
+++ b/src/activities/reader/ReaderActivity.cpp
@ -1,68 +0,0 @@
 #include "ReaderActivity.h"
 #include <SD.h>
 #include "CrossPointState.h"
 #include "Epub.h"
 #include "EpubReaderActivity.h"
 #include "FileSelectionActivity.h"
 #include "activities/util/FullScreenMessageActivity.h"
 std::unique_ptr<Epub> ReaderActivity::loadEpub(const std::string& path) {
  if (!SD.exists(path.c_str())) {
    Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
    return nullptr;
  }
  auto epub = std::unique_ptr<Epub>(new Epub(path, "/.crosspoint"));
  if (epub->load()) {
    return epub;
  }
  Serial.printf("[%lu] [   ] Failed to load epub\n", millis());
  return nullptr;
 }
 void ReaderActivity::onSelectEpubFile(const std::string& path) {
  exitActivity();
  enterNewActivity(new FullScreenMessageActivity(renderer, inputManager, "Loading..."));
  auto epub = loadEpub(path);
  if (epub) {
    APP_STATE.openEpubPath = path;
    APP_STATE.saveToFile();
    onGoToEpubReader(std::move(epub));
  } else {
    exitActivity();
    enterNewActivity(new FullScreenMessageActivity(renderer, inputManager, "Failed to load epub", REGULAR,
                                                   EInkDisplay::HALF_REFRESH));
    delay(2000);
    onGoToFileSelection();
  }
 }
 void ReaderActivity::onGoToFileSelection() {
  exitActivity();
  enterNewActivity(new FileSelectionActivity(
      renderer, inputManager, [this](const std::string& path) { onSelectEpubFile(path); }, onGoBack));
 }
 void ReaderActivity::onGoToEpubReader(std::unique_ptr<Epub> epub) {
  exitActivity();
  enterNewActivity(new EpubReaderActivity(renderer, inputManager, std::move(epub), [this] { onGoToFileSelection(); }));
 }
 void ReaderActivity::onEnter() {
  if (initialEpubPath.empty()) {
    onGoToFileSelection();
    return;
  }
  auto epub = loadEpub(initialEpubPath);
  if (!epub) {
    onGoBack();
    return;
  }
  onGoToEpubReader(std::move(epub));
 }
--- a/src/activities/reader/ReaderActivity.h
+++ b/src/activities/reader/ReaderActivity.h
@ -1,24 +0,0 @@
 #pragma once
 #include <memory>
 #include "../ActivityWithSubactivity.h"
 class Epub;
 class ReaderActivity final : public ActivityWithSubactivity {
  std::string initialEpubPath;
  const std::function<void()> onGoBack;
  static std::unique_ptr<Epub> loadEpub(const std::string& path);
  void onSelectEpubFile(const std::string& path);
  void onGoToFileSelection();
  void onGoToEpubReader(std::unique_ptr<Epub> epub);
 public:
  explicit ReaderActivity(GfxRenderer& renderer, InputManager& inputManager, std::string initialEpubPath,
                          const std::function<void()>& onGoBack)
      : ActivityWithSubactivity(renderer, inputManager),
        initialEpubPath(std::move(initialEpubPath)),
        onGoBack(onGoBack) {}
  void onEnter() override;
 };
--- a/src/activities/settings/SettingsActivity.cpp
+++ b/src/activities/settings/SettingsActivity.cpp
@ -1,130 +0,0 @@
 #include "SettingsActivity.h"
 #include <GfxRenderer.h>
 #include "CrossPointSettings.h"
 #include "config.h"
 // Define the static settings list
 const SettingInfo SettingsActivity::settingsList[settingsCount] = {
    {"White Sleep Screen", &CrossPointSettings::whiteSleepScreen},
    {"Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing}};
 void SettingsActivity::taskTrampoline(void* param) {
  auto* self = static_cast<SettingsActivity*>(param);
  self->displayTaskLoop();
 }
 void SettingsActivity::onEnter() {
  renderingMutex = xSemaphoreCreateMutex();
  // Reset selection to first item
  selectedSettingIndex = 0;
  // Trigger first update
  updateRequired = true;
  xTaskCreate(&SettingsActivity::taskTrampoline, "SettingsActivityTask",
              2048,               // Stack size
              this,               // Parameters
              1,                  // Priority
              &displayTaskHandle  // Task handle
  );
 }
 void SettingsActivity::onExit() {
  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
  xSemaphoreTake(renderingMutex, portMAX_DELAY);
  if (displayTaskHandle) {
    vTaskDelete(displayTaskHandle);
    displayTaskHandle = nullptr;
  }
  vSemaphoreDelete(renderingMutex);
  renderingMutex = nullptr;
 }
 void SettingsActivity::loop() {
  // Handle actions with early return
  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
    toggleCurrentSetting();
    updateRequired = true;
    return;
  }
  if (inputManager.wasPressed(InputManager::BTN_BACK)) {
    SETTINGS.saveToFile();
    onGoHome();
    return;
  }
  // Handle navigation
  if (inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT)) {
    // Move selection up (with wrap-around)
    selectedSettingIndex = (selectedSettingIndex > 0) ? (selectedSettingIndex - 1) : (settingsCount - 1);
    updateRequired = true;
  } else if (inputManager.wasPressed(InputManager::BTN_DOWN) || inputManager.wasPressed(InputManager::BTN_RIGHT)) {
    // Move selection down (with wrap-around)
    selectedSettingIndex = (selectedSettingIndex < settingsCount - 1) ? (selectedSettingIndex + 1) : 0;
    updateRequired = true;
  }
 }
 void SettingsActivity::toggleCurrentSetting() {
  // Validate index
  if (selectedSettingIndex < 0 || selectedSettingIndex >= settingsCount) {
    return;
  }
  // Toggle the boolean value using the member pointer
  bool currentValue = SETTINGS.*(settingsList[selectedSettingIndex].valuePtr);
  SETTINGS.*(settingsList[selectedSettingIndex].valuePtr) = !currentValue;
  // Save settings when they change
  SETTINGS.saveToFile();
 }
 void SettingsActivity::displayTaskLoop() {
  while (true) {
    if (updateRequired) {
      updateRequired = false;
      xSemaphoreTake(renderingMutex, portMAX_DELAY);
      render();
      xSemaphoreGive(renderingMutex);
    }
    vTaskDelay(10 / portTICK_PERIOD_MS);
  }
 }
 void SettingsActivity::render() const {
  renderer.clearScreen();
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
  // Draw header
  renderer.drawCenteredText(READER_FONT_ID, 10, "Settings", true, BOLD);
  // We always have at least one setting
  // Draw all settings
  for (int i = 0; i < settingsCount; i++) {
    const int settingY = 60 + i * 30;  // 30 pixels between settings
    // Draw selection indicator for the selected setting
    if (i == selectedSettingIndex) {
      renderer.drawText(UI_FONT_ID, 5, settingY, ">");
    }
    // Draw setting name and value
    renderer.drawText(UI_FONT_ID, 20, settingY, settingsList[i].name);
    bool value = SETTINGS.*(settingsList[i].valuePtr);
    renderer.drawText(UI_FONT_ID, pageWidth - 80, settingY, value ? "ON" : "OFF");
  }
  // Draw help text
  renderer.drawText(SMALL_FONT_ID, 20, pageHeight - 30, "Press OK to toggle, BACK to save & exit");
  // Always use standard refresh for settings screen
  renderer.displayBuffer();
 }
--- a/src/activities/settings/SettingsActivity.h
+++ b/src/activities/settings/SettingsActivity.h
@ -1,42 +0,0 @@
 #pragma once
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <freertos/task.h>
 #include <cstdint>
 #include <string>
 #include <vector>
 #include "../Activity.h"
 class CrossPointSettings;
 // Structure to hold setting information
 struct SettingInfo {
  const char* name;                        // Display name of the setting
  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings
 };
 class SettingsActivity final : public Activity {
  TaskHandle_t displayTaskHandle = nullptr;
  SemaphoreHandle_t renderingMutex = nullptr;
  bool updateRequired = false;
  int selectedSettingIndex = 0;  // Currently selected setting
  const std::function<void()> onGoHome;
  // Static settings list
  static constexpr int settingsCount = 2;  // Number of settings
  static const SettingInfo settingsList[settingsCount];
  static void taskTrampoline(void* param);
  [[noreturn]] void displayTaskLoop();
  void render() const;
  void toggleCurrentSetting();
 public:
  explicit SettingsActivity(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onGoHome)
      : Activity(renderer, inputManager), onGoHome(onGoHome) {}
  void onEnter() override;
  void onExit() override;
  void loop() override;
 };
--- a/src/activities/util/FullScreenMessageActivity.h
+++ b/src/activities/util/FullScreenMessageActivity.h
@ -1,21 +0,0 @@
 #pragma once
 #include <EInkDisplay.h>
 #include <EpdFontFamily.h>
 #include <string>
 #include <utility>
 #include "../Activity.h"
 class FullScreenMessageActivity final : public Activity {
  std::string text;
  EpdFontStyle style;
  EInkDisplay::RefreshMode refreshMode;
 public:
  explicit FullScreenMessageActivity(GfxRenderer& renderer, InputManager& inputManager, std::string text,
                                     const EpdFontStyle style = REGULAR,
                                     const EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH)
      : Activity(renderer, inputManager), text(std::move(text)), style(style), refreshMode(refreshMode) {}
  void onEnter() override;
 };
--- a/src/config.h
+++ b/src/config.h
@ -9,7 +9,7 @@
 *    "./lib/EpdFont/builtinFonts/bookerly_italic_2b.h",
 *  ].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
 */
-#define READER_FONT_ID 1818981670
+#define READER_FONT_ID 1747632454
 /**
 * Generated with:
@ -18,7 +18,7 @@
 *    "./lib/EpdFont/builtinFonts/ubuntu_bold_10.h",
 *  ].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
 */
-#define UI_FONT_ID (-1619831379)
+#define UI_FONT_ID 225955604
 /**
 * Generated with:
@ -26,4 +26,4 @@
 *    "./lib/EpdFont/builtinFonts/pixelarial14.h",
 *  ].map{|f| Digest::SHA256.hexdigest(File.read(f)).to_i(16) }.sum % (2 ** 32) - (2 ** 31)'
 */
-#define SMALL_FONT_ID (-139796914)
+#define SMALL_FONT_ID 2037928017
--- a/src/main.cpp
+++ b/src/main.cpp
@ -14,15 +14,13 @@
 #include <builtinFonts/ubuntu_bold_10.h>
 #include "Battery.h"
 #include "CrossPointSettings.h"
 #include "CrossPointState.h"
 #include "activities/boot_sleep/BootActivity.h"
 #include "activities/boot_sleep/SleepActivity.h"
 #include "activities/home/HomeActivity.h"
 #include "activities/reader/ReaderActivity.h"
 #include "activities/settings/SettingsActivity.h"
 #include "activities/util/FullScreenMessageActivity.h"
 #include "config.h"
 #include "screens/BootLogoScreen.h"
 #include "screens/EpubReaderScreen.h"
 #include "screens/FileSelectionScreen.h"
 #include "screens/FullScreenMessageScreen.h"
 #include "screens/SleepScreen.h"
 #define SPI_FQ 40000000
 // Display SPI pins (custom pins for XteinkX4, not hardware SPI defaults)
@ -41,7 +39,8 @@
 EInkDisplay einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY);
 InputManager inputManager;
 GfxRenderer renderer(einkDisplay);
-Activity* currentActivity;
+Screen* currentScreen;
 CrossPointState appState;
 // Fonts
 EpdFont bookerlyFont(&bookerly_2b);
@ -59,22 +58,35 @@ EpdFontFamily ubuntuFontFamily(&ubuntu10Font, &ubuntuBold10Font);
 // Power button timing
 // Time required to confirm boot from sleep
-constexpr unsigned long POWER_BUTTON_WAKEUP_MS = 500;
+constexpr unsigned long POWER_BUTTON_WAKEUP_MS = 1000;
 // Time required to enter sleep mode
-constexpr unsigned long POWER_BUTTON_SLEEP_MS = 500;
+constexpr unsigned long POWER_BUTTON_SLEEP_MS = 1000;
 // Auto-sleep timeout (10 minutes of inactivity)
 constexpr unsigned long AUTO_SLEEP_TIMEOUT_MS = 10 * 60 * 1000;
-void exitActivity() {
+std::unique_ptr<Epub> loadEpub(const std::string& path) {
-  if (currentActivity) {
+  if (!SD.exists(path.c_str())) {
-    currentActivity->onExit();
+    Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
-    delete currentActivity;
+    return nullptr;
  }
  auto epub = std::unique_ptr<Epub>(new Epub(path, "/.crosspoint"));
  if (epub->load()) {
    return epub;
  }
  Serial.printf("[%lu] [   ] Failed to load epub\n", millis());
  return nullptr;
 }
 void exitScreen() {
  if (currentScreen) {
    currentScreen->onExit();
    delete currentScreen;
  }
 }
-void enterNewActivity(Activity* activity) {
+void enterNewScreen(Screen* screen) {
-  currentActivity = activity;
+  currentScreen = screen;
-  currentActivity->onEnter();
+  currentScreen->onEnter();
 }
 // Verify long press on wake-up from deep sleep
@ -118,8 +130,8 @@ void waitForPowerRelease() {
 // Enter deep sleep mode
 void enterDeepSleep() {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new SleepActivity(renderer, inputManager));
+  enterNewScreen(new SleepScreen(renderer, inputManager));
  Serial.printf("[%lu] [   ] Power button released after a long press. Entering deep sleep.\n", millis());
  delay(1000);  // Allow Serial buffer to empty and display to update
@ -134,20 +146,28 @@ void enterDeepSleep() {
 }
 void onGoHome();
-void onGoToReader(const std::string& initialEpubPath) {
+void onSelectEpubFile(const std::string& path) {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new ReaderActivity(renderer, inputManager, initialEpubPath, onGoHome));
+  enterNewScreen(new FullScreenMessageScreen(renderer, inputManager, "Loading..."));
 }
 void onGoToReaderHome() { onGoToReader(std::string()); }
-void onGoToSettings() {
+  auto epub = loadEpub(path);
-  exitActivity();
+  if (epub) {
-  enterNewActivity(new SettingsActivity(renderer, inputManager, onGoHome));
+    appState.openEpubPath = path;
    appState.saveToFile();
    exitScreen();
    enterNewScreen(new EpubReaderScreen(renderer, inputManager, std::move(epub), onGoHome));
  } else {
    exitScreen();
    enterNewScreen(
        new FullScreenMessageScreen(renderer, inputManager, "Failed to load epub", REGULAR, EInkDisplay::HALF_REFRESH));
    delay(2000);
    onGoHome();
  }
 }
 void onGoHome() {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new HomeActivity(renderer, inputManager, onGoToReaderHome, onGoToSettings));
+  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile));
 }
 void setup() {
@ -173,20 +193,27 @@ void setup() {
  renderer.insertFont(SMALL_FONT_ID, smallFontFamily);
  Serial.printf("[%lu] [   ] Fonts setup\n", millis());
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new BootActivity(renderer, inputManager));
+  enterNewScreen(new BootLogoScreen(renderer, inputManager));
  // SD Card Initialization
  SD.begin(SD_SPI_CS, SPI, SPI_FQ);
-  SETTINGS.loadFromFile();
+  appState.loadFromFile();
-  APP_STATE.loadFromFile();
+  if (!appState.openEpubPath.empty()) {
-  if (APP_STATE.openEpubPath.empty()) {
+    auto epub = loadEpub(appState.openEpubPath);
-    onGoHome();
+    if (epub) {
-  } else {
+      exitScreen();
-    onGoToReader(APP_STATE.openEpubPath);
+      enterNewScreen(new EpubReaderScreen(renderer, inputManager, std::move(epub), onGoHome));
      // Ensure we're not still holding the power button before leaving setup
      waitForPowerRelease();
      return;
    }
  }
  exitScreen();
  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile));
  // Ensure we're not still holding the power button before leaving setup
  waitForPowerRelease();
 }
@ -202,27 +229,13 @@ void loop() {
  }
  inputManager.update();
-
+  if (inputManager.wasReleased(InputManager::BTN_POWER) && inputManager.getHeldTime() > POWER_BUTTON_WAKEUP_MS) {
  // Check for any user activity (button press or release)
  static unsigned long lastActivityTime = millis();
  if (inputManager.wasAnyPressed() || inputManager.wasAnyReleased()) {
    lastActivityTime = millis();  // Reset inactivity timer
  }
  if (millis() - lastActivityTime >= AUTO_SLEEP_TIMEOUT_MS) {
    Serial.printf("[%lu] [SLP] Auto-sleep triggered after %lu ms of inactivity\n", millis(), AUTO_SLEEP_TIMEOUT_MS);
    enterDeepSleep();
    // This should never be hit as `enterDeepSleep` calls esp_deep_sleep_start
    return;
  }
-  if (inputManager.wasReleased(InputManager::BTN_POWER) && inputManager.getHeldTime() > POWER_BUTTON_SLEEP_MS) {
+  if (currentScreen) {
-    enterDeepSleep();
+    currentScreen->handleInput();
    // This should never be hit as `enterDeepSleep` calls esp_deep_sleep_start
    return;
  }
  if (currentActivity) {
    currentActivity->loop();
  }
 }
--- a/src/activities/boot_sleep/BootActivity.cpp
+++ b/src/activities/boot_sleep/BootActivity.cpp
@ -1,11 +1,11 @@
-#include "BootActivity.h"
+#include "BootLogoScreen.h"
 #include <GfxRenderer.h>
 #include "config.h"
 #include "images/CrossLarge.h"
-void BootActivity::onEnter() {
+void BootLogoScreen::onEnter() {
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
--- a/src/screens/BootLogoScreen.h
+++ b/src/screens/BootLogoScreen.h
@ -0,0 +1,8 @@
 #pragma once
 #include "Screen.h"
 class BootLogoScreen final : public Screen {
 public:
  explicit BootLogoScreen(GfxRenderer& renderer, InputManager& inputManager) : Screen(renderer, inputManager) {}
  void onEnter() override;
 };
--- a/src/activities/reader/EpubReaderActivity.cpp
+++ b/src/activities/reader/EpubReaderActivity.cpp
@ -1,30 +1,26 @@
-#include "EpubReaderActivity.h"
+#include "EpubReaderScreen.h"
 #include <Epub/Page.h>
 #include <GfxRenderer.h>
 #include <SD.h>
 #include "Battery.h"
 #include "CrossPointSettings.h"
 #include "EpubReaderChapterSelectionActivity.h"
 #include "config.h"
-namespace {
+constexpr int PAGES_PER_REFRESH = 15;
-constexpr int pagesPerRefresh = 15;
+constexpr unsigned long SKIP_CHAPTER_MS = 700;
 constexpr unsigned long skipChapterMs = 700;
 constexpr float lineCompression = 0.95f;
 constexpr int marginTop = 8;
 constexpr int marginRight = 10;
 constexpr int marginBottom = 22;
 constexpr int marginLeft = 10;
 }  // namespace
-void EpubReaderActivity::taskTrampoline(void* param) {
+void EpubReaderScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<EpubReaderActivity*>(param);
+  auto* self = static_cast<EpubReaderScreen*>(param);
  self->displayTaskLoop();
 }
-void EpubReaderActivity::onEnter() {
+void EpubReaderScreen::onEnter() {
  if (!epub) {
    return;
  }
@ -33,6 +29,7 @@ void EpubReaderActivity::onEnter() {
  epub->setupCacheDir();
  // TODO: Move this to a state object
  if (SD.exists((epub->getCachePath() + "/progress.bin").c_str())) {
    File f = SD.open((epub->getCachePath() + "/progress.bin").c_str());
    uint8_t data[4];
@ -46,7 +43,7 @@ void EpubReaderActivity::onEnter() {
  // Trigger first update
  updateRequired = true;
-  xTaskCreate(&EpubReaderActivity::taskTrampoline, "EpubReaderActivityTask",
+  xTaskCreate(&EpubReaderScreen::taskTrampoline, "EpubReaderScreenTask",
              8192,               // Stack size
              this,               // Parameters
              1,                  // Priority
@ -54,7 +51,7 @@ void EpubReaderActivity::onEnter() {
  );
 }
-void EpubReaderActivity::onExit() {
+void EpubReaderScreen::onExit() {
  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
  xSemaphoreTake(renderingMutex, portMAX_DELAY);
  if (displayTaskHandle) {
@ -67,40 +64,9 @@ void EpubReaderActivity::onExit() {
  epub.reset();
 }
-void EpubReaderActivity::loop() {
+void EpubReaderScreen::handleInput() {
  // Pass input responsibility to sub activity if exists
  if (subAcitivity) {
    subAcitivity->loop();
    return;
  }
  // Enter chapter selection activity
  if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
    // Don't start activity transition while rendering
    xSemaphoreTake(renderingMutex, portMAX_DELAY);
    subAcitivity.reset(new EpubReaderChapterSelectionActivity(
        this->renderer, this->inputManager, epub, currentSpineIndex,
        [this] {
          subAcitivity->onExit();
          subAcitivity.reset();
          updateRequired = true;
        },
        [this](const int newSpineIndex) {
          if (currentSpineIndex != newSpineIndex) {
            currentSpineIndex = newSpineIndex;
            nextPageNumber = 0;
            section.reset();
          }
          subAcitivity->onExit();
          subAcitivity.reset();
          updateRequired = true;
        }));
    subAcitivity->onEnter();
    xSemaphoreGive(renderingMutex);
  }
  if (inputManager.wasPressed(InputManager::BTN_BACK)) {
-    onGoBack();
+    onGoHome();
    return;
  }
@ -113,15 +79,7 @@ void EpubReaderActivity::loop() {
    return;
  }
-  // any botton press when at end of the book goes back to the last page
+  const bool skipChapter = inputManager.getHeldTime() > SKIP_CHAPTER_MS;
  if (currentSpineIndex > 0 && currentSpineIndex >= epub->getSpineItemsCount()) {
    currentSpineIndex = epub->getSpineItemsCount() - 1;
    nextPageNumber = UINT16_MAX;
    updateRequired = true;
    return;
  }
  const bool skipChapter = inputManager.getHeldTime() > skipChapterMs;
  if (skipChapter) {
    // We don't want to delete the section mid-render, so grab the semaphore
@ -167,7 +125,7 @@ void EpubReaderActivity::loop() {
  }
 }
-void EpubReaderActivity::displayTaskLoop() {
+void EpubReaderScreen::displayTaskLoop() {
  while (true) {
    if (updateRequired) {
      updateRequired = false;
@ -180,45 +138,35 @@ void EpubReaderActivity::displayTaskLoop() {
 }
 // TODO: Failure handling
-void EpubReaderActivity::renderScreen() {
+void EpubReaderScreen::renderScreen() {
  if (!epub) {
    return;
  }
-  // edge case handling for sub-zero spine index
+  if (currentSpineIndex >= epub->getSpineItemsCount() || currentSpineIndex < 0) {
  if (currentSpineIndex < 0) {
    currentSpineIndex = 0;
  }
  // based bounds of book, show end of book screen
  if (currentSpineIndex > epub->getSpineItemsCount()) {
    currentSpineIndex = epub->getSpineItemsCount();
  }
  // Show end of book screen
  if (currentSpineIndex == epub->getSpineItemsCount()) {
    renderer.clearScreen();
    renderer.drawCenteredText(READER_FONT_ID, 300, "End of book", true, BOLD);
    renderer.displayBuffer();
    return;
  }
  if (!section) {
    const auto filepath = epub->getSpineItem(currentSpineIndex);
    Serial.printf("[%lu] [ERS] Loading file: %s, index: %d\n", millis(), filepath.c_str(), currentSpineIndex);
    section = std::unique_ptr<Section>(new Section(epub, currentSpineIndex, renderer));
-    if (!section->loadCacheMetadata(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom, marginLeft,
+    if (!section->loadCacheMetadata(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom,
-                                    SETTINGS.extraParagraphSpacing)) {
+                                    marginLeft)) {
      Serial.printf("[%lu] [ERS] Cache not found, building...\n", millis());
      {
        const int textWidth = renderer.getTextWidth(READER_FONT_ID, "Indexing...");
        constexpr int margin = 20;
-        // Round all coordinates to 8 pixel boundaries
+        const int x = (GfxRenderer::getScreenWidth() - textWidth - margin * 2) / 2;
-        const int x = ((GfxRenderer::getScreenWidth() - textWidth - margin * 2) / 2 + 7) / 8 * 8;
+        constexpr int y = 50;
-        constexpr int y = 56;
+        const int w = textWidth + margin * 2;
-        const int w = (textWidth + margin * 2 + 7) / 8 * 8;
+        const int h = renderer.getLineHeight(READER_FONT_ID) + margin * 2;
-        const int h = (renderer.getLineHeight(READER_FONT_ID) + margin * 2 + 7) / 8 * 8;
+        renderer.grayscaleRevert();
-        renderer.clearScreen();
+        uint8_t *fb1 = renderer.getFrameBuffer();
        renderer.swapBuffers();
        memcpy(fb1, renderer.getFrameBuffer(), EInkDisplay::BUFFER_SIZE);
        renderer.fillRect(x, y, w, h, 0);
        renderer.drawText(READER_FONT_ID, x + margin, y + margin, "Indexing...");
        renderer.drawRect(x + 5, y + 5, w - 10, h - 10);
        renderer.displayBuffer();
@ -227,7 +175,7 @@ void EpubReaderActivity::renderScreen() {
      section->setupCacheDir();
      if (!section->persistPageDataToSD(READER_FONT_ID, lineCompression, marginTop, marginRight, marginBottom,
-                                        marginLeft, SETTINGS.extraParagraphSpacing)) {
+                                        marginLeft)) {
        Serial.printf("[%lu] [ERS] Failed to persist page data to SD\n", millis());
        section.reset();
        return;
@ -284,53 +232,41 @@ void EpubReaderActivity::renderScreen() {
  f.close();
 }
-void EpubReaderActivity::renderContents(std::unique_ptr<Page> page) {
+void EpubReaderScreen::renderContents(std::unique_ptr<Page> page) {
  page->render(renderer, READER_FONT_ID);
  renderStatusBar();
  if (pagesUntilFullRefresh <= 1) {
    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
-    pagesUntilFullRefresh = pagesPerRefresh;
+    pagesUntilFullRefresh = PAGES_PER_REFRESH;
  } else {
    renderer.displayBuffer();
    pagesUntilFullRefresh--;
  }
  // Save bw buffer to reset buffer state after grayscale data sync
  renderer.storeBwBuffer();
  // grayscale rendering
  // TODO: Only do this if font supports it
  {
    renderer.clearScreen(0x00);
-    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
+    renderer.setFontRenderMode(GfxRenderer::GRAYSCALE_LSB);
    page->render(renderer, READER_FONT_ID);
    renderer.copyGrayscaleLsbBuffers();
    // Render and copy to MSB buffer
    renderer.clearScreen(0x00);
-    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
+    renderer.setFontRenderMode(GfxRenderer::GRAYSCALE_MSB);
    page->render(renderer, READER_FONT_ID);
    renderer.copyGrayscaleMsbBuffers();
    // display grayscale part
    renderer.displayGrayBuffer();
-    renderer.setRenderMode(GfxRenderer::BW);
+    renderer.setFontRenderMode(GfxRenderer::BW);
  }
  // restore the bw data
  renderer.restoreBwBuffer();
 }
-void EpubReaderActivity::renderStatusBar() const {
+void EpubReaderScreen::renderStatusBar() const {
  constexpr auto textY = 776;
  // Calculate progress in book
  float sectionChapterProg = static_cast<float>(section->currentPage) / section->pageCount;
  uint8_t bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg);
  // Right aligned text for progress counter
-  const std::string progress = std::to_string(section->currentPage + 1) + "/" + std::to_string(section->pageCount) +
+  const std::string progress = std::to_string(section->currentPage + 1) + " / " + std::to_string(section->pageCount);
                               "  " + std::to_string(bookProgress) + "%";
  const auto progressTextWidth = renderer.getTextWidth(SMALL_FONT_ID, progress.c_str());
  renderer.drawText(SMALL_FONT_ID, GfxRenderer::getScreenWidth() - marginRight - progressTextWidth, textY,
                    progress.c_str());
@ -371,21 +307,12 @@ void EpubReaderActivity::renderStatusBar() const {
  const int titleMarginLeft = 20 + percentageTextWidth + 30 + marginLeft;
  const int titleMarginRight = progressTextWidth + 30 + marginRight;
  const int availableTextWidth = GfxRenderer::getScreenWidth() - titleMarginLeft - titleMarginRight;
-  const int tocIndex = epub->getTocIndexForSpineIndex(currentSpineIndex);
+  const auto tocItem = epub->getTocItem(epub->getTocIndexForSpineIndex(currentSpineIndex));
-
+  auto title = tocItem.title;
-  std::string title;
+  int titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
-  int titleWidth;
+  while (titleWidth > availableTextWidth) {
-  if (tocIndex == -1) {
+    title = title.substr(0, title.length() - 8) + "...";
    title = "Unnamed";
    titleWidth = renderer.getTextWidth(SMALL_FONT_ID, "Unnamed");
  } else {
    const auto tocItem = epub->getTocItem(tocIndex);
    title = tocItem.title;
    titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
    while (titleWidth > availableTextWidth) {
      title = title.substr(0, title.length() - 8) + "...";
      titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
    }
  }
  renderer.drawText(SMALL_FONT_ID, titleMarginLeft + (availableTextWidth - titleWidth) / 2, textY, title.c_str());
--- a/src/activities/reader/EpubReaderActivity.h
+++ b/src/activities/reader/EpubReaderActivity.h
@ -5,19 +5,18 @@
 #include <freertos/semphr.h>
 #include <freertos/task.h>
-#include "../Activity.h"
+#include "Screen.h"
-class EpubReaderActivity final : public Activity {
+class EpubReaderScreen final : public Screen {
  std::shared_ptr<Epub> epub;
  std::unique_ptr<Section> section = nullptr;
  TaskHandle_t displayTaskHandle = nullptr;
  SemaphoreHandle_t renderingMutex = nullptr;
  std::unique_ptr<Activity> subAcitivity = nullptr;
  int currentSpineIndex = 0;
  int nextPageNumber = 0;
  int pagesUntilFullRefresh = 0;
  bool updateRequired = false;
-  const std::function<void()> onGoBack;
+  const std::function<void()> onGoHome;
  static void taskTrampoline(void* param);
  [[noreturn]] void displayTaskLoop();
@ -26,10 +25,10 @@ class EpubReaderActivity final : public Activity {
  void renderStatusBar() const;
 public:
-  explicit EpubReaderActivity(GfxRenderer& renderer, InputManager& inputManager, std::unique_ptr<Epub> epub,
+  explicit EpubReaderScreen(GfxRenderer& renderer, InputManager& inputManager, std::unique_ptr<Epub> epub,
-                              const std::function<void()>& onGoBack)
+                            const std::function<void()>& onGoHome)
-      : Activity(renderer, inputManager), epub(std::move(epub)), onGoBack(onGoBack) {}
+      : Screen(renderer, inputManager), epub(std::move(epub)), onGoHome(onGoHome) {}
  void onEnter() override;
  void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };
--- a/src/activities/reader/FileSelectionActivity.cpp
+++ b/src/activities/reader/FileSelectionActivity.cpp
@ -1,4 +1,4 @@
-#include "FileSelectionActivity.h"
+#include "FileSelectionScreen.h"
 #include <GfxRenderer.h>
 #include <SD.h>
@ -15,12 +15,12 @@ void sortFileList(std::vector<std::string>& strs) {
  });
 }
-void FileSelectionActivity::taskTrampoline(void* param) {
+void FileSelectionScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<FileSelectionActivity*>(param);
+  auto* self = static_cast<FileSelectionScreen*>(param);
  self->displayTaskLoop();
 }
-void FileSelectionActivity::loadFiles() {
+void FileSelectionScreen::loadFiles() {
  files.clear();
  selectorIndex = 0;
  auto root = SD.open(basepath.c_str());
@ -42,7 +42,7 @@ void FileSelectionActivity::loadFiles() {
  sortFileList(files);
 }
-void FileSelectionActivity::onEnter() {
+void FileSelectionScreen::onEnter() {
  renderingMutex = xSemaphoreCreateMutex();
  basepath = "/";
@ -52,7 +52,7 @@ void FileSelectionActivity::onEnter() {
  // Trigger first update
  updateRequired = true;
-  xTaskCreate(&FileSelectionActivity::taskTrampoline, "FileSelectionActivityTask",
+  xTaskCreate(&FileSelectionScreen::taskTrampoline, "FileSelectionScreenTask",
              2048,               // Stack size
              this,               // Parameters
              1,                  // Priority
@ -60,7 +60,7 @@ void FileSelectionActivity::onEnter() {
  );
 }
-void FileSelectionActivity::onExit() {
+void FileSelectionScreen::onExit() {
  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
  xSemaphoreTake(renderingMutex, portMAX_DELAY);
  if (displayTaskHandle) {
@ -72,7 +72,7 @@ void FileSelectionActivity::onExit() {
  files.clear();
 }
-void FileSelectionActivity::loop() {
+void FileSelectionScreen::handleInput() {
  const bool prevPressed =
      inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT);
  const bool nextPressed =
@ -91,16 +91,11 @@ void FileSelectionActivity::loop() {
    } else {
      onSelect(basepath + files[selectorIndex]);
    }
-  } else if (inputManager.wasPressed(InputManager::BTN_BACK)) {
+  } else if (inputManager.wasPressed(InputManager::BTN_BACK) && basepath != "/") {
-    if (basepath != "/") {
+    basepath = basepath.substr(0, basepath.rfind('/'));
-      basepath = basepath.substr(0, basepath.rfind('/'));
+    if (basepath.empty()) basepath = "/";
-      if (basepath.empty()) basepath = "/";
+    loadFiles();
-      loadFiles();
+    updateRequired = true;
      updateRequired = true;
    } else {
      // At root level, go back home
      onGoHome();
    }
  } else if (prevPressed) {
    selectorIndex = (selectorIndex + files.size() - 1) % files.size();
    updateRequired = true;
@ -110,7 +105,7 @@ void FileSelectionActivity::loop() {
  }
 }
-void FileSelectionActivity::displayTaskLoop() {
+void FileSelectionScreen::displayTaskLoop() {
  while (true) {
    if (updateRequired) {
      updateRequired = false;
@ -122,15 +117,12 @@ void FileSelectionActivity::displayTaskLoop() {
  }
 }
-void FileSelectionActivity::render() const {
+void FileSelectionScreen::render() const {
  renderer.clearScreen();
  const auto pageWidth = GfxRenderer::getScreenWidth();
  renderer.drawCenteredText(READER_FONT_ID, 10, "CrossPoint Reader", true, BOLD);
  // Help text
  renderer.drawText(SMALL_FONT_ID, 20, GfxRenderer::getScreenHeight() - 30, "Press BACK for Home");
  if (files.empty()) {
    renderer.drawText(UI_FONT_ID, 20, 60, "No EPUBs found");
  } else {
--- a/src/activities/reader/FileSelectionActivity.h
+++ b/src/activities/reader/FileSelectionActivity.h
@ -7,9 +7,9 @@
 #include <string>
 #include <vector>
-#include "../Activity.h"
+#include "Screen.h"
-class FileSelectionActivity final : public Activity {
+class FileSelectionScreen final : public Screen {
  TaskHandle_t displayTaskHandle = nullptr;
  SemaphoreHandle_t renderingMutex = nullptr;
  std::string basepath = "/";
@ -17,7 +17,6 @@ class FileSelectionActivity final : public Activity {
  int selectorIndex = 0;
  bool updateRequired = false;
  const std::function<void(const std::string&)> onSelect;
  const std::function<void()> onGoHome;
  static void taskTrampoline(void* param);
  [[noreturn]] void displayTaskLoop();
@ -25,11 +24,10 @@ class FileSelectionActivity final : public Activity {
  void loadFiles();
 public:
-  explicit FileSelectionActivity(GfxRenderer& renderer, InputManager& inputManager,
+  explicit FileSelectionScreen(GfxRenderer& renderer, InputManager& inputManager,
-                                 const std::function<void(const std::string&)>& onSelect,
+                               const std::function<void(const std::string&)>& onSelect)
-                                 const std::function<void()>& onGoHome)
+      : Screen(renderer, inputManager), onSelect(onSelect) {}
      : Activity(renderer, inputManager), onSelect(onSelect), onGoHome(onGoHome) {}
  void onEnter() override;
  void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };
--- a/src/activities/util/FullScreenMessageActivity.cpp
+++ b/src/activities/util/FullScreenMessageActivity.cpp
@ -1,10 +1,10 @@
-#include "FullScreenMessageActivity.h"
+#include "FullScreenMessageScreen.h"
 #include <GfxRenderer.h>
 #include "config.h"
-void FullScreenMessageActivity::onEnter() {
+void FullScreenMessageScreen::onEnter() {
  const auto height = renderer.getLineHeight(UI_FONT_ID);
  const auto top = (GfxRenderer::getScreenHeight() - height) / 2;
--- a/src/screens/FullScreenMessageScreen.h
+++ b/src/screens/FullScreenMessageScreen.h
@ -0,0 +1,21 @@
 #pragma once
 #include <EInkDisplay.h>
 #include <EpdFontFamily.h>
 #include <string>
 #include <utility>
 #include "Screen.h"
 class FullScreenMessageScreen final : public Screen {
  std::string text;
  EpdFontStyle style;
  EInkDisplay::RefreshMode refreshMode;
 public:
  explicit FullScreenMessageScreen(GfxRenderer& renderer, InputManager& inputManager, std::string text,
                                   const EpdFontStyle style = REGULAR,
                                   const EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH)
      : Screen(renderer, inputManager), text(std::move(text)), style(style), refreshMode(refreshMode) {}
  void onEnter() override;
 };
--- a/src/screens/Screen.h
+++ b/src/screens/Screen.h
@ -0,0 +1,17 @@
 #pragma once
 #include <InputManager.h>
 class GfxRenderer;
 class Screen {
 protected:
  GfxRenderer& renderer;
  InputManager& inputManager;
 public:
  explicit Screen(GfxRenderer& renderer, InputManager& inputManager) : renderer(renderer), inputManager(inputManager) {}
  virtual ~Screen() = default;
  virtual void onEnter() {}
  virtual void onExit() {}
  virtual void handleInput() {}
 };
--- a/src/screens/SleepScreen.cpp
+++ b/src/screens/SleepScreen.cpp
@ -0,0 +1,18 @@
 #include "SleepScreen.h"
 #include <GfxRenderer.h>
 #include "config.h"
 #include "images/CrossLarge.h"
 void SleepScreen::onEnter() {
  const auto pageWidth = GfxRenderer::getScreenWidth();
  const auto pageHeight = GfxRenderer::getScreenHeight();
  renderer.clearScreen();
  renderer.drawImage(CrossLarge, (pageWidth - 128) / 2, (pageHeight - 128) / 2, 128, 128);
  renderer.drawCenteredText(UI_FONT_ID, pageHeight / 2 + 70, "CrossPoint", true, BOLD);
  renderer.drawCenteredText(SMALL_FONT_ID, pageHeight / 2 + 95, "SLEEPING");
  renderer.invertScreen();
  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
 }
--- a/src/screens/SleepScreen.h
+++ b/src/screens/SleepScreen.h
@ -0,0 +1,8 @@
 #pragma once
 #include "Screen.h"
 class SleepScreen final : public Screen {
 public:
  explicit SleepScreen(GfxRenderer& renderer, InputManager& inputManager) : Screen(renderer, inputManager) {}
  void onEnter() override;
 };
		`@ -1 +1 @@`
			`Subproject commit 98a5aa1f8969ccd317c9b45bf0fa84b6c82e167f`				`Subproject commit 7e0dce916706da7d80ec225fade191aea6b87fb6`