fix: Set explicit littlefs version tag

Reviewed-on: #6

.forgejo/workflows/push.yaml

@@ -0,0 +1,190 @@
+name: "BTClock CI"
+
+on:
+  push:
+    tags:
+      - "*"
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: docker
+    container:
+      image: ghcr.io/catthehacker/ubuntu:js-22.04
+    permissions:
+      contents: write
+      checks: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: yarn
+          cache-dependency-path: "**/yarn.lock"
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+            ~/data/node_modules
+            .pio
+            data/node_modules
+          key: ${{ runner.os }}-pio
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+          cache: "pip"
+      - name: Get current date
+        id: dateAndTime
+        shell: bash
+        run: echo "dateAndTime=$(date +'%Y-%m-%d-%H:%M')" >> $GITHUB_OUTPUT
+      - name: Install PlatformIO Core
+        shell: bash
+        run: pip install --upgrade platformio
+      - name: Run unit tests
+        shell: bash
+        run: mkdir -p junit-reports && pio test -e native_test_only --junit-output-path junit-reports/
+      - name: Build BTClock firmware
+        shell: bash
+        run: pio run
+      - name: Build BTClock filesystem
+        shell: bash
+        run: pio run --target buildfs
+      - name: Copy bootloader to output folder
+        run: cp ~/.platformio/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin .pio
+      - name: Upload artifacts
+        uses: https://code.forgejo.org/forgejo/upload-artifact@v4
+        with:
+          include-hidden-files: true
+          retention-days: 1
+          name: prepared-outputs
+          path: .pio/**/*.bin
+  merge:
+    runs-on: docker
+    container:
+      image: ghcr.io/catthehacker/ubuntu:js-22.04
+    permissions:
+      contents: write
+      checks: write
+    needs: build
+    continue-on-error: true
+    strategy:
+      matrix:
+        chip:
+          - name: lolin_s3_mini
+            version: esp32s3
+          - name: btclock_rev_b
+            version: esp32s3
+          - name: btclock_v8
+            version: esp32s3
+        epd_variant: [213epd, 29epd]
+        exclude:
+          - chip: { name: btclock_rev_b, version: esp32s3 }
+            epd_variant: 29epd
+          - chip: { name: btclock_v8, version: esp32s3 }
+            epd_variant: 29epd
+    steps:
+      - uses: https://code.forgejo.org/forgejo/download-artifact@v4
+        with:
+          name: prepared-outputs
+          path: .pio
+      - name: Install esptools.py
+        run: pip install --upgrade esptool
+      - name: Create merged firmware binary
+        shell: bash
+        run: |
+          mkdir -p ${{ matrix.chip.name }}_${{ matrix.epd_variant }} 
+          if [ "${{ matrix.chip.name }}" == "btclock_v8" ]; then
+            esptool.py --chip ${{ matrix.chip.version }} merge_bin \
+            -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin \
+            --flash_mode dio \
+            --flash_freq 80m \
+            --flash_size 16MB \
+            0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin \
+            0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin \
+            0xe000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/ota_data_initial.bin \
+            0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin \
+            0xDF0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs_16MB.bin
+          elif [ "${{ matrix.chip.name }}" == "btclock_rev_b" ]; then
+            esptool.py --chip ${{ matrix.chip.version }} merge_bin \
+            -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin \
+            --flash_mode dio \
+            --flash_freq 80m \
+            --flash_size 8MB \
+            0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin \
+            0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin \
+            0xe000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/ota_data_initial.bin \
+            0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin \
+            0x6F0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs_8MB.bin;
+          else
+            esptool.py --chip ${{ matrix.chip.version }} merge_bin \
+            -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin \
+            --flash_mode dio \
+            0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin \
+            0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin \
+            0xe000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/ota_data_initial.bin \
+            0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin \
+            0x380000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs_4MB.bin
+            # Adjust the offset for littlefs or other files as needed for the original case
+          fi
+
+      - name: Create checksum for firmware
+        shell: bash
+        run: shasum -a 256 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin | awk '{print $1}' > ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}_firmware.bin.sha256
+
+      - name: Create checksum for merged binary
+        shell: bash
+        run: shasum -a 256 ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin | awk '{print $1}' > ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin.sha256
+
+      - name: Create checksum for littlefs partition
+        shell: bash
+        run: |
+          fs_file=$(find .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }} -name "littlefs*.bin")
+          echo $fs_file
+          fs_name=$(basename "$fs_file")
+          shasum -a 256 "$fs_file" | awk '{print $1}' > "${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${fs_name}.sha256"
+          cat "${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${fs_name}.sha256"
+      - name: Copy all artifacts to output folder
+        run: cp .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.bin .pio/boot_app0.bin ${{ matrix.chip.name }}_${{ matrix.epd_variant }}
+
+      - name: Create OTA binary file
+        run: mv ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}_firmware.bin
+      - name: Upload artifacts
+        uses: https://code.forgejo.org/forgejo/upload-artifact@v4
+        with:
+          name: build-${{ matrix.chip.name }}-${{ matrix.epd_variant }}
+          path: |
+            ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.bin
+            ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.sha256
+  release:
+    runs-on: docker
+    permissions:
+      contents: write
+      checks: write
+    needs: merge
+    steps:
+      - name: Download matrix outputs
+        uses: https://code.forgejo.org/forgejo/download-artifact@v4
+        with:
+          pattern: build-*
+          merge-multiple: false
+          path: temp
+      - name: Copy files
+        run: |
+          mkdir -p release
+          find temp -type f \( -name "*.bin" -o -name "*.sha256" \) -exec cp -f {} release/ \;
+      - name: Create release
+        uses: https://code.forgejo.org/actions/forgejo-release@v2.4.0
+        with:
+          url: "https://git.btclock.dev"
+          repo: "${{ github.repository }}"
+          direction: upload
+          tag: "${{ github.ref_name }}"
+          sha: "${{ github.sha }}"
+          release-dir: release
+          token: ${{ secrets.TOKEN }}
+          override: ${{ github.ref_type != 'tag' && github.ref_name != 'main' }}
+          prerelease: ${{ github.ref_type != 'tag' && github.ref_name != 'main' }}
+          release-notes-assistant: false

.github/actions/install-build/action.yml

@@ -0,0 +1,43 @@
+name: "Install and build"
+description: "Install and build"
+
+runs:
+  using: "composite"
+  steps:
+    - uses: actions/setup-node@v4
+      with:
+        node-version: lts/*
+        cache: yarn
+        cache-dependency-path: '**/yarn.lock'
+    - uses: actions/cache@v4
+      with:
+        path: |
+          ~/.cache/pip
+          ~/.platformio/.cache
+          ~/data/node_modules
+        key: ${{ runner.os }}-pio
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+    - name: Get current date
+      id: dateAndTime
+      shell: bash
+      run: echo "dateAndTime=$(date +'%Y-%m-%d-%H:%M')" >> $GITHUB_OUTPUT
+    - name: Install PlatformIO Core
+      shell: bash
+      run: pip install --upgrade platformio
+    - name: Run unit tests
+      shell: bash
+      run: mkdir -p junit-reports && pio test -e native_test_only --junit-output-path junit-reports/
+    - name: Publish Test Report
+      uses: mikepenz/action-junit-report@v4
+      if: success() || failure() # always run even if the previous step fails
+      with:
+        report_paths: '**/junit-reports/*.xml'
+        detailed_summary: true
+    - name: Build BTClock firmware
+      shell: bash
+      run: pio run 
+    - name: Build BTClock filesystem
+      shell: bash
+      run: pio run --target buildfs

.github/workflows/pull_request.yml

@@ -0,0 +1,19 @@
+name: Pull Request Workflow
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      checks: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: "Install and build"
+        uses: ./.github/actions/install-build

.github/workflows/tagging.yml

@@ -0,0 +1,154 @@
+name: BTClock CI
+
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      checks: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: "Install and build"
+        uses: ./.github/actions/install-build
+      - name: Copy bootloader to output folder
+        run: cp ~/.platformio/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin .pio
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          include-hidden-files: true
+          retention-days: 1
+          name: prepared-outputs
+          path: .pio/**/*.bin
+  merge:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      checks: write
+    needs: build
+    continue-on-error: true
+    strategy:
+      matrix:
+        chip:
+          - name: lolin_s3_mini
+            version: esp32s3
+          - name: btclock_rev_b
+            version: esp32s3
+          - name: btclock_v8
+            version: esp32s3
+        epd_variant: [213epd, 29epd]
+        exclude:
+          - chip: {name: btclock_rev_b, version: esp32s3}
+            epd_variant: 29epd
+          - chip: {name: btclock_v8, version: esp32s3}
+            epd_variant: 29epd
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: prepared-outputs
+          path: .pio
+      - name: Install esptools.py
+        run: pip install --upgrade esptool
+      # - name: Create merged firmware binary
+      # run: mkdir -p ${{ matrix.chip.name }}_${{ matrix.epd_variant }} && esptool.py --chip ${{ matrix.chip.version }} merge_bin -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin --flash_mode dio 0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin 0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin 0xe000 .pio/boot_app0.bin 0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin 0x369000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs.bin
+      - name: Create merged firmware binary
+        run: |
+          if [ "${{ matrix.chip.name }}" == "btclock_v8" ]; then
+            mkdir -p ${{ matrix.chip.name }}_${{ matrix.epd_variant }} && \
+            esptool.py --chip ${{ matrix.chip.version }} merge_bin \
+            -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin \
+            --flash_mode dio \
+            --flash_freq 80m \
+            --flash_size 16MB \
+            0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin \
+            0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin \
+            0xe000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/ota_data_initial.bin \
+            0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin \
+            0x810000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs.bin;
+          else
+            # Original command for other cases
+            mkdir -p ${{ matrix.chip.name }}_${{ matrix.epd_variant }} && \
+            esptool.py --chip ${{ matrix.chip.version }} merge_bin \
+            -o ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin \
+            --flash_mode dio \
+            0x0000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/bootloader.bin \
+            0x8000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/partitions.bin \
+            0xe000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/ota_data_initial.bin \
+            0x10000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin \
+            0x369000 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs.bin
+            # Adjust the offset for littlefs or other files as needed for the original case
+          fi
+
+      - name: Create checksum for firmware
+        run: shasum -a 256 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin | awk '{print $1}' > ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}_firmware.bin.sha256
+
+      - name: Create checksum for merged binary
+        run: shasum -a 256 ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin | awk '{print $1}' > ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}.bin.sha256
+
+      - name: Create checksum for littlefs partition
+        run: shasum -a 256 .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs.bin | awk '{print $1}' > ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/littlefs.bin.sha256
+
+      - name: Copy all artifacts to output folder
+        run: cp .pio/build/${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.bin .pio/boot_app0.bin ${{ matrix.chip.name }}_${{ matrix.epd_variant }}
+
+      - name: Create OTA binary file
+        run: mv ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/firmware.bin ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/${{ matrix.chip.name }}_${{ matrix.epd_variant }}_firmware.bin
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-${{ matrix.chip.name }}-${{ matrix.epd_variant }}
+          path: |
+            ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.bin
+            ${{ matrix.chip.name }}_${{ matrix.epd_variant }}/*.sha256
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      checks: write
+    needs: merge
+    steps:
+      - name: Download matrix outputs
+        uses: actions/download-artifact@v4
+        with:
+          pattern: build-*
+          merge-multiple: false
+      - name: Write commit hash to file
+        run: echo $GITHUB_SHA > commit.txt
+
+      - name: Write build date to file
+        run: echo "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" > date.txt
+
+      - name: Create release
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "**/*.bin,**/*.sha256"
+          allowUpdates: true
+          removeArtifacts: true
+          makeLatest: true
+        #   - name: Create release
+        #   uses: ncipollo/release-action@v1
+        #   with:
+        #     artifacts: "output/full-firmware.bin,output/full-firmware.sha256,.pio/build/lolin_s3_mini_qr/*.bin"
+        #     allowUpdates: true
+        #     removeArtifacts: true
+        #     makeLatest: true
+      - name: Pushes full-firmware.bin to web flasher
+        id: push_directory
+        uses: cpina/github-action-push-to-another-repository@main
+        env:
+          SSH_DEPLOY_KEY: ${{ secrets.SSH_DEPLOY_KEY }}
+        with:
+          source-directory: .
+          target-directory: firmware_v3/
+          destination-github-username: "btclock"
+          destination-repository-name: "web-flasher"
+          target-branch: main
+          user-name: ${{github.actor}}
+          user-email: ${{github.actor}}@users.noreply.github.com

.github/workflows/workflow.yml

@@ -1,84 +0,0 @@
-name: BTClock CI
-
-on: 
-  push:
-    tags:
-      - '*'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: lts/*
-          cache: yarn
-          cache-dependency-path: '**/yarn.lock'
-      - uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/pip
-            ~/.platformio/.cache
-          key: ${{ runner.os }}-pio
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.9'
-      - name: Get current date
-        id: dateAndTime
-        # run: echo "::set-output name=dateAndTime::$(date +'%Y-%m-%d-%H:%M')"
-        run: echo "dateAndTime=$(date +'%Y-%m-%d-%H:%M')" >> $GITHUB_OUTPUT
-      - name: Install PlatformIO Core
-        run: pip install --upgrade platformio
-
-      - name: Build BTClock firmware
-        run: pio run -e default 
-
-      - name: Build BTClock filesystem
-        run: pio run -e default --target buildfs
-
-      - name: Install esptools.py
-        run: pip install --upgrade esptool
-
-      - name: Create merged firmware binary
-        run: mkdir -p output && esptool.py --chip esp32s3 merge_bin -o output/full-firmware.bin --flash_mode dio 0x0000 .pio/build/lolin_s3_mini/bootloader.bin 0x8000 .pio/build/lolin_s3_mini/partitions.bin 0xe000 ~/.platformio/packages/framework-arduinoespressif32/tools/partitions/boot_app0.bin 0x10000 .pio/build/lolin_s3_mini/firmware.bin 0x330000 .pio/build/lolin_s3_mini/littlefs.bin
-
-      - name: Create checksum for merged binary
-        run: shasum -a 256 output/full-firmware.bin | awk '{print $1}' > output/full-firmware.sha256
-
-      - name: Write commit hash to file
-        run: echo $GITHUB_SHA > output/commit.txt
-
-      - name: Write build date to file
-        run: echo "$(date -u +'%Y-%m-%dT%H:%M:%SZ')" > output/date.txt
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          path: |
-            .pio/build/lolin_s3_mini/*.bin
-            output/full-firmware.bin
-            output/full-firmware.sha256
-      - name: Create release
-        uses: ncipollo/release-action@v1
-        with:
-          name: release-${{ steps.dateAndTime.outputs.dateAndTime }}
-          artifacts: "output/full-firmware.bin,output/full-firmware.sha256,.pio/build/lolin_s3_mini/*.bin"
-          allowUpdates: true
-          removeArtifacts: true
-      # - name: Pushes full-firmware.bin to web flasher
-      #   id: push_directory
-      #   uses: cpina/github-action-push-to-another-repository@main
-      #   env:
-      #     SSH_DEPLOY_KEY: ${{ secrets.SSH_DEPLOY_KEY }}
-      #   with:
-      #     source-directory: output/
-      #     target-directory: firmware_v3/
-      #     destination-github-username: 'btclock'
-      #     destination-repository-name: 'web-flasher'
-      #     target-branch: btclock
-      #     user-name: ${{github.actor}}
-      #     user-email: ${{github.actor}}@users.noreply.github.com

.gitignore

@@ -11,3 +11,4 @@ data/node_modules
 node_modules
 .DS_Store
 *.bin
+ci/cache

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "data"]
+	path = data
+	url = https://git.btclock.dev/btclock/webui.git

.vscode/settings.json

@@ -0,0 +1,70 @@
+{
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "__verbose_abort": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "bitset": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "__nullptr": "cpp",
+        "__string": "cpp",
+        "chrono": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "algorithm": "cpp"
+    }
+}

CMakeLists.txt

@@ -1,4 +1,7 @@
 cmake_minimum_required(VERSION 3.16.0)
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-list(APPEND EXTRA_COMPONENT_DIRS managed_components)
+
+get_filename_component(configName "${CMAKE_BINARY_DIR}" NAME)
+list(APPEND EXTRA_COMPONENT_DIRS "${CMAKE_SOURCE_DIR}/.pio/libdeps/${configName}/esp_littlefs")
+
 project(btclock_espidf)

LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,59 @@
+# BTClock v3
+
+[![Latest release](https://git.btclock.dev/btclock/btclock_v3/badges/release.svg)](https://git.btclock.dev/btclock/btclock_v3/releases/latest)
+
+[![BTClock CI](https://git.btclock.dev/btclock/btclock_v3/badges/workflows/push.yaml/badge.svg)](https://git.btclock.dev/btclock/btclock_v3/actions?workflow=push.yaml&actor=0&status=0)
+
+Software for the BTClock project.
+
+Biggest differences with v2 are:
+- Uses WebSockets for all data
+- Built on the ESP-IDF with Arduino as a library 
+- Makes better use of native timers and interrupts
+- Able to be flashed over-the-air (using ESP OTA)
+- Added market capitalization screen
+- LED flash on new block (and focus to block height screen on new block)
+
+New features:
+- BitAxe integration
+- Nostr Zap notifier
+- Multiple mining pool stats integrations
+
+"Steal focus on new block" means that when a new block is mined, the display will switch to the block height screen if it's not on it already.
+
+See the [docs](https://git.btclock.dev/btclock/docs) repo for more information and building instructions.
+
+**NOTE**: The software assumes that the hardware is run in a controlled private network. ~~The Web UI and the OTA update mechanism are not password protected and accessible to anyone in the network. Also, since the device only fetches numbers through WebSockets it will skip server certificate verification to save resources.~~ Since 3.2.0 the WebUI is password protectable and all certificates are verified. OTA update mechanism is not password-protected. 
+
+## Building
+
+Use PlatformIO to build it yourself. Make sure you fetch the [WebUI](https://git.btclock.dev/btclock/webui) submodule.
+
+
+## Mining pool stats
+Enable mining pool stats by accessing your btclock's web UI (point a web browser at the device's IP address).
+
+Under Settings -> Extra Features: toggle Enable Mining Pool Stats.
+
+New options will appear. Select your mining pool and enter your pool username (Ocean) or api key (Braiins).
+
+The Mining Pool Earnings screen displays:
+* Braiins: Today's mining reward thus far
+* Ocean: Your estimated earnings if the pool were to find a block right now
+
+For solo mining pools, there are no earning estimations. Your username is the onchain withdrawal address, without the worker name.
+
+
+### Braiins Pool integration
+Create an API key based on the steps [here](https://academy.braiins.com/en/braiins-pool/monitoring/#api-configuration).
+
+The key's permissions should be:
+* Web Access: no
+* API Access: yes
+* Access Permissions: Read-only
+
+Copy the token that is created for the new key. Enter this as your "Mining Pool username or api key" in the btclock web UI.
+
+
+### Ocean integration
+Your "Mining Pool username" is just the onchain withdrawal address that you specify when pointing your miners at Ocean.

boards/btclock_rev_b.json

@@ -0,0 +1,60 @@
+{
+  "build": {
+    "arduino":{
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_8MB.csv"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_BTCLOCK_REV_B",
+      "-DARDUINO_ESP32S3_DEV",
+      "-DIS_BTCLOCK_REV_B",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1",
+      "-DARDUINO_USB_CDC_ON_BOOT=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "espidf": {
+      "sdkconfig_path": "boards"
+    },
+    "hwids": [
+      [
+        "0x303A",
+        "0x1001"
+      ]
+    ],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": [
+      "esp-builtin"
+    ],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "BTClock (rev. B)",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608,    
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "http://github.com/btclock",
+  "vendor": "BTClock"
+}

boards/btclock_v8.json

@@ -0,0 +1,62 @@
+{
+  "build": {
+    "arduino":{
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_16MB.csv",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_BTCLOCK",
+      "-DARDUINO_ESP32S3_DEV",
+      "-DIS_BTCLOCK_V8",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1",
+      "-DARDUINO_USB_CDC_ON_BOOT=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "psram_type": "opi",
+    "esp-idf": {
+      "sdkconfig_path": "boards/sdkconfig.btclock_v8"
+    },
+    "hwids": [
+      [
+        "0x303A",
+        "0x1001"
+      ]
+    ],
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": [
+      "esp-builtin"
+    ],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "BTClock",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,    
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "http://github.com/btclock",
+  "vendor": "BTClock"
+}

ci/Dockerfile

@@ -0,0 +1,15 @@
+# Use the official Python 3.9 image as the base
+FROM python:3.9-slim
+
+# Set the working directory
+WORKDIR /workspace
+
+RUN apt-get update && apt-get install -y git
+
+# Install PlatformIO
+RUN pip install platformio
+
+WORKDIR /usr/src
+
+CMD ["platformio", "run"]
+

data

@@ -0,0 +1 @@
+Subproject commit 0116cd68cdfdf383823f74e0f9665a1700cf0500

data/.yarnrc.yml

@@ -1 +0,0 @@
-nodeLinker: node-modules

data/esbuild.mjs

@@ -1,50 +0,0 @@
-import esbuild from "esbuild";
-import { sassPlugin } from "esbuild-sass-plugin";
-import htmlPlugin from '@chialab/esbuild-plugin-html';
-import handlebarsPlugin from "esbuild-plugin-handlebars";
-import { clean } from 'esbuild-plugin-clean';
-
-import postcss from "postcss";
-import autoprefixer from "autoprefixer";
-
-const hbsOptions = {
-    additionalHelpers: { splitText: "helpers.js" },
-    additionalPartials: {},
-    precompileOptions: {}
-  }
-
-esbuild
-    .build({
-        entryPoints: ["src/css/style.scss", "src/js/script.ts", "src/index.html", "src/js/helpers.js"],
-        outdir: "build",
-        bundle: true,
-        loader: {
-            ".png": "dataurl",
-            ".woff": "dataurl",
-            ".woff2": "dataurl",
-            ".eot": "dataurl",
-            ".ttf": "dataurl",
-            ".svg": "dataurl",
-        },
-        plugins: [
-            clean({
-                patterns: ['./build/*']
-              }),
-            htmlPlugin(),
-            sassPlugin({
-                async transform(source) {
-                    const { css } = await postcss([autoprefixer]).process(
-                        source
-                        , { from: undefined });
-                    return css;
-                },
-            }),
-            handlebarsPlugin(hbsOptions),
-
-        ],
-        minify: true,
-        metafile: false,
-        sourcemap: false
-    })
-    .then(() => console.log("⚡ Build complete! ⚡"))
-    .catch(() => process.exit(1));

data/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "data",
-  "packageManager": "yarn@3.2.1",
-  "scripts": {
-    "build": "node esbuild.mjs"
-  },
-  "dependencies": {
-    "esbuild": "0.19.4"
-  },
-  "devDependencies": {
-    "@chialab/esbuild-plugin-html": "^0.17.2",
-    "@craftamap/esbuild-plugin-html": "^0.5.0",
-    "@esbuilder/html": "^0.0.6",
-    "autoprefixer": "^10.4.16",
-    "bootstrap": "^5.3.2",
-    "esbuild-plugin-clean": "^1.0.1",
-    "esbuild-plugin-handlebars": "^1.0.2",
-    "esbuild-sass-plugin": "^2.16.0",
-    "handlebars": "^4.7.7",
-    "postcss": "^8.4.31",
-    "typescript": "^5.1.6"
-  }
-}

data/src/css/style.scss

@@ -1,121 +0,0 @@
-// @import "../node_modules/bootstrap/scss/bootstrap";
-
-@import "../node_modules/bootstrap/scss/functions";
-@import "../node_modules/bootstrap/scss/variables";
-@import "../node_modules/bootstrap/scss/variables-dark";
-
-$form-range-track-bg: #fff;
-
-@import "../node_modules/bootstrap/scss/mixins";
-@import "../node_modules/bootstrap/scss/maps";
-@import "../node_modules/bootstrap/scss/utilities";
-
-@import "../node_modules/bootstrap/scss/root";
-@import "../node_modules/bootstrap/scss/reboot";
-@import "../node_modules/bootstrap/scss/type";
-@import "../node_modules/bootstrap/scss/containers";
-@import "../node_modules/bootstrap/scss/grid";
-@import "../node_modules/bootstrap/scss/forms";
-@import "../node_modules/bootstrap/scss/buttons";
-@import "../node_modules/bootstrap/scss/navbar";
-@import "../node_modules/bootstrap/scss/nav";
-@import "../node_modules/bootstrap/scss/card";
-@import "../node_modules/bootstrap/scss/progress";
-
-@import "../node_modules/bootstrap/scss/helpers";
-@import "../node_modules/bootstrap/scss/utilities/api";
-
-
-@font-face {
-    font-display: swap;
-    /* Check https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/font-display for other options. */
-    font-family: 'Oswald';
-    font-style: normal;
-    font-weight: 400;
-    src: url('oswald.woff2') format('woff2'),
-        /* Chrome 36+, Opera 23+, Firefox 39+ */
-        url('oswald.woff') format('woff');
-    /* Chrome 5+, Firefox 3.6+, IE 9+, Safari 5.1+ */
-}
-
-nav {
-    margin-bottom: 15px;
-}
-
-.splitText div:first-child::after {
-    display: block;
-    content: '';
-    margin-top: 0px;
-    border-bottom: 2px solid;
-    margin-bottom: 3px;
-}
-
-#btcclock-wrapper {
-    margin: 0 auto;
-}
-
-.btclock {
-    display: flex;
-    flex-direction: row;
-    flex-wrap: nowrap;
-    justify-content: space-between;
-    align-items: center;
-    align-content: stretch;
-    font-family: 'Oswald', sans-serif;
-}
-
-.btclock>div {
-    padding: 5px;
-}
-
-.fg-ffff .btclock>div {
-    color: #fff;
-    border-color: #fff;
-}
-
-.bg-ffff .btclock>div {
-    background: #fff;
-}
-
-.fg-f800 .btclock>div {
-    color: #f00;
-    border-color: #f00;
-}
-
-.bg-f800 .btclock>div {
-    background: #f00;
-}
-
-.fg-0 .btclock>div {
-    color: #000;
-    border-color: #000;
-}
-
-.bg-0 .btclock>div {
-    background: #000;
-}
-
-.splitText {
-    font-size: 2.2rem;
-    padding-top: 5px;
-    padding-bottom: 5px;
-    text-align: center;
-}
-
-.digit {
-    font-size: 5rem;
-    padding-left: 10px;
-    padding-right: 10px;
-}
-
-.digit-blank {
-    content: "abc";
-}
-
-#customText {
-    text-transform: uppercase;
-}
-
-#toggleTimerArea {
-    cursor: pointer;
-}

data/src/index.html

@@ -1,245 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="description" content="">
-  <link href="/css/style.css" rel="stylesheet">
-  <title>&#8383;TClock</title>
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/handlebars.js/4.7.7/handlebars.min.js"
-    integrity="sha512-RNLkV3d+aLtfcpEyFG8jRbnWHxUqVZozacROI4J2F1sTaDqo1dPQYs01OMi1t1w9Y2FdbSCDSQ2ZVdAC8bzgAg=="
-    crossorigin="anonymous" referrerpolicy="no-referrer"></script>
-</head>
-
-<body>
-  <nav class="navbar navbar-light bg-light">
-    <div class="container-fluid">
-      <span class="navbar-brand mb-0 h1">&#8383;TClock</span>
-    </div>
-  </nav>
-  <script id="entry-template" type="text/x-handlebars-template">
-        <div class="entry">
-          <h1>Status</h1>
-          <div class="body">
-            <div class="btn-group" role="group" aria-label="Basic radio toggle button group">
-              {{#each screens }}
-              <input type="radio" class="btn-check" name="btnradio" id="btnradio{{ @index }}" autocomplete="off" {{#ifEquals @index ../currentScreen }} checked {{/ifEquals}} onclick="changeScreen({{ @index }})">
-              <label class="btn btn-outline-primary" for="btnradio{{ @index }}">{{ this }}</label>
-             {{/each}}
-        
-            </div>
-            <p>Rendered:</p>
-            {{#if rendered }}
-            <div class="btcclock-wrapper" id="btcclock-wrapper">
-              <div class="btclock">
-            {{#each data }}
-              {{{splitText this}}}
-            {{/each}}
-            </div></div>
-            {{/if}}
-            {{#if ledStatus }}
-            <p>LED status:</p>
-
-            {{#each ledStatus }}
-              <div style="background: #{{ this }}">&nbsp;</div>
-            {{/each}}
-            
-            {{/if}}
-            <div>
-              <p>Screen cycle: 
-                <span onclick="toggleTimer({{ timerRunning }})" id="toggleTimerArea">
-                {{#if timerRunning}}
-                &#9205;
-                {{else}}
-                &#9208;
-                {{/if}}
-                </span>
-              </p>
-            </div>
-            <hr>
-            <div>
-              <div class="progress" role="progressbar" aria-label="Memory usage" aria-valuenow="{{ memUsage }}" aria-valuemin="0" aria-valuemax="100">
-                <div class="progress-bar progress-bar-striped" style="width: {{ memUsage }}%">{{ memUsage }}%</div>
-              </div>
-              <div class="d-flex justify-content-between">
-                <div>Memory usage</div>
-                <div>{{ memFree }} / {{ memTotal }} KiB</div>
-              </div>
-            </div>
-            <hr>
-            <div>
-              <p>Uptime: {{#if uptime.h }}{{ uptime.h }}h {{/if}}{{ uptime.m }}m {{ uptime.s }}s</p>
-              <p>
-                Price connection:
-                <span>
-                {{#if connectionStatus.price}}
-                &#9989;
-                {{else}}
-                &#10060;
-                {{/if}}
-                </span>
-                - 
-                Mempool.space connection:
-                <span>
-                  {{#if connectionStatus.price}}
-                  &#9989;
-                  {{else}}
-                  &#10060;
-                  {{/if}}
-                </span>
-              </p>
-            </div>
-          </div>
-        </div>
-      </script>
-  <div class="container-fluid">
-    <div class="row">
-      <div class="col">
-        <div class="h-100 p-3 border bg-light">
-          <h1>Custom text</h1>
-          <form name="customText" id="customTextForm">
-            <div class="row">
-              <label for="customText" class="col-sm-4 col-form-label">Text</label>
-              <div class="col-sm-8">
-                <input type="text" class="form-control" id="customText" name="customText" maxlength="7">
-              </div>
-            </div>
-            <footer>
-              <button type="submit" class="btn btn-primary">Show Text</button>
-              <button type="button" class="btn btn-secondary" id="restartBtn">Restart</button>
-            </footer>
-          </form>
-          <hr>
-          <h2>LEDs</h2>
-          <form id="ledsForm" name="ledsForm">
-            <div class="row">
-              <label for="ledColorPicker" class="col-sm-6 col-form-label">LEDs color</label>
-              <div class="col-sm-6">
-                <input type="color" id="ledColorPicker" name="pickedColor" value="#ff8800">
-              </div>
-            </div>
-            <button type="button" class="btn btn-secondary" id="turnOffLedsBtn">Turn off</button>
-            <button type="submit" class="btn btn-primary">Set color</button>
-          </form>
-        </div>
-      </div>
-      <div class="col">
-        <div id="output" class="p-3 border bg-light"></div>
-      </div>
-      <div class="col">
-        <div class="h-100 p-3 border bg-light">
-          <h1>Settings</h1>
-          <form method="post" action="/api/settings" name="settings" id="settingsForm">
-            <div class="row">
-              <label for="fgColor" class="col-sm-6 col-form-label">Text color</label>
-              <div class="col-sm-6">
-                <select class="form-select" id="fgColor" name="fgColor">
-                  <option value="0xF800">Red</option>
-                  <option value="0xFFFF">White</option>
-                  <option value="0x0">Black</option>
-                </select>
-              </div>
-            </div>
-            <div class="row">
-              <label for="bgColor" class="col-sm-6 col-form-label">Background color</label>
-              <div class="col-sm-6">
-                <select class="form-select" id="bgColor" name="bgColor">
-                  <option value="0xF800">Red</option>
-                  <option value="0xFFFF">White</option>
-                  <option value="0x0">Black</option>
-                </select>
-              </div>
-            </div>
-            <div class="row">
-              <label for="timePerScreen" class="col-sm-6 col-form-label">Time per screen</label>
-              <div class="col-sm-6">
-                <div class="input-group mb-3">
-                  <input type="text" name="timePerScreen" id="timePerScreen" class="form-control">
-                  <span class="input-group-text">minutes</span>
-                </div>
-
-              </div>
-            </div>
-            <div class="row">
-              <label for="fullRefreshMin" class="col-sm-6 col-form-label">Full refresh every</label>
-              <div class="col-sm-6">
-                <div class="input-group mb-3">
-                  <input type="text" name="fullRefreshMin" id="fullRefreshMin" class="form-control">
-                  <span class="input-group-text">minutes</span>
-                </div>
-              </div>
-            </div>
-            <div class="row">
-              <label for="tzOffset" class="col-sm-6 col-form-label">Timezone offset</label>
-              <div class="col-sm-6 mb-3">
-                <div class="input-group">
-                  <input type="number" name="tzOffset" id="tzOffset" class="form-control">
-                  <span class="input-group-text">min</span>
-                  <button class="btn btn-outline-secondary" type="button" id="getTzOffsetBtn">Auto</button>
-                </div>
-                <div class="form-text">A restart is required to apply TZ offset.</div>
-              </div>
-            </div>
-            <div class="row">
-              <label for="minSecPriceUpd" class="col-sm-6 col-form-label">Time between price updates</label>
-              <div class="col-sm-6 mb-3">
-                <div class="input-group">
-                  <input type="number" name="minSecPriceUpd" id="minSecPriceUpd" class="form-control">
-                  <span class="input-group-text">sec</span>
-                </div>
-                <div class="form-text">Short amounts might shorten lifespan.</div>
-              </div>
-            </div>
-            <div class="row">
-              <div class=" col-sm-6">
-                <div class="form-check form-switch">
-                  <input class="form-check-input" type="checkbox" id="ledFlashOnUpdate" name="ledFlashOnUpd" value="1">
-                  <label class="form-check-label" for="ledFlashOnUpdate">LED flash on new block</label>
-                </div>
-              </div>
-            </div>
-            <div class="row">
-              <label class="col-sm-6 col-form-label" for="ledBrightness">LED brightness</label>
-              <div class="col-sm-6">
-                <input type="range" class="form-range" id="ledBrightness" name="ledBrightness" value="128" min="0"
-                  max="255">
-              </div>
-            </div>
-            <div class="row">
-              <label for="mempoolInstance" class="col-sm-6 col-form-label">Mempool Instance</label>
-              <div class="col-sm-6">
-                <input type="text" name="mempoolInstance" id="mempoolInstance" class="form-control">
-              </div>
-            </div>
-            <script id="screens-template" type="text/x-handlebars-template">
-              {{#each screens }}
-              <div class="row">
-                <div class="col-sm-12">
-                <div class="form-check form-switch">
-                  <input class="form-check-input" type="checkbox" id="screen{{id}}" name="screen[{{id}}]" value="1" {{#if enabled}}checked{{/if}}>
-                  <label class="form-check-label" for="screen{{id}}">{{name}}</label>
-                </div>
-              </div>
-              {{/each}}
-            </script>
-            <h3>Screens</h3>
-            <div id="outputScreens"></div>
-            <button type="submit" class="btn btn-secondary">Reset</button>
-            <button type="submit" class="btn btn-primary" id="saveSettingsBtn">Save</button>
-          </form>
-
-        </div>
-      </div>
-    </div>
-  </div>
-  <footer>
-    <small>
-      <span id="gitRev"></span>
-      <span id="lastBuildTime"></span>
-    </small>
-  </footer>
-  <script src="/js/script.js"></script>
-</body>
-
-</html>

data/src/js/helpers.js

@@ -1,17 +0,0 @@
-//import "handlebars/dist/handlebars.js";
-
-Handlebars.registerHelper('splitText', function (aString) {
-    if (aString.includes("/")) {
-      var c = aString.split("/").map((el) => { return "<div class=\"flex-items\">" + el + "</div>"; }).join('');
-      return "<div class=\"splitText\">" + c + "</div>";
-    }
-    if (aString.length == 0 || aString === " ") {
-      aString = "&nbsp;&nbsp;";
-    }
-    //return aString;
-    return "<div class=\"digit\">" + aString + "</div>";
-  });
-
-Handlebars.registerHelper('ifEquals', function(arg1, arg2, options) {
-    return (arg1 == arg2) ? options.fn(this) : options.inverse(this);
-});

data/src/js/script.ts

@@ -1,214 +0,0 @@
-import './helpers.js';
-
-var screens = ["Block Height", "Moscow Time", "Ticker", "Time", "Halving countdown"];
-
-toTime = (secs) => {
-    var hours = Math.floor(secs / (60 * 60));
-
-    var divisor_for_minutes = secs % (60 * 60);
-    var minutes = Math.floor(divisor_for_minutes / 60);
-
-    var divisor_for_seconds = divisor_for_minutes % 60;
-    var seconds = Math.ceil(divisor_for_seconds);
-
-    var obj = {
-        "h": hours,
-        "m": minutes,
-        "s": seconds
-    };
-    return obj;
-}
-
-let processStatusData = (jsonData) => {
-    var source = document.getElementById("entry-template").innerHTML;
-    var template = Handlebars.compile(source);
-
-    var context = {
-        timerRunning: jsonData.timerRunning,
-        memUsage: Math.round(jsonData.espFreeHeap / jsonData.espHeapSize * 100),
-        memFree: Math.round(jsonData.espFreeHeap / 1024),
-        memTotal: Math.round(jsonData.espHeapSize / 1024),
-        uptime: toTime(jsonData.espUptime),
-        currentScreen: jsonData.currentScreen,
-        rendered: jsonData.data,
-        data: jsonData.data,
-        screens: screens,
-        ledStatus: jsonData.ledStatus ? jsonData.ledStatus.map((t) => (t).toString(16)) : [],
-        connectionStatus: jsonData.connectionStatus
-    };
-
-
-    document.getElementById('output').innerHTML = template(context);
-}
-
-
-if (!!window.EventSource) {
-    var source = new EventSource('/events');
-
-    source.addEventListener('open', function (e) {
-        console.log("Status EventSource Connected");
-        if (e.data) {
-            processStatusData(JSON.parse(e.data));
-        }
-    }, false);
-
-    source.addEventListener('error', function (e) {
-        if (e.target.readyState != EventSource.OPEN) {
-            console.log("Status EventSource Disconnected");
-        }
-        source.close();
-    }, false);
-
-    source.addEventListener('status', function (e) {
-        processStatusData(JSON.parse(e.data));
-    }, false);
-}
-
-
-// getBcStatus = () => {
-//     fetch('/api/status', {
-//         method: 'get'
-//     })
-//         .then(response => response.json())
-//         .then()
-//         .catch(err => {
-//             //error block
-//         });
-// }
-
-// interval = setInterval(getBcStatus, 2500);
-// getBcStatus();
-
-fetch('/api/settings', {
-    method: 'get'
-})
-    .then(response => response.json())
-    .then(jsonData => {
-        var fgColor = ("0x" + jsonData.fgColor.toString(16).toUpperCase());
-        if (jsonData.epdColors == 2) {
-            document.getElementById('fgColor').querySelector('[value="0xF800"]').remove();
-            document.getElementById('bgColor').querySelector('[value="0xF800"]').remove();
-        }
-
-        document.getElementById('customText').setAttribute('maxlength', jsonData.numScreens);
-        document.getElementById('output').classList.add("fg-" + jsonData.fgColor.toString(16));
-        document.getElementById('output').classList.add("bg-" + jsonData.bgColor.toString(16));
-
-        document.getElementById('fgColor').value = fgColor;
-        document.getElementById('bgColor').value = "0x" + jsonData.bgColor.toString(16).toUpperCase();
-
-        if (jsonData.ledFlashOnUpdate)
-            document.getElementById('ledFlashOnUpdate').checked = true;
-
-        if (jsonData.useBitcoinNode)
-            document.getElementById('useBitcoinNode').checked = true;
-
-        // let nodeFields = ["rpcHost", "rpcPort", "rpcUser", "tzOffset"];
-
-        // for (let n of nodeFields) {
-        //     document.getElementById(n).value = jsonData[n];
-        // }
-
-        document.getElementById('timePerScreen').value = jsonData.timerSeconds / 60;
-        document.getElementById('ledBrightness').value = jsonData.ledBrightness;
-        document.getElementById('fullRefreshMin').value = jsonData.fullRefreshMin;
-        document.getElementById('tzOffset').value = jsonData.tzOffset;
-        document.getElementById('mempoolInstance').value = jsonData.mempoolInstance;
-        document.getElementById('minSecPriceUpd').value = jsonData.minSecPriceUpd;
-
-        if (jsonData.gitRev)
-            document.getElementById('gitRev').innerHTML = "Version: " + jsonData.gitRev;
-
-        if (jsonData.lastBuildTime)
-            document.getElementById('lastBuildTime').innerHTML = " / " + new Date((jsonData.lastBuildTime * 1000)).toLocaleString();
-
-        var source = document.getElementById("screens-template").innerHTML;
-        var template = Handlebars.compile(source);
-        var context = { screens: jsonData.screens };
-        document.getElementById('outputScreens').innerHTML = template(context);
-    })
-    .catch(err => {
-        console.log('error', err);
-    });
-
-
-
-var settingsForm = document.querySelector('#settingsForm');
-settingsForm.onsubmit = (event) => {
-    var formData = new FormData(settingsForm);
-
-    fetch("/api/settings",
-        {
-            body: formData,
-            method: "post"
-        }).then(() => {
-            console.log('Submitted');
-            document.getElementById('saveSettingsBtn')?.classList.add('btn-success');
-        });
-
-    return false;
-}
-
-document.getElementById('restartBtn').onclick = (event) => {
-    fetch('/api/restart');
-    return false;
-}
-
-
-var ledsForm = document.querySelector('#ledsForm');
-ledsForm.onsubmit = (event) => {
-    var formData = new FormData(ledsForm);
-
-    fetch('/api/lights/' + encodeURIComponent(formData.get('pickedColor').substring(1)), {
-        method: 'get'
-    })
-
-    return false;
-}
-
-turnOffLedsBtn.onclick = (event) => {
-    fetch('/api/lights/off', {
-        method: 'get'
-    })
-    return false;
-}
-
-let tzOffsetBtn = document.getElementById('getTzOffsetBtn');
-
-if (tzOffsetBtn)
-    tzOffsetBtn.onclick = (event) => {
-        document.getElementById("tzOffset").value = new Date(new Date().getFullYear(), 0, 1).getTimezoneOffset() * -1;
-        return false;
-    };
-
-var textForm = document.querySelector('#customTextForm');
-textForm.onsubmit = (event) => {
-    var formData = new FormData(textForm);
-
-    fetch('/api/show/text/' + encodeURIComponent(formData.get('customText')), {
-        method: 'get'
-    })
-        .then(response => response.json())
-        .catch(err => {
-            //error block
-        });
-    return false;
-}
-
-changeScreen = (id) => {
-    fetch('/api/show/screen/' + encodeURIComponent(id), {
-        method: 'get'
-    })
-        .then(response => response.json())
-        .catch(err => {
-            //error block
-        });
-}
-
-toggleTimer = (currentStatus) => {
-    if (currentStatus) {
-        fetch('/api/action/pause');
-    } else {
-        fetch('/api/action/timer_restart');
-    }
-}

data/src/wifi.html

@@ -1,48 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="description" content="">
-  <link href="/css/style.css" rel="stylesheet">
-  <title>&#8383;TClock WiFi Settings</title>
-</head>
-
-<body>
-  <nav class="navbar navbar-light bg-light">
-    <div class="container-fluid">
-      <span class="navbar-brand mb-0 h1">&#8383;TClock WiFi Settings</span>
-    </div>
-  </nav>
- 
-  <div class="container-fluid">
-    <div class="row">
-      <div class="col">
-        <div class="h-100 p-3 border bg-light">
-          <h1>WiFi Settings</h1>
-          <form name="customText" id="customTextForm" method="post" action="/setup/wifi">
-            <div class="row">
-              <label for="ssid" class="col-sm-4 col-form-label">SSID</label>
-              <div class="col-sm-8">
-                <input type="text" class="form-control" id="ssid" name="ssid" required>
-              </div>
-            </div>
-            <div class="row">
-                <label for="password" class="col-sm-4 col-form-label">Password</label>
-                <div class="col-sm-8">
-                  <input type="text" class="form-control" id="password" name="password" required>
-                </div>
-              </div>
-            <footer>
-              <button type="submit" class="btn btn-primary">Save and connect</button>
-              <p><small>The BTClock will restart and connect to your network. If it doesn't, reset to factory settings by holding the red button while booting to retry.</small></p>
-            </footer>
-          </form>
-        </div>
-      </div>
-    </div>
-  </div>
-</body>
-
-</html>

data/tsconfig.json

@@ -1,6 +0,0 @@
-{
-    "files": ["src/js/**.ts"],
-    "compilerOptions": {
-      "noImplicitAny": true,
-    }
-  }

dependencies.lock

@@ -1,16 +1,9 @@
 dependencies:
-  esp_littlefs:
-    component_hash: afa6d4544fadca368a35eb712d427cbb8334bc4f35a8f8299261b959a443c832
-    source:
-      git: https://github.com/joltwallet/esp_littlefs.git
-      path: .
-      type: git
-    version: b671069b1e9e279f357736e7b51402f46e39d1b5
   idf:
     component_hash: null
     source:
       type: idf
-    version: 4.4.5
-manifest_hash: 4b13ff241ec4d36ca2303b885c7088c32d74d090ef8e0ca6ea4c7d53047011d6
+    version: 4.4.7
+manifest_hash: 1d4ef353a86901733b106a1897b186dbf9fc091a4981f0560ea2f6899b7a3d44
 target: esp32s3
 version: 1.0.0

lib/btclock/bitaxe_handler.cpp

@@ -0,0 +1,88 @@
+#include "bitaxe_handler.hpp"
+
+std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(uint64_t hashrate)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    ret.fill(""); // Initialize all elements to empty strings
+
+    // Convert hashrate to GH/s and round to nearest integer
+    double hashRateGH = static_cast<double>(hashrate) / std::pow(10, getHashrateMultiplier('G'));
+    std::string hashRateStr = std::to_string(static_cast<uint64_t>(std::round(hashRateGH)));
+
+    // Place the icons
+    ret[0] = "mdi:bitaxe";
+    ret[NUM_SCREENS - 1] = "GH/S";
+
+    // Calculate the position where the digits should start
+    std::size_t textLength = hashRateStr.length();
+    std::size_t startIndex = NUM_SCREENS - 1 - textLength;
+
+    // Insert the "mdi:pickaxe" icon just before the digits
+    if (startIndex > 0)
+    {
+        ret[startIndex - 1] = "mdi:pickaxe";
+    }
+
+    // Place each digit
+    for (std::size_t i = 0; i < textLength; ++i)
+    {
+        ret[startIndex + i] = std::string(1, hashRateStr[i]);
+    }
+
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(uint64_t difficulty)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    ret.fill("");
+
+    // Add icons at the start
+    ret[0] = "mdi:bitaxe";
+    ret[1] = "mdi:rocket";
+
+    if (difficulty == 0) {
+        ret[NUM_SCREENS - 1] = "0";
+        return ret;
+    }
+
+    // Find the appropriate suffix and format the number
+    const std::pair<char, int> suffixes[] = {
+        {'Q', 15}, {'T', 12}, {'G', 9}, {'M', 6}, {'K', 3}
+    };
+
+    std::string text;
+    for (const auto& suffix : suffixes) {
+        if (difficulty >= std::pow(10, suffix.second)) {
+            double value = difficulty / std::pow(10, suffix.second);
+            char buffer[32];
+            snprintf(buffer, sizeof(buffer), "%.1f", value);
+            text = buffer;
+            // Remove trailing zeros and decimal point if not needed
+            if (text.find('.') != std::string::npos) {
+                text = text.substr(0, text.find_last_not_of('0') + 1);
+                if (text.back() == '.') {
+                    text.pop_back();
+                }
+            }
+            text += suffix.first;
+            break;
+        }
+    }
+
+    if (text.empty()) {
+        text = std::to_string(difficulty);
+    }
+
+    // Calculate start position to right-align the text
+    std::size_t startIndex = NUM_SCREENS - text.length();
+    
+    // Place the formatted difficulty string
+    for (std::size_t i = 0; i < text.length() && (startIndex + i) < NUM_SCREENS; ++i)
+    {
+        ret[startIndex + i] = std::string(1, text[i]);
+    }
+
+    return ret;
+}
+

lib/btclock/bitaxe_handler.hpp

@@ -0,0 +1,7 @@
+#include <array>
+#include <string>
+#include <cstdint>
+#include "utils.hpp"
+
+std::array<std::string, NUM_SCREENS> parseBitaxeHashRate(uint64_t hashrate);
+std::array<std::string, NUM_SCREENS> parseBitaxeBestDiff(uint64_t difficulty);

lib/btclock/data_handler.cpp

@@ -0,0 +1,390 @@
+#include "data_handler.hpp"
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#include <emscripten/bind.h>
+#endif
+
+char getCurrencySymbol(char input)
+{
+    switch (input)
+    {
+    case CURRENCY_EUR:
+        return '[';
+        break;
+    case CURRENCY_GBP:
+        return ']';
+        break;
+    case CURRENCY_JPY:
+        return '^';
+        break;
+    case CURRENCY_AUD:
+    case CURRENCY_CAD:
+    case CURRENCY_USD:
+        return '$';
+        break;
+    default:
+        return input;
+    }
+}
+
+std::string getCurrencyCode(char input)
+{
+    switch (input)
+    {
+    case CURRENCY_EUR:
+        return CURRENCY_CODE_EUR;
+        break;
+    case CURRENCY_GBP:
+        return CURRENCY_CODE_GBP;
+        break;
+    case CURRENCY_JPY:
+        return CURRENCY_CODE_JPY;
+        break;
+    case CURRENCY_AUD:
+        return CURRENCY_CODE_AUD;
+        break;
+    case CURRENCY_CAD:
+        return CURRENCY_CODE_CAD;
+        break;
+    default:
+        return CURRENCY_CODE_USD;
+    }
+}
+
+char getCurrencyChar(const std::string& input)
+{
+    if (input == "EUR")
+        return CURRENCY_EUR;
+    else if (input == "GBP")
+        return CURRENCY_GBP;
+    else if (input == "JPY")
+        return CURRENCY_JPY;
+    else if (input == "AUD")
+        return CURRENCY_AUD;
+    else if (input == "CAD")
+        return CURRENCY_CAD;
+    else
+        return CURRENCY_USD;  // Assuming USD is the default for unknown inputs
+}
+
+std::array<std::string, NUM_SCREENS> parsePriceData(std::uint32_t price, char currencySymbol, bool useSuffixFormat, bool mowMode, bool shareDot)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    std::string priceString;
+    if (std::to_string(price).length() >= NUM_SCREENS || useSuffixFormat)
+    {
+        int numScreens = shareDot || mowMode ? NUM_SCREENS - 1 : NUM_SCREENS - 2;
+        priceString = getCurrencySymbol(currencySymbol) + formatNumberWithSuffix(price, numScreens, mowMode);
+    }
+    else
+    {
+        priceString = getCurrencySymbol(currencySymbol) + std::to_string(price);
+    }
+    std::uint32_t firstIndex = 0;
+    if ((shareDot && priceString.length() <= (NUM_SCREENS)) || priceString.length() < (NUM_SCREENS))
+    {
+        priceString.insert(priceString.begin(), NUM_SCREENS - priceString.length(), ' ');
+
+        if (mowMode)
+        {
+            ret[0] = "MOW/UNITS";
+        }
+        else
+        {
+            ret[0] = "BTC/" + getCurrencyCode(currencySymbol);
+        }
+
+
+        firstIndex = 1;
+    }
+    
+    size_t dotPosition = priceString.find('.');
+
+    if (shareDot && dotPosition != std::string::npos && dotPosition > 0)
+    {
+        std::vector<std::string> tempArray;
+        if (dotPosition != std::string::npos && dotPosition > 0)
+        {
+            for (size_t i = 0; i < priceString.length(); ++i)
+            {
+                if (i == dotPosition - 1)
+                {
+                    tempArray.push_back(std::string(1, priceString[i]) + ".");
+                    ++i; // Skip the dot in the next iteration
+                }
+                else
+                {
+                    tempArray.push_back(std::string(1, priceString[i]));
+                }
+            }
+
+            // Copy from tempArray to ret
+            for (std::uint32_t i = firstIndex; i < NUM_SCREENS && i - firstIndex < tempArray.size(); ++i)
+            {
+                ret[i] = tempArray[i - firstIndex];
+            }
+        }
+    }
+    else
+    {
+        for (std::uint32_t i = firstIndex; i < NUM_SCREENS; i++)
+        {
+            ret[i] = std::string(1, priceString[i]);
+        }
+    }
+
+
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseSatsPerCurrency(std::uint32_t price,char currencySymbol, bool withSatsSymbol)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    std::string priceString = std::to_string(int(round(1 / float(price) * 10e7)));
+    std::uint32_t firstIndex = 0;
+    std::uint8_t insertSatSymbol = NUM_SCREENS - priceString.length() - 1;
+
+    if (priceString.length() < (NUM_SCREENS))
+    {
+        // Check if price is greater than 1 billion
+        if (price >= 100000000)
+        {
+            double satsPerCurrency = (1.0 / static_cast<double>(price)) * 1e8; // Calculate satoshis
+            std::ostringstream oss;
+            oss << std::fixed << std::setprecision(3) << satsPerCurrency; // Format with 3 decimal places
+            priceString = oss.str();
+        }
+        else
+        {
+            priceString = std::to_string(static_cast<int>(round(1.0 / static_cast<double>(price) * 1e8))); // Default formatting
+        }
+
+        // Pad the string with spaces if necessary
+        if (priceString.length() < NUM_SCREENS)
+        {
+            priceString.insert(priceString.begin(), NUM_SCREENS - priceString.length(), ' ');
+        }
+
+        if (currencySymbol != CURRENCY_USD || price >= 100000000) // no time anymore when earlier than 1
+            ret[0] = "SATS/" + getCurrencyCode(currencySymbol);
+        else 
+            ret[0] = "MSCW/TIME";
+
+        firstIndex = 1;
+
+        for (std::uint32_t i = firstIndex; i < NUM_SCREENS; i++)
+        {
+            ret[i] = priceString[i];
+        }
+
+        if (withSatsSymbol)
+        {
+            ret[insertSatSymbol] = "STS";
+        }
+    }
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseBlockHeight(std::uint32_t blockHeight)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    std::string blockNrString = std::to_string(blockHeight);
+    std::uint32_t firstIndex = 0;
+
+    if (blockNrString.length() < NUM_SCREENS)
+    {
+        blockNrString.insert(blockNrString.begin(), NUM_SCREENS - blockNrString.length(), ' ');
+        ret[0] = "BLOCK/HEIGHT";
+        firstIndex = 1;
+    }
+
+    for (std::uint32_t i = firstIndex; i < NUM_SCREENS; i++)
+    {
+        ret[i] = blockNrString[i];
+    }
+
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseBlockFees(std::uint16_t blockFees)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    std::string blockFeesString = std::to_string(blockFees);
+    std::uint32_t firstIndex = 0;
+
+    if (blockFeesString.length() < NUM_SCREENS)
+    {
+        blockFeesString.insert(blockFeesString.begin(), NUM_SCREENS - blockFeesString.length() - 1, ' ');
+        ret[0] = "FEE/RATE";
+        firstIndex = 1;
+    }
+
+    for (std::uint8_t i = firstIndex; i < NUM_SCREENS - 1; i++)
+    {
+        ret[i] = blockFeesString[i];
+    }
+
+    ret[NUM_SCREENS - 1] = "sat/vB";
+
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseHalvingCountdown(std::uint32_t blockHeight, bool asBlocks)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    const std::uint32_t nextHalvingBlock = 210000 - (blockHeight % 210000);
+    const std::uint32_t minutesToHalving = nextHalvingBlock * 10;
+
+    if (asBlocks)
+    {
+        std::string blockNrString = std::to_string(nextHalvingBlock);
+        std::uint32_t firstIndex = 0;
+
+        if (blockNrString.length() < NUM_SCREENS)
+        {
+            blockNrString.insert(blockNrString.begin(), NUM_SCREENS - blockNrString.length(), ' ');
+            ret[0] = "HAL/VING";
+            firstIndex = 1;
+        }
+
+        for (std::uint32_t i = firstIndex; i < NUM_SCREENS; i++)
+        {
+            ret[i] = blockNrString[i];
+        }
+    }
+    else
+    {
+
+        const int years = floor(minutesToHalving / 525600);
+        const int days = floor((minutesToHalving - (years * 525600)) / (24 * 60));
+        const int hours = floor((minutesToHalving - (years * 525600) - (days * (24 * 60))) / 60);
+        const int mins = floor(minutesToHalving - (years * 525600) - (days * (24 * 60)) - (hours * 60));
+        ret[0] = "BIT/COIN";
+        ret[1] = "HAL/VING";
+        ret[(NUM_SCREENS - 5)] = std::to_string(years) + "/YRS";
+        ret[(NUM_SCREENS - 4)] = std::to_string(days) + "/DAYS";
+        ret[(NUM_SCREENS - 3)] = std::to_string(hours) + "/HRS";
+        ret[(NUM_SCREENS - 2)] = std::to_string(mins) + "/MINS";
+        ret[(NUM_SCREENS - 1)] = "TO/GO";
+    }
+
+    return ret;
+}
+
+std::array<std::string, NUM_SCREENS> parseMarketCap(std::uint32_t blockHeight, std::uint32_t price, char currencySymbol, bool bigChars)
+{
+    std::array<std::string, NUM_SCREENS> ret;
+    std::uint32_t firstIndex = 0;
+    double supply = getSupplyAtBlock(blockHeight);
+    uint64_t marketCap = static_cast<std::uint64_t>(supply * double(price));
+
+    ret[0] = getCurrencyCode(currencySymbol) + "/MCAP";
+
+    if (bigChars)
+    {
+        firstIndex = 1;
+        // Serial.print("Market cap: ");
+        // Serial.println(marketCap);
+        std::string priceString = currencySymbol + formatNumberWithSuffix(marketCap, (NUM_SCREENS - 2));
+        priceString.insert(priceString.begin(), NUM_SCREENS - priceString.length(), ' ');
+
+        for (std::uint32_t i = firstIndex; i < NUM_SCREENS; i++)
+        {
+            ret[i] = priceString[i];
+        }
+    }
+    else
+    {
+        std::string stringValue = std::to_string(marketCap);
+        size_t mcLength = stringValue.length();
+        size_t leadingSpaces = (3 - mcLength % 3) % 3;
+        stringValue = std::string(leadingSpaces, ' ') + stringValue;
+
+        std::uint32_t groups = (mcLength + leadingSpaces) / 3;
+
+        if (groups < NUM_SCREENS)
+        {
+            firstIndex = 1;
+        }
+
+        for (int i = firstIndex; i < NUM_SCREENS - groups - 1; i++)
+        {
+            ret[i] = "";
+        }
+
+        ret[NUM_SCREENS - groups - 1] = std::string(" ") + currencySymbol + " ";
+        for (std::uint32_t i = 0; i < groups; i++)
+        {
+            ret[(NUM_SCREENS - groups + i)] = stringValue.substr(i * 3, 3).c_str();
+        }
+    }
+
+    return ret;
+}
+
+#ifdef __EMSCRIPTEN__
+emscripten::val arrayToStringArray(const std::array<std::string, NUM_SCREENS> &arr)
+{
+    emscripten::val jsArray = emscripten::val::array();
+    for (const auto &str : arr)
+    {
+        jsArray.call<void>("push", str);
+    }
+    return jsArray;
+}
+
+emscripten::val vectorToStringArray(const std::vector<std::string> &vec)
+{
+    emscripten::val jsArray = emscripten::val::array();
+    for (size_t i = 0; i < vec.size(); ++i)
+    {
+        jsArray.set(i, vec[i]);
+    }
+    return jsArray;
+}
+
+emscripten::val parseBlockHeightArray(std::uint32_t blockHeight)
+{
+    return arrayToStringArray(parseBlockHeight(blockHeight));
+}
+
+emscripten::val parsePriceDataArray(std::uint32_t price, const std::string &currencySymbol, bool useSuffixFormat = false, bool mowMode = false, bool shareDot = false)
+{
+    return arrayToStringArray(parsePriceData(price, currencySymbol[0], useSuffixFormat, mowMode, shareDot));
+}
+
+emscripten::val parseHalvingCountdownArray(std::uint32_t blockHeight, bool asBlocks)
+{
+    return arrayToStringArray(parseHalvingCountdown(blockHeight, asBlocks));
+}
+
+emscripten::val parseMarketCapArray(std::uint32_t blockHeight, std::uint32_t price, const std::string &currencySymbol, bool bigChars)
+{
+    return arrayToStringArray(parseMarketCap(blockHeight, price, currencySymbol[0], bigChars));
+}
+
+emscripten::val parseBlockFeesArray(std::uint16_t blockFees)
+{
+    return arrayToStringArray(parseBlockFees(blockFees));
+}
+
+emscripten::val parseSatsPerCurrencyArray(std::uint32_t price, const std::string &currencySymbol, bool withSatsSymbol)
+{
+    return arrayToStringArray(parseSatsPerCurrency(price, currencySymbol[0], withSatsSymbol));
+}
+
+EMSCRIPTEN_BINDINGS(my_module)
+{
+    //    emscripten::register_vector<std::string>("StringList");
+
+    emscripten::function("parseBlockHeight", &parseBlockHeightArray);
+    emscripten::function("parseHalvingCountdown", &parseHalvingCountdownArray);
+    emscripten::function("parseMarketCap", &parseMarketCapArray);
+    emscripten::function("parseBlockFees", &parseBlockFeesArray);
+    emscripten::function("parseSatsPerCurrency", &parseSatsPerCurrencyArray);
+    emscripten::function("parsePriceData", &parsePriceDataArray);
+
+    emscripten::function("arrayToStringArray", &arrayToStringArray);
+    emscripten::function("vectorToStringArray", &vectorToStringArray);
+}
+#endif

lib/btclock/data_handler.hpp

@@ -0,0 +1,32 @@
+#include <array>
+#include <string>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#include "utils.hpp"
+
+const char CURRENCY_USD = '$';
+const char CURRENCY_EUR = '[';
+const char CURRENCY_GBP = ']';
+const char CURRENCY_JPY = '^';
+const char CURRENCY_AUD = '_';
+const char CURRENCY_CAD = '`';
+
+const std::string CURRENCY_CODE_USD = "USD";
+const std::string CURRENCY_CODE_EUR = "EUR";
+const std::string CURRENCY_CODE_GBP = "GBP";
+const std::string CURRENCY_CODE_JPY = "JPY";
+const std::string CURRENCY_CODE_AUD = "AUD";
+const std::string CURRENCY_CODE_CAD = "CAD";
+
+std::array<std::string, NUM_SCREENS> parsePriceData(std::uint32_t price, char currency, bool useSuffixFormat = false, bool mowMode = false, bool shareDot = false);
+std::array<std::string, NUM_SCREENS> parseSatsPerCurrency(std::uint32_t price, char currencySymbol, bool withSatsSymbol);
+std::array<std::string, NUM_SCREENS> parseBlockHeight(std::uint32_t blockHeight);
+std::array<std::string, NUM_SCREENS> parseHalvingCountdown(std::uint32_t blockHeight, bool asBlocks);
+std::array<std::string, NUM_SCREENS> parseMarketCap(std::uint32_t blockHeight, std::uint32_t price, char currencySymbol, bool bigChars);
+std::array<std::string, NUM_SCREENS> parseBlockFees(std::uint16_t blockFees);
+
+char getCurrencySymbol(char input);
+std::string getCurrencyCode(char input);
+char getCurrencyChar(const std::string& input);

lib/btclock/nostrdisplay_handler.cpp

@@ -0,0 +1,24 @@
+#include "nostrdisplay_handler.hpp"
+
+std::array<std::string, NUM_SCREENS> parseZapNotify(std::uint16_t amount, bool withSatsSymbol)
+{
+    std::string text = std::to_string(amount);
+    std::size_t textLength = text.length();
+    std::size_t startIndex = NUM_SCREENS - textLength;
+
+    std::array<std::string, NUM_SCREENS> textEpdContent = {"ZAP", "mdi-lnbolt", "", "", "", "", ""};
+
+    // Insert the sats symbol just before the digits
+    if (startIndex > 0 && withSatsSymbol)
+    {
+        textEpdContent[startIndex - 1] = "STS";
+    }
+
+    // Place the digits
+    for (std::size_t i = 0; i < textLength; i++)
+    {
+        textEpdContent[startIndex + i] = text.substr(i, 1);
+    }
+
+    return textEpdContent;
+}

lib/btclock/nostrdisplay_handler.hpp

@@ -0,0 +1,5 @@
+#include <array>
+#include <string>
+#include "utils.hpp"
+
+std::array<std::string, NUM_SCREENS> parseZapNotify(std::uint16_t amount, bool withSatsSymbol);

lib/btclock/utils.cpp

@@ -0,0 +1,256 @@
+#include "utils.hpp"
+
+int modulo(int x, int N)
+{
+    return (x % N + N) % N;
+}
+
+double getSupplyAtBlock(std::uint32_t blockNr)
+{
+    if (blockNr >= 33 * 210000)
+    {
+        return 20999999.9769;
+    }
+
+    const int initialBlockReward = 50;  // Initial block reward
+    const int halvingInterval = 210000; // Number of blocks before halving
+
+    int halvingCount = blockNr / halvingInterval;
+    double totalBitcoinInCirculation = 0;
+
+    for (int i = 0; i < halvingCount; ++i)
+    {
+        totalBitcoinInCirculation += halvingInterval * initialBlockReward * std::pow(0.5, i);
+    }
+
+    totalBitcoinInCirculation += (blockNr % halvingInterval) * initialBlockReward * std::pow(0.5, halvingCount);
+
+    return totalBitcoinInCirculation;
+}
+
+std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters) 
+{
+    return formatNumberWithSuffix(num, numCharacters, false);
+}
+
+std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters, bool mowMode)
+{
+    static char result[20]; // Adjust size as needed
+    const long long quadrillion = 1000000000000000LL;
+    const long long trillion = 1000000000000LL;
+    const long long billion = 1000000000;
+    const long long million = 1000000;
+    const long long thousand = 1000;
+
+    double numDouble = (double)num;
+    int numDigits = (int)log10(num) + 1;
+    char suffix;
+
+    if (num >= quadrillion || numDigits > 15)
+    {
+        numDouble /= quadrillion;
+        suffix = 'Q';
+    }
+    else if (num >= trillion || numDigits > 12)
+    {
+        numDouble /= trillion;
+        suffix = 'T';
+    }
+    else if (num >= billion || numDigits > 9)
+    {
+        numDouble /= billion;
+        suffix = 'B';
+    }
+    else if (num >= million || numDigits > 6 || (mowMode && num >= thousand))
+    {
+        numDouble /= million;
+        suffix = 'M';
+    }
+    else if (!mowMode && (num >= thousand || numDigits > 3))
+    {
+        numDouble /= thousand;
+        suffix = 'K';
+    }
+    else if (!mowMode)
+    {
+        snprintf(result, sizeof(result), "%llu", (unsigned long long)num);
+        return result;
+    }
+    else // mowMode is true and num < 1000
+    {
+        numDouble /= million;
+        suffix = 'M';
+    }
+
+    // Add suffix
+    int len;
+
+    // Mow Mode always uses string truncation to avoid rounding
+    std::string mowAsString = std::to_string(numDouble);
+    if (mowMode) {
+        // Default to one decimal place
+        len = snprintf(result, sizeof(result), "%s%c", mowAsString.substr(0, mowAsString.find(".") + 2).c_str(), suffix);
+    }
+    else
+    {
+        len = snprintf(result, sizeof(result), "%.0f%c", numDouble, suffix);
+    }
+
+    // If there's room, add more decimal places
+    if (len < numCharacters)
+    {
+        int restLen = mowMode ? numCharacters - len : numCharacters - len - 1;
+
+        if (mowMode) {
+            snprintf(result, sizeof(result), "%s%c", mowAsString.substr(0, mowAsString.find(".") + 2 + restLen).c_str(), suffix);
+        }
+        else
+        {
+            snprintf(result, sizeof(result), "%.*f%c", restLen, numDouble, suffix);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Get sat amount from a bolt11 invoice 
+ * 
+ * Based on https://github.com/lnbits/nostr-zap-lamp/blob/main/nostrZapLamp/nostrZapLamp.ino
+ */
+int64_t getAmountInSatoshis(std::string bolt11) {
+    int64_t number = -1;
+    char multiplier = ' ';
+
+    for (unsigned int i = 0; i < bolt11.length(); ++i) {
+        if (isdigit(bolt11[i])) {
+            number = 0;
+            while (isdigit(bolt11[i])) {
+                number = number * 10 + (bolt11[i] - '0');
+                ++i;
+            }
+            for (unsigned int j = i; j < bolt11.length(); ++j) {
+                if (isalpha(bolt11[j])) {
+                    multiplier = bolt11[j];
+                    break;
+                }
+            }
+            break;
+        }
+    }
+
+    if (number == -1 || multiplier == ' ') {
+        return -1;
+    }
+
+    int64_t satoshis = number;
+
+    switch (multiplier) {
+        case 'm':
+            satoshis *= 100000; // 0.001 * 100,000,000
+            break;
+        case 'u':
+            satoshis *= 100; // 0.000001 * 100,000,000
+            break;
+        case 'n':
+            satoshis /= 10; // 0.000000001 * 100,000,000
+            break;
+        case 'p':
+            satoshis /= 10000; // 0.000000000001 * 100,000,000
+            break;
+        default:
+            return -1;
+    }
+
+    return satoshis;
+}
+
+void parseHashrateString(const std::string& hashrate, std::string& label, std::string& output, unsigned int maxCharacters) {
+    // Handle empty string or "0" cases
+    if (hashrate.empty() || hashrate == "0") {
+        label = "H/S";
+        output = "0";
+        return;
+    }
+
+    size_t suffixLength = 0;
+    if (hashrate.length() > 21) {
+        label = "ZH/S";
+        suffixLength = 21;
+    } else if (hashrate.length() > 18) {
+        label = "EH/S";
+        suffixLength = 18;
+    } else if (hashrate.length() > 15) {
+        label = "PH/S";
+        suffixLength = 15;
+    } else if (hashrate.length() > 12) {
+        label = "TH/S";
+        suffixLength = 12;
+    } else if (hashrate.length() > 9) {
+        label = "GH/S";
+        suffixLength = 9;
+    } else if (hashrate.length() > 6) {
+        label = "MH/S";
+        suffixLength = 6;
+    } else if (hashrate.length() > 3) {
+        label = "KH/S";
+        suffixLength = 3;
+    } else {
+        label = "H/S";
+        suffixLength = 0;
+    }
+
+        double value = std::stod(hashrate) / std::pow(10, suffixLength);
+
+        // Calculate integer part length
+        int integerPartLength = std::to_string(static_cast<int>(value)).length();
+
+        // Calculate remaining space for decimals
+        int remainingSpace = maxCharacters - integerPartLength;
+
+        char buffer[32];
+        if (remainingSpace <= 0)
+        {
+            // No space for decimals, just round to integer
+            snprintf(buffer, sizeof(buffer), "%.0f", value);
+        }
+        else
+        {
+            // Space for decimal point and some decimals
+            snprintf(buffer, sizeof(buffer), "%.*f", remainingSpace - 1, value);
+        }
+
+        // Remove trailing zeros and decimal point if necessary
+        output = buffer;
+        if (output.find('.') != std::string::npos)
+        {
+            output = output.substr(0, output.find_last_not_of('0') + 1);
+            if (output.back() == '.')
+            {
+                output.pop_back();
+            }
+        }
+  
+}
+
+int getHashrateMultiplier(char unit) {
+    if (unit == '0')
+        return 0;
+
+    static const std::unordered_map<char, int> multipliers = {
+        {'Z', 21}, {'E', 18}, {'P', 15}, {'T', 12},
+        {'G', 9},  {'M', 6},  {'K', 3}
+    };
+    return multipliers.at(unit);
+}
+
+int getDifficultyMultiplier(char unit) {
+    if (unit == '0')
+        return 0;
+
+    static const std::unordered_map<char, int> multipliers = {
+        {'Q', 15}, {'T', 12}, {'B', 9}, {'M', 6}, {'K', 3}, {'G', 9},
+        {'q', 15}, {'t', 12}, {'b', 9}, {'m', 6}, {'k', 3}, {'g', 9}
+    };
+    return multipliers.at(unit);
+}

lib/btclock/utils.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <cmath>
+#include <cstdint>
+#include <sstream>
+#include <iomanip>
+#include <unordered_map>
+
+
+int modulo(int x,int N);
+
+double getSupplyAtBlock(std::uint32_t blockNr);
+
+std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters = 4);
+std::string formatNumberWithSuffix(std::uint64_t num, int numCharacters, bool mowMode);
+int64_t getAmountInSatoshis(std::string bolt11);
+void parseHashrateString(const std::string& hashrate, std::string& label, std::string& output, unsigned int maxCharacters);
+int getHashrateMultiplier(char unit);
+int getDifficultyMultiplier(char unit);

lib/qrcode/qrcodegen.h

@@ -0,0 +1,389 @@
+/* 
+ * QR Code generator library (C)
+ * 
+ * Copyright (c) Project Nayuki. (MIT License)
+ * https://www.nayuki.io/page/qr-code-generator-library
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * - The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ * - The Software is provided "as is", without warranty of any kind, express or
+ *   implied, including but not limited to the warranties of merchantability,
+ *   fitness for a particular purpose and noninfringement. In no event shall the
+ *   authors or copyright holders be liable for any claim, damages or other
+ *   liability, whether in an action of contract, tort or otherwise, arising from,
+ *   out of or in connection with the Software or the use or other dealings in the
+ *   Software.
+ */
+#ifdef USE_QR
+
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* 
+ * This library creates QR Code symbols, which is a type of two-dimension barcode.
+ * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+ * A QR Code structure is an immutable square grid of dark and light cells.
+ * The library provides functions to create a QR Code from text or binary data.
+ * The library covers the QR Code Model 2 specification, supporting all versions (sizes)
+ * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+ * 
+ * Ways to create a QR Code object:
+ * - High level: Take the payload data and call qrcodegen_encodeText() or qrcodegen_encodeBinary().
+ * - Low level: Custom-make the list of segments and call
+ *   qrcodegen_encodeSegments() or qrcodegen_encodeSegmentsAdvanced().
+ * (Note that all ways require supplying the desired error correction level and various byte buffers.)
+ */
+
+
+/*---- Enum and struct types----*/
+
+/* 
+ * The error correction level in a QR Code symbol.
+ */
+enum qrcodegen_Ecc {
+	// Must be declared in ascending order of error protection
+	// so that an internal qrcodegen function works properly
+	qrcodegen_Ecc_LOW = 0 ,  // The QR Code can tolerate about  7% erroneous codewords
+	qrcodegen_Ecc_MEDIUM  ,  // The QR Code can tolerate about 15% erroneous codewords
+	qrcodegen_Ecc_QUARTILE,  // The QR Code can tolerate about 25% erroneous codewords
+	qrcodegen_Ecc_HIGH    ,  // The QR Code can tolerate about 30% erroneous codewords
+};
+
+
+/* 
+ * The mask pattern used in a QR Code symbol.
+ */
+enum qrcodegen_Mask {
+	// A special value to tell the QR Code encoder to
+	// automatically select an appropriate mask pattern
+	qrcodegen_Mask_AUTO = -1,
+	// The eight actual mask patterns
+	qrcodegen_Mask_0 = 0,
+	qrcodegen_Mask_1,
+	qrcodegen_Mask_2,
+	qrcodegen_Mask_3,
+	qrcodegen_Mask_4,
+	qrcodegen_Mask_5,
+	qrcodegen_Mask_6,
+	qrcodegen_Mask_7,
+};
+
+
+/* 
+ * Describes how a segment's data bits are interpreted.
+ */
+enum qrcodegen_Mode {
+	qrcodegen_Mode_NUMERIC      = 0x1,
+	qrcodegen_Mode_ALPHANUMERIC = 0x2,
+	qrcodegen_Mode_BYTE         = 0x4,
+	qrcodegen_Mode_KANJI        = 0x8,
+	qrcodegen_Mode_ECI          = 0x7,
+};
+
+
+/* 
+ * A segment of character/binary/control data in a QR Code symbol.
+ * The mid-level way to create a segment is to take the payload data
+ * and call a factory function such as qrcodegen_makeNumeric().
+ * The low-level way to create a segment is to custom-make the bit buffer
+ * and initialize a qrcodegen_Segment struct with appropriate values.
+ * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+ * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+ * Moreover, the maximum allowed bit length is 32767 because
+ * the largest QR Code (version 40) has 31329 modules.
+ */
+struct qrcodegen_Segment {
+	// The mode indicator of this segment.
+	enum qrcodegen_Mode mode;
+	
+	// The length of this segment's unencoded data. Measured in characters for
+	// numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+	// Always zero or positive. Not the same as the data's bit length.
+	int numChars;
+	
+	// The data bits of this segment, packed in bitwise big endian.
+	// Can be null if the bit length is zero.
+	uint8_t *data;
+	
+	// The number of valid data bits used in the buffer. Requires
+	// 0 <= bitLength <= 32767, and bitLength <= (capacity of data array) * 8.
+	// The character count (numChars) must agree with the mode and the bit buffer length.
+	int bitLength;
+};
+
+
+
+/*---- Macro constants and functions ----*/
+
+#define qrcodegen_VERSION_MIN   1  // The minimum version number supported in the QR Code Model 2 standard
+#define qrcodegen_VERSION_MAX  40  // The maximum version number supported in the QR Code Model 2 standard
+
+// Calculates the number of bytes needed to store any QR Code up to and including the given version number,
+// as a compile-time constant. For example, 'uint8_t buffer[qrcodegen_BUFFER_LEN_FOR_VERSION(25)];'
+// can store any single QR Code from version 1 to 25 (inclusive). The result fits in an int (or int16).
+// Requires qrcodegen_VERSION_MIN <= n <= qrcodegen_VERSION_MAX.
+#define qrcodegen_BUFFER_LEN_FOR_VERSION(n)  ((((n) * 4 + 17) * ((n) * 4 + 17) + 7) / 8 + 1)
+
+// The worst-case number of bytes needed to store one QR Code, up to and including
+// version 40. This value equals 3918, which is just under 4 kilobytes.
+// Use this more convenient value to avoid calculating tighter memory bounds for buffers.
+#define qrcodegen_BUFFER_LEN_MAX  qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX)
+
+
+
+/*---- Functions (high level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given text string to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * The input text must be encoded in UTF-8 and contain no NULs.
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code may use numeric,
+ * alphanumeric, or byte mode to encode the text.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC
+ * can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
+ * up to 4296 characters, or any digit string up to 7089 characters.
+ * These numbers represent the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/* 
+ * Encodes the given binary data to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
+ * - Before calling the function:
+ *   - The array ranges dataAndTemp[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The input array range dataAndTemp[0 : dataLen] should normally be
+ *     valid UTF-8 text, but is not required by the QR Code standard.
+ *   - The initial state of dataAndTemp[dataLen : len] and qrcode[0 : len]
+ *     can be uninitialized because the function always writes before reading.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - dataAndTemp contains no useful data and should be treated as entirely uninitialized.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * If successful, the resulting QR Code will use byte mode to encode the data.
+ * 
+ * In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
+ * sequence up to length 2953. This is the hard upper limit of the QR Code standard.
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ */
+bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
+	enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl);
+
+
+/*---- Functions (low level) to generate QR Codes ----*/
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version at the given ECC level,
+ * then false is returned.
+ * 
+ * The smallest possible QR Code version is automatically chosen for
+ * the output. The ECC level of the result may be higher than the
+ * ecl argument if it can be done without increasing the version.
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
+	enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Encodes the given segments to a QR Code, returning true if successful.
+ * If the data is too long to fit in any version in the given range
+ * at the given ECC level, then false is returned.
+ * 
+ * Requires 1 <= minVersion <= maxVersion <= 40.
+ * 
+ * The smallest possible QR Code version within the given range is automatically
+ * chosen for the output. Iff boostEcl is true, then the ECC level of the result
+ * may be higher than the ecl argument if it can be done without increasing the
+ * version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
+ * qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
+ * 
+ * About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
+ * - Before calling the function:
+ *   - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
+ *     reading and writing; hence each array must have a length of at least len.
+ *   - The two ranges must not overlap (aliasing).
+ *   - The initial state of both ranges can be uninitialized
+ *     because the function always writes before reading.
+ *   - The input array segs can contain segments whose data buffers overlap with tempBuffer.
+ * - After the function returns:
+ *   - Both ranges have no guarantee on which elements are initialized and what values are stored.
+ *   - tempBuffer contains no useful data and should be treated as entirely uninitialized.
+ *   - Any segment whose data buffer overlaps with tempBuffer[0 : len]
+ *     must be treated as having invalid values in that array.
+ *   - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
+ * 
+ * Please consult the QR Code specification for information on
+ * data capacities per version, ECC level, and text encoding mode.
+ * 
+ * This function allows the user to create a custom sequence of segments that switches
+ * between modes (such as alphanumeric and byte) to encode text in less space.
+ * This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
+ */
+bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
+	int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in numeric mode.
+ * A string is encodable iff each character is in the range 0 to 9.
+ */
+bool qrcodegen_isNumeric(const char *text);
+
+
+/* 
+ * Tests whether the given string can be encoded as a segment in alphanumeric mode.
+ * A string is encodable iff each character is in the following set: 0 to 9, A to Z
+ * (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+bool qrcodegen_isAlphanumeric(const char *text);
+
+
+/* 
+ * Returns the number of bytes (uint8_t) needed for the data buffer of a segment
+ * containing the given number of characters using the given mode. Notes:
+ * - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or the internal
+ *   calculation of the number of needed bits exceeds INT16_MAX (i.e. 32767).
+ * - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
+ * - It is okay for the user to allocate more bytes for the buffer than needed.
+ * - For byte mode, numChars measures the number of bytes, not Unicode code points.
+ * - For ECI mode, numChars must be 0, and the worst-case number of bytes is returned.
+ *   An actual ECI segment can have shorter data. For non-ECI modes, the result is exact.
+ */
+size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars);
+
+
+/* 
+ * Returns a segment representing the given binary data encoded in
+ * byte mode. All input byte arrays are acceptable. Any text string
+ * can be converted to UTF-8 bytes and encoded as a byte mode segment.
+ */
+struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given string of decimal digits encoded in numeric mode.
+ */
+struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing the given text string encoded in alphanumeric mode.
+ * The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+ * dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+ */
+struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]);
+
+
+/* 
+ * Returns a segment representing an Extended Channel Interpretation
+ * (ECI) designator with the given assignment value.
+ */
+struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]);
+
+
+/*---- Functions to extract raw data from QR Codes ----*/
+
+/* 
+ * Returns the side length of the given QR Code, assuming that encoding succeeded.
+ * The result is in the range [21, 177]. Note that the length of the array buffer
+ * is related to the side length - every 'uint8_t qrcode[]' must have length at least
+ * qrcodegen_BUFFER_LEN_FOR_VERSION(version), which equals ceil(size^2 / 8 + 1).
+ */
+int qrcodegen_getSize(const uint8_t qrcode[]);
+
+
+/* 
+ * Returns the color of the module (pixel) at the given coordinates, which is false
+ * for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+ * If the given coordinates are out of bounds, then false (light) is returned.
+ */
+bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

maintainers.yaml

@@ -0,0 +1,20 @@
+identifier: BTClock
+maintainers:
+- npub1k5f85zx0xdskyayqpfpc0zq6n7vwqjuuxugkayk72fgynp34cs3qfcvqg2
+relays:
+- wss://relay.noderunners.network/
+- wss://nostr.sathoarder.com/
+- wss://offchain.pub/
+- wss://nostr3.daedaluslabs.io/
+- wss://nostr4.daedaluslabs.io/
+- wss://nostr.dbtc.link/
+- wss://purplepag.es/
+- wss://nos.lol/
+- wss://nostr1.daedaluslabs.io/
+- wss://nostr.noderunners.network/
+- wss://nostr.lnbitcoin.cz/
+- wss://relay.primal.net/
+- wss://relay.damus.io
+- wss://nostr-relay.derekross.me/
+- wss://nostr2.azzamo.net/
+- wss://nostr2.daedaluslabs.io/

partition.csv

@@ -1,7 +1,7 @@
 # Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     36K,     20K,
-otadata,  data, ota,     56K,     8K,
-app0,     app,  ota_0,   64K,     3200K,
-#app1,     app,  ota_1,   ,        1600K,
-spiffs,   data, spiffs,  ,        600K,
-coredump, data, coredump,,        64K,
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x1b8000,
+app1,     app,  ota_1,   ,        0x1b8000,
+spiffs,   data, spiffs,  ,        0x66C00,
+coredump, data, coredump,,        0x10000,

partition_16mb.csv

@@ -0,0 +1,7 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x6F0000,
+app1,     app,  ota_1,   ,        0x6F0000,
+spiffs,   data, spiffs,  ,        0x200000,
+coredump, data, coredump,,        0x10000,

partition_8mb.csv

@@ -0,0 +1,7 @@
+# Name,   Type, SubType, Offset,  Size, Flags
+nvs,      data, nvs,     0x9000,  0x5000,
+otadata,  data, ota,     0xe000,  0x2000,
+app0,     app,  ota_0,   0x10000, 0x370000,
+app1,     app,  ota_1,   ,        0x370000,
+spiffs,   data, spiffs,  ,        0xCD000,
+coredump, data, coredump,,        0x10000,

platformio.ini

@@ -7,46 +7,194 @@
 ;
 ; Please visit documentation for the other options and examples
 ; https://docs.platformio.org/page/projectconf.html
+
 [platformio]
-data_dir = data/build
+data_dir = data/build_gz
+default_envs = lolin_s3_mini_213epd, lolin_s3_mini_29epd, btclock_rev_b_213epd, btclock_v8_213epd
 
 [env]
-platform = espressif32
-framework = arduino, espidf
-monitor_speed = 115200
-upload_speed = 921600
-monitor_filters = esp32_exception_decoder, colorize
-board_build.filesystem = littlefs
 
 [btclock_base]
-extra_scripts = post:scripts/extra_script.py
-board_build.partitions = partition.csv
+platform = espressif32 @ ^6.10.0
+framework = arduino, espidf
+monitor_speed = 115200
+monitor_filters = esp32_exception_decoder, colorize
+board_build.filesystem = littlefs
+extra_scripts = pre:scripts/pre_script.py, post:scripts/extra_script.py
+platform_packages = 
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower
+board_build.embed_files = 
+	x509_crt_bundle
 build_flags = 
-  !python scripts/git_rev.py
-  -DLAST_BUILD_TIME=$UNIX_TIME
-  -DARDUINO_USB_CDC_ON_BOOT
-  -fexceptions
+	!python scripts/git_rev.py
+	-DLAST_BUILD_TIME=$UNIX_TIME
+	-DARDUINO_USB_CDC_ON_BOOT
+	-DCORE_DEBUG_LEVEL=0
+	-D CONFIG_ASYNC_TCP_STACK_SIZE=16384
+	-fexceptions
 build_unflags = 
-  -Werror=all
-  -fno-exceptions
+	-Werror=all
+	-fno-exceptions
 lib_deps = 
-    bblanchon/ArduinoJson@^6.21.3
-    esphome/Improv@^1.2.3
-    esphome/ESPAsyncWebServer-esphome@^3.1.0
-    adafruit/Adafruit BusIO@^1.14.5
-    adafruit/Adafruit MCP23017 Arduino Library@^2.3.0
-    adafruit/Adafruit NeoPixel@^1.11.0
-    https://github.com/dsbaars/universal_pin
-    https://github.com/dsbaars/GxEPD2#universal_pin
+	https://github.com/joltwallet/esp_littlefs.git#v1.16.4
+	bblanchon/ArduinoJson@^7.3.0
+	esp32async/ESPAsyncWebServer @ 3.7.0
+	robtillaart/MCP23017@^0.9.0
+	adafruit/Adafruit NeoPixel@^1.12.4
+	https://github.com/dsbaars/universal_pin#feature/mcp23017_rt
+	https://github.com/dsbaars/GxEPD2#universal_pin
+	https://github.com/tzapu/WiFiManager.git#v2.0.17
+	https://github.com/dsbaars/nostrduino#feature/fix-btclock
 
 [env:lolin_s3_mini]
 extends = btclock_base
 board = lolin_s3_mini
+board_build.partitions = partition.csv
 build_flags = 
-    ${btclock_base.build_flags}
-    -D MCP_INT_PIN=8
-    -D NEOPIXEL_PIN=34
-    -D NEOPIXEL_COUNT=4
-    -D NUM_SCREENS=7
+	${btclock_base.build_flags}
+	-D MCP_INT_PIN=8
+	-D NEOPIXEL_PIN=34
+	-D NEOPIXEL_COUNT=4
+	-D NUM_SCREENS=7
+	-D I2C_SDA_PIN=35
+	-D I2C_SCK_PIN=36
+	-DARDUINO_USB_CDC_ON_BOOT=1
+	-D IS_HW_REV_A
 build_unflags = 
-  ${btclock_base.build_unflags}
+	${btclock_base.build_unflags}
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:btclock_rev_b]
+extends = btclock_base
+board = btclock_rev_b
+board_build.partitions = partition_8mb.csv
+build_flags = 
+	${btclock_base.build_flags}
+	-D MCP_INT_PIN=8
+	-D NEOPIXEL_PIN=15
+	-D NEOPIXEL_COUNT=4
+	-D NUM_SCREENS=7
+	-D I2C_SDA_PIN=35
+	-D I2C_SCK_PIN=36
+	-D HAS_FRONTLIGHT
+	-D PCA_OE_PIN=48
+	-D PCA_I2C_ADDR=0x42
+	-D IS_HW_REV_B
+
+lib_deps = 
+	${btclock_base.lib_deps}
+	robtillaart/PCA9685@^0.7.1
+	claws/BH1750@^1.3.0
+build_unflags = 
+	${btclock_base.build_unflags}
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:lolin_s3_mini_213epd]
+extends = env:lolin_s3_mini
+test_framework = unity
+build_flags = 
+	${env:lolin_s3_mini.build_flags}
+	-D USE_QR
+	-D VERSION_EPD_2_13
+	-D HW_REV=\"REV_A_EPD_2_13\"
+	-D CONFIG_ARDUINO_MAIN_TASK_STACK_SIZE=16384
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:btclock_rev_b_213epd]
+extends = env:btclock_rev_b
+test_framework = unity
+build_flags = 
+	${env:btclock_rev_b.build_flags}
+	-D USE_QR
+	-D VERSION_EPD_2_13
+	-D HW_REV=\"REV_B_EPD_2_13\"
+	-D CONFIG_ARDUINO_MAIN_TASK_STACK_SIZE=16384
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:lolin_s3_mini_29epd]
+extends = env:lolin_s3_mini
+test_framework = unity
+build_flags = 
+	${env:lolin_s3_mini.build_flags}
+	-D USE_QR
+	-D VERSION_EPD_2_9
+	-D HW_REV=\"REV_A_EPD_2_9\"
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:btclock_rev_b_29epd]
+extends = env:btclock_rev_b
+test_framework = unity
+build_flags = 
+	${env:btclock_rev_b.build_flags}
+	-D USE_QR
+	-D VERSION_EPD_2_9
+	-D HW_REV=\"REV_B_EPD_2_9\"
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:btclock_v8]
+extends = btclock_base
+board = btclock_v8
+board_build.partitions = partition_16mb.csv
+board_build.flash_mode = qio
+test_framework = unity
+build_flags = 
+	${btclock_base.build_flags}
+	-D MCP_INT_PIN=4
+	-D NEOPIXEL_PIN=5
+	-D NEOPIXEL_COUNT=4
+	-D NUM_SCREENS=8
+	-D SPI_SDA_PIN=11
+	-D SPI_SCK_PIN=12
+	-D I2C_SDA_PIN=1
+	-D I2C_SCK_PIN=2
+	-D MCP_RESET_PIN=21
+	-D MCP1_A0_PIN=6
+	-D MCP1_A1_PIN=7
+	-D MCP1_A2_PIN=8
+	-D MCP2_A0_PIN=9
+	-D MCP2_A1_PIN=10
+	-D MCP2_A2_PIN=14
+build_unflags = 
+	${btclock_base.build_unflags}
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:btclock_v8_213epd]
+extends = env:btclock_v8
+test_framework = unity
+build_flags = 
+	${env:btclock_v8.build_flags}
+	-D USE_QR
+	-D VERSION_EPD_2_13
+	-D HW_REV=\"REV_V8_EPD_2_13\"
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216
+
+[env:native_test_only]
+platform = native
+test_framework = unity
+build_flags = 
+	${btclock_base.build_flags}
+	-D MCP_INT_PIN=8
+	-D NEOPIXEL_PIN=34
+	-D NEOPIXEL_COUNT=4
+	-D NUM_SCREENS=7
+	-D UNITY_TEST
+	-std=gnu++17
+platform_packages = 
+	platformio/tool-mklittlefs@^1.203.210628
+	earlephilhower/tool-mklittlefs-rp2040-earlephilhower@^5.100300.230216

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

requirements.txt

@@ -0,0 +1 @@
+platformio

scripts/extra_script.py

@@ -1,7 +1,125 @@
 Import("env")
+import os
+import gzip
+from shutil import copyfileobj, rmtree, copyfile, copytree
+from pathlib import Path
+import subprocess
+
+
+
+
+revision = (
+    subprocess.check_output(["git", "rev-parse", "HEAD"])
+    .strip()
+    .decode("utf-8")
+)
+
+def gzip_file(input_file, output_file):
+    with open(input_file, 'rb') as f_in:
+        with gzip.open(output_file, 'wb') as f_out:
+            copyfileobj(f_in, f_out)
+
+def process_directory(input_dir, output_dir):
+    if os.path.exists(output_dir):
+        rmtree(output_dir)
+    for root, dirs, files in os.walk(input_dir):
+        relative_path = os.path.relpath(root, input_dir)
+        output_root = os.path.join(output_dir, relative_path)
+
+        Path(output_root).mkdir(parents=True, exist_ok=True)
+
+        for file in files:
+#            if not file.endswith(('.bin')):
+                input_file_path = os.path.join(root, file)
+                output_file_path = os.path.join(output_root, file + '.gz')
+                gzip_file(input_file_path, output_file_path)
+                print(f'Compressed: {input_file_path} -> {output_file_path}')
+    file_path = os.path.join(output_dir, "fs_hash.txt")
+    with open(file_path, "w") as file:
+        file.write(revision)
+
 
 # Build web interface before building FS
 def before_buildfs(source, target, env):
-    env.Execute("cd data && yarn && yarn build")
 
-env.AddPreAction("$BUILD_DIR/littlefs.bin", before_buildfs)
+    env.Execute("cd data && yarn && yarn postinstall && yarn build")
+    input_directory = 'data/dist'
+    output_directory = 'data/build_gz'
+#    copytree("assets", "data/dist/assets")
+
+    process_directory(input_directory, output_directory)
+
+def get_fs_partition_size(env):
+    import csv
+    
+    # Get partition table path - first try custom, then default
+    board_config = env.BoardConfig()
+    partition_table = board_config.get("build.partitions", "default.csv")
+    
+    # Handle default partition table path
+    if partition_table == "default.csv" or partition_table == "huge_app.csv":
+        partition_table = os.path.join(env.PioPlatform().get_package_dir("framework-arduinoespressif32"), 
+                                     "tools", "partitions", partition_table)
+    
+    # Parse CSV to find spiffs/littlefs partition
+    with open(partition_table, 'r') as f:
+        for row in csv.reader(f):
+            if len(row) < 5:
+                continue
+            # Remove comments and whitespace
+            row = [cell.strip().split('#')[0] for cell in row]
+            # Check if this is a spiffs or littlefs partition
+            if row[0].startswith(('spiffs', 'littlefs')):
+                # Size is in hex format
+                return int(row[4], 16)
+    return 0
+
+def get_littlefs_used_size(binary_path):  
+    mklittlefs_path = os.path.join(env.PioPlatform().get_package_dir("tool-mklittlefs-rp2040-earlephilhower"), "mklittlefs")
+
+    try:
+        result = subprocess.run([mklittlefs_path, '-l', binary_path], capture_output=True, text=True)
+                
+        if result.returncode == 0:
+            # Parse the output to sum up file sizes
+            total_size = 0
+            for line in result.stdout.splitlines():
+                if line.strip() and not line.startswith('<dir>') and not line.startswith('Creation'): 
+                    # Each line format: size filename
+                    size = line.split()[0]
+                    total_size += int(size)
+            return total_size
+    except Exception as e:
+        print(f"Error getting filesystem size: {e}")
+    return 0
+
+ 
+def after_littlefs(source, target, env):
+    binary_path = str(target[0])
+    partition_size = get_fs_partition_size(env)
+    used_size = get_littlefs_used_size(binary_path)
+    
+    percentage = (used_size / partition_size) * 100
+    bar_width = 50
+    filled = int(bar_width * percentage / 100)
+    bar = '=' * filled + '-' * (bar_width - filled)
+    
+    print(f"\nLittleFS Actual Usage: [{bar}] {percentage:.1f}% ({used_size}/{partition_size} bytes)")
+
+
+flash_size = env.BoardConfig().get("upload.flash_size", "4MB")
+fs_image_name = f"littlefs_{flash_size}"
+env.Replace(ESP32_FS_IMAGE_NAME=fs_image_name)
+env.Replace(ESP8266_FS_IMAGE_NAME=fs_image_name)
+
+os.environ["PUBLIC_BASE_URL"] = ""
+fs_name = env.get("ESP32_FS_IMAGE_NAME", "littlefs.bin")
+# Or alternatively:
+# fs_name = env.get("FSTOOLNAME", "littlefs.bin")
+
+# Use the variable in the pre-action
+env.AddPreAction(f"$BUILD_DIR/{fs_name}.bin", before_buildfs)
+env.AddPostAction(f"$BUILD_DIR/{fs_name}.bin", after_littlefs)
+# LittleFS Actual Usage: [==============================--------------------] 60.4% (254165/420864 bytes)
+# LittleFS Actual Usage: [==============================--------------------] 60.2% (253476/420864 bytes)
+# 372736 used

scripts/find_btclocks.py

@@ -0,0 +1,86 @@
+import sys
+import os
+import logging
+
+from os.path import expanduser
+
+sys.path.append(expanduser("~") + '/.platformio/packages/framework-arduinoespressif32/tools') 
+
+from zeroconf import ServiceBrowser, ServiceListener, Zeroconf
+from requests import request
+import espota
+import argparse
+import random
+import subprocess
+
+FLASH = 0
+SPIFFS = 100
+
+PROGRESS = True
+TIMEOUT = 10
+
+revision = (
+    subprocess.check_output(["git", "rev-parse", "HEAD"])
+    .strip()
+    .decode("utf-8")
+)
+
+class Listener(ServiceListener):
+ 
+    def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        print(f"Service {name} updated")
+
+    def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        print(f"Service {name} removed")
+
+    def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+        global PROGRESS
+        PROGRESS = True
+        espota.PROGRESS = True
+        global TIMEOUT
+        TIMEOUT = 10
+        espota.TIMEOUT = 10
+        info = zc.get_service_info(type_, name)
+        if (name.startswith('btclock-')):
+            print(f"Service {name} added")
+            print("Address: " + str(info.parsed_addresses()))
+            # python  ~/.platformio/packages/framework-arduinoespressif32/tools/espota.py -i 192.168.20.231 -f .pio/build/lolin_s3_mini_qr/firmware.bin -r
+            #arguments = [f"-i {str()} -f  -r"]
+            namespace = argparse.Namespace(
+                esp_ip=info.parsed_addresses()[0], 
+                image=f"{os.getcwd()}/.pio/build/lolin_s3_mini_213epd/firmware.bin",
+                littlefs=f"{os.getcwd()}/.pio/build/lolin_s3_mini_213epd/littlefs.bin",
+                progress=True
+                )
+            if (str(info.properties.get(b"version").decode())) != "3.0":
+                print("Too old version")
+                return
+
+            if (str(info.properties.get(b"rev").decode())) == revision:
+                print("Newest version, skipping but updating LittleFS")
+                espota.serve(namespace.esp_ip, "0.0.0.0", 3232, random.randint(10000,60000), "", namespace.littlefs, SPIFFS)
+
+            else:
+                print("Different version, going to update")
+                #espota.serve(namespace.esp_ip, "0.0.0.0", 3232, random.randint(10000,60000), "", namespace.littlefs, SPIFFS)
+
+                espota.serve(namespace.esp_ip, "0.0.0.0", 3232, random.randint(10000,60000), "", namespace.image, FLASH)
+            #print(arguments)
+            
+            #logging.basicConfig(level = logging.DEBUG, format = '%(asctime)-8s [%(levelname)s]: %(message)s', datefmt = '%H:%M:%S')
+                    
+            #espota.serve(namespace.esp_ip, "0.0.0.0", 3232, random.randint(10000,60000), "", namespace.image, FLASH)
+            #address = "http://" + info.parsed_addresses()[0]+"/api/restart"
+            #response = request("GET", address)
+            #espota.main(namespace)
+
+zconf = Zeroconf()
+ 
+serviceListener = Listener()
+ 
+browser = ServiceBrowser(zconf, "_http._tcp.local.", serviceListener)
+
+try:
+    input("Press enter to exit...\n\n")
+finally:
+    zconf.close()

scripts/git_rev.py

@@ -5,4 +5,17 @@ revision = (
     .strip()
     .decode("utf-8")
 )
+
+try:
+    tag = (
+        subprocess.check_output(["git", "describe", "--tags", "--exact-match"])
+        .strip()
+        .decode("utf-8")
+    )
+    git_tag_define = '\'-DGIT_TAG=\"%s\"\'' % tag
+except subprocess.CalledProcessError:
+    git_tag_define = ''
+    
 print("'-DGIT_REV=\"%s\"'" % revision)
+if git_tag_define:
+    print(git_tag_define)

scripts/hash.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+data_directory="data/build"
+
+# Use find to list all files in the directory (including hidden files), sort them, and then calculate the hash
+#hash=$(find "$data_directory" -type f \( ! -iname ".*" \) | LC_ALL=C  sort | xargs cat  | shasum -a 256 | cut -d ' ' -f 1)
+hash=$(find "$data_directory" -type f \( ! -iname ".*" \) | LC_ALL=C sort | xargs -I {} cat {} | shasum -a 256 | cut -d ' ' -f 1)
+
+echo "Hash of files in $data_directory: $hash"

scripts/hash_fsdata.py

@@ -0,0 +1,75 @@
+import os
+from pathlib import Path
+import hashlib
+
+def calculate_file_hash(file_path):
+    hasher = hashlib.sha256()
+    with open(file_path, 'rb') as file:
+        for chunk in iter(lambda: file.read(4096), b''):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+# def calculate_directory_hash(directory_path):
+#     file_hashes = []
+#     for root, dirs, files in os.walk(directory_path):
+#         for file_name in sorted(files):  # Sorting based on filenames
+#             if not file_name.startswith('.'):  # Skip dotfiles
+#                 file_path = os.path.join(root, file_name)
+#                 file_hash = calculate_file_hash(file_path)
+#                 file_hashes.append((file_path, file_hash))
+
+#     combined_hash = hashlib.sha256()
+#     for file_path, _ in sorted(file_hashes):  # Sorting based on filenames
+#         print(f"{file_path}: {file_hash}")
+#         file_hash = calculate_file_hash(file_path)
+#         combined_hash.update(file_hash.encode('utf-8'))
+
+#     return combined_hash.hexdigest()
+
+
+# def calculate_directory_hash(directory_path):
+#     combined_hash = hashlib.sha256()
+#     for root, dirs, files in os.walk(directory_path):
+#         for file_name in sorted(files):  # Sorting based on filenames
+#             if not file_name.startswith('.'):  # Skip dotfiles
+#                 file_path = os.path.join(root, file_name)
+#                 with open(file_path, 'rb') as file:
+#                     print(f"{file_path}")
+#                     for chunk in iter(lambda: file.read(4096), b''):
+#                         combined_hash.update(chunk)
+
+#     return combined_hash.hexdigest()
+
+# def calculate_directory_hash(directory_path):
+#     combined_content = b''
+#     for root, dirs, files in os.walk(directory_path):
+#         for file_name in sorted(files):  # Sorting based on filenames
+#             if not file_name.startswith('.'):  # Skip dotfiles
+#                 file_path = os.path.join(root, file_name)
+#                 with open(file_path, 'rb') as file:
+#                     print(f"{file_path}")
+#                     combined_content += file.read()
+
+#     combined_hash = hashlib.sha256(combined_content).hexdigest()
+#     return combined_hash
+
+def calculate_directory_hash(directory_path):
+    file_paths = []
+    for root, dirs, files in os.walk(directory_path):
+        for file_name in files:
+            if not file_name.startswith('.'):  # Skip dotfiles
+                file_paths.append(os.path.join(root, file_name))
+
+    combined_content = b''
+    for file_path in sorted(file_paths):  # Sorting based on filenames
+        with open(file_path, 'rb') as file:
+            print(f"{file_path}")
+            combined_content += file.read()
+
+    combined_hash = hashlib.sha256(combined_content).hexdigest()
+    return combined_hash
+
+data_directory = 'data/build'
+directory_hash = calculate_directory_hash(data_directory)
+
+print(f"Hash of files in {data_directory}: {directory_hash}")

scripts/pre_script.py

@@ -0,0 +1,7 @@
+Import("env")
+
+flash_size = env.BoardConfig().get("upload.flash_size", "4MB")
+fs_image_name = f"littlefs_{flash_size}"
+env.Replace(ESP32_FS_IMAGE_NAME=fs_image_name)
+env.Replace(ESP8266_FS_IMAGE_NAME=fs_image_name)
+

sdkconfig.defaults

@@ -4,27 +4,45 @@ CONFIG_FREERTOS_HZ=1000
 CONFIG_MBEDTLS_PSK_MODES=y
 CONFIG_MBEDTLS_KEY_EXCHANGE_PSK=y
 
-CONFIG_FREERTOS_USE_TRACE_FACILITY=n
-CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=n
-CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=n
-CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=n
-CONFIG_ESP_TLS_INSECURE=y
-CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY=y
+#CONFIG_FREERTOS_USE_TRACE_FACILITY=y
+#CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=y
+#CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=n 
+#CONFIG_ESP_TLS_INSECURE=y
+#CONFIG_ESP_TLS_SKIP_SERVER_CERT_VERIFY=y
 
 CONFIG_HEAP_CORRUPTION_DETECTION=CONFIG_HEAP_POISONING_LIGHT
 CONFIG_HEAP_POISONING_LIGHT=y
 
 CONFIG_ESP32S3_SPIRAM_SUPPORT=y
+CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y 
 CONFIG_BOOTLOADER_LOG_LEVEL=0
-CONFIG_LOG_BOOTLOADER_LEVEL_NONE=y
 CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
 CONFIG_ESP32S3_SPIRAM_SUPPORT=y
 CONFIG_LOG_DEFAULT_LEVEL_NONE=y
 CONFIG_LOG_DEFAULT_LEVEL=0
 CONFIG_LOG_MAXIMUM_LEVEL=0
-CONFIG_LOG_BOOTLOADER_LEVEL_NONE=y
-CONFIG_LOG_BOOTLOADER_LEVEL=0
-CONFIG_CXX_EXCEPTIONS=y
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
 #CONFIG_BOOTLOADER_WDT_ENABLE=n
-#CONFIG_TASK_WDT=n
+#CONFIG_ESP_TASK_WDT=n
+
+#Required for BTClock
+#CONFIG_SPIRAM_MODE_OCT=y
+#CONFIG_SPIRAM_MODE_QUAD=n
+
+# Save RAM
+CONFIG_LWIP_IPV4=y
+CONFIG_LWIP_IPV6=y
+CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=6
+CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=12
+CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM=12
+CONFIG_ESP32_WIFI_RX_BA_WIN=6
+
+CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=3120
+CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_240=y
+CONFIG_RTC_CLK_CAL_CYCLES=576
+CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=y
+CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH=3120
+CONFIG_ESP_SYSTEM_MEMPROT_FEATURE=n
+CONFIG_SPIRAM_CACHE_WORKAROUND=y
+CONFIG_COMPILER_OPTIMIZATION_SIZE=y
+#CONFIG_NEWLIB_NANO_FORMAT=y

src/CMakeLists.txt

@@ -1,4 +1,4 @@
 FILE(GLOB_RECURSE app_sources ${CMAKE_SOURCE_DIR}/src/*.*)
 
 idf_component_register(SRCS ${app_sources})
-target_compile_options(${COMPONENT_LIB} PRIVATE -std=gnu++11)
+target_compile_options(${COMPONENT_LIB} PRIVATE -std=gnu++17)

src/fonts/antonio-semibold20.h

@@ -1,482 +1,296 @@
-const uint8_t Antonio_SemiBold20pt7bBitmaps[] PROGMEM = {
-  0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x66, 0x66, 0x66,
-  0x66, 0x66, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7B, 0xDE, 0xF7,
-  0x98, 0xC6, 0x00, 0x03, 0x8F, 0x01, 0xC7, 0x80, 0xE3, 0x80, 0xF1, 0xC0,
-  0x70, 0xE0, 0x38, 0x70, 0x1C, 0x78, 0x0E, 0x3C, 0x07, 0x1C, 0x07, 0x8E,
-  0x03, 0x87, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x38, 0xE0, 0x3C,
-  0x70, 0x1E, 0x38, 0x0E, 0x1C, 0x07, 0x0E, 0x03, 0x8F, 0x0F, 0xFF, 0xF7,
-  0xFF, 0xF8, 0xF1, 0xC0, 0x70, 0xE0, 0x38, 0x70, 0x1C, 0x78, 0x0E, 0x3C,
-  0x0F, 0x1C, 0x07, 0x8E, 0x03, 0x87, 0x01, 0xC3, 0x80, 0xE3, 0xC0, 0x71,
-  0xE0, 0x78, 0xE0, 0x00, 0x06, 0x00, 0x30, 0x01, 0x80, 0x0C, 0x00, 0x60,
-  0x1F, 0xC1, 0xFF, 0x9F, 0xFC, 0xFB, 0xF7, 0x87, 0xBC, 0x3D, 0xE1, 0xEF,
-  0x0F, 0x78, 0x7B, 0xE3, 0xDF, 0x00, 0x7C, 0x01, 0xF8, 0x0F, 0xE0, 0x3F,
-  0x80, 0x7C, 0x01, 0xF0, 0x07, 0xC0, 0x3E, 0xF0, 0xF7, 0x87, 0xFC, 0x3F,
-  0xE1, 0xFF, 0x0F, 0xFC, 0x7B, 0xFF, 0xCF, 0xFE, 0x3F, 0xE0, 0xFE, 0x01,
-  0xC0, 0x0E, 0x00, 0x70, 0x03, 0x80, 0x1C, 0x00, 0x1F, 0x80, 0x01, 0xC0,
-  0x07, 0xFE, 0x00, 0x3C, 0x00, 0x7F, 0xE0, 0x03, 0xC0, 0x0F, 0x9F, 0x00,
-  0x38, 0x00, 0xF0, 0xF0, 0x07, 0x80, 0x0F, 0x0F, 0x00, 0x70, 0x00, 0xF0,
-  0xF0, 0x0F, 0x00, 0x0F, 0x0F, 0x00, 0xF0, 0x00, 0xF0, 0xF0, 0x0E, 0x00,
-  0x0F, 0x0F, 0x01, 0xE0, 0x00, 0xF0, 0xF0, 0x1C, 0x00, 0x0F, 0x0F, 0x03,
-  0xC0, 0x60, 0xF0, 0xF0, 0x3C, 0x3F, 0xCF, 0x0F, 0x03, 0x87, 0xFE, 0xF0,
-  0xF0, 0x78, 0xFF, 0xEF, 0x0F, 0x07, 0x8F, 0x0E, 0xF0, 0xF0, 0xF0, 0xF0,
-  0xFF, 0x0F, 0x0F, 0x0E, 0x0F, 0xF0, 0xF0, 0xE0, 0xE0, 0xF7, 0xDF, 0x1E,
-  0x0E, 0x0F, 0x7F, 0xE1, 0xE0, 0xE0, 0xF3, 0xFC, 0x1C, 0x0E, 0x0F, 0x1F,
-  0x83, 0xC0, 0xE0, 0xF0, 0x00, 0x38, 0x0E, 0x0F, 0x00, 0x07, 0x80, 0xE0,
-  0xF0, 0x00, 0x78, 0x0E, 0x0F, 0x00, 0x07, 0x00, 0xE0, 0xF0, 0x00, 0xF0,
-  0x0E, 0x0F, 0x00, 0x0E, 0x00, 0xE0, 0xF0, 0x01, 0xE0, 0x0F, 0x0F, 0x00,
-  0x1E, 0x00, 0xF1, 0xE0, 0x01, 0xC0, 0x0F, 0xFE, 0x00, 0x3C, 0x00, 0x7F,
-  0xC0, 0x03, 0x80, 0x03, 0xF8, 0x03, 0xE0, 0x03, 0xFE, 0x00, 0xFF, 0x80,
-  0x7C, 0xF0, 0x1E, 0x1C, 0x07, 0x87, 0x01, 0xE1, 0xC0, 0x78, 0x70, 0x1E,
-  0x1C, 0x07, 0x8F, 0x00, 0xF3, 0x80, 0x3D, 0xE0, 0x0F, 0x78, 0x01, 0xFC,
-  0x00, 0x7E, 0x00, 0x1F, 0x80, 0x07, 0xC0, 0x03, 0xF0, 0x00, 0xFE, 0x08,
-  0x7F, 0x86, 0x3F, 0xE3, 0x8F, 0x3C, 0xF7, 0x8F, 0x79, 0xE1, 0xFC, 0x78,
-  0x7F, 0x3C, 0x1F, 0x8F, 0x03, 0xE3, 0xC0, 0xF0, 0xF0, 0x3E, 0x1E, 0x1F,
-  0x87, 0xFF, 0xF1, 0xFF, 0xFC, 0x3F, 0xE7, 0x87, 0xF1, 0xE0, 0xFF, 0xFF,
-  0xF7, 0x76, 0x66, 0x66, 0x3E, 0xFF, 0xFF, 0xCF, 0x1E, 0x3C, 0x78, 0xF1,
-  0xE3, 0xC7, 0x8F, 0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC7, 0x8F, 0x1E, 0x3C,
-  0x78, 0xF1, 0xE3, 0xC7, 0x8F, 0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xFB, 0xF7,
-  0xE1, 0xC0, 0xF1, 0xF3, 0xF1, 0xE3, 0xC7, 0xCF, 0x9F, 0x3E, 0x7C, 0xF9,
-  0xF3, 0xE7, 0xCF, 0x9F, 0x3E, 0x7C, 0xF9, 0xF3, 0xE7, 0xCF, 0x9F, 0x3E,
-  0x7C, 0xF9, 0xF3, 0xE7, 0xCF, 0x9F, 0x3E, 0x7B, 0xF7, 0xEF, 0x98, 0x00,
-  0x07, 0x00, 0x1C, 0x04, 0x71, 0x39, 0xCE, 0xFB, 0x7D, 0xFF, 0xC1, 0xFC,
-  0x03, 0xE0, 0x3F, 0xE3, 0xEF, 0xFF, 0x73, 0x99, 0xC6, 0x07, 0x08, 0x1C,
-  0x00, 0x70, 0x00, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xF0, 0xF0, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0xFF, 0xFF, 0xFF,
-  0x8C, 0xE7, 0x31, 0x9C, 0xC0, 0xFF, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0x00,
-  0xF8, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0E, 0x00, 0xF0, 0x07, 0x80, 0x3C,
-  0x01, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x38, 0x03, 0xC0, 0x1E, 0x00,
-  0xF0, 0x07, 0x80, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x0F, 0x00, 0x78,
-  0x03, 0xC0, 0x1E, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x3C, 0x01,
-  0xE0, 0x0F, 0x00, 0x78, 0x07, 0x80, 0x00, 0x0F, 0xC1, 0xFF, 0x9F, 0xFC,
-  0xFF, 0xF7, 0x8F, 0xFC, 0x3F, 0xE1, 0xFF, 0x0F, 0xF8, 0x7F, 0xC3, 0xFE,
-  0x1F, 0xF0, 0xFF, 0x87, 0xFC, 0x3F, 0xE1, 0xFF, 0x0F, 0xF8, 0x7F, 0xC3,
-  0xFE, 0x1F, 0xF0, 0xFF, 0x87, 0xFC, 0x3F, 0xE1, 0xFF, 0x0F, 0xF8, 0x7F,
-  0xC3, 0xFE, 0x1F, 0xF0, 0xFF, 0x87, 0xBC, 0x7D, 0xF7, 0xEF, 0xFE, 0x3F,
-  0xF0, 0xFF, 0x00, 0x03, 0x83, 0xC3, 0xE3, 0xFF, 0xFF, 0xFF, 0xFF, 0x9F,
-  0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3,
-  0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8,
-  0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC0, 0x0F, 0x81, 0xFF, 0x1F, 0xF8, 0xFF,
-  0xEF, 0x8F, 0x7C, 0x7B, 0xC3, 0xDE, 0x1E, 0xF0, 0xFF, 0x87, 0xFC, 0x3F,
-  0xE1, 0xEF, 0x0F, 0x78, 0x78, 0x07, 0xC0, 0x3C, 0x03, 0xE0, 0x1E, 0x01,
-  0xF0, 0x0F, 0x00, 0xF8, 0x07, 0x80, 0x7C, 0x07, 0xC0, 0x3E, 0x03, 0xE0,
-  0x1F, 0x00, 0xF0, 0x07, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0xFE, 0xFF, 0xF7,
-  0xFF, 0x80, 0x0F, 0xC0, 0xFF, 0x87, 0xFF, 0x1F, 0xFE, 0x78, 0xFB, 0xE1,
-  0xEF, 0x87, 0xBC, 0x1E, 0xF0, 0x7B, 0xC1, 0xE0, 0x07, 0x80, 0x1E, 0x00,
-  0x78, 0x03, 0xE0, 0x3F, 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0xC0, 0x0F, 0x00,
-  0x3E, 0x00, 0x78, 0x01, 0xE0, 0x07, 0xBC, 0x1E, 0xF0, 0x7F, 0xC1, 0xFF,
-  0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xE1, 0xE7, 0xDF, 0x9F, 0xFC, 0x3F, 0xE0,
-  0x7F, 0x00, 0x01, 0xF0, 0x07, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x1F,
-  0xC0, 0x7F, 0x01, 0xFC, 0x06, 0xF0, 0x3B, 0xC0, 0xEF, 0x03, 0xBC, 0x1C,
-  0xF0, 0x73, 0xC1, 0xCF, 0x0F, 0x3C, 0x38, 0xF0, 0xE3, 0xC7, 0x8F, 0x1C,
-  0x3C, 0x70, 0xF1, 0xC3, 0xCF, 0x0F, 0x38, 0x3C, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0,
-  0x03, 0xC0, 0xFF, 0xEF, 0xFE, 0xFF, 0xEF, 0xFE, 0xF0, 0x0F, 0x00, 0xF0,
-  0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xF3, 0x0F, 0xFC, 0xFF, 0xEF, 0xFE, 0xF9,
-  0xEF, 0x1F, 0xF0, 0xF1, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x0F, 0x00,
-  0xF0, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x1F, 0xFB,
-  0xEF, 0xFE, 0x7F, 0xC3, 0xF8, 0x0F, 0xC0, 0xFF, 0x83, 0xFF, 0x1F, 0xFC,
-  0x78, 0xF9, 0xE1, 0xEF, 0x87, 0xBE, 0x1E, 0xF8, 0x7B, 0xE1, 0xEF, 0x80,
-  0x3E, 0x00, 0xF8, 0x03, 0xEF, 0x8F, 0xFF, 0x3F, 0xFE, 0xFF, 0xFB, 0xE1,
-  0xEF, 0x87, 0xBE, 0x1E, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8,
-  0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x79, 0xE1, 0xE7, 0xFF, 0x9F,
-  0xFE, 0x3F, 0xF0, 0x7F, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0x00, 0x7C, 0x01, 0xE0, 0x0F, 0x80, 0x3C, 0x00, 0xF0, 0x07, 0xC0, 0x1E,
-  0x00, 0x78, 0x03, 0xE0, 0x0F, 0x80, 0x3C, 0x00, 0xF0, 0x07, 0xC0, 0x1E,
-  0x00, 0x78, 0x03, 0xE0, 0x0F, 0x80, 0x3C, 0x00, 0xF0, 0x07, 0xC0, 0x1F,
-  0x00, 0x7C, 0x01, 0xF0, 0x07, 0x80, 0x1E, 0x00, 0xF8, 0x03, 0xE0, 0x0F,
-  0x80, 0x3E, 0x00, 0xF8, 0x00, 0x1F, 0xC1, 0xFF, 0x1F, 0xFC, 0xFB, 0xFF,
-  0x8F, 0xFC, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0,
-  0xFF, 0x87, 0xBC, 0x79, 0xFF, 0xC7, 0xFC, 0x3F, 0xE3, 0xFF, 0x9E, 0x3D,
-  0xF1, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC,
-  0x1F, 0xE0, 0xFF, 0x07, 0xFC, 0x3F, 0xF7, 0xEF, 0xFE, 0x3F, 0xF0, 0xFE,
-  0x00, 0x1F, 0x81, 0xFF, 0x1F, 0xFD, 0xFF, 0xEF, 0x8F, 0x78, 0x7F, 0xC3,
-  0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F,
-  0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0xC7, 0xDF, 0xFE, 0xFF, 0xF3, 0xFF, 0x80,
-  0x3C, 0x01, 0xE0, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x0F,
-  0xFC, 0x79, 0xF7, 0xCF, 0xFE, 0x3F, 0xE0, 0xFE, 0x00, 0xFF, 0xFF, 0xF0,
-  0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xF3, 0x9C, 0xCE, 0x73, 0x98,
-  0x00, 0x20, 0x0C, 0x07, 0x81, 0xF0, 0xFE, 0x3F, 0x9F, 0xC7, 0xF0, 0xF8,
-  0x1C, 0x03, 0xE0, 0x7E, 0x07, 0xF0, 0x3F, 0x03, 0xF8, 0x1F, 0x01, 0xE0,
-  0x0C, 0x00, 0x80, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x0F, 0xFF,
-  0xFF, 0xFF, 0xC0, 0x80, 0x18, 0x03, 0x80, 0x7C, 0x0F, 0xC0, 0xFE, 0x07,
-  0xF0, 0x7F, 0x03, 0xE0, 0x3C, 0x0F, 0x83, 0xF1, 0xFC, 0xFE, 0x3F, 0x87,
-  0xC0, 0xF0, 0x18, 0x02, 0x00, 0x00, 0x1F, 0x87, 0xFC, 0x7F, 0xEF, 0xFE,
-  0xF1, 0xEF, 0x1F, 0xF1, 0xFF, 0x1F, 0xF1, 0xFF, 0x1F, 0xF1, 0xFF, 0x1F,
-  0x01, 0xF0, 0x1E, 0x01, 0xE0, 0x3E, 0x03, 0xE0, 0xFC, 0x3F, 0x83, 0xF0,
-  0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x00, 0x3F, 0x80,
-  0x00, 0xFF, 0xF0, 0x00, 0xFF, 0xFC, 0x00, 0xF8, 0x0F, 0x00, 0xF0, 0x03,
-  0xC0, 0xF0, 0x00, 0xF0, 0xF0, 0x00, 0x38, 0x78, 0x00, 0x1C, 0x38, 0x1F,
-  0x87, 0x3C, 0x3F, 0xE3, 0x9E, 0x1E, 0xF1, 0xCE, 0x1C, 0x38, 0xE7, 0x0E,
-  0x1C, 0x77, 0x8E, 0x0E, 0x1F, 0xC7, 0x07, 0x0F, 0xE3, 0x83, 0x87, 0xF1,
-  0xC1, 0xC3, 0xF8, 0xE0, 0xE1, 0xFC, 0x70, 0x70, 0xFE, 0x38, 0x38, 0x7F,
-  0x1C, 0x1C, 0x77, 0x8E, 0x0E, 0x39, 0xC7, 0x07, 0x1C, 0xE3, 0xC7, 0xCE,
-  0x70, 0xF6, 0xFE, 0x3C, 0x7F, 0x3F, 0x1E, 0x1F, 0x0F, 0x07, 0x81, 0x00,
-  0x03, 0xC0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x1F, 0x80,
-  0x70, 0x07, 0xFF, 0xF8, 0x00, 0xFF, 0xFE, 0x00, 0x1F, 0xF0, 0x00, 0x07,
-  0xC0, 0x07, 0xE0, 0x0F, 0xE0, 0x0F, 0xE0, 0x0F, 0xE0, 0x0F, 0xE0, 0x0F,
-  0xE0, 0x0F, 0xF0, 0x0E, 0xF0, 0x1E, 0xF0, 0x1E, 0xF0, 0x1E, 0xF0, 0x1E,
-  0xF0, 0x1E, 0x70, 0x1E, 0x78, 0x1C, 0x78, 0x3C, 0x78, 0x3C, 0x78, 0x3C,
-  0x78, 0x3C, 0x78, 0x3C, 0x3C, 0x3C, 0x3C, 0x7C, 0x3C, 0x78, 0x3C, 0x7F,
-  0xFC, 0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFE, 0x78, 0x1E, 0xF8, 0x1E, 0xF8,
-  0x1E, 0xF0, 0x1E, 0xF0, 0x1F, 0xF0, 0x1F, 0xFF, 0x03, 0xFF, 0x8F, 0xFF,
-  0x3F, 0xFC, 0xF0, 0xFB, 0xC3, 0xEF, 0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xC1,
-  0xEF, 0x07, 0xBC, 0x3E, 0xF0, 0xFB, 0xC3, 0xCF, 0xFF, 0x3F, 0xF8, 0xFF,
-  0xF3, 0xFF, 0xCF, 0x0F, 0xBC, 0x1E, 0xF0, 0x7B, 0xC1, 0xEF, 0x07, 0xFC,
-  0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xC3, 0xEF,
-  0xFF, 0xBF, 0xFC, 0xFF, 0xE3, 0xFF, 0x00, 0x0F, 0xC0, 0x7F, 0xC3, 0xFF,
-  0x9F, 0xFE, 0x7C, 0x79, 0xE1, 0xFF, 0x87, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0,
-  0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0x0F, 0x80, 0x3E, 0x00, 0xF8,
-  0x03, 0xE0, 0x0F, 0x80, 0x3E, 0x00, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE,
-  0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x1F, 0x78, 0x7D, 0xE1, 0xE7,
-  0xEF, 0x8F, 0xFE, 0x3F, 0xF0, 0x3F, 0x80, 0xFF, 0x07, 0xFF, 0x3F, 0xFD,
-  0xFF, 0xEF, 0x0F, 0xF8, 0x7F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC,
-  0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83,
-  0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F,
-  0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x7F, 0xFF, 0xDF, 0xFE, 0xFF,
-  0xE7, 0xFC, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x3C, 0x0F, 0x03,
-  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F,
-  0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
-  0xC0, 0xF0, 0x3C, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0xC0, 0xF0,
-  0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F,
-  0x03, 0xC0, 0xF0, 0x3C, 0x00, 0x0F, 0xE0, 0x7F, 0xC3, 0xFF, 0x9F, 0xFE,
-  0x7C, 0x7D, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83,
-  0xFE, 0x0F, 0xF8, 0x03, 0xE0, 0x0F, 0x80, 0x3E, 0x00, 0xF9, 0xFF, 0xE7,
-  0xFF, 0x9F, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8,
-  0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0x78, 0x3D, 0xE1, 0xF7, 0xEF, 0xCF,
-  0xFF, 0x3F, 0xEC, 0x3F, 0x30, 0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xFC, 0x1F,
-  0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xFC, 0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0x07,
-  0xFC, 0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0x07, 0xFC, 0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xFC, 0x1F, 0xF0,
-  0x7F, 0xC1, 0xFF, 0x07, 0xFC, 0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xFC,
-  0x1F, 0xF0, 0x7F, 0xC1, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xF8,
-  0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00,
-  0xF8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F,
-  0x00, 0xF8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0xF8, 0x7F, 0xC3, 0xFE,
-  0x1F, 0xF0, 0xFF, 0x87, 0xFC, 0x3F, 0xE1, 0xEF, 0x0F, 0x78, 0x7B, 0xF7,
-  0xCF, 0xFC, 0x7F, 0xE1, 0xFE, 0x00, 0xF0, 0x3D, 0xE0, 0xFB, 0xC1, 0xE7,
-  0x83, 0xCF, 0x0F, 0x9E, 0x1E, 0x3C, 0x3C, 0x78, 0xF8, 0xF1, 0xE1, 0xE7,
-  0xC3, 0xCF, 0x87, 0x9E, 0x0F, 0x7C, 0x1E, 0xF8, 0x3D, 0xE0, 0x7F, 0xC0,
-  0xFF, 0x01, 0xFE, 0x03, 0xFE, 0x07, 0xBC, 0x0F, 0x7C, 0x1E, 0xF8, 0x3C,
-  0xF0, 0x79, 0xF0, 0xF1, 0xE1, 0xE3, 0xC3, 0xC7, 0xC7, 0x87, 0x8F, 0x0F,
-  0x9E, 0x1F, 0x3C, 0x1E, 0x78, 0x3E, 0xF0, 0x7D, 0xE0, 0x7C, 0xF0, 0x3C,
-  0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
-  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0,
-  0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF8, 0x01, 0xFF, 0x80, 0x1F, 0xF8, 0x03,
-  0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0,
-  0x7F, 0xFE, 0x07, 0xFF, 0xE0, 0x7F, 0xFE, 0x07, 0xFE, 0xE0, 0x7F, 0xEE,
-  0x0F, 0xFE, 0xF0, 0xFF, 0xEF, 0x0E, 0xFE, 0x70, 0xEF, 0xE7, 0x0E, 0xFE,
-  0x70, 0xEF, 0xE7, 0x1E, 0xFE, 0x79, 0xCF, 0xE3, 0x9C, 0xFF, 0x39, 0xCF,
-  0xF3, 0x9C, 0xFF, 0x3B, 0xCF, 0xF3, 0xF8, 0xFF, 0x1F, 0x8F, 0xF1, 0xF8,
-  0xFF, 0x1F, 0x8F, 0xF1, 0xF8, 0xFF, 0x1F, 0x8F, 0xF0, 0xF0, 0xFF, 0x0F,
-  0x0F, 0xF0, 0xF0, 0xFF, 0x0F, 0x0F, 0xE0, 0x3F, 0x80, 0xFF, 0x03, 0xFC,
-  0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFF, 0x0F, 0xFC, 0x3F, 0xF0, 0xFF,
-  0xE3, 0xFF, 0x8F, 0xFE, 0x3F, 0xFC, 0xFF, 0xF3, 0xFD, 0xCF, 0xF7, 0xBF,
-  0xDE, 0xFF, 0x3B, 0xFC, 0xFF, 0xF3, 0xDF, 0xC7, 0x7F, 0x1F, 0xFC, 0x7F,
-  0xF0, 0xFF, 0xC3, 0xFF, 0x0F, 0xFC, 0x1F, 0xF0, 0x7F, 0xC1, 0xFF, 0x03,
-  0xFC, 0x0F, 0xF0, 0x3F, 0xC0, 0x70, 0x0F, 0xE0, 0x7F, 0xC3, 0xFF, 0x9F,
-  0xFE, 0x7C, 0x7D, 0xE1, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF,
-  0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F,
-  0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F,
-  0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0x78, 0x7D, 0xE1, 0xF7, 0xFF,
-  0x8F, 0xFE, 0x3F, 0xF0, 0x3F, 0x80, 0xFF, 0x87, 0xFF, 0x3F, 0xFD, 0xFF,
-  0xEF, 0x0F, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F,
-  0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x1F, 0xF0, 0xFF, 0xFF, 0xBF,
-  0xFD, 0xFF, 0xCF, 0xF8, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80,
-  0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07,
-  0x80, 0x00, 0x0F, 0xE0, 0x7F, 0xC3, 0xFF, 0x9F, 0xFE, 0x7C, 0x7D, 0xE1,
-  0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8,
-  0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE,
-  0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF,
-  0x83, 0xFE, 0x0F, 0x78, 0x7D, 0xE1, 0xF7, 0xFF, 0x8F, 0xFE, 0x3F, 0xF0,
-  0x3F, 0x80, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x01, 0xE0, 0x03, 0x00, 0xFF,
-  0x83, 0xFF, 0x8F, 0xFF, 0x3F, 0xFE, 0xF0, 0xFB, 0xC1, 0xEF, 0x07, 0xBC,
-  0x1E, 0xF0, 0x7B, 0xC1, 0xEF, 0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xC3, 0xEF,
-  0x1F, 0x3F, 0xFC, 0xFF, 0xE3, 0xFF, 0xCF, 0x0F, 0xBC, 0x1E, 0xF0, 0x7B,
-  0xC1, 0xEF, 0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xC1, 0xEF, 0x07, 0xBC, 0x1E,
-  0xF0, 0x7B, 0xC1, 0xEF, 0x07, 0xBC, 0x1E, 0xF0, 0x7B, 0xC1, 0xF0, 0x0F,
-  0xC0, 0xFF, 0xC3, 0xFF, 0x1F, 0xFE, 0x78, 0x79, 0xE1, 0xEF, 0x87, 0xBE,
-  0x1F, 0xF8, 0x7D, 0xE1, 0xF7, 0x87, 0xDF, 0x1F, 0x7E, 0x00, 0xFC, 0x01,
-  0xF8, 0x03, 0xF0, 0x0F, 0xE0, 0x1F, 0x80, 0x3F, 0x00, 0x7E, 0x00, 0xF9,
-  0xE1, 0xF7, 0x87, 0xDE, 0x0F, 0x78, 0x3D, 0xE0, 0xF7, 0x83, 0xDE, 0x0F,
-  0x78, 0x3D, 0xE1, 0xF7, 0xEF, 0x8F, 0xFE, 0x3F, 0xF0, 0x3F, 0x80, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F,
-  0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F,
-  0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F,
-  0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F, 0x80, 0xF8, 0x0F,
-  0x80, 0xF8, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0,
-  0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8,
-  0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE,
-  0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF,
-  0x83, 0xFE, 0x0F, 0x78, 0x3D, 0xE1, 0xF7, 0xEF, 0xCF, 0xFE, 0x3F, 0xF8,
-  0x7F, 0x80, 0xF0, 0x1F, 0xF0, 0x1E, 0xF0, 0x1E, 0xF0, 0x1E, 0xF8, 0x1E,
-  0x78, 0x1E, 0x78, 0x1E, 0x78, 0x3C, 0x78, 0x3C, 0x78, 0x3C, 0x7C, 0x3C,
-  0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x78, 0x3C, 0x78, 0x3C, 0x78,
-  0x1E, 0x78, 0x1E, 0x78, 0x1E, 0x78, 0x1E, 0x78, 0x1E, 0x70, 0x1E, 0xF0,
-  0x0E, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xE0,
-  0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0xF0, 0x3C,
-  0x0F, 0xF0, 0x3C, 0x0F, 0xF0, 0x3C, 0x0F, 0xF0, 0x3C, 0x1E, 0xF0, 0x3C,
-  0x1E, 0x78, 0x3E, 0x1E, 0x78, 0x7E, 0x1E, 0x78, 0x7E, 0x1E, 0x78, 0x7E,
-  0x1E, 0x78, 0x7E, 0x1E, 0x78, 0x7E, 0x1E, 0x78, 0x7E, 0x1E, 0x38, 0x7F,
-  0x1C, 0x38, 0xF7, 0x1C, 0x3C, 0xF7, 0x3C, 0x3C, 0xE7, 0x3C, 0x3C, 0xE7,
-  0x3C, 0x3C, 0xE7, 0x3C, 0x3C, 0xE7, 0x3C, 0x3C, 0xE7, 0xBC, 0x1D, 0xE3,
-  0xB8, 0x1D, 0xC3, 0xB8, 0x1D, 0xC3, 0xB8, 0x1F, 0xC3, 0xB8, 0x1F, 0xC3,
-  0xB8, 0x1F, 0xC3, 0xF8, 0x1F, 0xC3, 0xF8, 0x1F, 0xC1, 0xF8, 0x0F, 0x81,
-  0xF8, 0x0F, 0x81, 0xF0, 0x0F, 0x81, 0xF0, 0x0F, 0x81, 0xF0, 0x0F, 0x81,
-  0xF0, 0x0F, 0x81, 0xF0, 0xF0, 0x3F, 0xC0, 0xF7, 0x07, 0x9E, 0x1E, 0x78,
-  0x78, 0xE3, 0xE3, 0xCF, 0x0F, 0x3C, 0x3C, 0xF0, 0x7F, 0x81, 0xFE, 0x07,
-  0xF8, 0x0F, 0xE0, 0x3F, 0x00, 0xFC, 0x01, 0xF0, 0x07, 0x80, 0x3E, 0x00,
-  0xF8, 0x03, 0xF0, 0x0F, 0xC0, 0x7F, 0x01, 0xFE, 0x07, 0xF8, 0x3F, 0xE0,
-  0xF3, 0xC3, 0xCF, 0x0F, 0x3C, 0x78, 0x71, 0xE1, 0xE7, 0x87, 0x9E, 0x0E,
-  0xF0, 0x3F, 0xC0, 0xF0, 0xF8, 0x0F, 0x78, 0x1F, 0x78, 0x1E, 0x7C, 0x1E,
-  0x3C, 0x1E, 0x3C, 0x3E, 0x3C, 0x3C, 0x3E, 0x3C, 0x1E, 0x3C, 0x1E, 0x78,
-  0x1E, 0x78, 0x0F, 0x78, 0x0F, 0x78, 0x0F, 0xF0, 0x0F, 0xF0, 0x07, 0xF0,
-  0x07, 0xF0, 0x07, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0,
-  0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0,
-  0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0, 0x03, 0xE0,
-  0x7F, 0xF7, 0xFF, 0x7F, 0xF7, 0xFF, 0x01, 0xF0, 0x1E, 0x01, 0xE0, 0x3E,
-  0x03, 0xE0, 0x3C, 0x07, 0xC0, 0x7C, 0x07, 0xC0, 0x78, 0x0F, 0x80, 0xF8,
-  0x0F, 0x80, 0xF0, 0x1F, 0x01, 0xF0, 0x1E, 0x01, 0xE0, 0x3E, 0x03, 0xE0,
-  0x3C, 0x07, 0xC0, 0x7C, 0x07, 0xC0, 0x78, 0x0F, 0x80, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-  0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-  0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xFF,
-  0xFF, 0xFF, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x07, 0x00, 0xF0, 0x1E, 0x03,
-  0xC0, 0x78, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x3C, 0x07, 0x80, 0xF0,
-  0x1E, 0x01, 0xC0, 0x3C, 0x07, 0x80, 0xF0, 0x0E, 0x01, 0xE0, 0x3C, 0x07,
-  0x80, 0xF0, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0x78, 0x0F, 0x01, 0xE0,
-  0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
-  0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
-  0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0xFF, 0xFF, 0xFF,
-  0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x80, 0x7F, 0x01, 0xFE, 0x03, 0xDC, 0x07,
-  0xBC, 0x0E, 0x78, 0x3C, 0xF0, 0x79, 0xE0, 0xF1, 0xE1, 0xE3, 0xC7, 0x87,
-  0x8F, 0x0F, 0x1E, 0x0F, 0x3C, 0x1E, 0xF8, 0x3D, 0xE0, 0x7C, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xF0, 0xF9, 0xE7, 0x8E, 0x38, 0x71, 0xC3, 0x0F, 0xC0, 0xFF,
-  0xC3, 0xFF, 0x1F, 0xFE, 0x78, 0x79, 0xE1, 0xEF, 0x87, 0xBE, 0x1E, 0xF8,
-  0x7C, 0x01, 0xF0, 0x07, 0xC0, 0x7F, 0x0F, 0xFC, 0x7F, 0xF3, 0xE7, 0xDE,
-  0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF,
-  0x87, 0xFE, 0x1F, 0xF8, 0x7D, 0xE3, 0xF7, 0xFF, 0xDF, 0xFF, 0x3F, 0x7C,
-  0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x79, 0xE3, 0xDF, 0x9F,
-  0xFE, 0xFF, 0xFF, 0xC7, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1,
-  0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F,
-  0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xFC,
-  0x7F, 0xF7, 0xFF, 0xFE, 0xF7, 0xF7, 0x9F, 0x00, 0x0F, 0xC1, 0xFF, 0x8F,
-  0xFC, 0xFF, 0xF7, 0x87, 0xBC, 0x3F, 0xE1, 0xFF, 0x0F, 0xF8, 0x7F, 0xC3,
-  0xFE, 0x1F, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00, 0xF8, 0x07,
-  0xC0, 0x3E, 0x1F, 0xF0, 0xFF, 0x87, 0xFC, 0x3F, 0xE1, 0xEF, 0x0F, 0x78,
-  0x7B, 0xE7, 0xDF, 0xFC, 0x7F, 0xE1, 0xFE, 0x00, 0x00, 0x7C, 0x01, 0xF0,
-  0x07, 0xC0, 0x1F, 0x00, 0x7C, 0x7D, 0xF3, 0xFF, 0xDF, 0xFF, 0x7F, 0xFD,
-  0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F,
-  0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87,
-  0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7D, 0xE1,
-  0xF7, 0xDF, 0xDF, 0xFF, 0x3F, 0xFC, 0x7D, 0xF0, 0x0F, 0xC0, 0x7F, 0xC3,
-  0xFF, 0x1F, 0xFE, 0x78, 0x79, 0xE1, 0xEF, 0x87, 0xBE, 0x1E, 0xF8, 0x7B,
-  0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00,
-  0xF8, 0x03, 0xE0, 0x0F, 0x87, 0xBE, 0x1E, 0xF8, 0x7B, 0xE1, 0xEF, 0x87,
-  0x9E, 0x1E, 0x78, 0x79, 0xF3, 0xE7, 0xFF, 0x0F, 0xFC, 0x1F, 0xE0, 0x07,
-  0xC3, 0xF1, 0xFC, 0x7C, 0x1E, 0x07, 0x8F, 0xFF, 0xFF, 0xFF, 0xFF, 0xF1,
-  0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78,
-  0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07,
-  0x81, 0xE0, 0x78, 0x1E, 0x07, 0x80, 0x1F, 0x7C, 0xFF, 0xF7, 0xFF, 0xDF,
-  0xFF, 0x78, 0x7D, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF,
-  0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F,
-  0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7D, 0xE1, 0xF7, 0xCF, 0xDF, 0xFF,
-  0x3F, 0xFC, 0x7D, 0xF0, 0x07, 0xC0, 0x1F, 0x00, 0x79, 0xC3, 0xE7, 0xFF,
-  0xBF, 0xFC, 0x3F, 0xC0, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00,
-  0x79, 0xF3, 0xDF, 0xDF, 0xFF, 0xFF, 0xFF, 0xC3, 0xFC, 0x1F, 0xE0, 0xFF,
-  0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0,
-  0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F,
-  0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xC0,
-  0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x3C, 0x78, 0xF1, 0xE0, 0x00, 0x0F,
-  0x9F, 0x3E, 0x7C, 0xF9, 0xF3, 0xE7, 0xCF, 0x9F, 0x3E, 0x7C, 0xF9, 0xF3,
-  0xE7, 0xCF, 0x9F, 0x3E, 0x7C, 0xF9, 0xF3, 0xE7, 0xCF, 0x9F, 0x3E, 0x7C,
-  0xF9, 0xFF, 0xDF, 0xBE, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00,
-  0xF0, 0x03, 0xC1, 0xFF, 0x07, 0xBC, 0x1E, 0xF0, 0xFB, 0xC3, 0xCF, 0x1F,
-  0x3C, 0x78, 0xF1, 0xE3, 0xCF, 0x8F, 0x3C, 0x3D, 0xF0, 0xF7, 0x83, 0xDE,
-  0x0F, 0xF8, 0x3F, 0xC0, 0xFF, 0x83, 0xDE, 0x0F, 0x78, 0x3D, 0xF0, 0xF3,
-  0xC3, 0xCF, 0x8F, 0x1E, 0x3C, 0x7C, 0xF0, 0xF3, 0xC3, 0xCF, 0x0F, 0xBC,
-  0x1E, 0xF0, 0x7F, 0xC0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF3, 0xE1,
-  0xF3, 0xDF, 0xCF, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0xFC, 0x3F,
-  0xC1, 0xE0, 0xFF, 0x07, 0x83, 0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3F, 0xC1,
-  0xE0, 0xFF, 0x07, 0x83, 0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3F, 0xC1, 0xE0,
-  0xFF, 0x07, 0x83, 0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3F, 0xC1, 0xE0, 0xFF,
-  0x07, 0x83, 0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3F, 0xC1, 0xE0, 0xFF, 0x07,
-  0x83, 0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3F, 0xC1, 0xE0, 0xFF, 0x07, 0x83,
-  0xFC, 0x1E, 0x0F, 0xF0, 0x78, 0x3C, 0xF3, 0xE7, 0xBF, 0xBF, 0xFF, 0xFF,
-  0xFF, 0x87, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F,
-  0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC,
-  0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83,
-  0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0x80, 0x0F, 0xC0, 0x7F, 0x83, 0xFF, 0x1F,
-  0xFE, 0x78, 0x79, 0xE1, 0xEF, 0x87, 0xBE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF,
-  0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F,
-  0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xDE, 0x1E,
-  0x78, 0x79, 0xF3, 0xE7, 0xFF, 0x0F, 0xFC, 0x1F, 0xE0, 0xF3, 0xC7, 0xBF,
-  0xBF, 0xFD, 0xFF, 0xFF, 0x8F, 0xF8, 0x7F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F,
-  0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0,
-  0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F,
-  0xF8, 0xFF, 0xEF, 0xFF, 0xFD, 0xFF, 0xEF, 0x7E, 0x78, 0x03, 0xC0, 0x1E,
-  0x00, 0xF0, 0x07, 0x80, 0x00, 0x1E, 0x7C, 0xFF, 0xF7, 0xFF, 0xDF, 0xFF,
-  0x78, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87,
-  0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1,
-  0xFF, 0x87, 0xFE, 0x1F, 0xF8, 0x7F, 0xE1, 0xFF, 0x87, 0xFE, 0x1F, 0x78,
-  0x7D, 0xF7, 0xF7, 0xFF, 0xCF, 0xFF, 0x1F, 0x7C, 0x01, 0xF0, 0x07, 0xC0,
-  0x1F, 0x00, 0x7C, 0x01, 0xF0, 0xF3, 0xFB, 0xFF, 0xFF, 0xFF, 0xC7, 0x83,
-  0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0,
-  0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E,
-  0x0F, 0x00, 0x1F, 0x83, 0xFE, 0x1F, 0xF9, 0xFF, 0xCF, 0x0F, 0x78, 0x7B,
-  0xC3, 0xDE, 0x1E, 0xF0, 0xF7, 0xC7, 0xBE, 0x00, 0xF8, 0x07, 0xE0, 0x1F,
-  0x80, 0x7E, 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0x80, 0x7D, 0xE1, 0xEF, 0x0F,
-  0xF8, 0x7F, 0xC3, 0xFE, 0x1F, 0xF0, 0xF7, 0xEF, 0x9F, 0xFC, 0xFF, 0xC1,
-  0xFC, 0x00, 0x3E, 0x0F, 0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x8F, 0xFF, 0xFF,
-  0xFF, 0xCF, 0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x83, 0xE0, 0xF8, 0x3E, 0x0F,
-  0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x83, 0xE0,
-  0xF8, 0x3E, 0x0F, 0x83, 0xF0, 0xFF, 0x1F, 0xC3, 0xF0, 0xF8, 0x3F, 0xE0,
-  0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8,
-  0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE,
-  0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0x83, 0xFE, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF,
-  0x83, 0xFE, 0x0F, 0x78, 0x7D, 0xF3, 0xF7, 0xFF, 0xCF, 0xEF, 0x1F, 0x3C,
-  0xF0, 0x7F, 0xC1, 0xEF, 0x07, 0xBC, 0x1E, 0x78, 0x79, 0xE1, 0xE7, 0x87,
-  0x9E, 0x1C, 0x78, 0x71, 0xE3, 0xC7, 0x8F, 0x0E, 0x3C, 0x3C, 0xF0, 0xF3,
-  0xC3, 0xCE, 0x0F, 0x38, 0x3C, 0xE0, 0xF3, 0x81, 0xDE, 0x07, 0x78, 0x1F,
-  0xE0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x3F, 0x00, 0xFC, 0x03,
-  0xF0, 0x0F, 0x80, 0xF0, 0x78, 0x7F, 0x87, 0xC3, 0xFC, 0x3E, 0x1F, 0xE1,
-  0xF0, 0xF7, 0x0F, 0x87, 0xB8, 0x7C, 0x39, 0xC3, 0xE1, 0xCE, 0x1F, 0x8E,
-  0x79, 0xDC, 0x73, 0xCE, 0xE7, 0x9E, 0x77, 0x3C, 0xF3, 0xB9, 0xE3, 0x9D,
-  0xCF, 0x1C, 0xE6, 0x70, 0xE7, 0x3B, 0x87, 0x71, 0xDC, 0x3B, 0x8E, 0xE1,
-  0xDC, 0x77, 0x0F, 0xE3, 0xB8, 0x7F, 0x1D, 0xC3, 0xF8, 0xFE, 0x0F, 0x83,
-  0xE0, 0x7C, 0x1F, 0x03, 0xE0, 0xF8, 0x1F, 0x07, 0xC0, 0xF8, 0x3E, 0x07,
-  0xC1, 0xF0, 0x3E, 0x0F, 0x81, 0xE0, 0x7C, 0x00, 0xF0, 0x7B, 0xC1, 0xE7,
-  0x87, 0x9E, 0x3C, 0x78, 0xF0, 0xF3, 0xC3, 0xCE, 0x0F, 0x78, 0x1F, 0xE0,
-  0x7F, 0x01, 0xFC, 0x03, 0xF0, 0x0F, 0x80, 0x3E, 0x00, 0xF8, 0x03, 0xE0,
-  0x0F, 0x80, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x3D, 0xE0, 0xF7, 0x83, 0xDE,
-  0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xCF, 0x07, 0xBC, 0x1E, 0xF0, 0x7C, 0xF0,
-  0x3F, 0xC0, 0xFF, 0x07, 0xFE, 0x1E, 0x78, 0x79, 0xE1, 0xE7, 0x87, 0x9E,
-  0x1E, 0x78, 0x79, 0xE1, 0xC3, 0x87, 0x0F, 0x3C, 0x3C, 0xF0, 0xF3, 0xC3,
-  0xCF, 0x0F, 0x3C, 0x1C, 0xE0, 0x73, 0x81, 0xCE, 0x07, 0xB8, 0x1F, 0xE0,
-  0x7F, 0x80, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0,
-  0x07, 0x80, 0x1E, 0x00, 0xF8, 0x1F, 0xE0, 0x7F, 0x01, 0xFC, 0x00, 0x7F,
-  0xEF, 0xFD, 0xFF, 0xBF, 0xF0, 0x1E, 0x07, 0xC0, 0xF0, 0x1E, 0x07, 0xC0,
-  0xF0, 0x1E, 0x03, 0xC0, 0xF8, 0x1E, 0x03, 0xC0, 0xF8, 0x1E, 0x03, 0xC0,
-  0xF8, 0x1F, 0x03, 0xC0, 0x78, 0x1F, 0x03, 0xC0, 0x78, 0x1F, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFE, 0x07, 0xC3, 0xF1, 0xFC, 0x7E, 0x1E, 0x07, 0x81, 0xE0,
-  0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0xF8, 0x7E,
-  0x3F, 0x0F, 0x83, 0xF0, 0xFE, 0x0F, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81,
-  0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0xC1, 0xFC, 0x3F,
-  0x07, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF8, 0x3F, 0x0F,
-  0xC1, 0xF8, 0x3E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78,
-  0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1F, 0x83, 0xF0, 0x7C, 0x3F, 0x1F, 0xC7,
-  0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0, 0x78, 0x1E, 0x07, 0x81, 0xE0,
-  0x78, 0x3E, 0x0F, 0x8F, 0xC3, 0xF0, 0xF8, 0x00, 0x1E, 0x07, 0x9F, 0xF3,
-  0xDF, 0xFF, 0xDF, 0xFF, 0xEF, 0xFF, 0xE1, 0x03, 0xE0 };
+#pragma once
+
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+#include "fonts.hpp"
+
+const uint8_t Antonio_SemiBold20pt7bBitmaps_Gzip[] = {
+  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xa5, 0x57,
+  0x4f, 0x6f, 0xe3, 0xba, 0x11, 0xa7, 0xaa, 0xe2, 0xf1, 0x1d, 0x16, 0xe6,
+  0xf5, 0x1d, 0xbc, 0x62, 0x3f, 0xc2, 0xeb, 0xcd, 0x8b, 0x55, 0xac, 0xaf,
+  0xf2, 0x4e, 0x7b, 0x76, 0xb0, 0x40, 0x57, 0x46, 0x94, 0x48, 0x81, 0x81,
+  0xea, 0x52, 0xac, 0xaf, 0x5b, 0x60, 0x9b, 0x7c, 0x8d, 0x2d, 0x10, 0x6c,
+  0x64, 0x08, 0x78, 0xbe, 0x45, 0x5f, 0x60, 0x11, 0x53, 0x10, 0x50, 0x5f,
+  0x8a, 0x8a, 0x86, 0x80, 0x4a, 0x41, 0x14, 0xb1, 0x3f, 0xd2, 0x72, 0xfe,
+  0x6c, 0xb2, 0xd9, 0xd7, 0x96, 0xa4, 0x39, 0x43, 0x8a, 0x96, 0x86, 0x33,
+  0xc3, 0xdf, 0x0c, 0x89, 0xea, 0xcb, 0x1b, 0x5d, 0x08, 0xd3, 0x6c, 0x79,
+  0x70, 0x59, 0x7f, 0xf8, 0x95, 0xd8, 0x73, 0x6b, 0x19, 0x15, 0xd1, 0x26,
+  0x99, 0x88, 0xd1, 0x64, 0xe8, 0x0f, 0x5c, 0x3a, 0xa4, 0xef, 0xed, 0x98,
+  0x9b, 0xe5, 0xed, 0x48, 0xb8, 0x13, 0x67, 0x34, 0x18, 0xd2, 0x81, 0x3d,
+  0x67, 0xaa, 0x56, 0xcd, 0xdd, 0x3a, 0x66, 0xd6, 0x59, 0x69, 0x54, 0x24,
+  0xfb, 0xc2, 0x17, 0xe4, 0x07, 0xf2, 0xb3, 0x15, 0xbd, 0x20, 0xbf, 0xf0,
+  0x85, 0x3a, 0x6d, 0xaf, 0xeb, 0xf8, 0x6c, 0x2f, 0x2f, 0x99, 0x7f, 0x50,
+  0xac, 0x48, 0x60, 0x35, 0x4c, 0x78, 0x51, 0x60, 0x49, 0x9a, 0x8c, 0x65,
+  0x1d, 0xb7, 0x5e, 0xae, 0x58, 0x7b, 0xa0, 0xb2, 0xce, 0x13, 0x9d, 0x95,
+  0x0c, 0xc8, 0xc4, 0x8e, 0x86, 0x84, 0x47, 0x56, 0x42, 0x3b, 0xe2, 0x92,
+  0x50, 0xd8, 0x09, 0x3b, 0x25, 0x23, 0x22, 0x25, 0x8d, 0x18, 0x23, 0x13,
+  0x30, 0x8c, 0x80, 0x91, 0x60, 0x06, 0x60, 0x2c, 0x01, 0x66, 0x08, 0xc6,
+  0x4e, 0x7e, 0x91, 0xd2, 0xf5, 0x32, 0x66, 0xc7, 0x9d, 0x94, 0xbe, 0x2a,
+  0x19, 0x9d, 0x0f, 0x24, 0x8a, 0x62, 0x6c, 0xc0, 0xa4, 0x14, 0xa2, 0x5e,
+  0x39, 0x03, 0x16, 0xe6, 0x42, 0x54, 0xed, 0x70, 0xc0, 0xf8, 0x2c, 0x11,
+  0x92, 0x8c, 0x06, 0x8c, 0xd0, 0x08, 0x8c, 0xaf, 0x19, 0x02, 0x46, 0x82,
+  0x19, 0x80, 0xb1, 0x04, 0xbe, 0xe2, 0x90, 0x8d, 0xb0, 0x12, 0x66, 0x24,
+  0x49, 0xec, 0xc8, 0x6e, 0x6c, 0x61, 0x77, 0x44, 0x45, 0x81, 0x74, 0x86,
+  0x34, 0xb6, 0xf2, 0xc4, 0x9f, 0x80, 0x99, 0x93, 0x2a, 0xda, 0x13, 0xcc,
+  0xb7, 0x5a, 0x72, 0x04, 0xd1, 0x69, 0x62, 0x4b, 0xd2, 0xfd, 0x18, 0xfe,
+  0xd9, 0x2b, 0xe6, 0x6e, 0x3d, 0x9f, 0xe6, 0xad, 0x1f, 0xba, 0x7c, 0x6e,
+  0x17, 0x89, 0x94, 0x63, 0x87, 0xc7, 0x6a, 0xa3, 0x5a, 0x6f, 0x1d, 0x6f,
+  0x84, 0x52, 0xf5, 0x9f, 0xde, 0xbc, 0x19, 0x2b, 0x95, 0x39, 0xae, 0xbf,
+  0x29, 0x96, 0xf3, 0x27, 0xc8, 0x75, 0x9d, 0x27, 0x9b, 0x0a, 0xc3, 0xec,
+  0x74, 0x1c, 0x5c, 0x55, 0xeb, 0x47, 0xe4, 0xa0, 0x2e, 0x3f, 0x40, 0xf2,
+  0xe1, 0xef, 0xf7, 0x5f, 0x5d, 0x5c, 0x1f, 0xaa, 0x45, 0x6b, 0x0b, 0xaf,
+  0x28, 0xd5, 0xdb, 0xbf, 0xfe, 0x4a, 0x7f, 0x1c, 0x42, 0x5f, 0x50, 0x15,
+  0x9a, 0x36, 0xa0, 0xd6, 0x5c, 0xcf, 0xff, 0x65, 0xfd, 0xc7, 0x8f, 0x09,
+  0x28, 0x44, 0x20, 0x0d, 0x8d, 0x5c, 0x4b, 0x0c, 0x88, 0xd4, 0x34, 0x71,
+  0x34, 0x1d, 0xd9, 0x5b, 0xea, 0x1b, 0xca, 0x88, 0xa6, 0xd0, 0x87, 0xa6,
+  0xae, 0xa1, 0x34, 0x22, 0x4c, 0x9b, 0x56, 0xd5, 0x73, 0x63, 0xc0, 0x26,
+  0x4c, 0x3b, 0x2e, 0x55, 0xfc, 0xed, 0xc1, 0xd9, 0x61, 0x5d, 0x76, 0x9e,
+  0x54, 0xc4, 0x9e, 0xa5, 0x85, 0x96, 0xe6, 0x94, 0xc5, 0x69, 0x2e, 0x9b,
+  0x60, 0xcc, 0x9f, 0x62, 0x12, 0x76, 0xac, 0x78, 0xa3, 0xca, 0x79, 0x70,
+  0x90, 0x5e, 0x3a, 0xdb, 0x97, 0xc1, 0x83, 0x7c, 0x9a, 0xb8, 0xb6, 0x70,
+  0x2c, 0xc8, 0x04, 0xb1, 0x03, 0xb8, 0x90, 0x2d, 0xb8, 0x96, 0x34, 0x00,
+  0xed, 0xe0, 0x93, 0x11, 0x4b, 0x54, 0xac, 0x78, 0xe7, 0x5f, 0xe7, 0x65,
+  0x7c, 0xe6, 0xc8, 0x83, 0x85, 0xa0, 0x91, 0x03, 0xc1, 0x85, 0x67, 0x35,
+  0x54, 0xf0, 0x84, 0x91, 0x31, 0xf1, 0x2d, 0x41, 0xf1, 0x2c, 0x5c, 0x28,
+  0x4d, 0x0e, 0xf2, 0xf5, 0xea, 0xb4, 0xf5, 0x44, 0x48, 0xb4, 0x4f, 0x7a,
+  0xa4, 0xb5, 0x25, 0x4f, 0x42, 0xab, 0xfd, 0x41, 0xbe, 0x4e, 0x4a, 0xfb,
+  0x6c, 0x28, 0xdf, 0x2e, 0x32, 0xe6, 0x8e, 0x24, 0x2c, 0x32, 0x74, 0x27,
+  0x9b, 0x34, 0x63, 0x23, 0xb7, 0x3f, 0x41, 0x44, 0xc2, 0x3b, 0xe1, 0x1b,
+  0x20, 0xaa, 0xec, 0xd0, 0x7a, 0x0d, 0x33, 0x52, 0xb1, 0x16, 0xc3, 0xab,
+  0x92, 0xcb, 0xcd, 0x6e, 0x4a, 0x32, 0xb8, 0xa2, 0x69, 0xfc, 0xba, 0xec,
+  0xc2, 0xb4, 0x81, 0xa8, 0x33, 0xc5, 0x5b, 0xff, 0x0a, 0xa2, 0x7e, 0x76,
+  0x9a, 0x83, 0xbc, 0x8c, 0xc6, 0xa4, 0xb1, 0xcb, 0xb9, 0xf2, 0x3a, 0x75,
+  0xbd, 0x9d, 0x0c, 0x73, 0x15, 0x77, 0x7c, 0x47, 0xa6, 0xf9, 0x5a, 0x9d,
+  0x42, 0x8b, 0x61, 0xb4, 0x13, 0x20, 0x80, 0x39, 0x22, 0x08, 0x40, 0x13,
+  0xb3, 0xc9, 0x27, 0x78, 0x4e, 0xf4, 0x59, 0x83, 0x0e, 0x1a, 0x3d, 0x85,
+  0x0f, 0x10, 0x1c, 0x4a, 0xde, 0x5e, 0x2b, 0x58, 0x6e, 0xd1, 0x31, 0x19,
+  0xce, 0x5a, 0x2e, 0x60, 0x9f, 0xa9, 0x5a, 0xb6, 0x5e, 0xa1, 0x4e, 0xf6,
+  0x36, 0x8a, 0x36, 0xf7, 0x9e, 0xd0, 0xd6, 0x33, 0x96, 0xeb, 0x08, 0x87,
+  0x49, 0x6e, 0x60, 0x12, 0x1f, 0x26, 0xbd, 0x7d, 0xda, 0x2f, 0x5d, 0xae,
+  0x3a, 0x55, 0x29, 0xed, 0x48, 0xbb, 0x27, 0xac, 0x9d, 0xd6, 0xe6, 0x50,
+  0x13, 0x78, 0x1e, 0x41, 0x31, 0x40, 0xa3, 0x22, 0xcd, 0x12, 0x20, 0x4a,
+  0xf5, 0xf1, 0xe2, 0xed, 0x07, 0xf2, 0x87, 0x17, 0xf4, 0x58, 0x76, 0xde,
+  0xe9, 0x52, 0x36, 0x43, 0x5b, 0x1c, 0x51, 0xe9, 0xd9, 0x0d, 0xb7, 0xc4,
+  0x0b, 0xa2, 0x77, 0xd8, 0xf6, 0xff, 0x4a, 0xa2, 0x9f, 0xec, 0x28, 0x60,
+  0x49, 0x47, 0x65, 0x68, 0x0b, 0x97, 0xcd, 0x36, 0x6d, 0xe7, 0xc5, 0x89,
+  0xfc, 0xe9, 0x77, 0x78, 0x53, 0xdc, 0x86, 0x65, 0xb7, 0x29, 0xf9, 0x46,
+  0xf5, 0xcd, 0x92, 0xf0, 0x55, 0xf8, 0x45, 0xeb, 0xcd, 0xa4, 0x0b, 0x87,
+  0x45, 0x33, 0xdf, 0xec, 0x79, 0x3b, 0x21, 0x5e, 0x44, 0x20, 0x12, 0x5e,
+  0xdf, 0x30, 0x6d, 0x3a, 0x0d, 0x25, 0x64, 0xe4, 0x93, 0xe1, 0x88, 0xc7,
+  0xae, 0x57, 0x9c, 0x38, 0x9b, 0x8b, 0xe1, 0x68, 0x3d, 0x18, 0xbe, 0x7b,
+  0x3f, 0xe0, 0x4b, 0xca, 0x8a, 0x59, 0xbc, 0x59, 0xa4, 0x8d, 0xc8, 0xdb,
+  0xc9, 0xa4, 0x1b, 0x8d, 0xc2, 0xa1, 0x7e, 0xf0, 0x6a, 0x49, 0x87, 0xc5,
+  0xf2, 0x62, 0xf2, 0xef, 0xce, 0x0d, 0x3d, 0x87, 0x33, 0x7a, 0x4c, 0xf0,
+  0x62, 0xa0, 0x12, 0xbc, 0x01, 0x10, 0x30, 0xa1, 0xaa, 0x21, 0x0a, 0x2a,
+  0x93, 0x84, 0x26, 0x54, 0xb0, 0xbb, 0x2a, 0x07, 0xd2, 0xd9, 0xd5, 0x89,
+  0xe3, 0x0f, 0x7d, 0x77, 0x57, 0x51, 0x02, 0x90, 0xb0, 0x45, 0xed, 0xc2,
+  0xce, 0x77, 0x1a, 0x54, 0x2c, 0xe3, 0x92, 0x2b, 0x5b, 0xc1, 0x29, 0x5a,
+  0x79, 0x9d, 0x96, 0xc6, 0x63, 0x17, 0x20, 0x63, 0x8c, 0x32, 0xe5, 0x35,
+  0x50, 0x7b, 0xc6, 0xfa, 0xc9, 0x96, 0xdf, 0x3a, 0x75, 0x5a, 0xaa, 0xf3,
+  0x56, 0x15, 0x8a, 0xb0, 0x24, 0x4c, 0xe1, 0x34, 0xc1, 0x54, 0xbb, 0x10,
+  0x6b, 0x3c, 0xa1, 0x66, 0x86, 0x18, 0x5f, 0xe8, 0x5d, 0xe2, 0x76, 0x12,
+  0x84, 0xfb, 0x87, 0xf9, 0xba, 0x9c, 0xc3, 0xe2, 0x5e, 0xa4, 0xa8, 0xf2,
+  0x60, 0x71, 0x1c, 0xe2, 0xc5, 0x23, 0x8b, 0x3f, 0x35, 0x08, 0x15, 0xdc,
+  0x60, 0xdd, 0x12, 0x63, 0x69, 0xe9, 0x02, 0x93, 0x6f, 0x3b, 0x33, 0x95,
+  0x3c, 0x98, 0x33, 0x8b, 0x1e, 0x2f, 0x35, 0x33, 0xf6, 0xc3, 0xa5, 0xba,
+  0x23, 0x4c, 0x6c, 0x77, 0x72, 0x78, 0x4f, 0x5a, 0xd6, 0x6f, 0xe1, 0x4a,
+  0xe9, 0x93, 0xc1, 0x1e, 0xec, 0x84, 0xf9, 0x7b, 0x79, 0x5d, 0x42, 0x47,
+  0xff, 0xf4, 0x7e, 0x36, 0x7a, 0xe9, 0xd5, 0xf3, 0x80, 0xf4, 0xe5, 0xc9,
+  0x67, 0x5b, 0x22, 0xd5, 0xd7, 0x05, 0xd8, 0x93, 0x8c, 0x81, 0x41, 0x06,
+  0x75, 0x9e, 0x1c, 0xdc, 0x83, 0x40, 0x1d, 0xf7, 0xea, 0xac, 0x0d, 0xf3,
+  0x8e, 0xc8, 0x3d, 0x71, 0xbd, 0x58, 0xcf, 0x32, 0x76, 0xe2, 0xb8, 0xae,
+  0xdf, 0x6c, 0xf2, 0x75, 0x9a, 0xc5, 0x27, 0x2c, 0x70, 0x9a, 0x3d, 0x11,
+  0x26, 0xca, 0xea, 0xec, 0x8e, 0x9e, 0xe9, 0xa1, 0x2b, 0xa7, 0x72, 0x93,
+  0x17, 0xe9, 0x72, 0x19, 0xcf, 0xd9, 0x09, 0x77, 0x1d, 0x7f, 0x2c, 0x0f,
+  0x45, 0xf0, 0x48, 0x25, 0x4f, 0x76, 0x46, 0xa1, 0x8d, 0xa5, 0x22, 0xde,
+  0xd8, 0x2a, 0xf1, 0xda, 0x5d, 0x17, 0x76, 0x54, 0x09, 0x74, 0x9d, 0x08,
+  0xff, 0xc5, 0x3a, 0xa9, 0xca, 0x41, 0x37, 0x29, 0xd7, 0xa6, 0x73, 0xba,
+  0x69, 0x56, 0x7c, 0x54, 0xaf, 0xb2, 0xea, 0xa3, 0x7a, 0x9d, 0x55, 0x8d,
+  0xe2, 0xf3, 0xcd, 0x6d, 0x67, 0x22, 0xa8, 0xe9, 0x10, 0xb7, 0x95, 0xdd,
+  0x6e, 0xb5, 0x8b, 0xf3, 0x0d, 0x34, 0x2f, 0x14, 0x1c, 0xa5, 0x55, 0xd5,
+  0x4d, 0x56, 0x9f, 0x5f, 0xaa, 0xd7, 0xe0, 0x56, 0xcb, 0x90, 0xb7, 0xa1,
+  0x54, 0x29, 0x16, 0x18, 0x25, 0xe2, 0x0f, 0xd2, 0x4b, 0x26, 0xb7, 0xc6,
+  0xcb, 0xef, 0x1b, 0xef, 0x19, 0x02, 0x37, 0xac, 0x55, 0xef, 0x86, 0x71,
+  0xef, 0x86, 0x5f, 0x7b, 0x1e, 0x54, 0xac, 0xce, 0x6f, 0x54, 0xd6, 0xf8,
+  0x7d, 0xc0, 0x72, 0xfb, 0x28, 0x65, 0x06, 0xe4, 0xff, 0xf9, 0xa6, 0x83,
+  0x83, 0x8c, 0x38, 0x61, 0x13, 0x6c, 0x55, 0x03, 0xb2, 0xbc, 0x5e, 0xdc,
+  0x9d, 0x3d, 0x73, 0xbe, 0xb8, 0xa7, 0xcf, 0xd7, 0xed, 0xd9, 0x7b, 0x82,
+  0x48, 0x20, 0x7c, 0xaa, 0x83, 0xd1, 0x54, 0x83, 0x39, 0x6f, 0xf0, 0xf6,
+  0x78, 0xc5, 0x8f, 0x48, 0x6b, 0x35, 0xb6, 0x64, 0x82, 0x47, 0x1e, 0xf2,
+  0x85, 0x2b, 0x4c, 0x5e, 0xc2, 0x55, 0x45, 0x3d, 0xbb, 0xdc, 0x7a, 0x6c,
+  0xbf, 0x69, 0x53, 0x58, 0xd4, 0xfc, 0xf6, 0xf6, 0x1b, 0x76, 0xf8, 0xd4,
+  0x01, 0xe9, 0xbc, 0x26, 0x8c, 0x00, 0x33, 0x06, 0x93, 0x1a, 0xc7, 0xd7,
+  0xd5, 0x20, 0x52, 0xe0, 0xf6, 0xc5, 0x0c, 0x9d, 0x5d, 0x9d, 0x38, 0x00,
+  0x31, 0xb6, 0xab, 0x00, 0x35, 0xda, 0x57, 0x38, 0xdf, 0xae, 0x39, 0x52,
+  0x3b, 0xad, 0xe3, 0x1f, 0x7d, 0xdd, 0x80, 0x9f, 0xa3, 0x7a, 0xe8, 0xd6,
+  0xae, 0xbb, 0xbe, 0xdf, 0xce, 0x5e, 0x16, 0x9f, 0x5e, 0xa6, 0xba, 0xf1,
+  0xbe, 0x35, 0xba, 0x2d, 0x1a, 0x76, 0x8c, 0x26, 0xef, 0x37, 0x78, 0x53,
+  0x4d, 0x4f, 0x1c, 0xdf, 0x2f, 0x0a, 0xc4, 0x65, 0x57, 0x86, 0xc7, 0x1d,
+  0xd5, 0x39, 0x25, 0xd4, 0x0a, 0xa3, 0x6b, 0x50, 0x83, 0xde, 0x43, 0x0b,
+  0x93, 0x9e, 0xa8, 0x10, 0xad, 0x5d, 0x7f, 0x3f, 0x5f, 0xc7, 0x27, 0x03,
+  0xfc, 0x4f, 0x36, 0xcc, 0xe7, 0xbe, 0x13, 0x38, 0xae, 0xe3, 0x8e, 0x5d,
+  0x34, 0x30, 0xd8, 0x11, 0xd3, 0x15, 0x7b, 0xa1, 0xba, 0x0a, 0xfb, 0x3b,
+  0x35, 0xac, 0x15, 0xda, 0x2e, 0xca, 0xb8, 0x34, 0x41, 0x1a, 0xe2, 0x1b,
+  0x03, 0x48, 0xfe, 0x68, 0xf6, 0x0e, 0x34, 0xe4, 0x33, 0x45, 0x3f, 0x76,
+  0xec, 0xc4, 0xa7, 0x64, 0x4b, 0x22, 0x4d, 0x5c, 0x4d, 0x2c, 0x43, 0x06,
+  0x96, 0xd0, 0x84, 0x19, 0xe2, 0x6b, 0x62, 0x7c, 0xe3, 0x99, 0xa2, 0x1f,
+  0x27, 0x70, 0xb0, 0x08, 0x8a, 0xb0, 0xbf, 0xd0, 0xb3, 0x81, 0x0f, 0x4c,
+  0x11, 0xc0, 0x14, 0x8d, 0x28, 0x0e, 0x73, 0x35, 0xe4, 0x04, 0x46, 0xac,
+  0xab, 0xf5, 0xfb, 0xd1, 0x7e, 0xfa, 0xc0, 0x53, 0x9d, 0xc6, 0xa4, 0xe7,
+  0x21, 0x6b, 0xc3, 0x6a, 0x7d, 0xc9, 0xbf, 0x4a, 0x42, 0x0e, 0x8b, 0x5a,
+  0xad, 0x94, 0x17, 0xec, 0x8e, 0xdb, 0xb4, 0x58, 0x9d, 0x76, 0x0a, 0xd9,
+  0xc3, 0xf3, 0xc1, 0xa1, 0x85, 0xd2, 0xba, 0xba, 0x3e, 0xd5, 0x89, 0xe3,
+  0x1c, 0x89, 0x63, 0x7c, 0x76, 0x97, 0x1e, 0xde, 0x03, 0xcf, 0x7b, 0xa8,
+  0xb9, 0x5e, 0x19, 0xd4, 0x34, 0xf9, 0x8b, 0x4e, 0x63, 0x0e, 0x2b, 0x7c,
+  0x37, 0xbc, 0x79, 0x20, 0xcc, 0x93, 0x04, 0xe7, 0x6c, 0x05, 0x09, 0xdb,
+  0x43, 0x69, 0x82, 0xdf, 0xdd, 0xb6, 0x0e, 0xcc, 0x73, 0x63, 0x8e, 0xce,
+  0x04, 0xbf, 0x3e, 0xef, 0x8a, 0xe1, 0x4e, 0xd3, 0x6a, 0xad, 0x21, 0x4b,
+  0xd0, 0x74, 0xd3, 0x06, 0x0e, 0x9d, 0xeb, 0x45, 0x1b, 0xe1, 0x3b, 0xf4,
+  0xf8, 0x5b, 0x5d, 0xc4, 0x03, 0xa5, 0x55, 0x01, 0xd4, 0x78, 0x56, 0x96,
+  0x6c, 0x2b, 0x8b, 0xde, 0xc3, 0x34, 0x5d, 0x23, 0x2c, 0xc3, 0x11, 0x77,
+  0xba, 0xab, 0x20, 0xa8, 0x52, 0xe9, 0xf7, 0x02, 0x6b, 0x3f, 0x40, 0xca,
+  0x4e, 0x1e, 0x86, 0x22, 0x89, 0x3b, 0x82, 0x20, 0xec, 0x1b, 0x77, 0x83,
+  0xe0, 0x4a, 0xad, 0x3e, 0xdf, 0x25, 0xa9, 0xdb, 0xd4, 0x00, 0x69, 0x03,
+  0xd7, 0x37, 0x8b, 0x6c, 0xee, 0xee, 0x49, 0x0d, 0x3a, 0x8d, 0x87, 0x44,
+  0x54, 0x63, 0x8f, 0xc4, 0x71, 0xc1, 0xad, 0x23, 0xd0, 0x54, 0xc3, 0x5a,
+  0x98, 0x3c, 0x8e, 0x7d, 0x55, 0x5e, 0xad, 0xb2, 0xd2, 0xb0, 0x0d, 0x12,
+  0x48, 0x08, 0x37, 0x6b, 0x1d, 0x26, 0xfd, 0xff, 0x91, 0x75, 0xab, 0xf5,
+  0xf9, 0x39, 0xde, 0x15, 0x7f, 0x7f, 0xf3, 0x66, 0x80, 0xfc, 0x3e, 0x9c,
+  0xdd, 0x83, 0xd4, 0x6f, 0xba, 0xc1, 0xe5, 0x9d, 0x45, 0xab, 0xe5, 0x39,
+  0x82, 0x84, 0x9a, 0x7f, 0x27, 0x8b, 0xc1, 0x6d, 0x43, 0x21, 0xca, 0x1c,
+  0xdd, 0x86, 0x0f, 0xa7, 0x37, 0xef, 0x73, 0xae, 0xb6, 0x25, 0xfe, 0x61,
+  0x5d, 0xab, 0x4c, 0xf1, 0x9d, 0xa7, 0x5a, 0xb2, 0xba, 0xc6, 0xa6, 0x96,
+  0xb3, 0x85, 0xc0, 0x16, 0x1d, 0x46, 0x1f, 0x31, 0x84, 0x23, 0xd3, 0xba,
+  0x42, 0xf4, 0xf0, 0xcd, 0xfd, 0xa6, 0x5e, 0x7e, 0x26, 0xfa, 0x7a, 0x12,
+  0x1d, 0x99, 0x5b, 0x4a, 0x74, 0x98, 0x97, 0xfd, 0xd1, 0xa8, 0x4b, 0xdc,
+  0xb2, 0x16, 0x2d, 0x19, 0xb3, 0x99, 0x68, 0xc6, 0x4c, 0xbb, 0x65, 0x66,
+  0xb8, 0x27, 0x3b, 0xdc, 0x2d, 0x52, 0xf9, 0x5f, 0xe0, 0xff, 0x61, 0x05,
+  0xb9, 0x4b, 0x0e, 0x10, 0x35, 0x31, 0x0b, 0x5a, 0x05, 0x52, 0x0e, 0xfd,
+  0x7d, 0xdc, 0x75, 0x06, 0x80, 0xd6, 0x2a, 0xbd, 0xc0, 0x65, 0x47, 0x54,
+  0xc7, 0x97, 0xd4, 0xe7, 0x02, 0x77, 0x22, 0x8a, 0xab, 0x91, 0xb9, 0x21,
+  0x01, 0xec, 0xfc, 0x30, 0x4e, 0xdb, 0x31, 0xcf, 0x65, 0xcd, 0xe2, 0x4f,
+  0xc1, 0xab, 0x34, 0xbf, 0xe0, 0xef, 0xa7, 0x5f, 0xde, 0x5e, 0xac, 0x4f,
+  0xde, 0xb9, 0xd5, 0xdf, 0x8b, 0xbf, 0x65, 0xc3, 0x7f, 0x4c, 0xd6, 0xaf,
+  0xe3, 0xfd, 0x2f, 0xaf, 0xdf, 0xe7, 0x5f, 0xde, 0xb1, 0xe2, 0x53, 0xf8,
+  0x32, 0x6d, 0x3a, 0x08, 0x1a, 0x70, 0x5b, 0x34, 0x9c, 0x26, 0xcd, 0x98,
+  0x2e, 0xe4, 0x98, 0x1d, 0x8b, 0x80, 0x20, 0x58, 0xe2, 0xc3, 0xae, 0x6f,
+  0xbe, 0xb8, 0xfd, 0x94, 0xfe, 0x46, 0x9f, 0xa1, 0x9a, 0x0f, 0x9b, 0x00,
+  0x69, 0xae, 0xc4, 0x99, 0xf6, 0xe2, 0x00, 0x70, 0xae, 0x68, 0xd7, 0x8b,
+  0xac, 0x49, 0x1a, 0x33, 0x23, 0x32, 0x10, 0x7f, 0x28, 0xde, 0x1e, 0x5f,
+  0xd0, 0x4f, 0x78, 0x4f, 0xa4, 0xdf, 0xb3, 0x15, 0xd9, 0xdc, 0x81, 0xcc,
+  0xab, 0x49, 0x58, 0xde, 0xa8, 0x73, 0xe9, 0xd0, 0x64, 0xfb, 0xb3, 0x93,
+  0x66, 0xf7, 0xe3, 0x80, 0x5f, 0xf3, 0x33, 0x18, 0xa1, 0xb1, 0xe0, 0xe8,
+  0xe1, 0xb9, 0x6f, 0x8e, 0x3c, 0xa8, 0xb9, 0x63, 0x5f, 0x61, 0xc1, 0xa2,
+  0xf5, 0x68, 0xf2, 0xe8, 0xb0, 0x20, 0x0f, 0xf3, 0xd8, 0x02, 0xfb, 0x7c,
+  0xb0, 0x9a, 0xcf, 0x64, 0xe0, 0xf1, 0xe5, 0x83, 0x39, 0x58, 0x16, 0x86,
+  0x23, 0x0e, 0x3d, 0xad, 0x56, 0xf0, 0xb9, 0x52, 0xe5, 0xb6, 0xf8, 0x0f,
+  0x50, 0xdd, 0x7d, 0xcc, 0xa9, 0x11, 0x00, 0x00
+};
 
 const GFXglyph Antonio_SemiBold20pt7bGlyphs[] PROGMEM = {
-  {     0,   1,   1,   8,    0,    0 },   // 0x20 ' '
-  {     1,   4,  34,  10,    3,  -33 },   // 0x21 '!'
-  {    18,   5,  13,  16,    6,  -33 },   // 0x22 '"'
-  {    27,  17,  34,  20,    2,  -33 },   // 0x23 '#'
-  {   100,  13,  39,  16,    2,  -33 },   // 0x24 '$'
-  {   164,  36,  34,  42,    3,  -33 },   // 0x25 '%'
-  {   317,  18,  34,  19,    1,  -33 },   // 0x26 '&'
-  {   394,   4,  12,   8,    2,  -33 },   // 0x27 '''
-  {   400,   7,  38,  11,    3,  -33 },   // 0x28 '('
-  {   434,   7,  38,  11,    2,  -33 },   // 0x29 ')'
-  {   468,  14,  15,  17,    2,  -32 },   // 0x2A '*'
-  {   495,  12,  12,  14,    1,  -20 },   // 0x2B '+'
-  {   513,   5,  12,   9,    2,   -4 },   // 0x2C ','
-  {   521,   9,   3,  13,    2,  -16 },   // 0x2D '-'
-  {   525,   4,   4,  10,    3,   -3 },   // 0x2E '.'
-  {   527,  13,  34,  15,    1,  -33 },   // 0x2F '/'
-  {   583,  13,  34,  18,    2,  -33 },   // 0x30 '0'
-  {   639,   9,  34,  15,    2,  -33 },   // 0x31 '1'
-  {   678,  13,  34,  17,    3,  -33 },   // 0x32 '2'
-  {   734,  14,  34,  17,    2,  -33 },   // 0x33 '3'
-  {   794,  14,  34,  17,    2,  -33 },   // 0x34 '4'
-  {   854,  12,  34,  17,    3,  -33 },   // 0x35 '5'
-  {   905,  14,  34,  17,    2,  -33 },   // 0x36 '6'
-  {   965,  14,  34,  17,    2,  -33 },   // 0x37 '7'
-  {  1025,  13,  34,  17,    2,  -33 },   // 0x38 '8'
-  {  1081,  13,  34,  17,    2,  -33 },   // 0x39 '9'
-  {  1137,   4,  20,  10,    3,  -24 },   // 0x3A ':'
-  {  1147,   5,  27,  11,    3,  -24 },   // 0x3B ';'
-  {  1164,  11,  19,  14,    1,  -23 },   // 0x3C '<'
-  {  1191,  10,   9,  14,    2,  -19 },   // 0x3D '='
-  {  1203,  11,  19,  14,    2,  -23 },   // 0x3E '>'
-  {  1230,  12,  34,  17,    3,  -33 },   // 0x3F '?'
-  {  1281,  25,  35,  29,    2,  -33 },   // 0x40 '@'
-  {  1391,  16,  34,  18,    1,  -33 },   // 0x41 'A'
-  {  1459,  14,  34,  18,    3,  -33 },   // 0x42 'B'
-  {  1519,  14,  34,  18,    2,  -33 },   // 0x43 'C'
-  {  1579,  13,  34,  19,    3,  -33 },   // 0x44 'D'
-  {  1635,  10,  34,  15,    3,  -33 },   // 0x45 'E'
-  {  1678,  10,  34,  15,    3,  -33 },   // 0x46 'F'
-  {  1721,  14,  34,  18,    2,  -33 },   // 0x47 'G'
-  {  1781,  14,  34,  19,    3,  -33 },   // 0x48 'H'
-  {  1841,   4,  34,  10,    3,  -33 },   // 0x49 'I'
-  {  1858,  13,  34,  17,    2,  -33 },   // 0x4A 'J'
-  {  1914,  15,  34,  18,    3,  -33 },   // 0x4B 'K'
-  {  1978,  10,  34,  14,    3,  -33 },   // 0x4C 'L'
-  {  2021,  20,  34,  26,    3,  -33 },   // 0x4D 'M'
-  {  2106,  14,  34,  20,    3,  -33 },   // 0x4E 'N'
-  {  2166,  14,  34,  19,    2,  -33 },   // 0x4F 'O'
-  {  2226,  13,  34,  17,    3,  -33 },   // 0x50 'P'
-  {  2282,  14,  39,  19,    2,  -33 },   // 0x51 'Q'
-  {  2351,  14,  34,  18,    3,  -33 },   // 0x52 'R'
-  {  2411,  14,  34,  16,    1,  -33 },   // 0x53 'S'
-  {  2471,  12,  34,  13,    0,  -33 },   // 0x54 'T'
-  {  2522,  14,  34,  19,    2,  -33 },   // 0x55 'U'
-  {  2582,  16,  34,  17,    1,  -33 },   // 0x56 'V'
-  {  2650,  24,  34,  26,    1,  -33 },   // 0x57 'W'
-  {  2752,  14,  34,  16,    1,  -33 },   // 0x58 'X'
-  {  2812,  16,  34,  16,    0,  -33 },   // 0x59 'Y'
-  {  2880,  12,  34,  14,    1,  -33 },   // 0x5A 'Z'
-  {  2931,   8,  35,  13,    3,  -33 },   // 0x5B '['
-  {  2966,  11,  34,  15,    2,  -33 },   // 0x5C '\'
-  {  3013,   8,  35,  13,    2,  -33 },   // 0x5D ']'
-  {  3048,  15,  18,  18,    2,  -33 },   // 0x5E '^'
-  {  3082,  12,   3,  14,    1,    2 },   // 0x5F '_'
-  {  3087,   6,   8,   8,    1,  -38 },   // 0x60 '`'
-  {  3093,  14,  29,  18,    2,  -28 },   // 0x61 'a'
-  {  3144,  13,  34,  18,    3,  -33 },   // 0x62 'b'
-  {  3200,  13,  29,  17,    2,  -28 },   // 0x63 'c'
-  {  3248,  14,  34,  18,    2,  -33 },   // 0x64 'd'
-  {  3308,  14,  29,  17,    2,  -28 },   // 0x65 'e'
-  {  3359,  10,  34,  13,    1,  -33 },   // 0x66 'f'
-  {  3402,  14,  33,  18,    2,  -28 },   // 0x67 'g'
-  {  3460,  13,  34,  19,    3,  -33 },   // 0x68 'h'
-  {  3516,   4,  35,  10,    3,  -34 },   // 0x69 'i'
-  {  3534,   7,  39,  10,    1,  -34 },   // 0x6A 'j'
-  {  3569,  14,  34,  18,    3,  -33 },   // 0x6B 'k'
-  {  3629,   4,  34,  10,    3,  -33 },   // 0x6C 'l'
-  {  3646,  22,  29,  28,    3,  -28 },   // 0x6D 'm'
-  {  3726,  13,  29,  19,    3,  -28 },   // 0x6E 'n'
-  {  3774,  14,  29,  18,    2,  -28 },   // 0x6F 'o'
-  {  3825,  13,  34,  18,    3,  -28 },   // 0x70 'p'
-  {  3881,  14,  34,  18,    2,  -28 },   // 0x71 'q'
-  {  3941,   9,  29,  13,    3,  -28 },   // 0x72 'r'
-  {  3974,  13,  29,  16,    2,  -28 },   // 0x73 's'
-  {  4022,  10,  34,  12,    1,  -33 },   // 0x74 't'
-  {  4065,  14,  29,  19,    2,  -28 },   // 0x75 'u'
-  {  4116,  14,  29,  15,    1,  -28 },   // 0x76 'v'
-  {  4167,  21,  29,  23,    1,  -28 },   // 0x77 'w'
-  {  4244,  14,  29,  15,    1,  -28 },   // 0x78 'x'
-  {  4295,  14,  34,  16,    1,  -28 },   // 0x79 'y'
-  {  4355,  11,  29,  13,    1,  -28 },   // 0x7A 'z'
-  {  4395,  10,  37,  14,    2,  -33 },   // 0x7B '{'
-  {  4442,   4,  37,  10,    3,  -34 },   // 0x7C '|'
-  {  4461,  10,  37,  14,    2,  -33 },   // 0x7D '}'
-  {  4508,  17,   6,  21,    2,  -21 } }; // 0x7E '~'
+    {0, 1, 1, 8, 0, 0},         // 0x20 ' '
+    {1, 4, 34, 10, 3, -33},     // 0x21 '!'
+    {18, 5, 13, 16, 6, -33},    // 0x22 '"'
+    {27, 17, 34, 20, 2, -33},   // 0x23 '#'
+    {100, 13, 39, 16, 2, -33},  // 0x24 '$'
+    {164, 36, 34, 42, 3, -33},  // 0x25 '%'
+    {317, 18, 34, 19, 1, -33},  // 0x26 '&'
+    {394, 4, 12, 8, 2, -33},    // 0x27 '''
+    {400, 7, 38, 11, 3, -33},   // 0x28 '('
+    {434, 7, 38, 11, 2, -33},   // 0x29 ')'
+    {468, 14, 15, 17, 2, -32},  // 0x2A '*'
+    {495, 12, 12, 14, 1, -20},  // 0x2B '+'
+    {513, 5, 12, 9, 2, -4},     // 0x2C ','
+    {521, 9, 3, 13, 2, -16},    // 0x2D '-'
+    {525, 4, 4, 10, 3, -3},     // 0x2E '.'
+    {527, 13, 34, 15, 1, -33},  // 0x2F '/'
+    {583, 13, 34, 18, 2, -33},  // 0x30 '0'
+    {639, 9, 34, 15, 2, -33},   // 0x31 '1'
+    {678, 13, 34, 17, 3, -33},  // 0x32 '2'
+    {734, 14, 34, 17, 2, -33},  // 0x33 '3'
+    {794, 14, 34, 17, 2, -33},  // 0x34 '4'
+    {854, 12, 34, 17, 3, -33},  // 0x35 '5'
+    {905, 14, 34, 17, 2, -33},  // 0x36 '6'
+    {965, 14, 34, 17, 2, -33},  // 0x37 '7'
+    {1025, 13, 34, 17, 2, -33}, // 0x38 '8'
+    {1081, 13, 34, 17, 2, -33}, // 0x39 '9'
+    {1137, 4, 20, 10, 3, -24},  // 0x3A ':'
+    {1147, 5, 27, 11, 3, -24},  // 0x3B ';'
+    {1164, 11, 19, 14, 1, -23}, // 0x3C '<'
+    {1191, 10, 9, 14, 2, -19},  // 0x3D '='
+    {1203, 11, 19, 14, 2, -23}, // 0x3E '>'
+    {1230, 12, 34, 17, 3, -33}, // 0x3F '?'
+    {1281, 25, 35, 29, 2, -33}, // 0x40 '@'
+    {1391, 16, 34, 18, 1, -33}, // 0x41 'A'
+    {1459, 14, 34, 18, 3, -33}, // 0x42 'B'
+    {1519, 14, 34, 18, 2, -33}, // 0x43 'C'
+    {1579, 13, 34, 19, 3, -33}, // 0x44 'D'
+    {1635, 10, 34, 15, 3, -33}, // 0x45 'E'
+    {1678, 10, 34, 15, 3, -33}, // 0x46 'F'
+    {1721, 14, 34, 18, 2, -33}, // 0x47 'G'
+    {1781, 14, 34, 19, 3, -33}, // 0x48 'H'
+    {1841, 4, 34, 10, 3, -33},  // 0x49 'I'
+    {1858, 13, 34, 17, 2, -33}, // 0x4A 'J'
+    {1914, 15, 34, 18, 3, -33}, // 0x4B 'K'
+    {1978, 10, 34, 14, 3, -33}, // 0x4C 'L'
+    {2021, 20, 34, 26, 3, -33}, // 0x4D 'M'
+    {2106, 14, 34, 20, 3, -33}, // 0x4E 'N'
+    {2166, 14, 34, 19, 2, -33}, // 0x4F 'O'
+    {2226, 13, 34, 17, 3, -33}, // 0x50 'P'
+    {2282, 14, 39, 19, 2, -33}, // 0x51 'Q'
+    {2351, 14, 34, 18, 3, -33}, // 0x52 'R'
+    {2411, 14, 34, 16, 1, -33}, // 0x53 'S'
+    {2471, 12, 34, 13, 0, -33}, // 0x54 'T'
+    {2522, 14, 34, 19, 2, -33}, // 0x55 'U'
+    {2582, 16, 34, 17, 1, -33}, // 0x56 'V'
+    {2650, 24, 34, 26, 1, -33}, // 0x57 'W'
+    {2752, 14, 34, 16, 1, -33}, // 0x58 'X'
+    {2812, 16, 34, 16, 0, -33}, // 0x59 'Y'
+    {2880, 12, 34, 14, 1, -33}, // 0x5A 'Z'
+    {2931, 8, 35, 13, 3, -33},  // 0x5B '['
+    {2966, 11, 34, 15, 2, -33}, // 0x5C '\'
+    {3013, 8, 35, 13, 2, -33},  // 0x5D ']'
+    {3048, 15, 18, 18, 2, -33}, // 0x5E '^'
+    {3082, 12, 3, 14, 1, 2},    // 0x5F '_'
+    {3087, 6, 8, 8, 1, -38},    // 0x60 '`'
+    {3093, 14, 29, 18, 2, -28}, // 0x61 'a'
+    {3144, 13, 34, 18, 3, -33}, // 0x62 'b'
+    {3200, 13, 29, 17, 2, -28}, // 0x63 'c'
+    {3248, 14, 34, 18, 2, -33}, // 0x64 'd'
+    {3308, 14, 29, 17, 2, -28}, // 0x65 'e'
+    {3359, 10, 34, 13, 1, -33}, // 0x66 'f'
+    {3402, 14, 33, 18, 2, -28}, // 0x67 'g'
+    {3460, 13, 34, 19, 3, -33}, // 0x68 'h'
+    {3516, 4, 35, 10, 3, -34},  // 0x69 'i'
+    {3534, 7, 39, 10, 1, -34},  // 0x6A 'j'
+    {3569, 14, 34, 18, 3, -33}, // 0x6B 'k'
+    {3629, 4, 34, 10, 3, -33},  // 0x6C 'l'
+    {3646, 22, 29, 28, 3, -28}, // 0x6D 'm'
+    {3726, 13, 29, 19, 3, -28}, // 0x6E 'n'
+    {3774, 14, 29, 18, 2, -28}, // 0x6F 'o'
+    {3825, 13, 34, 18, 3, -28}, // 0x70 'p'
+    {3881, 14, 34, 18, 2, -28}, // 0x71 'q'
+    {3941, 9, 29, 13, 3, -28},  // 0x72 'r'
+    {3974, 13, 29, 16, 2, -28}, // 0x73 's'
+    {4022, 10, 34, 12, 1, -33}, // 0x74 't'
+    {4065, 14, 29, 19, 2, -28}, // 0x75 'u'
+    {4116, 14, 29, 15, 1, -28}, // 0x76 'v'
+    {4167, 21, 29, 23, 1, -28}, // 0x77 'w'
+    {4244, 14, 29, 15, 1, -28}, // 0x78 'x'
+    {4295, 14, 34, 16, 1, -28}, // 0x79 'y'
+    {4355, 11, 29, 13, 1, -28}, // 0x7A 'z'
+    {4395, 10, 37, 14, 2, -33}, // 0x7B '{'
+    {4442, 4, 37, 10, 3, -34},  // 0x7C '|'
+    {4461, 10, 37, 14, 2, -33}, // 0x7D '}'
+    {4508, 17, 6, 21, 2, -21}}; // 0x7E '~'
 
-const GFXfont Antonio_SemiBold20pt7b PROGMEM = {
-  (uint8_t  *)Antonio_SemiBold20pt7bBitmaps,
-  (GFXglyph *)Antonio_SemiBold20pt7bGlyphs,
-  0x20, 0x7E, 51 };
-
-// Approx. 5193 bytes
+// Font properties
+static constexpr FontData Antonio_SemiBold20pt7b_Properties = {
+    Antonio_SemiBold20pt7bBitmaps_Gzip,
+    Antonio_SemiBold20pt7bGlyphs,
+    sizeof(Antonio_SemiBold20pt7bBitmaps_Gzip),
+    4521,  // Original size
+    0x20,   // First char
+    0x7E,   // Last char
+    51     // yAdvance
+};

src/fonts/antonio-semibold40.h

@@ -0,0 +1,613 @@
+#pragma once
+
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+
+const uint8_t Antonio_SemiBold40pt7bBitmaps_Gzip[] = {
+  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe5, 0x5c,
+  0xbd, 0x72, 0xec, 0x3a, 0x72, 0x06, 0x8b, 0x5b, 0x66, 0xb2, 0x65, 0xdc,
+  0xd0, 0x81, 0x77, 0xf1, 0x0a, 0x1b, 0x3a, 0xb8, 0x75, 0xe0, 0x47, 0x72,
+  0xe8, 0xe0, 0x78, 0x40, 0x95, 0x02, 0x85, 0xf3, 0x08, 0x7a, 0x93, 0x15,
+  0x55, 0x0a, 0x14, 0xce, 0x23, 0x0c, 0x65, 0x05, 0x0a, 0x05, 0x95, 0x02,
+  0x41, 0x25, 0x0a, 0xed, 0xef, 0x6b, 0x90, 0x1c, 0xce, 0x48, 0x3a, 0xd2,
+  0xf9, 0xdd, 0x5b, 0xde, 0x39, 0x73, 0x40, 0x70, 0x48, 0x82, 0x0d, 0xa0,
+  0x7f, 0xbe, 0xee, 0x06, 0x64, 0x64, 0xfc, 0x3c, 0xe6, 0x70, 0x7a, 0x73,
+  0x50, 0xa4, 0xc1, 0xdb, 0x8b, 0x78, 0x58, 0xfc, 0xb5, 0x39, 0xea, 0xff,
+  0x7b, 0x2e, 0xcc, 0xf8, 0xb1, 0x4f, 0x59, 0xce, 0x6e, 0xb5, 0x48, 0x22,
+  0xb7, 0xd3, 0x99, 0xbb, 0xbc, 0x1b, 0x02, 0x8a, 0xb4, 0x72, 0x27, 0x57,
+  0x2c, 0xce, 0xe3, 0x67, 0x63, 0x9a, 0xde, 0xb7, 0x55, 0xb2, 0x9d, 0xc9,
+  0x75, 0x34, 0xfe, 0x68, 0x30, 0xb6, 0x0f, 0xa6, 0x8e, 0xae, 0x33, 0x43,
+  0x83, 0x1f, 0xaa, 0x64, 0x5c, 0xb7, 0x32, 0x4d, 0xc4, 0x5d, 0x83, 0xed,
+  0xcd, 0xaa, 0xc6, 0x0f, 0x6d, 0xe6, 0x63, 0xa6, 0xd6, 0xc7, 0x9a, 0xf1,
+  0xb1, 0x6e, 0x7e, 0xac, 0x37, 0x41, 0x1f, 0xcb, 0x35, 0x3a, 0x33, 0xb0,
+  0x47, 0x1e, 0xff, 0x37, 0xf8, 0x7f, 0xcf, 0x1f, 0xea, 0xe4, 0xc6, 0xc7,
+  0xaa, 0xf9, 0x31, 0x34, 0xbe, 0x7b, 0x6c, 0xa2, 0x89, 0x6f, 0xc3, 0x5d,
+  0xed, 0xf0, 0x7a, 0x3b, 0xcd, 0xfc, 0xd8, 0x8e, 0xa6, 0x45, 0x57, 0xda,
+  0xb1, 0x2b, 0x69, 0xee, 0xca, 0x30, 0x76, 0xc5, 0x95, 0xae, 0xbc, 0xfe,
+  0xd8, 0x72, 0x04, 0x8c, 0xc3, 0xf8, 0x74, 0xa6, 0x8a, 0xc6, 0x7c, 0x7e,
+  0x79, 0x12, 0x92, 0x09, 0xd2, 0x7a, 0x89, 0x4e, 0x06, 0x2b, 0x72, 0x2c,
+  0x72, 0x07, 0xaa, 0xc2, 0xb9, 0xb8, 0xe8, 0x6f, 0x13, 0x26, 0xa1, 0xca,
+  0xd2, 0x86, 0xb3, 0xde, 0xdd, 0xa6, 0x66, 0x3c, 0x39, 0xed, 0xdd, 0xcd,
+  0xd0, 0x3c, 0x4a, 0x95, 0x43, 0x1f, 0xd6, 0x83, 0xa9, 0x05, 0xcd, 0xf4,
+  0xc6, 0x65, 0xd4, 0x3a, 0x36, 0xe8, 0x04, 0x35, 0x90, 0x06, 0x22, 0xa4,
+  0x35, 0x12, 0x8d, 0xe3, 0x4d, 0xad, 0x09, 0xd1, 0xd8, 0xc1, 0x54, 0xac,
+  0xdd, 0x24, 0xfb, 0x88, 0x91, 0x0d, 0x6d, 0xd8, 0xf6, 0xee, 0x21, 0x35,
+  0xcf, 0xb9, 0xc2, 0x89, 0xdf, 0xf6, 0xf6, 0x21, 0xd5, 0x7a, 0xd2, 0x85,
+  0x6d, 0x74, 0x0f, 0xd9, 0x0e, 0x72, 0x99, 0x31, 0x62, 0x27, 0x22, 0x57,
+  0x22, 0xd1, 0x4b, 0x6a, 0x64, 0x30, 0x82, 0x0e, 0x0f, 0xc6, 0xfc, 0x0e,
+  0x36, 0x31, 0xa6, 0x46, 0x1f, 0xe3, 0x8b, 0x13, 0xbe, 0x46, 0x3f, 0x0d,
+  0x48, 0x31, 0x4d, 0x42, 0x6f, 0x05, 0x05, 0xc6, 0xd0, 0x78, 0xb4, 0xb0,
+  0xab, 0x60, 0x10, 0x31, 0x04, 0x79, 0xac, 0x3c, 0x4c, 0x95, 0x23, 0xf4,
+  0x8a, 0xa3, 0x27, 0x66, 0x59, 0xf1, 0xed, 0x5e, 0x25, 0x2c, 0x2a, 0xf8,
+  0x1e, 0x54, 0xf2, 0x9b, 0x15, 0xcc, 0xe2, 0x41, 0xa5, 0x9e, 0x2b, 0xe9,
+  0xb0, 0x42, 0x4a, 0xc7, 0x0a, 0x46, 0x91, 0x15, 0x1b, 0xad, 0xf4, 0x5a,
+  0xe9, 0x9d, 0xc4, 0x52, 0xc1, 0xc8, 0xb0, 0xe2, 0xba, 0x00, 0x2e, 0x5b,
+  0x56, 0x7c, 0x27, 0xb7, 0x59, 0x2b, 0x2d, 0xa6, 0x6c, 0xaf, 0x12, 0x40,
+  0x50, 0xa9, 0x54, 0x63, 0x05, 0x17, 0x8c, 0xb0, 0x83, 0x79, 0xaf, 0xc2,
+  0x0b, 0x83, 0x56, 0x8e, 0xf2, 0x58, 0x91, 0x5c, 0x6b, 0xc5, 0xa3, 0x92,
+  0x4a, 0x65, 0x28, 0x15, 0x8c, 0x73, 0x13, 0x59, 0xb1, 0x12, 0x4b, 0x05,
+  0xdc, 0x60, 0xb5, 0xa2, 0x94, 0x6a, 0xc5, 0xec, 0x2a, 0x6e, 0xae, 0x74,
+  0x63, 0xc5, 0xcf, 0x95, 0xf6, 0xb0, 0x12, 0xe6, 0x8a, 0x19, 0x2b, 0x32,
+  0x55, 0xf2, 0x61, 0xa5, 0xd2, 0x0a, 0xc6, 0x9c, 0xa3, 0xac, 0x15, 0x8e,
+  0x32, 0x3b, 0xa4, 0x83, 0x2b, 0x73, 0xe5, 0x38, 0x17, 0x0e, 0x09, 0x13,
+  0x63, 0x68, 0xc5, 0x2a, 0x87, 0xa4, 0xc2, 0x0f, 0x73, 0x05, 0x03, 0x4e,
+  0x92, 0xc9, 0x57, 0xdd, 0xa8, 0xaa, 0x20, 0x49, 0x36, 0x95, 0x1f, 0x6a,
+  0x3e, 0x28, 0xa8, 0x40, 0x9c, 0xf0, 0x03, 0xd9, 0x7f, 0x0b, 0x79, 0x84,
+  0x2c, 0x36, 0x54, 0x05, 0x62, 0x20, 0xbe, 0xbd, 0x6b, 0xeb, 0x01, 0x52,
+  0x2a, 0xed, 0xca, 0xb8, 0x68, 0xd1, 0x57, 0x68, 0x0c, 0xdf, 0xf9, 0xf1,
+  0x16, 0x4a, 0x38, 0x85, 0x59, 0x95, 0xcb, 0x39, 0x5a, 0x49, 0x60, 0xb1,
+  0xb0, 0xee, 0x8d, 0xbd, 0x87, 0xf0, 0xe4, 0x40, 0x12, 0x7a, 0xbc, 0x48,
+  0xe9, 0x1d, 0xc9, 0x50, 0x9a, 0xd8, 0x51, 0x32, 0xbd, 0x07, 0x71, 0x90,
+  0x33, 0x15, 0x39, 0x23, 0xca, 0xf8, 0xe6, 0x37, 0x48, 0xc1, 0xbf, 0x54,
+  0x92, 0xab, 0xce, 0x4b, 0xf7, 0x3b, 0x5a, 0xb2, 0x17, 0x39, 0x1c, 0xa7,
+  0xb0, 0x8e, 0xe1, 0x34, 0x8a, 0xbb, 0x1e, 0xdc, 0x75, 0x92, 0x23, 0xa8,
+  0x57, 0xf0, 0xd1, 0xc5, 0xd0, 0x28, 0x53, 0x65, 0xd7, 0x5b, 0x39, 0x86,
+  0xb0, 0xc5, 0xd0, 0xba, 0x01, 0x13, 0x88, 0x1b, 0xd0, 0xb8, 0xef, 0x9a,
+  0x01, 0x83, 0x45, 0x4e, 0xf4, 0xd1, 0xf5, 0x8d, 0x80, 0x0f, 0xa4, 0x87,
+  0xbc, 0x42, 0x56, 0x9d, 0x74, 0x54, 0x6a, 0x0e, 0xc5, 0x11, 0x94, 0x36,
+  0xc5, 0x15, 0x93, 0x9f, 0xd9, 0x2a, 0x18, 0x47, 0x3a, 0x3c, 0xdb, 0x73,
+  0x7c, 0x44, 0x02, 0x3e, 0xab, 0xf2, 0xf9, 0xf4, 0xe9, 0xf7, 0xf2, 0x31,
+  0x9f, 0x6d, 0x94, 0x4b, 0xf1, 0x83, 0x3c, 0xc8, 0x36, 0x85, 0xf3, 0x6c,
+  0x93, 0xef, 0x31, 0x39, 0x3f, 0xf5, 0xe0, 0x22, 0x94, 0xdd, 0x09, 0x14,
+  0xb2, 0x1f, 0x42, 0x04, 0xf9, 0xe6, 0xcf, 0xa9, 0x46, 0x4f, 0x7c, 0x82,
+  0x7e, 0xbe, 0xc5, 0x1d, 0xcd, 0xa0, 0x77, 0xe8, 0xa1, 0x43, 0x5f, 0x6d,
+  0xf4, 0x3f, 0xf2, 0x30, 0x35, 0x7d, 0x2e, 0x76, 0x08, 0xb7, 0x72, 0x96,
+  0xf1, 0xda, 0xf5, 0xe0, 0xbb, 0xae, 0x28, 0x1d, 0x32, 0x26, 0xb9, 0xcf,
+  0x54, 0x26, 0xfd, 0xe9, 0xcf, 0x4d, 0xd7, 0xa7, 0x4f, 0x76, 0x7d, 0x15,
+  0x87, 0xb0, 0x3e, 0x7d, 0x90, 0xff, 0x91, 0xad, 0x48, 0xc2, 0x60, 0x83,
+  0x3b, 0x55, 0xdd, 0x62, 0x52, 0x8a, 0xf2, 0xcd, 0xe4, 0x60, 0xa8, 0xf3,
+  0x47, 0xd9, 0x86, 0x87, 0xf4, 0x28, 0xee, 0xe4, 0x22, 0xe1, 0xc9, 0xe3,
+  0x2a, 0xfe, 0xc7, 0x6f, 0xb6, 0xfd, 0x4f, 0x33, 0x8c, 0xcd, 0xb6, 0x45,
+  0x01, 0xad, 0xde, 0xfc, 0xca, 0x8b, 0xcf, 0x07, 0x6f, 0x8e, 0x03, 0x5e,
+  0x77, 0x15, 0x3f, 0xbb, 0xe6, 0x82, 0x34, 0xd7, 0xdd, 0x5e, 0x23, 0x71,
+  0x6e, 0xcd, 0x94, 0x6f, 0x1e, 0x85, 0xb5, 0x7c, 0x21, 0xa6, 0xf3, 0x17,
+  0xac, 0x36, 0x7f, 0x21, 0x91, 0xf3, 0x17, 0x22, 0x38, 0x7f, 0x7d, 0xb7,
+  0xfb, 0x86, 0x76, 0xf1, 0x9d, 0x9a, 0x3f, 0x78, 0xc3, 0xa2, 0xf9, 0x7a,
+  0xd1, 0x7c, 0xb3, 0x68, 0xde, 0x2e, 0x9a, 0x77, 0x8b, 0xe6, 0xfd, 0x9b,
+  0xcd, 0xab, 0x11, 0x84, 0x44, 0x42, 0x41, 0x40, 0xf0, 0x2b, 0x74, 0x32,
+  0x08, 0x54, 0x20, 0xcd, 0xd6, 0x10, 0x7a, 0xd9, 0xc0, 0xe2, 0xe1, 0x57,
+  0xdf, 0xb9, 0x9b, 0x54, 0x53, 0x31, 0x9f, 0xc1, 0xd6, 0x41, 0x72, 0xd4,
+  0xf8, 0x36, 0x42, 0x6d, 0xdb, 0x41, 0x73, 0x02, 0x25, 0xa0, 0x11, 0x08,
+  0xde, 0xaf, 0xba, 0x04, 0x93, 0x7b, 0x0f, 0x45, 0x0e, 0xe3, 0xbb, 0x89,
+  0x85, 0xc2, 0xde, 0x5f, 0x43, 0x00, 0x0a, 0xf1, 0x7d, 0x61, 0xb0, 0x4a,
+  0x1f, 0x88, 0xd4, 0x26, 0xb5, 0xea, 0x41, 0x8c, 0x1c, 0x94, 0x42, 0xb4,
+  0xb0, 0xe1, 0xe7, 0x90, 0xf1, 0xc5, 0xe7, 0x5e, 0x52, 0x48, 0x36, 0x55,
+  0x60, 0xca, 0x1e, 0x36, 0x5a, 0x70, 0x57, 0x0d, 0x76, 0xec, 0x7e, 0xe1,
+  0x4f, 0x34, 0x12, 0x12, 0xa9, 0xed, 0x94, 0xf2, 0x73, 0xe5, 0x37, 0x10,
+  0x99, 0x21, 0x65, 0x50, 0xc5, 0xa7, 0x3d, 0xba, 0x8a, 0xee, 0x63, 0x48,
+  0x6a, 0xbd, 0xc7, 0xe8, 0x10, 0x61, 0x6c, 0xd0, 0xc7, 0x9e, 0x46, 0x8b,
+  0x43, 0xb3, 0xbb, 0x06, 0xf8, 0xd3, 0x71, 0xe6, 0xc1, 0x08, 0x85, 0x35,
+  0x12, 0xc1, 0x07, 0xbe, 0x78, 0x31, 0xbf, 0x30, 0x40, 0xa2, 0x9a, 0x77,
+  0xfc, 0x82, 0x07, 0x3b, 0xf2, 0x02, 0x1e, 0xf0, 0x91, 0xcf, 0xb8, 0xc4,
+  0x67, 0x0e, 0x1e, 0xab, 0xc4, 0x8c, 0x0f, 0x84, 0xd2, 0x76, 0xcf, 0xb6,
+  0xc9, 0x85, 0x22, 0x4f, 0x22, 0xcf, 0x20, 0x97, 0x6a, 0x52, 0xe4, 0x4c,
+  0x28, 0xe6, 0xbd, 0x36, 0x9a, 0xf7, 0xb8, 0x2b, 0x63, 0x82, 0xae, 0x0f,
+  0xb9, 0xeb, 0xf6, 0x8d, 0x19, 0x6f, 0x49, 0x09, 0xde, 0xcb, 0x76, 0x40,
+  0x0a, 0x6d, 0x9f, 0x2f, 0x35, 0xd1, 0xdf, 0x40, 0xa4, 0xb0, 0xf9, 0x56,
+  0xa1, 0x5b, 0x24, 0x74, 0xab, 0x30, 0xdd, 0x1e, 0x0f, 0xa2, 0x17, 0xbc,
+  0x09, 0x14, 0x8e, 0xcf, 0xd3, 0x56, 0xf2, 0x87, 0xb1, 0x41, 0xe9, 0xac,
+  0xa4, 0xaa, 0xa8, 0x21, 0x45, 0x67, 0x98, 0x15, 0x89, 0x07, 0x64, 0x6c,
+  0x62, 0xf3, 0x98, 0x95, 0xbb, 0x6e, 0xa0, 0x75, 0x67, 0xd1, 0x00, 0x77,
+  0xe5, 0xc2, 0x5d, 0xbd, 0x72, 0x57, 0x34, 0xfa, 0x2e, 0xa2, 0x3b, 0xbc,
+  0xd6, 0xa8, 0x49, 0x35, 0x04, 0x90, 0xa4, 0x09, 0x16, 0x04, 0x74, 0xe1,
+  0xca, 0xa0, 0x26, 0xaf, 0x51, 0x3b, 0x6b, 0xa8, 0xf9, 0x30, 0xdf, 0xb8,
+  0x82, 0x81, 0xc4, 0xe9, 0x13, 0x46, 0xf9, 0x16, 0xa3, 0x7e, 0xd6, 0x99,
+  0x15, 0x94, 0x21, 0xac, 0xa6, 0xdd, 0xc0, 0x94, 0xa2, 0xb7, 0x40, 0x48,
+  0xcd, 0x35, 0xcc, 0xeb, 0x3a, 0x9a, 0x95, 0xef, 0x6a, 0x18, 0x39, 0x7b,
+  0x31, 0x18, 0x0f, 0xd3, 0x36, 0xd0, 0x32, 0x41, 0x76, 0x61, 0xee, 0xb2,
+  0x8d, 0x75, 0xf2, 0x9d, 0x85, 0x29, 0xf0, 0x30, 0x6d, 0xd0, 0xd1, 0xc0,
+  0xd6, 0x9d, 0x83, 0xb9, 0x03, 0xe2, 0x81, 0xb7, 0x00, 0x8b, 0xed, 0x3b,
+  0x05, 0x44, 0x35, 0x10, 0x39, 0x14, 0x79, 0xeb, 0xf7, 0x95, 0xdb, 0xde,
+  0x47, 0x95, 0x06, 0x07, 0xab, 0x9e, 0x10, 0xc5, 0x97, 0x4e, 0x31, 0xa7,
+  0xc0, 0xba, 0x10, 0xb8, 0xb5, 0xc0, 0x10, 0x72, 0x72, 0xef, 0x94, 0x73,
+  0x07, 0x68, 0x1b, 0xdc, 0x39, 0xf3, 0x48, 0x3d, 0xe8, 0x04, 0xb2, 0xef,
+  0xcb, 0x0b, 0x80, 0xd4, 0xcf, 0x13, 0xbb, 0xcf, 0x4d, 0x6d, 0x86, 0x70,
+  0x33, 0xb8, 0xfb, 0x81, 0x57, 0x07, 0x21, 0xcc, 0x96, 0x75, 0x1b, 0xde,
+  0x6f, 0xac, 0x5c, 0x18, 0x25, 0x00, 0xa6, 0x5b, 0x88, 0x35, 0xad, 0xe2,
+  0x6f, 0x88, 0x46, 0xad, 0x4c, 0xd8, 0x12, 0xa7, 0x9f, 0x41, 0x9e, 0x92,
+  0xbf, 0x51, 0x87, 0xa6, 0xbc, 0x19, 0x93, 0x0a, 0x0c, 0x91, 0x38, 0xa1,
+  0x70, 0x36, 0x54, 0x16, 0x96, 0x7a, 0xd1, 0x2b, 0xe7, 0x52, 0x2f, 0x42,
+  0x1a, 0xd7, 0xe4, 0x5c, 0xb3, 0xd0, 0x8b, 0xa7, 0x45, 0x21, 0x81, 0x65,
+  0xb6, 0x11, 0x2e, 0x07, 0xa0, 0x26, 0x99, 0x5a, 0xb9, 0x02, 0x62, 0xd2,
+  0x8c, 0x56, 0x8e, 0xac, 0x87, 0x69, 0xd8, 0x8e, 0x2d, 0xb1, 0xaf, 0x37,
+  0xc5, 0xbf, 0xda, 0x8a, 0x7f, 0x62, 0x37, 0x27, 0x51, 0x38, 0x60, 0xca,
+  0xfc, 0x36, 0xbf, 0xce, 0x97, 0x00, 0x85, 0xe1, 0x8a, 0x34, 0x60, 0x24,
+  0x8c, 0x16, 0x9b, 0x79, 0x06, 0x85, 0x67, 0xd1, 0x5d, 0xc3, 0x56, 0x07,
+  0x9d, 0x1c, 0xe8, 0x45, 0xda, 0x57, 0x34, 0x42, 0x85, 0x61, 0x44, 0x6d,
+  0xc9, 0x5b, 0x3c, 0x10, 0x8b, 0xb4, 0xed, 0xc4, 0x67, 0x98, 0xa4, 0x90,
+  0x5d, 0xb1, 0xa3, 0x74, 0xed, 0xdd, 0xe5, 0xe7, 0xbb, 0xf4, 0xd0, 0x7e,
+  0xf9, 0xe6, 0x5e, 0xf9, 0x67, 0xd1, 0x72, 0x19, 0xa4, 0xf1, 0x19, 0x97,
+  0xe6, 0x67, 0x46, 0xa1, 0x15, 0x15, 0xae, 0x7a, 0x41, 0x14, 0x06, 0x76,
+  0x71, 0xd8, 0x7b, 0xb9, 0x8c, 0xed, 0xed, 0x1d, 0x54, 0xcb, 0x71, 0x00,
+  0xa3, 0x9d, 0x6d, 0x9d, 0x23, 0xc3, 0x62, 0x80, 0xba, 0x00, 0x4b, 0xf2,
+  0x94, 0xa7, 0x29, 0x78, 0x2e, 0xb6, 0xee, 0x85, 0xfd, 0xd9, 0x5d, 0x2a,
+  0xf6, 0x87, 0x4f, 0xdd, 0x01, 0x93, 0xbb, 0x3e, 0x5c, 0x64, 0x47, 0x26,
+  0xa9, 0xf5, 0x81, 0x4e, 0xf5, 0xb4, 0xd0, 0x9d, 0x71, 0x49, 0x21, 0x1b,
+  0xb0, 0xa5, 0xc3, 0x64, 0x0c, 0x35, 0xbd, 0xd1, 0x2d, 0xdf, 0x65, 0xa6,
+  0xe9, 0x7e, 0x67, 0x76, 0x95, 0x8c, 0xc2, 0x5a, 0x85, 0x42, 0x68, 0xa3,
+  0xc1, 0x92, 0x6b, 0x66, 0x6d, 0x74, 0x68, 0xeb, 0x42, 0xb7, 0x6f, 0xd4,
+  0xfd, 0x74, 0x6f, 0x1e, 0xd5, 0x6e, 0x9e, 0x8c, 0x7a, 0x2e, 0xd6, 0xf4,
+  0x6b, 0x6c, 0xf0, 0xc3, 0xfc, 0xd4, 0xd3, 0xa0, 0x0e, 0x30, 0xbc, 0xec,
+  0x01, 0xdd, 0x3b, 0x55, 0x61, 0x22, 0x53, 0x5f, 0xaa, 0x40, 0x09, 0x5e,
+  0xde, 0x87, 0x87, 0xc1, 0xc4, 0x17, 0x7a, 0x1c, 0x3d, 0xe7, 0x53, 0xca,
+  0xa1, 0x70, 0xa5, 0x17, 0x83, 0x52, 0x41, 0x40, 0xfc, 0x65, 0x6a, 0xa0,
+  0xf5, 0xe8, 0xcd, 0x5f, 0x03, 0xca, 0xfa, 0xd2, 0x92, 0xd0, 0xf8, 0x51,
+  0xb0, 0x3b, 0x5b, 0x3a, 0x0a, 0x07, 0x64, 0x9f, 0x61, 0xdf, 0xf8, 0xd8,
+  0xb7, 0x59, 0xfc, 0x8d, 0x0f, 0x08, 0x0b, 0xdb, 0x87, 0xb1, 0x60, 0xb4,
+  0x87, 0x71, 0x9b, 0xf8, 0xd9, 0x5b, 0xc0, 0xc2, 0x95, 0xc3, 0x0d, 0x7f,
+  0x32, 0xe6, 0x6f, 0xa6, 0xea, 0x18, 0x8b, 0x18, 0x54, 0x05, 0x76, 0x0d,
+  0xa6, 0x0e, 0x33, 0x0e, 0x13, 0x7d, 0x44, 0x3a, 0x5b, 0x4a, 0x5a, 0xe7,
+  0x31, 0x60, 0x3d, 0xba, 0x6d, 0x19, 0x14, 0x31, 0xb4, 0x52, 0xb4, 0x04,
+  0xf8, 0x35, 0xe8, 0x97, 0xf3, 0x8c, 0x11, 0x4c, 0x6a, 0xf7, 0x3b, 0x5c,
+  0x24, 0x72, 0x8c, 0xd4, 0x3e, 0xd6, 0x98, 0x3f, 0x1b, 0xf3, 0xdb, 0x4b,
+  0x92, 0xfb, 0x03, 0x4a, 0xc3, 0xfe, 0xe5, 0xdc, 0x9a, 0x5a, 0x23, 0x0a,
+  0x9f, 0x08, 0xee, 0xf8, 0xe6, 0x81, 0x76, 0x87, 0xaf, 0xc0, 0x7c, 0x82,
+  0x9f, 0x30, 0x89, 0xbd, 0x7e, 0x31, 0x88, 0xbc, 0x48, 0x43, 0x0f, 0x6d,
+  0xcf, 0x37, 0x3b, 0x12, 0x01, 0xcb, 0xa4, 0x94, 0x07, 0xa8, 0xc2, 0x3e,
+  0x80, 0x99, 0x23, 0x09, 0xa6, 0xe3, 0x54, 0x33, 0x62, 0xc4, 0x76, 0x7b,
+  0xbe, 0xc2, 0x68, 0x6f, 0xa8, 0x59, 0x1d, 0x3d, 0x27, 0xcc, 0x11, 0xe6,
+  0x3d, 0x07, 0x45, 0x2b, 0xfc, 0x1e, 0x8d, 0x5f, 0x79, 0xef, 0x5b, 0x60,
+  0xc8, 0xee, 0x3b, 0xc2, 0x93, 0x4c, 0x99, 0x26, 0x7d, 0x80, 0x6c, 0x69,
+  0x22, 0x9b, 0x83, 0xdc, 0xec, 0x83, 0xeb, 0xe5, 0xf7, 0xcd, 0xd9, 0x7c,
+  0xe3, 0xfe, 0xc5, 0x83, 0x54, 0x20, 0x8a, 0x09, 0xe8, 0x80, 0xaa, 0xd3,
+  0x2c, 0xf4, 0x89, 0x21, 0x58, 0x54, 0x37, 0x42, 0xc8, 0x1f, 0x62, 0x35,
+  0xe1, 0xa4, 0x82, 0x2b, 0x6a, 0x0d, 0xba, 0x34, 0x1a, 0x9e, 0x61, 0x59,
+  0x47, 0x9a, 0xc6, 0x9a, 0xee, 0x30, 0x58, 0x93, 0x7e, 0x90, 0x19, 0x4a,
+  0x09, 0x33, 0x9d, 0x51, 0x42, 0xa2, 0xbb, 0x95, 0xa7, 0x24, 0xad, 0x02,
+  0xde, 0xc5, 0x52, 0xb4, 0xcc, 0x75, 0xfc, 0x14, 0x60, 0x99, 0xa3, 0x5f,
+  0x55, 0x09, 0x65, 0xae, 0x4b, 0x19, 0x17, 0x65, 0xcf, 0xb2, 0x39, 0x2c,
+  0x87, 0xef, 0x28, 0xd1, 0x42, 0xb3, 0x57, 0x7e, 0xd2, 0x72, 0x05, 0x17,
+  0x9e, 0x25, 0xbb, 0xb3, 0x5a, 0xd5, 0xf1, 0x2f, 0xf0, 0xdb, 0xaa, 0xf4,
+  0x97, 0x67, 0x94, 0xb0, 0x54, 0x09, 0x34, 0x27, 0x81, 0x73, 0x8f, 0x1a,
+  0x40, 0x04, 0xfe, 0xc3, 0xeb, 0xf7, 0xbd, 0xeb, 0x1c, 0xb0, 0x47, 0xf1,
+  0xfe, 0x4a, 0xa0, 0xa1, 0x00, 0x85, 0x12, 0x98, 0x30, 0xe3, 0xec, 0xd4,
+  0x3a, 0xca, 0x1c, 0x3d, 0xd3, 0x12, 0x15, 0x35, 0x2d, 0xc5, 0x58, 0x75,
+  0x55, 0x89, 0x3e, 0x88, 0x42, 0x25, 0x51, 0xfc, 0x24, 0x1a, 0x08, 0xe0,
+  0x2c, 0x10, 0xdf, 0xcd, 0xfc, 0x9e, 0x14, 0x44, 0x55, 0x1a, 0x4c, 0x40,
+  0x0b, 0x34, 0x18, 0x04, 0x7b, 0x9c, 0x20, 0xc2, 0x01, 0x1a, 0x7f, 0xa8,
+  0x40, 0xc5, 0x59, 0x04, 0x57, 0x34, 0xe2, 0x68, 0xff, 0xac, 0x65, 0x38,
+  0xa8, 0xca, 0xe0, 0xac, 0x67, 0xb0, 0x16, 0xd1, 0xd5, 0x0d, 0x60, 0x22,
+  0x10, 0x16, 0x63, 0x14, 0xc2, 0x18, 0x0e, 0xa0, 0x15, 0x00, 0x0b, 0xf5,
+  0x8e, 0xbd, 0xca, 0xc6, 0x03, 0x62, 0x85, 0x63, 0xf0, 0x3d, 0x63, 0x41,
+  0xc0, 0x56, 0x83, 0xc3, 0x4c, 0x03, 0x5f, 0xf5, 0x81, 0xc0, 0x09, 0xb6,
+  0x2d, 0x33, 0x12, 0x53, 0x11, 0x5c, 0x0d, 0x0d, 0xb4, 0x95, 0x8d, 0x50,
+  0xee, 0x40, 0x5c, 0xb0, 0xee, 0xe5, 0x86, 0x23, 0x46, 0x90, 0xa0, 0xb6,
+  0x1b, 0xe0, 0x03, 0x74, 0x2c, 0xf9, 0xa2, 0x12, 0xe9, 0x43, 0x42, 0x0d,
+  0xcb, 0x85, 0x68, 0x74, 0x90, 0xe6, 0x27, 0x7b, 0xb0, 0x52, 0x68, 0x09,
+  0x23, 0x80, 0x76, 0x34, 0x60, 0xe2, 0x48, 0xdc, 0x96, 0xc8, 0xaa, 0xd7,
+  0xb8, 0x8c, 0x50, 0x34, 0xb2, 0xc6, 0x69, 0x40, 0xa0, 0x9a, 0x2f, 0xa0,
+  0x37, 0xa2, 0x08, 0xb6, 0xb7, 0x56, 0xb4, 0x45, 0xb5, 0x3e, 0x40, 0x8b,
+  0x6e, 0xa8, 0x9d, 0xa9, 0x93, 0x3f, 0x7a, 0xd8, 0x10, 0xc1, 0xf0, 0xd0,
+  0xf0, 0xf1, 0xb1, 0x31, 0x3b, 0xa3, 0x85, 0x7e, 0x7a, 0x43, 0x2b, 0xe5,
+  0x96, 0xf1, 0x39, 0x58, 0xae, 0x4a, 0xad, 0xd4, 0xb7, 0x1d, 0xc6, 0x56,
+  0xc2, 0x6d, 0x52, 0x4b, 0xb6, 0x29, 0x30, 0x68, 0xad, 0x3d, 0xca, 0xa5,
+  0x7f, 0xbd, 0x9a, 0x0b, 0xff, 0x25, 0xf7, 0x61, 0x67, 0xb0, 0x97, 0xc6,
+  0xea, 0x63, 0xe8, 0x49, 0x61, 0xc9, 0x88, 0x5a, 0x46, 0xd7, 0x60, 0x84,
+  0x24, 0xaf, 0x5e, 0xfa, 0x20, 0x1c, 0xdb, 0xb3, 0x99, 0xdb, 0xa5, 0xfb,
+  0xb0, 0xe7, 0x9c, 0xe6, 0x7d, 0x83, 0xfd, 0xce, 0x9c, 0xee, 0x4d, 0xd8,
+  0x77, 0x0e, 0xfc, 0x0f, 0x3f, 0x14, 0x92, 0x16, 0x04, 0x86, 0xcd, 0x3c,
+  0xa7, 0x23, 0x2b, 0xc5, 0xc2, 0x4a, 0x6d, 0xe1, 0x65, 0x38, 0x8a, 0xb7,
+  0xf4, 0x10, 0xf3, 0x5c, 0xed, 0x69, 0x4d, 0x32, 0x91, 0x81, 0xff, 0xea,
+  0xea, 0x8b, 0xc6, 0x50, 0xfd, 0xe6, 0xc6, 0x4a, 0xf5, 0x55, 0xb0, 0xf0,
+  0xaa, 0xbb, 0xf4, 0xad, 0x2f, 0xc8, 0x3f, 0x7a, 0x14, 0xbe, 0x50, 0xdd,
+  0xb9, 0x32, 0xf0, 0x82, 0x68, 0x74, 0xc7, 0x10, 0xcf, 0xb5, 0xa2, 0x41,
+  0x4c, 0x96, 0xfa, 0x2b, 0x33, 0xe4, 0x9b, 0xf9, 0x99, 0x11, 0x5b, 0x6a,
+  0x9c, 0x20, 0xad, 0xd5, 0xc0, 0x04, 0x55, 0xa9, 0x3a, 0x48, 0x52, 0x82,
+  0xb9, 0xaf, 0x8a, 0x4a, 0x4d, 0xcc, 0xa7, 0xb3, 0x7d, 0x54, 0x9c, 0xa6,
+  0x46, 0x87, 0x2e, 0xbd, 0xdf, 0xe0, 0x7c, 0xe9, 0x40, 0xac, 0x88, 0x3c,
+  0x0b, 0x50, 0xf4, 0x0f, 0xd9, 0x02, 0x63, 0x80, 0xb1, 0x32, 0x18, 0x6b,
+  0xeb, 0xe4, 0xfe, 0x4a, 0xf2, 0x67, 0x07, 0xcf, 0x50, 0xba, 0x58, 0x11,
+  0x60, 0xfd, 0x74, 0x8e, 0x7f, 0xeb, 0xf3, 0x8b, 0xc5, 0x2e, 0xbe, 0x4d,
+  0xc9, 0x57, 0x7f, 0x8a, 0x9a, 0x05, 0x10, 0x6c, 0x86, 0x39, 0xac, 0xf2,
+  0x0f, 0x39, 0x21, 0x7f, 0x52, 0x2f, 0xc2, 0x71, 0xef, 0xdf, 0x3f, 0x61,
+  0x16, 0x2e, 0x3a, 0x38, 0x42, 0x8f, 0x72, 0x42, 0x9f, 0xc3, 0x6a, 0xcc,
+  0x0c, 0xbc, 0x97, 0x54, 0xfb, 0x66, 0x4d, 0x2d, 0x30, 0xb0, 0x66, 0xc9,
+  0x68, 0xd4, 0x99, 0x0c, 0xb4, 0x61, 0xec, 0xee, 0xc1, 0xed, 0x6b, 0x28,
+  0x2a, 0xdf, 0xc3, 0x29, 0x6b, 0xe1, 0xb6, 0x55, 0x62, 0x61, 0xd8, 0xa0,
+  0xa4, 0x7b, 0x68, 0xa8, 0xe3, 0x5c, 0x6b, 0x7c, 0x1d, 0x4e, 0x7e, 0x37,
+  0x9e, 0x30, 0xea, 0xee, 0xaf, 0xc0, 0x81, 0x27, 0xf0, 0x53, 0x5c, 0xe4,
+  0x53, 0xf0, 0x4b, 0x4a, 0x23, 0xa1, 0x63, 0x20, 0xc0, 0xc3, 0x5e, 0x83,
+  0x3f, 0xa9, 0xfc, 0xf0, 0x72, 0x3a, 0x98, 0x14, 0x28, 0x4a, 0x53, 0x39,
+  0xdd, 0x5d, 0xd5, 0x9b, 0x41, 0xd5, 0x69, 0x9c, 0x08, 0xf0, 0xd7, 0x8b,
+  0x96, 0xc3, 0x8e, 0x88, 0x66, 0x18, 0xc9, 0xd8, 0x51, 0x65, 0x41, 0x24,
+  0xa6, 0x9e, 0x34, 0xcf, 0x5d, 0x18, 0x7b, 0x04, 0x31, 0xae, 0xa6, 0x77,
+  0x3c, 0x65, 0xcd, 0x1a, 0x82, 0xfe, 0x9f, 0xa1, 0x4e, 0x7e, 0x78, 0xf5,
+  0xe5, 0xa7, 0x53, 0x74, 0xa7, 0x30, 0x8f, 0x58, 0x5c, 0x41, 0x78, 0x20,
+  0x06, 0xf7, 0xa2, 0x58, 0xaf, 0x60, 0xc5, 0x9e, 0x50, 0x51, 0x23, 0x8f,
+  0x4c, 0xd4, 0x2a, 0x3c, 0x52, 0x9c, 0xa4, 0xf9, 0x2b, 0x8d, 0x3d, 0xb2,
+  0x09, 0xcf, 0x7b, 0x1c, 0xef, 0x71, 0xbc, 0x07, 0x8f, 0x9c, 0xb5, 0x8d,
+  0x94, 0xd9, 0x91, 0xbe, 0x82, 0xea, 0x8d, 0xd5, 0xb3, 0x3c, 0x27, 0x93,
+  0x05, 0xe8, 0x30, 0x04, 0xc0, 0x44, 0x7f, 0x86, 0x7b, 0xdc, 0xa9, 0x6c,
+  0x3b, 0xbb, 0x91, 0x9b, 0xde, 0xde, 0xc8, 0x7d, 0x6a, 0xee, 0xe5, 0x71,
+  0xa8, 0x1f, 0x65, 0xc8, 0x55, 0x82, 0xda, 0x34, 0x30, 0xe6, 0xae, 0x05,
+  0xdb, 0xad, 0xbb, 0xe0, 0xe4, 0x32, 0xfa, 0xb5, 0x5c, 0x27, 0x77, 0x22,
+  0x77, 0x83, 0xbd, 0x90, 0xb4, 0x6a, 0xae, 0xe0, 0x11, 0x35, 0x77, 0x92,
+  0xdd, 0x05, 0x14, 0x95, 0xbd, 0x02, 0xf2, 0x3b, 0x89, 0xf0, 0x91, 0xce,
+  0xe1, 0x3d, 0x4a, 0x3f, 0x04, 0xa8, 0xbf, 0xe0, 0x4f, 0x00, 0x0a, 0x4f,
+  0x8f, 0xe1, 0x3d, 0x6d, 0xce, 0xa1, 0x25, 0x6f, 0x80, 0x0b, 0xea, 0x7b,
+  0xa8, 0xe6, 0x23, 0x62, 0xc5, 0x4e, 0x12, 0x6e, 0x0c, 0x50, 0xa3, 0xd1,
+  0x41, 0x83, 0x82, 0xa5, 0x6b, 0x06, 0xa7, 0x8e, 0x18, 0x5e, 0xe8, 0x08,
+  0x85, 0x3a, 0x68, 0x4a, 0x30, 0x0b, 0x5c, 0x4c, 0x78, 0x9c, 0xbd, 0xc3,
+  0x0d, 0xd1, 0x32, 0x7a, 0xd5, 0xc0, 0x07, 0x05, 0xea, 0x24, 0xff, 0x97,
+  0x08, 0x71, 0xcb, 0x18, 0x31, 0xf3, 0x67, 0x80, 0xe8, 0x3d, 0xa0, 0xaf,
+  0x46, 0x47, 0xbb, 0x4a, 0x87, 0x82, 0x59, 0x74, 0xe5, 0x52, 0xa7, 0x4a,
+  0x18, 0xba, 0x98, 0x7a, 0x97, 0x1a, 0xa6, 0xb3, 0x0a, 0x64, 0x68, 0x10,
+  0x60, 0x17, 0xd8, 0x12, 0x6d, 0x07, 0x9a, 0x21, 0x0a, 0xa3, 0x1b, 0x8e,
+  0xf7, 0x53, 0xd5, 0x83, 0x4a, 0xd2, 0x13, 0x1a, 0x79, 0x02, 0xd5, 0xdb,
+  0x0e, 0x43, 0xd3, 0x60, 0xb4, 0xbc, 0x9c, 0x9e, 0x0b, 0xbb, 0x79, 0x8d,
+  0x9e, 0x3b, 0x8c, 0x08, 0x06, 0x09, 0x23, 0x91, 0xdd, 0x0d, 0x3b, 0x2e,
+  0xc7, 0x18, 0x47, 0x77, 0x8b, 0xfe, 0x05, 0x39, 0x7e, 0xd2, 0xc4, 0x5b,
+  0xbf, 0x68, 0x2e, 0x68, 0x0c, 0x05, 0xdd, 0xa2, 0xb8, 0x33, 0x88, 0xd2,
+  0xbb, 0x25, 0x31, 0xc4, 0x5e, 0xc4, 0x59, 0xad, 0x53, 0x7b, 0xd1, 0x4f,
+  0xf4, 0x6b, 0x57, 0x14, 0x2b, 0xd2, 0x8a, 0xd4, 0x3a, 0xe1, 0xbd, 0x59,
+  0xcd, 0xf9, 0x8d, 0x37, 0x8c, 0x9f, 0x7d, 0x7a, 0x35, 0xde, 0xf1, 0x51,
+  0x5b, 0xf5, 0x83, 0x2f, 0xbd, 0x84, 0x90, 0x63, 0xd8, 0xe5, 0xac, 0x40,
+  0x48, 0x51, 0x64, 0x78, 0x55, 0xb2, 0x95, 0xef, 0x43, 0x48, 0x45, 0x61,
+  0x6f, 0x40, 0xc8, 0xfc, 0x55, 0x06, 0xa7, 0x3c, 0xb0, 0xf3, 0x1c, 0x9a,
+  0x4c, 0x7f, 0x60, 0x7c, 0xc3, 0xa1, 0xcb, 0xd0, 0x4a, 0x9e, 0x43, 0x7f,
+  0x3f, 0xe1, 0x60, 0xfe, 0x49, 0xe6, 0x54, 0x8a, 0x0f, 0xbd, 0x77, 0xa8,
+  0xca, 0xba, 0x0e, 0x2e, 0x85, 0xf9, 0x77, 0xb8, 0xd2, 0xa6, 0x48, 0x63,
+  0x5f, 0x86, 0x3f, 0xc9, 0xec, 0x48, 0x95, 0x19, 0xfa, 0xfa, 0xe9, 0x7e,
+  0x31, 0xcf, 0xfb, 0x13, 0xdc, 0x2d, 0x5e, 0xa4, 0x7c, 0xe5, 0x37, 0x7b,
+  0x6f, 0xd8, 0x3f, 0xfc, 0x58, 0xc8, 0xb3, 0x17, 0xbd, 0xad, 0x8b, 0x33,
+  0xe8, 0x38, 0xeb, 0xdb, 0x01, 0xa6, 0x6e, 0x1d, 0xed, 0x7d, 0x1e, 0xe3,
+  0x8a, 0xf4, 0xf1, 0xc3, 0x59, 0x67, 0x1f, 0xc6, 0xa0, 0xf8, 0x22, 0x22,
+  0x4f, 0x57, 0x37, 0x9c, 0x26, 0x7b, 0x5f, 0x32, 0x44, 0x8d, 0x06, 0x76,
+  0x34, 0x3d, 0x23, 0xf3, 0xc1, 0x89, 0x66, 0x66, 0xa6, 0x43, 0xd6, 0x68,
+  0x83, 0x1e, 0x3a, 0xc6, 0xa3, 0x18, 0x06, 0x72, 0x4f, 0x5c, 0x07, 0x34,
+  0xc5, 0x30, 0x5f, 0x4c, 0x6d, 0xf1, 0x0e, 0xa7, 0x59, 0x9f, 0xa2, 0xa4,
+  0x05, 0xc6, 0xee, 0x32, 0x95, 0x7b, 0x11, 0xf9, 0x37, 0x82, 0x9a, 0xd3,
+  0xa7, 0x65, 0x62, 0x4b, 0xc3, 0x62, 0x03, 0xc5, 0xc0, 0x71, 0x79, 0x06,
+  0x41, 0xd3, 0x1f, 0xf2, 0xe7, 0x3f, 0x82, 0x57, 0xfa, 0x7d, 0xde, 0xec,
+  0x2c, 0x04, 0x98, 0xe3, 0x9b, 0xac, 0xf9, 0x93, 0x0b, 0x66, 0x7e, 0x8a,
+  0xba, 0x29, 0xc6, 0xb1, 0x63, 0xa4, 0xa9, 0x1a, 0x4c, 0x89, 0xcd, 0xd0,
+  0x59, 0x21, 0xd8, 0x63, 0xd6, 0x47, 0x43, 0x37, 0xa7, 0x3d, 0xf3, 0x43,
+  0xd5, 0x18, 0xd9, 0x21, 0xf0, 0x73, 0xd7, 0x63, 0x5c, 0xe9, 0x04, 0x73,
+  0xcc, 0xa5, 0x45, 0xae, 0xaf, 0x07, 0x82, 0x40, 0x70, 0x66, 0xff, 0x4a,
+  0xd8, 0x08, 0xa8, 0x34, 0xda, 0xe8, 0xfa, 0x29, 0xae, 0x14, 0x5a, 0xd1,
+  0xa0, 0x13, 0x6e, 0x00, 0x3c, 0x8c, 0xb8, 0xa1, 0xc4, 0xa4, 0xb8, 0xd2,
+  0xa5, 0x07, 0x9f, 0x9f, 0x83, 0xf1, 0xb4, 0x79, 0x30, 0x12, 0xd7, 0x29,
+  0xb9, 0x5d, 0x44, 0xeb, 0x6e, 0x8a, 0x2b, 0x61, 0xb6, 0x36, 0x98, 0xae,
+  0x53, 0xcc, 0x17, 0x57, 0xeb, 0x80, 0xf6, 0xe7, 0x31, 0xae, 0x34, 0x86,
+  0xcb, 0x9c, 0xe6, 0x23, 0x17, 0x11, 0xb5, 0xa4, 0x52, 0xc0, 0xfc, 0x6a,
+  0x33, 0x07, 0xdc, 0xca, 0xba, 0x1d, 0x9f, 0x54, 0x78, 0x0c, 0xbd, 0x60,
+  0xc3, 0x95, 0x36, 0x5a, 0xe6, 0x65, 0x19, 0xda, 0xb1, 0x4c, 0xbb, 0xd2,
+  0xbd, 0x56, 0x0e, 0x2c, 0x6b, 0xc6, 0x48, 0x07, 0x94, 0x5d, 0x29, 0xfd,
+  0xdb, 0x25, 0xfa, 0xcd, 0x30, 0xa9, 0x1b, 0xcb, 0xb0, 0x2a, 0x65, 0x93,
+  0x30, 0x92, 0x8b, 0x72, 0x55, 0xca, 0xc0, 0x45, 0x4a, 0x28, 0xa3, 0xed,
+  0xb3, 0x7f, 0xb5, 0xe4, 0xaa, 0x4e, 0x2d, 0xd7, 0x63, 0xd9, 0xdc, 0x0d,
+  0x6e, 0xdd, 0xef, 0x97, 0x69, 0xaf, 0xdc, 0xf4, 0xcd, 0xa3, 0x96, 0x4f,
+  0xc9, 0x6e, 0xfa, 0x1a, 0xe5, 0xb6, 0x94, 0x5d, 0xfd, 0x14, 0xf7, 0x4a,
+  0x99, 0x4a, 0x6a, 0x87, 0xb1, 0xac, 0xc6, 0xb2, 0x9f, 0xca, 0xf6, 0xa0,
+  0xac, 0xf7, 0x4b, 0xc3, 0x07, 0x97, 0xa5, 0x39, 0x28, 0xab, 0x5d, 0x49,
+  0x49, 0xd4, 0xec, 0x0f, 0x17, 0x5e, 0xb9, 0x1b, 0x1d, 0x63, 0x7f, 0x9d,
+  0x74, 0xe8, 0x2e, 0x30, 0x82, 0x18, 0xa9, 0xa3, 0xac, 0x83, 0xc4, 0x83,
+  0x05, 0xef, 0x08, 0x3b, 0x0f, 0xf6, 0x03, 0x47, 0x3d, 0x66, 0xf2, 0x6e,
+  0x8d, 0x83, 0x07, 0xf5, 0x0a, 0xa3, 0x94, 0xd3, 0x9d, 0x68, 0xb4, 0x76,
+  0x5c, 0x1c, 0x69, 0x8b, 0xe2, 0x6c, 0x64, 0x2f, 0x0d, 0x37, 0x26, 0xf2,
+  0xb2, 0xf2, 0x84, 0x1e, 0x96, 0xda, 0xb4, 0x2e, 0x99, 0xf9, 0x72, 0xe8,
+  0x98, 0xa8, 0x04, 0x1f, 0xf2, 0x7d, 0x72, 0xda, 0xdb, 0x98, 0x47, 0x22,
+  0x2a, 0x69, 0xe2, 0x48, 0x19, 0x0e, 0x70, 0x7c, 0xd2, 0x48, 0x35, 0xa4,
+  0xe4, 0xb2, 0xb0, 0xcb, 0x0d, 0xd1, 0x7a, 0xab, 0x0a, 0x53, 0x4c, 0x13,
+  0xd9, 0x32, 0x8e, 0x74, 0x7b, 0xc0, 0xe3, 0x74, 0xaf, 0x80, 0x01, 0xd8,
+  0x1a, 0x7c, 0xaa, 0x9e, 0x8e, 0x1d, 0x24, 0x64, 0x92, 0xb0, 0x16, 0x02,
+  0xbc, 0x88, 0xdb, 0x0e, 0x74, 0xba, 0x16, 0x22, 0x74, 0x8d, 0xe7, 0x2f,
+  0x81, 0x25, 0xd7, 0x91, 0x44, 0x31, 0x91, 0x4a, 0x4e, 0xd6, 0x98, 0xf1,
+  0x81, 0x8c, 0x30, 0x85, 0xef, 0xb3, 0x29, 0x0b, 0x98, 0x92, 0x76, 0xb8,
+  0xd2, 0xb8, 0x75, 0xab, 0x86, 0x9b, 0x43, 0x41, 0xb8, 0xe2, 0x62, 0x59,
+  0xda, 0x16, 0x3a, 0x85, 0x2e, 0x9c, 0x1e, 0x46, 0xc1, 0x7f, 0xf8, 0xe5,
+  0xc0, 0x38, 0xd2, 0xb3, 0x86, 0x92, 0x1e, 0x34, 0x9a, 0xb4, 0x15, 0xf5,
+  0xb1, 0x66, 0x25, 0x3d, 0x69, 0xe8, 0x26, 0xef, 0xb4, 0xb6, 0xb2, 0x4b,
+  0xb9, 0xc9, 0xa5, 0x59, 0x8d, 0xcf, 0x4f, 0xf9, 0x0f, 0x3f, 0x55, 0x7d,
+  0xc5, 0x53, 0x13, 0x75, 0x67, 0x5c, 0x27, 0x32, 0x13, 0xfd, 0x22, 0xa0,
+  0x81, 0x16, 0xa0, 0x7b, 0x7b, 0xce, 0x0f, 0x7c, 0x9a, 0x5c, 0xfd, 0xa2,
+  0x1f, 0xf6, 0x3e, 0x83, 0xe8, 0xba, 0xd8, 0x79, 0xe9, 0x94, 0x6f, 0xf7,
+  0x16, 0x6d, 0xb9, 0xc5, 0x6a, 0x2b, 0xdb, 0xef, 0x56, 0x61, 0x35, 0x71,
+  0x2f, 0xbb, 0xb4, 0x5c, 0x17, 0x56, 0x0d, 0xbb, 0x05, 0x5d, 0xa6, 0x2c,
+  0x5f, 0x98, 0xbf, 0xcb, 0x35, 0x60, 0xcb, 0x37, 0xb9, 0xee, 0xf5, 0xd7,
+  0xd8, 0x83, 0xd7, 0xa4, 0x2f, 0xbc, 0xe6, 0x70, 0x6c, 0x7f, 0xed, 0xbf,
+  0x83, 0xb7, 0x87, 0xa8, 0x62, 0xe2, 0xf3, 0xb8, 0x00, 0xa6, 0x35, 0xa3,
+  0x6c, 0xf9, 0xb3, 0xb6, 0x7a, 0xa6, 0x09, 0x55, 0xc9, 0x83, 0xd6, 0x35,
+  0x7e, 0xdd, 0xd3, 0x86, 0x39, 0xc8, 0xa5, 0x40, 0x96, 0x63, 0x30, 0xe1,
+  0x98, 0x0a, 0xac, 0xa7, 0xb4, 0x8a, 0xa6, 0x5d, 0x20, 0xd7, 0x42, 0x59,
+  0x86, 0x95, 0x3c, 0x57, 0x1d, 0xd2, 0x24, 0x48, 0xfa, 0x25, 0x6c, 0x28,
+  0x04, 0x9f, 0x5a, 0x6c, 0x43, 0x6b, 0xd4, 0xda, 0x87, 0xe2, 0x2d, 0xe6,
+  0xd7, 0xd0, 0x15, 0xf8, 0x70, 0x9d, 0xc2, 0xc9, 0x00, 0x3d, 0xe3, 0xba,
+  0x0c, 0x53, 0xd1, 0xf4, 0xbe, 0x8e, 0x0e, 0x28, 0xfb, 0x30, 0x74, 0xea,
+  0xc7, 0x44, 0xfa, 0x09, 0x5a, 0x67, 0xe8, 0xf4, 0xf1, 0x95, 0x0c, 0xf6,
+  0x22, 0xb9, 0x3d, 0xe7, 0xbd, 0xcb, 0x1a, 0x73, 0x85, 0xaf, 0xfd, 0xb4,
+  0x68, 0xfd, 0x34, 0xca, 0x45, 0x69, 0x66, 0x7e, 0xea, 0xeb, 0x57, 0xc7,
+  0xe9, 0xbb, 0xec, 0x33, 0x00, 0xf1, 0xd9, 0x93, 0xa6, 0xdf, 0x03, 0xd3,
+  0xef, 0xb7, 0x09, 0x72, 0x65, 0xb9, 0x6e, 0xec, 0x64, 0x30, 0xad, 0x79,
+  0xb9, 0x90, 0xea, 0xe5, 0xba, 0x14, 0xdb, 0x85, 0xcb, 0x0c, 0x98, 0x72,
+  0x27, 0x61, 0x6f, 0x5d, 0x8a, 0x7b, 0x42, 0xc7, 0x03, 0x89, 0xae, 0xd5,
+  0x23, 0x8f, 0x2f, 0x28, 0x7a, 0x67, 0x5d, 0xca, 0x57, 0x5e, 0x3a, 0xe8,
+  0xa2, 0x26, 0x4a, 0xbc, 0x8e, 0xbf, 0x19, 0x03, 0xca, 0xd0, 0x18, 0xd4,
+  0x1e, 0x0f, 0xa4, 0xf0, 0x4c, 0x4e, 0xef, 0xe5, 0x3a, 0xfb, 0xc4, 0x98,
+  0x18, 0xd3, 0xf2, 0xcc, 0x30, 0xb0, 0xb9, 0x2e, 0x30, 0x84, 0x40, 0x5f,
+  0xf8, 0x92, 0xeb, 0x91, 0x36, 0x40, 0x72, 0xd0, 0xe8, 0x8b, 0x0d, 0x01,
+  0xba, 0x32, 0xa8, 0x29, 0x8e, 0x61, 0x50, 0xa7, 0x6b, 0xef, 0x44, 0xc3,
+  0xdb, 0x52, 0x96, 0x9b, 0xbd, 0x7f, 0xf2, 0x4a, 0x03, 0xf3, 0x89, 0x46,
+  0x2c, 0xe7, 0x5d, 0x08, 0x30, 0x4f, 0xee, 0xb1, 0x40, 0xc9, 0x12, 0x23,
+  0xef, 0x75, 0x20, 0x13, 0xd9, 0xa3, 0x62, 0xde, 0xf4, 0x9d, 0x17, 0xba,
+  0x0b, 0x2e, 0x28, 0xc1, 0xd4, 0x62, 0x92, 0xef, 0xcb, 0x1c, 0x61, 0xc6,
+  0xb7, 0x49, 0x63, 0xee, 0x2f, 0x02, 0xa6, 0x46, 0x57, 0xa2, 0xc4, 0xba,
+  0x04, 0xf4, 0x7f, 0xce, 0xc9, 0xde, 0x4b, 0xe9, 0x98, 0x75, 0x54, 0xef,
+  0x0f, 0xd4, 0xec, 0x59, 0xbc, 0x9c, 0x5d, 0xca, 0xe6, 0x4e, 0xae, 0x61,
+  0x69, 0xc5, 0xb0, 0x7f, 0x41, 0x27, 0x28, 0x8c, 0xdb, 0x37, 0x38, 0x41,
+  0x17, 0x9c, 0xa0, 0x13, 0x4e, 0xd0, 0xbc, 0x63, 0x43, 0x5b, 0x7c, 0x7b,
+  0x48, 0x77, 0x27, 0xaf, 0x7c, 0xbe, 0x7f, 0x82, 0xec, 0x6e, 0x82, 0xce,
+  0x77, 0x13, 0x24, 0x65, 0x82, 0x02, 0x98, 0xb2, 0x22, 0x23, 0x36, 0xf4,
+  0x40, 0x9b, 0xb2, 0x8c, 0x93, 0x61, 0xe6, 0x52, 0x1c, 0x2c, 0x36, 0x89,
+  0xf3, 0x85, 0x5f, 0x5e, 0x70, 0xbd, 0x74, 0xc0, 0xb8, 0xe7, 0x70, 0x22,
+  0xb7, 0x77, 0xf2, 0x4c, 0xa9, 0xde, 0x70, 0x75, 0xf5, 0x09, 0xf5, 0xc2,
+  0xc1, 0xea, 0x9b, 0x71, 0x39, 0x4f, 0x59, 0x3a, 0x16, 0x0f, 0x1d, 0xe8,
+  0xdd, 0xaa, 0xb2, 0x8f, 0x5f, 0x7a, 0xa9, 0x0c, 0xcf, 0xa2, 0xbb, 0xcf,
+  0x4d, 0x0e, 0xf7, 0x53, 0x40, 0xc1, 0xc9, 0xf6, 0x4a, 0x9e, 0x48, 0xe1,
+  0x91, 0xec, 0xd2, 0x48, 0x93, 0x7a, 0xfa, 0x5f, 0x63, 0x87, 0xff, 0xaa,
+  0xc4, 0x75, 0xd4, 0x45, 0xbc, 0xdd, 0x2b, 0xab, 0x70, 0xcf, 0x0f, 0x17,
+  0x7d, 0x56, 0x1f, 0x8c, 0x17, 0x1d, 0xc1, 0x8f, 0x0a, 0x11, 0xce, 0xf6,
+  0xfa, 0x51, 0xf5, 0xc5, 0xe6, 0x49, 0xd7, 0xa8, 0xde, 0xca, 0x69, 0xc6,
+  0xd4, 0xde, 0x0e, 0x25, 0xaa, 0x38, 0xfc, 0x31, 0xbc, 0xcf, 0x2f, 0x1e,
+  0x76, 0x4b, 0x92, 0xa6, 0x85, 0x4d, 0xbb, 0xdd, 0x66, 0xdf, 0x53, 0xa4,
+  0xe5, 0x6e, 0x81, 0xf3, 0xa9, 0x71, 0x5d, 0xe3, 0xf3, 0x93, 0xb7, 0x31,
+  0xe8, 0x01, 0xf0, 0xef, 0x96, 0xdb, 0x27, 0xae, 0x01, 0xfc, 0x39, 0x6b,
+  0xba, 0xae, 0x26, 0x15, 0x64, 0xfb, 0xa5, 0x53, 0x8d, 0x3b, 0x95, 0xd4,
+  0xc7, 0x9c, 0x4b, 0x79, 0x99, 0xcc, 0x99, 0xb2, 0x28, 0x8b, 0x64, 0x4e,
+  0x37, 0x27, 0x73, 0xa6, 0x0c, 0xcc, 0x98, 0x90, 0x09, 0x9a, 0x3b, 0x01,
+  0xbb, 0x82, 0x57, 0xc7, 0xec, 0x4d, 0xd2, 0x5d, 0x0a, 0x4c, 0x17, 0xd0,
+  0xa3, 0xe5, 0x55, 0xa6, 0x7a, 0xf4, 0x66, 0x88, 0x3d, 0x3d, 0x06, 0x58,
+  0xac, 0x93, 0x34, 0x66, 0x6f, 0xba, 0x5d, 0xf6, 0x26, 0xcd, 0xef, 0x9d,
+  0xb2, 0x37, 0xf0, 0xd5, 0x0f, 0xb3, 0x37, 0xcd, 0x2e, 0x7b, 0xa3, 0x19,
+  0xa2, 0x57, 0xf5, 0xd9, 0xb7, 0x7e, 0xa2, 0x06, 0x27, 0x40, 0x19, 0x74,
+  0x12, 0x34, 0x5a, 0x82, 0x59, 0xbf, 0xc1, 0x20, 0x53, 0x06, 0xb6, 0xba,
+  0x8d, 0x2f, 0x10, 0x89, 0xab, 0x2d, 0x0d, 0xb0, 0x8f, 0xd2, 0x07, 0xe0,
+  0x10, 0x0c, 0x4c, 0xc7, 0x3d, 0x51, 0xaa, 0x17, 0x9b, 0x22, 0x15, 0x25,
+  0xa4, 0x55, 0xa2, 0x23, 0xfa, 0x73, 0x61, 0xc9, 0xfe, 0x9f, 0xea, 0x67,
+  0x8e, 0xe6, 0x1b, 0x8a, 0x64, 0xbd, 0x54, 0x24, 0xff, 0x70, 0x2d, 0xf1,
+  0x81, 0x03, 0x3d, 0x8c, 0x37, 0x6d, 0x30, 0x2c, 0xe0, 0xed, 0x5e, 0xba,
+  0xf5, 0x5d, 0x1b, 0xfc, 0x23, 0x4e, 0x76, 0x90, 0x85, 0x28, 0x7a, 0xb4,
+  0xc1, 0x8b, 0xb4, 0xee, 0x3e, 0x48, 0xaa, 0xa2, 0xbb, 0x03, 0x76, 0x0e,
+  0x43, 0xd8, 0xca, 0xfa, 0x09, 0x26, 0x6d, 0x04, 0x84, 0x27, 0xe4, 0xe2,
+  0xed, 0x88, 0x15, 0xfb, 0x8f, 0x83, 0xe8, 0x1f, 0x78, 0x29, 0xee, 0x20,
+  0xab, 0x55, 0xe4, 0xac, 0xfe, 0xee, 0x73, 0x31, 0x5f, 0x37, 0xcf, 0x30,
+  0x64, 0xa7, 0x19, 0xc4, 0x43, 0x43, 0xbc, 0x0d, 0xc5, 0xe7, 0x85, 0xd6,
+  0x15, 0x03, 0xfe, 0xeb, 0x3b, 0xb9, 0x1f, 0x82, 0x42, 0xa9, 0x09, 0x57,
+  0xad, 0xcb, 0xfa, 0x28, 0x2f, 0xaf, 0x4e, 0xd4, 0xcf, 0x80, 0x79, 0xaf,
+  0x4e, 0x14, 0x28, 0x78, 0x18, 0xdc, 0x73, 0x81, 0xa0, 0x1b, 0xae, 0xfe,
+  0x7d, 0x22, 0xa1, 0x00, 0xa7, 0xe7, 0x8c, 0xc7, 0x7f, 0x04, 0x41, 0x03,
+  0x49, 0x71, 0x9a, 0x37, 0x8c, 0x01, 0x04, 0x2a, 0xa3, 0x2c, 0xc9, 0xa9,
+  0xfa, 0xf9, 0x86, 0x2d, 0x34, 0xdf, 0xf1, 0x93, 0x19, 0x65, 0xa2, 0xb8,
+  0x38, 0x45, 0x26, 0x4e, 0xd4, 0x71, 0x60, 0x72, 0xc1, 0xa9, 0x4c, 0xbc,
+  0xb7, 0xad, 0x98, 0xeb, 0x55, 0xa7, 0x1d, 0xc3, 0xf3, 0xb6, 0x62, 0x2b,
+  0x9a, 0x3e, 0xf0, 0x83, 0x86, 0x4e, 0x4b, 0x3e, 0xe1, 0xb5, 0x6d, 0xc5,
+  0xd5, 0x72, 0x5b, 0xb1, 0x79, 0x6d, 0x5b, 0xf1, 0xbd, 0xe6, 0x8a, 0xc6,
+  0x6d, 0xc5, 0x5d, 0xd9, 0x56, 0xac, 0x29, 0xa6, 0x69, 0x3f, 0x18, 0x63,
+  0xbd, 0x2f, 0x0b, 0xf2, 0x5f, 0x5e, 0x16, 0xfd, 0xeb, 0xf7, 0xfd, 0xe0,
+  0xa2, 0xc3, 0xc0, 0x72, 0x55, 0x34, 0x31, 0x32, 0x0b, 0x5d, 0x1a, 0x6d,
+  0x88, 0x87, 0xbf, 0xcb, 0x3b, 0xfc, 0x49, 0x97, 0xf6, 0xc4, 0x5a, 0x17,
+  0xed, 0x17, 0x27, 0xf3, 0xf6, 0x01, 0xb8, 0x39, 0xd0, 0xd9, 0xba, 0x49,
+  0x10, 0xdd, 0x26, 0xbb, 0xfe, 0xaf, 0xc6, 0xec, 0x65, 0xf7, 0xf6, 0x37,
+  0x80, 0x84, 0x71, 0xcf, 0x90, 0xc1, 0x9d, 0x70, 0xd5, 0x18, 0x8b, 0x00,
+  0xb4, 0x75, 0x57, 0x99, 0xc1, 0xd7, 0x70, 0x92, 0x6c, 0x1f, 0xb8, 0x39,
+  0xc7, 0x1f, 0xe5, 0x26, 0xfa, 0xf3, 0xcc, 0xf8, 0xbd, 0x30, 0x76, 0x91,
+  0xab, 0xc1, 0x75, 0xfe, 0x02, 0x20, 0x21, 0x30, 0x78, 0xcf, 0x7d, 0x02,
+  0x03, 0x18, 0x42, 0x63, 0xcf, 0x26, 0xfb, 0xd6, 0x5d, 0xc6, 0x7a, 0x60,
+  0x64, 0xb6, 0xb3, 0xf7, 0x30, 0x50, 0x2b, 0xe3, 0x36, 0x5d, 0xfd, 0x84,
+  0x71, 0x0e, 0xc6, 0xde, 0xf6, 0x8c, 0x9a, 0x78, 0x69, 0x1b, 0x99, 0xf6,
+  0xaf, 0x33, 0xb0, 0xe2, 0xb3, 0x46, 0xec, 0x19, 0xba, 0x2d, 0xb9, 0x2b,
+  0x9f, 0x34, 0x5e, 0xab, 0xe1, 0x7a, 0x1a, 0xba, 0x8e, 0xc6, 0x2d, 0x36,
+  0x49, 0x57, 0x0c, 0xe8, 0x76, 0xe9, 0xce, 0x6f, 0x3b, 0x1f, 0xed, 0x4d,
+  0xb4, 0x43, 0xfd, 0x48, 0x29, 0xcc, 0xfa, 0xe3, 0xa9, 0xfe, 0x98, 0x6c,
+  0xae, 0x1f, 0x33, 0xb8, 0x38, 0xfb, 0x23, 0x30, 0xd1, 0x1a, 0x78, 0xc1,
+  0x5d, 0x24, 0xf7, 0xf7, 0x26, 0xe6, 0xe6, 0xf6, 0x68, 0xf0, 0x47, 0x4f,
+  0x7d, 0xb0, 0xfd, 0x6a, 0xc0, 0x8f, 0xfe, 0x0c, 0x3f, 0xda, 0xcd, 0x39,
+  0xea, 0xf7, 0x31, 0x34, 0x71, 0x18, 0x1c, 0x6e, 0x70, 0xe8, 0xbc, 0xbd,
+  0xc4, 0x23, 0x17, 0x77, 0x29, 0x37, 0x77, 0x69, 0xe5, 0x8f, 0x86, 0x95,
+  0x43, 0x3b, 0xee, 0xe4, 0x3a, 0xd9, 0xcb, 0xab, 0x94, 0xeb, 0xbb, 0xf4,
+  0xc9, 0x9b, 0xbc, 0xb2, 0x6b, 0xbc, 0xf4, 0xf8, 0x1e, 0x2f, 0xed, 0x86,
+  0xa1, 0x7e, 0x8a, 0x1e, 0x3f, 0x0e, 0x16, 0xb4, 0x9d, 0xd5, 0x0f, 0xb1,
+  0xb9, 0xed, 0x9e, 0x87, 0xea, 0x29, 0xba, 0x95, 0x59, 0x0d, 0x20, 0xc7,
+  0xfd, 0xbd, 0xc4, 0xcc, 0x03, 0x26, 0xb8, 0x47, 0x57, 0x43, 0xe2, 0x8f,
+  0xb9, 0x84, 0xcd, 0x21, 0x81, 0x98, 0x60, 0x8c, 0x4e, 0xac, 0x75, 0xbd,
+  0xbb, 0x46, 0xcb, 0x7d, 0x3c, 0xfc, 0x11, 0xfd, 0x67, 0x8c, 0x94, 0x9c,
+  0xab, 0x1b, 0xbb, 0x95, 0x8d, 0xf9, 0x63, 0xcf, 0x91, 0xa2, 0x43, 0xe3,
+  0x3b, 0xcc, 0x09, 0x77, 0x5c, 0x61, 0xd6, 0x18, 0x80, 0xf2, 0x1a, 0x3a,
+  0x8f, 0x98, 0x5e, 0x66, 0x0f, 0x02, 0x43, 0xc6, 0x4d, 0xca, 0x5c, 0x4e,
+  0x4c, 0x37, 0x88, 0xa1, 0xf3, 0xe7, 0x97, 0xa1, 0x73, 0x53, 0x36, 0x80,
+  0xcd, 0x31, 0x73, 0x5f, 0x56, 0xd1, 0x71, 0xed, 0xdc, 0x6e, 0x23, 0xcb,
+  0x32, 0x11, 0xd9, 0x8e, 0x8f, 0x93, 0xd9, 0x3c, 0x30, 0xa9, 0xc6, 0xcc,
+  0x4b, 0x8c, 0xde, 0xf5, 0x8c, 0xd8, 0x33, 0x66, 0xde, 0x4b, 0x35, 0x46,
+  0xf3, 0x87, 0x66, 0x0a, 0xf1, 0xe3, 0x70, 0x33, 0x05, 0xcb, 0x4b, 0x62,
+  0xa6, 0x24, 0x04, 0xa6, 0x2c, 0x57, 0xb9, 0xb0, 0x3b, 0xf8, 0x9b, 0x5d,
+  0x7a, 0x60, 0xef, 0x90, 0xf6, 0x93, 0x05, 0xe5, 0x10, 0xf9, 0x77, 0x1a,
+  0xc6, 0xc3, 0x98, 0x3a, 0x00, 0xd3, 0x62, 0xce, 0x35, 0x83, 0xb0, 0x38,
+  0xac, 0x3b, 0xf0, 0x91, 0x01, 0x03, 0xed, 0x1d, 0xda, 0xea, 0x11, 0xbd,
+  0xc2, 0xe1, 0x19, 0x87, 0x6d, 0x39, 0xec, 0x65, 0x60, 0xa7, 0xc3, 0xcb,
+  0x4d, 0x3e, 0x73, 0x92, 0xa1, 0x21, 0xc7, 0x6b, 0x7e, 0x62, 0x4e, 0x29,
+  0x70, 0x43, 0x82, 0xee, 0xb2, 0x0b, 0xb4, 0x26, 0x5b, 0xea, 0xba, 0x07,
+  0x0a, 0xf1, 0x33, 0x17, 0xfa, 0x08, 0x0d, 0x2a, 0x26, 0x18, 0xf7, 0xeb,
+  0x09, 0x5d, 0x0d, 0x9e, 0x00, 0xd8, 0x73, 0xea, 0xcb, 0x65, 0x3d, 0x79,
+  0xff, 0xde, 0xa2, 0xe0, 0x96, 0xf7, 0x76, 0x2f, 0xee, 0x7d, 0x01, 0xc7,
+  0xb9, 0x11, 0xb8, 0xa6, 0x06, 0x74, 0x0c, 0x1f, 0x38, 0x2a, 0x44, 0x4f,
+  0x4b, 0x44, 0x47, 0x86, 0x4d, 0x0f, 0x1f, 0x2b, 0x8a, 0x5a, 0x65, 0x61,
+  0x07, 0x6e, 0x33, 0x01, 0xb8, 0x27, 0x33, 0x83, 0xcd, 0x7b, 0xd6, 0xb8,
+  0xf5, 0xc4, 0xce, 0xb7, 0x7c, 0xb4, 0xd1, 0x7a, 0xec, 0x5c, 0xa1, 0x25,
+  0xd5, 0x23, 0x91, 0x96, 0xb1, 0xda, 0x5a, 0x53, 0x2c, 0x3f, 0xe1, 0xc3,
+  0x9d, 0x8b, 0x49, 0x45, 0xd4, 0x02, 0x27, 0x45, 0xee, 0x8a, 0xe9, 0xbe,
+  0xd1, 0x8c, 0x3b, 0x52, 0xc9, 0x2d, 0x2b, 0x6d, 0x88, 0x0d, 0x47, 0xd3,
+  0xe9, 0x8a, 0x29, 0x2e, 0xa0, 0x52, 0xb8, 0xfb, 0x0d, 0x90, 0x00, 0x1a,
+  0x6f, 0x28, 0x74, 0xb1, 0x59, 0x28, 0x96, 0x58, 0x97, 0xed, 0x42, 0xff,
+  0x66, 0x3e, 0x9b, 0xa6, 0x0f, 0xdc, 0x7d, 0x09, 0x2b, 0xec, 0x18, 0x3a,
+  0x16, 0x5d, 0x7b, 0xa2, 0x30, 0x94, 0x99, 0x62, 0x9a, 0x68, 0xe0, 0x1f,
+  0x5c, 0xa6, 0x46, 0xfa, 0xd7, 0xb2, 0x11, 0xe2, 0x6f, 0xe3, 0xf6, 0x50,
+  0x5d, 0xa1, 0xc6, 0x2c, 0x08, 0x58, 0x9e, 0xe6, 0x88, 0x48, 0x95, 0x68,
+  0x2a, 0x37, 0xba, 0xe2, 0x8f, 0x5e, 0xa3, 0x1d, 0x1d, 0x45, 0xba, 0xa9,
+  0xea, 0x2c, 0x9e, 0x80, 0x20, 0xe6, 0x4e, 0x41, 0x03, 0x3c, 0x5b, 0x98,
+  0x88, 0xce, 0xd2, 0x8e, 0xe2, 0x32, 0x1c, 0x5e, 0x13, 0x16, 0x97, 0x45,
+  0xc3, 0x9d, 0xcc, 0x8d, 0xb1, 0xfd, 0xac, 0x7f, 0x2b, 0xe4, 0x20, 0x5b,
+  0xd4, 0x1c, 0x5c, 0x0e, 0x92, 0xc6, 0xcb, 0xef, 0x35, 0x7e, 0x70, 0x79,
+  0x24, 0xad, 0x82, 0xfd, 0x52, 0xf7, 0x96, 0xb9, 0x34, 0x6e, 0x07, 0xa1,
+  0xeb, 0xcd, 0xe5, 0x61, 0xad, 0x28, 0x34, 0xa6, 0xb1, 0x8d, 0xd3, 0x2e,
+  0x86, 0xf2, 0x97, 0x1d, 0xda, 0xff, 0xbf, 0x63, 0x61, 0xbf, 0x72, 0x2c,
+  0xf8, 0x87, 0x58, 0x14, 0x07, 0x96, 0xd5, 0x03, 0x41, 0xa1, 0x08, 0x30,
+  0xb6, 0x3e, 0x75, 0x2c, 0x63, 0xdc, 0xa0, 0x53, 0x12, 0x2e, 0x35, 0x09,
+  0x42, 0x5c, 0xc0, 0x7c, 0x3e, 0xf3, 0x94, 0x42, 0x4a, 0x40, 0xc5, 0x9d,
+  0xe8, 0xc2, 0x02, 0xb1, 0x71, 0x8e, 0x93, 0x54, 0xe3, 0x5f, 0x07, 0x51,
+  0x68, 0xdb, 0x99, 0x79, 0xbb, 0x6e, 0x89, 0xa4, 0xf8, 0x12, 0x51, 0x23,
+  0xd7, 0xae, 0x0b, 0xc3, 0xf2, 0xb4, 0x5f, 0xc6, 0x5a, 0xc2, 0xd8, 0xc6,
+  0x30, 0xb7, 0x31, 0x6d, 0x71, 0x7e, 0xfd, 0x74, 0xf1, 0x2c, 0xaf, 0xb0,
+  0x3a, 0xfe, 0xaa, 0x7b, 0x38, 0x55, 0x17, 0x33, 0x30, 0x4c, 0x98, 0xff,
+  0xbc, 0x38, 0xfd, 0x70, 0xf6, 0x36, 0xfc, 0x92, 0xec, 0x6d, 0x53, 0x16,
+  0xd0, 0x4d, 0x7b, 0x76, 0xb8, 0xb4, 0xac, 0x7f, 0x23, 0xff, 0x3a, 0x5d,
+  0x16, 0x75, 0x51, 0xf9, 0x57, 0x88, 0xe4, 0x1b, 0xb3, 0xb7, 0xff, 0x07,
+  0xcb, 0x4b, 0x74, 0x5c, 0x80, 0x4a, 0x00, 0x00
+};
+
+const GFXglyph Antonio_SemiBold40pt7bGlyphs[] PROGMEM = {
+    {0, 1, 1, 17, 0, 0},                                       // 0x20 ' '
+    {1, 10, 67, 20, 5, -66},                                   // 0x21 '!'
+    {85, 10, 25, 32, 12, -66},                                 // 0x22 '"'
+    {117, 34, 67, 40, 3, -66},                                 // 0x23 '#'
+    {402, 26, 76, 32, 3, -66},                                 // 0x24 '$'
+    {649, 72, 69, 84, 6, -67},                                 // 0x25 '%'
+    {1270, 35, 69, 38, 3, -67},                                // 0x26 '&'
+    {1572, 8, 24, 16, 4, -66},                                 // 0x27 '''
+    {1596, 14, 77, 22, 5, -68},                                // 0x28 '('
+    {1731, 14, 77, 22, 3, -68},                                // 0x29 ')'
+    {1866, 29, 29, 35, 3, -65},                                // 0x2A '*'
+    {1972, 24, 24, 28, 2, -41},                                // 0x2B '+'
+    {2044, 10, 23, 18, 5, -9},                                 // 0x2C ','
+    {2073, 18, 6, 27, 3, -33},                                 // 0x2D '-'
+    {2087, 8, 8, 20, 6, -7},                                   // 0x2E '.'
+    {2095, 24, 68, 29, 3, -67},                                // 0x2F '/'
+    {2299, 27, 69, 35, 4, -67},                                // 0x30 '0'
+    {2532, 19, 67, 30, 3, -66},                                // 0x31 '1'
+    {2692, 25, 68, 34, 6, -67},                                // 0x32 '2'
+    {2905, 27, 69, 34, 4, -67},                                // 0x33 '3'
+    {3138, 30, 67, 34, 3, -66},                                // 0x34 '4'
+    {3390, 25, 68, 34, 5, -66},                                // 0x35 '5'
+    {3603, 27, 69, 34, 4, -67},                                // 0x36 '6'
+    {3836, 28, 67, 34, 4, -66},                                // 0x37 '7'
+    {4071, 27, 69, 34, 4, -67},                                // 0x38 '8'
+    {4304, 27, 69, 34, 3, -67},                                // 0x39 '9'
+    {4537, 10, 40, 20, 5, -49},                                // 0x3A ':'
+    {4587, 10, 54, 21, 6, -49},                                // 0x3B ';'
+    {4655, 22, 38, 28, 2, -47},                                // 0x3C '<'
+    {4760, 21, 19, 28, 4, -40},                                // 0x3D '='
+    {4810, 22, 38, 28, 3, -47},                                // 0x3E '>'
+    {4915, 24, 68, 33, 5, -67},                                // 0x3F '?'
+    {5119, 48, 71, 58, 5, -67},                                // 0x40 '@'
+    {5545, 31, 69, 37, 2, -67},                       // 0x41 'A'
+    {5805, 28, 67, 36, 5, -66},                                // 0x42 'B'
+    {6040, 27, 69, 36, 5, -67},                                // 0x43 'C'
+    {6273, 28, 67, 37, 5, -66},                                // 0x44 'D'
+    {6508, 22, 67, 30, 5, -66},                                // 0x45 'E'
+    {6693, 22, 67, 29, 5, -66},                                // 0x46 'F'
+    {6878, 27, 69, 37, 5, -67},                                // 0x47 'G'
+    {7111, 28, 67, 39, 5, -66},                                // 0x48 'H'
+    {7346, 9, 67, 20, 5, -66},                                 // 0x49 'I'
+    {7422, 26, 68, 35, 3, -66},                                // 0x4A 'J'
+    {7643, 30, 67, 36, 5, -66},                                // 0x4B 'K'
+    {7895, 22, 67, 28, 5, -66},                                // 0x4C 'L'
+    {8080, 41, 67, 52, 5, -66},                                // 0x4D 'M'
+    {8424, 29, 67, 40, 5, -66},                                // 0x4E 'N'
+    {8667, 27, 69, 37, 5, -67},                                // 0x4F 'O'
+    {8900, 28, 67, 35, 5, -66},                                // 0x50 'P'
+    {9135, 27, 79, 37, 5, -67},                                // 0x51 'Q'
+    {9402, 28, 67, 37, 5, -66},                                // 0x52 'R'
+    {9637, 27, 69, 32, 3, -67},                                // 0x53 'S'
+    {9870, 23, 67, 25, 1, -66},                                // 0x54 'T'
+    {10063, 28, 68, 37, 5, -66},                               // 0x55 'U'
+    {10301, 31, 67, 35, 2, -66},                               // 0x56 'V'
+    {10561, 48, 67, 52, 2, -66},                               // 0x57 'W'
+    {10963, 28, 67, 32, 2, -66},                               // 0x58 'X'
+    {11198, 31, 67, 32, 1, -66},                               // 0x59 'Y'
+    {11458, 23, 67, 27, 3, -66},                               // 0x5A 'Z'
+    {18021, 31, 69, 37, 2, -67},                       // 0x5B '[' --> euro {     18290,  31,  69,  37,    2,  -67 } was {11651, 17, 70, 26, 6, -66}
+    {11800, 24, 67, 30, 3, -66},                               // 0x5C '\' 
+    {18557,  30,  68,  36,    3,  -67 },                               // 0x5D ']' --> pound {     0,  30,  68,  36,    3,  -67 } was {12001, 16, 70, 26, 4, -66}
+    {18812,  31,  67,  32,    1,  -66 },                               // 0x5E '^' --> yen {     0,  31,  67,  32,    1,  -66 } was  {12141, 29, 35, 37, 4, -66
+    {12268, 25, 7, 29, 2, 2},                                  // 0x5F '_'
+    {12290, 12, 15, 16, 2, -77},                               // 0x60 '`'
+    {12313, 27, 59, 36, 4, -57},                               // 0x61 'a'
+    {12513, 27, 69, 37, 5, -67},                               // 0x62 'b'
+    {12746, 26, 59, 35, 5, -57},                               // 0x63 'c'
+    {12938, 26, 69, 37, 5, -67},                               // 0x64 'd'
+    {13163, 26, 59, 35, 5, -57},                               // 0x65 'e'
+    {13355, 20, 68, 25, 3, -67},                               // 0x66 'f'
+    {13525, 27, 67, 36, 4, -57},                               // 0x67 'g'
+    {13752, 28, 68, 38, 5, -67},                               // 0x68 'h'
+    {13990, 10, 71, 20, 5, -70},                               // 0x69 'i'
+    {14079, 14, 79, 20, 2, -70},                               // 0x6A 'j'
+    {14218, 30, 68, 35, 5, -67},                               // 0x6B 'k'
+    {14473, 9, 68, 20, 5, -67},                                // 0x6C 'l'
+    {14550, 46, 58, 56, 5, -57},                               // 0x6D 'm'
+    {14884, 28, 58, 38, 5, -57},                               // 0x6E 'n'
+    {15087, 26, 59, 36, 5, -57},                               // 0x6F 'o'
+    {15279, 27, 69, 37, 5, -57},                               // 0x70 'p'
+    {15512, 26, 69, 37, 5, -57},                               // 0x71 'q'
+    {15737, 19, 58, 25, 5, -57},                               // 0x72 'r'
+    {15875, 26, 59, 32, 3, -57},                               // 0x73 's'
+    {16067, 20, 67, 23, 2, -66},                               // 0x74 't'
+    {16235, 27, 58, 38, 5, -56},                               // 0x75 'u'
+    {16431, 27, 57, 31, 2, -56},                               // 0x76 'v'
+    {16624, 42, 57, 46, 2, -56},                               // 0x77 'w'
+    {16924, 28, 57, 30, 1, -56},                               // 0x78 'x'
+    {17124, 28, 67, 31, 2, -56},                               // 0x79 'y'
+    {17359, 21, 57, 27, 3, -56},                               // 0x7A 'z'
+    {17509, 20, 75, 27, 4, -67},                               // 0x7B '{'
+    {17697, 9, 75, 21, 6, -70},                                // 0x7C '|'
+    {17782, 19, 75, 27, 4, -67},                               // 0x7D '}'
+    {17961, 34, 14, 43, 4, -44}}; // 0x7E '~'
+
+
+//, {18021, 31, 69, 37, 2, -67}
+
+// const GFXfont Antonio_SemiBold40pt7b PROGMEM = {
+//     (uint8_t *)Antonio_SemiBold40pt7bBitmaps,
+//     (GFXglyph *)Antonio_SemiBold40pt7bGlyphs, 0x20, 0x7E, 100};
+
+// Approx. 18961 bytes
+
+// // Font metadata structure
+// struct FontData {
+//     const uint8_t* compressedData;
+//     const GFXglyph* glyphs;
+//     const size_t compressedSize;
+//     const size_t originalSize;
+//     const uint16_t first;
+//     const uint16_t last;
+//     const uint8_t yAdvance;
+// };
+
+// Font properties
+static constexpr FontData Antonio_SemiBold40pt7b_Properties = {
+    Antonio_SemiBold40pt7bBitmaps_Gzip,
+    Antonio_SemiBold40pt7bGlyphs,
+    sizeof(Antonio_SemiBold40pt7bBitmaps_Gzip),
+    19072,  // Original size
+    0x20,   // First char
+    0x7E,   // Last char
+    100     // yAdvance
+};

src/fonts/fonts.hpp

@@ -1,11 +1,97 @@
 #pragma once
 
-#include "antonio-semibold20.h"
-#include "antonio-semibold30.h"
-#include "antonio-semibold90.h"
-#include "oswald-20.h"
-#include "oswald-30.h"
-#include "oswald-90.h"
-#include "ubuntu-italic40.h"
-#include "ubuntu-italic60.h"
-#include "ubuntu-italic70.h"
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+#include <rom/miniz.h>
+
+// Font metadata structure
+struct FontData {
+    const uint8_t* compressedData;
+    const GFXglyph* glyphs;
+    const size_t compressedSize;
+    const size_t originalSize;
+    const uint16_t first;
+    const uint16_t last;
+    const uint8_t yAdvance;
+};
+
+// Font name constants
+namespace FontNames {
+    static const String ANTONIO = "antonio";
+    static const String OSWALD = "oswald";
+
+    static const std::array<String, 2> AVAILABLE_FONTS = {
+        ANTONIO,
+        OSWALD
+    };
+
+    static const std::array<String, 2>& getAvailableFonts() {
+        return AVAILABLE_FONTS;
+    }
+}
+
+class FontLoader {
+public:
+    static GFXfont* loadCompressedFont(const FontData& fontData) {
+        return loadCompressedFont(
+            fontData.compressedData,
+            fontData.glyphs,
+            fontData.compressedSize,
+            fontData.originalSize,
+            fontData.first,
+            fontData.last,
+            fontData.yAdvance
+        );
+    }
+
+    static GFXfont* loadCompressedFont(
+        const uint8_t* compressedData,
+        const GFXglyph* glyphs,
+        const size_t compressedSize,
+        const size_t originalSize,
+        const uint16_t first,
+        const uint16_t last,
+        const uint8_t yAdvance) 
+    {
+        uint8_t* decompressedData = (uint8_t*)malloc(originalSize);
+        if (!decompressedData) {
+            Serial.println(F("Failed to allocate memory for font decompression"));
+            return nullptr;
+        }
+
+        size_t decompressedSize = originalSize;
+        if (GzipDecompressor::decompressData(compressedData, 
+                                           compressedSize,
+                                           decompressedData, 
+                                           &decompressedSize))
+        {
+            GFXfont* font = (GFXfont*)malloc(sizeof(GFXfont));
+            if (!font) {
+                free(decompressedData);
+                Serial.println(F("Failed to allocate memory for font structure"));
+                return nullptr;
+            }
+
+            font->bitmap = decompressedData;
+            font->glyph = (GFXglyph*)glyphs;
+            font->first = first;
+            font->last = last;
+            font->yAdvance = yAdvance;
+
+            return font;
+        }
+
+        Serial.println(F("Font decompression failed"));
+        free(decompressedData);
+        return nullptr;
+    }
+
+    static void unloadFont(GFXfont* font) {
+        if (font) {
+            if (font->bitmap) {
+                free((void*)font->bitmap);
+            }
+            free(font);
+        }
+    }
+};

src/fonts/oswald-20.h

@@ -1,488 +0,0 @@
-const uint8_t Oswald_Regular20pt7bBitmaps[] PROGMEM = {
-  0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x77, 0x76, 0x66, 0x66, 0x66, 0x66,
-  0x66, 0x60, 0x00, 0xFF, 0xFF, 0xF7, 0xF3, 0xF9, 0xFC, 0xFE, 0x77, 0x3B,
-  0x9D, 0x8E, 0xC7, 0x63, 0x80, 0x07, 0x87, 0x83, 0xC7, 0xC1, 0xE3, 0xC1,
-  0xF1, 0xE0, 0xF0, 0xF0, 0x78, 0x78, 0x3C, 0x3C, 0x1E, 0x1E, 0x0F, 0x1F,
-  0x07, 0x8F, 0x07, 0xC7, 0x9F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x78,
-  0x78, 0x3C, 0x7C, 0x1E, 0x3C, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xF9, 0xE3, 0xE0, 0xF1, 0xF0, 0x78, 0xF0, 0x7C, 0x78, 0x3C, 0x3C,
-  0x1E, 0x1E, 0x0F, 0x0F, 0x07, 0x8F, 0x83, 0xC7, 0xC1, 0xE3, 0xC1, 0xF1,
-  0xE0, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x0F, 0xE0, 0x3F, 0xF0, 0x7F,
-  0xF8, 0xFE, 0xFC, 0xF0, 0x3C, 0xF0, 0x1E, 0xF0, 0x1E, 0xF0, 0x1E, 0xF0,
-  0x1C, 0xF0, 0x00, 0xF8, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0x3F, 0x00, 0x1F,
-  0x80, 0x0F, 0xE0, 0x07, 0xF0, 0x03, 0xF8, 0x01, 0xF8, 0x00, 0xFC, 0x00,
-  0x7E, 0x00, 0x3E, 0x20, 0x1E, 0xF0, 0x1E, 0xF0, 0x1F, 0xF0, 0x1F, 0xF0,
-  0x1E, 0xF8, 0x1E, 0x7C, 0x3E, 0x3F, 0xFC, 0x3F, 0xF8, 0x0F, 0xF0, 0x00,
-  0x80, 0x00, 0x80, 0x00, 0x80, 0x0F, 0x80, 0x1E, 0x00, 0x3F, 0xE0, 0x1C,
-  0x00, 0x7F, 0xF0, 0x3C, 0x00, 0x78, 0xF0, 0x3C, 0x00, 0x78, 0x70, 0x38,
-  0x00, 0xF0, 0x78, 0x38, 0x00, 0xF0, 0x78, 0x78, 0x00, 0xF0, 0x78, 0x78,
-  0x00, 0xF0, 0x78, 0x70, 0x00, 0xF0, 0x78, 0x70, 0x00, 0xF0, 0x78, 0xF0,
-  0x00, 0x70, 0x78, 0xF0, 0x00, 0x78, 0x70, 0xE0, 0x00, 0x78, 0xF1, 0xE0,
-  0x00, 0x7F, 0xF1, 0xE0, 0x00, 0x3F, 0xE1, 0xC0, 0xF8, 0x1F, 0xC1, 0xC3,
-  0xFE, 0x00, 0x03, 0xC7, 0xFE, 0x00, 0x03, 0xC7, 0x9F, 0x00, 0x03, 0x87,
-  0x0F, 0x00, 0x07, 0x8F, 0x07, 0x00, 0x07, 0x8F, 0x07, 0x00, 0x07, 0x8F,
-  0x07, 0x00, 0x07, 0x0F, 0x07, 0x00, 0x0F, 0x0F, 0x07, 0x00, 0x0F, 0x0F,
-  0x07, 0x00, 0x0E, 0x0F, 0x07, 0x00, 0x0E, 0x0F, 0x0F, 0x00, 0x1E, 0x07,
-  0x8F, 0x00, 0x1E, 0x07, 0xFF, 0x00, 0x1C, 0x03, 0xFE, 0x00, 0x3C, 0x01,
-  0xFC, 0x07, 0xE0, 0x00, 0xFF, 0x80, 0x1F, 0xFC, 0x03, 0xF7, 0xC0, 0x3C,
-  0x3E, 0x03, 0xC1, 0xE0, 0x7C, 0x1E, 0x07, 0xC1, 0xE0, 0x3C, 0x3E, 0x03,
-  0xC3, 0xC0, 0x3C, 0x3C, 0x01, 0xE7, 0x80, 0x1E, 0x70, 0x00, 0xEF, 0x00,
-  0x0F, 0xE0, 0x00, 0x7C, 0x00, 0x0F, 0x80, 0x01, 0xFC, 0x1F, 0x1F, 0xC1,
-  0xE3, 0xDE, 0x1E, 0x7D, 0xF1, 0xE7, 0x8F, 0x1E, 0x78, 0x7B, 0xCF, 0x87,
-  0xFC, 0xF8, 0x3F, 0xCF, 0x01, 0xF8, 0xF8, 0x1F, 0x87, 0x83, 0xFC, 0x7C,
-  0x7F, 0xF7, 0xFF, 0xFF, 0x3F, 0xF9, 0xF0, 0xFE, 0x0F, 0xFE, 0xEE, 0xEE,
-  0xEC, 0xCC, 0x07, 0x1F, 0x1F, 0x3C, 0x78, 0x78, 0x78, 0x70, 0xF0, 0xF0,
-  0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
-  0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x78, 0x78,
-  0x78, 0x38, 0x3E, 0x1F, 0x0F, 0x01, 0xE0, 0xF0, 0xF8, 0x3C, 0x3C, 0x1E,
-  0x1E, 0x1E, 0x1E, 0x1E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
-  0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0E,
-  0x1E, 0x1E, 0x1E, 0x1E, 0x1C, 0x3C, 0x7C, 0xF8, 0xF0, 0x80, 0x07, 0x00,
-  0x38, 0x01, 0xC1, 0x0E, 0x2E, 0x73, 0x7F, 0x7D, 0xFF, 0xC1, 0xF0, 0x0F,
-  0x80, 0xEC, 0x0E, 0x70, 0x71, 0xC7, 0x0E, 0x08, 0x40, 0x07, 0x80, 0x1E,
-  0x00, 0x78, 0x01, 0xE0, 0x07, 0x80, 0x1E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFC, 0x1E, 0x00, 0x78, 0x01, 0xE0, 0x07, 0x80, 0x1E, 0x00, 0x78, 0x01,
-  0xE0, 0xFF, 0xFF, 0xF3, 0x36, 0xEC, 0xFF, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF,
-  0xF0, 0x00, 0x70, 0x0F, 0x00, 0xF0, 0x0E, 0x00, 0xE0, 0x1E, 0x01, 0xE0,
-  0x1C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x38, 0x07, 0x80, 0x78, 0x07, 0x00,
-  0x70, 0x0F, 0x00, 0xF0, 0x0E, 0x01, 0xE0, 0x1E, 0x01, 0xE0, 0x1C, 0x03,
-  0xC0, 0x3C, 0x03, 0xC0, 0x38, 0x07, 0x80, 0x78, 0x07, 0x00, 0x70, 0x0F,
-  0x00, 0x07, 0xE0, 0x1F, 0xF8, 0x3F, 0xFC, 0x3F, 0x7E, 0x7C, 0x1E, 0x78,
-  0x1E, 0xF8, 0x1F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8,
-  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8,
-  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8,
-  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0x78, 0x1F, 0x78, 0x1E, 0x7E, 0x3E, 0x3F,
-  0xFC, 0x1F, 0xF8, 0x0F, 0xF0, 0x01, 0xC1, 0xF0, 0xFD, 0xFF, 0xFF, 0xFF,
-  0xFC, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C,
-  0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03,
-  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x07, 0xE0, 0x3F,
-  0xF0, 0xFF, 0xF3, 0xFF, 0xE7, 0x83, 0xFF, 0x03, 0xFC, 0x07, 0xF8, 0x0F,
-  0xF0, 0x1F, 0xE0, 0x3C, 0x00, 0x78, 0x01, 0xF0, 0x03, 0xE0, 0x07, 0x80,
-  0x1F, 0x00, 0x7C, 0x00, 0xF0, 0x03, 0xE0, 0x0F, 0x80, 0x1E, 0x00, 0x7C,
-  0x01, 0xF0, 0x03, 0xC0, 0x0F, 0x80, 0x3E, 0x00, 0x78, 0x01, 0xF0, 0x03,
-  0xC0, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xE0, 0x7F,
-  0xE1, 0xFF, 0xF3, 0xF7, 0xEF, 0x83, 0xFE, 0x03, 0xFC, 0x07, 0xF8, 0x0F,
-  0xF0, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x01, 0xF0, 0x07, 0xC0, 0x7F, 0x00,
-  0xFC, 0x01, 0xF8, 0x03, 0xF8, 0x01, 0xF8, 0x00, 0xF0, 0x01, 0xF0, 0x01,
-  0xE0, 0x03, 0xC0, 0x07, 0xF8, 0x0F, 0xF0, 0x1F, 0xE0, 0x3F, 0xC0, 0x7F,
-  0xC1, 0xFF, 0xC7, 0xCF, 0xFF, 0x8F, 0xFE, 0x0F, 0xF0, 0x00, 0xF8, 0x01,
-  0xF8, 0x01, 0xF8, 0x03, 0xF8, 0x03, 0xF8, 0x03, 0xF8, 0x07, 0x78, 0x07,
-  0x78, 0x0F, 0x78, 0x0E, 0x78, 0x1E, 0x78, 0x1E, 0x78, 0x3C, 0x78, 0x3C,
-  0x78, 0x3C, 0x78, 0x78, 0x78, 0x78, 0x78, 0xF0, 0x78, 0xF0, 0x78, 0xF0,
-  0x78, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x78, 0x00,
-  0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00, 0x78, 0x00,
-  0x78, 0x7F, 0xFC, 0xFF, 0xF9, 0xFF, 0xF3, 0xFF, 0xE7, 0x00, 0x0E, 0x00,
-  0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x84, 0x07,
-  0x7F, 0x0F, 0xFF, 0x1F, 0xFF, 0x3C, 0x1F, 0x78, 0x1E, 0x00, 0x3C, 0x00,
-  0x78, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0xF8, 0x0F, 0xF0, 0x1F,
-  0xE0, 0x3F, 0xC0, 0x7F, 0xC1, 0xF7, 0xC7, 0xCF, 0xFF, 0x8F, 0xFE, 0x0F,
-  0xF0, 0x07, 0xE0, 0x1F, 0xF8, 0x3F, 0xFC, 0x3F, 0xFE, 0x7C, 0x1E, 0x78,
-  0x1F, 0x78, 0x1F, 0x78, 0x0F, 0xF8, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0,
-  0x00, 0xF0, 0x00, 0xF3, 0xF0, 0xF7, 0xFC, 0xFF, 0xFE, 0xFC, 0x3E, 0xF8,
-  0x1E, 0xF0, 0x1F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0,
-  0x0F, 0xF8, 0x0F, 0x78, 0x1F, 0x78, 0x1E, 0x78, 0x1E, 0x3E, 0x3E, 0x3F,
-  0xFC, 0x1F, 0xF8, 0x0F, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0,
-  0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03,
-  0xC0, 0x1E, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x01, 0xE0,
-  0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03,
-  0xC0, 0x1E, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x07, 0xE0, 0x1F,
-  0xF8, 0x3F, 0xFC, 0x7E, 0x7C, 0x78, 0x3E, 0x78, 0x1E, 0xF8, 0x1E, 0xF0,
-  0x1E, 0xF0, 0x1E, 0xF8, 0x1E, 0x78, 0x1E, 0x78, 0x3E, 0x7C, 0x3C, 0x3F,
-  0xFC, 0x1F, 0xF8, 0x0F, 0xF0, 0x3F, 0xF8, 0x7E, 0x7C, 0x78, 0x3E, 0xF8,
-  0x1E, 0xF0, 0x1E, 0xF0, 0x1F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x1F, 0xF0,
-  0x1E, 0xF0, 0x1E, 0x78, 0x1E, 0x7C, 0x3E, 0x7F, 0xFC, 0x3F, 0xF8, 0x0F,
-  0xF0, 0x07, 0xC0, 0x3F, 0xE0, 0xFF, 0xE3, 0xF7, 0xE7, 0x83, 0xDF, 0x03,
-  0xFC, 0x07, 0xF8, 0x0F, 0xF0, 0x1F, 0xE0, 0x3F, 0xC0, 0x7F, 0x80, 0xFF,
-  0x01, 0xFE, 0x03, 0xFE, 0x07, 0xFC, 0x1F, 0x7F, 0xFE, 0x7F, 0xFC, 0x7F,
-  0x78, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0xF0, 0x1F,
-  0xE0, 0x3F, 0xC0, 0x7F, 0xC1, 0xE7, 0xC7, 0xCF, 0xFF, 0x0F, 0xFE, 0x07,
-  0xF0, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xF8,
-  0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFE,
-  0x33, 0x9B, 0xC8, 0x00, 0x20, 0x04, 0x01, 0x80, 0xF0, 0x3E, 0x1F, 0x87,
-  0xE1, 0xF8, 0xFC, 0x1F, 0x03, 0x80, 0x7C, 0x0F, 0xC0, 0xFC, 0x07, 0xE0,
-  0x7E, 0x03, 0xE0, 0x3C, 0x03, 0x80, 0x10, 0x02, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0x80,
-  0x0C, 0x00, 0xE0, 0x0F, 0x80, 0xFC, 0x07, 0xE0, 0x1F, 0x80, 0xFC, 0x03,
-  0xF0, 0x1F, 0x00, 0xF0, 0x1F, 0x03, 0xF0, 0xFC, 0x1F, 0x87, 0xE0, 0xFC,
-  0x0F, 0x80, 0xE0, 0x0C, 0x00, 0x80, 0x00, 0x0F, 0xE0, 0x3F, 0xF0, 0xFF,
-  0xF3, 0xFF, 0xEF, 0x83, 0xFE, 0x03, 0xFC, 0x07, 0xF8, 0x0F, 0xF0, 0x1F,
-  0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x03, 0xE0, 0x07, 0x80, 0x1F, 0x00,
-  0x7C, 0x01, 0xF0, 0x07, 0xC0, 0x1F, 0x00, 0x7C, 0x00, 0xF0, 0x01, 0xE0,
-  0x03, 0xC0, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x00, 0x01, 0xF8, 0x00, 0x00,
-  0x1F, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 0xC0, 0x01, 0xFF, 0xFF, 0xE0, 0x03,
-  0xF8, 0x01, 0xF0, 0x07, 0xE0, 0x00, 0xF8, 0x0F, 0xC0, 0x00, 0x7C, 0x0F,
-  0x00, 0x00, 0x3C, 0x1F, 0x00, 0x60, 0x1C, 0x1E, 0x03, 0xFF, 0x1E, 0x3C,
-  0x07, 0xFF, 0x0E, 0x3C, 0x0F, 0xFF, 0x0E, 0x78, 0x1F, 0x0F, 0x0F, 0x78,
-  0x1E, 0x0E, 0x07, 0x78, 0x3E, 0x1E, 0x07, 0x78, 0x3C, 0x1E, 0x07, 0x70,
-  0x3C, 0x1E, 0x07, 0xF0, 0x78, 0x1E, 0x07, 0xF0, 0x78, 0x1E, 0x0E, 0xF0,
-  0x78, 0x1C, 0x0E, 0xF0, 0x78, 0x1C, 0x0E, 0xF0, 0x78, 0x3C, 0x0E, 0xF0,
-  0x78, 0x3C, 0x1C, 0xF0, 0x78, 0x7C, 0x1C, 0x70, 0x7C, 0xFC, 0x38, 0x78,
-  0x3F, 0xDC, 0xF0, 0x78, 0x1F, 0xDF, 0xE0, 0x78, 0x0F, 0x8F, 0x80, 0x3C,
-  0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1F,
-  0x00, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x07, 0xF8, 0x03, 0x00, 0x03,
-  0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x80, 0x00, 0x1F, 0xFE, 0x00, 0x03,
-  0xE0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, 0xF0, 0x01, 0xFC,
-  0x00, 0x7F, 0x00, 0x1D, 0xC0, 0x07, 0x78, 0x01, 0xDE, 0x00, 0xF7, 0x80,
-  0x3C, 0xE0, 0x0F, 0x38, 0x03, 0x8F, 0x01, 0xE3, 0xC0, 0x78, 0xF0, 0x1E,
-  0x3C, 0x07, 0x87, 0x01, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0xFF,
-  0x83, 0xFF, 0xF0, 0xFF, 0xFC, 0x78, 0x0F, 0x1E, 0x03, 0xC7, 0x80, 0xF1,
-  0xE0, 0x1E, 0xF8, 0x07, 0xBC, 0x01, 0xEF, 0x00, 0x7B, 0xC0, 0x1F, 0xFF,
-  0xE0, 0x7F, 0xFC, 0x3F, 0xFF, 0x1F, 0xFF, 0xCF, 0x81, 0xF7, 0xC0, 0x7B,
-  0xE0, 0x3D, 0xF0, 0x1E, 0xF8, 0x0F, 0x7C, 0x07, 0xBE, 0x03, 0xDF, 0x01,
-  0xEF, 0x81, 0xE7, 0xC7, 0xF3, 0xFF, 0xE1, 0xFF, 0xF0, 0xFF, 0xFE, 0x7C,
-  0x1F, 0xBE, 0x03, 0xDF, 0x01, 0xFF, 0x80, 0x7F, 0xC0, 0x3F, 0xE0, 0x1F,
-  0xF0, 0x0F, 0xF8, 0x07, 0xFC, 0x03, 0xFE, 0x03, 0xFF, 0x01, 0xEF, 0x83,
-  0xF7, 0xFF, 0xF3, 0xFF, 0xF1, 0xFF, 0xE0, 0x07, 0xF0, 0x1F, 0xFC, 0x3F,
-  0xFE, 0x7F, 0x7E, 0x7C, 0x1F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF0, 0x0F, 0xF0,
-  0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x00, 0xF0, 0x00, 0xF0,
-  0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0, 0x00, 0xF0,
-  0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF8, 0x0F, 0xF8,
-  0x0F, 0x78, 0x1F, 0x7E, 0x3E, 0x3F, 0xFE, 0x1F, 0xFC, 0x0F, 0xF8, 0xFF,
-  0xC0, 0x7F, 0xFC, 0x3F, 0xFF, 0x9F, 0xFF, 0xCF, 0x81, 0xF7, 0xC0, 0x7B,
-  0xE0, 0x3D, 0xF0, 0x1F, 0xF8, 0x0F, 0xFC, 0x07, 0xFE, 0x03, 0xFF, 0x01,
-  0xFF, 0x80, 0xFF, 0xC0, 0x7F, 0xE0, 0x3F, 0xF0, 0x1F, 0xF8, 0x0F, 0xFC,
-  0x07, 0xFE, 0x03, 0xFF, 0x01, 0xFF, 0x80, 0xFF, 0xC0, 0x7F, 0xE0, 0x3F,
-  0xF0, 0x1F, 0xF8, 0x0F, 0xFC, 0x07, 0xBE, 0x03, 0xDF, 0x03, 0xEF, 0x83,
-  0xE7, 0xFF, 0xF3, 0xFF, 0xF1, 0xFF, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00, 0xF8, 0x07, 0xC0, 0x3E,
-  0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xFF, 0x9F, 0xFC, 0xFF, 0xE7, 0xC0,
-  0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00, 0xF8, 0x07,
-  0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00,
-  0xF8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xFF, 0x9F,
-  0xFC, 0xFF, 0xE7, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0,
-  0x1F, 0x00, 0xF8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03,
-  0xE0, 0x1F, 0x00, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x8F, 0xEF, 0xE7,
-  0x81, 0xF7, 0xC0, 0x7B, 0xE0, 0x3D, 0xE0, 0x1F, 0xF0, 0x0F, 0xF8, 0x07,
-  0xFC, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0,
-  0x00, 0xF0, 0x7F, 0xF8, 0x3F, 0xFC, 0x1F, 0xFE, 0x00, 0xFF, 0x00, 0x7F,
-  0x80, 0x3F, 0xC0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xFC, 0x03, 0xFE, 0x03,
-  0xEF, 0x01, 0xF7, 0xE3, 0xF9, 0xFF, 0xDC, 0x7F, 0xCE, 0x1F, 0xC7, 0xF8,
-  0x07, 0xFC, 0x03, 0xFE, 0x01, 0xFF, 0x00, 0xFF, 0x80, 0x7F, 0xC0, 0x3F,
-  0xE0, 0x1F, 0xF0, 0x0F, 0xF8, 0x07, 0xFC, 0x03, 0xFE, 0x01, 0xFF, 0x00,
-  0xFF, 0x80, 0x7F, 0xC0, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
-  0x03, 0xFE, 0x01, 0xFF, 0x00, 0xFF, 0x80, 0x7F, 0xC0, 0x3F, 0xE0, 0x1F,
-  0xF0, 0x0F, 0xF8, 0x07, 0xFC, 0x03, 0xFE, 0x01, 0xFF, 0x00, 0xFF, 0x80,
-  0x7F, 0xC0, 0x3F, 0xE0, 0x1F, 0xF0, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07,
-  0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0,
-  0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
-  0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0xFB, 0xFF, 0xFD, 0xFC, 0xF8,
-  0x00, 0xF8, 0x0F, 0x7C, 0x07, 0xBE, 0x07, 0x9F, 0x03, 0xCF, 0x83, 0xC7,
-  0xC1, 0xE3, 0xE1, 0xF1, 0xF0, 0xF0, 0xF8, 0xF8, 0x7C, 0x78, 0x3E, 0x7C,
-  0x1F, 0x3C, 0x0F, 0xBE, 0x07, 0xDE, 0x03, 0xFF, 0x01, 0xFF, 0xC0, 0xFF,
-  0xE0, 0x7F, 0xF0, 0x3F, 0x7C, 0x1F, 0x9E, 0x0F, 0x8F, 0x87, 0xC3, 0xC3,
-  0xE1, 0xE1, 0xF0, 0x78, 0xF8, 0x3C, 0x7C, 0x1F, 0x3E, 0x07, 0x9F, 0x03,
-  0xCF, 0x80, 0xF7, 0xC0, 0x7B, 0xE0, 0x3F, 0xF0, 0x0F, 0xF8, 0x07, 0xC0,
-  0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00, 0xF8, 0x07,
-  0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00, 0xF8,
-  0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7C, 0x03, 0xE0, 0x1F, 0x00,
-  0xF8, 0x07, 0xC0, 0x3E, 0x01, 0xF0, 0x0F, 0x80, 0x7F, 0xFF, 0xFF, 0xFF,
-  0xFF, 0x78, 0x00, 0xFB, 0xE0, 0x07, 0xDF, 0x00, 0x3E, 0xF8, 0x01, 0xF7,
-  0xC0, 0x0F, 0xBE, 0x00, 0xFD, 0xF8, 0x07, 0xEF, 0xC0, 0x3F, 0x7E, 0x01,
-  0xFB, 0xF0, 0x0D, 0xDD, 0xC0, 0xEE, 0xEE, 0x07, 0x77, 0x70, 0x3B, 0xBB,
-  0x81, 0xDD, 0xCC, 0x1C, 0xEE, 0x70, 0xE7, 0x73, 0x87, 0x3B, 0x9C, 0x39,
-  0xDC, 0x61, 0x8E, 0xE3, 0x9C, 0x77, 0x1C, 0xE3, 0xB8, 0xE7, 0x1D, 0xC7,
-  0x30, 0xEE, 0x1B, 0x87, 0x70, 0xFC, 0x3B, 0x87, 0xE1, 0xFC, 0x3E, 0x0F,
-  0xE0, 0xF0, 0x7F, 0x07, 0x83, 0xF8, 0x3C, 0x1F, 0xC1, 0xE0, 0xFE, 0x06,
-  0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xFC,
-  0x0F, 0xFC, 0x0F, 0xFE, 0x0F, 0xFE, 0x0F, 0xFE, 0x0F, 0xFF, 0x0F, 0xF7,
-  0x0F, 0xF7, 0x8F, 0xF3, 0x8F, 0xF3, 0xCF, 0xF3, 0xCF, 0xF1, 0xCF, 0xF1,
-  0xEF, 0xF0, 0xEF, 0xF0, 0xFF, 0xF0, 0x7F, 0xF0, 0x7F, 0xF0, 0x7F, 0xF0,
-  0x3F, 0xF0, 0x3F, 0xF0, 0x1F, 0xF0, 0x1F, 0xF0, 0x1F, 0xF0, 0x0F, 0xF0,
-  0x0F, 0xF0, 0x07, 0xF0, 0x07, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x8F,
-  0xEF, 0xE7, 0xC0, 0xF7, 0xC0, 0x7F, 0xE0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07,
-  0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF, 0x00, 0x7F, 0x80, 0x3F, 0xC0,
-  0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF,
-  0x00, 0x7F, 0x80, 0x3F, 0xC0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xFC, 0x03,
-  0xFE, 0x03, 0xEF, 0x01, 0xE7, 0xE1, 0xF1, 0xFF, 0xF0, 0x7F, 0xF0, 0x1F,
-  0xF0, 0xFF, 0xE0, 0xFF, 0xF8, 0xFF, 0xFC, 0xF9, 0xFE, 0xF8, 0x1E, 0xF8,
-  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8,
-  0x0F, 0xF8, 0x1F, 0xF8, 0x3E, 0xFF, 0xFE, 0xFF, 0xFC, 0xFF, 0xF0, 0xF8,
-  0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8,
-  0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8,
-  0x00, 0xF8, 0x00, 0xF8, 0x00, 0x07, 0xF0, 0x0F, 0xFE, 0x0F, 0xFF, 0x8F,
-  0xEF, 0xE7, 0xC0, 0xF7, 0xC0, 0x7F, 0xE0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07,
-  0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF, 0x00, 0x7F, 0x80, 0x3F, 0xC0,
-  0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF,
-  0x00, 0x7F, 0x80, 0x3F, 0xC0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xFC, 0x03,
-  0xFE, 0x03, 0xEF, 0x01, 0xE7, 0xE1, 0xF1, 0xFF, 0xF0, 0x7F, 0xF0, 0x1F,
-  0xF0, 0x00, 0x78, 0x00, 0x1E, 0x00, 0x07, 0x80, 0x01, 0xE0, 0x00, 0x60,
-  0x00, 0x10, 0xFF, 0xC0, 0x7F, 0xFC, 0x3F, 0xFF, 0x1F, 0x3F, 0xCF, 0x81,
-  0xE7, 0xC0, 0xFB, 0xE0, 0x3D, 0xF0, 0x1E, 0xF8, 0x0F, 0x7C, 0x07, 0xBE,
-  0x03, 0xDF, 0x03, 0xEF, 0x81, 0xF7, 0xC3, 0xF3, 0xFF, 0xF9, 0xFF, 0xF8,
-  0xFF, 0xF0, 0x7C, 0x7C, 0x3E, 0x1E, 0x1F, 0x0F, 0x0F, 0x87, 0xC7, 0xC1,
-  0xE3, 0xE0, 0xF1, 0xF0, 0x78, 0xF8, 0x3E, 0x7C, 0x0F, 0x3E, 0x07, 0x9F,
-  0x03, 0xCF, 0x80, 0xF7, 0xC0, 0x7B, 0xE0, 0x3D, 0xF0, 0x1F, 0x0F, 0xC0,
-  0x3F, 0xF0, 0x7F, 0xF8, 0xFC, 0xFC, 0xF0, 0x3C, 0xF0, 0x3E, 0xF0, 0x1E,
-  0xF0, 0x1E, 0xF0, 0x1C, 0xF0, 0x00, 0xF8, 0x00, 0xFC, 0x00, 0x7E, 0x00,
-  0x3F, 0x00, 0x1F, 0x80, 0x0F, 0xE0, 0x07, 0xF0, 0x03, 0xF8, 0x01, 0xF8,
-  0x00, 0xFC, 0x00, 0x7E, 0x00, 0x3E, 0x20, 0x1E, 0xF0, 0x1E, 0xF0, 0x1F,
-  0xF0, 0x1F, 0xF0, 0x1E, 0xF8, 0x1E, 0x7C, 0x3E, 0x3F, 0xFC, 0x3F, 0xF8,
-  0x0F, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x78, 0x00,
-  0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x1E, 0x00, 0x3C,
-  0x00, 0x78, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00,
-  0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07,
-  0x80, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x01, 0xE0,
-  0x03, 0xC0, 0xF0, 0x07, 0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF, 0x00,
-  0x7F, 0x80, 0x3F, 0xC0, 0x1F, 0xE0, 0x0F, 0xF0, 0x07, 0xF8, 0x03, 0xFC,
-  0x01, 0xFE, 0x00, 0xFF, 0x00, 0x7F, 0x80, 0x3F, 0xC0, 0x1F, 0xE0, 0x0F,
-  0xF0, 0x07, 0xF8, 0x03, 0xFC, 0x01, 0xFE, 0x00, 0xFF, 0x00, 0x7F, 0x80,
-  0x3F, 0xC0, 0x1F, 0xE0, 0x0F, 0xF8, 0x07, 0xFC, 0x03, 0xDE, 0x03, 0xEF,
-  0x81, 0xE7, 0xE1, 0xF1, 0xFF, 0xF0, 0x7F, 0xF8, 0x1F, 0xF0, 0xF0, 0x03,
-  0xFC, 0x00, 0xFF, 0x80, 0x79, 0xE0, 0x1E, 0x78, 0x07, 0x9E, 0x01, 0xE7,
-  0x80, 0x78, 0xF0, 0x3C, 0x3C, 0x0F, 0x0F, 0x03, 0xC3, 0xC0, 0xF0, 0xF0,
-  0x38, 0x1E, 0x1E, 0x07, 0x87, 0x81, 0xE1, 0xE0, 0x78, 0x78, 0x0F, 0x1C,
-  0x03, 0xCF, 0x00, 0xF3, 0xC0, 0x3C, 0xF0, 0x0F, 0x38, 0x01, 0xFE, 0x00,
-  0x7F, 0x80, 0x1F, 0xE0, 0x07, 0xF8, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0xF8, 0x00, 0x1E, 0x00, 0x07, 0x80, 0xF0, 0x0E,
-  0x03, 0xDC, 0x03, 0x80, 0xF7, 0x01, 0xE0, 0x3D, 0xE0, 0x78, 0x0F, 0x78,
-  0x1F, 0x03, 0x9E, 0x07, 0xC0, 0xE7, 0x81, 0xF0, 0x38, 0xE0, 0xFC, 0x1E,
-  0x38, 0x3F, 0x07, 0x8E, 0x0E, 0xE1, 0xE3, 0xC3, 0xB8, 0x78, 0xF0, 0xEE,
-  0x1C, 0x3C, 0x7B, 0x87, 0x07, 0x1C, 0xE1, 0xC1, 0xC7, 0x1C, 0xF0, 0x71,
-  0xC7, 0x3C, 0x1E, 0x71, 0xCF, 0x07, 0x9C, 0x73, 0x81, 0xEF, 0x1C, 0xE0,
-  0x3B, 0x87, 0xB8, 0x0E, 0xE0, 0xEE, 0x03, 0xB8, 0x3F, 0x80, 0xEE, 0x0F,
-  0xE0, 0x3F, 0x83, 0xF0, 0x0F, 0xC0, 0xFC, 0x01, 0xF0, 0x1F, 0x00, 0x7C,
-  0x07, 0xC0, 0x1F, 0x01, 0xF0, 0x07, 0xC0, 0x7C, 0x01, 0xE0, 0x1E, 0x00,
-  0x78, 0x03, 0x80, 0x1E, 0x00, 0xE0, 0xF0, 0x07, 0xF8, 0x07, 0xDE, 0x03,
-  0xCF, 0x01, 0xE7, 0xC1, 0xE1, 0xE0, 0xF0, 0xF0, 0xF0, 0x3C, 0x78, 0x1E,
-  0x3C, 0x07, 0xBC, 0x03, 0xDE, 0x01, 0xFE, 0x00, 0x7F, 0x00, 0x3F, 0x00,
-  0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x03, 0xF0, 0x01, 0xFC, 0x01, 0xFE,
-  0x00, 0xFF, 0x00, 0x7B, 0xC0, 0x79, 0xE0, 0x3C, 0x78, 0x3C, 0x3C, 0x1E,
-  0x1F, 0x0F, 0x07, 0x8F, 0x03, 0xC7, 0x80, 0xF7, 0xC0, 0x7B, 0xC0, 0x1F,
-  0xE0, 0x0F, 0xF8, 0x03, 0xDE, 0x00, 0xF7, 0x80, 0x3C, 0xF0, 0x1E, 0x3C,
-  0x07, 0x8F, 0x01, 0xE1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x03, 0xC7,
-  0x80, 0xF1, 0xE0, 0x3C, 0x78, 0x07, 0x3C, 0x01, 0xEF, 0x00, 0x7B, 0xC0,
-  0x0F, 0xE0, 0x03, 0xF8, 0x00, 0xFE, 0x00, 0x1F, 0x00, 0x07, 0xC0, 0x01,
-  0xF0, 0x00, 0x7C, 0x00, 0x1F, 0x00, 0x07, 0xC0, 0x01, 0xF0, 0x00, 0x7C,
-  0x00, 0x1F, 0x00, 0x07, 0xC0, 0x01, 0xF0, 0x00, 0x7C, 0x00, 0x1F, 0x00,
-  0x07, 0xC0, 0x7F, 0xFE, 0xFF, 0xFD, 0xFF, 0xF0, 0x01, 0xE0, 0x07, 0xC0,
-  0x0F, 0x00, 0x1E, 0x00, 0x7C, 0x00, 0xF0, 0x01, 0xE0, 0x07, 0x80, 0x0F,
-  0x00, 0x3E, 0x00, 0x78, 0x00, 0xF0, 0x03, 0xE0, 0x07, 0x80, 0x0F, 0x00,
-  0x3E, 0x00, 0x78, 0x00, 0xF0, 0x03, 0xC0, 0x07, 0x80, 0x1F, 0x00, 0x3C,
-  0x00, 0x78, 0x01, 0xF0, 0x03, 0xC0, 0x07, 0x80, 0x1F, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8,
-  0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F,
-  0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3,
-  0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xFF, 0xFE, 0xF0, 0x0F,
-  0x00, 0x70, 0x07, 0x80, 0x78, 0x03, 0x80, 0x38, 0x03, 0xC0, 0x3C, 0x01,
-  0xC0, 0x1C, 0x01, 0xE0, 0x1E, 0x00, 0xE0, 0x0F, 0x00, 0xF0, 0x0F, 0x00,
-  0x70, 0x07, 0x80, 0x78, 0x03, 0x80, 0x38, 0x03, 0xC0, 0x3C, 0x01, 0xC0,
-  0x1E, 0x01, 0xE0, 0x1E, 0x00, 0xE0, 0x0F, 0x00, 0xF0, 0x07, 0xFF, 0xFF,
-  0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0,
-  0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E,
-  0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87,
-  0xC3, 0xE1, 0xF0, 0xFF, 0xFF, 0xFE, 0x07, 0xC0, 0x0F, 0x80, 0x1F, 0x80,
-  0x7F, 0x00, 0xEF, 0x03, 0xDE, 0x07, 0x9C, 0x0E, 0x3C, 0x3C, 0x78, 0x78,
-  0x79, 0xE0, 0xF3, 0xC0, 0xEF, 0x01, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
-  0xF0, 0xF1, 0xE1, 0xC1, 0xC3, 0x83, 0x06, 0x0F, 0x81, 0xFF, 0x1F, 0xFD,
-  0xF3, 0xEF, 0x0F, 0x78, 0x7F, 0xC1, 0xE2, 0x0F, 0x00, 0x78, 0x0F, 0xC1,
-  0xFE, 0x3E, 0xF3, 0xE7, 0xBC, 0x3F, 0xE1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83,
-  0xFC, 0x3F, 0xF3, 0xFF, 0xF7, 0xBF, 0xBC, 0xF9, 0xE0, 0xF0, 0x03, 0xC0,
-  0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0,
-  0x03, 0xCF, 0x8F, 0x7F, 0x3F, 0xFE, 0xFC, 0xFB, 0xC1, 0xEF, 0x07, 0xFC,
-  0x0F, 0xF0, 0x3F, 0xC0, 0xFF, 0x03, 0xFC, 0x0F, 0xF0, 0x3F, 0xC0, 0xFF,
-  0x03, 0xFC, 0x0F, 0xF0, 0x3F, 0xC0, 0xFF, 0x07, 0xFC, 0x1E, 0xF8, 0x7B,
-  0xFF, 0xEF, 0x7F, 0x3C, 0xF8, 0x1F, 0x81, 0xFF, 0x1F, 0xFD, 0xF1, 0xEF,
-  0x0F, 0x78, 0x3B, 0xC1, 0xDE, 0x0F, 0xF0, 0x7F, 0x80, 0x3C, 0x01, 0xE0,
-  0x0F, 0x00, 0x78, 0x03, 0xC1, 0xFE, 0x0F, 0xF0, 0x77, 0x83, 0xBC, 0x3D,
-  0xF1, 0xE7, 0xFF, 0x3F, 0xF0, 0xFF, 0x00, 0x00, 0x78, 0x03, 0xC0, 0x1E,
-  0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0xF3, 0xCF,
-  0xFE, 0xFF, 0xFF, 0xDF, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83,
-  0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F,
-  0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x8F, 0xBF, 0xFD, 0xFF, 0xE7, 0xEF, 0x1F,
-  0x81, 0xFF, 0x1F, 0xFD, 0xF1, 0xEF, 0x0F, 0x78, 0x3F, 0xC1, 0xFE, 0x0F,
-  0xF0, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x78, 0x03, 0xC0, 0x1E,
-  0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x3F, 0xF1, 0xE7, 0xFF, 0x3F, 0xF0, 0x7F,
-  0x00, 0x01, 0x83, 0xF1, 0xFC, 0x7F, 0x1E, 0x0F, 0x83, 0xE0, 0xF8, 0xFF,
-  0xFF, 0xFF, 0xFC, 0xF8, 0x3E, 0x0F, 0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x83,
-  0xE0, 0xF8, 0x3E, 0x0F, 0x83, 0xE0, 0xF8, 0x3E, 0x0F, 0x83, 0xE0, 0xF8,
-  0x3E, 0x0F, 0x83, 0xE0, 0x07, 0xC3, 0x0F, 0xF3, 0x8F, 0xFF, 0xEF, 0x0F,
-  0x87, 0x87, 0x83, 0xC1, 0xC1, 0xC0, 0xE0, 0xE0, 0x70, 0x70, 0x38, 0x38,
-  0x1C, 0x1E, 0x0E, 0x0F, 0x0F, 0x07, 0x87, 0x81, 0xFF, 0x80, 0x7F, 0x80,
-  0x3F, 0x80, 0x38, 0x00, 0x38, 0x00, 0x1F, 0x00, 0x0F, 0xFE, 0x07, 0xFF,
-  0xC0, 0xFF, 0xE1, 0xC0, 0xF9, 0xE0, 0x3C, 0xE0, 0x0E, 0x78, 0x0F, 0x3E,
-  0x0F, 0x9F, 0xFF, 0x87, 0xFF, 0x80, 0xFF, 0x00, 0xF0, 0x07, 0x80, 0x3C,
-  0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x87,
-  0xBC, 0xFF, 0xEF, 0xFF, 0xEF, 0xFC, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F,
-  0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0,
-  0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F,
-  0xFF, 0xFF, 0xF0, 0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x0F, 0x0F, 0x0F, 0x0F, 0x00,
-  0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
-  0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
-  0x0F, 0x0F, 0x1F, 0xBF, 0xFE, 0xFC, 0x70, 0xF0, 0x01, 0xE0, 0x03, 0xC0,
-  0x07, 0x80, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x01,
-  0xE0, 0x7F, 0xC0, 0xF7, 0x83, 0xEF, 0x07, 0x9E, 0x1E, 0x3C, 0x7C, 0x78,
-  0xF0, 0xF3, 0xE1, 0xEF, 0x83, 0xDF, 0x07, 0xFE, 0x0F, 0xFC, 0x1F, 0xBC,
-  0x3E, 0x78, 0x78, 0xF8, 0xF0, 0xF1, 0xE1, 0xE3, 0xC1, 0xE7, 0x83, 0xCF,
-  0x07, 0x9E, 0x07, 0xBC, 0x0F, 0x78, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xF1, 0xE0, 0xF9, 0xEF, 0xE7, 0xFB, 0xFF, 0xFF, 0xF7,
-  0xC3, 0xF1, 0xEF, 0x07, 0x81, 0xFE, 0x0F, 0x03, 0xFC, 0x1E, 0x07, 0xF8,
-  0x3C, 0x0F, 0xF0, 0x78, 0x1F, 0xE0, 0xF0, 0x3F, 0xC1, 0xE0, 0x7F, 0x83,
-  0xC0, 0xFF, 0x07, 0x81, 0xFE, 0x0F, 0x03, 0xFC, 0x1E, 0x07, 0xF8, 0x3C,
-  0x0F, 0xF0, 0x78, 0x1F, 0xE0, 0xF0, 0x3F, 0xC1, 0xE0, 0x7F, 0x83, 0xC0,
-  0xFF, 0x07, 0x81, 0xFE, 0x0F, 0x03, 0xFC, 0x1E, 0x07, 0x80, 0xF1, 0xF7,
-  0x9F, 0xFF, 0xFF, 0xFD, 0xFF, 0x87, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0,
-  0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F,
-  0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xE0,
-  0x1F, 0x81, 0xFF, 0x1F, 0xFD, 0xF1, 0xEF, 0x0F, 0x78, 0x3F, 0xC1, 0xFE,
-  0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1,
-  0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x3F, 0xF1, 0xE7, 0xFF, 0x3F, 0xF0,
-  0x7F, 0x00, 0xF1, 0xE3, 0xDF, 0xCF, 0xFF, 0xBF, 0x3E, 0xF0, 0x7B, 0xC1,
-  0xFF, 0x07, 0xFC, 0x0F, 0xF0, 0x3F, 0xC0, 0xFF, 0x03, 0xFC, 0x0F, 0xF0,
-  0x3F, 0xC0, 0xFF, 0x03, 0xFC, 0x0F, 0xF0, 0x7F, 0xC1, 0xFF, 0x07, 0xBE,
-  0x1E, 0xFF, 0xFB, 0xFF, 0xCF, 0x3E, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x0F,
-  0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x00, 0x1E, 0x79, 0xFF, 0xDF, 0xFE,
-  0xFB, 0xFF, 0x87, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC,
-  0x1F, 0xE0, 0xFF, 0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83,
-  0xFC, 0x1F, 0xF1, 0xF7, 0xFF, 0xBF, 0xFC, 0xFD, 0xE0, 0x0F, 0x00, 0x78,
-  0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0xF0, 0xFC, 0xFF, 0x7F,
-  0xFF, 0xFE, 0x7E, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0,
-  0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F,
-  0x00, 0x0F, 0x81, 0xFE, 0x1F, 0xF8, 0xF1, 0xE7, 0x07, 0x38, 0x39, 0xC1,
-  0x8F, 0x00, 0x7C, 0x01, 0xF0, 0x07, 0xC0, 0x1F, 0x80, 0x7E, 0x01, 0xF0,
-  0x07, 0xC0, 0x1E, 0x30, 0x7F, 0x83, 0xFC, 0x1E, 0xF1, 0xE7, 0xFF, 0x1F,
-  0xF0, 0x7F, 0x00, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x0F, 0xFF,
-  0xFF, 0xFF, 0xCF, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C,
-  0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x81,
-  0xFC, 0x7F, 0x0F, 0xC0, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF, 0x07,
-  0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xE0, 0xFF,
-  0x07, 0xF8, 0x3F, 0xC1, 0xFE, 0x0F, 0xF0, 0x7F, 0x83, 0xFC, 0x1F, 0xF1,
-  0xFF, 0xFF, 0xFF, 0xBD, 0xF9, 0xE0, 0xF0, 0x7F, 0xC1, 0xEF, 0x07, 0xBC,
-  0x1E, 0xF0, 0x79, 0xE1, 0xE7, 0x8F, 0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC3,
-  0x8F, 0x0F, 0x38, 0x3C, 0xE0, 0xF7, 0x83, 0xDE, 0x07, 0x78, 0x1D, 0xC0,
-  0x77, 0x01, 0xFC, 0x07, 0xF0, 0x0F, 0xC0, 0x3E, 0x00, 0xF8, 0x00, 0xF0,
-  0x70, 0x7F, 0x83, 0x83, 0xFC, 0x3E, 0x1E, 0xE1, 0xF0, 0xE7, 0x0F, 0x87,
-  0x38, 0x7C, 0x39, 0xC3, 0xE1, 0xCF, 0x1B, 0x1E, 0x79, 0xDC, 0xF1, 0xCE,
-  0xE7, 0x0E, 0x77, 0x38, 0x73, 0xB9, 0xC3, 0x9C, 0xCE, 0x1C, 0xC7, 0x70,
-  0xFE, 0x3F, 0x83, 0xF1, 0xF8, 0x1F, 0x8F, 0xC0, 0xFC, 0x3E, 0x07, 0xC1,
-  0xF0, 0x3E, 0x0F, 0x81, 0xF0, 0x7C, 0x0F, 0x83, 0xC0, 0x3C, 0x0E, 0x00,
-  0xF8, 0x1E, 0xF0, 0x79, 0xE0, 0xF1, 0xE3, 0xC3, 0xC7, 0x83, 0xCE, 0x07,
-  0xBC, 0x07, 0xF8, 0x0F, 0xE0, 0x0F, 0xC0, 0x1F, 0x00, 0x3E, 0x00, 0x7C,
-  0x01, 0xFC, 0x03, 0xF8, 0x07, 0xF0, 0x1E, 0xF0, 0x3D, 0xE0, 0xF1, 0xE1,
-  0xE3, 0xC7, 0x83, 0xCF, 0x07, 0xBE, 0x07, 0x80, 0xF8, 0x1E, 0xF0, 0x7D,
-  0xE0, 0xF3, 0xC1, 0xE7, 0x83, 0xC7, 0x87, 0x8F, 0x0F, 0x1E, 0x3C, 0x3C,
-  0x78, 0x38, 0xF0, 0x79, 0xE0, 0xF3, 0x81, 0xE7, 0x01, 0xDE, 0x03, 0xBC,
-  0x07, 0x78, 0x0F, 0xE0, 0x0F, 0xC0, 0x1F, 0x80, 0x3F, 0x00, 0x7C, 0x00,
-  0xF8, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0x80, 0x7F, 0x00, 0xFE, 0x01, 0xF0,
-  0x03, 0x00, 0x00, 0x7F, 0xF7, 0xFF, 0x7F, 0xF7, 0xFE, 0x01, 0xE0, 0x3E,
-  0x03, 0xC0, 0x3C, 0x07, 0x80, 0x78, 0x0F, 0x80, 0xF0, 0x1F, 0x01, 0xE0,
-  0x1E, 0x03, 0xC0, 0x3C, 0x07, 0xC0, 0x78, 0x07, 0x80, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xF0, 0x0F, 0x8F, 0xCF, 0xE7, 0xC3, 0xC1, 0xE0, 0xF0, 0x78, 0x3C,
-  0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x3E, 0x3E, 0x1E,
-  0x0F, 0x83, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0,
-  0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xF9, 0xFC, 0x7E, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x7E, 0x3F, 0x07, 0xC3, 0xE1, 0xF0,
-  0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x1E,
-  0x0F, 0x07, 0xE1, 0xF0, 0xF8, 0xF8, 0x78, 0x7C, 0x3E, 0x1F, 0x0F, 0x87,
-  0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3E, 0x1F, 0x0F, 0x87, 0xCF, 0xC7, 0xE3,
-  0xE0, 0x0C, 0x00, 0x7E, 0x09, 0xFF, 0xFF, 0xFF, 0xE6, 0x1F, 0x80, 0x0E,
-  0x00 };
-
-const GFXglyph Oswald_Regular20pt7bGlyphs[] PROGMEM = {
-  {     0,   1,   1,   9,    0,    0 },   // 0x20 ' '
-  {     1,   4,  32,   8,    2,  -31 },   // 0x21 '!'
-  {    17,   9,  10,  10,    1,  -31 },   // 0x22 '"'
-  {    29,  17,  32,  19,    1,  -31 },   // 0x23 '#'
-  {    97,  16,  38,  19,    2,  -34 },   // 0x24 '$'
-  {   173,  32,  32,  35,    1,  -31 },   // 0x25 '%'
-  {   301,  20,  32,  24,    2,  -31 },   // 0x26 '&'
-  {   381,   4,  10,   5,    1,  -31 },   // 0x27 '''
-  {   386,   8,  40,  12,    3,  -31 },   // 0x28 '('
-  {   426,   8,  40,  10,    1,  -31 },   // 0x29 ')'
-  {   466,  13,  14,  16,    2,  -31 },   // 0x2A '*'
-  {   489,  14,  16,  16,    1,  -23 },   // 0x2B '+'
-  {   517,   4,  10,   7,    2,   -4 },   // 0x2C ','
-  {   522,   9,   3,  13,    2,  -12 },   // 0x2D '-'
-  {   526,   4,   5,   7,    2,   -4 },   // 0x2E '.'
-  {   529,  12,  32,  14,    1,  -31 },   // 0x2F '/'
-  {   577,  16,  32,  20,    2,  -31 },   // 0x30 '0'
-  {   641,  10,  32,  16,    1,  -31 },   // 0x31 '1'
-  {   681,  15,  32,  19,    2,  -31 },   // 0x32 '2'
-  {   741,  15,  32,  19,    2,  -31 },   // 0x33 '3'
-  {   801,  16,  32,  19,    2,  -31 },   // 0x34 '4'
-  {   865,  15,  32,  19,    2,  -31 },   // 0x35 '5'
-  {   925,  16,  32,  20,    2,  -31 },   // 0x36 '6'
-  {   989,  13,  32,  15,    1,  -31 },   // 0x37 '7'
-  {  1041,  16,  32,  20,    2,  -31 },   // 0x38 '8'
-  {  1105,  15,  32,  20,    2,  -31 },   // 0x39 '9'
-  {  1165,   5,  17,   8,    2,  -20 },   // 0x3A ':'
-  {  1176,   5,  24,   8,    2,  -21 },   // 0x3B ';'
-  {  1191,  11,  21,  15,    1,  -21 },   // 0x3C '<'
-  {  1220,  12,  10,  16,    2,  -20 },   // 0x3D '='
-  {  1235,  12,  21,  15,    2,  -21 },   // 0x3E '>'
-  {  1267,  15,  32,  19,    2,  -31 },   // 0x3F '?'
-  {  1327,  32,  37,  35,    2,  -31 },   // 0x40 '@'
-  {  1475,  18,  32,  19,    1,  -31 },   // 0x41 'A'
-  {  1547,  17,  32,  21,    2,  -31 },   // 0x42 'B'
-  {  1615,  16,  32,  20,    2,  -31 },   // 0x43 'C'
-  {  1679,  17,  32,  21,    2,  -31 },   // 0x44 'D'
-  {  1747,  13,  32,  16,    2,  -31 },   // 0x45 'E'
-  {  1799,  13,  32,  15,    2,  -31 },   // 0x46 'F'
-  {  1851,  17,  32,  21,    2,  -31 },   // 0x47 'G'
-  {  1919,  17,  32,  22,    2,  -31 },   // 0x48 'H'
-  {  1987,   4,  32,  10,    3,  -31 },   // 0x49 'I'
-  {  2003,   9,  33,  12,    0,  -31 },   // 0x4A 'J'
-  {  2041,  17,  32,  19,    2,  -31 },   // 0x4B 'K'
-  {  2109,  13,  32,  16,    2,  -31 },   // 0x4C 'L'
-  {  2161,  21,  32,  26,    2,  -31 },   // 0x4D 'M'
-  {  2245,  16,  32,  21,    2,  -31 },   // 0x4E 'N'
-  {  2309,  17,  32,  21,    2,  -31 },   // 0x4F 'O'
-  {  2377,  16,  32,  19,    2,  -31 },   // 0x50 'P'
-  {  2441,  17,  38,  21,    2,  -31 },   // 0x51 'Q'
-  {  2522,  17,  32,  20,    2,  -31 },   // 0x52 'R'
-  {  2590,  16,  32,  19,    2,  -31 },   // 0x53 'S'
-  {  2654,  15,  32,  16,    1,  -31 },   // 0x54 'T'
-  {  2714,  17,  32,  21,    2,  -31 },   // 0x55 'U'
-  {  2782,  18,  32,  20,    1,  -31 },   // 0x56 'V'
-  {  2854,  26,  32,  29,    1,  -31 },   // 0x57 'W'
-  {  2958,  17,  32,  19,    1,  -31 },   // 0x58 'X'
-  {  3026,  18,  32,  19,    0,  -31 },   // 0x59 'Y'
-  {  3098,  15,  32,  16,    1,  -31 },   // 0x5A 'Z'
-  {  3158,   9,  39,  13,    2,  -31 },   // 0x5B '['
-  {  3202,  12,  32,  14,    1,  -31 },   // 0x5C '\'
-  {  3250,   9,  39,  12,    1,  -31 },   // 0x5D ']'
-  {  3294,  15,  13,  17,    1,  -31 },   // 0x5E '^'
-  {  3319,  13,   3,  13,    0,    3 },   // 0x5F '_'
-  {  3324,   7,   8,  11,    2,  -31 },   // 0x60 '`'
-  {  3331,  13,  23,  17,    2,  -22 },   // 0x61 'a'
-  {  3369,  14,  32,  18,    2,  -31 },   // 0x62 'b'
-  {  3425,  13,  23,  16,    2,  -22 },   // 0x63 'c'
-  {  3463,  13,  32,  17,    2,  -31 },   // 0x64 'd'
-  {  3515,  13,  23,  16,    2,  -22 },   // 0x65 'e'
-  {  3553,  10,  31,  11,    1,  -30 },   // 0x66 'f'
-  {  3592,  17,  30,  17,    1,  -22 },   // 0x67 'g'
-  {  3656,  13,  32,  17,    2,  -31 },   // 0x68 'h'
-  {  3708,   5,  30,   9,    2,  -29 },   // 0x69 'i'
-  {  3727,   8,  36,   9,   -1,  -29 },   // 0x6A 'j'
-  {  3763,  15,  32,  17,    2,  -31 },   // 0x6B 'k'
-  {  3823,   5,  32,   9,    2,  -31 },   // 0x6C 'l'
-  {  3843,  23,  23,  27,    2,  -22 },   // 0x6D 'm'
-  {  3910,  13,  23,  17,    2,  -22 },   // 0x6E 'n'
-  {  3948,  13,  23,  17,    2,  -22 },   // 0x6F 'o'
-  {  3986,  14,  30,  17,    2,  -22 },   // 0x70 'p'
-  {  4039,  13,  30,  17,    2,  -22 },   // 0x71 'q'
-  {  4088,  10,  23,  13,    2,  -22 },   // 0x72 'r'
-  {  4117,  13,  23,  15,    1,  -22 },   // 0x73 's'
-  {  4155,  10,  29,  12,    1,  -28 },   // 0x74 't'
-  {  4192,  13,  23,  17,    2,  -22 },   // 0x75 'u'
-  {  4230,  14,  23,  15,    1,  -22 },   // 0x76 'v'
-  {  4271,  21,  23,  23,    1,  -22 },   // 0x77 'w'
-  {  4332,  15,  23,  15,    0,  -22 },   // 0x78 'x'
-  {  4376,  15,  29,  15,    0,  -22 },   // 0x79 'y'
-  {  4431,  12,  23,  14,    1,  -22 },   // 0x7A 'z'
-  {  4466,   9,  39,  12,    2,  -31 },   // 0x7B '{'
-  {  4510,   4,  38,   9,    3,  -31 },   // 0x7C '|'
-  {  4529,   9,  39,  13,    2,  -31 },   // 0x7D '}'
-  {  4573,  15,   6,  18,    1,  -19 } }; // 0x7E '~'
-
-const GFXfont Oswald_Regular20pt7b PROGMEM = {
-  (uint8_t  *)Oswald_Regular20pt7bBitmaps,
-  (GFXglyph *)Oswald_Regular20pt7bGlyphs,
-  0x20, 0x7E, 58 };
-
-// Approx. 5257 bytes

src/fonts/oswald-30.h

@@ -1,959 +0,0 @@
-const uint8_t Oswald_Regular30pt7bBitmaps[] PROGMEM = {
-  0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xDF, 0x7D, 0xF7,
-  0xDE, 0x79, 0xE7, 0x9E, 0x79, 0xE7, 0x9E, 0x79, 0xE7, 0x9E, 0x79, 0xE3,
-  0x8E, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFC, 0xFF, 0xF3, 0xFF, 0xCF, 0xFE, 0x3F, 0xF8, 0xFB, 0xE3, 0xEF,
-  0x8F, 0xBE, 0x3E, 0xF8, 0xFB, 0xC3, 0xEF, 0x0F, 0x3C, 0x3C, 0xF0, 0xF3,
-  0xC3, 0xCF, 0x0F, 0x00, 0x01, 0xF8, 0x3F, 0x80, 0xFC, 0x1F, 0x80, 0xFE,
-  0x0F, 0xC0, 0x7F, 0x07, 0xE0, 0x3F, 0x83, 0xF0, 0x1F, 0x81, 0xF8, 0x0F,
-  0xC1, 0xFC, 0x07, 0xE0, 0xFE, 0x03, 0xF0, 0x7E, 0x03, 0xF8, 0x3F, 0x01,
-  0xFC, 0x1F, 0x80, 0xFC, 0x0F, 0xC0, 0x7E, 0x07, 0xE0, 0x3F, 0x07, 0xF0,
-  0x1F, 0x83, 0xF8, 0x0F, 0xC1, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x7E, 0x0F,
-  0xE0, 0x3F, 0x07, 0xE0, 0x3F, 0x83, 0xF0, 0x1F, 0xC1, 0xF8, 0x0F, 0xC0,
-  0xFC, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x7F, 0x07, 0xE0, 0x3F, 0x03, 0xF0, 0x1F,
-  0x81, 0xF8, 0x0F, 0xC1, 0xFC, 0x07, 0xE0, 0xFE, 0x03, 0xF0, 0x7E, 0x03,
-  0xF8, 0x3F, 0x01, 0xFC, 0x1F, 0x80, 0xFC, 0x0F, 0xC0, 0x7E, 0x07, 0xE0,
-  0x3F, 0x07, 0xF0, 0x1F, 0x83, 0xF8, 0x0F, 0xC1, 0xF8, 0x0F, 0xE0, 0xFC,
-  0x07, 0xF0, 0x7E, 0x03, 0xF8, 0x3F, 0x01, 0xF8, 0x3F, 0x80, 0x00, 0x18,
-  0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0xFF,
-  0x00, 0x07, 0xFF, 0xC0, 0x0F, 0xFF, 0xF0, 0x1F, 0xFF, 0xF8, 0x3F, 0xFF,
-  0xF8, 0x3F, 0xC3, 0xFC, 0x7F, 0x00, 0xFC, 0x7E, 0x00, 0xFE, 0x7E, 0x00,
-  0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x3E, 0xFE, 0x00,
-  0x3F, 0x7E, 0x00, 0x20, 0x7E, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x80,
-  0x00, 0x3F, 0xC0, 0x00, 0x3F, 0xE0, 0x00, 0x1F, 0xF8, 0x00, 0x0F, 0xFC,
-  0x00, 0x07, 0xFE, 0x00, 0x03, 0xFF, 0x00, 0x01, 0xFF, 0x80, 0x00, 0xFF,
-  0xC0, 0x00, 0x3F, 0xE0, 0x00, 0x1F, 0xF0, 0x00, 0x0F, 0xF8, 0x00, 0x07,
-  0xFC, 0x00, 0x03, 0xFC, 0x00, 0x01, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00,
-  0x7F, 0x04, 0x00, 0x7F, 0x7C, 0x00, 0x3F, 0xFC, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7F, 0x00,
-  0x3F, 0x3F, 0x80, 0x7F, 0x3F, 0xC0, 0xFE, 0x1F, 0xFF, 0xFE, 0x1F, 0xFF,
-  0xFC, 0x0F, 0xFF, 0xF8, 0x03, 0xFF, 0xF0, 0x01, 0xFF, 0xC0, 0x00, 0x06,
-  0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06,
-  0x00, 0x03, 0xF8, 0x00, 0x0F, 0x80, 0x00, 0x0F, 0xFE, 0x00, 0x0F, 0x80,
-  0x00, 0x1F, 0xFF, 0x00, 0x1F, 0x80, 0x00, 0x3F, 0xFF, 0x80, 0x1F, 0x80,
-  0x00, 0x7F, 0xFF, 0x80, 0x1F, 0x00, 0x00, 0x7E, 0x0F, 0xC0, 0x1F, 0x00,
-  0x00, 0x7C, 0x0F, 0xC0, 0x3F, 0x00, 0x00, 0xFC, 0x07, 0xC0, 0x3F, 0x00,
-  0x00, 0xFC, 0x07, 0xC0, 0x3E, 0x00, 0x00, 0xFC, 0x07, 0xE0, 0x3E, 0x00,
-  0x00, 0xFC, 0x07, 0xE0, 0x7E, 0x00, 0x00, 0xFC, 0x07, 0xE0, 0x7C, 0x00,
-  0x00, 0xFC, 0x07, 0xE0, 0x7C, 0x00, 0x00, 0xFC, 0x07, 0xE0, 0xFC, 0x00,
-  0x00, 0xFC, 0x07, 0xE0, 0xFC, 0x00, 0x00, 0xFC, 0x07, 0xE0, 0xF8, 0x00,
-  0x00, 0xFC, 0x07, 0xC0, 0xF8, 0x00, 0x00, 0xFC, 0x07, 0xC1, 0xF8, 0x00,
-  0x00, 0xFC, 0x0F, 0xC1, 0xF8, 0x00, 0x00, 0x7E, 0x0F, 0xC1, 0xF0, 0x00,
-  0x00, 0x7F, 0x1F, 0xC1, 0xF0, 0x00, 0x00, 0x3F, 0xFF, 0x83, 0xF0, 0x00,
-  0x00, 0x3F, 0xFF, 0x83, 0xE0, 0x00, 0x00, 0x1F, 0xFF, 0x03, 0xE0, 0x3F,
-  0xF0, 0x0F, 0xFC, 0x07, 0xE0, 0x7F, 0xF8, 0x01, 0xE0, 0x07, 0xE0, 0xFF,
-  0xFC, 0x00, 0x00, 0x07, 0xC1, 0xFF, 0xFE, 0x00, 0x00, 0x07, 0xC1, 0xFF,
-  0xFE, 0x00, 0x00, 0x0F, 0xC3, 0xF0, 0x3F, 0x00, 0x00, 0x0F, 0xC3, 0xF0,
-  0x3F, 0x00, 0x00, 0x0F, 0x83, 0xF0, 0x3F, 0x00, 0x00, 0x0F, 0x83, 0xF0,
-  0x3F, 0x00, 0x00, 0x1F, 0x83, 0xF0, 0x1F, 0x00, 0x00, 0x1F, 0x03, 0xF0,
-  0x1F, 0x00, 0x00, 0x1F, 0x03, 0xF0, 0x1F, 0x00, 0x00, 0x3F, 0x03, 0xF0,
-  0x1F, 0x00, 0x00, 0x3F, 0x03, 0xF0, 0x1F, 0x00, 0x00, 0x3E, 0x03, 0xF0,
-  0x1F, 0x00, 0x00, 0x3E, 0x03, 0xF0, 0x3F, 0x00, 0x00, 0x7E, 0x03, 0xF0,
-  0x3F, 0x00, 0x00, 0x7E, 0x03, 0xF0, 0x3F, 0x00, 0x00, 0x7C, 0x03, 0xF0,
-  0x3F, 0x00, 0x00, 0xFC, 0x01, 0xF8, 0x7F, 0x00, 0x00, 0xFC, 0x01, 0xFF,
-  0xFE, 0x00, 0x00, 0xF8, 0x01, 0xFF, 0xFE, 0x00, 0x00, 0xF8, 0x00, 0xFF,
-  0xFC, 0x00, 0x01, 0xF8, 0x00, 0x7F, 0xF8, 0x00, 0x01, 0xF8, 0x00, 0x1F,
-  0xE0, 0x00, 0x7F, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x01, 0xFF, 0xFC, 0x00,
-  0x1F, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0x80, 0x0F, 0xF1, 0xFE, 0x00, 0x7F,
-  0x07, 0xF0, 0x07, 0xF0, 0x1F, 0x80, 0x3F, 0x80, 0xFC, 0x01, 0xFC, 0x07,
-  0xE0, 0x0F, 0xC0, 0x3F, 0x00, 0x7E, 0x01, 0xF8, 0x03, 0xF8, 0x0F, 0xC0,
-  0x1F, 0xC0, 0xFE, 0x00, 0x7E, 0x07, 0xE0, 0x03, 0xF0, 0x3F, 0x00, 0x1F,
-  0xC3, 0xF0, 0x00, 0x7E, 0x1F, 0x00, 0x03, 0xF1, 0xF8, 0x00, 0x0F, 0xDF,
-  0x80, 0x00, 0x7E, 0xF8, 0x00, 0x01, 0xFF, 0x80, 0x00, 0x07, 0xF8, 0x00,
-  0x00, 0x3F, 0x80, 0x00, 0x01, 0xFC, 0x00, 0x00, 0x1F, 0xE0, 0x00, 0x01,
-  0xFF, 0x80, 0x7E, 0x1F, 0xFC, 0x03, 0xF1, 0xFF, 0xF0, 0x1F, 0x8F, 0xDF,
-  0xC0, 0xFC, 0xFE, 0x7E, 0x0F, 0xE7, 0xE1, 0xF8, 0x7E, 0x7F, 0x0F, 0xE3,
-  0xF3, 0xF0, 0x3F, 0x1F, 0x9F, 0x80, 0xFD, 0xF8, 0xFC, 0x07, 0xFF, 0xCF,
-  0xE0, 0x1F, 0xFC, 0x7F, 0x00, 0x7F, 0xE3, 0xF8, 0x03, 0xFE, 0x1F, 0xC0,
-  0x0F, 0xF0, 0x7E, 0x00, 0xFF, 0xC3, 0xF0, 0x0F, 0xFF, 0x1F, 0xC0, 0xFF,
-  0xFE, 0x7F, 0xFF, 0xFF, 0xF3, 0xFF, 0xFF, 0x3F, 0x8F, 0xFF, 0xF0, 0xFC,
-  0x3F, 0xFF, 0x03, 0xE0, 0x7F, 0xE0, 0x0F, 0x00, 0x60, 0x00, 0x00, 0xFF,
-  0xFF, 0xFE, 0xFB, 0xEF, 0xBE, 0xFB, 0xCF, 0x3C, 0xF3, 0xCF, 0x00, 0x00,
-  0x70, 0x1F, 0x07, 0xF0, 0xFF, 0x0F, 0xE1, 0xF8, 0x1F, 0x83, 0xF0, 0x3F,
-  0x03, 0xF0, 0x3E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x7E,
-  0x07, 0xE0, 0x7C, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC,
-  0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC,
-  0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC,
-  0x07, 0xC0, 0x7E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x7E, 0x07, 0xE0, 0x7E,
-  0x03, 0xE0, 0x3F, 0x03, 0xF0, 0x1F, 0x01, 0xF8, 0x0F, 0xC0, 0xFF, 0x07,
-  0xF0, 0x3F, 0x00, 0xF0, 0xE0, 0x1F, 0x03, 0xF0, 0x7F, 0x07, 0xF0, 0x7E,
-  0x07, 0xE0, 0xFC, 0x0F, 0x81, 0xF8, 0x3F, 0x07, 0xE0, 0x7C, 0x0F, 0x81,
-  0xF8, 0x3F, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8,
-  0x3F, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F,
-  0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07,
-  0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF0, 0x7E, 0x0F, 0xC1,
-  0xF8, 0x3F, 0x0F, 0xC1, 0xF8, 0x3E, 0x0F, 0xC7, 0xF0, 0xFE, 0x1F, 0x03,
-  0xC0, 0x00, 0x01, 0xF0, 0x00, 0x3E, 0x00, 0x07, 0xC0, 0x00, 0xF8, 0x00,
-  0x1E, 0x00, 0x81, 0xC0, 0x9C, 0x38, 0x77, 0xE7, 0x3F, 0xFF, 0xFF, 0xEF,
-  0xFF, 0xF8, 0x7F, 0xFC, 0x01, 0xFC, 0x00, 0x3F, 0x80, 0x0F, 0x78, 0x01,
-  0xEF, 0x00, 0x78, 0xF0, 0x1F, 0x1F, 0x07, 0xC1, 0xF0, 0xF8, 0x3E, 0x06,
-  0x03, 0x00, 0x00, 0x78, 0x00, 0x01, 0xE0, 0x00, 0x07, 0x80, 0x00, 0x1E,
-  0x00, 0x00, 0x78, 0x00, 0x01, 0xE0, 0x00, 0x07, 0x80, 0x00, 0x1E, 0x00,
-  0x00, 0x78, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x00, 0x1E, 0x00, 0x00, 0x78,
-  0x00, 0x01, 0xE0, 0x00, 0x07, 0x80, 0x00, 0x1E, 0x00, 0x00, 0x78, 0x00,
-  0x01, 0xE0, 0x00, 0x07, 0x80, 0x00, 0x1E, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0x87, 0x0E, 0x3C, 0x73, 0xEF, 0x8E, 0x10, 0x00, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xC0, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x1F,
-  0x80, 0x07, 0xE0, 0x01, 0xF0, 0x00, 0x7C, 0x00, 0x3F, 0x00, 0x0F, 0xC0,
-  0x03, 0xE0, 0x00, 0xF8, 0x00, 0x7E, 0x00, 0x1F, 0x00, 0x07, 0xC0, 0x03,
-  0xF0, 0x00, 0xFC, 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x07, 0xE0, 0x01, 0xF8,
-  0x00, 0x7C, 0x00, 0x1F, 0x00, 0x0F, 0xC0, 0x03, 0xE0, 0x00, 0xF8, 0x00,
-  0x7E, 0x00, 0x1F, 0x80, 0x07, 0xC0, 0x01, 0xF0, 0x00, 0xFC, 0x00, 0x3F,
-  0x00, 0x0F, 0x80, 0x03, 0xE0, 0x01, 0xF8, 0x00, 0x7C, 0x00, 0x1F, 0x00,
-  0x07, 0xC0, 0x03, 0xF0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x1F, 0x80, 0x07,
-  0xE0, 0x01, 0xF0, 0x00, 0x7C, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xE0,
-  0x00, 0x00, 0xFF, 0x00, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0xF0, 0x0F, 0xFF,
-  0xF8, 0x1F, 0xFF, 0xFC, 0x3F, 0xC3, 0xFC, 0x3F, 0x80, 0xFE, 0x7F, 0x00,
-  0xFE, 0x7E, 0x00, 0x7E, 0x7E, 0x00, 0x7F, 0x7E, 0x00, 0x7F, 0xFE, 0x00,
-  0x7F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0xFE, 0x00, 0x7F, 0x7E, 0x00, 0x7F, 0x7E, 0x00, 0x7F, 0x7E, 0x00,
-  0x7E, 0x7F, 0x00, 0x7E, 0x3F, 0x00, 0xFE, 0x3F, 0x81, 0xFC, 0x1F, 0xFF,
-  0xFC, 0x1F, 0xFF, 0xF8, 0x0F, 0xFF, 0xF0, 0x07, 0xFF, 0xE0, 0x01, 0xFF,
-  0x80, 0x00, 0x08, 0x00, 0x00, 0x7C, 0x01, 0xF0, 0x1F, 0xC0, 0xFF, 0x1F,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3, 0xF0, 0x0F, 0xC0,
-  0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0,
-  0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC,
-  0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F,
-  0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F,
-  0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03,
-  0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0x7F, 0x80, 0x03, 0xFF, 0xE0, 0x07, 0xFF,
-  0xF0, 0x0F, 0xFF, 0xF8, 0x1F, 0xFF, 0xFC, 0x3F, 0xE3, 0xFE, 0x3F, 0x80,
-  0xFE, 0x3F, 0x80, 0x7E, 0x7F, 0x00, 0x7F, 0x7F, 0x00, 0x7F, 0x7F, 0x00,
-  0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00,
-  0x7F, 0x7E, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7E, 0x00, 0x00,
-  0xFE, 0x00, 0x00, 0xFE, 0x00, 0x01, 0xFC, 0x00, 0x01, 0xFC, 0x00, 0x03,
-  0xF8, 0x00, 0x07, 0xF0, 0x00, 0x07, 0xF0, 0x00, 0x0F, 0xE0, 0x00, 0x1F,
-  0xC0, 0x00, 0x1F, 0xC0, 0x00, 0x3F, 0x80, 0x00, 0x7F, 0x00, 0x00, 0x7F,
-  0x00, 0x00, 0xFE, 0x00, 0x01, 0xFE, 0x00, 0x01, 0xFC, 0x00, 0x03, 0xF8,
-  0x00, 0x03, 0xF8, 0x00, 0x07, 0xF0, 0x00, 0x0F, 0xE0, 0x00, 0x0F, 0xE0,
-  0x00, 0x1F, 0xC0, 0x00, 0x3F, 0x80, 0x00, 0x3F, 0x80, 0x00, 0x7F, 0x00,
-  0x00, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF,
-  0xFE, 0xFF, 0xFF, 0xFE, 0x00, 0xFF, 0x00, 0x07, 0xFF, 0xE0, 0x0F, 0xFF,
-  0xF0, 0x1F, 0xFF, 0xF8, 0x3F, 0xFF, 0xFC, 0x3F, 0xC3, 0xFC, 0x7F, 0x00,
-  0xFE, 0x7F, 0x00, 0x7E, 0x7E, 0x00, 0x7E, 0xFE, 0x00, 0x7F, 0xFE, 0x00,
-  0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0x00, 0x00,
-  0x7F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFE, 0x00, 0x01,
-  0xFC, 0x00, 0x3F, 0xFC, 0x00, 0x3F, 0xF8, 0x00, 0x3F, 0xE0, 0x00, 0x3F,
-  0x80, 0x00, 0x3F, 0xE0, 0x00, 0x3F, 0xF0, 0x00, 0x3F, 0xF8, 0x00, 0x03,
-  0xFC, 0x00, 0x01, 0xFC, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x7E, 0x00, 0x00,
-  0x7E, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x7F, 0x00, 0x00,
-  0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00,
-  0x7E, 0x7E, 0x00, 0x7E, 0x7E, 0x00, 0x7E, 0x7F, 0x00, 0xFE, 0x7F, 0x81,
-  0xFC, 0x3F, 0xFF, 0xFC, 0x1F, 0xFF, 0xF8, 0x1F, 0xFF, 0xF0, 0x07, 0xFF,
-  0xE0, 0x03, 0xFF, 0x80, 0x00, 0x30, 0x00, 0x00, 0x07, 0xF0, 0x00, 0x03,
-  0xFC, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x7F, 0xC0, 0x00, 0x1F, 0xF0, 0x00,
-  0x07, 0xFC, 0x00, 0x03, 0xFF, 0x00, 0x00, 0xFF, 0xC0, 0x00, 0x7F, 0xF0,
-  0x00, 0x1F, 0xFC, 0x00, 0x0F, 0xBF, 0x00, 0x03, 0xEF, 0xC0, 0x01, 0xFB,
-  0xF0, 0x00, 0x7C, 0xFC, 0x00, 0x1F, 0x3F, 0x00, 0x0F, 0xCF, 0xC0, 0x03,
-  0xE3, 0xF0, 0x01, 0xF8, 0xFC, 0x00, 0x7C, 0x3F, 0x00, 0x3F, 0x0F, 0xC0,
-  0x0F, 0xC3, 0xF0, 0x07, 0xE0, 0xFC, 0x01, 0xF8, 0x3F, 0x00, 0x7E, 0x0F,
-  0xC0, 0x3F, 0x03, 0xF0, 0x0F, 0xC0, 0xFC, 0x07, 0xF0, 0x3F, 0x01, 0xF8,
-  0x0F, 0xC0, 0xFE, 0x03, 0xF0, 0x3F, 0x00, 0xFC, 0x0F, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFC, 0x00, 0x0F, 0xC0, 0x00, 0x03, 0xF0, 0x00, 0x00, 0xFC, 0x00, 0x00,
-  0x3F, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x03, 0xF0, 0x00, 0x00, 0xFC, 0x00,
-  0x00, 0x3F, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x03, 0xF0, 0x00, 0x00, 0xFC,
-  0x00, 0x00, 0x3F, 0x00, 0x00, 0x0F, 0xC0, 0x7F, 0xFF, 0xF8, 0xFF, 0xFF,
-  0xF1, 0xFF, 0xFF, 0xE3, 0xFF, 0xFF, 0xC7, 0xFF, 0xFF, 0x8F, 0xFF, 0xFF,
-  0x1F, 0xFF, 0xFE, 0x3E, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xF8, 0x00, 0x01,
-  0xF0, 0x00, 0x03, 0xE0, 0x00, 0x07, 0xC0, 0x00, 0x0F, 0x80, 0x00, 0x1F,
-  0x00, 0x00, 0x3E, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xF8, 0x7C, 0x01, 0xF3,
-  0xFF, 0x03, 0xFF, 0xFF, 0x87, 0xFF, 0xFF, 0x0F, 0xFF, 0xFF, 0x1F, 0xE0,
-  0xFF, 0x3F, 0x80, 0xFE, 0x7E, 0x00, 0xFC, 0xF8, 0x01, 0xFC, 0x00, 0x03,
-  0xF8, 0x00, 0x03, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F,
-  0x80, 0x00, 0x3F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xFF,
-  0xE0, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0x80, 0x0F, 0xFF, 0x00, 0x3F, 0x7F,
-  0x00, 0x7E, 0xFE, 0x00, 0xFC, 0xFC, 0x03, 0xF9, 0xFC, 0x07, 0xE3, 0xFF,
-  0xFF, 0xC3, 0xFF, 0xFF, 0x03, 0xFF, 0xFC, 0x03, 0xFF, 0xF0, 0x01, 0xFF,
-  0xC0, 0x00, 0xFF, 0x00, 0x03, 0xFF, 0xE0, 0x07, 0xFF, 0xF0, 0x0F, 0xFF,
-  0xF8, 0x1F, 0xFF, 0xFC, 0x1F, 0xC3, 0xFC, 0x3F, 0x80, 0xFE, 0x3F, 0x00,
-  0x7E, 0x7F, 0x00, 0x7E, 0x7E, 0x00, 0x7F, 0x7E, 0x00, 0x7F, 0x7E, 0x00,
-  0x7F, 0x7E, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00,
-  0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x1F,
-  0x00, 0xFE, 0x7F, 0xE0, 0xFE, 0xFF, 0xF0, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF,
-  0xFC, 0xFF, 0xC1, 0xFC, 0xFF, 0x00, 0xFE, 0xFE, 0x00, 0x7E, 0xFE, 0x00,
-  0x7E, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00,
-  0x7F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x3F, 0xFE, 0x00, 0x3F, 0xFE, 0x00,
-  0x3F, 0x7E, 0x00, 0x7F, 0x7E, 0x00, 0x7F, 0x7E, 0x00, 0x7E, 0x7E, 0x00,
-  0x7E, 0x7F, 0x00, 0xFE, 0x3F, 0x00, 0xFC, 0x3F, 0x81, 0xFC, 0x1F, 0xFF,
-  0xFC, 0x1F, 0xFF, 0xF8, 0x0F, 0xFF, 0xF0, 0x07, 0xFF, 0xE0, 0x01, 0xFF,
-  0x80, 0x00, 0x08, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00,
-  0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00,
-  0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x03,
-  0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x3F,
-  0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0xFC,
-  0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x03, 0xF0,
-  0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x7F, 0x00, 0x00, 0xFF,
-  0x00, 0x0F, 0xFF, 0x80, 0x3F, 0xFF, 0x80, 0xFF, 0xFF, 0x83, 0xFF, 0xFF,
-  0x87, 0xF0, 0x7F, 0x1F, 0xC0, 0x7F, 0x3F, 0x80, 0x7E, 0x7E, 0x00, 0xFC,
-  0xFC, 0x01, 0xFD, 0xF8, 0x03, 0xFB, 0xF0, 0x03, 0xF7, 0xE0, 0x0F, 0xEF,
-  0xC0, 0x1F, 0xDF, 0x80, 0x3F, 0xBF, 0x00, 0x7E, 0x7E, 0x00, 0xFC, 0xFE,
-  0x01, 0xF8, 0xFC, 0x07, 0xE1, 0xFE, 0x1F, 0xC1, 0xFF, 0xFF, 0x01, 0xFF,
-  0xFC, 0x01, 0xFF, 0xF0, 0x03, 0xFF, 0xE0, 0x0F, 0xFF, 0xF0, 0x3F, 0xFF,
-  0xF0, 0xFE, 0x0F, 0xE3, 0xF8, 0x0F, 0xE7, 0xE0, 0x0F, 0xCF, 0xC0, 0x1F,
-  0xFF, 0x00, 0x1F, 0xFE, 0x00, 0x3F, 0xFC, 0x00, 0x7F, 0xF8, 0x00, 0xFF,
-  0xF0, 0x01, 0xFF, 0xE0, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0x80, 0x0F, 0xFF,
-  0x00, 0x1F, 0xFF, 0x00, 0x3F, 0x7E, 0x00, 0xFE, 0xFC, 0x01, 0xF9, 0xFC,
-  0x07, 0xF1, 0xFF, 0x7F, 0xE3, 0xFF, 0xFF, 0x83, 0xFF, 0xFE, 0x03, 0xFF,
-  0xF8, 0x01, 0xFF, 0xC0, 0x00, 0x10, 0x00, 0x00, 0xFE, 0x00, 0x0F, 0xFF,
-  0x00, 0x3F, 0xFF, 0x80, 0xFF, 0xFF, 0x83, 0xFF, 0xFF, 0x07, 0xF8, 0xFF,
-  0x1F, 0xC0, 0x7E, 0x3F, 0x00, 0xFE, 0xFE, 0x00, 0xFD, 0xF8, 0x01, 0xFB,
-  0xF0, 0x03, 0xFF, 0xE0, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0x80, 0x0F, 0xFF,
-  0x00, 0x1F, 0xFE, 0x00, 0x3F, 0xFC, 0x00, 0x7F, 0xF8, 0x00, 0xFF, 0xF0,
-  0x01, 0xFF, 0xE0, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0xC0, 0x1F, 0xFF, 0x80,
-  0x3F, 0xBF, 0x80, 0xFF, 0x7F, 0xFF, 0xFE, 0x7F, 0xFF, 0xFC, 0x7F, 0xFD,
-  0xF8, 0x7F, 0xF3, 0xF0, 0x7F, 0xC7, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F,
-  0x80, 0x00, 0x3F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xF8,
-  0x00, 0x03, 0xFF, 0xC0, 0x07, 0xFF, 0x80, 0x1F, 0xFF, 0x00, 0x3F, 0x7E,
-  0x00, 0x7E, 0xFE, 0x00, 0xFD, 0xFC, 0x03, 0xF9, 0xFC, 0x0F, 0xE3, 0xFF,
-  0xFF, 0xC3, 0xFF, 0xFF, 0x03, 0xFF, 0xFC, 0x03, 0xFF, 0xF0, 0x01, 0xFF,
-  0x80, 0x00, 0x18, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xE1, 0xC3, 0x8F, 0x3D, 0xF9, 0xE3, 0x00, 0x00, 0x01, 0x80, 0x01, 0xC0,
-  0x01, 0xE0, 0x03, 0xF0, 0x03, 0xF8, 0x07, 0xFC, 0x07, 0xFC, 0x07, 0xFC,
-  0x0F, 0xF8, 0x0F, 0xF8, 0x1F, 0xF0, 0x1F, 0xF0, 0x0F, 0xF0, 0x07, 0xE0,
-  0x03, 0xE0, 0x01, 0xF0, 0x00, 0xFE, 0x00, 0x7F, 0x80, 0x3F, 0xF0, 0x07,
-  0xFC, 0x01, 0xFF, 0x00, 0x3F, 0xE0, 0x0F, 0xF8, 0x03, 0xFE, 0x00, 0x7F,
-  0x80, 0x1F, 0xC0, 0x03, 0xE0, 0x00, 0xF0, 0x00, 0x18, 0x00, 0x04, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80,
-  0x00, 0x70, 0x00, 0x3C, 0x00, 0x1F, 0x80, 0x0F, 0xE0, 0x07, 0xFC, 0x01,
-  0xFF, 0x00, 0x7F, 0xC0, 0x0F, 0xF8, 0x03, 0xFE, 0x00, 0x7F, 0xC0, 0x1F,
-  0xF0, 0x07, 0xF8, 0x00, 0xFC, 0x00, 0x3E, 0x00, 0x1F, 0x00, 0x3F, 0x80,
-  0x3F, 0xC0, 0x7F, 0xE0, 0x7F, 0xC0, 0x7F, 0xC0, 0xFF, 0x80, 0xFF, 0x80,
-  0xFF, 0x00, 0xFF, 0x00, 0x7F, 0x00, 0x3E, 0x00, 0x1E, 0x00, 0x0C, 0x00,
-  0x04, 0x00, 0x00, 0x01, 0xFE, 0x00, 0x0F, 0xFF, 0x80, 0x3F, 0xFF, 0x80,
-  0xFF, 0xFF, 0x83, 0xFF, 0xFF, 0x8F, 0xFD, 0xFF, 0x9F, 0xC0, 0x7F, 0x3F,
-  0x00, 0x7F, 0xFE, 0x00, 0xFF, 0xF8, 0x00, 0xFF, 0xF0, 0x01, 0xFF, 0xE0,
-  0x03, 0xFF, 0xE0, 0x07, 0xEF, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00,
-  0x3F, 0x00, 0x00, 0xFE, 0x00, 0x01, 0xF8, 0x00, 0x07, 0xF0, 0x00, 0x0F,
-  0xE0, 0x00, 0x3F, 0x80, 0x00, 0x7E, 0x00, 0x01, 0xFC, 0x00, 0x07, 0xF0,
-  0x00, 0x1F, 0xC0, 0x00, 0x7F, 0x00, 0x01, 0xFC, 0x00, 0x07, 0xF0, 0x00,
-  0x1F, 0xC0, 0x00, 0x3F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xF8, 0x00, 0x01,
-  0xF0, 0x00, 0x03, 0xE0, 0x00, 0x07, 0xC0, 0x00, 0x0F, 0x80, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x0F, 0xE0, 0x00, 0x1F, 0xC0, 0x00, 0x3F, 0x80,
-  0x00, 0x7F, 0x00, 0x00, 0xFE, 0x00, 0x01, 0xFC, 0x00, 0x00, 0x00, 0x00,
-  0x30, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0xFF,
-  0xFF, 0xF8, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFC, 0x00, 0x00, 0x0F, 0xFF,
-  0xFF, 0xFF, 0x00, 0x00, 0x1F, 0xFF, 0x8F, 0xFF, 0x80, 0x00, 0x7F, 0xF0,
-  0x00, 0x7F, 0xC0, 0x00, 0xFF, 0xC0, 0x00, 0x1F, 0xE0, 0x01, 0xFF, 0x00,
-  0x00, 0x07, 0xE0, 0x01, 0xFE, 0x00, 0x00, 0x03, 0xF0, 0x03, 0xF8, 0x00,
-  0x00, 0x01, 0xF8, 0x07, 0xF8, 0x00, 0x00, 0x00, 0xF8, 0x07, 0xF0, 0x00,
-  0x00, 0x00, 0xFC, 0x0F, 0xE0, 0x01, 0xFD, 0xF0, 0x7C, 0x0F, 0xC0, 0x07,
-  0xFF, 0xF0, 0x7C, 0x1F, 0xC0, 0x0F, 0xFF, 0xF0, 0x3E, 0x1F, 0x80, 0x1F,
-  0xFF, 0xF0, 0x3E, 0x3F, 0x80, 0x3F, 0xE3, 0xF0, 0x3E, 0x3F, 0x00, 0x7F,
-  0x83, 0xE0, 0x1E, 0x3F, 0x00, 0x7E, 0x03, 0xE0, 0x1E, 0x3F, 0x00, 0xFE,
-  0x07, 0xE0, 0x1E, 0x7E, 0x00, 0xFC, 0x07, 0xE0, 0x1F, 0x7E, 0x01, 0xF8,
-  0x07, 0xE0, 0x1F, 0x7E, 0x01, 0xF8, 0x07, 0xE0, 0x1F, 0x7E, 0x03, 0xF0,
-  0x07, 0xC0, 0x1F, 0x7E, 0x03, 0xF0, 0x07, 0xC0, 0x1E, 0x7C, 0x03, 0xF0,
-  0x07, 0xC0, 0x1E, 0x7C, 0x03, 0xF0, 0x0F, 0xC0, 0x1E, 0x7C, 0x07, 0xE0,
-  0x0F, 0xC0, 0x1E, 0xFC, 0x07, 0xE0, 0x0F, 0xC0, 0x3E, 0xFC, 0x07, 0xE0,
-  0x0F, 0x80, 0x3E, 0xFC, 0x07, 0xE0, 0x0F, 0x80, 0x3C, 0xFC, 0x07, 0xE0,
-  0x0F, 0x80, 0x7C, 0x7C, 0x07, 0xE0, 0x1F, 0x80, 0x7C, 0x7C, 0x03, 0xF0,
-  0x1F, 0x80, 0xF8, 0x7C, 0x03, 0xF0, 0x3F, 0x80, 0xF0, 0x7E, 0x03, 0xF8,
-  0x7F, 0x81, 0xF0, 0x7E, 0x03, 0xFF, 0xEF, 0x83, 0xE0, 0x7E, 0x01, 0xFF,
-  0xEF, 0x8F, 0xC0, 0x7E, 0x00, 0xFF, 0xEF, 0xFF, 0x80, 0x3F, 0x00, 0x7F,
-  0xC7, 0xFF, 0x00, 0x3F, 0x00, 0x3F, 0x03, 0xFC, 0x00, 0x3F, 0x80, 0x00,
-  0x00, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xC0, 0x00,
-  0x00, 0x00, 0x00, 0x0F, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xF0, 0x00,
-  0x00, 0x00, 0x00, 0x07, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFE, 0x00,
-  0x00, 0x00, 0x00, 0x01, 0xFF, 0x80, 0x00, 0x10, 0x00, 0x00, 0xFF, 0xF0,
-  0x01, 0xF0, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x1F, 0xFF,
-  0xFF, 0xF8, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xF8, 0x00, 0x00, 0x01, 0xFF,
-  0xFF, 0xE0, 0x00, 0x00, 0x00, 0x0F, 0xF8, 0x00, 0x00, 0x00, 0x3F, 0x80,
-  0x00, 0x07, 0xF0, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x1F, 0xC0, 0x00, 0x07,
-  0xFC, 0x00, 0x00, 0xFF, 0x80, 0x00, 0x1F, 0xF0, 0x00, 0x03, 0xFE, 0x00,
-  0x00, 0xFF, 0xC0, 0x00, 0x1F, 0xFC, 0x00, 0x03, 0xEF, 0x80, 0x00, 0x7D,
-  0xF0, 0x00, 0x0F, 0xBE, 0x00, 0x03, 0xF7, 0xC0, 0x00, 0x7E, 0xFC, 0x00,
-  0x0F, 0x8F, 0x80, 0x01, 0xF1, 0xF0, 0x00, 0x3E, 0x3E, 0x00, 0x0F, 0xC7,
-  0xC0, 0x01, 0xF8, 0xFC, 0x00, 0x3F, 0x1F, 0x80, 0x07, 0xC1, 0xF0, 0x00,
-  0xF8, 0x3E, 0x00, 0x3F, 0x07, 0xE0, 0x07, 0xE0, 0xFC, 0x00, 0xFC, 0x1F,
-  0x80, 0x1F, 0x01, 0xF0, 0x07, 0xE0, 0x3E, 0x00, 0xFC, 0x07, 0xE0, 0x1F,
-  0x80, 0xFC, 0x03, 0xF0, 0x1F, 0x80, 0x7F, 0xFF, 0xF0, 0x1F, 0xFF, 0xFE,
-  0x03, 0xFF, 0xFF, 0xE0, 0x7F, 0xFF, 0xFC, 0x0F, 0xFF, 0xFF, 0x81, 0xF8,
-  0x03, 0xF0, 0x7E, 0x00, 0x3F, 0x0F, 0xC0, 0x07, 0xE1, 0xF8, 0x00, 0xFC,
-  0x3F, 0x00, 0x1F, 0x8F, 0xE0, 0x03, 0xF1, 0xF8, 0x00, 0x3F, 0x3F, 0x00,
-  0x07, 0xE7, 0xE0, 0x00, 0xFC, 0xFC, 0x00, 0x1F, 0xBF, 0x80, 0x03, 0xF7,
-  0xE0, 0x00, 0x7F, 0xFF, 0xF0, 0x00, 0x7F, 0xFF, 0xC0, 0x3F, 0xFF, 0xF8,
-  0x1F, 0xFF, 0xFE, 0x0F, 0xFF, 0xFF, 0x87, 0xE1, 0xFF, 0xE3, 0xF0, 0x07,
-  0xF1, 0xF8, 0x01, 0xFC, 0xFC, 0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x3F, 0x00,
-  0x1F, 0x9F, 0x80, 0x07, 0xCF, 0xC0, 0x03, 0xE7, 0xE0, 0x01, 0xF3, 0xF0,
-  0x01, 0xF9, 0xF8, 0x00, 0xFC, 0xFC, 0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x3F,
-  0x00, 0x3F, 0x1F, 0x80, 0x3F, 0x8F, 0xFF, 0xFF, 0x87, 0xFF, 0xFF, 0x03,
-  0xFF, 0xFE, 0x01, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0xF8, 0x7E, 0x07, 0xFE,
-  0x3F, 0x00, 0x7F, 0x9F, 0x80, 0x1F, 0xCF, 0xC0, 0x07, 0xF7, 0xE0, 0x03,
-  0xFB, 0xF0, 0x00, 0xFD, 0xF8, 0x00, 0x7E, 0xFC, 0x00, 0x3F, 0xFE, 0x00,
-  0x1F, 0xFF, 0x00, 0x0F, 0xFF, 0x80, 0x07, 0xFF, 0xC0, 0x03, 0xFF, 0xE0,
-  0x01, 0xFB, 0xF0, 0x00, 0xFD, 0xF8, 0x00, 0x7E, 0xFC, 0x00, 0x7F, 0x7E,
-  0x00, 0x7F, 0x3F, 0x00, 0x7F, 0x9F, 0xFF, 0xFF, 0x8F, 0xFF, 0xFF, 0xC7,
-  0xFF, 0xFF, 0xC3, 0xFF, 0xFF, 0x81, 0xFF, 0xFE, 0x00, 0x00, 0xFF, 0x80,
-  0x01, 0xFF, 0xF0, 0x03, 0xFF, 0xFE, 0x03, 0xFF, 0xFF, 0x83, 0xFF, 0xFF,
-  0xE1, 0xFE, 0x0F, 0xF1, 0xFC, 0x01, 0xFC, 0xFE, 0x00, 0xFE, 0x7E, 0x00,
-  0x3F, 0x7F, 0x00, 0x1F, 0xBF, 0x80, 0x0F, 0xDF, 0xC0, 0x07, 0xFF, 0xE0,
-  0x03, 0xFF, 0xF0, 0x01, 0xFF, 0xF8, 0x00, 0xFF, 0xFC, 0x00, 0x7F, 0xFE,
-  0x00, 0x3F, 0xFF, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x1F, 0xC0, 0x00, 0x0F,
-  0xE0, 0x00, 0x07, 0xF0, 0x00, 0x03, 0xF8, 0x00, 0x01, 0xFC, 0x00, 0x00,
-  0xFE, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3F, 0x80, 0x00, 0x1F, 0xC0, 0x00,
-  0x0F, 0xE0, 0x00, 0x07, 0xF0, 0x00, 0x03, 0xF8, 0x00, 0xFF, 0xFC, 0x00,
-  0x7F, 0xFE, 0x00, 0x3F, 0xFF, 0x00, 0x1F, 0xFF, 0x80, 0x0F, 0xFF, 0xC0,
-  0x07, 0xFF, 0xE0, 0x03, 0xF7, 0xF0, 0x01, 0xFB, 0xF8, 0x00, 0xFC, 0xFC,
-  0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x3F, 0x80, 0x3F, 0x8F, 0xE0, 0x3F, 0x87,
-  0xFF, 0xFF, 0xC1, 0xFF, 0xFF, 0xC0, 0x7F, 0xFF, 0xC0, 0x1F, 0xFF, 0xC0,
-  0x03, 0xFF, 0xC0, 0x00, 0x08, 0x00, 0x00, 0xFF, 0xE8, 0x00, 0xFF, 0xFF,
-  0x80, 0xFF, 0xFF, 0xE0, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0xFC, 0x0F,
-  0xFC, 0xFC, 0x01, 0xFE, 0xFC, 0x00, 0xFE, 0xFC, 0x00, 0x7E, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00,
-  0x7F, 0xFC, 0x00, 0x7F, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0xFE, 0xFC, 0x00,
-  0xFE, 0xFC, 0x03, 0xFC, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF,
-  0xF0, 0xFF, 0xFF, 0xC0, 0xFF, 0xFE, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x0F, 0xC0, 0x03, 0xF0,
-  0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0xFF, 0xCF, 0xFF, 0xF3, 0xFF,
-  0xFC, 0xFF, 0xFF, 0x3F, 0xFF, 0xCF, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0,
-  0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x0F, 0xC0, 0x03, 0xF0,
-  0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0xFF, 0x8F, 0xFF, 0xE3, 0xFF,
-  0xF8, 0xFF, 0xFE, 0x3F, 0xFF, 0x8F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0,
-  0x00, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0xFC, 0x00,
-  0x3F, 0x00, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0x00, 0xFF, 0x80, 0x03, 0xFF,
-  0xF8, 0x03, 0xFF, 0xFE, 0x03, 0xFF, 0xFF, 0x83, 0xFF, 0xFF, 0xE1, 0xFE,
-  0x0F, 0xF1, 0xFC, 0x01, 0xFC, 0xFE, 0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x7F,
-  0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xC0, 0x03, 0xFF, 0xE0, 0x01, 0xFF,
-  0xE0, 0x00, 0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC, 0x00, 0x00,
-  0x7E, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x0F, 0xC0, 0x00,
-  0x07, 0xE0, 0x00, 0x03, 0xF0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0xFC, 0x07,
-  0xFF, 0xFE, 0x03, 0xFF, 0xFF, 0x01, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0xC0,
-  0x7F, 0xFF, 0xE0, 0x00, 0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC,
-  0x00, 0x1F, 0xFE, 0x00, 0x0F, 0xFF, 0x00, 0x07, 0xFF, 0xC0, 0x03, 0xFF,
-  0xE0, 0x01, 0xFF, 0xF0, 0x00, 0xFF, 0xF8, 0x00, 0x7E, 0xFC, 0x00, 0x7F,
-  0x7F, 0x00, 0x3F, 0xBF, 0x80, 0x3F, 0xCF, 0xE0, 0x3F, 0xE7, 0xFF, 0xFE,
-  0xF1, 0xFF, 0xFF, 0x78, 0x7F, 0xFF, 0x3C, 0x1F, 0xFF, 0x1E, 0x07, 0xFF,
-  0x0F, 0x00, 0x18, 0x00, 0x00, 0xFC, 0x00, 0x1F, 0xFE, 0x00, 0x0F, 0xFF,
-  0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0, 0x01, 0xFF, 0xE0, 0x00, 0xFF,
-  0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC, 0x00, 0x1F, 0xFE, 0x00, 0x0F,
-  0xFF, 0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0, 0x01, 0xFF, 0xE0, 0x00,
-  0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC, 0x00, 0x1F, 0xFE, 0x00,
-  0x0F, 0xFF, 0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0, 0x01, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0, 0x01, 0xFF,
-  0xE0, 0x00, 0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC, 0x00, 0x1F,
-  0xFE, 0x00, 0x0F, 0xFF, 0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0, 0x01,
-  0xFF, 0xE0, 0x00, 0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFC, 0x00,
-  0x1F, 0xFE, 0x00, 0x0F, 0xFF, 0x00, 0x07, 0xFF, 0x80, 0x03, 0xFF, 0xC0,
-  0x01, 0xFF, 0xE0, 0x00, 0xFF, 0xF0, 0x00, 0x7F, 0xF8, 0x00, 0x3F, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F,
-  0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F,
-  0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07,
-  0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01,
-  0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0,
-  0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0,
-  0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x3F, 0x81, 0xFE, 0xFF, 0xFB,
-  0xFF, 0xCF, 0xFF, 0x3F, 0xF8, 0xFF, 0x00, 0xFC, 0x00, 0x7E, 0x7E, 0x00,
-  0x3F, 0x3F, 0x00, 0x3F, 0x9F, 0x80, 0x1F, 0x8F, 0xC0, 0x1F, 0xC7, 0xE0,
-  0x0F, 0xC3, 0xF0, 0x0F, 0xE1, 0xF8, 0x07, 0xE0, 0xFC, 0x07, 0xF0, 0x7E,
-  0x03, 0xF0, 0x3F, 0x03, 0xF8, 0x1F, 0x81, 0xF8, 0x0F, 0xC1, 0xFC, 0x07,
-  0xE0, 0xFE, 0x03, 0xF0, 0xFE, 0x01, 0xF8, 0x7F, 0x00, 0xFC, 0x7F, 0x00,
-  0x7E, 0x3F, 0x80, 0x3F, 0x3F, 0x80, 0x1F, 0x9F, 0xC0, 0x0F, 0xDF, 0xC0,
-  0x07, 0xEF, 0xE0, 0x03, 0xF7, 0xF0, 0x01, 0xFF, 0xFC, 0x00, 0xFF, 0xFE,
-  0x00, 0x7F, 0xFF, 0x80, 0x3F, 0xEF, 0xC0, 0x1F, 0xE7, 0xF0, 0x0F, 0xF1,
-  0xF8, 0x07, 0xF0, 0xFC, 0x03, 0xF8, 0x7F, 0x01, 0xF8, 0x1F, 0x80, 0xFC,
-  0x0F, 0xE0, 0x7E, 0x03, 0xF0, 0x3F, 0x01, 0xF8, 0x1F, 0x80, 0xFE, 0x0F,
-  0xC0, 0x3F, 0x07, 0xE0, 0x1F, 0xC3, 0xF0, 0x07, 0xE1, 0xF8, 0x03, 0xF0,
-  0xFC, 0x01, 0xFC, 0x7E, 0x00, 0x7E, 0x3F, 0x00, 0x3F, 0x9F, 0x80, 0x0F,
-  0xCF, 0xC0, 0x07, 0xF7, 0xE0, 0x03, 0xFB, 0xF0, 0x00, 0xFD, 0xF8, 0x00,
-  0x7F, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0,
-  0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80,
-  0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00,
-  0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00,
-  0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00,
-  0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00,
-  0x3F, 0x00, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00,
-  0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07, 0xE0, 0x00,
-  0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0xFD, 0xFC,
-  0x00, 0x01, 0xFB, 0xF8, 0x00, 0x07, 0xF7, 0xF8, 0x00, 0x0F, 0xEF, 0xF0,
-  0x00, 0x1F, 0xDF, 0xE0, 0x00, 0x3F, 0xBF, 0xC0, 0x00, 0xFF, 0x7F, 0xC0,
-  0x01, 0xFE, 0xFF, 0x80, 0x03, 0xFD, 0xFF, 0x00, 0x07, 0xFB, 0xFE, 0x00,
-  0x0F, 0xF7, 0xFC, 0x00, 0x3F, 0xFF, 0xFC, 0x00, 0x7F, 0xFF, 0xF8, 0x00,
-  0xFF, 0xFF, 0xF0, 0x01, 0xFF, 0xFF, 0xE0, 0x03, 0xFF, 0xFB, 0xC0, 0x0F,
-  0xFF, 0xF7, 0xC0, 0x1E, 0xFF, 0xE7, 0x80, 0x3D, 0xFF, 0xCF, 0x00, 0x7B,
-  0xFF, 0x9E, 0x01, 0xF7, 0xFF, 0x3E, 0x03, 0xCF, 0xFE, 0x3C, 0x07, 0x9F,
-  0xFC, 0x78, 0x0F, 0x3F, 0xF8, 0xF0, 0x1E, 0x7F, 0xF1, 0xE0, 0x7C, 0x7F,
-  0xE1, 0xE0, 0xF0, 0xFF, 0xC3, 0xC1, 0xE1, 0xFF, 0x87, 0x83, 0xC3, 0xFF,
-  0x0F, 0x0F, 0x87, 0xFE, 0x1F, 0x1E, 0x0F, 0xFC, 0x1E, 0x3C, 0x1F, 0xF8,
-  0x3C, 0x78, 0x3F, 0xF0, 0x78, 0xF0, 0x7F, 0xE0, 0xF3, 0xC0, 0xFF, 0xC0,
-  0xF7, 0x81, 0xFF, 0x81, 0xEF, 0x03, 0xFF, 0x03, 0xDE, 0x07, 0xFE, 0x07,
-  0xF8, 0x0F, 0xFC, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x3F, 0xF0, 0x1F,
-  0xC0, 0x7F, 0xE0, 0x3F, 0x80, 0xFF, 0xC0, 0x7E, 0x01, 0xFF, 0x80, 0x7C,
-  0x03, 0xFF, 0x00, 0xF8, 0x07, 0xFE, 0x01, 0xF0, 0x0F, 0xFC, 0x03, 0xC0,
-  0x1F, 0xF0, 0x00, 0x3F, 0xF0, 0x00, 0x7F, 0xE0, 0x00, 0xFF, 0xE0, 0x01,
-  0xFF, 0xC0, 0x03, 0xFF, 0x80, 0x07, 0xFF, 0x80, 0x0F, 0xFF, 0x00, 0x1F,
-  0xFF, 0x00, 0x3F, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0xFF, 0xFC, 0x01, 0xFF,
-  0xF8, 0x03, 0xFF, 0xF8, 0x07, 0xFF, 0xF0, 0x0F, 0xFF, 0xF0, 0x1F, 0xFB,
-  0xE0, 0x3F, 0xF7, 0xE0, 0x7F, 0xE7, 0xC0, 0xFF, 0xCF, 0x81, 0xFF, 0x9F,
-  0x83, 0xFF, 0x1F, 0x07, 0xFE, 0x3F, 0x0F, 0xFC, 0x3E, 0x1F, 0xF8, 0x7E,
-  0x3F, 0xF0, 0x7C, 0x7F, 0xE0, 0xF8, 0xFF, 0xC1, 0xF9, 0xFF, 0x81, 0xF3,
-  0xFF, 0x03, 0xF7, 0xFE, 0x03, 0xEF, 0xFC, 0x07, 0xFF, 0xF8, 0x0F, 0xFF,
-  0xF0, 0x0F, 0xFF, 0xE0, 0x1F, 0xFF, 0xC0, 0x1F, 0xFF, 0x80, 0x3F, 0xFF,
-  0x00, 0x3F, 0xFE, 0x00, 0x7F, 0xFC, 0x00, 0xFF, 0xF8, 0x00, 0xFF, 0xF0,
-  0x01, 0xFF, 0xE0, 0x01, 0xFF, 0xC0, 0x03, 0xFF, 0x80, 0x03, 0xFF, 0x00,
-  0x07, 0xFE, 0x00, 0x0F, 0xFC, 0x00, 0x0F, 0x00, 0xFF, 0x80, 0x00, 0xFF,
-  0xFC, 0x00, 0xFF, 0xFF, 0x80, 0x7F, 0xFF, 0xF0, 0x3F, 0xFF, 0xFE, 0x0F,
-  0xF0, 0x7F, 0xC7, 0xF0, 0x07, 0xF1, 0xFC, 0x00, 0xFE, 0x7E, 0x00, 0x3F,
-  0xBF, 0x80, 0x07, 0xEF, 0xE0, 0x01, 0xFB, 0xF8, 0x00, 0x7F, 0xFE, 0x00,
-  0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE,
-  0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F,
-  0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00,
-  0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8,
-  0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF,
-  0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01,
-  0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0,
-  0x01, 0xF9, 0xF8, 0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x9F, 0xC0, 0x0F, 0xC3,
-  0xF8, 0x0F, 0xF0, 0xFF, 0xFF, 0xF8, 0x1F, 0xFF, 0xFE, 0x03, 0xFF, 0xFF,
-  0x00, 0x7F, 0xFF, 0x80, 0x07, 0xFF, 0x80, 0x00, 0x08, 0x00, 0x00, 0xFF,
-  0xF4, 0x01, 0xFF, 0xFF, 0x03, 0xFF, 0xFF, 0x87, 0xFF, 0xFF, 0x8F, 0xFF,
-  0xFF, 0x9F, 0x80, 0xFF, 0xBF, 0x00, 0x7F, 0x7E, 0x00, 0x7E, 0xFC, 0x00,
-  0xFF, 0xF8, 0x00, 0xFF, 0xF0, 0x01, 0xFF, 0xE0, 0x03, 0xFF, 0xC0, 0x07,
-  0xFF, 0x80, 0x0F, 0xFF, 0x00, 0x1F, 0xFE, 0x00, 0x3F, 0xFC, 0x00, 0x7F,
-  0xF8, 0x01, 0xFF, 0xF0, 0x03, 0xFF, 0xE0, 0x0F, 0xEF, 0xC0, 0x3F, 0xDF,
-  0xFF, 0xFF, 0x3F, 0xFF, 0xFC, 0x7F, 0xFF, 0xF0, 0xFF, 0xFF, 0xC1, 0xFF,
-  0xFC, 0x03, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80,
-  0x00, 0x3F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xF8, 0x00,
-  0x03, 0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00,
-  0x3F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xFC, 0x00, 0x01, 0xF8, 0x00, 0x03,
-  0xF0, 0x00, 0x07, 0xE0, 0x00, 0x0F, 0xC0, 0x00, 0x1F, 0x80, 0x00, 0x3F,
-  0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xFF, 0x80, 0x00, 0xFF, 0xFC, 0x00,
-  0xFF, 0xFF, 0x80, 0x7F, 0xFF, 0xF8, 0x3F, 0xFF, 0xFE, 0x0F, 0xF0, 0x7F,
-  0xC7, 0xF0, 0x07, 0xF1, 0xFC, 0x00, 0xFE, 0x7E, 0x00, 0x1F, 0xBF, 0x80,
-  0x07, 0xEF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF,
-  0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F,
-  0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00,
-  0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE,
-  0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F,
-  0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00,
-  0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8,
-  0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xF9,
-  0xF8, 0x00, 0x7E, 0x7E, 0x00, 0x3F, 0x9F, 0xC0, 0x0F, 0xE3, 0xF8, 0x0F,
-  0xF0, 0xFF, 0xFF, 0xFC, 0x1F, 0xFF, 0xFE, 0x03, 0xFF, 0xFF, 0x00, 0x7F,
-  0xFF, 0x80, 0x07, 0xFF, 0x80, 0x00, 0x07, 0xF0, 0x00, 0x00, 0x7E, 0x00,
-  0x00, 0x1F, 0xC0, 0x00, 0x03, 0xF8, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x0F,
-  0x80, 0x00, 0x01, 0xE0, 0x00, 0x00, 0x38, 0x00, 0x00, 0x06, 0x00, 0x00,
-  0x00, 0x80, 0xFF, 0xE0, 0x00, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0xE0, 0xFF,
-  0xFF, 0xF0, 0xFF, 0xFF, 0xF8, 0xFC, 0x0F, 0xFC, 0xFC, 0x01, 0xFC, 0xFC,
-  0x00, 0xFE, 0xFC, 0x00, 0xFE, 0xFC, 0x00, 0xFE, 0xFC, 0x00, 0x7E, 0xFC,
-  0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC,
-  0x00, 0x7E, 0xFC, 0x00, 0xFE, 0xFC, 0x00, 0xFE, 0xFC, 0x00, 0xFE, 0xFC,
-  0x01, 0xFC, 0xFC, 0x07, 0xFC, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF0, 0xFF,
-  0xFF, 0xE0, 0xFF, 0xFF, 0xC0, 0xFF, 0xFF, 0xC0, 0xFC, 0x0F, 0xC0, 0xFC,
-  0x0F, 0xC0, 0xFC, 0x0F, 0xE0, 0xFC, 0x07, 0xE0, 0xFC, 0x07, 0xE0, 0xFC,
-  0x07, 0xE0, 0xFC, 0x07, 0xF0, 0xFC, 0x03, 0xF0, 0xFC, 0x03, 0xF0, 0xFC,
-  0x03, 0xF8, 0xFC, 0x01, 0xF8, 0xFC, 0x01, 0xF8, 0xFC, 0x01, 0xF8, 0xFC,
-  0x01, 0xFC, 0xFC, 0x00, 0xFC, 0xFC, 0x00, 0xFC, 0xFC, 0x00, 0xFE, 0xFC,
-  0x00, 0xFE, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7F, 0xFC,
-  0x00, 0x3F, 0x00, 0xFF, 0x00, 0x07, 0xFF, 0xC0, 0x0F, 0xFF, 0xF0, 0x1F,
-  0xFF, 0xF8, 0x3F, 0xFF, 0xF8, 0x3F, 0x83, 0xFC, 0x7F, 0x00, 0xFC, 0x7E,
-  0x00, 0xFE, 0x7E, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC, 0x00, 0x7E, 0xFC,
-  0x00, 0x3E, 0xFE, 0x00, 0x3F, 0x7E, 0x00, 0x20, 0x7E, 0x00, 0x00, 0x7F,
-  0x00, 0x00, 0x7F, 0x80, 0x00, 0x3F, 0xC0, 0x00, 0x3F, 0xE0, 0x00, 0x1F,
-  0xF8, 0x00, 0x0F, 0xFC, 0x00, 0x07, 0xFE, 0x00, 0x03, 0xFF, 0x00, 0x01,
-  0xFF, 0x80, 0x00, 0xFF, 0xC0, 0x00, 0x3F, 0xE0, 0x00, 0x1F, 0xF0, 0x00,
-  0x0F, 0xF8, 0x00, 0x07, 0xFC, 0x00, 0x03, 0xFC, 0x00, 0x01, 0xFE, 0x00,
-  0x00, 0xFE, 0x00, 0x00, 0x7F, 0x04, 0x00, 0x7F, 0x7C, 0x00, 0x3F, 0xFC,
-  0x00, 0x3F, 0xFE, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7E, 0x00, 0x3F, 0x7E,
-  0x00, 0x3F, 0x7F, 0x00, 0x3F, 0x3F, 0x80, 0x7F, 0x3F, 0xC0, 0xFE, 0x1F,
-  0xFF, 0xFE, 0x0F, 0xFF, 0xFC, 0x0F, 0xFF, 0xF8, 0x03, 0xFF, 0xF0, 0x01,
-  0xFF, 0xC0, 0x00, 0x18, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x03, 0xF8, 0x00, 0x0F, 0xE0,
-  0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00,
-  0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F,
-  0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80,
-  0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00,
-  0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFE,
-  0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00,
-  0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03,
-  0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8,
-  0x00, 0x0F, 0xE0, 0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00,
-  0x0F, 0xE0, 0x00, 0x3F, 0x80, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF,
-  0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07,
-  0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80,
-  0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F, 0xFF,
-  0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00, 0x1F,
-  0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE, 0x00,
-  0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F, 0xFE,
-  0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00, 0x7F,
-  0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8, 0x00,
-  0x7F, 0xFE, 0x00, 0x1F, 0xFF, 0x80, 0x07, 0xFF, 0xE0, 0x01, 0xFF, 0xF8,
-  0x00, 0x7E, 0x7E, 0x00, 0x1F, 0x9F, 0x80, 0x07, 0xE7, 0xE0, 0x01, 0xF9,
-  0xF8, 0x00, 0xFE, 0x7F, 0x00, 0x3F, 0x8F, 0xE0, 0x1F, 0xC3, 0xFC, 0x0F,
-  0xF0, 0xFF, 0xFF, 0xFC, 0x1F, 0xFF, 0xFE, 0x03, 0xFF, 0xFF, 0x00, 0x7F,
-  0xFF, 0x80, 0x07, 0xFF, 0x80, 0x00, 0x1C, 0x00, 0x00, 0xFE, 0x00, 0x07,
-  0xEF, 0xC0, 0x00, 0xFD, 0xF8, 0x00, 0x1F, 0xBF, 0x00, 0x03, 0xF7, 0xE0,
-  0x00, 0xFC, 0xFE, 0x00, 0x1F, 0x8F, 0xC0, 0x03, 0xF1, 0xF8, 0x00, 0x7E,
-  0x3F, 0x00, 0x0F, 0xC7, 0xF0, 0x03, 0xF0, 0x7E, 0x00, 0x7E, 0x0F, 0xC0,
-  0x0F, 0xC1, 0xF8, 0x01, 0xF8, 0x3F, 0x00, 0x3E, 0x07, 0xF0, 0x0F, 0xC0,
-  0x7E, 0x01, 0xF8, 0x0F, 0xC0, 0x3F, 0x01, 0xF8, 0x07, 0xE0, 0x3F, 0x00,
-  0xF8, 0x03, 0xF0, 0x3F, 0x00, 0x7E, 0x07, 0xE0, 0x0F, 0xC0, 0xFC, 0x01,
-  0xF8, 0x1F, 0x00, 0x1F, 0x83, 0xE0, 0x03, 0xF0, 0xFC, 0x00, 0x7E, 0x1F,
-  0x80, 0x0F, 0xC3, 0xF0, 0x01, 0xF8, 0x7C, 0x00, 0x1F, 0x8F, 0x80, 0x03,
-  0xF3, 0xF0, 0x00, 0x7E, 0x7E, 0x00, 0x0F, 0xCF, 0x80, 0x00, 0xF9, 0xF0,
-  0x00, 0x1F, 0xFE, 0x00, 0x03, 0xFF, 0xC0, 0x00, 0x7F, 0xF8, 0x00, 0x0F,
-  0xFE, 0x00, 0x00, 0xFF, 0xC0, 0x00, 0x1F, 0xF8, 0x00, 0x03, 0xFF, 0x00,
-  0x00, 0x7F, 0xC0, 0x00, 0x07, 0xF8, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x1F,
-  0xE0, 0x00, 0x03, 0xFC, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x07, 0xE0, 0x00,
-  0x00, 0xFC, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x7F, 0xF8, 0x00, 0xF8, 0x00,
-  0xFF, 0xF0, 0x01, 0xF0, 0x01, 0xF3, 0xE0, 0x03, 0xE0, 0x03, 0xE7, 0xC0,
-  0x0F, 0xE0, 0x07, 0xCF, 0x80, 0x1F, 0xC0, 0x0F, 0x9F, 0x80, 0x3F, 0x80,
-  0x3F, 0x3F, 0x00, 0x7F, 0x00, 0x7E, 0x7E, 0x00, 0xFE, 0x00, 0xF8, 0x7C,
-  0x03, 0xFE, 0x01, 0xF0, 0xF8, 0x07, 0xFC, 0x03, 0xE1, 0xF0, 0x0F, 0xF8,
-  0x07, 0xC3, 0xE0, 0x1F, 0xF0, 0x0F, 0x87, 0xE0, 0x3D, 0xE0, 0x3F, 0x0F,
-  0xC0, 0x7B, 0xC0, 0x7C, 0x0F, 0x81, 0xF7, 0xC0, 0xF8, 0x1F, 0x03, 0xEF,
-  0x81, 0xF0, 0x3E, 0x07, 0xCF, 0x03, 0xE0, 0x7C, 0x0F, 0x9E, 0x07, 0xC0,
-  0xF8, 0x1E, 0x3C, 0x0F, 0x81, 0xF8, 0x7C, 0x7C, 0x3F, 0x01, 0xF0, 0xF8,
-  0xF8, 0x7C, 0x03, 0xE1, 0xF1, 0xF0, 0xF8, 0x07, 0xC3, 0xE1, 0xE1, 0xF0,
-  0x0F, 0x87, 0x83, 0xC3, 0xE0, 0x1F, 0x1F, 0x07, 0xC7, 0xC0, 0x3F, 0x3E,
-  0x0F, 0x8F, 0x80, 0x3E, 0x7C, 0x1F, 0x3E, 0x00, 0x7C, 0xF8, 0x1E, 0x7C,
-  0x00, 0xF9, 0xE0, 0x3C, 0xF8, 0x01, 0xF3, 0xC0, 0x7D, 0xF0, 0x03, 0xEF,
-  0x80, 0xFB, 0xE0, 0x07, 0xDF, 0x01, 0xF7, 0xC0, 0x07, 0xFE, 0x01, 0xFF,
-  0x00, 0x0F, 0xFC, 0x03, 0xFE, 0x00, 0x1F, 0xF0, 0x07, 0xFC, 0x00, 0x3F,
-  0xE0, 0x0F, 0xF8, 0x00, 0x7F, 0xC0, 0x1F, 0xF0, 0x00, 0xFF, 0x80, 0x3F,
-  0xE0, 0x01, 0xFF, 0x00, 0x3F, 0x80, 0x01, 0xFC, 0x00, 0x7F, 0x00, 0x03,
-  0xF8, 0x00, 0xFE, 0x00, 0x07, 0xF0, 0x01, 0xFC, 0x00, 0x0F, 0xE0, 0x03,
-  0xF8, 0x00, 0x1F, 0xC0, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x07, 0xC0, 0x00,
-  0x3E, 0x00, 0x0F, 0x80, 0x00, 0x7C, 0x00, 0x1F, 0x00, 0xFC, 0x00, 0x0F,
-  0xDF, 0xC0, 0x03, 0xF9, 0xF8, 0x00, 0x7E, 0x3F, 0x00, 0x0F, 0xC3, 0xF0,
-  0x03, 0xF0, 0x7E, 0x00, 0x7E, 0x07, 0xE0, 0x0F, 0x80, 0xFC, 0x03, 0xF0,
-  0x1F, 0xC0, 0x7E, 0x01, 0xF8, 0x1F, 0x80, 0x3F, 0x03, 0xF0, 0x03, 0xF0,
-  0x7C, 0x00, 0x7E, 0x1F, 0x80, 0x07, 0xE3, 0xE0, 0x00, 0xFC, 0xFC, 0x00,
-  0x1F, 0xDF, 0x80, 0x01, 0xFB, 0xE0, 0x00, 0x3F, 0xFC, 0x00, 0x03, 0xFF,
-  0x00, 0x00, 0x7F, 0xE0, 0x00, 0x07, 0xF8, 0x00, 0x00, 0xFF, 0x00, 0x00,
-  0x1F, 0xE0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x0F, 0xF0,
-  0x00, 0x03, 0xFE, 0x00, 0x00, 0x7F, 0xE0, 0x00, 0x0F, 0xFC, 0x00, 0x03,
-  0xFF, 0xC0, 0x00, 0x7D, 0xF8, 0x00, 0x1F, 0xBF, 0x00, 0x03, 0xF3, 0xF0,
-  0x00, 0x7C, 0x7E, 0x00, 0x1F, 0x87, 0xE0, 0x03, 0xF0, 0xFC, 0x00, 0xFC,
-  0x1F, 0xC0, 0x1F, 0x81, 0xF8, 0x03, 0xE0, 0x3F, 0x00, 0xFC, 0x03, 0xF0,
-  0x1F, 0x80, 0x7E, 0x07, 0xE0, 0x07, 0xE0, 0xFC, 0x00, 0xFC, 0x1F, 0x80,
-  0x1F, 0xC7, 0xE0, 0x01, 0xF8, 0xFC, 0x00, 0x3F, 0x3F, 0x80, 0x03, 0xF7,
-  0xE0, 0x00, 0x7F, 0xFC, 0x00, 0x0F, 0xFF, 0x80, 0x01, 0xFB, 0xF8, 0x00,
-  0x3F, 0x3F, 0x00, 0x0F, 0xE7, 0xE0, 0x01, 0xF8, 0xFC, 0x00, 0x3F, 0x0F,
-  0xC0, 0x0F, 0xE1, 0xF8, 0x01, 0xF8, 0x3F, 0x00, 0x3F, 0x03, 0xF0, 0x0F,
-  0xE0, 0x7E, 0x01, 0xF8, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x07, 0xE0, 0x1F,
-  0x81, 0xF8, 0x03, 0xF0, 0x3F, 0x00, 0x3F, 0x07, 0xE0, 0x07, 0xE1, 0xF8,
-  0x00, 0xFC, 0x3F, 0x00, 0x0F, 0xC7, 0xE0, 0x01, 0xF9, 0xF8, 0x00, 0x3F,
-  0x3F, 0x00, 0x03, 0xF7, 0xE0, 0x00, 0x7F, 0xF8, 0x00, 0x0F, 0xFF, 0x00,
-  0x00, 0xFF, 0xE0, 0x00, 0x1F, 0xF8, 0x00, 0x03, 0xFF, 0x00, 0x00, 0x3F,
-  0xE0, 0x00, 0x07, 0xF8, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x0F, 0xE0, 0x00,
-  0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFC,
-  0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x7E, 0x00, 0x00,
-  0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x07, 0xE0,
-  0x00, 0x00, 0xFC, 0x00, 0x00, 0x1F, 0x80, 0x00, 0x03, 0xF0, 0x00, 0x00,
-  0x7E, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x01, 0xF8, 0x00, 0x7F, 0xFF, 0xFB,
-  0xFF, 0xFF, 0xDF, 0xFF, 0xFE, 0xFF, 0xFF, 0xF7, 0xFF, 0xFF, 0x80, 0x01,
-  0xF8, 0x00, 0x0F, 0xC0, 0x00, 0xFE, 0x00, 0x07, 0xE0, 0x00, 0x3F, 0x00,
-  0x03, 0xF8, 0x00, 0x1F, 0x80, 0x00, 0xFC, 0x00, 0x0F, 0xE0, 0x00, 0x7E,
-  0x00, 0x07, 0xF0, 0x00, 0x3F, 0x00, 0x01, 0xF8, 0x00, 0x1F, 0xC0, 0x00,
-  0xFC, 0x00, 0x07, 0xE0, 0x00, 0x7F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x80,
-  0x01, 0xF8, 0x00, 0x0F, 0xC0, 0x00, 0xFE, 0x00, 0x07, 0xE0, 0x00, 0x3F,
-  0x00, 0x03, 0xF8, 0x00, 0x1F, 0x80, 0x00, 0xFC, 0x00, 0x0F, 0xC0, 0x00,
-  0x7E, 0x00, 0x07, 0xF0, 0x00, 0x3F, 0x00, 0x01, 0xF8, 0x00, 0x1F, 0xC0,
-  0x00, 0xFC, 0x00, 0x07, 0xE0, 0x00, 0x7F, 0x00, 0x03, 0xF0, 0x00, 0x3F,
-  0x80, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x7E,
-  0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0, 0x3F, 0x01, 0xF8, 0x0F, 0xC0,
-  0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0, 0x3F, 0x01, 0xF8, 0x0F,
-  0xC0, 0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0, 0x3F, 0x01, 0xF8,
-  0x0F, 0xC0, 0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0, 0x3F, 0x01,
-  0xF8, 0x0F, 0xC0, 0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0, 0x3F,
-  0x01, 0xF8, 0x0F, 0xC0, 0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFC, 0x07, 0xE0,
-  0x3F, 0x01, 0xF8, 0x0F, 0xC0, 0x7E, 0x03, 0xF0, 0x1F, 0x80, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFE, 0xF8, 0x00, 0x3E, 0x00, 0x0F, 0xC0, 0x01, 0xF0, 0x00,
-  0x7C, 0x00, 0x1F, 0x00, 0x07, 0xE0, 0x00, 0xF8, 0x00, 0x3E, 0x00, 0x0F,
-  0xC0, 0x03, 0xF0, 0x00, 0x7C, 0x00, 0x1F, 0x00, 0x07, 0xE0, 0x01, 0xF8,
-  0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, 0xF0, 0x00, 0x7C, 0x00, 0x1F, 0x00,
-  0x07, 0xE0, 0x01, 0xF8, 0x00, 0x3E, 0x00, 0x0F, 0x80, 0x03, 0xF0, 0x00,
-  0xFC, 0x00, 0x1F, 0x00, 0x07, 0xC0, 0x01, 0xF8, 0x00, 0x3E, 0x00, 0x0F,
-  0x80, 0x03, 0xF0, 0x00, 0xFC, 0x00, 0x1F, 0x00, 0x07, 0xC0, 0x01, 0xF8,
-  0x00, 0x7E, 0x00, 0x0F, 0x80, 0x03, 0xE0, 0x00, 0xFC, 0x00, 0x3F, 0x00,
-  0x07, 0xC0, 0x01, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0x80, 0x03, 0xE0, 0x00,
-  0xFC, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x3F, 0x81,
-  0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F, 0xC0, 0xFE, 0x07, 0xF0, 0x3F,
-  0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F, 0xC0, 0xFE, 0x07, 0xF0,
-  0x3F, 0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F, 0xC0, 0xFE, 0x07,
-  0xF0, 0x3F, 0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F, 0xC0, 0xFE,
-  0x07, 0xF0, 0x3F, 0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F, 0xC0,
-  0xFE, 0x07, 0xF0, 0x3F, 0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0x03, 0xF8, 0x1F,
-  0xC0, 0xFE, 0x07, 0xF0, 0x3F, 0x81, 0xFC, 0x0F, 0xE0, 0x7F, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFE, 0x00, 0xFC, 0x00, 0x07, 0xF8, 0x00, 0x1F, 0xE0, 0x00,
-  0x7F, 0x80, 0x03, 0xFF, 0x00, 0x0F, 0xFC, 0x00, 0x7E, 0xF8, 0x01, 0xF3,
-  0xE0, 0x07, 0xCF, 0xC0, 0x3E, 0x1F, 0x00, 0xF8, 0x7C, 0x07, 0xE1, 0xF8,
-  0x1F, 0x03, 0xE0, 0xFC, 0x0F, 0xC3, 0xF0, 0x3F, 0x0F, 0x80, 0x7C, 0x7E,
-  0x01, 0xF9, 0xF8, 0x07, 0xEF, 0xC0, 0x0F, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xFE, 0x1F, 0x87,
-  0xE0, 0xFC, 0x1F, 0x07, 0xC0, 0xF0, 0x3E, 0x07, 0x81, 0xE0, 0x3C, 0x07,
-  0x03, 0xFF, 0x00, 0x7F, 0xFC, 0x07, 0xFF, 0xF0, 0x7F, 0xFF, 0xC3, 0xF8,
-  0xFE, 0x3F, 0x83, 0xF9, 0xF8, 0x0F, 0xCF, 0xC0, 0x7E, 0x7E, 0x03, 0xF3,
-  0xF0, 0x1F, 0x9F, 0x80, 0xFC, 0x00, 0x07, 0xE0, 0x00, 0x3F, 0x00, 0x07,
-  0xF8, 0x00, 0xFF, 0xC0, 0x1F, 0xFE, 0x03, 0xFF, 0xF0, 0x3F, 0x9F, 0x87,
-  0xF8, 0xFC, 0x3F, 0x07, 0xE3, 0xF0, 0x3F, 0x3F, 0x81, 0xF9, 0xF8, 0x0F,
-  0xCF, 0xC0, 0x7E, 0x7E, 0x03, 0xF7, 0xF0, 0x1F, 0xBF, 0x80, 0xFC, 0xFC,
-  0x0F, 0xE7, 0xF0, 0xFF, 0x3F, 0xFF, 0xF9, 0xFF, 0xFF, 0xC7, 0xFF, 0x3E,
-  0x1F, 0xF1, 0xF8, 0x7F, 0x0F, 0xC0, 0xFE, 0x00, 0x07, 0xF0, 0x00, 0x3F,
-  0x80, 0x01, 0xFC, 0x00, 0x0F, 0xE0, 0x00, 0x7F, 0x00, 0x03, 0xF8, 0x00,
-  0x1F, 0xC0, 0x00, 0xFE, 0x00, 0x07, 0xF0, 0x00, 0x3F, 0x80, 0x01, 0xFC,
-  0x00, 0x0F, 0xE0, 0x00, 0x7F, 0x00, 0x03, 0xF9, 0xFE, 0x1F, 0xDF, 0xF8,
-  0xFF, 0xFF, 0xE7, 0xFF, 0xFF, 0x3F, 0xFF, 0xFD, 0xFE, 0x0F, 0xEF, 0xE0,
-  0x3F, 0x7F, 0x01, 0xFB, 0xF8, 0x0F, 0xDF, 0xC0, 0x7F, 0xFE, 0x03, 0xFF,
-  0xF0, 0x1F, 0xFF, 0x80, 0xFF, 0xFC, 0x07, 0xFF, 0xE0, 0x3F, 0xFF, 0x01,
-  0xFF, 0xF8, 0x0F, 0xFF, 0xC0, 0x7F, 0xFE, 0x03, 0xFF, 0xF0, 0x1F, 0xFF,
-  0x80, 0xFF, 0xFC, 0x07, 0xFF, 0xE0, 0x3F, 0xFF, 0x01, 0xFF, 0xF8, 0x0F,
-  0xFF, 0xC0, 0x7E, 0xFE, 0x03, 0xF7, 0xF0, 0x1F, 0xBF, 0x81, 0xFD, 0xFF,
-  0xFF, 0xCF, 0xFF, 0xFE, 0x7F, 0xFF, 0xE3, 0xFB, 0xFF, 0x1F, 0xCF, 0xE0,
-  0x0F, 0xFE, 0x03, 0xFF, 0xE0, 0xFF, 0xFE, 0x3F, 0xFF, 0xE7, 0xF1, 0xFD,
-  0xFC, 0x1F, 0xBF, 0x01, 0xF7, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x80, 0xFF,
-  0xF0, 0x1F, 0xFE, 0x03, 0xFF, 0xC0, 0x01, 0xF8, 0x00, 0x3F, 0x00, 0x07,
-  0xE0, 0x00, 0xFC, 0x00, 0x1F, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F,
-  0xC0, 0x01, 0xF8, 0x0F, 0xFF, 0x01, 0xFF, 0xE0, 0x3F, 0xFC, 0x07, 0xFF,
-  0x80, 0xFF, 0xF0, 0x1F, 0xFE, 0x03, 0xEF, 0xE0, 0xFC, 0xFE, 0x3F, 0x9F,
-  0xFF, 0xF1, 0xFF, 0xFC, 0x1F, 0xFF, 0x01, 0xFF, 0xC0, 0x00, 0x03, 0xF0,
-  0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F,
-  0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03,
-  0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x0F, 0xE3, 0xF1, 0xFF,
-  0xBF, 0x3F, 0xFF, 0xF7, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xE0, 0x7F, 0xFE,
-  0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF,
-  0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F,
-  0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03,
-  0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0,
-  0x3F, 0xFC, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x07, 0xF7, 0xFB, 0xFF, 0x7F,
-  0xFF, 0xF3, 0xFF, 0xFF, 0x1F, 0xFB, 0xF0, 0xFE, 0x3F, 0x07, 0xFE, 0x03,
-  0xFF, 0xE0, 0xFF, 0xFE, 0x3F, 0xFF, 0xE7, 0xF1, 0xFD, 0xFC, 0x1F, 0xBF,
-  0x01, 0xFF, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x80, 0xFF, 0xF0, 0x1F, 0xFE,
-  0x03, 0xFF, 0xC0, 0x7F, 0xF8, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0x80, 0x03, 0xF0, 0x00, 0x7E, 0x00, 0x0F, 0xC0, 0x01, 0xF8,
-  0x00, 0x3F, 0x01, 0xFF, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x80, 0xFF, 0xF0,
-  0x1F, 0xFE, 0x03, 0xFF, 0xE0, 0xFC, 0xFE, 0x3F, 0x9F, 0xFF, 0xF1, 0xFF,
-  0xFC, 0x1F, 0xFF, 0x01, 0xFF, 0xC0, 0x00, 0xFF, 0x01, 0xFF, 0x03, 0xFF,
-  0x07, 0xFF, 0x07, 0xFF, 0x07, 0xE0, 0x0F, 0xE0, 0x0F, 0xE0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0,
-  0x0F, 0xC0, 0x00, 0x00, 0x01, 0x00, 0xFF, 0x83, 0x81, 0xFF, 0xE3, 0xE1,
-  0xFF, 0xFB, 0xF1, 0xFF, 0xFF, 0xF8, 0xFC, 0x3F, 0xE0, 0xFC, 0x0F, 0xC0,
-  0x7E, 0x03, 0xE0, 0x3E, 0x01, 0xF0, 0x1F, 0x00, 0xF8, 0x0F, 0x80, 0x7C,
-  0x07, 0xC0, 0x3E, 0x03, 0xE0, 0x1F, 0x81, 0xF0, 0x0F, 0xC0, 0xF8, 0x07,
-  0xE0, 0x7C, 0x03, 0xE0, 0x3E, 0x01, 0xF0, 0x1F, 0x80, 0xF8, 0x0F, 0xC0,
-  0xFC, 0x03, 0xF0, 0x7C, 0x01, 0xFF, 0xFE, 0x00, 0x7F, 0xFE, 0x00, 0x1F,
-  0xFF, 0x00, 0x0F, 0xFE, 0x00, 0x0F, 0x30, 0x00, 0x0F, 0x00, 0x00, 0x0F,
-  0x80, 0x00, 0x07, 0xC0, 0x00, 0x03, 0xFF, 0x00, 0x01, 0xFF, 0xFE, 0x00,
-  0xFF, 0xFF, 0xC0, 0x3F, 0xFF, 0xF0, 0x07, 0xFF, 0xFC, 0x0F, 0x9F, 0xFE,
-  0x0F, 0x80, 0x3F, 0x8F, 0x80, 0x07, 0xC7, 0xC0, 0x03, 0xE7, 0xC0, 0x01,
-  0xF3, 0xF0, 0x00, 0xF9, 0xF8, 0x00, 0xFC, 0xFF, 0xC7, 0xFC, 0x3F, 0xFF,
-  0xFE, 0x1F, 0xFF, 0xFE, 0x07, 0xFF, 0xFE, 0x00, 0xFF, 0xFC, 0x00, 0x01,
-  0x00, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00,
-  0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00,
-  0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0, 0x00, 0xFE, 0x00, 0x0F, 0xE0,
-  0x00, 0xFE, 0x1F, 0xCF, 0xE7, 0xFE, 0xFE, 0xFF, 0xEF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xF0, 0x7F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF,
-  0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F,
-  0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03,
-  0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0,
-  0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE,
-  0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x03, 0xFF,
-  0xE0, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xF0, 0x07, 0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07,
-  0xE0, 0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0,
-  0xFC, 0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xFC,
-  0x1F, 0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xFC, 0x1F,
-  0x83, 0xF0, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x0F, 0xE3, 0xFF, 0xFF, 0xFF,
-  0xEF, 0xF9, 0xFE, 0x1C, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0,
-  0x00, 0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00,
-  0x3F, 0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x00, 0x3F,
-  0x80, 0x00, 0xFE, 0x00, 0x03, 0xF8, 0x00, 0x0F, 0xE0, 0x1F, 0xFF, 0x80,
-  0x7E, 0xFE, 0x03, 0xFB, 0xF8, 0x0F, 0xCF, 0xE0, 0x7F, 0x3F, 0x83, 0xF8,
-  0xFE, 0x0F, 0xC3, 0xF8, 0x7F, 0x0F, 0xE3, 0xF8, 0x3F, 0x8F, 0xE0, 0xFE,
-  0x7F, 0x03, 0xF9, 0xF8, 0x0F, 0xEF, 0xE0, 0x3F, 0xFF, 0x00, 0xFF, 0xFE,
-  0x03, 0xFF, 0xF8, 0x0F, 0xFF, 0xF0, 0x3F, 0xEF, 0xC0, 0xFF, 0x3F, 0x03,
-  0xFC, 0x7E, 0x0F, 0xE1, 0xF8, 0x3F, 0x87, 0xE0, 0xFE, 0x0F, 0xC3, 0xF8,
-  0x3F, 0x0F, 0xE0, 0xFE, 0x3F, 0x81, 0xF8, 0xFE, 0x07, 0xE3, 0xF8, 0x1F,
-  0xCF, 0xE0, 0x3F, 0x3F, 0x80, 0xFC, 0xFE, 0x01, 0xFB, 0xF8, 0x07, 0xEF,
-  0xE0, 0x1F, 0xFF, 0x80, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x04, 0x00, 0x10, 0x3F, 0x0F, 0xF0,
-  0x7F, 0x8F, 0xCF, 0xFE, 0x3F, 0xF3, 0xF7, 0xFF, 0x9F, 0xFE, 0xFF, 0xFF,
-  0xEF, 0xFF, 0xBF, 0xC1, 0xFF, 0x07, 0xFF, 0xE0, 0x3F, 0x80, 0xFF, 0xF0,
-  0x0F, 0xC0, 0x3F, 0xFC, 0x03, 0xF0, 0x0F, 0xFF, 0x00, 0xFC, 0x03, 0xFF,
-  0xC0, 0x3F, 0x00, 0xFF, 0xF0, 0x0F, 0xC0, 0x3F, 0xFC, 0x03, 0xF0, 0x0F,
-  0xFF, 0x00, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0x00, 0xFF, 0xF0, 0x0F, 0xC0,
-  0x3F, 0xFC, 0x03, 0xF0, 0x0F, 0xFF, 0x00, 0xFC, 0x03, 0xFF, 0xC0, 0x3F,
-  0x00, 0xFF, 0xF0, 0x0F, 0xC0, 0x3F, 0xFC, 0x03, 0xF0, 0x0F, 0xFF, 0x00,
-  0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0x00, 0xFF, 0xF0, 0x0F, 0xC0, 0x3F, 0xFC,
-  0x03, 0xF0, 0x0F, 0xFF, 0x00, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0x00, 0xFF,
-  0xF0, 0x0F, 0xC0, 0x3F, 0xFC, 0x03, 0xF0, 0x0F, 0xFF, 0x00, 0xFC, 0x03,
-  0xFF, 0xC0, 0x3F, 0x00, 0xFF, 0xF0, 0x0F, 0xC0, 0x3F, 0xFC, 0x03, 0xF0,
-  0x0F, 0xFF, 0x00, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0x00, 0xFC, 0xFC, 0x1F,
-  0xCF, 0xC7, 0xFE, 0xFD, 0xFF, 0xEF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xF0,
-  0x7F, 0xFE, 0x07, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC,
-  0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF,
-  0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F,
-  0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03,
-  0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0,
-  0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0x07,
-  0xFC, 0x03, 0xFF, 0xE0, 0xFF, 0xFE, 0x3F, 0xFF, 0xE7, 0xF1, 0xFD, 0xFC,
-  0x1F, 0xBF, 0x01, 0xFF, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x80, 0xFF, 0xF0,
-  0x1F, 0xFE, 0x03, 0xFF, 0xC0, 0x7F, 0xF8, 0x0F, 0xFF, 0x01, 0xFF, 0xE0,
-  0x3F, 0xFC, 0x07, 0xFF, 0x80, 0xFF, 0xF0, 0x1F, 0xFE, 0x03, 0xFF, 0xC0,
-  0x7F, 0xF8, 0x0F, 0xFF, 0x01, 0xFF, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x80,
-  0xFF, 0xF0, 0x1F, 0xFE, 0x03, 0xFF, 0xE0, 0xFE, 0xFE, 0x3F, 0x9F, 0xFF,
-  0xF1, 0xFF, 0xFC, 0x1F, 0xFF, 0x01, 0xFF, 0x80, 0xFC, 0x7F, 0x07, 0xE7,
-  0xFE, 0x3F, 0x7F, 0xF1, 0xFF, 0xFF, 0xCF, 0xFF, 0xFE, 0x7F, 0x83, 0xFB,
-  0xF0, 0x0F, 0xDF, 0x80, 0x7E, 0xFC, 0x03, 0xF7, 0xE0, 0x1F, 0xFF, 0x00,
-  0xFF, 0xF8, 0x07, 0xFF, 0xC0, 0x3F, 0xFE, 0x01, 0xFF, 0xF0, 0x0F, 0xFF,
-  0x80, 0x7F, 0xFC, 0x03, 0xFF, 0xE0, 0x1F, 0xFF, 0x00, 0xFF, 0xF8, 0x07,
-  0xFF, 0xC0, 0x3F, 0xFE, 0x01, 0xFF, 0xF0, 0x0F, 0xFF, 0x80, 0x7F, 0xFC,
-  0x03, 0xF7, 0xE0, 0x1F, 0xBF, 0x00, 0xFD, 0xF8, 0x07, 0xEF, 0xE0, 0x7F,
-  0x7F, 0xFF, 0xF3, 0xFF, 0xFF, 0x9F, 0xFF, 0xF8, 0xFC, 0xFF, 0x87, 0xE3,
-  0xF8, 0x3F, 0x00, 0x01, 0xF8, 0x00, 0x0F, 0xC0, 0x00, 0x7E, 0x00, 0x03,
-  0xF0, 0x00, 0x1F, 0x80, 0x00, 0xFC, 0x00, 0x07, 0xE0, 0x00, 0x3F, 0x00,
-  0x01, 0xF8, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x0F, 0xE3, 0xF1, 0xFF, 0xBF,
-  0x3F, 0xFF, 0xF7, 0xFF, 0xFF, 0x7F, 0xFF, 0xF7, 0xE0, 0x7F, 0xFE, 0x03,
-  0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0,
-  0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC,
-  0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF,
-  0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F, 0xFC, 0x03, 0xFF, 0xC0, 0x3F,
-  0xFC, 0x03, 0xFF, 0xE0, 0x3F, 0xFE, 0x07, 0xF7, 0xFF, 0xFF, 0x7F, 0xFF,
-  0xF3, 0xFF, 0xFF, 0x1F, 0xFB, 0xF0, 0xFF, 0x3F, 0x00, 0x03, 0xF0, 0x00,
-  0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00,
-  0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0, 0x00, 0x3F, 0x00, 0x03, 0xF0,
-  0xFE, 0x1F, 0xFC, 0xFF, 0xFB, 0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xE0, 0xFF, 0x80, 0xFE, 0x01, 0xFC, 0x03, 0xF8, 0x07, 0xF0, 0x0F, 0xE0,
-  0x1F, 0xC0, 0x3F, 0x80, 0x7F, 0x00, 0xFE, 0x01, 0xFC, 0x03, 0xF8, 0x07,
-  0xF0, 0x0F, 0xE0, 0x1F, 0xC0, 0x3F, 0x80, 0x7F, 0x00, 0xFE, 0x01, 0xFC,
-  0x03, 0xF8, 0x07, 0xF0, 0x0F, 0xE0, 0x1F, 0xC0, 0x3F, 0x80, 0x7F, 0x00,
-  0xFE, 0x01, 0xFC, 0x00, 0x03, 0xFC, 0x01, 0xFF, 0xE0, 0x7F, 0xFC, 0x1F,
-  0xFF, 0xC3, 0xF8, 0xFC, 0x7E, 0x0F, 0x9F, 0x80, 0xF3, 0xF0, 0x1F, 0x7E,
-  0x03, 0xEF, 0xC0, 0x60, 0xFC, 0x00, 0x1F, 0xC0, 0x03, 0xFC, 0x00, 0x3F,
-  0xC0, 0x03, 0xFC, 0x00, 0x3F, 0xC0, 0x03, 0xFE, 0x00, 0x3F, 0xE0, 0x03,
-  0xFC, 0x00, 0x3F, 0xC0, 0x03, 0xFC, 0x00, 0x1F, 0xC0, 0x01, 0xF8, 0x20,
-  0x3F, 0x3C, 0x03, 0xFF, 0x80, 0x7D, 0xF0, 0x0F, 0xBF, 0x01, 0xF7, 0xF0,
-  0x7E, 0x7F, 0x1F, 0xCF, 0xFF, 0xF0, 0xFF, 0xFE, 0x0F, 0xFF, 0x80, 0x7F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F,
-  0xC0, 0x0F, 0xC0, 0x0F, 0xC0, 0x0F, 0xE0, 0x0F, 0xF1, 0x07, 0xFF, 0x07,
-  0xFF, 0x03, 0xFF, 0x01, 0xFF, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07,
-  0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0,
-  0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC,
-  0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF,
-  0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F,
-  0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07, 0xFF, 0xC0, 0x7F, 0xFC, 0x07,
-  0xFF, 0xC0, 0x7F, 0xFE, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xFF,
-  0x7F, 0x7F, 0xE7, 0xF3, 0xF8, 0x7F, 0xFC, 0x01, 0xFF, 0xE0, 0x1F, 0xBF,
-  0x80, 0xFC, 0xFC, 0x07, 0xE7, 0xE0, 0x3F, 0x3F, 0x01, 0xF9, 0xF8, 0x0F,
-  0xCF, 0xC0, 0xFC, 0x3F, 0x07, 0xE1, 0xF8, 0x3F, 0x0F, 0xC1, 0xF8, 0x7E,
-  0x0F, 0xC3, 0xF0, 0x7C, 0x0F, 0x83, 0xE0, 0x7C, 0x3F, 0x03, 0xF1, 0xF8,
-  0x1F, 0x8F, 0xC0, 0xFC, 0x7C, 0x03, 0xE3, 0xE0, 0x1F, 0x1F, 0x00, 0xF9,
-  0xF8, 0x07, 0xCF, 0xC0, 0x3F, 0x7C, 0x00, 0xFB, 0xE0, 0x07, 0xDF, 0x00,
-  0x3E, 0xF8, 0x01, 0xF7, 0xC0, 0x0F, 0xFE, 0x00, 0x7F, 0xE0, 0x01, 0xFF,
-  0x00, 0x0F, 0xF8, 0x00, 0x7F, 0xC0, 0x03, 0xFE, 0x00, 0x1F, 0xE0, 0x00,
-  0xF8, 0x07, 0xC0, 0x3F, 0xF0, 0x0F, 0x80, 0x7F, 0xE0, 0x3F, 0x01, 0xFF,
-  0xC0, 0x7E, 0x03, 0xEF, 0x80, 0xFC, 0x07, 0xCF, 0x81, 0xFC, 0x0F, 0x9F,
-  0x03, 0xF8, 0x1F, 0x3E, 0x0F, 0xF0, 0x3E, 0x7C, 0x1F, 0xE0, 0x7C, 0xF8,
-  0x3F, 0xC1, 0xF1, 0xF0, 0x7F, 0xC3, 0xE3, 0xE0, 0xF7, 0x87, 0xC3, 0xE1,
-  0xEF, 0x0F, 0x87, 0xC7, 0xDE, 0x1F, 0x0F, 0x8F, 0x3C, 0x3E, 0x1F, 0x1E,
-  0x78, 0x78, 0x3E, 0x3C, 0x79, 0xF0, 0x7C, 0x78, 0xF3, 0xE0, 0x78, 0xF1,
-  0xE7, 0xC0, 0xFB, 0xE3, 0xCF, 0x81, 0xF7, 0x87, 0x9F, 0x03, 0xEF, 0x07,
-  0xBC, 0x07, 0xDE, 0x0F, 0x78, 0x0F, 0xBC, 0x1F, 0xF0, 0x0F, 0xF8, 0x3F,
-  0xE0, 0x1F, 0xE0, 0x7F, 0xC0, 0x3F, 0xC0, 0x7F, 0x80, 0x7F, 0x80, 0xFE,
-  0x00, 0xFF, 0x01, 0xFC, 0x01, 0xFE, 0x03, 0xF8, 0x01, 0xF8, 0x07, 0xF0,
-  0x03, 0xF0, 0x0F, 0xE0, 0x07, 0xE0, 0x0F, 0xC0, 0x0F, 0xC0, 0x1F, 0x00,
-  0xFC, 0x01, 0xFF, 0xE0, 0x1F, 0xDF, 0x80, 0xFC, 0xFC, 0x07, 0xE3, 0xF0,
-  0x7E, 0x1F, 0x83, 0xF0, 0x7E, 0x3F, 0x03, 0xF1, 0xF8, 0x0F, 0xCF, 0x80,
-  0x7E, 0xFC, 0x01, 0xFF, 0xC0, 0x0F, 0xFE, 0x00, 0x7F, 0xF0, 0x01, 0xFF,
-  0x00, 0x0F, 0xF8, 0x00, 0x3F, 0x80, 0x01, 0xFC, 0x00, 0x0F, 0xE0, 0x00,
-  0xFF, 0x00, 0x07, 0xFC, 0x00, 0x7F, 0xE0, 0x03, 0xFF, 0x80, 0x3F, 0xFC,
-  0x01, 0xFB, 0xF0, 0x0F, 0x9F, 0x80, 0xFC, 0xFC, 0x07, 0xC3, 0xF0, 0x7E,
-  0x1F, 0x83, 0xF0, 0x7E, 0x3F, 0x03, 0xF1, 0xF8, 0x0F, 0xCF, 0x80, 0x7E,
-  0xFC, 0x01, 0xFF, 0xE0, 0x0F, 0xC0, 0xFC, 0x01, 0xFF, 0xE0, 0x0F, 0xFF,
-  0x00, 0x7E, 0xFC, 0x07, 0xF7, 0xE0, 0x3F, 0x3F, 0x01, 0xF9, 0xF8, 0x0F,
-  0xCF, 0xC0, 0x7E, 0x3F, 0x03, 0xE1, 0xF8, 0x3F, 0x0F, 0xC1, 0xF8, 0x7E,
-  0x0F, 0xC1, 0xF0, 0x7E, 0x0F, 0x83, 0xE0, 0x7E, 0x1F, 0x03, 0xF1, 0xF8,
-  0x0F, 0x8F, 0xC0, 0x7C, 0x7C, 0x03, 0xE3, 0xE0, 0x1F, 0x9F, 0x00, 0x7D,
-  0xF8, 0x03, 0xEF, 0xC0, 0x1F, 0x7C, 0x00, 0xFB, 0xE0, 0x07, 0xDF, 0x00,
-  0x1F, 0xF8, 0x00, 0xFF, 0x80, 0x07, 0xFC, 0x00, 0x3F, 0xE0, 0x00, 0xFF,
-  0x00, 0x07, 0xF8, 0x00, 0x3F, 0x80, 0x01, 0xFC, 0x00, 0x07, 0xE0, 0x00,
-  0x3F, 0x00, 0x01, 0xF0, 0x00, 0x1F, 0x80, 0x03, 0xFC, 0x00, 0xFF, 0xC0,
-  0x07, 0xFE, 0x00, 0x3F, 0xE0, 0x01, 0xFC, 0x00, 0x0C, 0x00, 0x00, 0x7F,
-  0xFF, 0xBF, 0xFF, 0xDF, 0xFF, 0xEF, 0xFF, 0xF7, 0xFF, 0xF8, 0x01, 0xF8,
-  0x00, 0xFC, 0x00, 0xFC, 0x00, 0x7E, 0x00, 0x7F, 0x00, 0x3F, 0x00, 0x3F,
-  0x80, 0x1F, 0x80, 0x0F, 0xC0, 0x0F, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x03,
-  0xF0, 0x01, 0xF8, 0x01, 0xFC, 0x00, 0xFC, 0x00, 0xFE, 0x00, 0x7E, 0x00,
-  0x7F, 0x00, 0x3F, 0x80, 0x1F, 0x80, 0x1F, 0xC0, 0x0F, 0xC0, 0x0F, 0xE0,
-  0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0,
-  0x00, 0xFC, 0x0F, 0xF0, 0x7F, 0xC3, 0xFF, 0x0F, 0xFC, 0x3F, 0x80, 0xFE,
-  0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F,
-  0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F,
-  0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x7F, 0x01, 0xFC, 0x3F,
-  0xE0, 0xFF, 0x03, 0xF8, 0x0F, 0xF0, 0x3F, 0xE0, 0x1F, 0xC0, 0x7F, 0x00,
-  0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0,
-  0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0,
-  0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xE0, 0x3F, 0x80, 0xFF,
-  0x83, 0xFF, 0x07, 0xFC, 0x0F, 0xF0, 0x1F, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-  0xFF, 0xFF, 0xFC, 0xFC, 0x03, 0xFC, 0x0F, 0xF8, 0x3F, 0xE0, 0xFF, 0xC0,
-  0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0,
-  0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC,
-  0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F,
-  0x80, 0xFE, 0x01, 0xFF, 0x07, 0xFC, 0x07, 0xF0, 0x3F, 0xC1, 0xFF, 0x0F,
-  0xE0, 0x3F, 0x80, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03,
-  0xF0, 0x0F, 0xC0, 0x3F, 0x00, 0xFC, 0x03, 0xF0, 0x0F, 0xC0, 0x3F, 0x00,
-  0xFC, 0x07, 0xF0, 0x1F, 0xC0, 0x7F, 0x01, 0xFC, 0x07, 0xF0, 0x1F, 0xC0,
-  0x7F, 0x0F, 0xFC, 0x3F, 0xE0, 0xFF, 0x83, 0xFC, 0x0F, 0xE0, 0x00, 0x03,
-  0x80, 0x00, 0x3F, 0x80, 0x43, 0xFF, 0x83, 0x9F, 0xFF, 0xBF, 0xFF, 0xFF,
-  0xFD, 0xF3, 0xFF, 0xE7, 0x03, 0xFF, 0x08, 0x03, 0xF0, 0x00, 0x03, 0x80 };
-
-const GFXglyph Oswald_Regular30pt7bGlyphs[] PROGMEM = {
-  {     0,   1,   1,  13,    0,    0 },   // 0x20 ' '
-  {     1,   6,  48,  12,    3,  -47 },   // 0x21 '!'
-  {    37,  14,  15,  16,    1,  -47 },   // 0x22 '"'
-  {    64,  25,  48,  29,    2,  -47 },   // 0x23 '#'
-  {   214,  24,  57,  29,    2,  -51 },   // 0x24 '$'
-  {   385,  48,  48,  52,    2,  -47 },   // 0x25 '%'
-  {   673,  29,  49,  36,    3,  -47 },   // 0x26 '&'
-  {   851,   6,  15,   7,    1,  -47 },   // 0x27 '''
-  {   863,  12,  59,  18,    4,  -47 },   // 0x28 '('
-  {   952,  11,  59,  15,    2,  -47 },   // 0x29 ')'
-  {  1034,  19,  20,  23,    3,  -47 },   // 0x2A '*'
-  {  1082,  22,  24,  24,    1,  -35 },   // 0x2B '+'
-  {  1148,   7,  15,  11,    2,   -6 },   // 0x2C ','
-  {  1162,  13,   5,  19,    3,  -19 },   // 0x2D '-'
-  {  1171,   6,   7,  11,    3,   -6 },   // 0x2E '.'
-  {  1177,  18,  48,  22,    2,  -47 },   // 0x2F '/'
-  {  1285,  24,  49,  30,    3,  -47 },   // 0x30 '0'
-  {  1432,  14,  48,  23,    2,  -47 },   // 0x31 '1'
-  {  1516,  24,  48,  28,    2,  -47 },   // 0x32 '2'
-  {  1660,  24,  49,  28,    2,  -47 },   // 0x33 '3'
-  {  1807,  26,  48,  28,    2,  -47 },   // 0x34 '4'
-  {  1963,  23,  48,  28,    3,  -47 },   // 0x35 '5'
-  {  2101,  24,  49,  30,    3,  -47 },   // 0x36 '6'
-  {  2248,  19,  48,  23,    1,  -47 },   // 0x37 '7'
-  {  2362,  23,  49,  29,    3,  -47 },   // 0x38 '8'
-  {  2503,  23,  49,  30,    3,  -47 },   // 0x39 '9'
-  {  2644,   6,  25,  12,    4,  -30 },   // 0x3A ':'
-  {  2663,   7,  36,  13,    3,  -32 },   // 0x3B ';'
-  {  2695,  17,  30,  22,    2,  -31 },   // 0x3C '<'
-  {  2759,  18,  16,  24,    3,  -31 },   // 0x3D '='
-  {  2795,  17,  30,  22,    3,  -31 },   // 0x3E '>'
-  {  2859,  23,  48,  29,    3,  -47 },   // 0x3F '?'
-  {  2997,  48,  56,  53,    3,  -47 },   // 0x40 '@'
-  {  3333,  27,  48,  29,    1,  -47 },   // 0x41 'A'
-  {  3495,  25,  48,  31,    4,  -47 },   // 0x42 'B'
-  {  3645,  25,  49,  30,    3,  -47 },   // 0x43 'C'
-  {  3799,  24,  48,  31,    4,  -47 },   // 0x44 'D'
-  {  3943,  18,  48,  24,    4,  -47 },   // 0x45 'E'
-  {  4051,  18,  48,  23,    4,  -47 },   // 0x46 'F'
-  {  4159,  25,  49,  31,    3,  -47 },   // 0x47 'G'
-  {  4313,  25,  48,  33,    4,  -47 },   // 0x48 'H'
-  {  4463,   7,  48,  15,    4,  -47 },   // 0x49 'I'
-  {  4505,  14,  49,  18,    0,  -47 },   // 0x4A 'J'
-  {  4591,  25,  48,  29,    4,  -47 },   // 0x4B 'K'
-  {  4741,  19,  48,  23,    4,  -47 },   // 0x4C 'L'
-  {  4855,  31,  48,  39,    4,  -47 },   // 0x4D 'M'
-  {  5041,  23,  48,  31,    4,  -47 },   // 0x4E 'N'
-  {  5179,  26,  49,  32,    3,  -47 },   // 0x4F 'O'
-  {  5339,  23,  48,  28,    4,  -47 },   // 0x50 'P'
-  {  5477,  26,  58,  32,    3,  -47 },   // 0x51 'Q'
-  {  5666,  24,  48,  30,    4,  -47 },   // 0x52 'R'
-  {  5810,  24,  49,  28,    2,  -47 },   // 0x53 'S'
-  {  5957,  22,  48,  24,    1,  -47 },   // 0x54 'T'
-  {  6089,  26,  49,  32,    3,  -47 },   // 0x55 'U'
-  {  6249,  27,  48,  30,    1,  -47 },   // 0x56 'V'
-  {  6411,  39,  48,  43,    2,  -47 },   // 0x57 'W'
-  {  6645,  27,  48,  28,    1,  -47 },   // 0x58 'X'
-  {  6807,  27,  48,  28,    1,  -47 },   // 0x59 'Y'
-  {  6969,  21,  48,  25,    2,  -47 },   // 0x5A 'Z'
-  {  7095,  13,  59,  20,    4,  -47 },   // 0x5B '['
-  {  7191,  18,  48,  22,    2,  -47 },   // 0x5C '\'
-  {  7299,  13,  59,  18,    2,  -47 },   // 0x5D ']'
-  {  7395,  22,  19,  26,    2,  -47 },   // 0x5E '^'
-  {  7448,  20,   5,  20,    0,    4 },   // 0x5F '_'
-  {  7461,  10,  12,  16,    3,  -47 },   // 0x60 '`'
-  {  7476,  21,  34,  25,    2,  -33 },   // 0x61 'a'
-  {  7566,  21,  48,  26,    3,  -47 },   // 0x62 'b'
-  {  7692,  19,  34,  24,    3,  -33 },   // 0x63 'c'
-  {  7773,  20,  48,  26,    3,  -47 },   // 0x64 'd'
-  {  7893,  19,  34,  25,    3,  -33 },   // 0x65 'e'
-  {  7974,  16,  46,  17,    1,  -45 },   // 0x66 'f'
-  {  8066,  25,  46,  26,    1,  -34 },   // 0x67 'g'
-  {  8210,  20,  48,  26,    3,  -47 },   // 0x68 'h'
-  {  8330,   6,  46,  13,    4,  -45 },   // 0x69 'i'
-  {  8365,  11,  55,  14,   -1,  -45 },   // 0x6A 'j'
-  {  8441,  22,  48,  25,    3,  -47 },   // 0x6B 'k'
-  {  8573,   6,  48,  13,    4,  -47 },   // 0x6C 'l'
-  {  8609,  34,  35,  40,    3,  -34 },   // 0x6D 'm'
-  {  8758,  20,  34,  26,    3,  -33 },   // 0x6E 'n'
-  {  8843,  19,  34,  25,    3,  -33 },   // 0x6F 'o'
-  {  8924,  21,  45,  26,    3,  -33 },   // 0x70 'p'
-  {  9043,  20,  45,  26,    3,  -33 },   // 0x71 'q'
-  {  9156,  15,  34,  19,    3,  -33 },   // 0x72 'r'
-  {  9220,  19,  34,  22,    1,  -33 },   // 0x73 's'
-  {  9301,  16,  44,  18,    1,  -43 },   // 0x74 't'
-  {  9389,  20,  34,  26,    3,  -33 },   // 0x75 'u'
-  {  9474,  21,  34,  23,    1,  -33 },   // 0x76 'v'
-  {  9564,  31,  34,  35,    2,  -33 },   // 0x77 'w'
-  {  9696,  21,  34,  23,    1,  -33 },   // 0x78 'x'
-  {  9786,  21,  43,  23,    1,  -33 },   // 0x79 'y'
-  {  9899,  17,  34,  20,    2,  -33 },   // 0x7A 'z'
-  {  9972,  14,  59,  18,    2,  -47 },   // 0x7B '{'
-  { 10076,   6,  57,  14,    4,  -47 },   // 0x7C '|'
-  { 10119,  14,  59,  19,    3,  -47 },   // 0x7D '}'
-  { 10223,  22,   9,  26,    2,  -29 } }; // 0x7E '~'
-
-const GFXfont Oswald_Regular30pt7b PROGMEM = {
-  (uint8_t  *)Oswald_Regular30pt7bBitmaps,
-  (GFXglyph *)Oswald_Regular30pt7bGlyphs,
-  0x20, 0x7E, 87 };
-
-// Approx. 10920 bytes

src/fonts/oswald-medium20.h

@@ -0,0 +1,323 @@
+#pragma once
+
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+#include "fonts.hpp"
+
+const uint8_t Oswald_Medium20pt7bBitmaps_Gzip[] = {
+  0x1f,0x8b,0x08,0x00,0xf7,0xa4,0x71,0x67,0x02,0xff,0xad,0x58,
+  0xcf,0x8e,0xdb,0xb8,0x19,0xa7,0xa0,0xa2,0xbc,0x04,0xe1,0xb5,
+  0x87,0x81,0x98,0x37,0xe8,0x1e,0xb3,0x80,0x22,0xf6,0x51,0xda,
+  0x37,0x48,0xb1,0x87,0x3a,0x18,0x45,0xd4,0xc0,0x07,0xdf,0x56,
+  0x2f,0xb0,0x88,0x5f,0x63,0x81,0xa6,0x19,0x1a,0x2e,0xe0,0x4b,
+  0xb1,0x7e,0x81,0x36,0xa6,0xa1,0x83,0x6f,0x2b,0x1a,0x3e,0x98,
+  0x86,0x39,0x64,0x7f,0x94,0xec,0x19,0x4f,0x32,0x49,0x16,0x45,
+  0xc5,0xb1,0xf4,0xf1,0xff,0xc7,0xef,0xef,0x8f,0x43,0x42,0x7c,
+  0x8e,0xff,0xde,0x7c,0xff,0xcb,0x0f,0x3f,0x6d,0xbe,0xff,0xd7,
+  0x8b,0x24,0x56,0xbd,0x5c,0xbe,0xe9,0x5e,0x6d,0x7e,0xde,0x67,
+  0xed,0x4f,0x3f,0xfc,0x48,0x58,0x43,0x27,0xe3,0xc5,0xac,0x55,
+  0x5b,0x3d,0x32,0xf9,0xa8,0xc8,0xb3,0x8c,0x31,0xd1,0xcf,0x34,
+  0x5b,0x6d,0xcd,0x68,0x94,0xe7,0x32,0xdc,0x86,0x55,0xe8,0xc2,
+  0xae,0x9d,0xad,0xb5,0x31,0x23,0x9b,0x8f,0xb2,0x9c,0x65,0xb4,
+  0xa1,0x8b,0xf1,0x7c,0xd6,0x6a,0x52,0x93,0x3f,0x91,0x17,0xc4,
+  0x27,0x61,0x16,0xb6,0xc1,0xba,0xca,0xf1,0x8a,0xdd,0xd2,0xd5,
+  0xb8,0x53,0xa9,0x49,0x1c,0x09,0x44,0x28,0x66,0xd2,0x33,0x81,
+  0x96,0x8a,0x88,0x9c,0x79,0x1a,0xc6,0x61,0x76,0xd4,0x77,0xd6,
+  0x49,0x2f,0x3c,0x0b,0xa9,0x27,0x7f,0x20,0xcf,0xc8,0xef,0x49,
+  0x4a,0x58,0x9d,0x11,0x66,0x69,0x4d,0x43,0xa2,0xd2,0xa0,0x5f,
+  0x13,0x6b,0x73,0x92,0x17,0x8c,0x30,0x3a,0xae,0x53,0xb0,0x41,
+  0xc0,0x19,0xc9,0xb3,0x2b,0x34,0x34,0x24,0x05,0xff,0xc4,0x58,
+  0x4d,0x8a,0xe2,0x25,0x61,0x21,0x23,0x49,0x58,0x4c,0xac,0x58,
+  0xcf,0x43,0xaa,0xb6,0x41,0x93,0x7c,0x64,0xc9,0xf3,0x22,0x23,
+  0x69,0x33,0x51,0x49,0xbb,0x36,0x64,0x64,0x4b,0x72,0x55,0x70,
+  0xc2,0xd8,0x44,0xa5,0x73,0x34,0x68,0x3b,0x22,0x23,0x8c,0xc8,
+  0x68,0xa8,0xe9,0x4d,0x50,0x89,0x12,0x86,0x18,0x6a,0xa8,0x4e,
+  0x03,0x09,0x86,0x7b,0xda,0x6a,0x5b,0x72,0x36,0x5e,0x9b,0xb2,
+  0x60,0x93,0x7a,0x6b,0x78,0x9e,0x74,0x44,0xe8,0xd4,0xe2,0x30,
+  0xac,0x4e,0x6d,0x1e,0x26,0x1f,0xb6,0xfb,0x95,0xd8,0x6e,0x3e,
+  0x14,0xfb,0xb9,0xb7,0x72,0x4a,0x77,0xba,0x2c,0xf9,0x26,0xf8,
+  0x10,0x96,0xce,0x06,0x06,0x91,0xfe,0xfa,0xab,0xa6,0x8c,0x8b,
+  0xaa,0x2c,0xed,0x97,0x9e,0xb2,0x2c,0x85,0xe0,0x54,0x97,0x82,
+  0xcf,0x35,0x36,0xc3,0x9e,0x33,0x63,0xe3,0x77,0x02,0x46,0xef,
+  0x89,0x81,0x62,0xcd,0x72,0x31,0x57,0xac,0x7e,0x99,0xa8,0x1f,
+  0xff,0xf8,0x37,0x6c,0xd0,0x5a,0x56,0x7b,0x36,0x3a,0xb6,0x3f,
+  0x3e,0xfb,0x73,0x5a,0x53,0xf2,0x9c,0x5c,0x91,0x97,0xe4,0x75,
+  0xaf,0x50,0x7f,0x5f,0x25,0x3a,0x51,0x68,0xf8,0xe9,0xd7,0x3d,
+  0xc1,0xc7,0xe1,0x57,0x93,0x51,0xaa,0xae,0x88,0x66,0xf8,0xd6,
+  0x79,0xa2,0x9f,0x93,0xd7,0x14,0x5f,0x95,0x41,0x08,0xe4,0x65,
+  0x8a,0xef,0xd0,0x75,0x95,0xe0,0x7b,0xee,0xa2,0x86,0x41,0x6b,
+  0x4d,0x58,0x84,0xdd,0xfa,0x68,0xde,0x5a,0xe1,0x38,0xea,0xbd,
+  0x56,0x83,0x0e,0x46,0x7e,0xa1,0x61,0x45,0x97,0x8b,0x0d,0x0c,
+  0xc5,0x48,0xc3,0x4d,0x3a,0xdb,0xde,0x45,0xe6,0x2a,0x4e,0x67,
+  0xa6,0xfc,0xca,0xcb,0x70,0x27,0xbc,0xf4,0x52,0x3a,0x61,0xf9,
+  0xa9,0x08,0x22,0x48,0x01,0xf9,0x3b,0xe2,0x12,0x9b,0x9a,0x14,
+  0xea,0xa2,0x8a,0x29,0x5e,0xf3,0x5a,0xa0,0x39,0x76,0x40,0xfa,
+  0x7d,0x61,0x46,0x58,0x09,0x3b,0x73,0x95,0x15,0xf6,0xb4,0x02,
+  0x89,0xf3,0xab,0xd4,0xa5,0x16,0xc5,0xc1,0xfa,0xaa,0xbe,0xe5,
+  0x7e,0x75,0xb0,0x5b,0x05,0x8f,0x0d,0x1d,0x37,0xc4,0x13,0x51,
+  0x33,0x4d,0x6d,0xe2,0x49,0xa8,0x85,0xce,0x2c,0xfd,0x90,0x74,
+  0xf5,0x4e,0xe7,0x36,0x2b,0x68,0x33,0x6e,0xb5,0xb1,0x79,0xd4,
+  0x0d,0x28,0x1b,0xce,0x0f,0xb8,0x83,0x6d,0x68,0x62,0xef,0x89,
+  0x33,0x3f,0xc1,0x5b,0xf2,0x50,0x0e,0x26,0x58,0xe8,0xe1,0xc4,
+  0x1d,0xe1,0xe7,0x72,0xe6,0xc4,0x15,0xd2,0xf7,0x07,0x37,0x83,
+  0xcc,0x27,0x61,0xd1,0xee,0xf4,0x01,0x32,0x2f,0x7a,0x67,0x22,
+  0xbc,0x66,0xff,0xa4,0xa1,0x0d,0x87,0x68,0x6d,0x15,0x8f,0xce,
+  0xf7,0x48,0xe6,0xd3,0x5e,0xe6,0xeb,0x41,0xe6,0x67,0xe6,0x5c,
+  0xaa,0x59,0x5d,0x24,0x96,0x2a,0x4e,0xca,0xc4,0x30,0x55,0x10,
+  0x9b,0x6a,0x5e,0x83,0xa6,0x4a,0x44,0xfa,0xa1,0x3b,0x35,0xac,
+  0x66,0x26,0xb2,0x22,0x7d,0x55,0xb9,0xe2,0x2c,0x43,0x27,0xca,
+  0xa2,0xac,0xb0,0x87,0x1d,0xfa,0xca,0xe2,0x42,0x3f,0xa7,0x11,
+  0xe0,0xdd,0x0b,0xc7,0xa0,0x9d,0xd3,0x98,0xca,0xdd,0xeb,0xe0,
+  0x61,0x14,0x54,0x1b,0x64,0x10,0x2b,0x36,0xbd,0x38,0xbd,0xb8,
+  0x3c,0x7b,0xb4,0x55,0x12,0x9f,0x34,0x46,0xa7,0xfb,0x1a,0x21,
+  0xd1,0xbc,0xaf,0xfe,0xfa,0xee,0x35,0x79,0xf1,0x8c,0x8e,0xb7,
+  0x90,0xc0,0x42,0x1b,0x9e,0x3a,0xd1,0x7a,0xae,0x2c,0x25,0x2f,
+  0x86,0xf3,0x9a,0x61,0x70,0xef,0x0a,0xf5,0x33,0x82,0xf3,0x06,
+  0x0a,0xcd,0x4a,0x62,0x04,0xdb,0xf9,0xd0,0x68,0xfb,0x1c,0x91,
+  0x8c,0x69,0xb9,0x0d,0x7b,0x44,0xbb,0x00,0x41,0xe3,0x58,0x42,
+  0x95,0xc4,0x26,0x91,0x77,0xd8,0x94,0x83,0x18,0x20,0x99,0x92,
+  0x98,0x44,0xa7,0x8a,0xd6,0xc3,0x8a,0xbd,0xf1,0x51,0xcd,0x14,
+  0x41,0x68,0x43,0xfc,0x51,0x84,0x07,0x8b,0x1f,0x4c,0x06,0xb6,
+  0x28,0xa0,0x77,0x4e,0x08,0xcc,0x8d,0xe4,0x3c,0xd9,0x34,0x2c,
+  0x39,0x2e,0x9a,0x71,0x68,0x17,0x37,0xc1,0xec,0x67,0xd6,0x5c,
+  0xcf,0xec,0xe8,0x95,0xb6,0x79,0x66,0x6c,0xc1,0x46,0xb0,0x74,
+  0x57,0xb0,0xb1,0xcf,0xe8,0xcc,0xb3,0x54,0x75,0xf4,0x46,0xef,
+  0xc7,0xca,0x5c,0xc3,0xf5,0xdf,0x18,0xeb,0x72,0x2b,0x7d,0x9e,
+  0xf3,0xce,0x65,0x74,0xef,0xd8,0x8d,0xb1,0xa9,0x22,0x24,0x89,
+  0x27,0x2b,0xa3,0x1c,0xf0,0x63,0x08,0xc7,0x69,0x98,0x2a,0x9c,
+  0x53,0x83,0x07,0x83,0x58,0xa8,0x48,0x6a,0x88,0x44,0x0f,0x42,
+  0xb0,0x84,0x16,0x13,0xc4,0x61,0xcd,0x5c,0xb2,0xaf,0x0b,0x43,
+  0x57,0xe4,0xa8,0x8b,0x92,0x2e,0x6b,0x6b,0x38,0x4f,0x5b,0xed,
+  0x86,0x28,0x27,0x11,0xaf,0xda,0xe0,0x64,0x68,0x6e,0xb6,0x46,
+  0x14,0x69,0xa7,0xde,0x5a,0x76,0x9b,0xec,0x95,0x08,0x5a,0xa0,
+  0x6f,0x17,0x9c,0x93,0xb7,0x68,0x3e,0x9a,0xc2,0x21,0x74,0x0f,
+  0x04,0xbf,0x0d,0xcb,0x30,0x87,0x2d,0x07,0xc1,0x3a,0x15,0x8c,
+  0x70,0x08,0xe0,0x41,0xc1,0xe8,0x06,0x02,0xf6,0x17,0x42,0x1c,
+  0xd3,0x06,0xb8,0x52,0x0c,0x0c,0xdb,0xe0,0x2a,0x3e,0xa5,0xa7,
+  0x75,0x6e,0xd3,0xd0,0xcf,0xc2,0x49,0x18,0x72,0x07,0x79,0x20,
+  0xb0,0x45,0xec,0xea,0xc7,0x74,0xea,0x60,0xab,0xc8,0x20,0x2c,
+  0x5c,0x98,0x4b,0x7e,0xe8,0xb0,0xe9,0x69,0xf0,0x37,0x89,0xd9,
+  0xd1,0xc0,0x58,0xc4,0xc0,0xcf,0xc9,0x2b,0x4e,0x2a,0xbe,0xff,
+  0xa0,0x53,0x38,0x2c,0xbf,0xbc,0x6c,0xec,0x3f,0xe1,0xd1,0xa3,
+  0xaa,0xd4,0xf0,0xda,0x51,0x2d,0x12,0xcb,0x50,0x09,0x2b,0x0f,
+  0x33,0xba,0x1d,0x2a,0x8f,0x7a,0x50,0x39,0x9f,0xdd,0xe3,0xec,
+  0xe9,0x23,0x9e,0x2f,0x8e,0x2c,0x03,0x47,0x68,0x85,0x80,0x2e,
+  0x64,0x88,0x31,0x77,0x16,0x8e,0xb2,0xf4,0xdb,0xf0,0x5e,0x2c,
+  0x3f,0x11,0xef,0x67,0xc4,0x03,0x77,0x5f,0x1e,0x13,0x89,0xf0,
+  0xc4,0xf3,0x8d,0x78,0x3c,0x33,0x4e,0x60,0xde,0xd1,0x21,0xf8,
+  0xb2,0xd5,0xcd,0xce,0x54,0x15,0x5b,0xce,0xb6,0xb6,0x12,0x6c,
+  0xd2,0x1a,0x58,0xd1,0x74,0x8c,0xb6,0xd8,0x05,0x05,0x61,0xa3,
+  0x3a,0x58,0x1e,0xd2,0xa3,0xc6,0xb0,0xc5,0xcc,0x62,0xee,0x64,
+  0x1d,0x57,0xc0,0xd8,0x38,0x11,0x1a,0xe5,0xb7,0xe9,0x1e,0x23,
+  0x3f,0x11,0xff,0x37,0x3f,0x27,0x6e,0x2b,0x72,0x67,0x31,0x9f,
+  0xad,0x94,0x94,0xc9,0x9d,0xa3,0x7b,0xc3,0x57,0x2a,0xc8,0xf1,
+  0x9d,0x67,0x7b,0x2b,0x56,0xba,0xbb,0x9e,0xfc,0xa3,0xcb,0xf6,
+  0xef,0xaf,0x3f,0x6e,0xbb,0xeb,0xc5,0xab,0x4d,0xbe,0x7f,0xb7,
+  0xfb,0x78,0xbd,0x3c,0x74,0x62,0xf3,0x73,0x68,0x5a,0x2f,0x1a,
+  0xeb,0x45,0x6b,0xc3,0x64,0xee,0x39,0xb3,0xa5,0x58,0x9b,0x30,
+  0x19,0xfb,0xe7,0xcc,0x32,0x47,0x7d,0x1a,0x6e,0x7a,0xdb,0xb5,
+  0xc2,0xf3,0x10,0xa3,0x6f,0x1b,0xd5,0x12,0x3e,0xca,0x4e,0xec,
+  0x57,0x87,0x0e,0x81,0x5b,0x40,0x57,0x0d,0x2c,0x7f,0x7d,0x8e,
+  0xb8,0x51,0x55,0x35,0x64,0x0b,0x03,0x65,0x17,0xda,0xbe,0xfd,
+  0x6d,0x86,0xf9,0x40,0xdc,0x45,0x4b,0x6f,0x4e,0x96,0x6e,0x04,
+  0xc8,0x1d,0xd2,0x84,0xb8,0x4d,0x3f,0xb5,0xf4,0x5b,0xd6,0x85,
+  0x63,0xcc,0x21,0xa0,0x1f,0xbb,0xce,0x67,0xc4,0xff,0x8b,0x9f,
+  0x98,0xd4,0x54,0x12,0x73,0x1b,0x25,0x44,0x45,0x3f,0xbc,0xe7,
+  0x2e,0x3c,0x38,0xff,0x30,0xf5,0xc4,0x1d,0x34,0xce,0x16,0xed,
+  0xd6,0xba,0x42,0xb0,0xe5,0x7c,0x67,0x9c,0xe3,0x82,0x76,0xf0,
+  0xc3,0xea,0xec,0xfc,0x9c,0xe9,0x21,0x53,0xfb,0xca,0x9e,0xb2,
+  0x0c,0x2c,0x0c,0xe9,0x57,0x22,0x76,0x09,0x8d,0x0c,0x88,0x5c,
+  0x9d,0x0c,0x0d,0x62,0x74,0x9f,0x85,0xbc,0x88,0x18,0x32,0x66,
+  0x99,0x7b,0x03,0xd6,0x08,0xdb,0x69,0x04,0x04,0x35,0x07,0x8b,
+  0x7d,0x14,0xff,0x56,0xf5,0xb7,0xcb,0xe1,0x53,0x62,0xff,0x48,
+  0x32,0x96,0x02,0x0c,0xd7,0x6f,0x0d,0x2f,0xd9,0x2a,0xdd,0xa8,
+  0x83,0x29,0x0a,0xd6,0x4c,0xda,0x01,0xbf,0xd1,0xc9,0x6c,0xab,
+  0x4b,0xcb,0x0b,0x04,0xdd,0x9d,0x2e,0x0c,0x7b,0x1f,0x31,0xa6,
+  0x8a,0x27,0x03,0xb8,0x90,0x35,0x8f,0xa0,0x72,0x50,0x96,0xcd,
+  0xa8,0xa7,0x37,0xfb,0x1b,0xfd,0x46,0xdb,0xa2,0x14,0x6c,0xca,
+  0xe6,0x9b,0xb9,0x39,0x18,0x17,0x2b,0x0d,0x9b,0xcf,0x17,0xd6,
+  0x1c,0x90,0x73,0xe5,0x94,0x4d,0x37,0xf3,0xcd,0xf7,0xe6,0xf0,
+  0x4b,0x99,0xed,0x3e,0xd2,0xf7,0xfb,0x9b,0xee,0x95,0x96,0x4b,
+  0xcb,0xd7,0x9e,0x5a,0x79,0xe3,0xb9,0x16,0x13,0xc3,0xd6,0x80,
+  0x3a,0x12,0xee,0xaa,0x44,0xf4,0x1d,0x38,0x10,0x52,0x19,0xce,
+  0x9f,0xea,0x12,0xe6,0x64,0x2d,0xe2,0xff,0x1c,0x49,0x88,0xd3,
+  0x8d,0x2a,0x2d,0x9b,0x42,0x77,0xdc,0xa6,0x31,0x89,0xd1,0x1e,
+  0xe4,0x2a,0xb0,0x25,0x09,0x20,0x1b,0x98,0x54,0xdc,0xa5,0x5d,
+  0xfd,0xd6,0xf6,0x29,0xc3,0x02,0xbc,0xcd,0xb5,0xeb,0xa7,0x68,
+  0x04,0x95,0xae,0x3e,0x18,0xa8,0x75,0x40,0xcc,0x73,0xdd,0x2f,
+  0x8c,0x83,0x5a,0xe4,0x9a,0xa0,0x99,0xed,0xd3,0x4f,0xbf,0x16,
+  0x8b,0xc8,0x88,0x13,0xe0,0xa2,0x12,0xf0,0x28,0x89,0x06,0x45,
+  0xd5,0x65,0x93,0xf4,0xe1,0x0e,0x76,0x03,0x38,0x12,0xb3,0x6f,
+  0x89,0x3c,0xab,0x23,0x59,0x0c,0x24,0xeb,0x49,0x77,0x22,0x49,
+  0x24,0xa1,0x43,0x76,0x11,0xc3,0x1e,0x63,0xe6,0x2f,0x11,0xc1,
+  0x9b,0x14,0xf7,0x0d,0xbc,0xae,0x00,0x77,0xcf,0x2f,0x7d,0x7a,
+  0xe5,0xe7,0x17,0x01,0x2e,0x3e,0xbd,0x5e,0x26,0xfd,0x36,0xda,
+  0x8c,0xf2,0x0c,0x37,0x92,0xd9,0x57,0x09,0x19,0x3c,0xb0,0x82,
+  0x06,0x40,0x30,0x11,0x41,0x65,0xa3,0x6c,0x54,0x94,0x79,0x0e,
+  0xdc,0x54,0xd8,0x73,0xe4,0x05,0xec,0xcf,0x8b,0xec,0x39,0x83,
+  0xf1,0x6b,0x44,0x97,0xcd,0x72,0xc5,0x3e,0xf0,0x12,0xe7,0x4c,
+  0x23,0xee,0x69,0xf7,0xcb,0xe6,0x1d,0xaa,0xf6,0xad,0x39,0xb6,
+  0x11,0x9b,0x2c,0x37,0x4d,0x53,0x7f,0x66,0xc0,0xdb,0xb6,0xdb,
+  0xa0,0x73,0x75,0x02,0x2e,0x46,0x6a,0x58,0xe3,0x38,0xd0,0x87,
+  0xea,0x3c,0x74,0xab,0xf0,0xc1,0x97,0x30,0x01,0xa4,0x96,0x5b,
+  0x6f,0x11,0xb0,0x26,0x9e,0x5b,0x19,0x91,0x5e,0x0f,0xf8,0xfa,
+  0x1a,0x1a,0x43,0x21,0x6d,0x98,0x79,0x12,0x41,0xf4,0x19,0xde,
+  0xf4,0xa8,0x3a,0x8f,0x0a,0xc1,0xd3,0x78,0x78,0x9d,0x95,0x06,
+  0x2b,0xcc,0x31,0x9c,0x5d,0x56,0x97,0x01,0xf7,0xc5,0xe9,0xed,
+  0x79,0x93,0xe3,0x69,0x93,0xe1,0xa4,0x3d,0xaa,0x3c,0x6d,0xe2,
+  0x87,0x4d,0xe8,0xda,0xc9,0x29,0xb2,0x05,0x00,0x4d,0x3f,0x06,
+  0x17,0x27,0x90,0x05,0x55,0x36,0xda,0xe6,0x25,0x09,0xc4,0x75,
+  0x63,0xff,0x12,0xde,0x07,0x5f,0x54,0x9f,0xeb,0xb2,0x77,0x48,
+  0x84,0x5c,0x8d,0xbb,0x49,0x0d,0x07,0x94,0x08,0xd7,0xb3,0x60,
+  0xb4,0x7b,0xcd,0xde,0x03,0xac,0xc7,0x00,0x84,0x38,0x3d,0x0e,
+  0x4f,0x88,0x6e,0xb7,0xe9,0x31,0x5f,0x3c,0xd5,0xd3,0xa2,0xbb,
+  0xaf,0x0e,0xb8,0xf3,0xb3,0x74,0xa9,0x78,0x13,0x03,0x1b,0x10,
+  0xd8,0x40,0xb8,0x4a,0x3c,0x41,0x40,0x30,0x9d,0xbe,0x44,0xfe,
+  0xa7,0x12,0x91,0x6e,0x85,0xe2,0xac,0x3d,0xd8,0xa3,0x39,0x02,
+  0xd5,0x44,0xf4,0x1e,0x8c,0x3b,0xdd,0x0a,0x51,0x62,0x3c,0xec,
+  0x23,0x62,0xf8,0xc2,0x83,0x61,0x47,0xe7,0x4f,0x30,0xa6,0xe2,
+  0xf0,0xe4,0xff,0xe5,0xef,0xb0,0x3b,0x02,0xb8,0x40,0x73,0xec,
+  0x2b,0x1a,0xee,0xab,0xf5,0xa7,0x56,0xf4,0xd9,0x27,0x88,0x41,
+  0xc1,0x76,0xbb,0xdf,0x45,0x50,0x3d,0x79,0x52,0xa2,0xb1,0xba,
+  0x0e,0x7b,0x58,0xae,0x2c,0xca,0x47,0x81,0x99,0x64,0x95,0xec,
+  0xaf,0x87,0x5f,0xe3,0x66,0x13,0xa2,0x47,0xac,0xfa,0x2b,0xdf,
+  0xbd,0xad,0x5a,0x29,0x3a,0xcc,0xf4,0xf2,0x09,0x23,0x02,0x89,
+  0x68,0x86,0x45,0xb8,0x2f,0xaf,0xd7,0x61,0xcc,0x49,0x95,0xb8,
+  0xd4,0x51,0x0b,0x07,0x8d,0x46,0xfe,0x9d,0x9c,0x85,0xc9,0xea,
+  0xe4,0x00,0xe7,0x59,0xfd,0x15,0xda,0x3d,0xb1,0x96,0xa0,0x2e,
+  0x34,0xc6,0x3f,0x71,0xfa,0x4f,0x64,0x21,0xc3,0xdd,0xdd,0x7e,
+  0xa3,0x5c,0xef,0xc6,0xeb,0xfd,0xbc,0x9b,0x34,0x53,0x5e,0xe0,
+  0xc4,0xf6,0xa0,0x77,0xb3,0x4d,0x2f,0x0c,0xb0,0x80,0x50,0xad,
+  0x64,0xed,0xe3,0x51,0x88,0x19,0xc9,0xf9,0xdc,0x17,0x7c,0x6b,
+  0xf6,0x4d,0xf3,0xbe,0x7c,0xd3,0xee,0x96,0xfc,0xdd,0x1b,0xb7,
+  0xeb,0x36,0xd3,0xbf,0xe5,0xd7,0x7f,0x6f,0xff,0xe3,0xb3,0x8d,
+  0x09,0x62,0xb2,0x75,0xa2,0xd1,0x4e,0xd2,0x16,0x57,0x99,0x1b,
+  0x5b,0xb2,0xb1,0x2e,0x71,0x67,0xe3,0x65,0x56,0x14,0x45,0x2e,
+  0x72,0x5e,0x72,0x1b,0x97,0x8e,0xff,0xcf,0x78,0x08,0x44,0x08,
+  0x45,0xc8,0x23,0x79,0x35,0x04,0x22,0x8b,0x41,0x28,0xa0,0xf3,
+  0x22,0xce,0x2a,0xf2,0xac,0xcc,0x62,0xd3,0x88,0x8d,0xd8,0x79,
+  0x76,0x5f,0x52,0x3d,0x14,0xa1,0x50,0x10,0x36,0xe4,0x31,0x62,
+  0x5d,0xc3,0x81,0x6e,0x81,0x72,0x55,0x91,0x3e,0x26,0xa1,0x1c,
+  0x8c,0x50,0x74,0xb1,0x75,0xb8,0x15,0x8c,0x91,0xc8,0x1e,0x5e,
+  0xbc,0x41,0xde,0x10,0x8f,0xdb,0xf0,0x72,0x7c,0x61,0x5c,0xf2,
+  0x94,0x85,0x0b,0xd6,0xe2,0x37,0x07,0x72,0x3c,0xbf,0x00,0x45,
+  0x31,0x9e,0x2d,0xb6,0x26,0x26,0x9b,0x8b,0x0e,0xe0,0xb9,0x66,
+  0x4e,0xf8,0xef,0xc4,0x2f,0x21,0x48,0xff,0xc2,0x91,0xef,0xfe,
+  0x0b,0x06,0x62,0xc2,0xe3,0x11,0x13,0x00,0x00,
+};
+
+const GFXglyph Oswald_Medium20pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  10,    0,    0 },   // 0x20 ' '
+  {     1,   5,  32,   9,    2,  -31 },   // 0x21 '!'
+  {    21,  11,  11,  12,    1,  -31 },   // 0x22 '"'
+  {    37,  17,  32,  20,    2,  -31 },   // 0x23 '#'
+  {   105,  17,  39,  19,    1,  -34 },   // 0x24 '$'
+  {   188,  34,  32,  37,    2,  -31 },   // 0x25 '%'
+  {   324,  19,  32,  23,    2,  -31 },   // 0x26 '&'
+  {   400,   4,  11,   6,    1,  -31 },   // 0x27 '''
+  {   406,   8,  39,  13,    3,  -31 },   // 0x28 '('
+  {   445,   9,  39,  12,    1,  -31 },   // 0x29 ')'
+  {   489,  13,  14,  16,    2,  -31 },   // 0x2A '*'
+  {   512,  15,  16,  17,    1,  -23 },   // 0x2B '+'
+  {   542,   5,  10,   8,    2,   -4 },   // 0x2C ','
+  {   549,  10,   3,  12,    1,  -12 },   // 0x2D '-'
+  {   553,   5,   5,   9,    2,   -4 },   // 0x2E '.'
+  {   557,  13,  32,  16,    1,  -31 },   // 0x2F '/'
+  {   609,  17,  32,  21,    2,  -31 },   // 0x30 '0'
+  {   677,  10,  32,  15,    1,  -31 },   // 0x31 '1'
+  {   717,  16,  32,  19,    2,  -31 },   // 0x32 '2'
+  {   781,  16,  32,  19,    2,  -31 },   // 0x33 '3'
+  {   845,  18,  32,  20,    1,  -31 },   // 0x34 '4'
+  {   917,  16,  32,  19,    2,  -31 },   // 0x35 '5'
+  {   981,  17,  32,  20,    2,  -31 },   // 0x36 '6'
+  {  1049,  14,  32,  16,    1,  -31 },   // 0x37 '7'
+  {  1105,  16,  32,  20,    2,  -31 },   // 0x38 '8'
+  {  1169,  16,  32,  20,    2,  -31 },   // 0x39 '9'
+  {  1233,   6,  18,   9,    2,  -20 },   // 0x3A ':'
+  {  1247,   6,  25,  10,    2,  -21 },   // 0x3B ';'
+  {  1266,  11,  17,  15,    2,  -24 },   // 0x3C '<'
+  {  1290,  13,  11,  17,    2,  -21 },   // 0x3D '='
+  {  1308,  12,  17,  15,    2,  -24 },   // 0x3E '>'
+  {  1334,  15,  32,  19,    2,  -31 },   // 0x3F '?'
+  {  1394,  33,  37,  36,    2,  -31 },   // 0x40 '@'
+  {  1547,  19,  32,  20,    1,  -31 },   // 0x41 'A'
+  {  1623,  18,  32,  22,    2,  -31 },   // 0x42 'B'
+  {  1695,  18,  32,  21,    2,  -31 },   // 0x43 'C'
+  {  1767,  18,  32,  22,    2,  -31 },   // 0x44 'D'
+  {  1839,  14,  32,  17,    2,  -31 },   // 0x45 'E'
+  {  1895,  13,  32,  16,    2,  -31 },   // 0x46 'F'
+  {  1947,  18,  32,  22,    2,  -31 },   // 0x47 'G'
+  {  2019,  18,  32,  23,    2,  -31 },   // 0x48 'H'
+  {  2091,   5,  32,  11,    3,  -31 },   // 0x49 'I'
+  {  2111,  10,  33,  13,    0,  -31 },   // 0x4A 'J'
+  {  2153,  19,  32,  21,    2,  -31 },   // 0x4B 'K'
+  {  2229,  14,  32,  16,    2,  -31 },   // 0x4C 'L'
+  {  2285,  22,  32,  27,    2,  -31 },   // 0x4D 'M'
+  {  2373,  17,  32,  21,    2,  -31 },   // 0x4E 'N'
+  {  2441,  18,  32,  22,    2,  -31 },   // 0x4F 'O'
+  {  2513,  18,  32,  21,    2,  -31 },   // 0x50 'P'
+  {  2585,  18,  38,  22,    2,  -31 },   // 0x51 'Q'
+  {  2671,  18,  32,  22,    2,  -31 },   // 0x52 'R'
+  {  2743,  16,  32,  19,    2,  -31 },   // 0x53 'S'
+  {  2807,  15,  32,  17,    1,  -31 },   // 0x54 'T'
+  {  2867,  18,  32,  22,    2,  -31 },   // 0x55 'U'
+  {  2939,  18,  32,  20,    1,  -31 },   // 0x56 'V'
+  {  3011,  26,  32,  28,    1,  -31 },   // 0x57 'W'
+  {  3115,  19,  32,  20,    0,  -31 },   // 0x58 'X'
+  {  3191,  19,  32,  19,    0,  -31 },   // 0x59 'Y'
+  {  3267,  15,  32,  17,    1,  -31 },   // 0x5A 'Z'
+  {  3327,   9,  39,  13,    2,  -31 },   // 0x5B '['
+  {  3371,  13,  32,  16,    1,  -31 },   // 0x5C '\'
+  {  3423,   9,  39,  12,    1,  -31 },   // 0x5D ']'
+  {  3467,  16,  13,  18,    1,  -31 },   // 0x5E '^'
+  {  3493,  14,   4,  14,    0,    3 },   // 0x5F '_'
+  {  3500,   8,   8,  11,    2,  -31 },   // 0x60 '`'
+  {  3508,  15,  23,  17,    1,  -22 },   // 0x61 'a'
+  {  3552,  15,  32,  19,    2,  -31 },   // 0x62 'b'
+  {  3612,  14,  23,  17,    2,  -22 },   // 0x63 'c'
+  {  3653,  15,  32,  19,    2,  -31 },   // 0x64 'd'
+  {  3713,  14,  23,  17,    2,  -22 },   // 0x65 'e'
+  {  3754,  11,  31,  12,    1,  -30 },   // 0x66 'f'
+  {  3797,  18,  31,  18,    1,  -23 },   // 0x67 'g'
+  {  3867,  15,  32,  19,    2,  -31 },   // 0x68 'h'
+  {  3927,   6,  31,  10,    2,  -30 },   // 0x69 'i'
+  {  3951,   9,  37,  10,   -1,  -30 },   // 0x6A 'j'
+  {  3993,  16,  32,  18,    2,  -31 },   // 0x6B 'k'
+  {  4057,   6,  32,  10,    2,  -31 },   // 0x6C 'l'
+  {  4081,  24,  23,  28,    2,  -22 },   // 0x6D 'm'
+  {  4150,  15,  23,  19,    2,  -22 },   // 0x6E 'n'
+  {  4194,  14,  23,  18,    2,  -22 },   // 0x6F 'o'
+  {  4235,  15,  30,  19,    2,  -22 },   // 0x70 'p'
+  {  4292,  15,  30,  19,    2,  -22 },   // 0x71 'q'
+  {  4349,  11,  23,  14,    2,  -22 },   // 0x72 'r'
+  {  4381,  14,  23,  16,    1,  -22 },   // 0x73 's'
+  {  4422,  11,  29,  13,    1,  -28 },   // 0x74 't'
+  {  4462,  14,  23,  19,    2,  -22 },   // 0x75 'u'
+  {  4503,  15,  23,  16,    0,  -22 },   // 0x76 'v'
+  {  4547,  21,  23,  23,    1,  -22 },   // 0x77 'w'
+  {  4608,  16,  23,  16,    0,  -22 },   // 0x78 'x'
+  {  4654,  16,  29,  16,    0,  -22 },   // 0x79 'y'
+  {  4712,  13,  23,  15,    1,  -22 },   // 0x7A 'z'
+  {  4750,  10,  40,  13,    2,  -31 },   // 0x7B '{'
+  {  4800,   4,  38,  10,    3,  -31 },   // 0x7C '|'
+  {  4819,  10,  40,  14,    2,  -31 },   // 0x7D '}'
+  {  4869,  16,   6,  18,    1,  -18 } }; // 0x7E '~'
+
+// const GFXfont Oswald_Medium20pt7b PROGMEM = {
+//   (uint8_t  *)Oswald_Medium20pt7bBitmaps,
+//   (GFXglyph *)Oswald_Medium20pt7bGlyphs,
+//   0x20, 0x7E, 58 };
+
+// // Approx. 5553 bytes
+
+
+// Font properties
+static constexpr FontData Oswald_Medium20pt7b_Properties = {
+    Oswald_Medium20pt7bBitmaps_Gzip,
+    Oswald_Medium20pt7bGlyphs,
+    sizeof(Oswald_Medium20pt7bBitmaps_Gzip),
+    5553,  // Original size
+    0x20,   // First char
+    0x7E,   // Last char
+    58    // yAdvance
+};

src/fonts/oswald-medium30.h

@@ -0,0 +1,497 @@
+#pragma once
+
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+#include "fonts.hpp"
+
+const uint8_t Oswald_Medium30pt7bBitmaps_Gzip[] = {
+  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcd, 0x5a,
+  0xbb, 0x72, 0x23, 0x3b, 0x92, 0x05, 0xb7, 0x8c, 0x72, 0x26, 0x1a, 0x63,
+  0x5e, 0x63, 0xe2, 0x62, 0x3f, 0x61, 0xcc, 0x36, 0xee, 0x08, 0xf7, 0x53,
+  0xf6, 0x13, 0xc6, 0x6c, 0x43, 0x4b, 0x94, 0x82, 0x86, 0xbc, 0xd1, 0x27,
+  0xf0, 0x53, 0x04, 0x86, 0x0c, 0x99, 0xfc, 0x83, 0x65, 0x31, 0x68, 0xd0,
+  0x14, 0x14, 0x32, 0x08, 0x86, 0x4a, 0xc8, 0x3d, 0x27, 0xc1, 0xa7, 0xd4,
+  0x52, 0xf7, 0xbd, 0xdd, 0x3b, 0xb1, 0x25, 0x50, 0x55, 0x85, 0x42, 0xe1,
+  0x91, 0x48, 0x9c, 0x3c, 0x99, 0x28, 0x23, 0x3c, 0x0a, 0x8f, 0xf1, 0xee,
+  0xb8, 0xac, 0xc7, 0x6f, 0x7a, 0x7c, 0xd6, 0xc3, 0x18, 0x23, 0xbb, 0xa3,
+  0x78, 0x71, 0x72, 0xb3, 0xb8, 0x7f, 0x58, 0x6d, 0x96, 0xcf, 0xe9, 0x25,
+  0x8f, 0x87, 0x8b, 0xb1, 0xbb, 0xb0, 0xd3, 0x76, 0x3e, 0x59, 0xcf, 0x56,
+  0xfd, 0x63, 0xff, 0x25, 0xfd, 0x66, 0x46, 0x83, 0xeb, 0x42, 0xdb, 0xbb,
+  0x49, 0x6e, 0xfb, 0x61, 0x94, 0xbd, 0x19, 0xdb, 0xe8, 0x26, 0x09, 0x37,
+  0x0d, 0x6e, 0x8a, 0x8b, 0xbe, 0x4d, 0x76, 0x96, 0x9b, 0x34, 0x36, 0x28,
+  0xe9, 0xdb, 0x25, 0x2a, 0x0e, 0x22, 0x0b, 0x91, 0x8d, 0xc8, 0x0b, 0x6e,
+  0x76, 0xaf, 0x15, 0x1b, 0xfd, 0x35, 0x4a, 0x0e, 0x28, 0x69, 0xf7, 0x3d,
+  0x90, 0x5b, 0x91, 0x07, 0x91, 0x67, 0xf4, 0xa5, 0xd6, 0x79, 0x6c, 0xc0,
+  0xb2, 0x81, 0x80, 0x3a, 0xd1, 0x40, 0x7f, 0xda, 0x40, 0xef, 0xee, 0x72,
+  0x9b, 0x0a, 0x4b, 0x9a, 0xbf, 0x19, 0xf3, 0xc9, 0x98, 0xd6, 0x98, 0xa6,
+  0x33, 0xa3, 0x68, 0xda, 0xc1, 0x38, 0xe9, 0x9c, 0xf4, 0x4e, 0xb2, 0x43,
+  0x95, 0x22, 0x76, 0x90, 0x79, 0x76, 0xeb, 0xdc, 0x3e, 0x0d, 0xcd, 0x4b,
+  0x19, 0x15, 0x31, 0x12, 0xba, 0x70, 0x1b, 0xff, 0xe6, 0x92, 0xb1, 0x83,
+  0x69, 0x8a, 0x19, 0x49, 0x67, 0xa4, 0x37, 0x7e, 0x30, 0x56, 0x4c, 0x23,
+  0xd1, 0x48, 0x7a, 0x73, 0xd3, 0xd6, 0x62, 0x01, 0xc5, 0xf0, 0x5a, 0xfe,
+  0xd2, 0xc8, 0x30, 0x12, 0x54, 0x25, 0x5d, 0x90, 0x58, 0x9b, 0xb3, 0xcf,
+  0x43, 0xbb, 0x95, 0xeb, 0x21, 0x50, 0xaa, 0xc5, 0x4a, 0x69, 0xa4, 0x18,
+  0x24, 0x37, 0x18, 0x93, 0x8c, 0xf9, 0xfc, 0xaa, 0xaf, 0x68, 0x1a, 0xb9,
+  0xa8, 0xfd, 0xd2, 0x98, 0x20, 0xc6, 0x76, 0xe8, 0x78, 0x42, 0x16, 0xdf,
+  0xba, 0xe4, 0x0c, 0xf5, 0xcc, 0xa2, 0xb0, 0x0c, 0xc4, 0xdc, 0x21, 0x6b,
+  0xdc, 0x64, 0x66, 0xc5, 0x30, 0x62, 0x96, 0xed, 0xc7, 0x78, 0x71, 0x34,
+  0x20, 0xcb, 0xf6, 0xfe, 0x2a, 0xa1, 0xc6, 0x16, 0x02, 0x32, 0xbe, 0x2b,
+  0xc8, 0x6a, 0x93, 0x9b, 0xa1, 0xfa, 0xd2, 0x64, 0x64, 0xd9, 0x18, 0x6c,
+  0xc4, 0x73, 0xcb, 0x2c, 0x3f, 0xc9, 0x17, 0xe8, 0x44, 0x66, 0x16, 0x1a,
+  0x5e, 0x22, 0xcb, 0x4a, 0xbe, 0x68, 0x30, 0x18, 0x4c, 0x10, 0x86, 0x21,
+  0xb3, 0x1c, 0xa4, 0x93, 0xfe, 0x02, 0xd9, 0xa3, 0xd8, 0xde, 0x61, 0x98,
+  0x66, 0x94, 0xc3, 0x0d, 0x0a, 0x5e, 0xd8, 0xbe, 0xe0, 0xdd, 0xbb, 0xec,
+  0x22, 0xb3, 0x9a, 0xac, 0x59, 0x01, 0x59, 0xb3, 0xa1, 0xed, 0x91, 0xe5,
+  0x3b, 0x0c, 0x16, 0xea, 0xe0, 0xd0, 0x83, 0x58, 0x38, 0x40, 0x14, 0x65,
+  0xa7, 0xd0, 0x5f, 0x4c, 0x4e, 0xd4, 0x57, 0xb2, 0xbe, 0xe2, 0xd1, 0x9f,
+  0xde, 0x60, 0x2e, 0x67, 0x78, 0x25, 0x37, 0x03, 0xb2, 0x1c, 0xfa, 0xc3,
+  0xac, 0x56, 0x98, 0x45, 0xa9, 0x20, 0xab, 0xc5, 0x1c, 0xa0, 0x6e, 0xdf,
+  0x1b, 0xde, 0x72, 0x1a, 0x32, 0x24, 0xd5, 0x43, 0xfa, 0x9d, 0x45, 0x39,
+  0xb1, 0xa9, 0x4d, 0xbe, 0xf3, 0x57, 0x03, 0xeb, 0x63, 0xcd, 0x68, 0xa3,
+  0x41, 0xab, 0x2e, 0x16, 0x68, 0x5c, 0x4f, 0x0d, 0x72, 0xf7, 0xc9, 0x14,
+  0x6f, 0x9a, 0xe7, 0x6c, 0xec, 0x02, 0x93, 0x98, 0x75, 0x2e, 0x6d, 0xa6,
+  0xb0, 0x4c, 0xc3, 0x1e, 0x27, 0x37, 0x91, 0x6e, 0xf0, 0xa5, 0x5d, 0x49,
+  0xf2, 0x6e, 0x31, 0xdb, 0x96, 0xb1, 0x9b, 0xaf, 0x72, 0x09, 0x76, 0xbd,
+  0x4e, 0xc1, 0xfb, 0x2b, 0xd9, 0x0e, 0xad, 0xdc, 0xf4, 0x1e, 0xdd, 0x94,
+  0x55, 0x6e, 0xa1, 0xf4, 0xae, 0x2f, 0x23, 0xb9, 0x86, 0x92, 0xb9, 0xa5,
+  0x14, 0xe8, 0xf1, 0x13, 0x7e, 0x37, 0xf2, 0x34, 0x78, 0xb1, 0x3d, 0xf4,
+  0xc1, 0xfc, 0xd3, 0x7c, 0xa6, 0x7a, 0x2f, 0x6e, 0xc7, 0x2f, 0xcf, 0xeb,
+  0xf9, 0xf4, 0xe2, 0x32, 0x99, 0x2f, 0x36, 0x16, 0x9b, 0xe4, 0x66, 0x08,
+  0x6d, 0x46, 0x87, 0x51, 0x03, 0xba, 0xce, 0xb3, 0xe0, 0x7e, 0x86, 0x47,
+  0x61, 0x72, 0xc8, 0xc4, 0x48, 0x38, 0x0a, 0xbd, 0xd9, 0x3f, 0xa9, 0xc5,
+  0xf6, 0x8f, 0xeb, 0xbf, 0x62, 0x07, 0xdf, 0x0b, 0xc5, 0xfb, 0x2b, 0x56,
+  0x0f, 0xcb, 0x66, 0x1f, 0x71, 0xef, 0xf4, 0x7d, 0x3e, 0xd9, 0x55, 0x32,
+  0x9c, 0x55, 0xf2, 0xb5, 0x9b, 0x93, 0x86, 0xfd, 0x8c, 0x67, 0x3c, 0x9c,
+  0x0c, 0xe1, 0xae, 0xf0, 0x51, 0x0f, 0xfd, 0x1d, 0x74, 0x22, 0x0c, 0xd4,
+  0xcf, 0x76, 0xbf, 0x5c, 0x7e, 0x7e, 0x5a, 0xcd, 0x65, 0x1c, 0x38, 0xc8,
+  0x7b, 0x49, 0x58, 0x20, 0x0e, 0x93, 0x42, 0x6d, 0x7f, 0x4e, 0x76, 0x1e,
+  0x87, 0x71, 0xbb, 0xcc, 0x9f, 0xac, 0xf9, 0xfb, 0x7f, 0x72, 0x2a, 0x9b,
+  0x9e, 0x0a, 0x7e, 0x71, 0x7e, 0xd9, 0xc8, 0xe9, 0x91, 0xde, 0x16, 0x38,
+  0x5c, 0xee, 0xcb, 0xb4, 0xad, 0x75, 0x17, 0x97, 0x5f, 0xfe, 0x7e, 0xf2,
+  0xd6, 0xfe, 0x82, 0x65, 0x2f, 0x8d, 0xeb, 0x4e, 0x4f, 0xb6, 0x6b, 0xd2,
+  0xab, 0xd3, 0x18, 0xa7, 0xd1, 0xe9, 0x29, 0xe2, 0x74, 0xf1, 0xea, 0xd4,
+  0xc6, 0x51, 0x3e, 0x3d, 0xa1, 0x27, 0xfe, 0xec, 0xe4, 0x28, 0x08, 0x23,
+  0x1d, 0x74, 0xb1, 0xe1, 0x3a, 0x97, 0x2b, 0x91, 0xa5, 0x76, 0x66, 0x90,
+  0x49, 0x09, 0x51, 0x7c, 0x0c, 0x0b, 0x60, 0x42, 0xc2, 0x12, 0x82, 0x32,
+  0xa3, 0xcc, 0x11, 0x2c, 0xbc, 0xfc, 0xd0, 0x83, 0x97, 0xd2, 0x14, 0x19,
+  0x49, 0x98, 0x89, 0x7f, 0x84, 0xbe, 0xc9, 0xb5, 0xc8, 0x4c, 0x24, 0x2a,
+  0x0a, 0x45, 0xe2, 0x15, 0x30, 0xd1, 0x8c, 0xb1, 0x16, 0x72, 0x78, 0x3a,
+  0x91, 0xee, 0x3d, 0xa6, 0xdf, 0xf5, 0xe8, 0x56, 0x27, 0xa3, 0xd2, 0x0c,
+  0x6d, 0xfe, 0x73, 0xb7, 0x26, 0x44, 0x8c, 0x19, 0x5d, 0x1b, 0x69, 0xb3,
+  0x18, 0x73, 0xc6, 0x98, 0xd1, 0x19, 0x8c, 0xf9, 0x36, 0x7a, 0x8c, 0xf9,
+  0x21, 0xd9, 0x4d, 0x6e, 0x9f, 0x0f, 0x58, 0x4b, 0x31, 0xe1, 0x2d, 0xe3,
+  0x23, 0x97, 0x30, 0x12, 0x60, 0x97, 0xc8, 0x4b, 0x14, 0x65, 0x6a, 0x33,
+  0x31, 0xbb, 0x55, 0x20, 0xae, 0x09, 0x4a, 0x54, 0x13, 0xdf, 0xac, 0x09,
+  0xef, 0xef, 0xaa, 0x50, 0x7b, 0xb1, 0x50, 0x93, 0xb1, 0x51, 0xab, 0x01,
+  0xfb, 0x02, 0x94, 0x8d, 0x87, 0x99, 0x98, 0x68, 0xaf, 0xb6, 0x58, 0x64,
+  0x72, 0x55, 0xd0, 0xe3, 0xdb, 0x2a, 0xbe, 0xde, 0x42, 0x45, 0x59, 0x66,
+  0x18, 0x01, 0xc1, 0x50, 0x77, 0xe8, 0x34, 0xb1, 0xe2, 0x86, 0xaf, 0x03,
+  0xe8, 0xa3, 0xc2, 0x3b, 0x0d, 0x08, 0x40, 0xb8, 0x63, 0x5f, 0xd1, 0x4b,
+  0xf4, 0x6c, 0xff, 0x86, 0x74, 0x5e, 0xb1, 0x5e, 0xab, 0xda, 0x0d, 0x70,
+  0xc4, 0x91, 0xfb, 0xc4, 0x99, 0xb8, 0xdf, 0xcf, 0x04, 0x9a, 0x8b, 0x44,
+  0x2d, 0xa8, 0x30, 0x2d, 0x8c, 0xda, 0x0d, 0x0c, 0x97, 0x23, 0x8b, 0x04,
+  0x1f, 0x35, 0x2c, 0xbd, 0x09, 0x6a, 0xaa, 0x1a, 0x58, 0x80, 0xff, 0xc6,
+  0xda, 0xb9, 0x8d, 0xcd, 0x26, 0x9b, 0x01, 0x0b, 0x68, 0xda, 0xb7, 0xab,
+  0xc1, 0x0c, 0xa1, 0x73, 0x37, 0xa9, 0x5d, 0x16, 0x33, 0x78, 0x98, 0x4d,
+  0x98, 0x5e, 0x81, 0x1d, 0xee, 0xb1, 0x20, 0x5b, 0x5d, 0xfa, 0x0a, 0x0b,
+  0x3d, 0xd6, 0x29, 0x16, 0xa9, 0xbc, 0x3d, 0x12, 0xa5, 0x05, 0xd9, 0x2a,
+  0x68, 0xf6, 0x0a, 0x72, 0x18, 0x2e, 0xc6, 0xc3, 0xc1, 0x9c, 0x3e, 0x0a,
+  0x98, 0xbe, 0xaf, 0x26, 0xbc, 0x00, 0x45, 0x3a, 0x4f, 0xa5, 0x26, 0x1f,
+  0x0b, 0x75, 0x9d, 0x53, 0xaf, 0xa9, 0x40, 0xe9, 0x45, 0x67, 0xbb, 0xe8,
+  0x84, 0xbf, 0x4d, 0xf2, 0x3a, 0x69, 0x79, 0x4c, 0x90, 0xb6, 0xe5, 0x69,
+  0xab, 0xa1, 0xe0, 0x3d, 0xa5, 0x46, 0xdb, 0x57, 0x95, 0x8c, 0x4b, 0x60,
+  0xbf, 0xb0, 0xf6, 0xd3, 0x09, 0x2d, 0x9c, 0xf6, 0x6e, 0x5e, 0x57, 0x43,
+  0xe6, 0xb8, 0x8e, 0xf3, 0x89, 0x61, 0xb9, 0xd5, 0x60, 0x37, 0x72, 0xfd,
+  0x2c, 0x2b, 0xea, 0x00, 0xfb, 0x26, 0xa1, 0x97, 0xdb, 0xde, 0xeb, 0x6a,
+  0xdc, 0x29, 0x00, 0x7b, 0x29, 0xe7, 0xd3, 0x59, 0xf5, 0x75, 0x40, 0xa7,
+  0x30, 0x9d, 0x80, 0xc5, 0x1b, 0x55, 0xa4, 0xd3, 0x85, 0xa5, 0x88, 0xf4,
+  0x56, 0xce, 0xb4, 0x4a, 0x6d, 0x42, 0xeb, 0xe8, 0x89, 0x7b, 0x75, 0x53,
+  0x28, 0xef, 0x7a, 0x13, 0x47, 0x5f, 0xbd, 0x01, 0xa0, 0x1c, 0x6e, 0xda,
+  0x93, 0x1b, 0x73, 0x72, 0x23, 0x87, 0x1b, 0x2c, 0x89, 0x56, 0xbb, 0x0b,
+  0xb2, 0xe1, 0x29, 0x35, 0x62, 0x33, 0x2c, 0x00, 0x12, 0x05, 0x7a, 0x2e,
+  0xdf, 0x80, 0x34, 0xd2, 0xa7, 0x93, 0xc1, 0xaf, 0x07, 0xf2, 0x13, 0x0a,
+  0xe0, 0xfc, 0xf5, 0x59, 0x7d, 0xf7, 0xf8, 0x62, 0xd9, 0xa7, 0xb3, 0xda,
+  0xae, 0x84, 0xf5, 0x90, 0xd6, 0xf0, 0xad, 0x5a, 0x55, 0xb3, 0x9b, 0x2a,
+  0x60, 0x60, 0x3a, 0x4c, 0x55, 0xcf, 0xa9, 0x02, 0x03, 0xda, 0x4d, 0xd5,
+  0x11, 0x0f, 0x5e, 0x23, 0xda, 0x11, 0x28, 0x4a, 0xf3, 0x22, 0x4d, 0x09,
+  0x6b, 0x81, 0x16, 0x4f, 0x75, 0x11, 0x71, 0xbe, 0x03, 0xf8, 0xda, 0xdd,
+  0xeb, 0xb9, 0xc5, 0x7a, 0x3c, 0x81, 0x16, 0xac, 0xbc, 0x6e, 0x37, 0x55,
+  0x6f, 0x30, 0xf0, 0x38, 0x55, 0xe6, 0x70, 0xec, 0x18, 0x67, 0x2a, 0xbb,
+  0xc3, 0x9c, 0x1f, 0x7b, 0x42, 0xfc, 0xe9, 0xd3, 0xaf, 0x17, 0xc3, 0x97,
+  0x7f, 0x1a, 0xf3, 0x3b, 0x2c, 0xf8, 0x25, 0xa6, 0x22, 0xc4, 0x90, 0x3c,
+  0xc6, 0xed, 0x8b, 0x2f, 0x16, 0xe0, 0x0b, 0x2b, 0xe8, 0x23, 0x2e, 0xa4,
+  0x0f, 0x05, 0xf2, 0x0c, 0xe0, 0x05, 0x28, 0xd3, 0xd2, 0xc2, 0x80, 0xd9,
+  0xfd, 0x7e, 0xa2, 0x1b, 0xa7, 0x4d, 0x9c, 0xdb, 0x3a, 0x68, 0xd3, 0x67,
+  0xda, 0xa3, 0x0c, 0xf9, 0x79, 0x48, 0xf3, 0x8a, 0x0b, 0xe0, 0x0a, 0x33,
+  0x03, 0x3e, 0x03, 0x23, 0x64, 0x93, 0x85, 0x94, 0x1d, 0xe4, 0x71, 0x03,
+  0x35, 0xec, 0x50, 0xa6, 0x43, 0xe1, 0xce, 0x80, 0xb0, 0x01, 0x4c, 0x4e,
+  0x27, 0x11, 0x93, 0xc2, 0x34, 0x91, 0x30, 0x3a, 0x9b, 0x32, 0x88, 0xe6,
+  0xcb, 0x61, 0xf9, 0x51, 0x75, 0x0a, 0x97, 0x0a, 0x52, 0xab, 0xa0, 0x0b,
+  0x00, 0x06, 0xba, 0x01, 0xfc, 0x38, 0x7d, 0x0a, 0xbb, 0xc3, 0x57, 0xd2,
+  0xe9, 0xf1, 0xd5, 0x02, 0xb5, 0xcc, 0xb8, 0x8e, 0x8f, 0xd7, 0x2d, 0x66,
+  0x41, 0x25, 0x3d, 0xe8, 0x35, 0x99, 0x1b, 0xfe, 0x67, 0xc2, 0x69, 0x2b,
+  0x0a, 0x84, 0xa4, 0x71, 0xe0, 0x5c, 0x99, 0x8d, 0x43, 0xb8, 0x9e, 0xc5,
+  0xc1, 0xda, 0xc8, 0x30, 0x21, 0x42, 0xa8, 0x7e, 0x03, 0x80, 0x06, 0xfd,
+  0x87, 0x0a, 0x2e, 0x26, 0x29, 0x90, 0x10, 0x8e, 0xc1, 0xff, 0x21, 0x9f,
+  0x6b, 0xac, 0x60, 0xf0, 0xb3, 0x0c, 0xbe, 0x73, 0x95, 0x87, 0x66, 0xb0,
+  0xf1, 0xc2, 0xc3, 0x3a, 0x25, 0x3b, 0x8d, 0xc0, 0xc3, 0x66, 0x9d, 0x40,
+  0x8c, 0xcd, 0x16, 0xdc, 0xd2, 0xc5, 0x0b, 0x30, 0x65, 0xb8, 0x24, 0xd3,
+  0x0e, 0x4b, 0xba, 0x59, 0x83, 0x12, 0x8e, 0xf1, 0x00, 0x8c, 0xad, 0x1b,
+  0x83, 0xe2, 0xa0, 0xc0, 0x2d, 0xca, 0xe7, 0xf6, 0x01, 0x0f, 0xca, 0xe8,
+  0x09, 0x0f, 0xc0, 0x5a, 0xf5, 0x01, 0x78, 0x1e, 0xe8, 0xb6, 0xbb, 0x21,
+  0xc0, 0x82, 0xbd, 0x80, 0xaa, 0xc1, 0xe5, 0xc0, 0xcc, 0xcd, 0xb2, 0xeb,
+  0x80, 0x27, 0x28, 0xe3, 0xc0, 0xf4, 0x50, 0x27, 0x66, 0xa6, 0x43, 0xdf,
+  0xee, 0x40, 0x41, 0x7b, 0x90, 0x5a, 0x4e, 0x24, 0x8f, 0xa0, 0xff, 0xa1,
+  0xa7, 0x14, 0x48, 0xcd, 0xc2, 0x60, 0x99, 0x95, 0xaa, 0x8c, 0x6a, 0xa9,
+  0x6c, 0x7e, 0xad, 0xea, 0x08, 0x2f, 0x40, 0x21, 0x04, 0x76, 0x00, 0x42,
+  0xd2, 0x1b, 0x55, 0x54, 0x55, 0x1c, 0x50, 0x6c, 0x43, 0x71, 0xf1, 0x2d,
+  0x47, 0xb4, 0x06, 0x33, 0xc6, 0xa5, 0xcf, 0xea, 0x95, 0x38, 0xae, 0x8c,
+  0xac, 0xe4, 0xd8, 0x63, 0xfa, 0x80, 0xf7, 0x0e, 0xcc, 0x16, 0x5a, 0xdd,
+  0x6e, 0x30, 0xb7, 0xb7, 0x5d, 0xf3, 0x02, 0xa0, 0x99, 0x03, 0x83, 0x7c,
+  0xd7, 0x3e, 0x42, 0x63, 0x6f, 0x7a, 0x32, 0x6c, 0xb7, 0xca, 0xf0, 0xd7,
+  0xfa, 0x36, 0x09, 0xdd, 0x80, 0x66, 0x50, 0x16, 0x6b, 0x40, 0x02, 0xc1,
+  0xfc, 0x22, 0x0c, 0x0a, 0xc6, 0x0a, 0xc5, 0x82, 0xc6, 0x41, 0xd2, 0xb8,
+  0xf4, 0x8a, 0x82, 0xb0, 0x3a, 0x60, 0xb4, 0x26, 0x5c, 0xe3, 0x05, 0x1f,
+  0xdd, 0x0a, 0x2f, 0xa0, 0x8a, 0x0c, 0x4b, 0xb5, 0x86, 0xfe, 0xfa, 0x88,
+  0x35, 0x6c, 0xb0, 0xa0, 0x47, 0x9c, 0x75, 0xc7, 0x85, 0x8e, 0x45, 0x41,
+  0xff, 0x87, 0x0b, 0xb9, 0xf8, 0x7b, 0xb9, 0xcf, 0x2d, 0xcc, 0x1a, 0x60,
+  0xdb, 0x3e, 0x61, 0x6e, 0x61, 0xd6, 0xe6, 0xa9, 0xd9, 0x16, 0x13, 0xb0,
+  0x8a, 0xd6, 0xa8, 0xb2, 0x3e, 0x5a, 0x61, 0x46, 0xc3, 0x95, 0xd4, 0xb7,
+  0xd0, 0x30, 0x20, 0x83, 0x68, 0x42, 0x07, 0x6e, 0x35, 0xb4, 0x78, 0x2b,
+  0xcc, 0x53, 0xfb, 0x82, 0xb7, 0x6e, 0x23, 0x40, 0x80, 0xca, 0xee, 0x45,
+  0xfd, 0x04, 0xa1, 0xb7, 0x97, 0xe8, 0x34, 0xd5, 0x47, 0x0d, 0xf1, 0x6c,
+  0xd1, 0x7b, 0x90, 0x1f, 0x2c, 0x0d, 0xa2, 0x03, 0x49, 0x8a, 0xe7, 0x80,
+  0x8a, 0x0a, 0x51, 0xd1, 0x0d, 0x58, 0x41, 0xb3, 0x89, 0xe6, 0xd6, 0xc5,
+  0x6d, 0x09, 0xfb, 0x80, 0x25, 0x2c, 0xab, 0xac, 0x3e, 0x1b, 0x2d, 0xc3,
+  0x9b, 0x1b, 0x2e, 0x13, 0xb3, 0xa3, 0x05, 0x1f, 0xdc, 0xbc, 0x5f, 0x01,
+  0x61, 0x0b, 0x6c, 0x21, 0x4c, 0xb3, 0x5f, 0x55, 0xe3, 0x89, 0xc1, 0x35,
+  0x15, 0x10, 0x39, 0x8f, 0x0e, 0x95, 0x60, 0xa6, 0x88, 0xae, 0x14, 0x7b,
+  0x52, 0xef, 0x5c, 0xe6, 0xf0, 0x2c, 0x20, 0x00, 0x0c, 0xea, 0x36, 0x02,
+  0x33, 0xdb, 0xea, 0x77, 0x2a, 0xd4, 0xfd, 0xec, 0x1b, 0x20, 0x6b, 0x6d,
+  0x47, 0x1b, 0xad, 0x5d, 0x54, 0x4f, 0x56, 0x1a, 0x15, 0xf4, 0x5b, 0x8e,
+  0x21, 0xd5, 0x40, 0xbd, 0xf7, 0x0f, 0xd2, 0xcf, 0x27, 0xff, 0x3e, 0x2e,
+  0x7c, 0xf2, 0xda, 0x47, 0x47, 0x04, 0x82, 0x41, 0xf5, 0xa0, 0xce, 0x30,
+  0x0b, 0x36, 0x01, 0xd8, 0xfc, 0x79, 0x16, 0xed, 0xbe, 0x97, 0x35, 0x6d,
+  0xff, 0x14, 0xa2, 0x7b, 0xa7, 0xd4, 0x47, 0x59, 0xd4, 0x92, 0x20, 0x27,
+  0x33, 0x01, 0x3d, 0x72, 0x83, 0x5f, 0x01, 0xfc, 0x43, 0xe7, 0xa1, 0x87,
+  0x50, 0x78, 0x4c, 0xa4, 0x7b, 0xa0, 0x07, 0x63, 0x54, 0x6f, 0x28, 0xc6,
+  0x8e, 0xcb, 0x9c, 0xaa, 0x00, 0x68, 0xb3, 0x59, 0x09, 0x2c, 0x34, 0x02,
+  0xfc, 0xd1, 0xec, 0x2a, 0xa1, 0x24, 0x67, 0xaa, 0x8c, 0x5f, 0xd3, 0x5e,
+  0x89, 0x56, 0xf6, 0x8a, 0x6d, 0x9f, 0x07, 0xaa, 0x8a, 0x7f, 0x18, 0x2c,
+  0x29, 0xcc, 0x54, 0x9e, 0x1f, 0x45, 0xc6, 0x4e, 0xe6, 0x33, 0x79, 0xcc,
+  0xe8, 0x8a, 0xf9, 0x8d, 0xb8, 0xfe, 0x71, 0x1d, 0xdf, 0xf3, 0xe8, 0xbd,
+  0xe3, 0x4f, 0x57, 0x78, 0xfe, 0xe8, 0x0f, 0x1e, 0x4d, 0x69, 0xe1, 0xb6,
+  0xb8, 0xe4, 0x7b, 0x90, 0xb0, 0xab, 0x1f, 0xb8, 0x1d, 0xe9, 0x8d, 0xdf,
+  0xc0, 0x4b, 0x98, 0x0a, 0x5c, 0xf6, 0x04, 0x44, 0x23, 0x44, 0x51, 0xac,
+  0x15, 0x4a, 0xec, 0x23, 0x26, 0x13, 0x5c, 0x12, 0xfe, 0x3b, 0x40, 0x1e,
+  0x90, 0x48, 0x07, 0x98, 0x5e, 0x30, 0x30, 0xff, 0x0a, 0xb7, 0xfe, 0x1e,
+  0xbc, 0x1a, 0x6f, 0xf9, 0xde, 0xad, 0x07, 0xc5, 0xa8, 0xdb, 0xfe, 0x14,
+  0x77, 0x14, 0x43, 0x1c, 0x17, 0x38, 0x96, 0x2f, 0x98, 0xcc, 0x16, 0x4b,
+  0xdb, 0xf7, 0xfe, 0x0e, 0x6f, 0xa1, 0xfd, 0x56, 0x1d, 0x6f, 0x56, 0x48,
+  0xd7, 0xdd, 0x2f, 0xd1, 0x1d, 0x6d, 0xcb, 0x66, 0xb0, 0x16, 0xd7, 0x83,
+  0xa4, 0xee, 0x35, 0x09, 0x88, 0x26, 0x07, 0x44, 0xfb, 0xce, 0xe5, 0xf1,
+  0xc3, 0xff, 0xce, 0x0f, 0xb2, 0x80, 0x29, 0x18, 0xe6, 0x1a, 0x6c, 0x73,
+  0x0b, 0x3b, 0x5d, 0x02, 0xa0, 0x1c, 0x19, 0xa0, 0x64, 0x06, 0xd0, 0x18,
+  0x91, 0x81, 0x59, 0x9d, 0x62, 0x82, 0x91, 0xe1, 0xb7, 0x50, 0xce, 0x12,
+  0x80, 0xce, 0x53, 0x8c, 0x78, 0x8d, 0xc1, 0x23, 0xc3, 0x8d, 0x41, 0x82,
+  0x16, 0x53, 0x69, 0x36, 0x6b, 0x89, 0x2f, 0xdb, 0x97, 0xe4, 0xc7, 0xe1,
+  0xd2, 0x4e, 0xa7, 0x8b, 0xc9, 0x7a, 0xbd, 0x59, 0x6e, 0xb7, 0xdb, 0x3c,
+  0x1e, 0x8f, 0x2f, 0xdc, 0x74, 0x7a, 0x73, 0x7d, 0xbf, 0x5e, 0x3d, 0x3d,
+  0x6e, 0xf3, 0x30, 0x8c, 0xc7, 0xde, 0xbb, 0xe9, 0xf5, 0xfc, 0x7e, 0xbd,
+  0x7c, 0x5a, 0x6e, 0x73, 0x40, 0x11, 0x57, 0x90, 0x21, 0xd7, 0xeb, 0x5e,
+  0x90, 0xe1, 0xd3, 0x78, 0x0c, 0x12, 0x34, 0x9d, 0x48, 0x0b, 0x03, 0x3e,
+  0xdb, 0x32, 0x9e, 0x31, 0x86, 0x5c, 0x17, 0x57, 0xa5, 0xdd, 0xc0, 0x3e,
+  0xbf, 0x30, 0x88, 0x34, 0x86, 0xb1, 0x96, 0x0e, 0x04, 0xac, 0xf7, 0x70,
+  0x18, 0x6c, 0x84, 0x47, 0xc5, 0x54, 0xf6, 0x49, 0x6a, 0xea, 0x34, 0xc5,
+  0x7d, 0xea, 0x35, 0xa5, 0x7d, 0xca, 0x9a, 0xd4, 0xe5, 0x29, 0x45, 0xd3,
+  0x38, 0x94, 0xa0, 0xc9, 0x6b, 0x24, 0xcf, 0xed, 0x93, 0xd5, 0xd4, 0x6a,
+  0x6a, 0xf6, 0x49, 0xb9, 0x6f, 0x39, 0x32, 0xe7, 0xda, 0xb4, 0xaf, 0xe9,
+  0x35, 0x92, 0x64, 0x45, 0x92, 0xf0, 0x54, 0x91, 0x64, 0x91, 0xce, 0x14,
+  0xe9, 0x04, 0x49, 0xbc, 0xfc, 0xb4, 0x47, 0xaa, 0xf2, 0x31, 0xcc, 0x07,
+  0x97, 0xab, 0x39, 0x9d, 0xa9, 0x8d, 0x57, 0xdc, 0xb7, 0xc4, 0x2c, 0xf5,
+  0xce, 0x40, 0x25, 0xdf, 0x5a, 0x1d, 0x5a, 0x83, 0x50, 0xad, 0xce, 0xf3,
+  0x50, 0x55, 0x3f, 0x2a, 0xf3, 0x3f, 0x18, 0x8d, 0x87, 0x9d, 0xd1, 0x68,
+  0xe8, 0x95, 0xe3, 0x9d, 0x6a, 0xd7, 0xb2, 0xd6, 0x96, 0xc9, 0x0e, 0x45,
+  0x9d, 0x4d, 0x28, 0xdd, 0x9f, 0xbd, 0xf9, 0xff, 0x21, 0x41, 0x79, 0x5f,
+  0x82, 0x51, 0xe3, 0xbb, 0xe8, 0x70, 0xb3, 0x3b, 0x31, 0xaa, 0x68, 0x18,
+  0x8d, 0x62, 0xc4, 0xb7, 0x31, 0xa7, 0xa4, 0x48, 0xf6, 0xa4, 0x68, 0x26,
+  0xeb, 0x03, 0x29, 0xd2, 0xea, 0x3b, 0x88, 0xb2, 0x39, 0xd2, 0x1b, 0x0a,
+  0x7e, 0xb1, 0xe7, 0x4b, 0x80, 0x2b, 0xac, 0x32, 0x9d, 0x96, 0xeb, 0xea,
+  0x62, 0x41, 0x17, 0x41, 0xc5, 0x7a, 0x85, 0xab, 0x0a, 0x31, 0xb3, 0x03,
+  0xe6, 0xf4, 0xe1, 0x8e, 0xb1, 0x9f, 0x4e, 0x6c, 0x72, 0x4b, 0x05, 0x39,
+  0x0f, 0x02, 0x06, 0xe3, 0x2b, 0xf0, 0x9b, 0x6b, 0x85, 0xaf, 0x80, 0x47,
+  0x63, 0x2c, 0xb9, 0x7a, 0x66, 0xa9, 0x2a, 0xc2, 0x75, 0xf1, 0x4b, 0x54,
+  0xa6, 0x0e, 0x96, 0x9b, 0xe7, 0xf6, 0x89, 0x0e, 0x57, 0x87, 0xde, 0xfe,
+  0xda, 0x56, 0xc3, 0x16, 0x7a, 0x8d, 0x9d, 0xd7, 0xc8, 0x86, 0x2b, 0xfb,
+  0x78, 0x06, 0x15, 0x4a, 0x76, 0x19, 0xf1, 0x24, 0xe8, 0xe1, 0x13, 0x03,
+  0xe8, 0xb0, 0x83, 0x30, 0x69, 0xaa, 0x4c, 0x70, 0x4f, 0x19, 0x20, 0x83,
+  0x14, 0x80, 0x9c, 0xf4, 0xb9, 0x6f, 0x72, 0x58, 0xa9, 0x91, 0x1c, 0x9c,
+  0x86, 0x71, 0x30, 0xe3, 0x70, 0x19, 0x76, 0xea, 0xf9, 0x95, 0xe3, 0x10,
+  0x24, 0xfa, 0xf7, 0xa7, 0x9f, 0x65, 0x1d, 0xff, 0xc4, 0xa3, 0x66, 0xa7,
+  0x18, 0xdf, 0x5c, 0xd4, 0x1d, 0xa1, 0x1e, 0x9e, 0x80, 0x04, 0xfa, 0xcc,
+  0x86, 0xac, 0x7b, 0x0d, 0xb5, 0xf2, 0x1d, 0x3c, 0x00, 0x9c, 0xa2, 0xbb,
+  0x1b, 0x46, 0x8c, 0x2b, 0xcd, 0x06, 0x3a, 0x01, 0x3c, 0x41, 0x7d, 0xe8,
+  0x00, 0x10, 0x56, 0xbb, 0xd2, 0x6a, 0x88, 0x5e, 0xe0, 0x13, 0xd1, 0x05,
+  0x63, 0x84, 0x1d, 0xed, 0xc2, 0xd5, 0x49, 0xe8, 0x08, 0x3c, 0x89, 0x0c,
+  0x68, 0x9b, 0xf6, 0xcd, 0x16, 0x6c, 0x75, 0x1a, 0xd5, 0xd3, 0x58, 0xc4,
+  0xd1, 0x8b, 0x86, 0xb3, 0x6a, 0x74, 0x5e, 0x15, 0x6a, 0xa7, 0x0c, 0x56,
+  0x74, 0x97, 0x83, 0xbe, 0x4b, 0xa8, 0x6a, 0x00, 0xe5, 0xe1, 0x89, 0xbe,
+  0x4d, 0x61, 0x3c, 0x89, 0xb1, 0x3b, 0x0d, 0x4d, 0xd0, 0x7d, 0x47, 0xb3,
+  0x0c, 0x3a, 0x6e, 0x19, 0x75, 0x5c, 0x33, 0xec, 0x08, 0xf7, 0xae, 0x63,
+  0x28, 0x63, 0x9f, 0xe5, 0x13, 0xda, 0x96, 0xd9, 0xe0, 0x61, 0x1a, 0x52,
+  0x81, 0x8d, 0xb8, 0x83, 0xb1, 0x40, 0xe7, 0x98, 0x05, 0xf3, 0x91, 0x0a,
+  0xec, 0xc8, 0x1d, 0x0c, 0x4a, 0x68, 0x1f, 0x9f, 0x56, 0xd9, 0xdd, 0xcf,
+  0xe1, 0xce, 0xb9, 0x0b, 0x78, 0x76, 0x03, 0x9c, 0xbc, 0xa7, 0x27, 0xf8,
+  0x7b, 0xf3, 0xf9, 0xbc, 0x0f, 0xde, 0xc1, 0xeb, 0xcb, 0x97, 0x43, 0xf3,
+  0xbc, 0xdc, 0x24, 0x8b, 0x95, 0x15, 0x3d, 0x04, 0x89, 0x7e, 0x07, 0x2c,
+  0xd6, 0x9e, 0xd1, 0x28, 0xa8, 0xb0, 0x1b, 0xa0, 0xc0, 0x70, 0xff, 0x31,
+  0x27, 0x91, 0x33, 0x02, 0x85, 0x77, 0x20, 0xe3, 0x18, 0x81, 0x43, 0x56,
+  0x17, 0xfa, 0x06, 0xe0, 0x0f, 0xb2, 0x07, 0x92, 0x07, 0xa6, 0x90, 0xe8,
+  0xcd, 0xc7, 0x46, 0x7d, 0xf8, 0xd4, 0x68, 0x98, 0x80, 0xb1, 0x1c, 0x0f,
+  0xf2, 0x61, 0x1f, 0x92, 0xba, 0x3e, 0xf7, 0xea, 0x43, 0x81, 0x27, 0x34,
+  0xd9, 0x33, 0x78, 0x0f, 0x8f, 0x92, 0x82, 0x86, 0xc3, 0x0f, 0xd1, 0x62,
+  0x85, 0xb6, 0x90, 0x69, 0x80, 0x4c, 0xd5, 0x11, 0xd8, 0x0b, 0x73, 0xb4,
+  0x97, 0x62, 0x7f, 0x10, 0x1f, 0x61, 0x32, 0x72, 0x09, 0x32, 0x53, 0x37,
+  0x45, 0x52, 0x0d, 0x5b, 0xa6, 0xba, 0x70, 0x32, 0xdd, 0xab, 0x16, 0xec,
+  0x17, 0xac, 0xc4, 0x2e, 0x0b, 0x9d, 0x3e, 0xc7, 0x00, 0x22, 0xa0, 0x22,
+  0x86, 0x09, 0xf0, 0xc0, 0x77, 0xea, 0xcf, 0xa1, 0x77, 0xf7, 0x89, 0x70,
+  0xe3, 0x1e, 0xe8, 0xc0, 0x71, 0x63, 0x45, 0xb9, 0x3e, 0x34, 0x64, 0xe7,
+  0x9b, 0x55, 0x18, 0x21, 0x7f, 0x51, 0x70, 0x51, 0xc8, 0xe1, 0xbe, 0x8a,
+  0x53, 0x8f, 0x8d, 0x8e, 0x25, 0xd6, 0x33, 0x03, 0x0e, 0x96, 0x35, 0x0c,
+  0xb5, 0xf9, 0x3d, 0x18, 0x8c, 0xd8, 0xbb, 0x1d, 0x4e, 0xec, 0x7a, 0xfd,
+  0x01, 0x4b, 0xfe, 0x8e, 0x47, 0x81, 0xf1, 0xde, 0x8d, 0x46, 0x80, 0xf5,
+  0xb2, 0x67, 0x14, 0x4d, 0xc3, 0x64, 0x3e, 0x8e, 0x34, 0x52, 0xa6, 0x41,
+  0x38, 0x46, 0xd9, 0x18, 0x53, 0x63, 0x04, 0x8d, 0xc1, 0x33, 0x06, 0xd1,
+  0x34, 0x24, 0xa7, 0x01, 0xb8, 0x5a, 0xba, 0x7c, 0x58, 0x3a, 0x1f, 0x4b,
+  0xbf, 0xc3, 0x56, 0x75, 0xad, 0xf8, 0xee, 0xff, 0xe0, 0x54, 0xeb, 0x8f,
+  0xe8, 0x42, 0x57, 0xb7, 0x23, 0xea, 0x5e, 0x06, 0xae, 0x7d, 0xdd, 0xe5,
+  0xb0, 0x75, 0x0f, 0x02, 0xd7, 0xe3, 0xdd, 0x7e, 0xc4, 0xa1, 0xe0, 0xf0,
+  0x7d, 0x05, 0xe3, 0xeb, 0x82, 0xdd, 0x88, 0xaa, 0xb6, 0xc3, 0xd6, 0xa1,
+  0x65, 0x30, 0xe5, 0xe7, 0x9f, 0x76, 0xf5, 0x47, 0x2c, 0xfa, 0x91, 0xc6,
+  0xfc, 0x29, 0x6e, 0xa8, 0x6a, 0x82, 0xfa, 0x36, 0x9b, 0xbe, 0x7d, 0x88,
+  0x00, 0x12, 0xef, 0xba, 0x82, 0xd5, 0xea, 0x5b, 0x2e, 0xea, 0xe2, 0xba,
+  0x01, 0xef, 0x96, 0xe6, 0x19, 0xe6, 0x98, 0x30, 0x74, 0x7e, 0x0c, 0x02,
+  0xe5, 0x26, 0x00, 0xb4, 0x69, 0xdc, 0xc6, 0xc1, 0x5e, 0x25, 0xae, 0x50,
+  0xc6, 0x2f, 0x5a, 0x8d, 0x2a, 0xcb, 0xed, 0x3a, 0xc3, 0x6a, 0x49, 0x98,
+  0xbc, 0x14, 0xc0, 0xa1, 0x4e, 0x2d, 0x17, 0x26, 0xa3, 0x97, 0x9e, 0x5e,
+  0xad, 0x7b, 0x78, 0x2c, 0x30, 0x87, 0xe2, 0x77, 0x05, 0x16, 0x51, 0x9d,
+  0x5d, 0x4b, 0x43, 0xb8, 0x94, 0xb0, 0x50, 0x6d, 0x5b, 0xcc, 0x4b, 0x70,
+  0x8f, 0x40, 0x97, 0xf4, 0xd7, 0x5d, 0x38, 0x6d, 0x17, 0x48, 0x4b, 0x54,
+  0x12, 0x54, 0x1a, 0xba, 0xaf, 0x64, 0xdf, 0xe7, 0x70, 0x9b, 0x35, 0x0a,
+  0x0d, 0x57, 0x7a, 0x33, 0xc0, 0xf0, 0xc1, 0x03, 0x81, 0x7d, 0x67, 0x6c,
+  0x0e, 0xe6, 0x0b, 0x46, 0x0e, 0xc4, 0x35, 0x6b, 0x24, 0x0f, 0x53, 0x1e,
+  0xb9, 0xe5, 0xfa, 0x95, 0x6c, 0x46, 0x5e, 0x05, 0xcc, 0xa0, 0x7d, 0x16,
+  0xb7, 0x51, 0x8e, 0x35, 0x05, 0x13, 0x58, 0x0c, 0xdc, 0x8e, 0xfd, 0x0f,
+  0x2e, 0x2c, 0xcf, 0xb8, 0xab, 0xe5, 0x68, 0xb7, 0x82, 0x35, 0x4b, 0x6c,
+  0x0c, 0x80, 0x64, 0x1d, 0x41, 0x1d, 0x4c, 0xd5, 0xf7, 0x3a, 0xf2, 0xe3,
+  0xe5, 0xa1, 0x00, 0x07, 0xce, 0xd7, 0x4a, 0xb8, 0xcf, 0xca, 0xe0, 0xb4,
+  0xf9, 0x08, 0xe0, 0x6b, 0x40, 0xbf, 0xbe, 0x73, 0xb0, 0x33, 0x74, 0xa8,
+  0x88, 0x63, 0xc8, 0x05, 0x0e, 0xeb, 0x73, 0x71, 0x9b, 0xec, 0x8e, 0x03,
+  0xbe, 0x62, 0x3f, 0xc0, 0x9a, 0xc9, 0x0a, 0x1d, 0xdb, 0x05, 0x17, 0x8a,
+  0x1a, 0x30, 0x3e, 0xcb, 0xde, 0x97, 0xe6, 0x80, 0xc5, 0x3e, 0xab, 0xe0,
+  0xd6, 0x0c, 0x09, 0x03, 0xaa, 0xc4, 0xc4, 0x3a, 0xda, 0x11, 0x49, 0x38,
+  0x46, 0xfb, 0xb8, 0x1b, 0x6d, 0x39, 0x1f, 0xed, 0xa9, 0x72, 0x9c, 0x0f,
+  0x7c, 0x37, 0xda, 0x81, 0xa3, 0x5d, 0xbc, 0x33, 0x5a, 0x54, 0xd0, 0xe2,
+  0xcf, 0xf2, 0x2f, 0x1d, 0xff, 0x4e, 0x6b, 0x3d, 0xcd, 0xff, 0x23, 0x7f,
+  0xa8, 0x1d, 0xe6, 0xe4, 0xb7, 0x46, 0xe0, 0xdf, 0x28, 0x11, 0x84, 0xc9,
+  0xee, 0xab, 0xfd, 0xed, 0x7d, 0xdc, 0xaf, 0xff, 0xf6, 0x68, 0x7f, 0xf7,
+  0x68, 0x30, 0x2b, 0x2c, 0xe2, 0x96, 0x34, 0xee, 0xe4, 0x00, 0xa4, 0xc3,
+  0x44, 0x58, 0xda, 0x86, 0xca, 0x33, 0x49, 0x37, 0x69, 0x4f, 0x89, 0xdd,
+  0xd4, 0x6b, 0x06, 0xda, 0x61, 0xbf, 0xa8, 0x50, 0xd9, 0x99, 0x30, 0xe9,
+  0x47, 0x79, 0x6c, 0xdc, 0x3d, 0x4e, 0xc5, 0xb8, 0x1b, 0x92, 0x41, 0x65,
+  0x92, 0x0c, 0x6b, 0x90, 0x97, 0x82, 0xea, 0xd2, 0x59, 0x79, 0xa5, 0x1f,
+  0xef, 0x5e, 0x8a, 0x9f, 0x17, 0x09, 0xcf, 0x55, 0x1a, 0x5b, 0x92, 0xf2,
+  0x53, 0x65, 0xfb, 0xc1, 0xcb, 0x7a, 0x9c, 0x06, 0xe4, 0x3f, 0x38, 0x4e,
+  0xf7, 0xae, 0xf7, 0x71, 0xea, 0x6f, 0x6c, 0x71, 0xbf, 0x7b, 0xb3, 0xe4,
+  0x94, 0xdc, 0xbe, 0xc8, 0x43, 0x09, 0xab, 0xd2, 0x76, 0x67, 0x9b, 0x0e,
+  0x89, 0x8a, 0xfe, 0x66, 0xa7, 0xe9, 0xf8, 0x80, 0x8e, 0x20, 0xf7, 0xb3,
+  0xa0, 0xe7, 0x20, 0xe2, 0xa8, 0x17, 0x42, 0xba, 0xce, 0xa8, 0x95, 0xfb,
+  0x2b, 0xba, 0x17, 0xbc, 0xdf, 0x80, 0xda, 0x6f, 0xee, 0x42, 0x8b, 0x6f,
+  0x3b, 0x59, 0x80, 0xc1, 0x25, 0x7f, 0x97, 0x61, 0x60, 0xf1, 0x86, 0x6e,
+  0xb6, 0xd7, 0x4b, 0x86, 0x42, 0x41, 0xd2, 0x50, 0x15, 0xb0, 0x09, 0x6a,
+  0x6e, 0xeb, 0x9e, 0xc7, 0xb7, 0x25, 0xf2, 0xea, 0x30, 0x4d, 0xf7, 0xc9,
+  0x3e, 0x16, 0x78, 0x1a, 0x21, 0x71, 0xc7, 0xf4, 0xb6, 0x1c, 0x9f, 0x4d,
+  0x84, 0x32, 0xa7, 0xf4, 0x81, 0x37, 0x64, 0x05, 0xff, 0xee, 0x8b, 0x24,
+  0xf0, 0x6f, 0xe4, 0x61, 0x43, 0xd7, 0x91, 0xc7, 0x94, 0x7e, 0xe3, 0x4f,
+  0x51, 0x22, 0x5e, 0xa6, 0x1d, 0x58, 0x9c, 0x42, 0xe3, 0x82, 0xd0, 0xf8,
+  0x47, 0xea, 0xd9, 0x83, 0x85, 0x1c, 0xc1, 0x02, 0x0f, 0xfb, 0x0a, 0x16,
+  0x82, 0xb9, 0x62, 0xde, 0x5a, 0x51, 0x79, 0x91, 0xe4, 0xf6, 0x04, 0xac,
+  0xbf, 0x81, 0x74, 0x35, 0xfb, 0xa4, 0x34, 0xe1, 0x32, 0x87, 0x05, 0x23,
+  0x97, 0x80, 0xd0, 0x2c, 0x01, 0x66, 0x69, 0x32, 0xfc, 0xe5, 0x43, 0xdc,
+  0x35, 0x76, 0x35, 0x84, 0x87, 0xa7, 0x1d, 0x19, 0xa2, 0x1b, 0xf0, 0x43,
+  0x52, 0x03, 0x22, 0xec, 0x98, 0x95, 0x7f, 0xa6, 0x79, 0xf9, 0xe5, 0x43,
+  0x20, 0x80, 0x5c, 0x6f, 0x30, 0xee, 0x07, 0xbe, 0xc2, 0x63, 0x05, 0x0b,
+  0x16, 0xc1, 0x1a, 0x7b, 0x38, 0x0b, 0x99, 0x7b, 0x38, 0x28, 0x05, 0x4f,
+  0xf3, 0x9b, 0x19, 0x4a, 0xea, 0xa8, 0x15, 0x41, 0xee, 0x30, 0x84, 0xf5,
+  0xb6, 0x58, 0x90, 0xf3, 0x30, 0x7a, 0x1a, 0x3e, 0xb9, 0xf4, 0x3b, 0xf7,
+  0xe6, 0x49, 0x20, 0xc9, 0x10, 0x62, 0xbb, 0xbb, 0x34, 0xdc, 0xe3, 0x53,
+  0xea, 0xd0, 0x77, 0xf2, 0x2b, 0x68, 0x81, 0x5b, 0x74, 0xa5, 0xb4, 0x1b,
+  0x58, 0x7a, 0x86, 0x07, 0xee, 0x38, 0xa4, 0xe8, 0xb2, 0xf9, 0x0b, 0x58,
+  0x1d, 0xa9, 0xb9, 0x72, 0x74, 0x90, 0xf5, 0x48, 0x8a, 0x6e, 0x4f, 0x76,
+  0xcb, 0x4b, 0xcd, 0x78, 0x53, 0xe2, 0xbd, 0x8c, 0xa0, 0x2e, 0x82, 0xc5,
+  0xd2, 0x81, 0x33, 0xe0, 0xd3, 0x4f, 0xd2, 0x54, 0x5e, 0xce, 0x74, 0xa3,
+  0x82, 0xc7, 0x02, 0xd8, 0x8a, 0x65, 0x61, 0xd3, 0x7f, 0xa9, 0x35, 0xda,
+  0x95, 0x84, 0x91, 0xdb, 0x0e, 0xf0, 0x7d, 0xc2, 0x74, 0x59, 0x02, 0x5d,
+  0x1c, 0x38, 0x38, 0x76, 0x49, 0x46, 0x42, 0xaa, 0x04, 0xb7, 0x06, 0x4e,
+  0x0d, 0x5c, 0x1a, 0xf8, 0x38, 0xcd, 0x13, 0x3f, 0xbe, 0xf1, 0xe8, 0x3d,
+  0xdd, 0x18, 0x78, 0xd0, 0x70, 0x0e, 0x02, 0x7c, 0x15, 0x5c, 0xd2, 0x5d,
+  0xf0, 0x47, 0xe9, 0xf1, 0x6b, 0x9f, 0xf1, 0xee, 0x17, 0xea, 0x2f, 0xec,
+  0x7e, 0x63, 0x6f, 0xf3, 0xf9, 0xef, 0x26, 0x17, 0xfc, 0x06, 0x3f, 0xbd,
+  0x1c, 0xdc, 0xeb, 0xdf, 0xff, 0xfc, 0x23, 0xbb, 0xf2, 0x8f, 0x6c, 0x8b,
+  0x3f, 0xff, 0xc1, 0x39, 0xc5, 0x8f, 0x5b, 0x99, 0xa9, 0xdd, 0xff, 0x32,
+  0x7f, 0x54, 0x00, 0x38, 0x93, 0x99, 0x1f, 0x67, 0x71, 0x67, 0xa9, 0xc0,
+  0xb7, 0xc3, 0x18, 0xe0, 0xc9, 0x61, 0x44, 0x79, 0x0c, 0x1f, 0xc8, 0x3e,
+  0xf1, 0x6b, 0x00, 0xc7, 0x30, 0x8c, 0xc6, 0xd1, 0x72, 0x9d, 0xf6, 0xba,
+  0x5d, 0x09, 0x1f, 0x88, 0x23, 0x19, 0xb8, 0x91, 0x26, 0x4a, 0x0b, 0x51,
+  0x74, 0xd1, 0xfb, 0xdb, 0x38, 0x26, 0x0f, 0x99, 0x64, 0xb8, 0xa8, 0xe2,
+  0x80, 0xbb, 0x57, 0xa5, 0xc0, 0x2b, 0xa5, 0x17, 0x03, 0x37, 0x98, 0xb4,
+  0x0b, 0x96, 0xd5, 0x93, 0x5c, 0x6a, 0x9a, 0x0d, 0xee, 0x90, 0xee, 0x06,
+  0xbb, 0xca, 0x87, 0xd4, 0xae, 0x52, 0xbb, 0xd9, 0xa5, 0x86, 0x09, 0x76,
+  0x15, 0xbe, 0x4d, 0x4d, 0xfb, 0x4f, 0x45, 0xb4, 0x37, 0xfb, 0xcf, 0x53,
+  0x6a, 0xd2, 0x0d, 0x40, 0xa1, 0x3b, 0xe6, 0xf4, 0xab, 0x3f, 0xa7, 0x7e,
+  0x85, 0xc3, 0xd2, 0xc5, 0xaa, 0xda, 0xd0, 0x5d, 0xe1, 0x45, 0x52, 0xdd,
+  0xe7, 0x52, 0xa0, 0x1c, 0xce, 0x2f, 0xc5, 0x9c, 0x5d, 0x72, 0x9b, 0x8d,
+  0x97, 0xa7, 0x47, 0xc2, 0xc4, 0x41, 0xb2, 0x00, 0xf4, 0xa5, 0xb4, 0xdf,
+  0xf1, 0x51, 0x0f, 0x8c, 0x92, 0x16, 0xc3, 0xe2, 0x0c, 0xfc, 0xeb, 0x20,
+  0x8a, 0x6f, 0x7c, 0xf2, 0x83, 0xbf, 0x06, 0x70, 0xd0, 0xa2, 0xa1, 0x26,
+  0xff, 0x61, 0xa3, 0x23, 0x94, 0x77, 0xa4, 0x0b, 0x8d, 0x95, 0xa9, 0xd4,
+  0xa7, 0x7d, 0xff, 0x2f, 0xef, 0xff, 0x1a, 0x10, 0x5f, 0x2e, 0x31, 0x36,
+  0xdd, 0x94, 0x43, 0xfe, 0x07, 0xef, 0xb2, 0x66, 0x87, 0x36, 0xd0, 0x52,
+  0x8f, 0xf6, 0xe8, 0xd3, 0xf8, 0xfe, 0xaf, 0x92, 0xea, 0x57, 0x4f, 0xb0,
+  0x76, 0xff, 0xb2, 0xe5, 0x17, 0x7e, 0x60, 0xd4, 0xd7, 0x8f, 0x70, 0xe8,
+  0xc9, 0x41, 0x67, 0x34, 0xae, 0x07, 0xd5, 0x02, 0x5e, 0x2d, 0xd1, 0x52,
+  0x53, 0x2c, 0xbd, 0x61, 0x88, 0x9a, 0x3b, 0x9c, 0x98, 0x19, 0x2a, 0x6a,
+  0x88, 0xee, 0x11, 0xb7, 0xf7, 0xa0, 0x5c, 0xdc, 0xb9, 0xa5, 0x3b, 0xaa,
+  0x9e, 0x2d, 0x63, 0xe7, 0x91, 0xc1, 0x29, 0xba, 0xa6, 0xf4, 0x4b, 0xbf,
+  0xf5, 0xf4, 0xb4, 0x2a, 0xd6, 0x9c, 0x43, 0x6d, 0x68, 0x52, 0x46, 0x68,
+  0xd7, 0x32, 0x70, 0x01, 0x63, 0x48, 0x33, 0xa5, 0x11, 0xc2, 0x56, 0xc3,
+  0x37, 0x35, 0x72, 0xa2, 0xc4, 0x8e, 0x5f, 0x9f, 0xea, 0x97, 0x4d, 0x40,
+  0x48, 0x24, 0x8d, 0x40, 0x27, 0x4d, 0xfd, 0x18, 0x53, 0xbb, 0x4f, 0xe6,
+  0xbd, 0x24, 0x04, 0x99, 0xb3, 0xf4, 0x41, 0xe1, 0x57, 0xc9, 0xf3, 0xab,
+  0xc6, 0xf3, 0x64, 0x34, 0x36, 0xb9, 0x8f, 0x25, 0x45, 0x0d, 0x01, 0xd4,
+  0x68, 0xc6, 0xa0, 0xd1, 0x23, 0xc6, 0x20, 0xa1, 0x40, 0x35, 0x6c, 0xa4,
+  0x1f, 0x66, 0x6a, 0xbc, 0xa8, 0xdd, 0xd6, 0x78, 0xd1, 0x0b, 0xa4, 0xb4,
+  0x88, 0x23, 0x39, 0x0f, 0x14, 0x1d, 0x23, 0x44, 0xf0, 0xc8, 0x35, 0xd2,
+  0xd5, 0x9f, 0x9c, 0x9a, 0xb3, 0xe0, 0xea, 0x47, 0xcf, 0x8e, 0xa7, 0xff,
+  0x05, 0xbc, 0x47, 0xa4, 0x19, 0x06, 0x2d, 0x00, 0x00
+};
+
+const GFXglyph Oswald_Medium30pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  14,    0,    0 },   // 0x20 ' '
+  {     1,   8,  48,  14,    3,  -47 },   // 0x21 '!'
+  {    49,  17,  17,  19,    1,  -47 },   // 0x22 '"'
+  {    86,  26,  48,  30,    2,  -47 },   // 0x23 '#'
+  {   242,  25,  59,  29,    2,  -52 },   // 0x24 '$'
+  {   427,  51,  48,  56,    2,  -47 },   // 0x25 '%'
+  {   733,  29,  49,  34,    3,  -47 },   // 0x26 '&'
+  {   911,   7,  17,   9,    1,  -47 },   // 0x27 '''
+  {   926,  13,  59,  19,    4,  -47 },   // 0x28 '('
+  {  1022,  13,  59,  17,    2,  -47 },   // 0x29 ')'
+  {  1118,  21,  21,  24,    2,  -47 },   // 0x2A '*'
+  {  1174,  22,  24,  25,    2,  -35 },   // 0x2B '+'
+  {  1240,   8,  16,  13,    2,   -7 },   // 0x2C ','
+  {  1256,  14,   6,  18,    2,  -19 },   // 0x2D '-'
+  {  1267,   8,   8,  13,    3,   -7 },   // 0x2E '.'
+  {  1275,  19,  48,  23,    2,  -47 },   // 0x2F '/'
+  {  1389,  25,  49,  31,    3,  -47 },   // 0x30 '0'
+  {  1543,  15,  48,  22,    2,  -47 },   // 0x31 '1'
+  {  1633,  25,  48,  29,    2,  -47 },   // 0x32 '2'
+  {  1783,  25,  49,  29,    2,  -47 },   // 0x33 '3'
+  {  1937,  27,  48,  30,    2,  -47 },   // 0x34 '4'
+  {  2099,  24,  49,  29,    3,  -47 },   // 0x35 '5'
+  {  2246,  25,  49,  31,    3,  -47 },   // 0x36 '6'
+  {  2400,  21,  48,  24,    1,  -47 },   // 0x37 '7'
+  {  2526,  24,  49,  30,    3,  -47 },   // 0x38 '8'
+  {  2673,  25,  49,  31,    2,  -47 },   // 0x39 '9'
+  {  2827,   7,  28,  14,    4,  -31 },   // 0x3A ':'
+  {  2852,   8,  38,  15,    4,  -32 },   // 0x3B ';'
+  {  2890,  18,  25,  23,    2,  -36 },   // 0x3C '<'
+  {  2947,  19,  16,  25,    3,  -31 },   // 0x3D '='
+  {  2985,  18,  25,  23,    3,  -36 },   // 0x3E '>'
+  {  3042,  24,  48,  28,    2,  -47 },   // 0x3F '?'
+  {  3186,  50,  56,  55,    3,  -47 },   // 0x40 '@'
+  {  3536,  29,  48,  31,    1,  -47 },   // 0x41 'A'
+  {  3710,  27,  48,  33,    4,  -47 },   // 0x42 'B'
+  {  3872,  26,  49,  32,    3,  -47 },   // 0x43 'C'
+  {  4032,  26,  48,  33,    4,  -47 },   // 0x44 'D'
+  {  4188,  20,  48,  25,    4,  -47 },   // 0x45 'E'
+  {  4308,  19,  48,  24,    4,  -47 },   // 0x46 'F'
+  {  4422,  27,  49,  33,    3,  -47 },   // 0x47 'G'
+  {  4588,  27,  48,  34,    4,  -47 },   // 0x48 'H'
+  {  4750,   8,  48,  16,    4,  -47 },   // 0x49 'I'
+  {  4798,  15,  49,  19,    1,  -47 },   // 0x4A 'J'
+  {  4890,  27,  48,  31,    4,  -47 },   // 0x4B 'K'
+  {  5052,  20,  48,  25,    4,  -47 },   // 0x4C 'L'
+  {  5172,  34,  48,  40,    3,  -47 },   // 0x4D 'M'
+  {  5376,  24,  48,  32,    4,  -47 },   // 0x4E 'N'
+  {  5520,  27,  49,  33,    3,  -47 },   // 0x4F 'O'
+  {  5686,  26,  48,  31,    4,  -47 },   // 0x50 'P'
+  {  5842,  27,  57,  33,    3,  -47 },   // 0x51 'Q'
+  {  6035,  27,  48,  33,    4,  -47 },   // 0x52 'R'
+  {  6197,  26,  49,  29,    2,  -47 },   // 0x53 'S'
+  {  6357,  24,  48,  25,    1,  -47 },   // 0x54 'T'
+  {  6501,  27,  49,  33,    3,  -47 },   // 0x55 'U'
+  {  6667,  28,  48,  30,    1,  -47 },   // 0x56 'V'
+  {  6835,  38,  48,  42,    2,  -47 },   // 0x57 'W'
+  {  7063,  28,  48,  29,    1,  -47 },   // 0x58 'X'
+  {  7231,  27,  48,  29,    1,  -47 },   // 0x59 'Y'
+  {  7393,  22,  48,  25,    2,  -47 },   // 0x5A 'Z'
+  // Euro sign ([) - ASCII code 91
+  {     11030,  30,  49,  31,    0,  -47 },   // 0x5B '['
+  // Backslash placeholder - ASCII code 92
+  {      0,   0,   0,  0,    0,    0 },   // 0x5C '\' 
+  // Pound sign (]) - ASCII code 93
+   {     11214,  24,  48,  26,    1,  -47 },   // 0x5D ']'
+  // Yen sign (^) - ASCII code 94
+  {     11358,  28,  48,  27,    0,  -47 },    // 0x5E '^'
+  {  7905,  21,   6,  21,    0,    4 },   // 0x5F '_'
+  {  7921,  11,  12,  17,    3,  -47 },   // 0x60 '`'
+  {  7938,  22,  35,  26,    1,  -33 },   // 0x61 'a'
+  {  8035,  23,  49,  28,    3,  -47 },   // 0x62 'b'
+  {  8176,  22,  35,  26,    2,  -33 },   // 0x63 'c'
+  {  8273,  23,  49,  28,    2,  -47 },   // 0x64 'd'
+  {  8414,  22,  35,  26,    2,  -33 },   // 0x65 'e'
+  {  8511,  16,  46,  18,    1,  -45 },   // 0x66 'f'
+  {  8603,  28,  46,  28,    1,  -34 },   // 0x67 'g'
+  {  8764,  22,  48,  28,    3,  -47 },   // 0x68 'h'
+  {  8896,   8,  46,  15,    3,  -45 },   // 0x69 'i'
+  {  8942,  13,  56,  15,   -1,  -45 },   // 0x6A 'j'
+  {  9033,  25,  48,  28,    3,  -47 },   // 0x6B 'k'
+  {  9183,   8,  48,  15,    4,  -47 },   // 0x6C 'l'
+  {  9231,  36,  35,  42,    3,  -34 },   // 0x6D 'm'
+  {  9389,  22,  34,  28,    3,  -33 },   // 0x6E 'n'
+  {  9483,  22,  35,  27,    2,  -33 },   // 0x6F 'o'
+  {  9580,  23,  45,  28,    3,  -33 },   // 0x70 'p'
+  {  9710,  22,  45,  28,    3,  -33 },   // 0x71 'q'
+  {  9834,  17,  34,  21,    3,  -33 },   // 0x72 'r'
+  {  9907,  21,  35,  24,    1,  -33 },   // 0x73 's'
+  {  9999,  17,  44,  19,    1,  -43 },   // 0x74 't'
+  { 10093,  22,  35,  28,    3,  -33 },   // 0x75 'u'
+  { 10190,  22,  34,  24,    1,  -33 },   // 0x76 'v'
+  { 10284,  32,  34,  35,    1,  -33 },   // 0x77 'w'
+  { 10420,  23,  34,  24,    1,  -33 },   // 0x78 'x'
+  { 10518,  24,  43,  25,    0,  -33 },   // 0x79 'y'
+  { 10647,  18,  34,  22,    2,  -33 },   // 0x7A 'z'
+  { 10724,  15,  59,  20,    3,  -47 },   // 0x7B '{'
+  { 10835,   7,  58,  15,    4,  -47 },   // 0x7C '|'
+  { 10886,  16,  59,  21,    2,  -47 },   // 0x7D '}'
+  { 11004,  23,   9,  27,    2,  -28 } }; // 0x7E '~'
+
+// const GFXfont Oswald_Medium30pt7b PROGMEM = {
+//   (uint8_t  *)Oswald_Medium30pt7bBitmaps,
+//   (GFXglyph *)Oswald_Medium30pt7bGlyphs,
+//   0x20, 0x7E, 87 };
+
+// Approx. 11702 bytes
+
+
+// Font properties
+static constexpr FontData Oswald_Medium30pt7b_Properties = {
+    Oswald_Medium30pt7bBitmaps_Gzip,
+    Oswald_Medium30pt7bGlyphs,
+    sizeof(Oswald_Medium30pt7bBitmaps_Gzip),
+    11526,  // Original size
+    0x20,   // First char
+    0x7E,   // Last char
+    87     // yAdvance
+};

src/fonts/sats-symbol.h

@@ -0,0 +1,235 @@
+#pragma once
+
+#include <Adafruit_GFX.h>
+#include <Arduino.h>
+#include "fonts.hpp"
+
+const uint8_t Satoshi_Symbol90pt7bBitmaps_Gzip[] = {
+  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x63, 0x60,
+  0x60, 0x60, 0xe0, 0xff, 0xc7, 0x00, 0x05, 0xcc, 0xff, 0x1b, 0x60, 0xcc,
+  0xff, 0x0f, 0x60, 0x2c, 0xfb, 0x1f, 0x30, 0xd6, 0x60, 0x53, 0x38, 0x28,
+  0x81, 0xfd, 0x7f, 0x3a, 0x83, 0x81, 0xf6, 0x30, 0x1a, 0xe0, 0xa7, 0xb7,
+  0xff, 0x0f, 0x0c, 0xb4, 0x8f, 0x51, 0x01, 0x33, 0xbd, 0xfd, 0xff, 0x61,
+  0xa0, 0x7d, 0x8c, 0x17, 0x0c, 0x8e, 0x92, 0x82, 0x44, 0x85, 0x54, 0x8f,
+  0x23, 0x88, 0xe1, 0xec, 0xff, 0xa1, 0x56, 0xf2, 0xff, 0xff, 0x03, 0x61,
+  0xc8, 0xff, 0x87, 0x3a, 0xc7, 0x1e, 0x16, 0x8d, 0xf5, 0x30, 0xa7, 0xc2,
+  0x12, 0x36, 0xe3, 0x7f, 0xa8, 0xeb, 0x98, 0x47, 0x8d, 0x19, 0x35, 0x66,
+  0x78, 0x1b, 0x43, 0x65, 0xf0, 0x00, 0x00, 0xc7, 0x63, 0x9f, 0x4b, 0xde,
+  0x08, 0x00, 0x00
+};
+// unsigned int satoshi_bin_gz_len = 123;
+
+
+// const uint8_t Satoshi_Symbol90pt7bBitmaps[] PROGMEM = {
+//   0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+//   0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+//   0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0x80, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xE0, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x03, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+//   0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
+//   0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF,
+//   0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF,
+//   0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+//   0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
+//   0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF,
+//   0xFF, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF,
+//   0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF,
+//   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x0F, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F,
+//   0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+//   0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF,
+//   0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+//   0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x07, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//   0x7F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+//   0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x00, 0x3F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F,
+//   0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00, 0x00, 0x00, 0x00,
+//   0x00, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
+//   0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xFC, 0x00, 0x00,
+//   0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+//   0xFF, 0xE0 };
+
+const GFXglyph Satoshi_Symbol90pt7bGlyphs[] PROGMEM = {
+  {     0,  82, 127,  99,    8, -126 },  {  1302,  71, 109,  93,    0, -117 } }; // 0x53 'S'
+
+// const GFXfont Satoshi_Symbol90pt7b PROGMEM = {
+//   (uint8_t  *)Satoshi_Symbol90pt7bBitmaps,
+//   (GFXglyph *)Satoshi_Symbol90pt7bGlyphs,
+//   0x53, 0x53, 192 };
+
+  // Font properties
+static constexpr FontData Satoshi_Symbol90pt7b_Properties = {
+    Satoshi_Symbol90pt7bBitmaps_Gzip,
+    Satoshi_Symbol90pt7bGlyphs,
+    sizeof(Satoshi_Symbol90pt7bBitmaps_Gzip),
+    2270,  // Original size
+    0x53,   // First char
+    0x53,   // Last char
+    192    // yAdvance
+};
+
+
+// Approx. 2284 bytes

src/fonts/ubuntu-italic12.h

@@ -1,296 +0,0 @@
-const uint8_t Ubuntu_Italic12pt7bBitmaps[] PROGMEM = {
-  0x00, 0x0C, 0x31, 0x86, 0x18, 0x63, 0x0C, 0x30, 0x86, 0x00, 0x00, 0x0E,
-  0x38, 0xE0, 0x66, 0xCF, 0x36, 0x6C, 0xD1, 0x00, 0x01, 0x83, 0x03, 0x06,
-  0x03, 0x06, 0x03, 0x06, 0x7F, 0xFF, 0x7F, 0xFF, 0x0C, 0x18, 0x0C, 0x18,
-  0x1C, 0x38, 0x18, 0x30, 0x18, 0x30, 0xFF, 0xFE, 0xFF, 0xFE, 0x60, 0xC0,
-  0x60, 0xC0, 0x60, 0xC0, 0xC1, 0x80, 0x00, 0x60, 0x07, 0x00, 0x30, 0x07,
-  0xE0, 0xFF, 0x86, 0x08, 0x60, 0x03, 0x00, 0x18, 0x00, 0xE0, 0x03, 0xC0,
-  0x0F, 0x00, 0x1C, 0x00, 0x70, 0x01, 0x80, 0x0C, 0x00, 0x62, 0x0E, 0x3F,
-  0xF0, 0xFE, 0x00, 0xC0, 0x0E, 0x00, 0x60, 0x00, 0x1E, 0x03, 0x23, 0x06,
-  0x63, 0x0C, 0xC3, 0x18, 0xC3, 0x30, 0xC3, 0x70, 0xC6, 0x60, 0xC4, 0xC0,
-  0x79, 0x9E, 0x03, 0x23, 0x06, 0x63, 0x0E, 0xC3, 0x0C, 0xC3, 0x18, 0xC3,
-  0x30, 0xC6, 0x60, 0xC4, 0xC0, 0x78, 0x03, 0xE0, 0x1F, 0xC0, 0xE3, 0x03,
-  0x0C, 0x0C, 0x30, 0x31, 0x80, 0xCE, 0x01, 0xF0, 0x0F, 0x00, 0xFC, 0x27,
-  0x39, 0xD8, 0x66, 0xC0, 0xF3, 0x01, 0xCC, 0x06, 0x38, 0x7C, 0x7F, 0xB0,
-  0xF8, 0x60, 0x6F, 0x6D, 0x00, 0x01, 0x01, 0xC1, 0xC1, 0xC0, 0xC0, 0xC0,
-  0xE0, 0x60, 0x70, 0x30, 0x18, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0,
-  0x60, 0x30, 0x18, 0x06, 0x03, 0x01, 0x00, 0x02, 0x06, 0x06, 0x03, 0x03,
-  0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x06, 0x06, 0x0C, 0x0C,
-  0x18, 0x18, 0x30, 0x70, 0xE0, 0x40, 0x1C, 0x0E, 0x37, 0x7D, 0x77, 0xF0,
-  0xE0, 0xD8, 0xEE, 0x22, 0x00, 0x03, 0x00, 0x60, 0x18, 0x03, 0x00, 0x61,
-  0xFF, 0xFF, 0xF8, 0x60, 0x0C, 0x01, 0x80, 0x60, 0x0C, 0x00, 0x18, 0xCC,
-  0x67, 0x33, 0x00, 0xFF, 0xF0, 0xFF, 0x80, 0x00, 0x07, 0x00, 0x06, 0x00,
-  0x0E, 0x00, 0x0C, 0x00, 0x18, 0x00, 0x38, 0x00, 0x30, 0x00, 0x70, 0x00,
-  0x60, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x03, 0x80, 0x03, 0x00, 0x06,
-  0x00, 0x0E, 0x00, 0x0C, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x30, 0x00, 0x70,
-  0x00, 0x60, 0x00, 0xE0, 0x00, 0x03, 0xC0, 0xFE, 0x1C, 0x73, 0x83, 0x30,
-  0x37, 0x03, 0x60, 0x36, 0x03, 0xC0, 0x3C, 0x06, 0xC0, 0x6C, 0x0E, 0xC0,
-  0xCC, 0x1C, 0xE3, 0x87, 0xF0, 0x3C, 0x00, 0x06, 0x3C, 0xF7, 0xEC, 0xC1,
-  0x86, 0x0C, 0x18, 0x30, 0xE1, 0x83, 0x06, 0x0C, 0x30, 0x60, 0x07, 0xC0,
-  0xFE, 0x1C, 0x71, 0x03, 0x00, 0x30, 0x03, 0x00, 0x60, 0x0E, 0x01, 0xC0,
-  0x38, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0x60, 0x0F, 0xFC, 0xFF, 0xC0,
-  0x07, 0xC0, 0xFE, 0x08, 0x70, 0x03, 0x00, 0x30, 0x07, 0x00, 0xE0, 0x7C,
-  0x07, 0xC0, 0x0E, 0x00, 0x60, 0x06, 0x00, 0x60, 0x0E, 0x41, 0xCF, 0xF8,
-  0x7E, 0x00, 0x00, 0x38, 0x03, 0x80, 0x3C, 0x03, 0x60, 0x33, 0x03, 0x38,
-  0x31, 0x83, 0x8C, 0x18, 0x61, 0x87, 0x18, 0x30, 0xFF, 0xEF, 0xFF, 0x00,
-  0x60, 0x03, 0x00, 0x30, 0x01, 0x80, 0x03, 0xF8, 0x1F, 0xC1, 0x80, 0x0C,
-  0x00, 0xC0, 0x06, 0x00, 0x3C, 0x03, 0xF8, 0x01, 0xC0, 0x07, 0x00, 0x18,
-  0x00, 0xC0, 0x06, 0x00, 0x71, 0x07, 0x1F, 0xF0, 0x7E, 0x00, 0x00, 0xF0,
-  0x3F, 0x0F, 0x01, 0xC0, 0x38, 0x03, 0x00, 0x6F, 0x87, 0xFC, 0xF0, 0xEC,
-  0x06, 0xC0, 0x6C, 0x06, 0xC0, 0x6C, 0x0C, 0xE1, 0xC7, 0xF8, 0x3E, 0x00,
-  0x7F, 0xF7, 0xFF, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x38, 0x07, 0x00, 0x60,
-  0x0C, 0x01, 0xC0, 0x18, 0x03, 0x00, 0x30, 0x06, 0x00, 0x60, 0x0E, 0x00,
-  0xC0, 0x00, 0x07, 0xE0, 0x7F, 0x87, 0x0E, 0x70, 0x33, 0x01, 0x98, 0x0C,
-  0xE0, 0xC3, 0xFC, 0x1F, 0x81, 0xCE, 0x18, 0x39, 0x80, 0xCC, 0x06, 0x60,
-  0x73, 0x87, 0x0F, 0xF0, 0x3F, 0x00, 0x03, 0xE0, 0x7F, 0x87, 0x0E, 0x30,
-  0x33, 0x01, 0x98, 0x0C, 0xC0, 0x67, 0x07, 0x1F, 0xF8, 0x7F, 0x80, 0x0C,
-  0x00, 0xC0, 0x0E, 0x00, 0xE0, 0x1E, 0x1F, 0xC0, 0xF8, 0x00, 0x39, 0xCE,
-  0x00, 0x00, 0x00, 0x00, 0x39, 0xCE, 0x00, 0x0E, 0x1C, 0x38, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x60, 0xC3, 0x06, 0x1C, 0x30, 0xC0, 0x00, 0x10,
-  0x0F, 0x07, 0xE1, 0xF0, 0xF8, 0x0E, 0x00, 0x78, 0x01, 0xE0, 0x07, 0x80,
-  0x1C, 0x00, 0x00, 0x7F, 0xF7, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFE,
-  0xFF, 0xE0, 0x00, 0x03, 0x80, 0x1E, 0x00, 0x78, 0x01, 0xE0, 0x06, 0x03,
-  0xE0, 0xF8, 0x7E, 0x0F, 0x00, 0x80, 0x00, 0x1F, 0x1F, 0xC8, 0x60, 0x30,
-  0x18, 0x18, 0x1C, 0x1C, 0x18, 0x18, 0x18, 0x0C, 0x00, 0x00, 0x00, 0x01,
-  0xC0, 0xE0, 0x70, 0x00, 0x00, 0x7E, 0x00, 0x3F, 0xF8, 0x07, 0x81, 0xC0,
-  0xE0, 0x0E, 0x1C, 0x00, 0x73, 0x87, 0xC3, 0x31, 0xFE, 0x36, 0x38, 0x63,
-  0x63, 0x0C, 0x3C, 0x60, 0xC3, 0xC6, 0x0C, 0x3C, 0x61, 0x86, 0xC6, 0x18,
-  0x6C, 0x71, 0x8E, 0xC3, 0xFF, 0xCC, 0x1E, 0xF0, 0x60, 0x00, 0x07, 0x00,
-  0x00, 0x38, 0x10, 0x01, 0xFF, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x30, 0x01,
-  0xC0, 0x0F, 0x80, 0x36, 0x01, 0xD8, 0x06, 0x60, 0x31, 0x81, 0xC6, 0x06,
-  0x18, 0x38, 0x61, 0xC1, 0x87, 0xFF, 0x3F, 0xFC, 0xC0, 0x36, 0x00, 0xD8,
-  0x03, 0xC0, 0x0C, 0x0F, 0xF0, 0x3F, 0xE1, 0x81, 0xC6, 0x03, 0x18, 0x0C,
-  0x60, 0x33, 0x03, 0x8F, 0xFC, 0x3F, 0xF0, 0xC0, 0xE3, 0x01, 0x98, 0x06,
-  0x60, 0x19, 0x80, 0xE6, 0x0F, 0x3F, 0xF8, 0xFF, 0x00, 0x01, 0xF8, 0x1F,
-  0xF1, 0xE0, 0x8E, 0x00, 0x30, 0x01, 0x80, 0x06, 0x00, 0x30, 0x00, 0xC0,
-  0x03, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03, 0x80, 0x07, 0x06, 0x0F,
-  0xF8, 0x1F, 0xC0, 0x0F, 0xE0, 0x1F, 0xF0, 0x60, 0x70, 0xC0, 0x61, 0x80,
-  0x63, 0x00, 0xCE, 0x01, 0x98, 0x03, 0x30, 0x06, 0x60, 0x0C, 0xC0, 0x33,
-  0x00, 0x66, 0x01, 0x8C, 0x07, 0x18, 0x3C, 0x7F, 0xE0, 0xFF, 0x00, 0x0F,
-  0xF8, 0x7F, 0xC6, 0x00, 0x30, 0x01, 0x80, 0x0C, 0x00, 0xE0, 0x07, 0xF8,
-  0x3F, 0xC1, 0x80, 0x0C, 0x00, 0xC0, 0x06, 0x00, 0x30, 0x01, 0x80, 0x1F,
-  0xF8, 0xFF, 0xC0, 0x0F, 0xFC, 0x3F, 0xF1, 0x80, 0x06, 0x00, 0x18, 0x00,
-  0x60, 0x03, 0x00, 0x0F, 0xF8, 0x3F, 0xE0, 0xC0, 0x03, 0x00, 0x18, 0x00,
-  0x60, 0x01, 0x80, 0x06, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x01, 0xFC, 0x0F,
-  0xFC, 0x78, 0x11, 0xC0, 0x03, 0x00, 0x0C, 0x00, 0x18, 0x00, 0x70, 0x00,
-  0xC0, 0x01, 0x80, 0x33, 0x00, 0xE6, 0x01, 0x8C, 0x03, 0x1C, 0x06, 0x1C,
-  0x18, 0x1F, 0xF0, 0x1F, 0xC0, 0x0C, 0x03, 0x0C, 0x03, 0x18, 0x06, 0x18,
-  0x06, 0x18, 0x06, 0x18, 0x06, 0x38, 0x0C, 0x3F, 0xFC, 0x3F, 0xFC, 0x30,
-  0x0C, 0x30, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0xC0,
-  0x30, 0xC0, 0x30, 0x0C, 0x31, 0x86, 0x18, 0x63, 0x0C, 0x30, 0xC7, 0x18,
-  0x61, 0x86, 0x30, 0xC0, 0x00, 0x18, 0x00, 0xC0, 0x0C, 0x00, 0x60, 0x03,
-  0x00, 0x38, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x06, 0x00, 0x30, 0x01, 0x80,
-  0x0C, 0x00, 0xC1, 0x0E, 0x1F, 0xE0, 0x7E, 0x00, 0x0C, 0x07, 0x0C, 0x0E,
-  0x18, 0x3C, 0x18, 0x70, 0x18, 0xE0, 0x19, 0xC0, 0x3B, 0x80, 0x3F, 0x00,
-  0x3E, 0x00, 0x37, 0x00, 0x33, 0x80, 0x61, 0xC0, 0x61, 0xC0, 0x60, 0xE0,
-  0x60, 0x70, 0xC0, 0x30, 0xC0, 0x38, 0x0C, 0x03, 0x01, 0x80, 0x60, 0x18,
-  0x06, 0x03, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x01, 0x80, 0x60, 0x18, 0x06,
-  0x03, 0xFF, 0xFF, 0xC0, 0x06, 0x00, 0xE1, 0xC0, 0x1C, 0x3C, 0x07, 0x87,
-  0x81, 0xF1, 0xF0, 0x3E, 0x36, 0x0D, 0xC6, 0xE1, 0xB1, 0xCC, 0x66, 0x31,
-  0x8C, 0xC6, 0x33, 0x18, 0xC6, 0xC3, 0x30, 0xD8, 0xE6, 0x0E, 0x18, 0xC1,
-  0xC3, 0x38, 0x30, 0x66, 0x00, 0x0C, 0xC0, 0x01, 0x80, 0x0C, 0x01, 0x87,
-  0x00, 0xC7, 0x80, 0xC3, 0xE0, 0x61, 0xB0, 0x30, 0xDC, 0x18, 0xE6, 0x18,
-  0x63, 0x8C, 0x30, 0xC6, 0x18, 0x73, 0x0C, 0x1B, 0x8C, 0x0D, 0x86, 0x03,
-  0xC3, 0x01, 0xE1, 0x80, 0xF1, 0x80, 0x30, 0xC0, 0x18, 0x00, 0x03, 0xF0,
-  0x1F, 0xF0, 0x78, 0x71, 0xC0, 0x73, 0x00, 0x6C, 0x00, 0xD8, 0x01, 0xE0,
-  0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x36, 0x00, 0x6C, 0x01, 0x9C, 0x07,
-  0x1C, 0x3C, 0x1F, 0xF0, 0x1F, 0x80, 0x0F, 0xE0, 0x3F, 0xE1, 0x81, 0xC6,
-  0x03, 0x18, 0x0C, 0x60, 0x33, 0x80, 0xCC, 0x06, 0x30, 0x78, 0xFF, 0x83,
-  0xF8, 0x18, 0x00, 0x60, 0x01, 0x80, 0x06, 0x00, 0x30, 0x00, 0xC0, 0x00,
-  0x03, 0xF0, 0x1F, 0xF0, 0x78, 0x71, 0xC0, 0x73, 0x00, 0x6C, 0x00, 0xD8,
-  0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80, 0x0F, 0x00, 0x36, 0x00, 0x6C, 0x01,
-  0x9C, 0x07, 0x1C, 0x3C, 0x1F, 0xF0, 0x1F, 0x80, 0x0C, 0x00, 0x1E, 0x00,
-  0x1F, 0x00, 0x0E, 0x00, 0x0F, 0xE0, 0x3F, 0xE1, 0x81, 0xC6, 0x03, 0x18,
-  0x0C, 0x60, 0x33, 0x81, 0xCC, 0x1E, 0x3F, 0xF0, 0xFF, 0x83, 0x0C, 0x18,
-  0x18, 0x60, 0x61, 0x80, 0xC6, 0x03, 0x30, 0x0C, 0xC0, 0x18, 0x03, 0xF0,
-  0x7F, 0xC3, 0x04, 0x30, 0x01, 0x80, 0x0C, 0x00, 0x70, 0x01, 0xE0, 0x07,
-  0x80, 0x0E, 0x00, 0x38, 0x00, 0xC0, 0x06, 0x00, 0x31, 0x07, 0x1F, 0xF0,
-  0x7F, 0x00, 0xFF, 0xFF, 0xFF, 0x06, 0x00, 0x60, 0x0C, 0x00, 0xC0, 0x0C,
-  0x01, 0xC0, 0x18, 0x01, 0x80, 0x18, 0x03, 0x00, 0x30, 0x03, 0x00, 0x30,
-  0x06, 0x00, 0x60, 0x00, 0x18, 0x06, 0x30, 0x1C, 0xC0, 0x31, 0x80, 0x63,
-  0x00, 0xC6, 0x03, 0x18, 0x06, 0x30, 0x0C, 0x60, 0x39, 0xC0, 0x63, 0x00,
-  0xC6, 0x01, 0x8C, 0x06, 0x18, 0x0C, 0x38, 0x70, 0x3F, 0xE0, 0x3F, 0x00,
-  0xC0, 0x0F, 0x00, 0x6C, 0x01, 0xB0, 0x0C, 0xC0, 0x33, 0x01, 0x8E, 0x0E,
-  0x18, 0x30, 0x61, 0xC1, 0x86, 0x06, 0x30, 0x19, 0xC0, 0x66, 0x01, 0xB0,
-  0x07, 0xC0, 0x0E, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x3C, 0x00, 0x07, 0xC0,
-  0xC0, 0x6C, 0x0C, 0x06, 0xC1, 0xC0, 0xCC, 0x1C, 0x0C, 0xC3, 0x41, 0x8C,
-  0x36, 0x18, 0xC6, 0x63, 0x8C, 0x66, 0x30, 0xCC, 0x67, 0x0D, 0x86, 0x60,
-  0xD8, 0x6E, 0x0F, 0x06, 0xC0, 0xF0, 0x7C, 0x0E, 0x03, 0x80, 0xE0, 0x38,
-  0x00, 0x0C, 0x01, 0xC1, 0x80, 0xE0, 0x60, 0x30, 0x0C, 0x18, 0x03, 0x0C,
-  0x00, 0x66, 0x00, 0x1F, 0x00, 0x03, 0x80, 0x00, 0xE0, 0x00, 0x78, 0x00,
-  0x33, 0x00, 0x18, 0xC0, 0x0C, 0x18, 0x06, 0x06, 0x03, 0x00, 0xC1, 0x80,
-  0x30, 0xC0, 0x06, 0x00, 0xC0, 0x1F, 0x01, 0x98, 0x18, 0xC0, 0xC3, 0x0C,
-  0x18, 0xC0, 0xE6, 0x03, 0x60, 0x1E, 0x00, 0x70, 0x03, 0x00, 0x18, 0x01,
-  0x80, 0x0C, 0x00, 0x60, 0x07, 0x00, 0x30, 0x00, 0x0F, 0xFE, 0x1F, 0xFC,
-  0x00, 0x30, 0x00, 0xC0, 0x03, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03,
-  0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x03, 0x00, 0x0E, 0x00, 0x38, 0x00,
-  0x7F, 0xF8, 0xFF, 0xF0, 0x03, 0xE0, 0x7C, 0x18, 0x03, 0x00, 0x60, 0x0C,
-  0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x60, 0x0C, 0x01, 0x80, 0x70, 0x0C,
-  0x01, 0x80, 0x30, 0x0E, 0x01, 0x80, 0x30, 0x06, 0x01, 0xF8, 0x3F, 0x00,
-  0xC6, 0x31, 0x86, 0x31, 0x8C, 0x63, 0x18, 0xC3, 0x18, 0xC6, 0x31, 0x8C,
-  0x31, 0x8C, 0x60, 0x07, 0xE0, 0xFC, 0x03, 0x00, 0x60, 0x0C, 0x03, 0x80,
-  0x60, 0x0C, 0x01, 0x80, 0x70, 0x0C, 0x01, 0x80, 0x30, 0x0C, 0x01, 0x80,
-  0x30, 0x06, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC1, 0xF0, 0x3E, 0x00, 0x01,
-  0x80, 0x38, 0x06, 0xC0, 0xCC, 0x1C, 0xC3, 0x86, 0x30, 0x66, 0x07, 0x40,
-  0x20, 0xFF, 0xFF, 0xFF, 0x67, 0x1C, 0x71, 0x00, 0x03, 0xE0, 0xFF, 0x3C,
-  0x33, 0x06, 0x60, 0x6E, 0x06, 0xC0, 0x6C, 0x0C, 0xC0, 0xCC, 0x0C, 0xE1,
-  0xC7, 0xFC, 0x3E, 0xC0, 0x0C, 0x00, 0xC0, 0x1C, 0x01, 0x80, 0x18, 0x01,
-  0xBC, 0x1F, 0xE3, 0x87, 0x30, 0x33, 0x03, 0x30, 0x36, 0x03, 0x60, 0x76,
-  0x06, 0x60, 0xEC, 0x3C, 0xFF, 0x87, 0xE0, 0x07, 0xE3, 0xFC, 0xE1, 0x38,
-  0x06, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x03, 0x82, 0x3F, 0xC1,
-  0xF0, 0x00, 0x0C, 0x00, 0x70, 0x01, 0x80, 0x06, 0x00, 0x18, 0x0F, 0xC0,
-  0xFF, 0x0F, 0x0C, 0x30, 0x61, 0x81, 0x86, 0x06, 0x30, 0x38, 0xC0, 0xC3,
-  0x03, 0x0C, 0x0C, 0x38, 0x70, 0x7F, 0xC0, 0xF3, 0x00, 0x07, 0xC3, 0xFC,
-  0xE1, 0xB0, 0x36, 0x07, 0x83, 0xBF, 0xE7, 0xF0, 0xC0, 0x18, 0x03, 0x82,
-  0x3F, 0xC3, 0xF0, 0x00, 0x7C, 0x07, 0xE0, 0x18, 0x00, 0xE0, 0x03, 0x00,
-  0x0F, 0xC0, 0x7F, 0x01, 0x80, 0x06, 0x00, 0x18, 0x00, 0xC0, 0x03, 0x00,
-  0x0C, 0x00, 0x30, 0x01, 0x80, 0x06, 0x00, 0x18, 0x00, 0xE0, 0x03, 0x00,
-  0x0C, 0x00, 0x60, 0x03, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0xF0, 0xF0, 0xC3,
-  0x06, 0x18, 0x18, 0x60, 0x63, 0x01, 0x8C, 0x0C, 0x30, 0x30, 0xC0, 0xC3,
-  0x8F, 0x07, 0xF8, 0x0F, 0x60, 0x03, 0x84, 0x1C, 0x3F, 0xF0, 0x7F, 0x00,
-  0x0C, 0x01, 0x80, 0x70, 0x0C, 0x01, 0x80, 0x3F, 0x07, 0xF1, 0x87, 0x30,
-  0x66, 0x0C, 0xC1, 0xB8, 0x36, 0x0C, 0xC1, 0x98, 0x33, 0x06, 0xC1, 0x98,
-  0x30, 0x0C, 0x30, 0x00, 0x18, 0x63, 0x0C, 0x30, 0xC7, 0x18, 0x61, 0x8E,
-  0x30, 0xC0, 0x00, 0x60, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x01, 0x80, 0x60,
-  0x0C, 0x01, 0x80, 0x30, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x01, 0x80, 0x30,
-  0x06, 0x01, 0xC0, 0x30, 0x7E, 0x0F, 0x00, 0x0C, 0x00, 0xC0, 0x18, 0x01,
-  0x80, 0x18, 0x01, 0x83, 0x10, 0xC3, 0x18, 0x33, 0x03, 0x60, 0x2C, 0x07,
-  0xC0, 0x6C, 0x06, 0x60, 0x63, 0x06, 0x38, 0xC1, 0x8C, 0x1C, 0x18, 0xCE,
-  0x63, 0x18, 0xCC, 0x63, 0x19, 0xCC, 0x63, 0x18, 0xF3, 0x80, 0x0F, 0xCF,
-  0x07, 0xFF, 0xE1, 0x8F, 0x1C, 0xC1, 0x83, 0x30, 0x60, 0xCC, 0x18, 0x33,
-  0x06, 0x0D, 0x83, 0x06, 0x60, 0xC1, 0x98, 0x30, 0x66, 0x0C, 0x1B, 0x06,
-  0x0C, 0xC1, 0x83, 0x00, 0x0F, 0x83, 0xF8, 0x63, 0x98, 0x33, 0x06, 0x60,
-  0xCC, 0x1B, 0x06, 0x60, 0xCC, 0x19, 0x83, 0x60, 0xCC, 0x18, 0x0F, 0x83,
-  0xF8, 0xE3, 0xB8, 0x36, 0x07, 0xC0, 0xF0, 0x1E, 0x07, 0xC0, 0xD8, 0x3B,
-  0x8E, 0x3F, 0x83, 0xE0, 0x07, 0xE0, 0x7F, 0x83, 0x0E, 0x30, 0x31, 0x81,
-  0x8C, 0x0C, 0x60, 0x66, 0x07, 0x30, 0x31, 0x83, 0x8C, 0x78, 0xFF, 0x87,
-  0xF0, 0x30, 0x01, 0x80, 0x18, 0x00, 0xC0, 0x00, 0x03, 0xE0, 0xFF, 0x3C,
-  0x33, 0x06, 0x60, 0x6E, 0x06, 0xC0, 0x6C, 0x0C, 0xC0, 0xCC, 0x0C, 0xE1,
-  0xC7, 0xF8, 0x3D, 0x80, 0x18, 0x03, 0x80, 0x30, 0x03, 0x00, 0x0F, 0x8F,
-  0xC6, 0x06, 0x03, 0x01, 0x80, 0xC0, 0xC0, 0x60, 0x30, 0x18, 0x18, 0x0C,
-  0x00, 0x0F, 0x87, 0xF3, 0x88, 0xC0, 0x30, 0x0F, 0x01, 0xF0, 0x1E, 0x01,
-  0x80, 0x64, 0x3B, 0xFC, 0x7E, 0x00, 0x18, 0x0C, 0x0C, 0x06, 0x03, 0xF9,
-  0xFD, 0x80, 0xC0, 0x60, 0x70, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x11, 0xF8,
-  0x78, 0x00, 0x30, 0x66, 0x0D, 0x83, 0x30, 0x66, 0x0D, 0x81, 0xB0, 0x36,
-  0x0C, 0xC1, 0x98, 0x33, 0x8E, 0x3F, 0xC7, 0xD8, 0xE0, 0x6C, 0x1D, 0x83,
-  0x30, 0x66, 0x18, 0xC7, 0x18, 0xC3, 0x38, 0x66, 0x0D, 0xC1, 0xF0, 0x3C,
-  0x03, 0x00, 0xC0, 0xC0, 0xF0, 0x30, 0x7C, 0x0C, 0x1B, 0x07, 0x06, 0xC1,
-  0xC3, 0x30, 0xF0, 0xCE, 0x24, 0x63, 0x99, 0x98, 0x6C, 0x6C, 0x1B, 0x1F,
-  0x07, 0x87, 0x81, 0xE1, 0xE0, 0x70, 0x70, 0x00, 0x18, 0x70, 0xC6, 0x0C,
-  0xC0, 0x7C, 0x07, 0x80, 0x70, 0x07, 0x00, 0xF8, 0x1D, 0x81, 0x9C, 0x30,
-  0xC6, 0x0C, 0xE0, 0x60, 0x0C, 0x0C, 0x30, 0x70, 0xC1, 0x83, 0x06, 0x0C,
-  0x38, 0x38, 0xC0, 0x63, 0x01, 0x98, 0x06, 0x60, 0x1B, 0x00, 0x7C, 0x01,
-  0xE0, 0x03, 0x80, 0x1C, 0x00, 0xE0, 0x3F, 0x00, 0xF0, 0x00, 0x1F, 0xF1,
-  0xFF, 0x00, 0x60, 0x0C, 0x03, 0x80, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07,
-  0x00, 0xE0, 0x0F, 0xFC, 0xFF, 0xC0, 0x03, 0x83, 0xC3, 0x81, 0x80, 0xC0,
-  0x60, 0x60, 0x30, 0x18, 0x18, 0x38, 0x1C, 0x06, 0x03, 0x01, 0x80, 0xC0,
-  0x60, 0x60, 0x30, 0x18, 0x0C, 0x07, 0x81, 0xC0, 0x03, 0x03, 0x06, 0x06,
-  0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x1C, 0x18, 0x18, 0x18, 0x30, 0x30, 0x30,
-  0x30, 0x60, 0x60, 0x60, 0x60, 0xC0, 0xC0, 0x03, 0x80, 0x78, 0x03, 0x00,
-  0x60, 0x0C, 0x01, 0x80, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x03, 0x80, 0xF0,
-  0x18, 0x06, 0x00, 0xC0, 0x18, 0x07, 0x00, 0xC0, 0x18, 0x03, 0x00, 0xC1,
-  0xF8, 0x3C, 0x00, 0x3C, 0x1B, 0xF1, 0xF8, 0xFD, 0x83, 0xC0 };
-
-const GFXglyph Ubuntu_Italic12pt7bGlyphs[] PROGMEM = {
-  {     0,   1,   1,   6,    0,    0 },   // 0x20 ' '
-  {     1,   6,  17,   6,    2,  -16 },   // 0x21 '!'
-  {    14,   7,   6,  10,    6,  -17 },   // 0x22 '"'
-  {    20,  16,  17,  16,    2,  -16 },   // 0x23 '#'
-  {    54,  13,  23,  14,    2,  -19 },   // 0x24 '$'
-  {    92,  16,  17,  20,    4,  -16 },   // 0x25 '%'
-  {   126,  14,  18,  15,    2,  -17 },   // 0x26 '&'
-  {   158,   3,   6,   6,    6,  -17 },   // 0x27 '''
-  {   161,   9,  23,   8,    4,  -18 },   // 0x28 '('
-  {   187,   8,  23,   8,   -1,  -18 },   // 0x29 ')'
-  {   210,   9,   9,  11,    4,  -16 },   // 0x2A '*'
-  {   221,  11,  12,  14,    3,  -12 },   // 0x2B '+'
-  {   238,   5,   7,   6,    0,   -2 },   // 0x2C ','
-  {   243,   6,   2,   7,    2,   -7 },   // 0x2D '-'
-  {   245,   3,   3,   6,    2,   -2 },   // 0x2E '.'
-  {   247,  16,  23,   9,   -2,  -18 },   // 0x2F '/'
-  {   293,  12,  17,  14,    3,  -16 },   // 0x30 '0'
-  {   319,   7,  17,  14,    6,  -16 },   // 0x31 '1'
-  {   334,  12,  17,  14,    3,  -16 },   // 0x32 '2'
-  {   360,  12,  17,  14,    3,  -16 },   // 0x33 '3'
-  {   386,  13,  17,  14,    2,  -16 },   // 0x34 '4'
-  {   414,  13,  17,  14,    2,  -16 },   // 0x35 '5'
-  {   442,  12,  17,  14,    3,  -16 },   // 0x36 '6'
-  {   468,  12,  17,  14,    4,  -16 },   // 0x37 '7'
-  {   494,  13,  17,  14,    3,  -16 },   // 0x38 '8'
-  {   522,  13,  17,  14,    2,  -16 },   // 0x39 '9'
-  {   550,   5,  13,   6,    2,  -12 },   // 0x3A ':'
-  {   559,   7,  17,   6,    0,  -12 },   // 0x3B ';'
-  {   574,  12,  11,  14,    3,  -12 },   // 0x3C '<'
-  {   591,  12,   7,  14,    3,  -10 },   // 0x3D '='
-  {   602,  12,  11,  14,    3,  -12 },   // 0x3E '>'
-  {   619,   9,  18,   9,    3,  -17 },   // 0x3F '?'
-  {   640,  20,  21,  22,    3,  -16 },   // 0x40 '@'
-  {   693,  14,  17,  15,    0,  -16 },   // 0x41 'A'
-  {   723,  14,  17,  15,    2,  -16 },   // 0x42 'B'
-  {   753,  14,  17,  14,    3,  -16 },   // 0x43 'C'
-  {   783,  15,  17,  17,    3,  -16 },   // 0x44 'D'
-  {   815,  13,  17,  13,    2,  -16 },   // 0x45 'E'
-  {   843,  14,  17,  13,    2,  -16 },   // 0x46 'F'
-  {   873,  15,  17,  16,    3,  -16 },   // 0x47 'G'
-  {   905,  16,  17,  16,    2,  -16 },   // 0x48 'H'
-  {   939,   6,  17,   6,    2,  -16 },   // 0x49 'I'
-  {   952,  13,  17,  12,    1,  -16 },   // 0x4A 'J'
-  {   980,  16,  17,  15,    2,  -16 },   // 0x4B 'K'
-  {  1014,  10,  17,  12,    2,  -16 },   // 0x4C 'L'
-  {  1036,  19,  17,  20,    2,  -16 },   // 0x4D 'M'
-  {  1077,  17,  17,  17,    2,  -16 },   // 0x4E 'N'
-  {  1114,  15,  17,  18,    4,  -16 },   // 0x4F 'O'
-  {  1146,  14,  17,  14,    2,  -16 },   // 0x50 'P'
-  {  1176,  15,  21,  18,    4,  -16 },   // 0x51 'Q'
-  {  1216,  14,  17,  15,    2,  -16 },   // 0x52 'R'
-  {  1246,  13,  17,  12,    1,  -16 },   // 0x53 'S'
-  {  1274,  12,  17,  13,    4,  -16 },   // 0x54 'T'
-  {  1300,  15,  17,  16,    3,  -16 },   // 0x55 'U'
-  {  1332,  14,  17,  15,    4,  -16 },   // 0x56 'V'
-  {  1362,  20,  17,  22,    5,  -16 },   // 0x57 'W'
-  {  1405,  18,  17,  15,    0,  -16 },   // 0x58 'X'
-  {  1444,  13,  17,  14,    4,  -16 },   // 0x59 'Y'
-  {  1472,  15,  17,  13,    1,  -16 },   // 0x5A 'Z'
-  {  1504,  11,  23,   8,    1,  -18 },   // 0x5B '['
-  {  1536,   5,  23,   9,    3,  -18 },   // 0x5C '\'
-  {  1551,  11,  23,   8,   -1,  -18 },   // 0x5D ']'
-  {  1583,  12,   9,  14,    3,  -16 },   // 0x5E '^'
-  {  1597,  12,   2,  12,   -1,    3 },   // 0x5F '_'
-  {  1600,   5,   5,   9,    5,  -18 },   // 0x60 '`'
-  {  1604,  12,  13,  13,    2,  -12 },   // 0x61 'a'
-  {  1624,  12,  18,  13,    2,  -17 },   // 0x62 'b'
-  {  1651,  11,  13,  11,    2,  -12 },   // 0x63 'c'
-  {  1669,  14,  18,  13,    2,  -17 },   // 0x64 'd'
-  {  1701,  11,  13,  12,    2,  -12 },   // 0x65 'e'
-  {  1719,  14,  22,   9,    0,  -17 },   // 0x66 'f'
-  {  1758,  14,  17,  13,    0,  -12 },   // 0x67 'g'
-  {  1788,  11,  18,  13,    2,  -17 },   // 0x68 'h'
-  {  1813,   6,  17,   6,    2,  -16 },   // 0x69 'i'
-  {  1826,  11,  21,   6,   -3,  -16 },   // 0x6A 'j'
-  {  1855,  12,  18,  12,    2,  -17 },   // 0x6B 'k'
-  {  1882,   5,  18,   7,    3,  -17 },   // 0x6C 'l'
-  {  1894,  18,  13,  20,    2,  -12 },   // 0x6D 'm'
-  {  1924,  11,  13,  13,    2,  -12 },   // 0x6E 'n'
-  {  1942,  11,  13,  13,    2,  -12 },   // 0x6F 'o'
-  {  1960,  13,  17,  13,    1,  -12 },   // 0x70 'p'
-  {  1988,  12,  17,  13,    2,  -12 },   // 0x71 'q'
-  {  2014,   9,  13,   9,    2,  -12 },   // 0x72 'r'
-  {  2029,  10,  13,  10,    1,  -12 },   // 0x73 's'
-  {  2046,   9,  17,   9,    3,  -16 },   // 0x74 't'
-  {  2066,  11,  13,  13,    3,  -12 },   // 0x75 'u'
-  {  2084,  11,  13,  12,    3,  -12 },   // 0x76 'v'
-  {  2102,  18,  13,  19,    3,  -12 },   // 0x77 'w'
-  {  2132,  12,  13,  11,    1,  -12 },   // 0x78 'x'
-  {  2152,  14,  17,  11,   -1,  -12 },   // 0x79 'y'
-  {  2182,  12,  13,  11,    1,  -12 },   // 0x7A 'z'
-  {  2202,   9,  23,   8,    3,  -18 },   // 0x7B '{'
-  {  2228,   8,  23,   7,    1,  -18 },   // 0x7C '|'
-  {  2251,  11,  23,   8,   -1,  -18 },   // 0x7D '}'
-  {  2283,  13,   4,  14,    2,   -8 } }; // 0x7E '~'
-
-const GFXfont Ubuntu_Italic12pt7b PROGMEM = {
-  (uint8_t  *)Ubuntu_Italic12pt7bBitmaps,
-  (GFXglyph *)Ubuntu_Italic12pt7bGlyphs,
-  0x20, 0x7E, 27 };
-
-// Approx. 2962 bytes

src/icons/icons.cpp

@@ -0,0 +1,542 @@
+#include "icons.h"
+
+// 'lightning-bolt', 122x122px
+const unsigned char epd_icons_lightning_bolt [] PROGMEM = {
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0
+};
+// 'rocket-launch', 122x122px
+const unsigned char epd_icons_rocket_launch [] PROGMEM = {
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x07, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x0f, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x1f, 0xff, 0x80, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x1f, 0xff, 0x80, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xfe, 0xf8, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xf1, 0xf0, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xc1, 0xf0, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0x03, 0xe0, 0x00, 0x00, 0x1f, 0xff, 0x80, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xfc, 0x03, 0xc0, 0x00, 0x00, 0x0f, 0xff, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf0, 0x07, 0xc0, 0x00, 0x00, 0x07, 0xfe, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x80, 0x0f, 0x80, 0x00, 0x00, 0x03, 0xfc, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfe, 0x00, 0x0f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf8, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x80, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x80, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf8, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xc0, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xfc, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf0, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xe0, 0x7e, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xc0, 0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x81, 0xff, 0x80, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x03, 0xff, 0xc0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfe, 0x07, 0xe7, 0xe0, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfc, 0x0f, 0xc3, 0xf0, 0x00, 0x00, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf8, 0x1f, 0x81, 0xf8, 0x00, 0x03, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf0, 0x3f, 0x00, 0xfc, 0x00, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x7e, 0x00, 0x7e, 0x00, 0x3f, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xc0, 0xfc, 0x00, 0x3f, 0x80, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x81, 0xf8, 0x00, 0x7f, 0xff, 0xfe, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x03, 0xf0, 0x00, 0xff, 0xff, 0xf8, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x07, 0xe0, 0x01, 0xf3, 0xff, 0xe0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x0f, 0xc0, 0x03, 0xe0, 0xff, 0x80, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x1f, 0x80, 0x07, 0xc0, 0xff, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x3f, 0x00, 0x0f, 0x81, 0xff, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x7e, 0x00, 0x1f, 0x03, 0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfc, 0x00, 0x3e, 0x07, 0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf8, 0x00, 0x7c, 0x0f, 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf0, 0x00, 0xf8, 0x1f, 0xff, 0xc0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x01, 0xf0, 0x3f, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xc0, 0x03, 0xe0, 0x7f, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x80, 0x07, 0xc0, 0xff, 0xff, 0xe0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x00, 0x0f, 0x81, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x00, 0x1f, 0x03, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x00, 0x3e, 0x07, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x00, 0x7c, 0x0f, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x00, 0xf8, 0x1f, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x01, 0xf0, 0x3f, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0
+};
+// 'pickaxe', 122x122px
+const unsigned char epd_icons_pickaxe [] PROGMEM = {
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x31, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xe0, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x7f, 0xf8, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xfd, 0x80, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xff, 0xe0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xf8, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x1f, 0xff, 0xfc, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xfe, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x01, 0xff, 0xff, 0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xe0, 0x0f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xe0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xfe, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xe0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xfe, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xe0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfe, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf0, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0x80, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xc0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xe0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0
+};
+
+const unsigned char epd_icons_bitaxe_logo [] PROGMEM = {
+	// 'bitaxe_dark copy', 88x220px
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3e, 0xff, 0xff, 0xfd, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0xff, 0xff, 0xfc, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfe, 
+	0x00, 0xff, 0xff, 0xfe, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x7f, 0xff, 0xff, 0x00, 
+	0x07, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x3f, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 
+	0xf8, 0x00, 0x3f, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x1f, 0xff, 0xff, 
+	0xf0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x0f, 0xff, 0xff, 0xf8, 0x03, 0xff, 0xff, 0xff, 
+	0xff, 0xf0, 0x00, 0x07, 0xff, 0xff, 0xf8, 0x01, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x03, 0xff, 
+	0xff, 0xfc, 0x00, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x00, 0x7f, 0xff, 
+	0xff, 0xff, 0xe0, 0x07, 0xf8, 0x7f, 0xff, 0xfd, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xe0, 0x07, 0xfe, 
+	0x3f, 0xff, 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0x1f, 0xff, 0xff, 0xf8, 0x07, 
+	0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xcf, 0xff, 0xff, 0xf8, 0x01, 0xff, 0xff, 0xff, 0x80, 0x0f, 
+	0xff, 0xe7, 0xff, 0xff, 0xf8, 0x01, 0xff, 0xff, 0xff, 0x80, 0x1f, 0xff, 0xf3, 0xff, 0xff, 0xf0, 
+	0x01, 0xff, 0xff, 0xff, 0xc0, 0x1f, 0xff, 0xf3, 0xff, 0xff, 0xf0, 0x03, 0xff, 0xff, 0xff, 0xf0, 
+	0x1f, 0xff, 0xf9, 0xff, 0xff, 0xf0, 0x03, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xfd, 0xff, 0xff, 
+	0xe0, 0x07, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xfd, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 
+	0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 
+	0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 
+	0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 
+	0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xfc, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfe, 
+	0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0x7f, 
+	0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xfc, 0x7f, 0xff, 0xff, 
+	0xff, 0xfc, 0x00, 0x00, 0x7f, 0x3f, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x7e, 
+	0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x0f, 0xff, 
+	0xff, 0xff, 0xf0, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 
+	0x3c, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x03, 
+	0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0x80, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x0f, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xf8, 
+	0x1f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xfc, 0x1f, 0xff, 0xf0, 0x03, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x07, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 
+	0x0f, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0x80, 0x1f, 0xff, 0xfc, 0xff, 0xff, 
+	0xff, 0xff, 0xfc, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 
+	0x00, 0x3f, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 
+	0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xf0, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 
+	0x01, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xc0, 
+	0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0xf8, 0x00, 
+	0x00, 0x0f, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 
+	0xe0, 0x0f, 0xff, 0xf1, 0xf8, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xf9, 0xfc, 
+	0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x1f, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0x3f, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 
+	0xff, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xfd, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xfe, 0x3f, 
+	0xff, 0xf8, 0xff, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x1f, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xfc, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 
+	0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 
+	0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xf7, 0xff, 0xff, 0xfc, 0x3f, 0xff, 
+	0xff, 0xff, 0xe0, 0x07, 0xff, 0xf3, 0xff, 0xff, 0xfc, 0x1f, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 
+	0xf3, 0xff, 0xff, 0xf8, 0x07, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xf3, 0xff, 0xff, 0xf8, 0x01, 
+	0xff, 0xff, 0xff, 0x80, 0x0f, 0xff, 0xf9, 0xff, 0xff, 0xf0, 0x01, 0xff, 0xff, 0xff, 0x80, 0x1f, 
+	0xff, 0xf9, 0xff, 0xff, 0xf0, 0x03, 0xff, 0xff, 0xff, 0xc0, 0x1f, 0xff, 0xfc, 0xff, 0xff, 0xf0, 
+	0x03, 0xff, 0xff, 0xff, 0xf0, 0x1f, 0xff, 0xfe, 0x3f, 0xff, 0xe0, 0x03, 0xff, 0xff, 0xff, 0xf8, 
+	0x3f, 0xff, 0x7e, 0x1f, 0xff, 0xe0, 0x07, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xfc, 0xff, 0x03, 0xff, 
+	0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x80, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 
+	0xff, 0x80, 0x01, 0xff, 0xc0, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x80, 0x03, 0xff, 0xe0, 
+	0x00, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xe0, 0x00, 0x00, 0x1f, 0xff, 0xff, 
+	0xff, 0xff, 0xe0, 0x1f, 0xff, 0xf0, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xff, 
+	0xf8, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x7f, 0xff, 0xf8, 0x00, 0x00, 0x3f, 0xff, 
+	0xff, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xf8, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, 
+	0xff, 0xfc, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x7f, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x87, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xfc, 0x7f, 0xff, 0xff, 
+	0xff, 0x83, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 
+	0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x0f, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xff, 0x80, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xf8, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0x83, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xf8, 0x7f, 
+	0xff, 0xf9, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xf0, 0xff, 0xf8, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xe0, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x07, 0xff, 0xc0, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x80, 0x1f, 0xf0, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x80, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0xff, 0xc0, 0x3f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xe0, 0x3f, 
+	0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x7f, 0x80, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x1f, 0xff, 0xf9, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 
+	0xff, 0xf0, 0x1f, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x1f, 0xff, 0xfd, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xfe, 0x3f, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x1f, 0xff, 
+	0xff, 0xfc, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x1f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 
+	0xef, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xfc, 0x00, 
+	0x00, 0x01, 0xf8, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 
+	0x00, 0x07, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf8, 
+	0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x60, 0x00, 
+	0x00, 0x00, 0x03, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 
+	0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 
+	0xff, 0xe0, 0x07, 0xff, 0xff, 0x80, 0x0f, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xe0, 0x07, 0xff, 0xff, 
+	0x80, 0x1f, 0xff, 0xff, 0xfc, 0x1f, 0xff, 0xc0, 0x07, 0xff, 0xff, 0x80, 0x1f, 0xff, 0xff, 0xf8, 
+	0x0f, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xf8, 0x07, 0xff, 0x80, 0x0f, 0xff, 
+	0xff, 0x00, 0x3f, 0xff, 0xff, 0xf8, 0x03, 0xff, 0x80, 0x1f, 0xff, 0xff, 0x80, 0x3f, 0xff, 0xff, 
+	0xf0, 0x01, 0xff, 0xc0, 0x1f, 0xff, 0xff, 0xc0, 0x3f, 0xff, 0xff, 0xf0, 0x01, 0xff, 0xf0, 0x1f, 
+	0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xf0, 0x03, 0xff, 0xf8, 0x3f, 0xff, 0xff, 0xf8, 0x7f, 0xff, 
+	0xff, 0xe0, 0x03, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xfe, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x07, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 
+	0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 
+	0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x7f, 0xff, 0x80, 0x00, 0xff, 0xff, 0xff, 0xe0, 0x3f, 0xfe, 0x00, 0x7f, 0xff, 0x80, 0x03, 0xff, 
+	0xff, 0xff, 0xf8, 0xff, 0xfe, 0x00, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xfe, 
+	0x00, 0xff, 0xff, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xfe, 0x00, 0xff, 0xff, 0xe0, 0x1f, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xfe, 0x01, 0xff, 0xff, 0xf8, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0xff, 0xff, 0xfc, 
+	0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xfe, 0x03, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 
+	0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0xff, 
+	0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff, 
+	0xbf, 0xff, 0xff, 0xff, 0xc1, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xe0, 
+	0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x7f, 0xff, 0xff, 0xff, 0x9f, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x3f, 0xe7, 0xff, 0xff, 0xe7, 0xfd, 0xff, 0xff, 0xff, 0xff, 
+	0xfe, 0x00, 0x1f, 0xff, 0xff, 0xfc, 0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x7f, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
+	0xff, 0xff, 0xff, 0xff
+};
+
+// Array of all bitmaps for convenience. (Total bytes used to store images in PROGMEM = 8032)
+const int epd_icons_allArray_LEN = 4;
+const unsigned char* epd_icons_allArray[epd_icons_allArray_LEN] = {
+	epd_icons_pickaxe,
+	epd_icons_rocket_launch,
+	epd_icons_lightning_bolt,
+	epd_icons_bitaxe_logo
+};

src/icons/icons.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef ICONS_H
+#define ICONS_H
+
+#include <Arduino.h>
+
+extern const unsigned char* epd_icons_allArray[];
+
+#endif // ICONS_H

src/idf_component.yml

@@ -1,6 +1,3 @@
 dependencies:
   # Required IDF version
   idf: ">=4.4"
-
-  esp_littlefs:
-    git: https://github.com/joltwallet/esp_littlefs.git

src/lib/bitaxe_fetch.cpp

@@ -0,0 +1,60 @@
+#include "bitaxe_fetch.hpp"
+
+void BitAxeFetch::taskWrapper(void* pvParameters) {
+    BitAxeFetch::getInstance().task();
+}
+
+uint64_t BitAxeFetch::getHashRate() const {
+    return hashrate;
+}
+
+uint64_t BitAxeFetch::getBestDiff() const {
+    return bestDiff;
+}
+
+void BitAxeFetch::task() {
+    for (;;) {
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+        HTTPClient http;
+        http.setUserAgent(USER_AGENT);
+        String bitaxeApiUrl = "http://" + preferences.getString("bitaxeHostname", DEFAULT_BITAXE_HOSTNAME) + "/api/system/info";
+        http.begin(bitaxeApiUrl.c_str());
+
+        int httpCode = http.GET();
+
+        if (httpCode == 200) {
+            String payload = http.getString();
+            JsonDocument doc;
+            deserializeJson(doc, payload);
+            
+            // Convert GH/s to H/s (multiply by 10^9)
+            float hashRateGH = doc["hashRate"].as<float>();
+            hashrate = static_cast<uint64_t>(std::round(hashRateGH * std::pow(10, getHashrateMultiplier('G'))));
+            
+            // Parse difficulty string and convert to uint64_t
+            std::string diffStr = doc["bestDiff"].as<std::string>();
+            char diffUnit = diffStr[diffStr.length() - 1];
+            if (std::isalpha(diffUnit)) {
+                float diffValue = std::stof(diffStr.substr(0, diffStr.length() - 1));
+                bestDiff = static_cast<uint64_t>(std::round(diffValue * std::pow(10, getDifficultyMultiplier(diffUnit))));
+            } else {
+                bestDiff = std::stoull(diffStr);
+            }
+
+            if (workQueue != nullptr && (ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_HASHRATE || ScreenHandler::getCurrentScreen() == SCREEN_BITAXE_BESTDIFF)) {
+                WorkItem priceUpdate = {TASK_BITAXE_UPDATE, 0};
+                xQueueSend(workQueue, &priceUpdate, portMAX_DELAY);
+            }
+        } else {
+            Serial.print(F("Error retrieving BitAxe data. HTTP status code: "));
+            Serial.println(httpCode);
+            Serial.println(bitaxeApiUrl);
+        }
+    }
+}
+
+void BitAxeFetch::setup() {
+    xTaskCreate(taskWrapper, "bitaxeFetch", (3 * 1024), NULL, tskIDLE_PRIORITY, &taskHandle);
+    xTaskNotifyGive(taskHandle);
+}

src/lib/bitaxe_fetch.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <Arduino.h>
+#include <HTTPClient.h>
+#include <utils.hpp>
+
+#include "lib/config.hpp"
+#include "lib/shared.hpp"
+
+class BitAxeFetch {
+public:
+    static BitAxeFetch& getInstance() {
+        static BitAxeFetch instance;
+        return instance;
+    }
+
+    void setup();
+    uint64_t getHashRate() const;
+    uint64_t getBestDiff() const;
+    static void taskWrapper(void* pvParameters);
+    TaskHandle_t getTaskHandle() const { return taskHandle; }
+
+private:
+    BitAxeFetch() = default;
+    ~BitAxeFetch() = default;
+    BitAxeFetch(const BitAxeFetch&) = delete;
+    BitAxeFetch& operator=(const BitAxeFetch&) = delete;
+
+    void task();
+    
+    TaskHandle_t taskHandle = nullptr;
+    uint64_t hashrate = 0;
+    uint64_t bestDiff = 0;
+};

src/lib/block_notify.cpp

@@ -1,117 +1,325 @@
 #include "block_notify.hpp"
 
-char *wsServer;
-esp_websocket_client_handle_t blockNotifyClient = NULL;
-unsigned long int currentBlockHeight;
+// Initialize static members
+esp_websocket_client_handle_t BlockNotify::wsClient = nullptr;
+uint32_t BlockNotify::currentBlockHeight = 878000;
+uint16_t BlockNotify::blockMedianFee = 1;
+bool BlockNotify::notifyInit = false;
+unsigned long int BlockNotify::lastBlockUpdate = 0;
+TaskHandle_t BlockNotify::taskHandle = nullptr;
 
-void setupBlockNotify()
-{
+const char* BlockNotify::mempoolWsCert = R"EOF(
+-----BEGIN CERTIFICATE-----
+MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB
+iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl
+cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV
+BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw
+MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV
+BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU
+aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy
+dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
+AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B
+3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY
+tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/
+Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2
+VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT
+79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6
+c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT
+Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l
+c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee
+UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE
+Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd
+BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G
+A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF
+Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO
+VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3
+ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs
+8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR
+iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze
+Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ
+XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/
+qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB
+VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB
+L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG
+jjxDah2nGN59PRbxYvnKkKj9
+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+)EOF";
+
+void BlockNotify::onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) {
+    esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
+    BlockNotify& instance = BlockNotify::getInstance();
+
+    switch (event_id) {
+        case WEBSOCKET_EVENT_CONNECTED:
+        {
+            notifyInit = true;
+            Serial.print(F("Connected to "));
+            Serial.println(preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE));
+
+            JsonDocument doc;
+            doc["action"] = "want";
+            JsonArray dataArray = doc.createNestedArray("data");
+            dataArray.add("blocks");
+            dataArray.add("mempool-blocks");
+            
+            String sub;
+            serializeJson(doc, sub);
+            esp_websocket_client_send_text(wsClient, sub.c_str(), sub.length(), portMAX_DELAY);
+            break;
+        }
+        case WEBSOCKET_EVENT_DATA:
+            instance.onWebsocketMessage(data);
+            break;
+
+        case WEBSOCKET_EVENT_DISCONNECTED:
+            Serial.println(F("Mempool.space WS Connection Closed"));
+            break;
+
+        case WEBSOCKET_EVENT_ERROR:
+            Serial.println(F("Mempool.space WS Connection Error"));
+            break;
+    }
+}
+
+void BlockNotify::onWebsocketMessage(esp_websocket_event_data_t *data) {
+    JsonDocument doc;
+    JsonDocument filter;
+    filter["block"]["height"] = true;
+    filter["mempool-blocks"][0]["medianFee"] = true;
+
+    deserializeJson(doc, (char*)data->data_ptr, DeserializationOption::Filter(filter));
+
+    if (doc["block"].is<JsonObject>()) {
+        JsonObject block = doc["block"];
+        if (block["height"].as<uint>() != currentBlockHeight) {
+            processNewBlock(block["height"].as<uint>());
+        }
+    }
+    else if (doc["mempool-blocks"].is<JsonArray>()) {
+        JsonArray blockInfo = doc["mempool-blocks"].as<JsonArray>();
+        uint medianFee = (uint)round(blockInfo[0]["medianFee"].as<double>());
+        processNewBlockFee(medianFee);
+    }
+}
+
+void BlockNotify::setup() {
     IPAddress result;
-
     int dnsErr = -1;
     String mempoolInstance = preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);
 
-    while (dnsErr != 1) {
+    while (dnsErr != 1 && !strchr(mempoolInstance.c_str(), ':')) {
         dnsErr = WiFi.hostByName(mempoolInstance.c_str(), result);
 
         if (dnsErr != 1) {
             Serial.print(mempoolInstance);
-            Serial.println("mempool DNS could not be resolved");
+            Serial.println(F("mempool DNS could not be resolved"));
             WiFi.reconnect();
             vTaskDelay(pdMS_TO_TICKS(1000));
         }
     }
-    Serial.println("mempool DNS can be resolved");
 
     // Get current block height through regular API
-    HTTPClient *http = new HTTPClient();
-    http->begin("https://" + mempoolInstance + "/api/blocks/tip/height");
-    int httpCode = http->GET();
+    int blockFetch = fetchLatestBlock();
 
-    if (httpCode > 0 && httpCode == HTTP_CODE_OK)
-    {
-        String blockHeightStr = http->getString();
-        currentBlockHeight = blockHeightStr.toInt();
-        xTaskNotifyGive(blockUpdateTaskHandle);
+    if (blockFetch > currentBlockHeight)
+        currentBlockHeight = blockFetch;
+
+    if (currentBlockHeight != -1) {
+        lastBlockUpdate = esp_timer_get_time() / 1000000;
     }
 
-   // std::strcpy(wsServer, String("wss://" + mempoolInstance + "/api/v1/ws").c_str());
+    if (workQueue != nullptr) {
+        WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
+        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+    }
+
+    const bool useSSL = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE);
+    const String protocol = useSSL ? "wss" : "ws";
+    String wsUri = protocol + "://" + mempoolInstance + "/api/v1/ws";
 
     esp_websocket_client_config_t config = {
-        .uri = "wss://mempool.bitcoin.nl/api/v1/ws",
+        .task_stack = (6*1024),
+        .user_agent = USER_AGENT
     };
 
-    Serial.printf("Connecting to %s\r\n", config.uri);
+    if (useSSL) {
+        config.cert_pem = mempoolWsCert;
+    }
 
-    blockNotifyClient = esp_websocket_client_init(&config);
-    esp_websocket_register_events(blockNotifyClient, WEBSOCKET_EVENT_ANY, onWebsocketEvent, blockNotifyClient);
-    esp_websocket_client_start(blockNotifyClient);
+    config.uri = wsUri.c_str();
+
+    Serial.printf("Connecting to %s\r\n", mempoolInstance.c_str());
+
+    wsClient = esp_websocket_client_init(&config);
+    esp_websocket_register_events(wsClient, WEBSOCKET_EVENT_ANY, onWebsocketEvent, wsClient);
+    esp_websocket_client_start(wsClient);
 }
 
-void onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
-{
-    esp_websocket_event_data_t *data = (esp_websocket_event_data_t *)event_data;
-    String init;
-    String sub;
-    switch (event_id)
-    {
-    case WEBSOCKET_EVENT_CONNECTED:
-        Serial.println("Connected to Mempool.space WebSocket");
 
-        sub = "{\"action\": \"want\", \"data\":[\"blocks\"]}";
-        if (esp_websocket_client_send_text(blockNotifyClient, sub.c_str(), sub.length(), portMAX_DELAY) == -1)
+
+void BlockNotify::processNewBlock(uint32_t newBlockHeight) {
+    if (newBlockHeight <= currentBlockHeight)
+    {
+        return;
+    }
+
+    currentBlockHeight = newBlockHeight;
+    lastBlockUpdate = esp_timer_get_time() / 1000000;
+
+    if (workQueue != nullptr)
+    {
+        WorkItem blockUpdate = {TASK_BLOCK_UPDATE, 0};
+        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+    }
+
+    if (ScreenHandler::getCurrentScreen() != SCREEN_BLOCK_HEIGHT &&
+        preferences.getBool("stealFocus", DEFAULT_STEAL_FOCUS))
+    {
+        uint64_t timerPeriod = 0;
+        if (isTimerActive())
         {
-            Serial.println("Mempool.space WS Block Subscribe Error");
+            timerPeriod = getTimerSeconds();
+            esp_timer_stop(screenRotateTimer);
         }
-
-        break;
-    case WEBSOCKET_EVENT_DATA:
-        onWebsocketMessage(data);
-        // Handle the received WebSocket message (block notifications) here
-        break;
-    case WEBSOCKET_EVENT_ERROR:
-        Serial.println("Mempool.space WS Connnection error");
-        break;
-    case WEBSOCKET_EVENT_DISCONNECTED:
-        Serial.println("Mempool.space WS Connnection Closed");
-        break;
+        ScreenHandler::setCurrentScreen(SCREEN_BLOCK_HEIGHT);
+        if (timerPeriod > 0)
+        {
+            esp_timer_start_periodic(screenRotateTimer,
+                                   timerPeriod * usPerSecond);
+        }
+        vTaskDelay(pdMS_TO_TICKS(315*NUM_SCREENS)); // Extra delay because of screen switching
     }
-}
 
-void onWebsocketMessage(esp_websocket_event_data_t *event_data)
-{
-    SpiRamJsonDocument doc(event_data->data_len);
-
-    deserializeJson(doc, (char *)event_data->data_ptr);
-    // serializeJsonPretty(doc, Serial);
-
-    if (doc.containsKey("block"))
+    if (preferences.getBool("ledFlashOnUpd", DEFAULT_LED_FLASH_ON_UPD))
     {
-        JsonObject block = doc["block"];
-
-        currentBlockHeight = block["height"].as<long>();
-        Serial.print("New block found: ");
-        Serial.println(block["height"].as<long>());
-
-        if (blockUpdateTaskHandle != nullptr) {
-            xTaskNotifyGive(blockUpdateTaskHandle);
-            if (preferences.getBool("ledFlashOnUpd", false)) {
-                vTaskDelay(pdMS_TO_TICKS(250)); // Wait until screens are updated
-                queueLedEffect(LED_FLASH_BLOCK_NOTIFY);
-            }
-        }
+        vTaskDelay(pdMS_TO_TICKS(250)); // Wait until screens are updated
+        getLedHandler().queueEffect(LED_FLASH_BLOCK_NOTIFY);
     }
-
-    doc.clear();
 }
 
-unsigned long getBlockHeight()
-{
+void BlockNotify::processNewBlockFee(uint16_t newBlockFee) {
+    if (blockMedianFee == newBlockFee)
+    {
+        return;
+    }
+
+    blockMedianFee = newBlockFee;
+
+    if (workQueue != nullptr)
+    {
+        WorkItem blockUpdate = {TASK_FEE_UPDATE, 0};
+        xQueueSend(workQueue, &blockUpdate, portMAX_DELAY);
+    }
+}
+
+uint32_t BlockNotify::getBlockHeight() const { 
     return currentBlockHeight; 
 }
 
-bool isBlockNotifyConnected() {
-    if (blockNotifyClient == NULL)
-        return false;
-    return esp_websocket_client_is_connected(blockNotifyClient);
+void BlockNotify::setBlockHeight(uint32_t newBlockHeight)
+{
+    currentBlockHeight = newBlockHeight;
+}
+
+uint16_t BlockNotify::getBlockMedianFee() const { 
+    return blockMedianFee; 
+}
+
+void BlockNotify::setBlockMedianFee(uint16_t newBlockMedianFee)
+{
+    blockMedianFee = newBlockMedianFee;
+}
+
+bool BlockNotify::isConnected() const
+{
+    if (wsClient == NULL)
+        return false;
+    return esp_websocket_client_is_connected(wsClient);
+}
+
+bool BlockNotify::isInitialized() const
+{
+    return notifyInit;
+}
+
+void BlockNotify::stop()
+{
+    if (wsClient == NULL)
+        return;
+
+    esp_websocket_client_close(wsClient, portMAX_DELAY);
+    esp_websocket_client_stop(wsClient);
+    esp_websocket_client_destroy(wsClient);
+    wsClient = NULL;
+}
+
+void BlockNotify::restart()
+{
+    stop();
+    setup();
+}
+
+int BlockNotify::fetchLatestBlock() {
+    try {
+        String mempoolInstance = preferences.getString("mempoolInstance", DEFAULT_MEMPOOL_INSTANCE);
+        const String protocol = preferences.getBool("mempoolSecure", DEFAULT_MEMPOOL_SECURE) ? "https" : "http";
+        String url = protocol + "://" + mempoolInstance + "/api/blocks/tip/height";
+
+        HTTPClient* http = HttpHelper::begin(url);
+        Serial.println("Fetching block height from " + url);
+        int httpCode = http->GET();
+
+        if (httpCode > 0 && httpCode == HTTP_CODE_OK) {
+            String blockHeightStr = http->getString();
+            HttpHelper::end(http);
+            return blockHeightStr.toInt();
+        }
+        HttpHelper::end(http);
+        Serial.println("HTTP code" + String(httpCode));
+    } catch (...) {
+        Serial.println(F("An exception occurred while trying to get the latest block"));
+    }
+    return 2203; // B-T-C
+}
+
+uint BlockNotify::getLastBlockUpdate() const
+{
+    return lastBlockUpdate;
+}
+
+void BlockNotify::setLastBlockUpdate(uint lastUpdate)
+{
+    lastBlockUpdate = lastUpdate;
 }

src/lib/block_notify.hpp

@@ -1,22 +1,65 @@
 #pragma once
 
+#include <Arduino.h>
+#include <ArduinoJson.h>
+#include <HTTPClient.h>
+#include <esp_timer.h>
+#include <esp_websocket_client.h>
 #include <cstring>
 #include <string>
-#include <Arduino.h>
-#include <HTTPClient.h>
-#include <ArduinoJson.h>
-#include "shared.hpp"
 
-#include "esp_websocket_client.h"
-#include "screen_handler.hpp"
-#include "led_handler.hpp"
+#include "lib/led_handler.hpp"
+#include "lib/screen_handler.hpp"
+#include "lib/timers.hpp"
+#include "lib/shared.hpp"
 
-//using namespace websockets;
+class BlockNotify {
+public:
+    static BlockNotify& getInstance() {
+        static BlockNotify instance;
+        return instance;
+    }
 
-void setupBlockNotify();
+    // Delete copy constructor and assignment operator
+    BlockNotify(const BlockNotify&) = delete;
+    void operator=(const BlockNotify&) = delete;
 
-void onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
-void onWebsocketMessage(esp_websocket_event_data_t* event_data);
+    // Block notification setup and control
+    void setup();
+    void stop();
+    void restart();
+    bool isConnected() const;
+    bool isInitialized() const;
 
-unsigned long getBlockHeight();
-bool isBlockNotifyConnected();
+    // Block height management
+    void setBlockHeight(uint32_t newBlockHeight);
+    uint32_t getBlockHeight() const;
+
+    // Block fee management
+    void setBlockMedianFee(uint16_t blockMedianFee);
+    uint16_t getBlockMedianFee() const;
+
+    // Block processing
+    void processNewBlock(uint32_t newBlockHeight);
+    void processNewBlockFee(uint16_t newBlockFee);
+
+    // Block fetch and update tracking
+    int fetchLatestBlock();
+    uint getLastBlockUpdate() const;
+    void setLastBlockUpdate(uint lastUpdate);
+
+private:
+    BlockNotify() = default;  // Private constructor for singleton
+    
+    void setupTask();
+    static void onWebsocketEvent(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data);
+    void onWebsocketMessage(esp_websocket_event_data_t *data);
+
+    static const char* mempoolWsCert;
+    static esp_websocket_client_handle_t wsClient;
+    static uint32_t currentBlockHeight;
+    static uint16_t blockMedianFee;
+    static bool notifyInit;
+    static unsigned long int lastBlockUpdate;
+    static TaskHandle_t taskHandle;
+};

src/lib/button_handler.cpp

@@ -1,62 +1,110 @@
 #include "button_handler.hpp"
 
-TaskHandle_t buttonTaskHandle = NULL;
-const TickType_t debounceDelay = pdMS_TO_TICKS(50);
-TickType_t lastDebounceTime = 0;
+// Initialize static members
+TaskHandle_t ButtonHandler::buttonTaskHandle = NULL;
+ButtonState ButtonHandler::buttonStates[4] = {};
 
-void buttonTask(void *parameter)
-{
-    while (1)
-    {
+#ifdef IS_BTCLOCK_V8
+#define BTN_1 256
+#define BTN_2 512
+#define BTN_3 1024
+#define BTN_4 2048
+#else
+#define BTN_1 2048
+#define BTN_2 1024
+#define BTN_3 512
+#define BTN_4 256
+#endif
+
+void ButtonHandler::buttonTask(void *parameter) {
+    while (1) {
         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+        
         TickType_t currentTime = xTaskGetTickCount();
-        if ((currentTime - lastDebounceTime) >= debounceDelay)
-        {
-            lastDebounceTime = currentTime;
         
-            if (!digitalRead(MCP_INT_PIN))
-            {
-                uint pin = mcp.getLastInterruptPin();
+        std::lock_guard<std::mutex> lock(mcpMutex);
         
-                switch (pin)
-                {
-                case 3:
-                    toggleTimerActive();
-                    break;
-                case 2:
-                    nextScreen();
-                    break;
-                case 1:
-                    previousScreen();
-                    break;
-                case 0:
-                    showSystemStatusScreen();
-                    break;
+        if (!digitalRead(MCP_INT_PIN)) {
+            uint16_t intFlags = mcp1.getInterruptFlagRegister();
+            uint16_t intCap = mcp1.getInterruptCaptureRegister();
+            
+            // Check button states
+            if (intFlags & BTN_1) handleButtonPress(0);
+            if (intFlags & BTN_2) handleButtonPress(1);
+            if (intFlags & BTN_3) handleButtonPress(2);
+            if (intFlags & BTN_4) handleButtonPress(3);
+            
+            // Check for button releases
+            for (int i = 0; i < 4; i++) {
+                if (buttonStates[i].isPressed) {
+                    bool currentlyPressed = false;
+                    switch (i) {
+                        case 0: currentlyPressed = (intCap & BTN_1); break;
+                        case 1: currentlyPressed = (intCap & BTN_2); break;
+                        case 2: currentlyPressed = (intCap & BTN_3); break;
+                        case 3: currentlyPressed = (intCap & BTN_4); break;
+                    }
+                    if (!currentlyPressed) {
+                        handleButtonRelease(i);
+                    }
                 }
             }
-            mcp.clearInterrupts();
-            // Very ugly, but for some reason this is necessary
-            while (!digitalRead(MCP_INT_PIN))
-            {
-                mcp.clearInterrupts();
-            }
+        }
+        
+        // Clear interrupt state
+        while (!digitalRead(MCP_INT_PIN)) {
+            mcp1.getInterruptCaptureRegister();
+            delay(1);
         }
     }
 }
 
-void IRAM_ATTR handleButtonInterrupt()
-{
+void ButtonHandler::handleButtonPress(int buttonIndex) {
+    TickType_t currentTime = xTaskGetTickCount();
+    ButtonState &state = buttonStates[buttonIndex];
+    
+    if ((currentTime - state.lastPressTime) >= debounceDelay) {
+        state.isPressed = true;
+        state.lastPressTime = currentTime;
+    }
+}
+
+void ButtonHandler::handleButtonRelease(int buttonIndex) {
+    ButtonState &state = buttonStates[buttonIndex];
+    
+    if (!state.isPressed) return;  // Ignore if button wasn't pressed
+    
+    state.isPressed = false;
+    handleSingleClick(buttonIndex);
+}
+
+void ButtonHandler::handleSingleClick(int buttonIndex) {
+    switch (buttonIndex) {
+        case 0:
+            toggleTimerActive();
+            break;
+        case 1:
+            ScreenHandler::nextScreen();
+            break;
+        case 2:
+            ScreenHandler::previousScreen();
+            break;
+        case 3:
+            ScreenHandler::showSystemStatusScreen();
+            break;
+    }
+}
+
+void IRAM_ATTR ButtonHandler::handleButtonInterrupt() {
     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
     xTaskNotifyFromISR(buttonTaskHandle, 0, eNoAction, &xHigherPriorityTaskWoken);
-    if (xHigherPriorityTaskWoken == pdTRUE)
-    {
+    if (xHigherPriorityTaskWoken == pdTRUE) {
         portYIELD_FROM_ISR();
     }
 }
 
-void setupButtonTask()
-{
-    xTaskCreate(buttonTask, "ButtonTask", 4096, NULL, tskIDLE_PRIORITY, &buttonTaskHandle); // Create the FreeRTOS task
-    // Use interrupt instead of task
-    attachInterrupt(MCP_INT_PIN, handleButtonInterrupt, CHANGE);
+void ButtonHandler::setup() {
+    xTaskCreate(buttonTask, "ButtonTask", 3072, NULL, tskIDLE_PRIORITY,
+                &buttonTaskHandle);
+    attachInterrupt(MCP_INT_PIN, handleButtonInterrupt, FALLING);
 }

src/lib/button_handler.hpp

@@ -1,13 +1,54 @@
 #pragma once
 
 #include <Arduino.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#include "shared.hpp"
-#include "screen_handler.hpp"
 
-extern TaskHandle_t buttonTaskHandle;
+#include "lib/screen_handler.hpp"
+#include "lib/shared.hpp"
+#include "lib/timers.hpp"
 
-void buttonTask(void *pvParameters);
-void IRAM_ATTR handleButtonInterrupt();
-void setupButtonTask();
+// Track timing for each button
+struct ButtonState {
+    TickType_t lastPressTime = 0;
+    TickType_t pressStartTime = 0;
+    bool isPressed = false;
+    uint8_t clickCount = 0;
+    bool longPressHandled = false;
+};
+
+class ButtonHandler {
+private:
+    static const TickType_t debounceDelay = pdMS_TO_TICKS(50);
+    static const TickType_t doubleClickDelay = pdMS_TO_TICKS(1000);  // Maximum time between clicks for double click
+    static const TickType_t longPressDelay = pdMS_TO_TICKS(1500);   // Time to hold for long press
+
+    static ButtonState buttonStates[4];
+    static TaskHandle_t buttonTaskHandle;
+
+    // Button handlers
+    static void handleButtonPress(int buttonIndex);
+    static void handleButtonRelease(int buttonIndex);
+    static void handleSingleClick(int buttonIndex);
+    static void handleDoubleClick(int buttonIndex);
+    static void handleLongPress(int buttonIndex);
+
+    // Task function
+    static void buttonTask(void *pvParameters);
+
+public:
+    static void setup();
+    static void IRAM_ATTR handleButtonInterrupt();
+    static void suspendTask() { if (buttonTaskHandle != NULL) vTaskSuspend(buttonTaskHandle); }
+    static void resumeTask() { if (buttonTaskHandle != NULL) vTaskResume(buttonTaskHandle); }
+
+    #ifdef IS_BTCLOCK_V8
+    static const uint16_t BTN_1 = 256;
+    static const uint16_t BTN_2 = 512;
+    static const uint16_t BTN_3 = 1024;
+    static const uint16_t BTN_4 = 2048;
+    #else
+    static const uint16_t BTN_1 = 2048;
+    static const uint16_t BTN_2 = 1024;
+    static const uint16_t BTN_3 = 512;
+    static const uint16_t BTN_4 = 256;
+    #endif
+};

src/lib/config.hpp

@@ -1,56 +1,107 @@
-#pragma once;
-#include <WiFiClientSecure.h>
+#pragma once
+
+#include <MCP23017.h>
+#include <Arduino.h>
 #include <Preferences.h>
-#include <Adafruit_MCP23X17.h>
-
-#include "shared.hpp"
-#include <esp_system.h>
-#include <esp_netif.h>
-#include <esp_sntp.h>
-#include "epd.hpp"
-#include "improv.hpp"
-#include "hal/wdt_hal.h" 
-#include "esp_task_wdt.h"
-
+#include <WiFiClientSecure.h>
+#include <WiFiManager.h>
+#include <base64.h>
+#include <esp_task_wdt.h>
+#include <nvs_flash.h>
 #include <map>
 
-#include "lib/screen_handler.hpp"
-#include "lib/webserver.hpp"
 #include "lib/block_notify.hpp"
-#include "lib/price_notify.hpp"
 #include "lib/button_handler.hpp"
+#include "lib/epd.hpp"
+// #include "lib/improv.hpp"
 #include "lib/led_handler.hpp"
+#include "lib/ota.hpp"
+#include "lib/nostr_notify.hpp"
+#include "lib/bitaxe_fetch.hpp"
+#include "lib/mining_pool_stats_fetch.hpp"
+
+#include "lib/v2_notify.hpp"
+
+#include "lib/price_notify.hpp"
+#include "lib/screen_handler.hpp"
+#include "lib/shared.hpp"
+#include "lib/webserver.hpp"
+#ifdef HAS_FRONTLIGHT
+#include "PCA9685.h"
+#include "BH1750.h"
+#endif
+
+#include "shared.hpp"
+#include "defaults.hpp"
 
 #define NTP_SERVER "pool.ntp.org"
-#define DEFAULT_MEMPOOL_INSTANCE "mempool.space"
-#define TIME_OFFSET_SECONDS 3600
-#define USER_AGENT "BTClock/2.0"
+#define DEFAULT_TIME_OFFSET_SECONDS 3600
+#ifndef MCP_DEV_ADDR
 #define MCP_DEV_ADDR 0x20
-#define DEFAULT_SECONDS_BETWEEN_PRICE_UPDATE 30
+#endif
 
-#define DEFAULT_FG_COLOR GxEPD_WHITE
-#define DEFAULT_BG_COLOR GxEPD_BLACK
-
-#define BITCOIND_HOST ""
-#define BITCOIND_PORT 8332
-#define BITCOIND_RPC_USER ""
-#define BITCOIND_RPC_PASS ""
 
 void setup();
-void setupTime();
+void syncTime();
+uint getLastTimeSync();
 void setupPreferences();
-void setupWebsocketClients();
+void setupWebsocketClients(void *pvParameters);
 void setupHardware();
-void tryImprovSetup();
+void setupWifi();
 void setupTimers();
 void finishSetup();
-std::map<int, std::string> getScreenNameMap();
+void setupMcp();
+#ifdef HAS_FRONTLIGHT
+extern BH1750 bh1750;
+extern bool hasLuxSensor;
+float getLightLevel();
+bool hasLightLevel();
+#endif
+
+String getMyHostname();
+std::vector<ScreenMapping> getScreenNameMap();
 
 std::vector<std::string> getLocalUrl();
-bool improv_connectWifi(std::string ssid, std::string password);
-void improvGetAvailableWifiNetworks();
-bool onImprovCommandCallback(improv::ImprovCommand cmd);
-void onImprovErrorCallback(improv::Error err);
-void improv_set_state(improv::State state);
-void improv_send_response(std::vector<uint8_t> &response);
-void improv_set_error(improv::Error error);
+// bool improv_connectWifi(std::string ssid, std::string password);
+// void improvGetAvailableWifiNetworks();
+// bool onImprovCommandCallback(improv::ImprovCommand cmd);
+// void onImprovErrorCallback(improv::Error err);
+// void improv_set_state(improv::State state);
+// void improv_send_response(std::vector<uint8_t> &response);
+// void improv_set_error(improv::Error error);
+//void addCurrencyMappings(const std::vector<std::string>& currencies);
+std::vector<std::string> getActiveCurrencies();
+std::vector<std::string> getAvailableCurrencies();
+
+bool isActiveCurrency(std::string &currency);
+
+void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info);
+String getHwRev();
+bool isWhiteVersion();
+String getFsRev();
+
+bool debugLogEnabled();
+
+void addScreenMapping(int value, const char* name);
+// void addScreenMapping(int value, const String& name);
+// void addScreenMapping(int value, const std::string& name);
+
+int findScreenIndexByValue(int value);
+String replaceAmbiguousChars(String input);
+const char* getFirmwareFilename();
+const char* getWebUiFilename();
+// void loadIcons();
+
+extern Preferences preferences;
+extern MCP23017 mcp1;
+#ifdef IS_BTCLOCK_V8
+extern MCP23017 mcp2;
+#endif
+
+#ifdef HAS_FRONTLIGHT
+extern PCA9685 flArray;
+#endif
+
+// Expose DataSourceType enum
+extern DataSourceType getDataSource();
+extern void setDataSource(DataSourceType source);

src/lib/defaults.hpp

@@ -0,0 +1,101 @@
+#pragma once
+
+#define INITIAL_BLOCK_HEIGHT 876600
+#define INITIAL_LAST_PRICE 50000
+#define DEFAULT_TX_POWER 0
+
+#define DEFAULT_MEMPOOL_SECURE true
+#define DEFAULT_LED_TEST_ON_POWER true
+#define DEFAULT_LED_FLASH_ON_UPD false
+#define DEFAULT_LED_BRIGHTNESS 128
+#define DEFAULT_STEAL_FOCUS false
+#define DEFAULT_MCAP_BIG_CHAR true
+#define DEFAULT_MDNS_ENABLED true
+#define DEFAULT_OTA_ENABLED true
+#define DEFAULT_FETCH_EUR_PRICE false
+#define DEFAULT_USE_SATS_SYMBOL false
+#define DEFAULT_USE_BLOCK_COUNTDOWN true
+#define DEFAULT_SUFFIX_PRICE false
+#define DEFAULT_DISABLE_LEDS false
+#define DEFAULT_DISABLE_FL false
+#define DEFAULT_MOW_MODE false
+#define DEFAULT_SUFFIX_SHARE_DOT false
+
+#define DEFAULT_V2_SOURCE_CURRENCY CURRENCY_USD
+
+#define DEFAULT_TIME_OFFSET_SECONDS 3600
+
+#define DEFAULT_HOSTNAME_PREFIX "btclock"
+#define DEFAULT_MEMPOOL_INSTANCE "mempool.space"
+
+#define DEFAULT_USE_NOSTR false
+#define DEFAULT_NOSTR_NPUB "642317135fd4c4205323b9dea8af3270657e62d51dc31a657c0ec8aab31c6288"
+#define DEFAULT_NOSTR_RELAY "wss://relay.primal.net"
+
+#define DEFAULT_SECONDS_BETWEEN_PRICE_UPDATE 30
+#define DEFAULT_MINUTES_FULL_REFRESH 60
+
+#define DEFAULT_FG_COLOR GxEPD_WHITE
+#define DEFAULT_BG_COLOR GxEPD_BLACK
+
+#define DEFAULT_WP_TIMEOUT 15*60
+
+#define DEFAULT_FL_MAX_BRIGHTNESS 2048
+#define DEFAULT_FL_EFFECT_DELAY 15
+
+#define DEFAULT_LUX_LIGHT_TOGGLE 128
+#define DEFAULT_FL_OFF_WHEN_DARK true   
+
+#define DEFAULT_FL_ALWAYS_ON true
+#define DEFAULT_FL_FLASH_ON_UPDATE true
+
+#define DEFAULT_LED_STATUS false
+#define DEFAULT_TIMER_ACTIVE true
+#define DEFAULT_TIMER_SECONDS 1800
+#define DEFAULT_CURRENT_SCREEN 0
+
+#define DEFAULT_BITAXE_ENABLED false
+#define DEFAULT_BITAXE_HOSTNAME "bitaxe1"
+
+#define DEFAULT_MINING_POOL_STATS_ENABLED false
+#define DEFAULT_MINING_POOL_NAME "ocean"
+#define DEFAULT_MINING_POOL_USER "38Qkkei3SuF1Eo45BaYmRHUneRD54yyTFy"  // Random actual Ocean hasher
+#define DEFAULT_LOCAL_POOL_ENDPOINT "umbrel.local:2019"
+
+#define DEFAULT_ZAP_NOTIFY_ENABLED false
+#define DEFAULT_ZAP_NOTIFY_PUBKEY "b5127a08cf33616274800a4387881a9f98e04b9c37116e92de5250498635c422"
+#define DEFAULT_LED_FLASH_ON_ZAP true
+#define DEFAULT_FL_FLASH_ON_ZAP true
+#define DEFAULT_FONT_NAME "antonio"
+
+#define DEFAULT_HTTP_AUTH_ENABLED false
+#define DEFAULT_HTTP_AUTH_USERNAME "btclock"
+#define DEFAULT_HTTP_AUTH_PASSWORD "satoshi"
+
+#define DEFAULT_ACTIVE_CURRENCIES "USD,EUR,JPY"
+
+#define DEFAULT_GIT_RELEASE_URL "https://git.btclock.dev/api/v1/repos/btclock/btclock_v3/releases/latest"
+#define DEFAULT_VERTICAL_DESC true
+
+#define DEFAULT_MINING_POOL_LOGOS_URL "https://git.btclock.dev/btclock/mining-pool-logos/raw/branch/main"
+
+#define DEFAULT_ENABLE_DEBUG_LOG false
+
+#define DEFAULT_DISABLE_FL false
+#define DEFAULT_CUSTOM_ENDPOINT "ws-staging.btclock.dev"
+#define DEFAULT_CUSTOM_ENDPOINT_DISABLE_SSL false
+#define DEFAULT_MOW_MODE false
+
+// Define data source types
+enum DataSourceType {
+    BTCLOCK_SOURCE = 0,  // BTClock's own data source
+    THIRD_PARTY_SOURCE = 1,  // Third party data sources like mempool.space
+    NOSTR_SOURCE = 2,  // Nostr data source
+    CUSTOM_SOURCE = 3  // Custom data source endpoint
+};
+
+#define DEFAULT_DATA_SOURCE BTCLOCK_SOURCE
+
+#ifndef DEFAULT_BOOT_TEXT
+#define DEFAULT_BOOT_TEXT "BTCLOCK"
+#endif

src/lib/epd.cpp

@@ -1,206 +1,247 @@
 #include "epd.hpp"
 
-Native_Pin EPD_CS[NUM_SCREENS] = {
-    Native_Pin(2),
-    Native_Pin(4),
-    Native_Pin(6),
-    Native_Pin(10),
-    Native_Pin(33),
-    Native_Pin(21),
-    Native_Pin(17),
-#if NUM_SCREENS == 9
-    // MCP23X17_Pin(mcp2, 7),
-    Native_Pin(-1),
-    Native_Pin(-1),
+// Initialize static members
+#ifdef IS_BTCLOCK_REV_B
+Native_Pin EPDManager::EPD_DC(14);
+std::array<Native_Pin, NUM_SCREENS> EPDManager::EPD_CS = {
+    Native_Pin(2), Native_Pin(4), Native_Pin(6), Native_Pin(10),
+    Native_Pin(38), Native_Pin(21), Native_Pin(17)
+};
+std::array<Native_Pin, NUM_SCREENS> EPDManager::EPD_BUSY = {
+    Native_Pin(3), Native_Pin(5), Native_Pin(7), Native_Pin(9),
+    Native_Pin(37), Native_Pin(18), Native_Pin(16)
+};
+std::array<MCP23X17_Pin, NUM_SCREENS> EPDManager::EPD_RESET = {
+    MCP23X17_Pin(mcp1, 8), MCP23X17_Pin(mcp1, 9), MCP23X17_Pin(mcp1, 10),
+    MCP23X17_Pin(mcp1, 11), MCP23X17_Pin(mcp1, 12), MCP23X17_Pin(mcp1, 13),
+    MCP23X17_Pin(mcp1, 14)
+};
+#elif defined(IS_BTCLOCK_V8)
+Native_Pin EPDManager::EPD_DC(38);
+std::array<MCP23X17_Pin, NUM_SCREENS> EPDManager::EPD_BUSY = {
+    MCP23X17_Pin(mcp1, 8), MCP23X17_Pin(mcp1, 9), MCP23X17_Pin(mcp1, 10),
+    MCP23X17_Pin(mcp1, 11), MCP23X17_Pin(mcp1, 12), MCP23X17_Pin(mcp1, 13),
+    MCP23X17_Pin(mcp1, 14), MCP23X17_Pin(mcp1, 4)
+};
+std::array<MCP23X17_Pin, NUM_SCREENS> EPDManager::EPD_CS = {
+    MCP23X17_Pin(mcp2, 8), MCP23X17_Pin(mcp2, 10), MCP23X17_Pin(mcp2, 12),
+    MCP23X17_Pin(mcp2, 14), MCP23X17_Pin(mcp2, 0), MCP23X17_Pin(mcp2, 2),
+    MCP23X17_Pin(mcp2, 4), MCP23X17_Pin(mcp2, 6)
+};
+std::array<MCP23X17_Pin, NUM_SCREENS> EPDManager::EPD_RESET = {
+    MCP23X17_Pin(mcp2, 9), MCP23X17_Pin(mcp2, 11), MCP23X17_Pin(mcp2, 13),
+    MCP23X17_Pin(mcp2, 15), MCP23X17_Pin(mcp2, 1), MCP23X17_Pin(mcp2, 3),
+    MCP23X17_Pin(mcp2, 5), MCP23X17_Pin(mcp2, 7)
+};
+#else
+Native_Pin EPDManager::EPD_DC(14);
+std::array<Native_Pin, NUM_SCREENS> EPDManager::EPD_CS = {
+    Native_Pin(2), Native_Pin(4), Native_Pin(6), Native_Pin(10),
+    Native_Pin(33), Native_Pin(21), Native_Pin(17)
+};
+std::array<Native_Pin, NUM_SCREENS> EPDManager::EPD_BUSY = {
+    Native_Pin(3), Native_Pin(5), Native_Pin(7), Native_Pin(9),
+    Native_Pin(37), Native_Pin(18), Native_Pin(16)
+};
+std::array<MCP23X17_Pin, NUM_SCREENS> EPDManager::EPD_RESET = {
+    MCP23X17_Pin(mcp1, 8), MCP23X17_Pin(mcp1, 9), MCP23X17_Pin(mcp1, 10),
+    MCP23X17_Pin(mcp1, 11), MCP23X17_Pin(mcp1, 12), MCP23X17_Pin(mcp1, 13),
+    MCP23X17_Pin(mcp1, 14)
+};
 #endif
-};
-Native_Pin EPD_BUSY[NUM_SCREENS] = {
-    Native_Pin(3),
-    Native_Pin(5),
-    Native_Pin(7),
-    Native_Pin(9),
-    Native_Pin(37),
-    Native_Pin(18),
-    Native_Pin(16),
-};
-MCP23X17_Pin EPD_RESET_MPD[NUM_SCREENS] = {
-    MCP23X17_Pin(mcp, 8),
-    MCP23X17_Pin(mcp, 9),
-    MCP23X17_Pin(mcp, 10),
-    MCP23X17_Pin(mcp, 11),
-    MCP23X17_Pin(mcp, 12),
-    MCP23X17_Pin(mcp, 13),
-    MCP23X17_Pin(mcp, 14),
-};
 
-Native_Pin EPD_DC = Native_Pin(14);
-
-GxEPD2_BW<GxEPD2_213_B74, GxEPD2_213_B74::HEIGHT> displays[NUM_SCREENS] = {
-    GxEPD2_213_B74(&EPD_CS[0], &EPD_DC, &EPD_RESET_MPD[0], &EPD_BUSY[0]),
-    GxEPD2_213_B74(&EPD_CS[1], &EPD_DC, &EPD_RESET_MPD[1], &EPD_BUSY[1]),
-    GxEPD2_213_B74(&EPD_CS[2], &EPD_DC, &EPD_RESET_MPD[2], &EPD_BUSY[2]),
-    GxEPD2_213_B74(&EPD_CS[3], &EPD_DC, &EPD_RESET_MPD[3], &EPD_BUSY[3]),
-    GxEPD2_213_B74(&EPD_CS[4], &EPD_DC, &EPD_RESET_MPD[4], &EPD_BUSY[4]),
-    GxEPD2_213_B74(&EPD_CS[5], &EPD_DC, &EPD_RESET_MPD[5], &EPD_BUSY[5]),
-    GxEPD2_213_B74(&EPD_CS[6], &EPD_DC, &EPD_RESET_MPD[6], &EPD_BUSY[6]),
-#if NUM_SCREENS == 9
-    GxEPD2_213_B74(&EPD8_CS, &EPD_DC, &EPD_RESET_MPD[7], &EPD8_BUSY),
-    GxEPD2_213_B74(&EPD9_CS, &EPD_DC, &EPD_RESET_MPD[8], &EPD9_BUSY),
-#endif
-};
-
-std::array<String, NUM_SCREENS> currentEpdContent;
-std::array<String, NUM_SCREENS> epdContent;
-uint32_t lastFullRefresh[NUM_SCREENS];
-TaskHandle_t tasks[NUM_SCREENS];
-SemaphoreHandle_t epdUpdateSemaphore[NUM_SCREENS];
-
-int fgColor = GxEPD_WHITE;
-int bgColor = GxEPD_BLACK;
-
-#define FONT_SMALL Antonio_SemiBold20pt7b
-#define FONT_BIG Antonio_SemiBold90pt7b
-
-void setupDisplays()
-{
-    for (uint i = 0; i < NUM_SCREENS; i++)
-    {
-        displays[i].init();
-    }
-
-    for (uint i = 0; i < NUM_SCREENS; i++)
-    {
-        epdUpdateSemaphore[i] = xSemaphoreCreateBinary();
-        xSemaphoreGive(epdUpdateSemaphore[i]);
-
-        int *taskParam = new int;
-        *taskParam = i;
-
-        xTaskCreate(updateDisplay, "EpdUpd" + char(i), 4096, taskParam, tskIDLE_PRIORITY, &tasks[i]); // create task
-    }
-
-    epdContent = {"B",
-                  "T",
-                  "C",
-                  "L",
-                  "O",
-                  "C",
-                  "K"};
-    for (uint i = 0; i < NUM_SCREENS; i++)
-    {
-        xTaskNotifyGive(tasks[i]);
-    }
-
-    xTaskCreate(taskEpd, "epd_task", 2048, NULL, tskIDLE_PRIORITY, NULL);
+EPDManager& EPDManager::getInstance() {
+    static EPDManager instance;
+    return instance;
 }
 
-void taskEpd(void *pvParameters)
+EPDManager::EPDManager() 
+    : currentContent{}
+    , content{}
+    , lastFullRefresh{}
+    , tasks{}
+    , updateQueue{nullptr}
+    , antonioFonts{nullptr, nullptr, nullptr}
+    , oswaldFonts{nullptr, nullptr, nullptr}
+    , fontSmall{nullptr}
+    , fontBig{nullptr}
+    , fontMedium{nullptr}
+    , fontSatsymbol{nullptr}
+    , bgColor{GxEPD_BLACK}
+    , fgColor{GxEPD_WHITE}
+    , displays{
+        #ifdef IS_BTCLOCK_V8
+        EPD_CLASS(&EPD_CS[0], &EPD_DC, &EPD_RESET[0], &EPD_BUSY[0]),
+            EPD_CLASS(&EPD_CS[1], &EPD_DC, &EPD_RESET[1], &EPD_BUSY[1]),
+            EPD_CLASS(&EPD_CS[2], &EPD_DC, &EPD_RESET[2], &EPD_BUSY[2]),
+            EPD_CLASS(&EPD_CS[3], &EPD_DC, &EPD_RESET[3], &EPD_BUSY[3]),
+            EPD_CLASS(&EPD_CS[4], &EPD_DC, &EPD_RESET[4], &EPD_BUSY[4]),
+            EPD_CLASS(&EPD_CS[5], &EPD_DC, &EPD_RESET[5], &EPD_BUSY[5]),
+            EPD_CLASS(&EPD_CS[6], &EPD_DC, &EPD_RESET[6], &EPD_BUSY[6]),
+            EPD_CLASS(&EPD_CS[7], &EPD_DC, &EPD_RESET[7], &EPD_BUSY[7])
+        #else
+            EPD_CLASS(&EPD_CS[0], &EPD_DC, &EPD_RESET[0], &EPD_BUSY[0]),
+            EPD_CLASS(&EPD_CS[1], &EPD_DC, &EPD_RESET[1], &EPD_BUSY[1]),
+            EPD_CLASS(&EPD_CS[2], &EPD_DC, &EPD_RESET[2], &EPD_BUSY[2]),
+            EPD_CLASS(&EPD_CS[3], &EPD_DC, &EPD_RESET[3], &EPD_BUSY[3]),
+            EPD_CLASS(&EPD_CS[4], &EPD_DC, &EPD_RESET[4], &EPD_BUSY[4]),
+            EPD_CLASS(&EPD_CS[5], &EPD_DC, &EPD_RESET[5], &EPD_BUSY[5]),
+            EPD_CLASS(&EPD_CS[6], &EPD_DC, &EPD_RESET[6], &EPD_BUSY[6])
+        #endif
+    }
 {
-    while (1)
-    {
-        bool updatedThisCycle = false;
+}
 
-        for (uint i = 0; i < NUM_SCREENS; i++)
-        {
-            if (epdContent[i].compareTo(currentEpdContent[i]) != 0)
-            {
-                if (!updatedThisCycle)
-                {
-                    updatedThisCycle = true;
-                }
+EPDManager::~EPDManager() {
+    // Clean up tasks
+    for (auto& task : tasks) {
+        if (task != nullptr) {
+            vTaskDelete(task);
+        }
+    }
 
-                if (xSemaphoreTake(epdUpdateSemaphore[i], pdMS_TO_TICKS(5000)) == pdTRUE)
-                {
-                    xTaskNotifyGive(tasks[i]);
-                }
-                else
-                {
-                    Serial.println("Couldnt get screen" + String(i));
-                }
-            }
+    // Clean up queue
+    if (updateQueue != nullptr) {
+        vQueueDelete(updateQueue);
+    }
+
+    // Clean up fonts
+    delete antonioFonts.big;
+    delete antonioFonts.medium;
+    delete antonioFonts.small;
+    delete oswaldFonts.big;
+    delete oswaldFonts.medium;
+    delete oswaldFonts.small;
+}
+
+void EPDManager::initialize() {
+    // Load fonts based on preference
+    String fontName = preferences.getString("fontName", DEFAULT_FONT_NAME);
+    loadFonts(fontName);
+
+    // Initialize displays
+    std::lock_guard<std::mutex> lockMcp(mcpMutex);
+    for (auto& display : displays) {
+        display.init(0, true, 30);
+    }
+
+    // Create update queue and task
+    updateQueue = xQueueCreate(UPDATE_QUEUE_SIZE, sizeof(UpdateDisplayTaskItem));
+    xTaskCreate(prepareDisplayUpdateTask, "PrepareUpd", EPD_TASK_STACK_SIZE * 2, nullptr, 11, nullptr);
+
+    // Create display update tasks
+    for (size_t i = 0; i < NUM_SCREENS; i++) {
+        auto* taskParam = new int(i);
+        xTaskCreate(updateDisplayTask, ("EpdUpd" + String(i)).c_str(), EPD_TASK_STACK_SIZE, 
+                   taskParam, 11, &tasks[i]);
+    }
+
+    // Check for storage mode (prevents burn-in)
+    if (mcp1.read1(0) == LOW) {
+        setForegroundColor(GxEPD_BLACK);
+        setBackgroundColor(GxEPD_WHITE);
+        content.fill("");
+    } else {
+        // Initialize with custom text or default
+        String customText = preferences.getString("displayText", DEFAULT_BOOT_TEXT);
+        std::array<String, NUM_SCREENS> newContent;
+        newContent.fill(" ");
+        
+        for (size_t i = 0; i < std::min(customText.length(), (size_t)NUM_SCREENS); i++) {
+            newContent[i] = String(customText[i]);
         }
         
-#ifdef WITH_RGB_LED
-        if (updatedThisCycle && preferences.getBool("ledFlashOnUpd", false))
-        {
-            xTaskNotifyGive(ledHandlerTaskHandle);
-        }
-#endif
+        content = newContent;
+    }
 
-        vTaskDelay(pdMS_TO_TICKS(1000));
+    setContent(content);
+}
+
+void EPDManager::loadFonts(const String& fontName) {
+    if (fontName == FontNames::ANTONIO) {
+        // Load Antonio fonts
+        antonioFonts.big = FontLoader::loadCompressedFont(Antonio_SemiBold90pt7b_Properties);
+        antonioFonts.medium = FontLoader::loadCompressedFont(Antonio_SemiBold40pt7b_Properties);
+        antonioFonts.small = FontLoader::loadCompressedFont(Antonio_SemiBold20pt7b_Properties);
+
+        fontBig = antonioFonts.big;
+        fontMedium = antonioFonts.medium;
+        fontSmall = antonioFonts.small;
+    } else if (fontName == FontNames::OSWALD) {
+        // Load Oswald fonts
+        oswaldFonts.big = FontLoader::loadCompressedFont(Oswald_Medium80pt7b_Properties);
+        oswaldFonts.medium = FontLoader::loadCompressedFont(Oswald_Medium30pt7b_Properties);
+        oswaldFonts.small = FontLoader::loadCompressedFont(Oswald_Medium20pt7b_Properties);
+
+        fontBig = oswaldFonts.big;
+        fontMedium = oswaldFonts.medium;
+        fontSmall = oswaldFonts.small;
+    }
+
+    fontSatsymbol = FontLoader::loadCompressedFont(Satoshi_Symbol90pt7b_Properties);
+}
+
+void EPDManager::forceFullRefresh() {
+    std::fill(lastFullRefresh.begin(), lastFullRefresh.end(), 0);
+}
+
+void EPDManager::setContent(const std::array<String, NUM_SCREENS>& newContent, bool forceUpdate) {
+    std::lock_guard<std::mutex> lock(updateMutex);
+    waitUntilNoneBusy();
+
+    for (size_t i = 0; i < NUM_SCREENS; i++) {
+        if (newContent[i].compareTo(currentContent[i]) != 0 || forceUpdate) {
+            content[i] = newContent[i];
+            UpdateDisplayTaskItem dispUpdate{static_cast<char>(i)};
+            xQueueSend(updateQueue, &dispUpdate, portMAX_DELAY);
+        }
     }
 }
 
-void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent)
-{
-    epdContent = newEpdContent;
+void EPDManager::setContent(const std::array<std::string, NUM_SCREENS>& newContent) {
+    std::array<String, NUM_SCREENS> conv;
+    for (size_t i = 0; i < newContent.size(); ++i) {
+        conv[i] = String(newContent[i].c_str());
+    }
+    setContent(conv);
 }
 
-extern "C" void updateDisplay(void *pvParameters) noexcept
-{
-    const int epdIndex = *(int *)pvParameters;
-    delete (int *)pvParameters;
+std::array<String, NUM_SCREENS> EPDManager::getCurrentContent() const {
+    return currentContent;
+}
 
-    for (;;)
-    {
-        // Wait for the task notification
-        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+void EPDManager::waitUntilNoneBusy() {
+    for (size_t i = 0; i < NUM_SCREENS; i++) {
+        uint32_t count = 0;
+        while (EPD_BUSY[i].digitalRead()) {
+            count++;
+            vTaskDelay(BUSY_RETRY_DELAY);
 
-        if (epdContent[epdIndex].compareTo(currentEpdContent[epdIndex]) != 0)
-        {
-            
-            displays[epdIndex].init(0, false); // Little longer reset duration because of MCP
-            uint count = 0;
-            while (EPD_BUSY[epdIndex].digitalRead() == HIGH || count < 10) {
+            if (count == BUSY_TIMEOUT_COUNT) {
                 vTaskDelay(pdMS_TO_TICKS(100));
-                if (count >= 9) {
-                    displays[epdIndex].init(0, false); 
-                }
-                count++;
-            }
-
-            bool updatePartial = true;
-
-            // Full Refresh every half hour
-            if (!lastFullRefresh[epdIndex] || (millis() - lastFullRefresh[epdIndex]) > (preferences.getUInt("fullRefreshMin", 30) * 60 * 1000))
-            {
-                updatePartial = false;
-                lastFullRefresh[epdIndex] = millis();
-            }
-            if (strstr(epdContent[epdIndex].c_str(), "/") != NULL)
-            {
-                String top = epdContent[epdIndex].substring(0, epdContent[epdIndex].indexOf("/"));
-                String bottom = epdContent[epdIndex].substring(epdContent[epdIndex].indexOf("/") + 1);
-                splitText(epdIndex, top, bottom, updatePartial);
-            }
-            else
-            {
-                showDigit(epdIndex, epdContent[epdIndex].c_str()[0], updatePartial, &FONT_BIG);
-            }
-
-            char tries = 0;
-            while (tries < 3)
-            {
-                if (displays[epdIndex].displayWithReturn(updatePartial))
-                {
-                    displays[epdIndex].hibernate();
-                    currentEpdContent[epdIndex] = epdContent[epdIndex];
-                    break;
-                }
-
-                vTaskDelay(pdMS_TO_TICKS(100));
-                tries++;
+            } else if (count > BUSY_TIMEOUT_COUNT + 5) {
+                log_e("Display %d busy timeout", i);
+                break;
             }
         }
-        xSemaphoreGive(epdUpdateSemaphore[epdIndex]);
     }
 }
 
-void splitText(const uint dispNum, String top, String bottom, bool partial)
-{
+void EPDManager::setupDisplay(uint dispNum, const GFXfont* font) {
     displays[dispNum].setRotation(2);
-    displays[dispNum].setFont(&FONT_SMALL);
-    displays[dispNum].setTextColor(getFgColor());
+    displays[dispNum].setFont(font);
+    displays[dispNum].setTextColor(fgColor);
+    displays[dispNum].fillScreen(bgColor);
+}
+
+void EPDManager::splitText(uint dispNum, const String& top, const String& bottom, bool partial) {
+    if (preferences.getBool("verticalDesc", DEFAULT_VERTICAL_DESC) && dispNum == 0) {
+        displays[dispNum].setRotation(1);
+    } else {
+        displays[dispNum].setRotation(2);
+    }
+    displays[dispNum].setFont(fontSmall);
+    displays[dispNum].setTextColor(fgColor);
 
     // Top text
     int16_t ttbx, ttby;
@@ -216,65 +257,281 @@ void splitText(const uint dispNum, String top, String bottom, bool partial)
     uint16_t bx = ((displays[dispNum].width() - tbbw) / 2) - tbbx;
     uint16_t by = ((displays[dispNum].height() - tbbh) / 2) - tbby + tbbh / 2 + 12;
 
-    // Make separator as wide as the shortest text.
-    uint16_t lineWidth, lineX;
-    if (tbbw < ttbh)
-        lineWidth = tbbw;
-    else
-        lineWidth = ttbw;
-    lineX = round((displays[dispNum].width() - lineWidth) / 2);
+    // Make separator as wide as the shortest text
+    uint16_t lineWidth = (tbbw < ttbh) ? tbbw : ttbw;
+    uint16_t lineX = round((displays[dispNum].width() - lineWidth) / 2);
 
-    displays[dispNum].fillScreen(getBgColor());
+    displays[dispNum].fillScreen(bgColor);
     displays[dispNum].setCursor(tx, ty);
     displays[dispNum].print(top);
-    displays[dispNum].fillRoundRect(lineX, displays[dispNum].height() / 2 - 3, lineWidth, 6, 3, getFgColor());
+    displays[dispNum].fillRoundRect(lineX, displays[dispNum].height() / 2 - 3,
+                                  lineWidth, 6, 3, fgColor);
     displays[dispNum].setCursor(bx, by);
     displays[dispNum].print(bottom);
 }
 
-void showDigit(const uint dispNum, char chr, bool partial, const GFXfont *font)
-{
+void EPDManager::showDigit(uint dispNum, char chr, bool partial, const GFXfont* font) {
     String str(chr);
-    displays[dispNum].setRotation(2);
-    displays[dispNum].setFont(font);
-    displays[dispNum].setTextColor(getFgColor());
+    if (chr == '.') {
+        str = "!";
+    }
+
+    setupDisplay(dispNum, font);
+
     int16_t tbx, tby;
     uint16_t tbw, tbh;
     displays[dispNum].getTextBounds(str, 0, 0, &tbx, &tby, &tbw, &tbh);
-    // center the bounding box by transposition of the origin:
+
     uint16_t x = ((displays[dispNum].width() - tbw) / 2) - tbx;
     uint16_t y = ((displays[dispNum].height() - tbh) / 2) - tby;
-    displays[dispNum].fillScreen(getBgColor());
+
     displays[dispNum].setCursor(x, y);
     displays[dispNum].print(str);
+
+    if (chr == '.') {
+        displays[dispNum].fillRect(0, 0, displays[dispNum].width(),
+                               round(displays[dispNum].height() * 0.67), bgColor);
+    }
 }
 
-int getBgColor()
-{
-    return bgColor;
+void EPDManager::showChars(uint dispNum, const String& chars, bool partial, const GFXfont* font) {
+    setupDisplay(dispNum, font);
+
+    int16_t tbx, tby;
+    uint16_t tbw, tbh;
+    displays[dispNum].getTextBounds(chars, 0, 0, &tbx, &tby, &tbw, &tbh);
+
+    // Center the bounding box by transposition of the origin
+    uint16_t x = ((displays[dispNum].width() - tbw) / 2) - tbx;
+    uint16_t y = ((displays[dispNum].height() - tbh) / 2) - tby;
+
+    for (size_t i = 0; i < chars.length(); i++) {
+        char c = chars[i];
+        if (c == '.' || c == ',') {
+            // For the dot, calculate its specific descent
+            GFXglyph* dotGlyph = &font->glyph[c - font->first];
+            int16_t dotDescent = dotGlyph->yOffset;
+
+            // Draw the dot with adjusted y-position
+            displays[dispNum].setCursor(x, y + dotDescent + dotGlyph->height + 8);
+            displays[dispNum].print(c);
+        } else {
+            // For other characters, use the original y-position
+            displays[dispNum].setCursor(x, y);
+            displays[dispNum].print(c);
+        }
+
+        // Move x-position for the next character
+        x += font->glyph[c - font->first].xAdvance;
+    }
 }
 
-int getFgColor()
-{
-    return fgColor;
+bool EPDManager::renderIcon(uint dispNum, const String& text, bool partial) {
+    displays[dispNum].setRotation(2);
+    displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
+                                   displays[dispNum].height());
+    displays[dispNum].fillScreen(bgColor);
+    displays[dispNum].setTextColor(fgColor);
+
+    uint iconIndex = 0;
+    uint width = 122;
+    uint height = 122;
+
+    if (text.endsWith("rocket")) {
+        iconIndex = 1;
+    } else if (text.endsWith("lnbolt")) {
+        iconIndex = 2;
+    } else if (text.endsWith("bitaxe")) {
+        width = 88;
+        height = 220;
+        iconIndex = 3;
+    } else if (text.endsWith("miningpool")) {
+        LogoData logo = MiningPoolStatsFetch::getInstance().getLogo();
+        if (logo.size == 0) {
+            Serial.println(F("No logo found"));
+            return false;
+        }
+
+        int x_offset = (displays[dispNum].width() - logo.width) / 2;
+        int y_offset = (displays[dispNum].height() - logo.height) / 2;
+        displays[dispNum].drawInvertedBitmap(x_offset, y_offset, logo.data, 
+                                         logo.width, logo.height, fgColor);
+        return true;
+    }
+
+    int x_offset = (displays[dispNum].width() - width) / 2;
+    int y_offset = (displays[dispNum].height() - height) / 2;
+    displays[dispNum].drawInvertedBitmap(x_offset, y_offset, epd_icons_allArray[iconIndex], 
+                                     width, height, fgColor);
+    return true;
 }
 
-void setBgColor(int color)
-{
-    bgColor = color;
+void EPDManager::renderText(uint dispNum, const String& text, bool partial) {
+    displays[dispNum].setRotation(2);
+    displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
+                                   displays[dispNum].height());
+    displays[dispNum].fillScreen(GxEPD_WHITE);
+    displays[dispNum].setTextColor(GxEPD_BLACK);
+    displays[dispNum].setCursor(0, 50);
+
+    std::stringstream ss;
+    ss.str(text.c_str());
+    std::string line;
+
+    while (std::getline(ss, line, '\n')) {
+        if (line.rfind("*", 0) == 0) {
+            line.erase(std::remove(line.begin(), line.end(), '*'), line.end());
+            displays[dispNum].setFont(&FreeSansBold9pt7b);
+        } else {
+            displays[dispNum].setFont(&FreeSans9pt7b);
+        }
+        displays[dispNum].println(line.c_str());
+    }
 }
 
-void setFgColor(int color)
-{
-    fgColor = color;
+void EPDManager::renderQr(uint dispNum, const String& text, bool partial) {
+#ifdef USE_QR
+    // Dynamically allocate QR buffer
+    uint8_t* qrcode = (uint8_t*)malloc(qrcodegen_BUFFER_LEN_MAX);
+    if (!qrcode) {
+        log_e("Failed to allocate QR buffer");
+        return;
+    }
+
+    uint8_t tempBuffer[800];
+    bool ok = qrcodegen_encodeText(
+        text.substring(2).c_str(), tempBuffer, qrcode, qrcodegen_Ecc_LOW,
+        qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
+
+    if (ok) {
+        const int size = qrcodegen_getSize(qrcode);
+        const int padding = floor(float(displays[dispNum].width() - (size * 4)) / 2);
+        const int paddingY = floor(float(displays[dispNum].height() - (size * 4)) / 2);
+        
+        displays[dispNum].setRotation(2);
+        displays[dispNum].setPartialWindow(0, 0, displays[dispNum].width(),
+                                       displays[dispNum].height());
+        displays[dispNum].fillScreen(GxEPD_WHITE);
+
+        for (int y = 0; y < size * 4; y++) {
+            for (int x = 0; x < size * 4; x++) {
+                displays[dispNum].drawPixel(
+                    padding + x, paddingY + y,
+                    qrcodegen_getModule(qrcode, floor(float(x) / 4), floor(float(y) / 4))
+                        ? GxEPD_BLACK
+                        : GxEPD_WHITE);
+            }
+        }
+    }
+
+    free(qrcode);
+#endif
 }
 
-std::array<String, NUM_SCREENS> getCurrentEpdContent()
-{
-  //  Serial.println("currentEpdContent");
-
-    // for (int i = 0; i < NUM_SCREENS; i++) {
-    //     Serial.printf("%d = %s", i, currentEpdContent[i]);
-    // }
-    return currentEpdContent;
+int16_t EPDManager::calculateDescent(const GFXfont* font) {
+    int16_t maxDescent = 0;
+    for (uint16_t i = font->first; i <= font->last; i++) {
+        GFXglyph* glyph = &font->glyph[i - font->first];
+        int16_t descent = glyph->yOffset;
+        if (descent > maxDescent) {
+            maxDescent = descent;
+        }
+    }
+    return maxDescent;
+}
+
+void EPDManager::updateDisplayTask(void* pvParameters) noexcept {
+    auto& instance = EPDManager::getInstance();
+    const int epdIndex = *(int*)pvParameters;
+    delete (int*)pvParameters;
+
+    for (;;) {
+        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+        std::lock_guard<std::mutex> lock(instance.displayMutexes[epdIndex]);
+        {
+            std::lock_guard<std::mutex> lockMcp(mcpMutex);
+            instance.displays[epdIndex].init(0, false, 40);
+        }
+
+        uint32_t count = 0;
+        while (instance.EPD_BUSY[epdIndex].digitalRead() == HIGH || count < 10) {
+            vTaskDelay(pdMS_TO_TICKS(100));
+            count++;
+        }
+
+        bool updatePartial = true;
+        if (!instance.lastFullRefresh[epdIndex] ||
+            (millis() - instance.lastFullRefresh[epdIndex]) >
+            (preferences.getUInt("fullRefreshMin", DEFAULT_MINUTES_FULL_REFRESH) * 60 * 1000)) {
+            updatePartial = false;
+        }
+
+        char tries = 0;
+        while (tries < 3) {
+            if (instance.displays[epdIndex].displayWithReturn(updatePartial)) {
+                instance.displays[epdIndex].powerOff();
+                instance.currentContent[epdIndex] = instance.content[epdIndex];
+                if (!updatePartial) {
+                    instance.lastFullRefresh[epdIndex] = millis();
+                }
+
+                if (eventSourceTaskHandle != nullptr) {
+                    xTaskNotifyGive(eventSourceTaskHandle);
+                }
+                break;
+            }
+
+            vTaskDelay(pdMS_TO_TICKS(100));
+            tries++;
+        }
+    }
+}
+
+void EPDManager::prepareDisplayUpdateTask(void* pvParameters) {
+    auto& instance = EPDManager::getInstance();
+    UpdateDisplayTaskItem receivedItem;
+
+    for (;;) {
+        if (xQueueReceive(instance.updateQueue, &receivedItem, portMAX_DELAY)) {
+            uint epdIndex = receivedItem.dispNum;
+            std::lock_guard<std::mutex> lock(instance.displayMutexes[epdIndex]);
+
+            bool updatePartial = true;
+
+            if (instance.content[epdIndex].length() > 1 && 
+                strstr(instance.content[epdIndex].c_str(), "/") != nullptr) {
+                String top = instance.content[epdIndex].substring(
+                    0, instance.content[epdIndex].indexOf("/"));
+                String bottom = instance.content[epdIndex].substring(
+                    instance.content[epdIndex].indexOf("/") + 1);
+                instance.splitText(epdIndex, top, bottom, updatePartial);
+            } else if (instance.content[epdIndex].startsWith(F("qr"))) {
+                instance.renderQr(epdIndex, instance.content[epdIndex], updatePartial);
+            } else if (instance.content[epdIndex].startsWith(F("mdi"))) {
+                if (!instance.renderIcon(epdIndex, instance.content[epdIndex], updatePartial)) {
+                    continue;
+                }
+            } else if (instance.content[epdIndex].length() > 5) {
+                instance.renderText(epdIndex, instance.content[epdIndex], updatePartial);
+            } else {
+                if (instance.content[epdIndex].length() == 2) {
+                    instance.showChars(epdIndex, instance.content[epdIndex], updatePartial, instance.fontBig);
+                } else if (instance.content[epdIndex].length() > 1 && 
+                         instance.content[epdIndex].indexOf(".") == -1) {
+                    if (instance.content[epdIndex].equals("STS")) {
+                        instance.showDigit(epdIndex, 'S', updatePartial, instance.fontSatsymbol);
+                    } else {
+                        instance.showChars(epdIndex, instance.content[epdIndex], updatePartial,
+                                       instance.fontMedium);
+                    }
+                } else {
+                    instance.showDigit(epdIndex, instance.content[epdIndex].c_str()[0], 
+                                   updatePartial, instance.fontBig);
+                }
+            }
+
+            xTaskNotifyGive(instance.tasks[epdIndex]);
+        }
+    }
 }

src/lib/epd.hpp

@@ -1,23 +1,135 @@
 #pragma once
 
+#include <Fonts/FreeSans9pt7b.h>
+#include <Fonts/FreeSansBold9pt7b.h>
 #include <GxEPD2_BW.h>
-#include <native_pin.hpp>
+#include "gzip_decompressor.hpp"
+
 #include <mcp23x17_pin.hpp>
-#include "shared.hpp"
-#include "config.hpp"
+#include <mutex>
+#include <native_pin.hpp>
+#include <regex>
+#include <array>
+#include <memory>
+
 #include "fonts/fonts.hpp"
+#include "lib/config.hpp"
+#include "lib/shared.hpp"
+#include "icons/icons.h"
+#include "mining_pool_stats_fetch.hpp"
 
-void setupDisplays();
-void taskEpd(void *pvParameters);
+// Font includes
+#include "../fonts/antonio-semibold20.h"
+#include "../fonts/antonio-semibold40.h"
+#include "../fonts/antonio-semibold90.h"
 
-void splitText(const uint dispNum, String top, String bottom, bool partial);
-void showDigit(const uint dispNum, char chr, bool partial, const GFXfont *font);
-extern "C" void updateDisplay(void *pvParameters) noexcept;
+// Oswald fonts
+#include "../fonts/oswald-medium20.h"
+#include "../fonts/oswald-medium30.h"
+#include "../fonts/oswald-medium80.h"
 
-int getBgColor();
-int getFgColor();
-void setBgColor(int color);
-void setFgColor(int color);
+#include "../fonts/sats-symbol.h"
 
-void setEpdContent(std::array<String, NUM_SCREENS> newEpdContent);
-std::array<String, NUM_SCREENS> getCurrentEpdContent();
+#ifdef USE_QR
+#include "qrcodegen.h"
+#endif
+
+struct UpdateDisplayTaskItem {
+    char dispNum;
+};
+
+struct FontFamily {
+    GFXfont* big;
+    GFXfont* medium;
+    GFXfont* small;
+};
+
+class EPDManager {
+public:
+    static EPDManager& getInstance();
+
+    // Delete copy constructor and assignment operator
+    EPDManager(const EPDManager&) = delete;
+    EPDManager& operator=(const EPDManager&) = delete;
+
+    void initialize();
+    void forceFullRefresh();
+    void loadFonts(const String& fontName);
+    void setContent(const std::array<String, NUM_SCREENS>& newContent, bool forceUpdate = false);
+    void setContent(const std::array<std::string, NUM_SCREENS>& newContent);
+    std::array<String, NUM_SCREENS> getCurrentContent() const;
+
+    int getBackgroundColor() const { return bgColor; }
+    int getForegroundColor() const { return fgColor; }
+    void setBackgroundColor(int color) { bgColor = color; }
+    void setForegroundColor(int color) { fgColor = color; }
+    void waitUntilNoneBusy();
+
+private:
+    EPDManager();  // Private constructor for singleton
+    ~EPDManager(); // Private destructor
+
+    void setupDisplay(uint dispNum, const GFXfont* font);
+    void splitText(uint dispNum, const String& top, const String& bottom, bool partial);
+    void showDigit(uint dispNum, char chr, bool partial, const GFXfont* font);
+    void showChars(uint dispNum, const String& chars, bool partial, const GFXfont* font);
+    bool renderIcon(uint dispNum, const String& text, bool partial);
+    void renderText(uint dispNum, const String& text, bool partial);
+    void renderQr(uint dispNum, const String& text, bool partial);
+    int16_t calculateDescent(const GFXfont* font);
+
+    static void updateDisplayTask(void* pvParameters) noexcept;
+    static void prepareDisplayUpdateTask(void* pvParameters);
+
+    // Member variables
+    std::array<String, NUM_SCREENS> currentContent;
+    std::array<String, NUM_SCREENS> content;
+    std::array<uint32_t, NUM_SCREENS> lastFullRefresh;
+    std::array<TaskHandle_t, NUM_SCREENS> tasks;
+    QueueHandle_t updateQueue;
+
+    FontFamily antonioFonts;
+    FontFamily oswaldFonts;
+    const GFXfont* fontSmall;
+    const GFXfont* fontBig;
+    const GFXfont* fontMedium;
+    const GFXfont* fontSatsymbol;
+
+    int bgColor;
+    int fgColor;
+
+    std::mutex updateMutex;
+    std::array<std::mutex, NUM_SCREENS> displayMutexes;
+
+    // Pin configurations based on board version
+    #ifdef IS_BTCLOCK_REV_B
+    static Native_Pin EPD_DC;
+    static std::array<Native_Pin, NUM_SCREENS> EPD_CS;
+    static std::array<Native_Pin, NUM_SCREENS> EPD_BUSY;
+    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
+    #elif defined(IS_BTCLOCK_V8)
+    static Native_Pin EPD_DC;
+    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_BUSY;
+    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_CS;
+    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
+    #else
+    static Native_Pin EPD_DC;
+    static std::array<Native_Pin, NUM_SCREENS> EPD_CS;
+    static std::array<Native_Pin, NUM_SCREENS> EPD_BUSY;
+    static std::array<MCP23X17_Pin, NUM_SCREENS> EPD_RESET;
+    #endif
+
+    // Display array
+    std::array<GxEPD2_BW<EPD_CLASS, EPD_CLASS::HEIGHT>, NUM_SCREENS> displays;
+
+    static constexpr size_t UPDATE_QUEUE_SIZE = 14;
+    static constexpr uint32_t BUSY_TIMEOUT_COUNT = 200;
+    static constexpr TickType_t BUSY_RETRY_DELAY = pdMS_TO_TICKS(10);
+    static constexpr size_t EPD_TASK_STACK_SIZE = 
+        #ifdef IS_BTCLOCK_V8
+            4096
+        #else
+            2048
+        #endif
+    ;
+};

src/lib/gzip_decompressor.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "rom/miniz.h"
+#include <Arduino.h>
+
+class GzipDecompressor {
+public:
+    static bool decompressData(const uint8_t* input, size_t inputSize, 
+                             uint8_t* output, size_t* outputSize) {
+        if (!input || !output || !outputSize || inputSize < 18) { // Minimum gzip size
+            return false;
+        }
+
+        tinfl_decompressor* decomp = new tinfl_decompressor;
+        if (!decomp) {
+            return false;
+        }
+
+        tinfl_init(decomp);
+        
+        size_t inPos = 10; // Skip gzip header
+        size_t outPos = 0;
+        
+        while (inPos < inputSize - 8) { // -8 for footer
+            size_t inBytes = inputSize - inPos - 8;
+            size_t outBytes = *outputSize - outPos;
+            
+            tinfl_status status = tinfl_decompress(decomp,
+                &input[inPos], &inBytes,
+                output, &output[outPos], &outBytes,
+                TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
+
+            inPos += inBytes;
+            outPos += outBytes;
+
+            if (status == TINFL_STATUS_DONE) {
+                *outputSize = outPos;
+                delete decomp;
+                return true;
+            } else if (status < 0) {
+                delete decomp;
+                return false;
+            }
+        }
+        
+        delete decomp;
+        return false;
+    }
+};

src/lib/improv.cpp

@@ -1,145 +0,0 @@
-#include "improv.h"
-
-namespace improv {
-
-ImprovCommand parse_improv_data(const std::vector<uint8_t> &data, bool check_checksum) {
-  return parse_improv_data(data.data(), data.size(), check_checksum);
-}
-
-ImprovCommand parse_improv_data(const uint8_t *data, size_t length, bool check_checksum) {
-  ImprovCommand improv_command;
-  Command command = (Command) data[0];
-  uint8_t data_length = data[1];
-
-  if (data_length != length - 2 - check_checksum) {
-    improv_command.command = UNKNOWN;
-    return improv_command;
-  }
-
-  if (check_checksum) {
-    uint8_t checksum = data[length - 1];
-
-    uint32_t calculated_checksum = 0;
-    for (uint8_t i = 0; i < length - 1; i++) {
-      calculated_checksum += data[i];
-    }
-
-    if ((uint8_t) calculated_checksum != checksum) {
-      improv_command.command = BAD_CHECKSUM;
-      return improv_command;
-    }
-  }
-
-  if (command == WIFI_SETTINGS) {
-    uint8_t ssid_length = data[2];
-    uint8_t ssid_start = 3;
-    size_t ssid_end = ssid_start + ssid_length;
-
-    uint8_t pass_length = data[ssid_end];
-    size_t pass_start = ssid_end + 1;
-    size_t pass_end = pass_start + pass_length;
-
-    std::string ssid(data + ssid_start, data + ssid_end);
-    std::string password(data + pass_start, data + pass_end);
-    return {.command = command, .ssid = ssid, .password = password};
-  }
-
-  improv_command.command = command;
-  return improv_command;
-}
-
-bool parse_improv_serial_byte(size_t position, uint8_t byte, const uint8_t *buffer,
-                              std::function<bool(ImprovCommand)> &&callback, std::function<void(Error)> &&on_error) {
-  if (position == 0)
-    return byte == 'I';
-  if (position == 1)
-    return byte == 'M';
-  if (position == 2)
-    return byte == 'P';
-  if (position == 3)
-    return byte == 'R';
-  if (position == 4)
-    return byte == 'O';
-  if (position == 5)
-    return byte == 'V';
-
-  if (position == 6)
-    return byte == IMPROV_SERIAL_VERSION;
-
-  if (position <= 8)
-    return true;
-
-  uint8_t type = buffer[7];
-  uint8_t data_len = buffer[8];
-
-  if (position <= 8 + data_len)
-    return true;
-
-  if (position == 8 + data_len + 1) {
-    uint8_t checksum = 0x00;
-    for (size_t i = 0; i < position; i++)
-      checksum += buffer[i];
-
-    if (checksum != byte) {
-      on_error(ERROR_INVALID_RPC);
-      return false;
-    }
-
-    if (type == TYPE_RPC) {
-      auto command = parse_improv_data(&buffer[9], data_len, false);
-      return callback(command);
-    }
-  }
-
-  return false;
-}
-
-std::vector<uint8_t> build_rpc_response(Command command, const std::vector<std::string> &datum, bool add_checksum) {
-  std::vector<uint8_t> out;
-  uint32_t length = 0;
-  out.push_back(command);
-  for (const auto &str : datum) {
-    uint8_t len = str.length();
-    length += len + 1;
-    out.push_back(len);
-    out.insert(out.end(), str.begin(), str.end());
-  }
-  out.insert(out.begin() + 1, length);
-
-  if (add_checksum) {
-    uint32_t calculated_checksum = 0;
-
-    for (uint8_t byte : out) {
-      calculated_checksum += byte;
-    }
-    out.push_back(calculated_checksum);
-  }
-  return out;
-}
-
-#ifdef ARDUINO
-std::vector<uint8_t> build_rpc_response(Command command, const std::vector<String> &datum, bool add_checksum) {
-  std::vector<uint8_t> out;
-  uint32_t length = 0;
-  out.push_back(command);
-  for (const auto &str : datum) {
-    uint8_t len = str.length();
-    length += len;
-    out.push_back(len);
-    out.insert(out.end(), str.begin(), str.end());
-  }
-  out.insert(out.begin() + 1, length);
-
-  if (add_checksum) {
-    uint32_t calculated_checksum = 0;
-
-    for (uint8_t byte : out) {
-      calculated_checksum += byte;
-    }
-    out.push_back(calculated_checksum);
-  }
-  return out;
-}
-#endif  // ARDUINO
-
-}  // namespace improv

src/lib/improv.hpp

@@ -1,76 +0,0 @@
-#pragma once
-
-#ifdef ARDUINO
-#include <Arduino.h>
-#endif  // ARDUINO
-
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <vector>
-
-namespace improv {
-
-static const char *const SERVICE_UUID = "00467768-6228-2272-4663-277478268000";
-static const char *const STATUS_UUID = "00467768-6228-2272-4663-277478268001";
-static const char *const ERROR_UUID = "00467768-6228-2272-4663-277478268002";
-static const char *const RPC_COMMAND_UUID = "00467768-6228-2272-4663-277478268003";
-static const char *const RPC_RESULT_UUID = "00467768-6228-2272-4663-277478268004";
-static const char *const CAPABILITIES_UUID = "00467768-6228-2272-4663-277478268005";
-
-enum Error : uint8_t {
-  ERROR_NONE = 0x00,
-  ERROR_INVALID_RPC = 0x01,
-  ERROR_UNKNOWN_RPC = 0x02,
-  ERROR_UNABLE_TO_CONNECT = 0x03,
-  ERROR_NOT_AUTHORIZED = 0x04,
-  ERROR_UNKNOWN = 0xFF,
-};
-
-enum State : uint8_t {
-  STATE_STOPPED = 0x00,
-  STATE_AWAITING_AUTHORIZATION = 0x01,
-  STATE_AUTHORIZED = 0x02,
-  STATE_PROVISIONING = 0x03,
-  STATE_PROVISIONED = 0x04,
-};
-
-enum Command : uint8_t {
-  UNKNOWN = 0x00,
-  WIFI_SETTINGS = 0x01,
-  IDENTIFY = 0x02,
-  GET_CURRENT_STATE = 0x02,
-  GET_DEVICE_INFO = 0x03,
-  GET_WIFI_NETWORKS = 0x04,
-  BAD_CHECKSUM = 0xFF,
-};
-
-static const uint8_t CAPABILITY_IDENTIFY = 0x01;
-static const uint8_t IMPROV_SERIAL_VERSION = 1;
-
-enum ImprovSerialType : uint8_t {
-  TYPE_CURRENT_STATE = 0x01,
-  TYPE_ERROR_STATE = 0x02,
-  TYPE_RPC = 0x03,
-  TYPE_RPC_RESPONSE = 0x04
-};
-
-struct ImprovCommand {
-  Command command;
-  std::string ssid;
-  std::string password;
-};
-
-ImprovCommand parse_improv_data(const std::vector<uint8_t> &data, bool check_checksum = true);
-ImprovCommand parse_improv_data(const uint8_t *data, size_t length, bool check_checksum = true);
-
-bool parse_improv_serial_byte(size_t position, uint8_t byte, const uint8_t *buffer,
-                              std::function<bool(ImprovCommand)> &&callback, std::function<void(Error)> &&on_error);
-
-std::vector<uint8_t> build_rpc_response(Command command, const std::vector<std::string> &datum,
-                                        bool add_checksum = true);
-#ifdef ARDUINO
-std::vector<uint8_t> build_rpc_response(Command command, const std::vector<String> &datum, bool add_checksum = true);
-#endif  // ARDUINO
-
-}  // namespace improv

src/lib/led_handler.cpp

@@ -1,128 +1,377 @@
 #include "led_handler.hpp"
 
-TaskHandle_t ledTaskHandle = NULL;
-QueueHandle_t ledTaskQueue = NULL;
-Adafruit_NeoPixel pixels(NEOPIXEL_COUNT, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);
+// Singleton instance
+LedHandler& LedHandler::getInstance() {
+    static LedHandler instance;
+    return instance;
+}
 
-const TickType_t debounceDelay = pdMS_TO_TICKS(50);
-uint32_t notificationValue;
-unsigned long ledTaskParams;
-
-void ledTask(void *parameter)
+LedHandler::LedHandler()
+    : pixels(NEOPIXEL_COUNT, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800)
+    , ledTaskHandle(nullptr)
+    , ledTaskQueue(nullptr)
+    , ledTaskParams(0)
+    , dndEnabled(false)
+    , dndTimeBasedEnabled(false)
+    , dndTimeRange{23, 0, 7, 0}  // Default: 23:00 to 07:00
+#ifdef HAS_FRONTLIGHT
+    , frontlightOn(false)
+    , flInTransition(false)
+#endif
 {
-    while (1)
-    {
-        if (ledTaskQueue != NULL)
-        {
-            if (xQueueReceive(ledTaskQueue, &ledTaskParams, portMAX_DELAY) == pdPASS)
-            {
-                uint32_t oldLights[NEOPIXEL_COUNT];
+}
 
-                // get current state
-                for (int i = 0; i < NEOPIXEL_COUNT; i++)
-                {
-                    oldLights[i] = pixels.getPixelColor(i);
+void LedHandler::setup() {
+    loadDNDSettings();
+    pixels.begin();
+    pixels.setBrightness(preferences.getUInt("ledBrightness", DEFAULT_LED_BRIGHTNESS));
+    pixels.clear();
+    pixels.show();
+    setupTask();
+    
+    if (preferences.getBool("ledTestOnPower", DEFAULT_LED_TEST_ON_POWER)) {
+        while (!ledTaskQueue) {
+            delay(1);
+        }
+        queueEffect(LED_POWER_TEST);
+    }
+}
+
+void LedHandler::setupTask() {
+    ledTaskQueue = xQueueCreate(5, sizeof(uint));
+    xTaskCreate(ledTask, "LedTask", 2048, this, 10, &ledTaskHandle);
+}
+
+void LedHandler::ledTask(void* pvParameters) {
+    auto* handler = static_cast<LedHandler*>(pvParameters);
+    while (true) {
+        if (handler->ledTaskQueue != nullptr) {
+            if (xQueueReceive(handler->ledTaskQueue, &handler->ledTaskParams, portMAX_DELAY) == pdPASS) {
+                if (preferences.getBool("disableLeds", DEFAULT_DISABLE_LEDS)) {
+                    continue;
                 }
 
-                switch (ledTaskParams)
-                {
-                case LED_FLASH_ERROR:
-                    blinkDelayColor(250, 3, 255, 0, 0);
-                    break;
-                case LED_FLASH_SUCCESS:
-                    blinkDelayColor(250, 3, 0, 255, 0);
-                    break;
-                case LED_FLASH_UPDATE:
-                    break;
-                case LED_FLASH_BLOCK_NOTIFY:
-                    blinkDelayTwoColor(250, 3, pixels.Color(224, 67, 0), pixels.Color(8, 2, 0));
-                    break;
-                case LED_EFFECT_PAUSE_TIMER:
-                    for (int i = NEOPIXEL_COUNT; i >= 0; i--)
-                    {
-                        for (int j = NEOPIXEL_COUNT; j >= 0; j--)
-                        {
-                            uint32_t c = pixels.Color(0, 0, 0);
-                            if (i == j)
-                                c = pixels.Color(0, 255, 0);
-                            pixels.setPixelColor(j, c);
+                std::array<uint32_t, NEOPIXEL_COUNT> oldLights;
+                for (int i = 0; i < NEOPIXEL_COUNT; i++) {
+                    oldLights[i] = handler->pixels.getPixelColor(i);
+                }
+
+#ifdef HAS_FRONTLIGHT
+                uint flDelayTime = preferences.getUInt("flEffectDelay");
+#endif
+
+                switch (handler->ledTaskParams) {
+                    case LED_POWER_TEST:
+#ifdef HAS_FRONTLIGHT
+                        handler->frontlightFadeInAll(preferences.getUInt("flEffectDelay"), true);
+#endif
+                        handler->rainbow(20);
+                        handler->pixels.clear();
+                        break;
+
+                    case LED_EFFECT_WIFI_CONNECT_ERROR:
+                        handler->blinkDelayTwoColor(100, 3, handler->pixels.Color(8, 161, 236),
+                                                  handler->pixels.Color(255, 0, 0));
+                        break;
+
+                    case LED_EFFECT_CONFIGURING:
+                        for (int i = NEOPIXEL_COUNT; i--; i > 0) {
+                            for (int j = NEOPIXEL_COUNT; j--; j > 0) {
+                                uint32_t c = handler->pixels.Color(0, 0, 0);
+                                if (i == j)
+                                    c = handler->pixels.Color(0, 0, 255);
+                                handler->pixels.setPixelColor(j, c);
+                            }
+                            handler->pixels.show();
+                            delay(100);
                         }
+                        handler->pixels.clear();
+                        handler->pixels.show();
+                        break;
 
-                        pixels.show();
+                    case LED_FLASH_ERROR:
+                        handler->blinkDelayColor(250, 3, 255, 0, 0);
+                        break;
 
-                        delay(100);
+                    case LED_EFFECT_HEARTBEAT:
+                        handler->blinkDelayColor(150, 2, 0, 0, 255);
+                        break;
+
+                    case LED_DATA_BLOCK_ERROR:
+                        handler->blinkDelayColor(150, 2, 128, 0, 128);
+                        break;
+
+                    case LED_DATA_PRICE_ERROR:
+                        handler->blinkDelayColor(150, 2, 177, 90, 31);
+                        break;
+
+                    case LED_FLASH_IDENTIFY:
+                        handler->blinkDelayTwoColor(100, 2, handler->pixels.Color(255, 0, 0),
+                                                  handler->pixels.Color(0, 255, 255));
+                        handler->blinkDelayTwoColor(100, 2, handler->pixels.Color(0, 255, 0),
+                                                  handler->pixels.Color(0, 0, 255));
+                        break;
+
+                    case LED_EFFECT_WIFI_CONNECT_SUCCESS:
+                    case LED_FLASH_SUCCESS:
+                        handler->blinkDelayColor(150, 3, 0, 255, 0);
+                        break;
+
+                    case LED_PROGRESS_100:
+                        handler->pixels.setPixelColor(0, handler->pixels.Color(0, 255, 0));
+                        [[fallthrough]];
+                    case LED_PROGRESS_75:
+                        handler->pixels.setPixelColor(1, handler->pixels.Color(0, 255, 0));
+                        [[fallthrough]];
+                    case LED_PROGRESS_50:
+                        handler->pixels.setPixelColor(2, handler->pixels.Color(0, 255, 0));
+                        [[fallthrough]];
+                    case LED_PROGRESS_25:
+                        handler->pixels.setPixelColor(3, handler->pixels.Color(0, 255, 0));
+                        handler->pixels.show();
+                        break;
+
+                    case LED_EFFECT_NOSTR_ZAP:
+                    {
+#ifdef HAS_FRONTLIGHT
+                        bool frontlightWasOn = false;
+                        if (preferences.getBool("flFlashOnZap", DEFAULT_FL_FLASH_ON_ZAP)) {
+                            if (handler->frontlightOn) {
+                                frontlightWasOn = true;
+                                handler->frontlightFadeOutAll(flDelayTime, true);
+                            } else {
+                                handler->frontlightFadeInAll(flDelayTime, true);
+                            }
+                        }
+#endif
+                        for (int flash = 0; flash < random(7, 10); flash++) {
+                            handler->lightningStrike();
+                            delay(random(50, 150));
+                        }
+#ifdef HAS_FRONTLIGHT
+                        if (preferences.getBool("flFlashOnZap", DEFAULT_FL_FLASH_ON_ZAP)) {
+                            vTaskDelay(pdMS_TO_TICKS(10));
+                            if (frontlightWasOn) {
+                                handler->frontlightFadeInAll(flDelayTime, true);
+                            } else {
+                                handler->frontlightFadeOutAll(flDelayTime, true);
+                            }
+                        }
+#endif
+                        break;
                     }
 
-                    delay(900);
+                    case LED_FLASH_UPDATE:
+                        handler->blinkDelayTwoColor(250, 3, handler->pixels.Color(0, 230, 0),
+                                                  handler->pixels.Color(230, 230, 0));
+                        break;
 
-                    pixels.clear();
-                    pixels.show();
-                    break;
-                case LED_EFFECT_START_TIMER:
-                    pixels.clear();
-                    pixels.setPixelColor(NEOPIXEL_COUNT, pixels.Color(0, 255, 0));
-                    pixels.show();
-
-                    delay(900);
-
-                    for (int i = NEOPIXEL_COUNT; i--; i > 0)
+                    case LED_FLASH_BLOCK_NOTIFY:
                     {
-
-                        for (int j = NEOPIXEL_COUNT; j--; j > 0)
-                        {
-                            uint32_t c = pixels.Color(0, 0, 0);
-                            if (i == j)
-                                c = pixels.Color(0, 255, 0);
-
-                            pixels.setPixelColor(j, c);
+#ifdef HAS_FRONTLIGHT
+                        bool frontlightWasOn = false;
+                        if (preferences.getBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE)) {
+                            if (handler->frontlightOn) {
+                                frontlightWasOn = true;
+                                handler->frontlightFadeOutAll(flDelayTime, true);
+                            } else {
+                                handler->frontlightFadeInAll(flDelayTime, true);
+                            }
                         }
-
-                        pixels.show();
-
-                        delay(100);
+#endif
+                        handler->blinkDelayTwoColor(250, 3, handler->pixels.Color(224, 67, 0),
+                                                  handler->pixels.Color(8, 2, 0));
+#ifdef HAS_FRONTLIGHT
+                        if (preferences.getBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE)) {
+                            vTaskDelay(pdMS_TO_TICKS(10));
+                            if (frontlightWasOn) {
+                                handler->frontlightFadeInAll(flDelayTime, true);
+                            } else {
+                                handler->frontlightFadeOutAll(flDelayTime, true);
+                            }
+                        }
+#endif
+                        break;
                     }
 
-                    pixels.clear();
-                    pixels.show();
-                    break;
+                    case LED_EFFECT_WIFI_WAIT_FOR_CONFIG:
+                        handler->blinkDelayTwoColor(100, 1, handler->pixels.Color(8, 161, 236),
+                                                  handler->pixels.Color(156, 225, 240));
+                        break;
+
+                    case LED_EFFECT_WIFI_ERASE_SETTINGS:
+                        handler->blinkDelay(100, 3);
+                        break;
+
+                    case LED_EFFECT_WIFI_CONNECTING:
+                        for (int i = NEOPIXEL_COUNT; i >= 0; i--) {
+                            for (int j = NEOPIXEL_COUNT; j >= 0; j--) {
+                                if (j == i) {
+                                    handler->pixels.setPixelColor(i, handler->pixels.Color(16, 197, 236));
+                                } else {
+                                    handler->pixels.setPixelColor(j, handler->pixels.Color(0, 0, 0));
+                                }
+                            }
+                            handler->pixels.show();
+                            vTaskDelay(pdMS_TO_TICKS(100));
+                        }
+                        break;
+
+                    case LED_EFFECT_PAUSE_TIMER:
+                        for (int i = NEOPIXEL_COUNT; i >= 0; i--) {
+                            for (int j = NEOPIXEL_COUNT; j >= 0; j--) {
+                                uint32_t c = handler->pixels.Color(0, 0, 0);
+                                if (i == j)
+                                    c = handler->pixels.Color(0, 255, 0);
+                                handler->pixels.setPixelColor(j, c);
+                            }
+                            handler->pixels.show();
+                            delay(100);
+                        }
+                        handler->pixels.setPixelColor(0, handler->pixels.Color(255, 0, 0));
+                        handler->pixels.show();
+                        delay(900);
+                        handler->pixels.clear();
+                        handler->pixels.show();
+                        break;
+
+                    case LED_EFFECT_START_TIMER:
+                        handler->pixels.clear();
+                        handler->pixels.setPixelColor((NEOPIXEL_COUNT - 1), handler->pixels.Color(255, 0, 0));
+                        handler->pixels.show();
+                        delay(900);
+                        for (int i = NEOPIXEL_COUNT; i--; i > 0) {
+                            for (int j = NEOPIXEL_COUNT; j--; j > 0) {
+                                uint32_t c = handler->pixels.Color(0, 0, 0);
+                                if (i == j)
+                                    c = handler->pixels.Color(0, 255, 0);
+                                handler->pixels.setPixelColor(j, c);
+                            }
+                            handler->pixels.show();
+                            delay(100);
+                        }
+                        handler->pixels.clear();
+                        handler->pixels.show();
+                        break;
                 }
 
-                // revert to previous state
-                for (int i = 0; i < NEOPIXEL_COUNT; i++)
-                {
-                    pixels.setPixelColor(i, oldLights[i]);
+                // Restore previous state unless power test
+                for (int i = 0; i < NEOPIXEL_COUNT; i++) {
+                    handler->pixels.setPixelColor(i, oldLights[i]);
                 }
-
-                pixels.show();
+                handler->pixels.show();
             }
         }
     }
 }
 
-void setupLeds()
-{
-    pixels.begin();
-    pixels.setBrightness(preferences.getUInt("ledBrightness", 128));
-    pixels.setPixelColor(0, pixels.Color(255, 0, 0));
-    pixels.setPixelColor(1, pixels.Color(0, 255, 0));
-    pixels.setPixelColor(2, pixels.Color(0, 0, 255));
-    pixels.setPixelColor(3, pixels.Color(255, 255, 255));
+bool LedHandler::queueEffect(uint effect) {
+    if (isDNDActive()) {
+        return false;
+    }
+    if (ledTaskQueue == nullptr) {
+        return false;
+    }
+    xQueueSend(ledTaskQueue, &effect, portMAX_DELAY);
+    return true;
+}
+
+void LedHandler::clear() {
+    preferences.putBool("ledStatus", false);
+    pixels.clear();
     pixels.show();
-    setupLedTask();
 }
 
-void setupLedTask()
-{
-    ledTaskQueue = xQueueCreate(10, sizeof(unsigned long));
-
-    xTaskCreate(ledTask, "LedTask", 4096, NULL, tskIDLE_PRIORITY, &ledTaskHandle);
+void LedHandler::setLights(int r, int g, int b) {
+    setLights(pixels.Color(r, g, b));
 }
 
-void blinkDelay(int d, int times)
-{
-    for (int j = 0; j < times; j++)
-    {
+void LedHandler::setLights(uint32_t color) {
+    bool ledStatus = true;
+    for (int i = 0; i < NEOPIXEL_COUNT; i++) {
+        pixels.setPixelColor(i, color);
+    }
+    pixels.show();
 
+    if (color == pixels.Color(0, 0, 0)) {
+        ledStatus = false;
+    } else {
+        saveLedState();
+    }
+    preferences.putBool("ledStatus", ledStatus);
+}
+
+void LedHandler::saveLedState() {
+    for (int i = 0; i < pixels.numPixels(); i++) {
+        int pixelColor = pixels.getPixelColor(i);
+        char key[12];
+        snprintf(key, 12, "%s%d", "ledColor_", i);
+        preferences.putUInt(key, pixelColor);
+    }
+    xTaskNotifyGive(eventSourceTaskHandle);
+}
+
+void LedHandler::restoreLedState() {
+    for (int i = 0; i < pixels.numPixels(); i++) {
+        char key[12];
+        snprintf(key, 12, "%s%d", "ledColor_", i);
+        uint pixelColor = preferences.getUInt(key, pixels.Color(0, 0, 0));
+        pixels.setPixelColor(i, pixelColor);
+    }
+    pixels.show();
+}
+
+void LedHandler::rainbow(int wait) {
+    for (long firstPixelHue = 0; firstPixelHue < 5 * 65536; firstPixelHue += 256) {
+        pixels.rainbow(firstPixelHue);
+        pixels.show();
+        delayMicroseconds(wait);
+    }
+}
+
+void LedHandler::theaterChase(uint32_t color, int wait) {
+    for (int a = 0; a < 10; a++) {
+        for (int b = 0; b < 3; b++) {
+            pixels.clear();
+            for (int c = b; c < pixels.numPixels(); c += 3) {
+                pixels.setPixelColor(c, color);
+            }
+            pixels.show();
+            vTaskDelay(pdMS_TO_TICKS(wait));
+        }
+    }
+}
+
+void LedHandler::theaterChaseRainbow(int wait) {
+    int firstPixelHue = 0;
+    for (int a = 0; a < 30; a++) {
+        for (int b = 0; b < 3; b++) {
+            pixels.clear();
+            for (int c = b; c < pixels.numPixels(); c += 3) {
+                int hue = firstPixelHue + c * 65536L / pixels.numPixels();
+                uint32_t color = pixels.gamma32(pixels.ColorHSV(hue));
+                pixels.setPixelColor(c, color);
+            }
+            pixels.show();
+            vTaskDelay(pdMS_TO_TICKS(wait));
+            firstPixelHue += 65536 / 90;
+        }
+    }
+}
+
+void LedHandler::lightningStrike() {
+    uint32_t PURPLE = pixels.Color(128, 0, 128);
+    uint32_t YELLOW = pixels.Color(255, 226, 41);
+
+    for (int i = 0; i < pixels.numPixels(); i++) {
+        pixels.setPixelColor(i, random(2) == 0 ? YELLOW : PURPLE);
+    }
+    pixels.show();
+    delay(random(10, 50));
+}
+
+void LedHandler::blinkDelay(int d, int times) {
+    for (int j = 0; j < times; j++) {
         pixels.setPixelColor(0, pixels.Color(255, 0, 0));
         pixels.setPixelColor(1, pixels.Color(0, 255, 0));
         pixels.setPixelColor(2, pixels.Color(255, 0, 0));
@@ -141,15 +390,11 @@ void blinkDelay(int d, int times)
     pixels.show();
 }
 
-void blinkDelayColor(int d, int times, uint r, uint g, uint b)
-{
-    for (int j = 0; j < times; j++)
-    {
-        for (int i = 0; i < NEOPIXEL_COUNT; i++)
-        {
+void LedHandler::blinkDelayColor(int d, int times, uint r, uint g, uint b) {
+    for (int j = 0; j < times; j++) {
+        for (int i = 0; i < NEOPIXEL_COUNT; i++) {
             pixels.setPixelColor(i, pixels.Color(r, g, b));
         }
-
         pixels.show();
         vTaskDelay(pdMS_TO_TICKS(d));
 
@@ -161,19 +406,15 @@ void blinkDelayColor(int d, int times, uint r, uint g, uint b)
     pixels.show();
 }
 
-void blinkDelayTwoColor(int d, int times, uint32_t c1, uint32_t c2)
-{
-    for (int j = 0; j < times; j++)
-    {
-        for (int i = 0; i < NEOPIXEL_COUNT; i++)
-        {
+void LedHandler::blinkDelayTwoColor(int d, int times, const uint32_t& c1, const uint32_t& c2) {
+    for (int j = 0; j < times; j++) {
+        for (int i = 0; i < NEOPIXEL_COUNT; i++) {
             pixels.setPixelColor(i, c1);
         }
         pixels.show();
         vTaskDelay(pdMS_TO_TICKS(d));
 
-        for (int i = 0; i < NEOPIXEL_COUNT; i++)
-        {
+        for (int i = 0; i < NEOPIXEL_COUNT; i++) {
             pixels.setPixelColor(i, c2);
         }
         pixels.show();
@@ -183,44 +424,247 @@ void blinkDelayTwoColor(int d, int times, uint32_t c1, uint32_t c2)
     pixels.show();
 }
 
-void clearLeds()
-{
-    preferences.putBool("ledStatus", false);
-    pixels.clear();
-    pixels.show();
+// DND Implementation
+void LedHandler::loadDNDSettings() {
+    dndEnabled = preferences.getBool("dndEnabled", false);
+    dndTimeBasedEnabled = preferences.getBool("dndTimeEnabled", false);
+    
+    dndTimeRange.startHour = preferences.getUChar("dndStartHour", 23);
+    dndTimeRange.startMinute = preferences.getUChar("dndStartMin", 0);
+    dndTimeRange.endHour = preferences.getUChar("dndEndHour", 7);
+    dndTimeRange.endMinute = preferences.getUChar("dndEndMin", 0);
 }
 
-void setLights(int r, int g, int b)
-{
-    setLights(pixels.Color(r, g, b));
+void LedHandler::setDNDEnabled(bool enabled) {
+    dndEnabled = enabled;
+    preferences.putBool("dndEnabled", enabled);
+    if (enabled && isDNDActive()) {
+        clear();
+#ifdef HAS_FRONTLIGHT
+        frontlightFadeOutAll();
+#endif
+    }
 }
 
-void setLights(uint32_t color)
-{
-    preferences.putUInt("ledColor", color);
-    preferences.putBool("ledStatus", true);
+void LedHandler::setDNDTimeBasedEnabled(bool enabled) {
+    dndTimeBasedEnabled = enabled;
+    preferences.putBool("dndTimeEnabled", enabled);
+    if (enabled && isDNDActive()) {
+        clear();
+#ifdef HAS_FRONTLIGHT
+        frontlightFadeOutAll();
+#endif
+    }
+}
 
-    for (int i = 0; i < NEOPIXEL_COUNT; i++)
-    {
-        pixels.setPixelColor(i, color);
+void LedHandler::setDNDTimeRange(uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute) {
+    dndTimeRange.startHour = startHour;
+    dndTimeRange.startMinute = startMinute;
+    dndTimeRange.endHour = endHour;
+    dndTimeRange.endMinute = endMinute;
+    
+    preferences.putUChar("dndStartHour", startHour);
+    preferences.putUChar("dndStartMin", startMinute);
+    preferences.putUChar("dndEndHour", endHour);
+    preferences.putUChar("dndEndMin", endMinute);
+}
+
+bool LedHandler::isTimeInDNDRange(uint8_t hour, uint8_t minute) const {
+    uint16_t currentTime = hour * 60 + minute;
+    uint16_t startTime = dndTimeRange.startHour * 60 + dndTimeRange.startMinute;
+    uint16_t endTime = dndTimeRange.endHour * 60 + dndTimeRange.endMinute;
+    
+    if (startTime <= endTime) {
+        return currentTime >= startTime && currentTime < endTime;
+    } else {
+        return currentTime >= startTime || currentTime < endTime;
+    }
+}
+
+bool LedHandler::isDNDActive() const {
+    if (dndEnabled) {
+        return true;
     }
     
-    pixels.show();
-}
-
-
-QueueHandle_t getLedTaskQueue()
-{
-    return ledTaskQueue;
-}
-
-bool queueLedEffect(uint effect)
-{
-    if (ledTaskQueue == NULL)
-    {
-        return false;
+    if (dndTimeBasedEnabled) {
+        time_t now;
+        struct tm timeinfo;
+        time(&now);
+        localtime_r(&now, &timeinfo);
+        return isTimeInDNDRange(timeinfo.tm_hour, timeinfo.tm_min);
     }
     
-    unsigned long flashType = effect;
-    xQueueSend(ledTaskQueue, &flashType, portMAX_DELAY);
+    return false;
 }
+
+#ifdef HAS_FRONTLIGHT
+// Frontlight implementation
+void LedHandler::frontlightFlash(int flDelayTime) {
+    if (preferences.getBool("flDisable")) {
+        return;
+    }
+
+    if (frontlightOn) {
+        frontlightFadeOutAll(flDelayTime, true);
+        frontlightFadeInAll(flDelayTime, true);
+    } else {
+        frontlightFadeInAll(flDelayTime, true);
+        frontlightFadeOutAll(flDelayTime, true);
+    }
+}
+
+void LedHandler::frontlightFadeInAll() {
+    frontlightFadeInAll(preferences.getUInt("flEffectDelay"));
+}
+
+void LedHandler::frontlightFadeOutAll() {
+    frontlightFadeOutAll(preferences.getUInt("flEffectDelay"));
+}
+
+void LedHandler::frontlightFadeIn(uint num) {
+    frontlightFadeIn(num, preferences.getUInt("flEffectDelay"));
+}
+
+void LedHandler::frontlightFadeOut(uint num) {
+    frontlightFadeOut(num, preferences.getUInt("flEffectDelay"));
+}
+
+void LedHandler::frontlightSetBrightness(uint brightness) {
+    if (isDNDActive() || brightness > 4096) {
+        return;
+    }
+    
+    for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
+        flArray.setPWM(ledPin + 1, 0, brightness);
+    }
+}
+
+std::vector<uint16_t> LedHandler::frontlightGetStatus() {
+    std::vector<uint16_t> statuses;
+    for (int ledPin = 1; ledPin <= NUM_SCREENS; ledPin++) {
+        uint16_t a = 0, b = 0;
+        flArray.getPWM(ledPin + 1, &a, &b);
+        statuses.push_back(round(b - a / 4096));
+    }
+    return statuses;
+}
+
+void LedHandler::frontlightFadeInAll(int flDelayTime, bool staggered) {
+    if (preferences.getBool("flDisable") || frontlightIsOn() || flInTransition) {
+        return;
+    }
+
+    flInTransition = true;
+    const int maxBrightness = preferences.getUInt("flMaxBrightness");
+
+    if (staggered) {
+        int step = FL_FADE_STEP;
+        int staggerDelay = flDelayTime / NUM_SCREENS;
+
+        for (int dutyCycle = 0; dutyCycle <= maxBrightness + (NUM_SCREENS - 1) * maxBrightness / NUM_SCREENS; dutyCycle += step) {
+            for (int ledPin = 0; ledPin < NUM_SCREENS; ledPin++) {
+                int ledBrightness = dutyCycle - ledPin * maxBrightness / NUM_SCREENS;
+                if (ledBrightness < 0) {
+                    ledBrightness = 0;
+                } else if (ledBrightness > maxBrightness) {
+                    ledBrightness = maxBrightness;
+                }
+                flArray.setPWM(ledPin + 1, 0, ledBrightness);
+            }
+            vTaskDelay(pdMS_TO_TICKS(staggerDelay));
+        }
+    } else {
+        for (int dutyCycle = 0; dutyCycle <= maxBrightness; dutyCycle += FL_FADE_STEP) {
+            for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
+                flArray.setPWM(ledPin + 1, 0, dutyCycle);
+            }
+            vTaskDelay(pdMS_TO_TICKS(flDelayTime));
+        }
+    }
+    frontlightOn = true;
+    flInTransition = false;
+}
+
+void LedHandler::frontlightFadeOutAll(int flDelayTime, bool staggered) {
+    if (preferences.getBool("flDisable") || !frontlightIsOn() || flInTransition) {
+        return;
+    }
+
+    flInTransition = true;
+    if (staggered) {
+        int maxBrightness = preferences.getUInt("flMaxBrightness");
+        int step = FL_FADE_STEP;
+        int staggerDelay = flDelayTime / NUM_SCREENS;
+
+        for (int dutyCycle = maxBrightness; dutyCycle >= 0; dutyCycle -= step) {
+            for (int ledPin = 0; ledPin < NUM_SCREENS; ledPin++) {
+                int ledBrightness = dutyCycle - (NUM_SCREENS - 1 - ledPin) * maxBrightness / NUM_SCREENS;
+                if (ledBrightness < 0) {
+                    ledBrightness = 0;
+                } else if (ledBrightness > maxBrightness) {
+                    ledBrightness = maxBrightness;
+                }
+                flArray.setPWM(ledPin + 1, 0, ledBrightness);
+            }
+            vTaskDelay(pdMS_TO_TICKS(staggerDelay));
+        }
+    } else {
+        for (int dutyCycle = preferences.getUInt("flMaxBrightness"); dutyCycle >= 0; dutyCycle -= FL_FADE_STEP) {
+            for (int ledPin = 0; ledPin <= NUM_SCREENS; ledPin++) {
+                flArray.setPWM(ledPin + 1, 0, dutyCycle);
+            }
+            vTaskDelay(pdMS_TO_TICKS(flDelayTime));
+        }
+    }
+
+    flArray.allOFF();
+    frontlightOn = false;
+    flInTransition = false;
+}
+
+void LedHandler::frontlightFadeIn(uint num, int flDelayTime) {
+    if (isDNDActive() || preferences.getBool("flDisable")) {
+        return;
+    }
+    
+    for (int dutyCycle = 0; dutyCycle <= preferences.getUInt("flMaxBrightness"); dutyCycle += 5) {
+        flArray.setPWM(num + 1, 0, dutyCycle);
+        vTaskDelay(pdMS_TO_TICKS(flDelayTime));
+    }
+}
+
+void LedHandler::frontlightFadeOut(uint num, int flDelayTime) {
+    if (isDNDActive() || preferences.getBool("flDisable") || !frontlightIsOn()) {
+        return;
+    }
+
+    for (int dutyCycle = preferences.getUInt("flMaxBrightness"); dutyCycle >= 0; dutyCycle -= 5) {
+        flArray.setPWM(num + 1, 0, dutyCycle);
+        vTaskDelay(pdMS_TO_TICKS(flDelayTime));
+    }
+}
+
+void LedHandler::initializeFrontlight() {
+    if (!flArray.begin(PCA9685_MODE1_AUTOINCR | PCA9685_MODE1_ALLCALL, PCA9685_MODE2_TOTEMPOLE))
+    {
+        Serial.println(F("FL driver error"));
+        return;
+    }
+    flArray.setFrequency(200);
+    Serial.println(F("FL driver active"));
+
+    if (!preferences.isKey("flMaxBrightness"))
+    {
+        preferences.putUInt("flMaxBrightness", DEFAULT_FL_MAX_BRIGHTNESS);
+    }
+    if (!preferences.isKey("flEffectDelay"))
+    {
+        preferences.putUInt("flEffectDelay", DEFAULT_FL_EFFECT_DELAY);
+    }
+
+    if (!preferences.isKey("flFlashOnUpd"))
+    {
+        preferences.putBool("flFlashOnUpd", DEFAULT_FL_FLASH_ON_UPDATE);
+    }
+}
+#endif

src/lib/led_handler.hpp

@@ -1,10 +1,13 @@
 #pragma once
 
+#include <Adafruit_NeoPixel.h>
 #include <Arduino.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-#include <Adafruit_NeoPixel.h>
-#include "shared.hpp"
+#include <memory>
+
+#include "lib/shared.hpp"
+#include "lib/webserver.hpp"
 
 #ifndef NEOPIXEL_PIN
 #define NEOPIXEL_PIN 34
@@ -13,27 +16,120 @@
 #define NEOPIXEL_COUNT 4
 #endif
 
-typedef struct {
-    int flashType;
-} LedTaskParameters;
-
+// LED effect constants
 const int LED_FLASH_ERROR = 0;
 const int LED_FLASH_SUCCESS = 1;
 const int LED_FLASH_UPDATE = 2;
-const int LED_FLASH_BLOCK_NOTIFY = 3;
-const int LED_EFFECT_START_TIMER = 4;
-const int LED_EFFECT_PAUSE_TIMER = 5;
+const int LED_EFFECT_CONFIGURING = 10;
+const int LED_FLASH_BLOCK_NOTIFY = 4;
+const int LED_EFFECT_START_TIMER = 5;
+const int LED_EFFECT_PAUSE_TIMER = 6;
+const int LED_EFFECT_HEARTBEAT = 7;
+const int LED_EFFECT_WIFI_WAIT_FOR_CONFIG = 100;
+const int LED_EFFECT_WIFI_CONNECTING = 101;
+const int LED_EFFECT_WIFI_CONNECT_ERROR = 102;
+const int LED_EFFECT_WIFI_CONNECT_SUCCESS = 103;
+const int LED_EFFECT_WIFI_ERASE_SETTINGS = 104;
+const int LED_PROGRESS_25 = 200;
+const int LED_PROGRESS_50 = 201;
+const int LED_PROGRESS_75 = 202;
+const int LED_PROGRESS_100 = 203;
+const int LED_DATA_PRICE_ERROR = 300;
+const int LED_DATA_BLOCK_ERROR = 301;
+const int LED_EFFECT_NOSTR_ZAP = 400;
+const int LED_FLASH_IDENTIFY = 990;
+const int LED_POWER_TEST = 999;
 
-extern TaskHandle_t ledTaskHandle;
+// Do Not Disturb mode settings
+struct DNDTimeRange {
+    uint8_t startHour;
+    uint8_t startMinute;
+    uint8_t endHour;
+    uint8_t endMinute;
+};
 
-void ledTask(void *pvParameters);
-void setupLeds();
-void setupLedTask();
-void blinkDelay(int d, int times);
-void blinkDelayColor(int d, int times, uint r, uint g, uint b);
-void blinkDelayTwoColor(int d, int times, uint32_t c1, uint32_t c2);
-void clearLeds();
-QueueHandle_t getLedTaskQueue();
-bool queueLedEffect(uint effect);
-void setLights(int r, int g, int b);
-void setLights(uint32_t color);
+class LedHandler {
+public:
+    static LedHandler& getInstance();
+    
+    // Delete copy constructor and assignment operator
+    LedHandler(const LedHandler&) = delete;
+    LedHandler& operator=(const LedHandler&) = delete;
+
+    void setup();
+    void setupTask();
+    bool queueEffect(uint effect);
+    void clear();
+    void setLights(int r, int g, int b);
+    void setLights(uint32_t color);
+    void saveLedState();
+    void restoreLedState();
+    QueueHandle_t getTaskQueue() const { return ledTaskQueue; }
+    Adafruit_NeoPixel& getPixels() { return pixels; }
+
+    // DND methods
+    void setDNDEnabled(bool enabled);
+    void setDNDTimeBasedEnabled(bool enabled);
+    void setDNDTimeRange(uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute);
+    bool isDNDActive() const;
+    bool isTimeInDNDRange(uint8_t hour, uint8_t minute) const;
+    
+    // DND getters
+    bool isDNDEnabled() const { return dndEnabled; }
+    bool isDNDTimeBasedEnabled() const { return dndTimeBasedEnabled; }
+    uint8_t getDNDStartHour() const { return dndTimeRange.startHour; }
+    uint8_t getDNDStartMinute() const { return dndTimeRange.startMinute; }
+    uint8_t getDNDEndHour() const { return dndTimeRange.endHour; }
+    uint8_t getDNDEndMinute() const { return dndTimeRange.endMinute; }
+
+    // Effect methods
+    void rainbow(int wait);
+    void theaterChase(uint32_t color, int wait);
+    void theaterChaseRainbow(int wait);
+    void lightningStrike();
+    void blinkDelay(int d, int times);
+    void blinkDelayColor(int d, int times, uint r, uint g, uint b);
+    void blinkDelayTwoColor(int d, int times, const uint32_t& c1, const uint32_t& c2);
+
+#ifdef HAS_FRONTLIGHT
+    void frontlightFlash(int flDelayTime);
+    void frontlightFadeInAll();
+    void frontlightFadeOutAll();
+    void frontlightFadeIn(uint num);
+    void frontlightFadeOut(uint num);
+    std::vector<uint16_t> frontlightGetStatus();
+    void frontlightSetBrightness(uint brightness);
+    bool frontlightIsOn() const { return frontlightOn; }
+    void frontlightFadeInAll(int flDelayTime, bool staggered = false);
+    void frontlightFadeOutAll(int flDelayTime, bool staggered = false);
+    void frontlightFadeIn(uint num, int flDelayTime);
+    void frontlightFadeOut(uint num, int flDelayTime);
+    void initializeFrontlight();
+#endif
+
+private:
+    LedHandler();  // Private constructor for singleton
+    void loadDNDSettings();
+    static void ledTask(void* pvParameters);
+
+    Adafruit_NeoPixel pixels;
+    TaskHandle_t ledTaskHandle;
+    QueueHandle_t ledTaskQueue;
+    uint ledTaskParams;
+
+    // DND members
+    bool dndEnabled;
+    bool dndTimeBasedEnabled;
+    DNDTimeRange dndTimeRange;
+
+#ifdef HAS_FRONTLIGHT
+    static constexpr uint16_t FL_FADE_STEP = 25;
+    bool frontlightOn;
+    bool flInTransition;
+#endif
+};
+
+// Global accessor function
+inline LedHandler& getLedHandler() {
+    return LedHandler::getInstance();
+}

src/lib/mining_pool/braiins/brains_pool.cpp

@@ -0,0 +1,43 @@
+#include "brains_pool.hpp"
+
+void BraiinsPool::prepareRequest(HTTPClient &http) const
+{
+    http.addHeader("Pool-Auth-Token", poolUser.c_str());
+}
+
+std::string BraiinsPool::getApiUrl() const
+{
+    return "https://pool.braiins.com/accounts/profile/json/btc/";
+}
+
+PoolStats BraiinsPool::parseResponse(const JsonDocument &doc) const
+{
+    try
+    {
+        if (doc["btc"].isNull())
+        {
+            return PoolStats{
+                .hashrate = "0",
+                .dailyEarnings = 0};
+        }
+
+        std::string unit = doc["btc"]["hash_rate_unit"].as<std::string>();
+
+        static const std::unordered_map<std::string, int> multipliers = {
+            {"Zh/s", 21}, {"Eh/s", 18}, {"Ph/s", 15}, {"Th/s", 12}, {"Gh/s", 9}, {"Mh/s", 6}, {"Kh/s", 3}};
+
+        int multiplier = multipliers.at(unit);
+        float hashValue = doc["btc"]["hash_rate_5m"].as<float>();
+
+        return PoolStats{
+            .hashrate = std::to_string(static_cast<int>(std::round(hashValue))) + std::string(multiplier, '0'),
+            .dailyEarnings = static_cast<int64_t>(doc["btc"]["today_reward"].as<float>() * 100000000)};
+    }
+    catch (const std::exception &e)
+    {
+        Serial.printf("Error parsing %s response: %s\n", getPoolName().c_str(), e.what());
+        return PoolStats{
+            .hashrate = "0",
+            .dailyEarnings = std::nullopt};
+    }
+}

src/lib/mining_pool/braiins/brains_pool.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "lib/mining_pool/mining_pool_interface.hpp"
+#include <icons/icons.h>
+#include <utils.hpp>
+
+class BraiinsPool : public MiningPoolInterface
+{
+public:
+    void setPoolUser(const std::string &user) override { poolUser = user; }
+    void prepareRequest(HTTPClient &http) const override;
+    std::string getApiUrl() const override;
+    PoolStats parseResponse(const JsonDocument &doc) const override;
+    bool supportsDailyEarnings() const override { return true; }
+    bool hasLogo() const override { return true; }
+    std::string getDisplayLabel() const override { return "BRAIINS/POOL"; } // Fallback if needed
+    std::string getDailyEarningsLabel() const override { return "sats/earned"; }
+    std::string getLogoFilename() const override {
+        return "braiins.bin";
+    }
+
+    std::string getPoolName() const override {
+        return "braiins";
+    }
+
+    int getLogoWidth() const override {
+        return 37;
+    }
+
+    int getLogoHeight() const override {
+        return 230;
+    }
+};

src/lib/mining_pool/ckpool/ckpool.cpp

@@ -0,0 +1,47 @@
+#include "ckpool.hpp"
+
+void CKPool::prepareRequest(HTTPClient &http) const
+{
+    // Empty as CKPool doesn't need special headers
+}
+
+std::string CKPool::getApiUrl() const
+{
+    return getBaseUrl() + "/users/" + poolUser;
+}
+
+PoolStats CKPool::parseResponse(const JsonDocument &doc) const
+{
+    try
+    {
+        std::string hashrateStr = doc["hashrate1m"].as<std::string>();
+        
+        // Special case for "0"
+        if (hashrateStr == "0") {
+            return PoolStats{
+                .hashrate = "0",
+                .dailyEarnings = std::nullopt
+            };
+        }
+
+        char unit = hashrateStr.back();
+        std::string value = hashrateStr.substr(0, hashrateStr.size() - 1);
+
+        int multiplier = getHashrateMultiplier(unit);
+        double hashrate = std::stod(value) * std::pow(10, multiplier);
+
+        char buffer[32];
+        snprintf(buffer, sizeof(buffer), "%.0f", hashrate);
+
+        return PoolStats{
+            .hashrate = buffer,
+            .dailyEarnings = std::nullopt};
+    }
+    catch (const std::exception &e)
+    {
+        Serial.printf("Error parsing %s response: %s\n", getPoolName().c_str(), e.what());
+        return PoolStats{
+            .hashrate = "0",
+            .dailyEarnings = std::nullopt};
+    }
+} 

src/lib/mining_pool/ckpool/ckpool.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "lib/mining_pool/mining_pool_interface.hpp"
+#include <utils.hpp>
+
+class CKPool : public MiningPoolInterface {
+public:
+    void setPoolUser(const std::string& user) override { poolUser = user; }
+
+    void prepareRequest(HTTPClient& http) const override;
+    std::string getApiUrl() const override;
+    PoolStats parseResponse(const JsonDocument& doc) const override;
+    bool supportsDailyEarnings() const override { return false; }
+    std::string getDailyEarningsLabel() const override { return ""; }
+    bool hasLogo() const override { return false; }
+    std::string getDisplayLabel() const override { return "CK/POOL"; }
+    std::string getPoolName() const override {
+        return "ckpool";
+    }
+
+protected:
+    virtual std::string getBaseUrl() const {
+        return "https://solo.ckpool.org";
+    }
+}; 

src/lib/mining_pool/ckpool/eu_ckpool.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ckpool.hpp"
+
+class EUCKPool : public CKPool {
+public:
+    std::string getDisplayLabel() const override { return "CK/POOL"; }
+    std::string getPoolName() const override {
+        return "eu_ckpool";
+    }
+
+protected:
+    std::string getBaseUrl() const override {
+        return "https://eusolo.ckpool.org";
+    }
+}; 

src/lib/mining_pool/gobrrr_pool/gobrrr_pool.cpp

@@ -0,0 +1,6 @@
+// src/noderunners/noderunners_pool.cpp
+#include "gobrrr_pool.hpp"
+
+std::string GoBrrrPool::getApiUrl() const {
+    return "https://pool.gobrrr.me/api/client/" + poolUser;
+}

src/lib/mining_pool/gobrrr_pool/gobrrr_pool.hpp

@@ -0,0 +1,30 @@
+
+#pragma once
+
+#include "lib/mining_pool/mining_pool_interface.hpp"
+#include "lib/mining_pool/public_pool/public_pool.hpp"
+
+#include <icons/icons.h>
+
+class GoBrrrPool : public PublicPool {
+public:
+    std::string getApiUrl() const override;
+    bool hasLogo() const override { return true; }
+    std::string getDisplayLabel() const override { return "GOBRRR/POOL"; }
+    
+    std::string getLogoFilename() const override {
+        return "gobrrr.bin";
+    }
+
+    std::string getPoolName() const override {
+        return "gobrrr_pool";
+    }
+
+    int getLogoWidth() const override {
+        return 122;
+    }
+
+    int getLogoHeight() const override {
+        return 122;
+    }
+};

src/lib/mining_pool/logo_data.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <cstdint>
+#include <stddef.h>
+
+struct LogoData {
+    const uint8_t* data;
+    size_t width;
+    size_t height;  
+    size_t size;
+};

src/lib/mining_pool/mining_pool_interface.cpp

@@ -0,0 +1,18 @@
+#include "mining_pool_interface.hpp"
+#include "pool_factory.hpp"
+
+LogoData MiningPoolInterface::getLogo() const {
+    if (!hasLogo()) {
+        return LogoData{nullptr, 0, 0, 0};
+    }
+    
+    // Check if logo exists 
+    String logoPath = String(PoolFactory::getLogosDir()) + "/" + String(getPoolName().c_str()) + "_logo.bin";
+
+    if (!LittleFS.exists(logoPath)) {
+        return LogoData{nullptr, 0, 0, 0};
+    }
+    
+    // Now load the logo (whether it was just downloaded or already existed)
+    return PoolFactory::loadLogoFromFS(getPoolName(), this);
+} 

src/lib/mining_pool/mining_pool_interface.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <HTTPClient.h>
+#include <ArduinoJson.h>
+#include "pool_stats.hpp"
+#include "logo_data.hpp"
+#include "lib/shared.hpp"
+
+class MiningPoolInterface {
+public:
+    virtual ~MiningPoolInterface() = default;
+    virtual void setPoolUser(const std::string& user) = 0;
+    virtual void prepareRequest(HTTPClient& http) const = 0;
+    virtual std::string getApiUrl() const = 0;
+    virtual PoolStats parseResponse(const JsonDocument& doc) const = 0;
+    virtual bool hasLogo() const = 0;
+    virtual LogoData getLogo() const;
+    virtual std::string getDisplayLabel() const = 0;
+    virtual bool supportsDailyEarnings() const = 0;
+    virtual std::string getDailyEarningsLabel() const = 0;
+    virtual std::string getLogoFilename() const { return ""; }
+    virtual std::string getPoolName() const = 0;
+    virtual int getLogoWidth() const { return 0; }
+    virtual int getLogoHeight() const { return 0; }
+    std::string getLogoUrl() const {
+        if (!hasLogo() || getLogoFilename().empty()) {
+            return "";
+        }
+        std::string baseUrl = preferences.getString("poolLogosUrl", DEFAULT_MINING_POOL_LOGOS_URL).c_str();
+        return baseUrl + "/" + getLogoFilename().c_str();
+    }
+
+protected:
+    std::string poolUser;
+};