docs: close GOAL-001 WS8 (runner push unblocked)

* misc changes (see PR)

* macro only parsing

.clang-format

@@ -0,0 +1,19 @@
+---
+BasedOnStyle: LLVM
+UseTab: Never
+IndentWidth: 4
+TabWidth: 4
+ColumnLimit: 150
+PointerAlignment: Left
+ReferenceAlignment: Pointer
+AlignAfterOpenBracket: DontAlign
+BreakBeforeBraces: Attach
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortBlocksOnASingleLine: Always
+IndentCaseLabels: false
+SortIncludes: false
+SpaceBeforeParens: Never
+ReflowComments: false
+SpacesBeforeTrailingComments: 1

.clang-format-ignore

@@ -0,0 +1,16 @@
+# Third-party/vendor code
+components/codecs/inc/**
+components/esp-dsp/**
+components/esp_http_server/**
+components/spotify/cspot/**
+components/squeezelite/**
+components/telnet/libtelnet/**
+components/tjpgd/**
+managed_components/**
+
+# Generated web artifacts
+components/wifi-manager/webapp/dist/**
+components/wifi-manager/webapp/src/js/proto/**
+
+# Build outputs
+build/**

.cproject

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?fileVersion 4.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage">
-    	
-    <storageModule moduleId="org.eclipse.cdt.core.settings">
-        		
-        <cconfiguration id="org.eclipse.cdt.core.default.config.959280881">
-            			
-            <storageModule buildSystemId="org.eclipse.cdt.core.defaultConfigDataProvider" id="org.eclipse.cdt.core.default.config.959280881" moduleId="org.eclipse.cdt.core.settings" name="Configuration">
-                				
-                <externalSettings/>
-                				
-                <extensions/>
-                			
-            </storageModule>
-            			
-            <storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
-            		
-        </cconfiguration>
-        	
-    </storageModule>
-    	
-    <storageModule moduleId="org.eclipse.cdt.core.pathentry">
-        		
-        <pathentry excluding="**/CMakeFiles/**" kind="out" path="build"/>
-        	
-    </storageModule>
-    	
-    <storageModule moduleId="org.eclipse.cdt.core.LanguageSettingsProviders"/>
-    	
-    <storageModule moduleId="org.eclipse.cdt.make.core.buildtargets"/>
-    
-</cproject>

.devcontainer/devcontainer.json

@@ -0,0 +1,41 @@
+{
+  "name": "squeezelite-esp32 (idf v5.5)",
+  "build": {
+    "dockerfile": "../Dockerfile",
+    "context": ".."
+  },
+  "workspaceFolder": "/workspaces/squeezelite-esp32",
+  "containerUser": "root",
+  "remoteUser": "root",
+  "updateRemoteUserUID": false,
+  "mounts": [
+    "source=${localWorkspaceFolder}/.devcontainer-data,target=/root/.devcontainer-data,type=bind,consistency=cached"
+  ],
+  "containerEnv": {
+    "CODEX_HOME": "/root/.devcontainer-data/codex",
+    "VSCODE_AGENT_FOLDER": "/root/.devcontainer-data/vscode-server"
+  },
+  "postCreateCommand": "mkdir -p /root/.devcontainer-data/codex /root/.devcontainer-data/vscode-server",
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "terminal.integrated.defaultProfile.linux": "bash"
+      },
+      "extensions": [
+        "openai.chatgpt",
+        "ms-vscode.cpptools-extension-pack",
+        "ms-vscode.cpptools",
+        "ms-vscode.cmake-tools",
+        "ms-vscode.makefile-tools",
+        "ms-vscode.vscode-serial-monitor",
+        "espressif.esp-idf-extension",
+        "github.vscode-github-actions",
+        "dbaeumer.vscode-eslint",
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "drblury.protobuf-vsc",
+        "foxundermoon.shell-format"
+      ]
+    }
+  }
+}

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,90 @@
+---
+name: Bug report
+about: How to Submit an Issue for the squeezelite-esp32 Project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+To help us resolve your issue as quickly as possible, please follow these guidelines when submitting an issue. Providing all the necessary information will save both your time and ours.
+
+### Describe the bug
+A clear and concise description of what the bug is.
+
+### Preliminary Information
+
+1. **Firmware Version**: Specify the version of the firmware you are using.
+2. **Plugin Version**: Mention the version of the plugin installed on your LMS (Logitech Media Server).
+
+### Hardware Details
+
+Please describe your hardware setup:
+
+- **ESP32 Module**: For example, ESP32 WROVER, ESP32-S3, etc.
+- **Board Type**: If applicable, e.g., ESP32 audio kit, etc.
+- **DAC Chip**: Specify the DAC chip you are using.
+- **Additional Hardware**: Include details about any other hardware like rotary controls, buttons, screens (SPI, I2C), Ethernet, IO expansion, etc.
+
+### NVS Settings
+
+Follow these steps to share your NVS settings:
+
+1. Open the web UI of your device.
+2. Click on the "Credit" tab.
+3. Enable the "Show NVS Editor" checkbox. This allows you to view or change the NVS configuration even when not in recovery mode.
+4. Navigate to the "NVS Editor" tab.
+5. Scroll to the bottom and click "Download Config".
+6. Share the downloaded content here.
+
+<details>
+<pre><code>
+  Your log content here
+</code></pre>
+</details>
+
+
+### Logs
+
+To share logs:
+
+1. Connect your player to a computer using a USB cable. Use a built-in Serial-USB adapter if your player has one, or an external USB adapter otherwise.
+2. Go to the [web installer](https://sle118.github.io/squeezelite-esp32-installer/).
+3. Click "Connect to Device".
+4. Select the appropriate serial port.
+5. Click "Logs And Console".
+6. Download the logs and share them here. Please remove any sensitive information like Wi-Fi passwords or MAC addresses.
+- **If the problem occurs soon after booting**: Share the full log until the issue occurs.
+- **If the problem occurs later during playback**: Trim the logs to include information just before and after the problem occurs.
+
+#### Example Log
+
+Here's an example log for reference. Make sure to obfuscate sensitive information like Wi-Fi passwords, MAC addresses, and change IP addresses to something more generic.
+
+<details>
+<pre><code>
+=== START OF LOG ===
+Example of log from the console 
+rst:0x1 (POWERON_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
+configsip: 0, SPIWP:0xee
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:1
+...
+I (1041) cpu_start: Application information:
+I (1044) cpu_start: Project name:     Squeezelite-ESP32
+I (1050) cpu_start: App version:      I2S-4MFlash-1336
+I (1055) cpu_start: Compile time:     Aug 12 2023 01:20:18
+I (1062) cpu_start: ELF file SHA256:  34241d6e99fd1d6b...
+I (1068) cpu_start: ESP-IDF:          v4.3.5-dirty
+...
+I (1133) heap_init: At 40094A8C len 0000B574 (45 KiB): IRAM
+I (1139) spiram: Adding pool of 4066K of external SPI memory to heap allocator
+=== END OF LOG ===   
+</code></pre>
+</details>
+
+### Issue Description
+
+1. **Observed Behavior**: Describe what you think is wrong.
+2. **Expected Behavior**: Describe what you expect should happen.
+3. **Steps to Reproduce**: Provide a step-by-step guide on how to replicate the issue.

.github/pull_request_template.md

@@ -0,0 +1,33 @@
+## Summary
+
+- What changed:
+- Why it changed:
+
+## Test Strategy Check (Required)
+
+- [ ] I validated behavior at contract/module boundaries (not private implementation details).
+- [ ] New tests are refactor-resilient (should survive internal reorganization with identical behavior).
+- [ ] For bug fixes, I added at least one regression test at the highest stable boundary.
+- [ ] I avoided brittle assertions on internals (private helper call order, private layout, incidental log text), unless behavior-critical.
+
+## Validation Performed
+
+- [ ] Host/unit tests
+- [ ] Hardware/HIL tests (if applicable)
+- [ ] Platform profile(s) validated: `i2s` / `muse` / `squeezeamp` / N/A
+
+Commands and results:
+```bash
+# paste exact commands used
+```
+
+## Risk and Rollback
+
+- Risk level: low / medium / high
+- Potential regressions:
+- Rollback plan:
+
+## Related Docs
+
+- [ ] `documentation/TESTING_CHARTER.md` reviewed
+- [ ] `documentation/HARDWARE_TEST_MATRIX.md` reviewed (if platform impact)

.github/workflows/CrossBuild.yml

@@ -3,10 +3,15 @@ name: Cross-Build
 
 on:
   push:
-    branches-ignore: [ master ]
+    branches: 
+      - 'refactoring'
+      - 'main'
+      - 'master-cmake'
   pull_request:
-    branches-ignore: [ master ]
-
+    branches:
+      - 'refactoring'
+      - 'main'
+      - 'master-cmake'
 jobs:
   job1:
     name: Build Number
@@ -21,31 +26,36 @@ jobs:
         token: ${{secrets.github_token}}
   build:
     runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:release-v5.5
     needs: job1
     strategy:
       max-parallel: 1
       matrix:
-        node: [I2S-4MFlash, SqueezeAmp]
+        node: [I2S-4MFlash, SqueezeAmp, Muse]
         depth: [16, 32]
+        exclude:
+          - node: Muse
+            depth: 32
     steps:
     - name: Set target name
       run: |
         echo "TARGET_BUILD_NAME=${{ matrix.node }}" >> $GITHUB_ENV
         echo "build_version_prefix=1." >> $GITHUB_ENV
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 15
         submodules: true
     - name: Cache build
       id: cache-build
-      uses: actions/cache@v2
+      uses: actions/cache@v4
       with:
         path: |
           build
-          /var/lib/docker
         key: ${{ runner.os }}-${{ matrix.node }}-${{ matrix.depth }}
     - name: Set build parameters
       run: |
+        git config --global --add safe.directory "${GITHUB_WORKSPACE}"
         git update-index --chmod=+x ./server_certs/getcert.sh
         cd server_certs;./getcert.sh;cat github.pem;cd ..
         shopt -s nocasematch
@@ -57,7 +67,7 @@ jobs:
         echo "tag=${tag}" >> $GITHUB_ENV
         last_commit="$(git log --pretty=format:'%s' --max-count=1)"
         if [[ "$last_commit" =~ .*"Release".* ]]; then echo "release_flag=1" >> $GITHUB_ENV; else echo "release_flag=0" >> $GITHUB_ENV; fi
-        name="1.${BUILD_NUMBER}-${{matrix.depth}}#v4.0#${TARGET_BUILD_NAME}#${branch_name}"
+        name="1.${BUILD_NUMBER}-${{matrix.depth}}#v5.5#${TARGET_BUILD_NAME}#${branch_name}"
         artifact_prefix="squeezelite-esp32-${branch_name}-${TARGET_BUILD_NAME}-${{matrix.depth}}-${build_version_prefix}${BUILD_NUMBER}"
         artifact_file_name="${artifact_prefix}.zip"
         artifact_bin_file_name="${artifact_prefix}.bin"
@@ -82,11 +92,12 @@ jobs:
         cat $GITHUB_ENV
     - name: Build the firmware
       run: |
-        env | grep "artifact\|tag\|GITHUB\|version\|NUMBER\|TARGET" >${TARGET_BUILD_NAME}-env.txt
         echo "${tag}" >version.txt
-        docker pull sle118/idf:release-v4.0 
-        docker info 
-        docker run --env-file=${TARGET_BUILD_NAME}-env.txt  -v $PWD:/project -w /project sle118/idf:release-v4.0 /bin/bash -c "cp build-scripts/${TARGET_BUILD_NAME}-sdkconfig.defaults sdkconfig  && idf.py build -DDEPTH=${{ matrix.depth }} -DBUILD_NUMBER=${BUILD_NUMBER}-${{ matrix.depth }} && zip -r build_output.zip build && zip build/${artifact_file_name} partitions*.csv build/*.bin build/bootloader/bootloader.bin build/partition_table/partition-table.bin build/flash_project_args build/size_*.txt"
+        cp build-scripts/${TARGET_BUILD_NAME}-sdkconfig.defaults sdkconfig
+        . /opt/esp/idf/export.sh >/dev/null 2>&1
+        idf.py build -DDEPTH=${{ matrix.depth }} -DBUILD_NUMBER=${BUILD_NUMBER}-${{ matrix.depth }}
+        zip -r build_output.zip build
+        zip build/${artifact_file_name} partitions*.csv build/*.bin build/bootloader/bootloader.bin build/partition_table/partition-table.bin build/flash_project_args build/size_*.txt
     # - name: Build Mock firmware
     #   run: |
     #     mkdir -p build
@@ -101,7 +112,7 @@ jobs:
     #     echo "mock content"> size_comp1.txt
     #     echo "mock content"> size_comp2.txt
     #     echo "mock content"> ../partitions.csv
-    - uses: actions/upload-artifact@v2
+    - uses: actions/upload-artifact@v4
       with:
         name: ${{ env.artifact_file_name }}
         path: |
@@ -115,7 +126,7 @@ jobs:
           sdkconfig
           server_certs/github.pem
           build_output.zip
-    - uses: actions/upload-artifact@v2
+    - uses: actions/upload-artifact@v4
       with:
         name: ${{ env.artifact_bin_file_name }}
         path: |

.github/workflows/Platform_build.yml

@@ -0,0 +1,253 @@
+name: Platform Build
+on: 
+  push:
+    branches: 
+      - 'refactoring'
+      - 'main'
+      - 'master-cmake'
+  workflow_dispatch:
+    inputs:
+      ui_build:
+        description: 'Force Rebuilding the UI. When not forced, the system will check for [ui-build] in the last commit message to trigger a ui rebuild'
+        required: true
+        type: boolean
+      release_build:
+        description: 'Force a Release build. When not forced, the system will check for release word in the last commit message to trigger a release'
+        required: true
+        type: boolean
+jobs:
+  bootstrap:
+    name: Global setup
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:release-v5.5
+    outputs:
+      build_number: ${{ steps.buildnumber.outputs.build_number }}
+      ui_build: ${{ steps.build_flags.outputs.ui_build }}
+      release_flag: ${{ steps.build_flags.outputs.release_flag }}      
+      mock: ${{ steps.build_flags.outputs.mock }}            
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        submodules: true
+    - name: Install Python build tooling
+      run: |
+        if ! python -m pip --version >/dev/null 2>&1; then
+          apt-get update
+          apt-get install -y --no-install-recommends python3-pip
+          rm -rf /var/lib/apt/lists/*
+        fi
+        python -m pip install --upgrade pip
+        python -m pip install pygit2 requests protobuf grpcio-tools
+    - name: Generate common build number
+      id: buildnumber
+      uses: einaregilsson/build-number@v3
+      with:
+        token: ${{secrets.github_token}}
+
+    - name: Set build flags
+      id: build_flags
+      run: |
+        git config --global --add safe.directory "${GITHUB_WORKSPACE}"
+        ui_build_input="${{ github.event.inputs.ui_build || 'false' }}"
+        release_build_input="${{ github.event.inputs.release_build || 'false' }}"
+        [ "${ui_build_input}" = "true" ] && ui_build_option="--ui_build" || ui_build_option=""
+        [ "${release_build_input}" = "true" ] && release_build_option="--force" || release_build_option=""
+        echo "ui_build_option=$ui_build_option" >> "$GITHUB_OUTPUT"
+        echo "release_build_option=$release_build_option" >> "$GITHUB_OUTPUT"
+        echo "Dumping environment"
+        env
+        # build_flags support the following options
+        # --mock - to mock the compilation part - this is to be used for testing only
+        # --force - to force a release build even if the last commit message doesn't contain the word "release"
+        # --ui_build - to force a ui_build even if the last commit message doesn't contain "[ui-build]"
+        python docker/build_tools.py build_flags $ui_build_option $release_build_option
+    - name: Show Build Flags        
+      run: |
+          echo "Running with the following options" 
+          echo "Web Build Flag=${{steps.build_flags.outputs.ui_build}}"
+          echo "Mock flag=${{steps.build_flags.outputs.mock}}"
+          echo "Release Flag=${{steps.build_flags.outputs.release_flag}}"      
+    - name: Refresh certificates
+      if: ${{ steps.build_flags.outputs.release_flag == '1' }}
+      run: |
+        git update-index --chmod=+x ./server_certs/getcert.sh
+        cd server_certs;./getcert.sh;cat github.pem;cd ..        
+    - name: Setup Node.js dependencies
+      if: ${{ !env.ACT }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: 16
+        cache: 'npm'
+        cache-dependency-path: components/wifi-manager/webapp/package.json   
+    - name: Build Web Application
+      if: ${{ steps.build_flags.outputs.ui_build == '1' }} 
+      run: |
+        cd components/wifi-manager/webapp/ 
+        npm install 
+        npm run-script build
+    - name: Update repository with prebuilt items
+      if:  ${{ steps.build_flags.outputs.ui_build == '1' || steps.build_flags.outputs.release_flag == '1' }} 
+      run: |
+        git config user.name github-actions
+        git config user.email github-actions@github.com
+        git add server_certs 
+        git add components/wifi-manager/webapp/*.h 
+        git add components/wifi-manager/webapp/*.c 
+        git add components/wifi-manager/webapp/*.cmake 
+        git add components/wifi-manager/webapp/dist/*
+        if git diff --cached --quiet; then
+          echo "No prebuilt updates to commit."
+        else
+          git commit -m "Update prebuilt objects [skip actions]"
+          git push  https://${{secrets.github_token}}@github.com/sle118/squeezelite-esp32.git
+        fi
+    - name: Locally store commonly built objects
+      uses: actions/upload-artifact@v4
+      with:
+        name: prebuilt_objects
+        path: |
+          server_certs 
+          components/wifi-manager/webapp/*.h
+          components/wifi-manager/webapp/*.c
+          components/wifi-manager/webapp/dist/*
+          components/wifi-manager/webapp/*.cmake 
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:release-v5.5
+    needs: [bootstrap]
+    strategy:
+      matrix:
+        node: [I2S-4MFlash, SqueezeAmp, Muse]
+        depth: [16, 32]
+        exclude:
+          - node: Muse
+            depth: 32      
+          - node: bootstrap
+            depth: 32
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        submodules: true
+    - name: Install Python build tooling
+      run: |
+        if ! python -m pip --version >/dev/null 2>&1; then
+          apt-get update
+          apt-get install -y --no-install-recommends python3-pip
+          rm -rf /var/lib/apt/lists/*
+        fi
+        python -m pip install --upgrade pip
+        python -m pip install pygit2 requests protobuf grpcio-tools
+    - name: Show Build Flags        
+      run: |
+          echo "Running with the following options" 
+          echo "Web Build Flag=${{needs.bootstrap.outputs.ui_build}}"
+          echo "Mock flag=${{needs.bootstrap.outputs.mock}}"
+          echo "Release Flag=${{needs.bootstrap.outputs.release_flag}}"
+          echo Environment File name: $GITHUB_ENV        
+    - name: Set build parameters
+      run: |
+        git config --global --add safe.directory "${GITHUB_WORKSPACE}"
+        git status
+        python docker/build_tools.py environment --build ${{ needs.bootstrap.outputs.build_number }} --env_file "$GITHUB_ENV" --node "${{matrix.node}}" --depth ${{matrix.depth}} --major 2 --docker espressif/idf:release-v5.5 
+        
+    - uses: actions/download-artifact@v4
+      name: Restore common objects
+      with:
+        name: prebuilt_objects
+    - name: Build the firmware
+      if: ${{ needs.bootstrap.outputs.mock == '0' }} 
+      run: |
+        echo "Copying target sdkconfig"
+        cp build-scripts/${TARGET_BUILD_NAME}-sdkconfig.defaults sdkconfig
+        echo "Building project"
+        . /opt/esp/idf/export.sh >/dev/null 2>&1
+        idf.py build -DDEPTH=${DEPTH} -DBUILD_NUMBER=${BUILD_NUMBER}-${DEPTH} 
+    - name: Build Mock firmware
+      if: ${{ needs.bootstrap.outputs.mock == '1' }} 
+      run: |
+        mkdir -p build
+        cd build
+        mkdir -p partition_table
+        mkdir -p bootloader
+        echo \\"mock content\\"> ./squeezelite.bin
+        echo \"mock content\"> ./recovery.bin
+        echo \"mock content\"> ./bootloader/bootloader.bin
+        echo \"mock content\"> ./partition_table/partition-table.bin 
+        echo \"mock content\"> ./ota_data_initial.bin
+        echo \"mock content\"> ./flash_project_args 
+        echo \"mock content\"> ./size_comp1.txt
+        echo \"mock content\"> ./size_comp2.txt
+        echo \"mock content\"> ./partitions.csv        
+        echo {  \"write_flash_args\" : [ \"--flash_mode\", \"dio\", \"--flash_size\", \"detect\", \"--flash_freq\", \"80m\" ],  \"flash_settings\" : {      \"flash_mode\": \"dio\",      \"flash_size\": \"detect\",      \"flash_freq\": \"80m\"  },  \"flash_files\" : {      \"0x8000\" : \"partition_table/partition-table.bin\",      \"0xd000\" : \"ota_data_initial.bin\",      \"0x1000\" : \"bootloader/bootloader.bin\",      \"0x10000\" : \"recovery.bin\",      \"0x150000\" : \"squeezelite.bin\"  },  \"partition_table\" : { \"offset\" : \"0x8000\", \"file\" : \"partition_table/partition-table.bin\" },  \"otadata\" : { \"offset\" : \"0xd000\", \"file\" : \"ota_data_initial.bin\" },  \"bootloader\" : { \"offset\" : \"0x1000\", \"file\" : \"bootloader/bootloader.bin\" },  \"app\" : { \"offset\" : \"0x10000\", \"file\" : \"recovery.bin\" },  \"squeezelite\" : { \"offset\" : \"0x150000\", \"file\" : \"squeezelite.bin\" },  \"extra_esptool_args\" : {      \"after\"  : \"hard_reset\",      \"before\" : \"default_reset\"  }  }  > ./flasher_args.json
+    - name: Create Release Artifact Zip 
+      if: ${{ needs.bootstrap.outputs.release_flag == '1' && needs.bootstrap.outputs.mock == '0' }}
+      run: |
+        if [ -z "${artifact_file_name}" ]
+        then
+            echo "No artifact file name set.  Will not generate zip file."
+        else
+            echo "Generating build artifact zip file"
+            zip -r build_output.zip build
+            zip build/${artifact_file_name} partitions*.csv components/ build/*.bin build/bootloader/bootloader.bin build/partition_table/partition-table.bin build/flash_project_args build/size_*.txt
+        fi
+    - name: Upload Build Artifacts
+      uses: actions/upload-artifact@v4
+      if: ${{ needs.bootstrap.outputs.mock == '0' }}
+      with:
+        name: ${{ env.artifact_prefix }}
+        path: |
+          build/flash_project_args 
+          build/size_comp1.txt
+          build/size_comp2.txt
+          partitions.csv
+          sdkconfig
+          server_certs/github.pem
+          build/*.bin 
+          build/bootloader/bootloader.bin 
+          build/partition_table/partition-table.bin
+          build_output.zip
+    - name: Create Release
+      if: ${{ needs.bootstrap.outputs.release_flag == '1' && needs.bootstrap.outputs.mock == '0' }}
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+      with:
+        tag_name: ${{ env.tag }}
+        release_name: ${{ env.name }}
+        body: ${{ env.description }}
+        draft: false
+        prerelease: false
+    - name: Upload Release Asset - Squeezelite binary file
+      if: ${{ needs.bootstrap.outputs.release_flag == '1' && needs.bootstrap.outputs.mock == '0' }}
+      id: upload-release-asset 
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
+        asset_path: build/squeezelite.bin
+        asset_name: ${{ env.artifact_bin_file_name }}
+        asset_content_type: application/octet-stream        
+    - name: Upload Release Asset - Zip file
+      if: ${{ needs.bootstrap.outputs.release_flag == '1' && needs.bootstrap.outputs.mock == '0' }}
+      id: upload-release-asset-zip
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
+        asset_path: build/${{ env.artifact_file_name }}
+        asset_name: ${{ env.artifact_file_name }}
+        asset_content_type: application/octet-stream     
+  update_web_installer:
+    name: Update Web Installer After Release
+    needs: [ bootstrap, build ]
+    if: ${{ always() && !cancelled() && needs.bootstrap.outputs.release_flag == '1' && needs.bootstrap.outputs.mock == '0' }}
+    uses: ./.github/workflows/web_deploy.yml
+    secrets:
+      WEB_INSTALLER: ${{ secrets.WEB_INSTALLER }}

.github/workflows/codeql-analysis.yml

@@ -19,6 +19,7 @@ on:
     branches: [ master-cmake ]
   schedule:
     - cron: '19 12 * * 4'
+  workflow_dispatch:
 
 jobs:
   analyze:
@@ -39,7 +40,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +51,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v2
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -62,6 +63,13 @@ jobs:
     #- run: |
     #   make bootstrap
     #   make release
-
+    # Exclude specific artifacts from analysis
+    - name: Exclude Artifacts
+      run: |
+        # Exclude components/wifi-manager/webapp/dist/js/index* from analysis
+        echo 'components/wifi-manager/webapp/dist/js/index*' >> .codeql-exclude-paths
+        echo 'components/wifi-manager/webapp/dist/js/index*' >> .codeql-exclude-paths.txt
+        echo 'components/wifi-manager/webapp/dist/index*' >> .codeql-exclude-paths
+        echo 'components/wifi-manager/webapp/dist/index*' >> .codeql-exclude-paths.txt        
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2

.github/workflows/esp-idf-v4.3-build.yml

@@ -0,0 +1,170 @@
+# This is a basic workflow to help you get started with Actions
+name: ESP-IDF v5.5 (Legacy Matrix)
+on:
+  push:
+    branches: 
+      - 'refactoring'
+      - 'main'
+      - 'master-cmake'
+  pull_request:
+    branches:
+      - 'refactoring'
+      - 'main'
+      - 'master-cmake'
+jobs:
+  job1:
+    name: Build Number
+    runs-on: ubuntu-latest
+    outputs:
+      build_number: ${{ steps.buildnumber.outputs.build_number }}
+    steps:
+    - name: Generate common build number
+      id: buildnumber
+      uses: einaregilsson/build-number@v3
+      with:
+        token: ${{secrets.github_token}}
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:release-v5.5
+    needs: job1
+    strategy:
+      max-parallel: 1
+      matrix:
+        node: [I2S-4MFlash, SqueezeAmp, Muse]
+        depth: [16, 32]
+        exclude:
+         - node: Muse
+           depth: 32
+    steps:
+    - name: Set target name
+      run: |
+        echo "TARGET_BUILD_NAME=${{ matrix.node }}" >> $GITHUB_ENV
+        echo "build_version_prefix=2." >> $GITHUB_ENV
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 15
+        submodules: true
+    - name: Cache build
+      id: cache-build
+      uses: actions/cache@v4
+      with:
+        path: |
+          build
+        key: ${{ runner.os }}-${{ matrix.node }}-${{ matrix.depth }}
+    - name: Set build parameters
+      run: |
+        git config --global --add safe.directory "${GITHUB_WORKSPACE}"
+        git update-index --chmod=+x ./server_certs/getcert.sh
+        git update-index --chmod=+x ./buildFirmware.sh
+        git update-index --chmod=+x ./components/spotify/cspot/bell/external/nanopb/generator/protoc
+        git update-index --chmod=+x ./components/spotify/cspot/bell/external/nanopb/generator/protoc-gen-nanopb
+        git update-index --chmod=+x ./components/spotify/cspot/bell/external/nanopb/generator/*.py
+        git update-index --chmod=+x ./components/spotify/cspot/bell/external/nanopb/generator/*.py2
+        git update-index --chmod=+x ./components/spotify/cspot/bell/external/nanopb/generator/proto/*.py
+        
+
+        cd server_certs;./getcert.sh;cat github.pem;cd ..
+        shopt -s nocasematch
+        branch_name="${GITHUB_REF//refs\/heads\//}"
+        branch_name="${branch_name//[^a-zA-Z0-9\-~!@_\.]/}"
+        BUILD_NUMBER=${{ needs.job1.outputs.build_number }}
+        echo "BUILD_NUMBER=${BUILD_NUMBER}" >> $GITHUB_ENV
+        tag="${TARGET_BUILD_NAME}.${{matrix.depth}}.${build_version_prefix}${BUILD_NUMBER}.${branch_name}"
+        echo "tag=${tag}" >> $GITHUB_ENV
+        last_commit="$(git log --pretty=format:'%s' --max-count=1)"
+        if [[ "$last_commit" =~ .*"Release".* ]]; then echo "release_flag=1" >> $GITHUB_ENV; else echo "release_flag=0" >> $GITHUB_ENV; fi
+        name="${build_version_prefix}${BUILD_NUMBER}-${{matrix.depth}}#v5.5#${TARGET_BUILD_NAME}#${branch_name}"
+        artifact_prefix="squeezelite-esp32-${branch_name}-${TARGET_BUILD_NAME}-${{matrix.depth}}-${build_version_prefix}${BUILD_NUMBER}"
+        artifact_file_name="${artifact_prefix}.zip"
+        artifact_bin_file_name="${artifact_prefix}.bin"
+        echo "name=${name}" >> $GITHUB_ENV
+        echo "last_commit=${last_commit}" >> $GITHUB_ENV
+        echo "artifact_file_name=${artifact_file_name}" >> $GITHUB_ENV
+        echo "PROJECT_VER=${TARGET_BUILD_NAME}-${{ steps.buildnumber.outputs.build_number }} " >> $GITHUB_ENV
+        echo "artifact_bin_file_name=${artifact_bin_file_name}" >> $GITHUB_ENV
+        description=$'### Revision Log\n'
+        githist="$(git log --pretty=format:'%h %s (%cI) <%an>' --abbrev-commit --max-count=15 | sed --r 's/(^[\*]+)/\\\1/g')"
+        description="$description$githist"
+        echo 'description<<~EOD' >> $GITHUB_ENV
+        echo ${description}>> $GITHUB_ENV
+        echo '~EOD' >> $GITHUB_ENV        
+        echo ####### 
+        echo ####### Environment
+        echo ####### 
+        env
+        echo ####### 
+        echo ####### GITHUB ENV
+        echo ####### 
+        cat $GITHUB_ENV
+    - name: Build the firmware
+      run: |
+        . /opt/esp/idf/export.sh >/dev/null 2>&1
+        ./buildFirmware.sh
+    # - name: Build Mock firmware
+    #   run: |
+    #     mkdir -p build
+    #     cd build
+    #     mkdir -p partition_table
+    #     mkdir -p bootloader
+    #     echo "mock content"> squeezelite.bin
+    #     echo "mock content"> recovery.bin
+    #     echo "mock content"> ./bootloader/bootloader.bin
+    #     echo "mock content"> ./partition_table/partition-table.bin 
+    #     echo "mock content"> flash_project_args 
+    #     echo "mock content"> size_comp1.txt
+    #     echo "mock content"> size_comp2.txt
+    #     echo "mock content"> ../partitions.csv
+    - uses: actions/upload-artifact@v4
+      with:
+        name: ${{ env.artifact_file_name }}
+        path: |
+          build/*.bin
+          build/bootloader/bootloader.bin
+          build/partition_table/partition-table.bin 
+          build/flash_project_args 
+          build/size_comp1.txt
+          build/size_comp2.txt
+          partitions.csv
+          sdkconfig
+          server_certs/github.pem
+          build_output.zip
+    - uses: actions/upload-artifact@v4
+      with:
+        name: ${{ env.artifact_bin_file_name }}
+        path: |
+          build/squeezelite.bin
+    - name: Create Release
+      if: env.release_flag == 1     
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+      with:
+        tag_name: ${{ env.tag }}
+        release_name: ${{ env.name }}
+        body: ${{ env.description }}
+        draft: false
+        prerelease: true
+    - name: Upload Release Asset - Squeezelite binary file
+      if: env.release_flag == 1         
+      id: upload-release-asset 
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
+        asset_path: build/squeezelite.bin
+        asset_name: ${{ env.artifact_bin_file_name }}
+        asset_content_type: application/octet-stream        
+    - name: Upload Release Asset - Zip file
+      if: env.release_flag == 1         
+      id: upload-release-asset-zip
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }} # This pulls from the CREATE RELEASE step above, referencing it's ID to get its outputs object, which include a `upload_url`. See this blog post for more info: https://jasonet.co/posts/new-features-of-github-actions/#passing-data-to-future-steps 
+        asset_path: build/${{ env.artifact_file_name }}
+        asset_name: ${{ env.artifact_file_name }}
+        asset_content_type: application/octet-stream          

.github/workflows/style-lint.yml

@@ -0,0 +1,32 @@
+name: Style Lint
+
+on:
+  push:
+    branches:
+      - "refactoring"
+      - "main"
+      - "master-cmake"
+  pull_request:
+    branches:
+      - "refactoring"
+      - "main"
+      - "master-cmake"
+
+jobs:
+  clang-format:
+    name: clang-format
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install clang-format
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends clang-format
+
+      - name: Check style
+        run: |
+          build-scripts/lint_style.sh check

.github/workflows/web_deploy.yml

@@ -0,0 +1,34 @@
+name: Update Web Installer
+on:
+  workflow_call:
+    secrets:
+      WEB_INSTALLER:
+        required: true       
+  workflow_dispatch:
+jobs:
+  update_web_installer:
+    name: Update Web Installer After Release
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:release-v5.5
+    env:
+      WEB_INSTALLER: ${{ secrets.WEB_INSTALLER }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+      - name: Install Python build tooling
+        run: |
+          if ! python -m pip --version >/dev/null 2>&1; then
+            apt-get update
+            apt-get install -y --no-install-recommends python3-pip
+            rm -rf /var/lib/apt/lists/*
+          fi
+          python -m pip install --upgrade pip
+          python -m pip install pygit2 requests protobuf grpcio-tools
+      - name: Update Web Installer Project
+        run: |
+          git config --global --add safe.directory "${GITHUB_WORKSPACE}"
+          python docker/build_tools.py manifest --flash_file "/build/flash_project_args" --outdir "./bin_files" --manif_name "manifest" --max_count 3
+          python docker/build_tools.py pushinstaller --source "./bin_files" --manif_name "manifest" --target "web-installer" --url "https://github.com/sle118/squeezelite-esp32-installer.git" --artifacts "docs/artifacts" --web_installer_branch "main" --token "${{env.WEB_INSTALLER}}"

.gitignore

@@ -1,102 +1,28 @@
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Build files with potential private info
 build/
-sdkconfig.old
-
-# =========================
-# Operating System Files
-# =========================
-
-# Windows
-# =========================
-
-# Windows thumbnail cache files
-Thumbs.db
-ehthumbs.db
-ehthumbs_vista.db
-
-# Folder config file
-Desktop.ini
-
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
-
-# Windows Installer files
-*.cab
-*.msi
-*.msm
-*.msp
-
-# Windows shortcuts
-*.lnk
-*.save
-libs/
-
-/cdump.cmd
-/_*
-squeezelite-esp32-jsonblob.zip
-/flash_cmd.txt
-/writeSequeezeEsp.bat
-/writeSequeezeEsp.sh
-all_releases.json
-alltags.txt
-releases.json
-sdkconfig
-
 .vscode/c_cpp_properties.json
-
 .vscode/launch.json
-
 .vscode/settings.json
-
 .vscode/tasks.json
+alltags.txt
+components/wifi-manager/network_manager_handlers.multi
+esp32.code-workspace
+sdkconfig.old
+test/.vscode/c_cpp_properties.json
+test/.vscode/launch.json
+test/.vscode/settings.json
+test/.vscode/tasks.json
+test/sdkconfig
+components/wifi-manager/UML-State-Machine-in-C
+*.bak
 
-components/wifi-manager/.project
-
-components/wifi-manager/.settings/.jsdtscope
-
-components/wifi-manager/.settings/org.eclipse.wst.jsdt.ui.superType.container
-
-components/wifi-manager/.settings/org.eclipse.wst.jsdt.ui.superType.name
-
-components/wifi-manager/res/backup/
-
-*.code-workspace
-
-test/.vscode/
-
-node_modules/*
-esp-dsp/
-
-
+envfile.txt
+artifacts
+web-installer
+esp-idf-vscode-generated.gdb
+.vscode/.espidf.peripherals.state.json
+.vscode/squeezelite-esp32.code-workspace
+debug.log
+components/driver_bt/bt_app_source - Copy.c.old
+components/driver_bt/bt_app_source - Copy.c.old
+components/driver_bt/bt_app_source - Copy.c.old
+.devcontainer-data/

.gitmodules

@@ -5,3 +5,9 @@
 [submodule "components/esp-dsp"]
 	path = components/esp-dsp
 	url = https://github.com/philippe44/esp-dsp.git
+[submodule "components/wifi-manager/UML-State-Machine-in-C"]
+	path = components/wifi-manager/UML-State-Machine-in-C
+	url = https://github.com/kiishor/UML-State-Machine-in-C
+[submodule "components/wifi-manager/webapp/src/bootswatch"]
+	path = components/wifi-manager/webapp/src/bootswatch
+	url = https://github.com/thomaspark/bootswatch.git

.project

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>squeezelite-esp32-idfv4</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.cdt.core.cBuilder</name>
-			<triggers>clean,full,incremental,</triggers>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.cdt.core.cnature</nature>
-		<nature>org.eclipse.cdt.core.ccnature</nature>
-		<nature>com.espressif.idf.core.idfNature</nature>
-	</natures>
-</projectDescription>

AGENTS.md

@@ -0,0 +1,184 @@
+# AGENTS.md
+
+This file is the default startup brief for Codex sessions in this repository.
+Keep it short, directive, and high-signal.
+
+## Mission
+
+- Preserve platform behavior and stability.
+- Prefer small, reversible changes over broad rewrites.
+- Keep behavior unchanged unless a request explicitly asks for behavior changes.
+
+## Working Scope
+
+- Primary source code: `components/`, `main/`, `test/`.
+- Build and release scripts: `build-scripts/`, `docker/`, `.github/workflows/`.
+- Documentation: `documentation/`.
+
+## Engineering Priorities
+
+1. Correctness and safety.
+2. Backward-compatible behavior.
+3. Maintainability and clarity.
+4. Build/test reproducibility.
+5. Performance and footprint optimization.
+
+Optimize in this order unless the task explicitly changes priorities.
+
+## Do Not Edit By Default
+
+- Vendor/external code:
+  - `components/esp-dsp/`
+  - `components/spotify/cspot/`
+  - `components/telnet/libtelnet/`
+  - `managed_components/`
+- Build outputs and generated artifacts:
+  - `build/`
+  - `components/wifi-manager/webapp/dist/`
+
+Only modify these paths when the task explicitly requires it.
+
+## Behavioral Invariants
+
+- Treat OTA/recovery reliability as a product-level contract.
+- Treat partition layout as a fixed contract unless explicitly requested otherwise.
+- Do not introduce platform-specific compile-time branches when
+  runtime/config solutions are sufficient.
+- Avoid unrelated churn; keep patches tightly scoped to the request.
+
+## Standard Workflow
+
+1. Read the request and identify touched modules and contracts.
+2. Inspect current code and existing patterns in those modules.
+3. Implement the smallest coherent patch that preserves contracts.
+4. Run targeted validation commands.
+5. Report changes, validation evidence, and residual risks.
+6. Commit hygiene: make small commits and push frequently when progress
+   needs to be traceable by commit SHA across sessions/roles.
+
+Commit hygiene scope:
+- each role Codex runtime is responsible for commit hygiene in its own
+  repository (product repo for `arch`, infra repo for `infra`, runner
+  repo for `runner`)
+
+## Ownership Contract (Arch Closure Rule)
+
+When `arch:codex` is explicitly asked to "take ownership" of a task or
+workstream, `arch:codex` is accountable for driving it to closure:
+
+- closure means either:
+  - `done` with acceptance met and evidence recorded, or
+  - `blocked` with concrete blockers, owners, operator gates, and next
+    actions recorded (not vague "waiting")
+- `arch:codex` may delegate execution to `infra:codex` / `runner:codex`,
+  but must actively steer until closure (handoffs updated, blockers
+  cleared or escalated, and the workstream status stabilized)
+- do not stop at "prepared a packet"; prepared packets are inputs to
+  closure, not closure themselves
+
+Exception:
+- `arch:codex` may stop early when a pivot is required or a problem
+  solving loop is stalled, but only after recording a stable closure
+  state:
+  - `action_type=replan` with the pivot proposal and updated next
+    actions, or
+  - `blocked` with the specific stalled hypothesis, what was tried, and
+    what new information is needed to proceed
+
+## Validation Commands
+
+- Style check: `build-scripts/lint_style.sh check`
+- Style normalize: `build-scripts/lint_style.sh format`
+- Firmware build (example): `idf.py build`
+- Recovery footprint (platform-specific):
+  `build-scripts/build_recovery_size.sh <platform|defaults-file> [build-dir]`
+
+Use targeted checks first; avoid full-matrix builds unless requested.
+
+## Testing Rule (Grounding)
+
+- Tests should validate behavior contracts and invariants, not implementation details.
+- Prefer module-boundary and regression tests over private-internal assertions.
+- Every bug fix should include a regression test at the highest stable
+  boundary possible.
+- Use:
+  - `documentation/TESTING_CHARTER.md`
+  - `documentation/CONTRACT_TEST_TEMPLATE.md`
+  - `documentation/HARDWARE_TEST_MATRIX.md`
+  - `documentation/agents/ci_lane_contract.md`
+
+## Style Baseline
+
+- Use repository formatting/lint settings as the source of truth.
+- Do not introduce style-only churn outside task scope unless requested.
+- During refactors, normalization is acceptable when intentionally planned.
+- For doc-only cleanup tasks, follow
+  `documentation/agents/document_gardening.md`.
+
+## Frontend Context (Required)
+
+- For any UI/API work involving `components/wifi-manager/webapp/` or
+  `components/wifi-manager/http_server_handlers.c`, read:
+  - `documentation/agents/frontend_requirements_context.md`
+- Treat that file as requirements-first context and keep it current.
+- When frontend payload, routes, or protobuf contract changes, run:
+  - `build-scripts/ui_footprint_snapshot.sh`
+- Then update `documentation/agents/frontend_requirements_context.md` in
+  the same change.
+
+## Agent Docs Layout
+
+- Keep this file concise and policy-focused.
+- Put detailed playbooks under `documentation/agents/`.
+- For progressive context discovery, start with:
+  - `documentation/agents/start_here.md`
+- For remote-role delegation (`infra`/`runner`), follow:
+  - `documentation/agents/remote_delegation_contract.md` (autonomous
+    delegation + handshake + `thread_ref` correlation)
+- Add module-specific guidance in local `AGENTS.md` files when needed
+  (closest file to changed code takes precedence).
+
+## Short-Term Goal Tracking (Ephemeral)
+
+- Active multi-agent implementation goals live under:
+  - `documentation/short-term/active/`
+- Coordination files live under:
+  - `documentation/short-term/coordination/workstream_board.md`
+  - `documentation/short-term/coordination/handoff_log.md`
+- When prompted to continue pending multi-agent work, read those files
+  first and update them before ending the session.
+- Use role-based owner values in short-term boards:
+  - `arch:<agent-id>` for architecture/control-plane work
+  - `infra:<agent-id>` for infrastructure/host/VM work
+  - `runner:<agent-id>` for VM CI/CD execution work
+- Handoff entries for short-term goals should include:
+  - `context` (`arch-local` | `infra-live` | `runner-live`)
+  - `action_type` (`scaffold` | `delegate` | `execute` | `replan`)
+  - `operator_required` (`yes` | `no`)
+- Role-origin evidence naming should use prefixes where feasible:
+  - `arch_*`, `infra_*`, `runner_*`
+- User/operator reprioritization or path-shift requests (e.g. \"we
+  missed...\", \"easier way...\", \"we should prioritize...\") should
+  trigger a formal short-term replan update before continuing execution.
+- For ad-hoc user requests, proactively ask whether to track as a
+  ticket (`yes`/`no`) and, when accepted, record it in
+  `documentation/short-term/coordination/ad_hoc_ticket_queue.md`.
+- For local GitLab usage (`git.lecsys.net`), keep role secrets only in
+  `${XDG_CONFIG_HOME:-$HOME/.config}/codex/credentials/gitlab/git.lecsys.net/`
+  with directory mode `0700` and file mode `0600`; never commit
+  credential files or paste secret values in handoff logs.
+- Preserve CI lane boundary:
+  - upstream GitHub lane for build/non-hardware tests
+  - local LXD lane for hardware-in-loop execution
+- Repository boundary enforcement (strict):
+  - never edit or run role execution from `arch` against runner/infra
+    repositories on this machine (for example
+    `/workspaces/codex-runner-agent`, `/workspaces/codex-infra-agent`)
+  - all `runner` and `infra` workstreams must be executed by their
+    remote Codex runtimes and reported back via handoff logs
+- Completion gate:
+  - Workstream `done` means that workstream acceptance is met.
+  - Goal completion is separate and requires every item in the goal
+    deliverables checklist to be checked with evidence.
+  - Do not mark a goal complete or archive it while any deliverable
+    checklist item remains unchecked.

CHANGELOG

@@ -0,0 +1,27 @@
+2023-10-11
+ - Reduce the size of binaries (Fixes https://github.com/sle118/squeezelite-esp32/issues/329)
+ - [WEB] Allow running without LMS with option "Audio/Disable Squeezelite"
+
+2023-10.07
+ - catchup with official cspot
+ 
+2023-10-06
+ - fix cspot PREV on first track, NEXT on last track and normal ending
+ - use DMA_AUTO for SPI
+ - cspot share same time log
+ 
+2023-10-06
+ - Fix bootswatch bug that caused difficult to read UI ( issue #319)
+
+2023-10-02
+ - update cspot
+ 
+2023-09-29
+- sleep mechanism
+- spotify can store credentials so that zeroconf is optional and players are always registered
+- add battery to led_vu (see credits)
+- spdif can do 24 bits (see credits)
+- rmt fixes
+- airplay & spotify artwork fixes
+- airplay stability improvments
+- fix UI text color

CMakeLists.txt

@@ -1,14 +1,262 @@
 cmake_minimum_required(VERSION 3.5)
-set(EXTRA_COMPONENT_DIRS components/platform_console/app_recovery components/platform_console/app_squeezelite  )
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+set(PROJECT_VER $ENV{PROJECT_VER})
 add_definitions(-DMODEL_NAME=SqueezeESP32)
+
 if(NOT DEFINED DEPTH)
 	set(DEPTH "16")
 endif()	
-message(STATUS  "Building RECOVERY")
+
+# State machine hierarchy enabled and logging enabled
+add_definitions(-DSTATE_MACHINE_LOGGER=1)
+#add_definitions(-DHIERARCHICAL_STATES=1)
+
+# Align the nanopb library options across the entire project
+# otherwise this results in nasty structures misalignment 
+# when implementing callbacks
+add_definitions(-DPB_ENABLE_MALLOC -DPB_FIELD_32BIT)
+
+# Uncomment line below to get memory usage trace details
+# add_definitions(-DENABLE_MEMTRACE=1)
+#uncomment line below to get network ethernet debug logs 
+#add_definitions(-DNETWORK_ETHERNET_LOG_LEVEL=ESP_LOG_DEBUG)
+#uncomment line below to get network status debug logs
+#add_definitions(-DNETWORK_STATUS_LOG_LEVEL=ESP_LOG_DEBUG)
+add_definitions(-DNETWORK_HANDLERS_LOG_LEVEL=ESP_LOG_DEBUG)
+
+#add_definitions(-DNETWORK_WIFI_LOG_LEVEL=ESP_LOG_DEBUG)
+add_definitions(-DNETWORK_MANAGER_LOG_LEVEL=ESP_LOG_DEBUG)
+
+#add_definitions(-DNETWORK_HTTP_SERVER_LOG_LEVEL=ESP_LOG_DEBUG)
+
+# utility to build sizes
+function(build_size target_name) 
+    set(target_elf ${target_name}.elf)
+    set(target_map ${target_name}.map)
+    set(idf_size ${python} ${IDF_PATH}/tools/idf_size.py)
+    
+    if(DEFINED OUTPUT_JSON AND OUTPUT_JSON)
+        list(APPEND idf_size "--json")
+    endif()
+ 
+    add_custom_target(size-${target_name} ALL
+        DEPENDS ${target_elf}
+        COMMAND ${idf_size} ${target_map} -o "size-${target_name}"
+    )
+
+    add_custom_target(size-files-${target_name} ALL
+        DEPENDS ${target_elf}
+        COMMAND ${idf_size} --files ${target_map}
+    )
+
+    add_custom_target(size-components-${target_name} ALL
+        DEPENDS ${target_elf}
+        COMMAND ${idf_size} --archives ${target_map}
+    )
+endfunction()  
+
+# manually add the 2 versions for application: recovery and squeezelite
+set(EXTRA_COMPONENT_DIRS components/platform_console/app_recovery components/platform_console/app_squeezelite  )
+
 project(recovery)
-set_property(TARGET recovery.elf PROPERTY RECOVERY_PREFIX app_recovery )
-include(squeezelite.cmake)
-set(PROJECT_VER $ENV{PROJECT_VER})
-#target_compile_definitions(__idf_squeezelite-ota PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_VERBOSE)
-#target_compile_definitions(__idf_driver_bt PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+# we need own "esp_app_desc" to take precedence
+add_custom_command(
+			TARGET recovery.elf
+			PRE_LINK
+			COMMAND xtensa-esp32-elf-objcopy --weaken-symbol esp_app_desc  ${BUILD_DIR}/esp-idf/app_update/libapp_update.a
+	        VERBATIM
+)
+
+# when building recovery, add app_recovery to the link
+get_target_property(BCA recovery.elf LINK_LIBRARIES)
+list(REMOVE_ITEM BCA "idf::app_squeezelite" "idf::app_recovery" "-Wl,--Map=${BUILD_DIR}/recovery.map" "-Wl,--cref -Wl,--Map=${BUILD_DIR}/recovery.map")
+set_target_properties(recovery.elf PROPERTIES LINK_LIBRARIES "${BCA};idf::app_recovery;-Wl,--Map=${BUILD_DIR}/recovery.map")
+
+# create files with size for recovery 
+# build_size(recovery)
+
+# build squeezelite, add app_squeezelite to the link
+add_executable(squeezelite.elf "CMakeLists.txt")
+add_dependencies(squeezelite.elf recovery.elf)
+set_target_properties(squeezelite.elf PROPERTIES LINK_LIBRARIES "${BCA};idf::app_squeezelite;-Wl,--Map=${BUILD_DIR}/squeezelite.map")
+get_target_property(BCASQUEEZELITE squeezelite.elf LINK_LIBRARIES)
+add_custom_command(
+			TARGET squeezelite.elf
+			POST_BUILD 
+			COMMAND ${CMAKE_COMMAND} -E echo "Generating ${BUILD_DIR}/squeezelite.bin"
+            COMMAND ${CMAKE_COMMAND} -E echo "BCA value for squeezelite is: ${BCASQUEEZELITE}"
+			COMMAND ${ESPTOOLPY} elf2image ${ESPTOOLPY_FLASH_OPTIONS} ${ESPTOOLPY_ELF2IMAGE_OPTIONS} -o "squeezelite.bin" "squeezelite.elf"
+	        VERBATIM
+)
+
+# create files with size for squeezelite
+# build_size(squeezelite)
+    
+# make it part of cleanup    
+set_property(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" 
+             APPEND PROPERTY 
+             ADDITIONAL_MAKE_CLEAN_FILES "${BUILD_DIR}/squeezelite.elf" "${BUILD_DIR}/squeezelite.map"
+)
+
+# adding OTA_0 partition
+partition_table_get_partition_info(otaapp_offset "--partition-type app --partition-subtype ota_0" "offset")
+idf_component_get_property(main_args esptool_py FLASH_ARGS)
+idf_component_get_property(sub_args esptool_py FLASH_SUB_ARGS)
+esptool_py_flash_target(squeezelite-flash "${main_args}" "${sub_args}")
+esptool_py_flash_target_image(squeezelite-flash squeezelite "${otaapp_offset}" "${BUILD_DIR}/squeezelite.bin")
+esptool_py_flash_target_image(flash squeezelite "${otaapp_offset}" "${BUILD_DIR}/squeezelite.bin")
+
+# and JTAG scripts
+add_custom_target(_jtag_scripts  ALL
+					BYPRODUCTS "flash_dbg_project_args"  
+					POST_BUILD
+					COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_SOURCE_DIR}/tools/generate_debug_scripts.cmake"
+)
+
+if(CMAKE_HOST_UNIX)
+  # Add custom target to set executable permissions before build for cspot component
+    add_custom_target(set_cspot_permissions
+        COMMAND ${CMAKE_COMMAND} -E echo "************************************************************************************************"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** Setting permissions for required files"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/protoc-gen-nanopb"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/*.py"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/*.py2"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/proto/*.py"
+        COMMAND ${CMAKE_COMMAND} -E echo "**** ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/protoc"
+        COMMAND chmod +x ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/protoc-gen-nanopb
+        COMMAND chmod +x ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/*.py
+        COMMAND chmod +x ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/*.py2
+        COMMAND chmod +x ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/proto/*.py
+        COMMAND chmod +x ${CMAKE_SOURCE_DIR}/components/spotify/cspot/bell/external/nanopb/generator/protoc
+        COMMAND ${CMAKE_COMMAND} -E echo "************************************************************************************************"    
+    )
+
+  # Add a dependency to ensure permissions are set before building cspot component
+  add_dependencies(__idf_spotify set_cspot_permissions)
+endif()
+
+# Set the main project library target here before including protocol_buffers.cmake
+# add_library(main_project_lib ...)
+
+# Include the protocol_buffers.cmake file
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/protobuf ${CMAKE_CURRENT_BINARY_DIR}/protobuf)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/spiffs_src ${CMAKE_CURRENT_BINARY_DIR}/spiffs)
+
+
+
+# ======================= DEBUG FLAGS ============================
+
+# target_compile_definitions(__idf_wifi-manager PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_app_recovery PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_INFO)
+# target_compile_definitions(__idf_esp_event PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_INFO)
+# target_compile_definitions(__idf_esp_netif PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_bt PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_ERROR)
+# target_compile_definitions(__idf_mdns PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_tcpip_adapter PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_tcp_transport PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+# target_compile_definitions(__idf_app_squeezelite PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_app_trace PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_app_update PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_asio PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_audio PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_bootloader_support PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_display PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_driver PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_driver_bt PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_platform_config PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_squeezelite PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_squeezelite-ota PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_telnet PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_main PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+
+
+
+
+
+
+
+
+
+
+
+
+#target_compile_definitions(__idf_esp_eth PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_INFO)
+# target_compile_definitions(__idf_services PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_driver PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+
+# target_compile_definitions(__idf_esp_wifi PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_platform_console PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+
+
+
+# target_compile_definitions(__idf_esp_eth PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_INFO)
+
+
+
+# target_compile_definitions(__idf_freertos PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+
+# target_compile_definitions(__idf_cbor PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_cmock PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_coap PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_cxx PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_adc_cal PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_https_ota PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_http_client PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_http_server PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_hw_support PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_ipc PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_local_ctrl PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_pm PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_ringbuf PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_rom PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_serial_slave_link PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_system PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_esp_timer PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_expat PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_fatfs PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_freemodbus PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_hal PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_heap PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_jsmn PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_json PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_libsodium PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_log PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_lwip PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+# target_compile_definitions(__idf_mbedtls PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(mbedcrypto PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(mbedtls PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(mbedx509 PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_mqtt PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_newlib PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_nghttp PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_nvs_flash PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_openssl PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_perfmon PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+
+# target_compile_definitions(__idf_protobuf-c PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_protocomm PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_pthread PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_raop PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_sdmmc PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+# target_compile_definitions(__idf_soc PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_spiffs PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_spi_flash PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+
+# target_compile_definitions(__idf_tools PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_ulp PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_unity PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_vfs PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_wear_levelling PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_wifi_provisioning PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_wpa_supplicant PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)
+# target_compile_definitions(__idf_xtensa PRIVATE -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG)

Dockerfile

@@ -1,33 +1,33 @@
-FROM ubuntu:18.04
+FROM espressif/idf:release-v5.5
 
-RUN apt-get update && apt-get install -y git wget libncurses-dev flex bison gperf \
-  python python-pip python-setuptools python-serial python-click \
-  python-cryptography python-future python-pyparsing \
-  python-pyelftools cmake ninja-build ccache libusb-1.0
+ARG DEBIAN_FRONTEND=noninteractive
 
-RUN mkdir /workspace
-WORKDIR /workspace
+# Install tools required by firmware + UI + release automation.
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        ca-certificates \
+        clang-format \
+        curl \
+        git \
+        git-lfs \
+        gnupg \
+        jq \
+        python3-pip \
+        unzip \
+        xz-utils \
+        zip \
+    && rm -rf /var/lib/apt/lists/*
 
-# Download and checkout known good esp-idf commit
-RUN git clone --recursive https://github.com/espressif/esp-idf.git esp-idf
-RUN cd esp-idf && git checkout 4dac7c7df885adaa86a5c79f2adeaf8d68667349
-RUN git clone https://github.com/sle118/squeezelite-esp32.git
+# Use Node 16 for legacy webapp packages (node-sass toolchain compatibility).
+RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash - \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends nodejs \
+    && npm install -g npm@8 \
+    && rm -rf /var/lib/apt/lists/*
 
-# Download GCC 5.2.0
-RUN wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
-RUN tar -xzf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
-RUN rm xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz
+RUN python -m pip install --no-cache-dir setuptools pygit2 requests protobuf grpcio-tools
 
-RUN rm -r /workspace/squeezelite-esp32
-RUN mkdir /workspace/squeezelite-esp32
+COPY docker/build_tools.py /usr/local/bin/build_tools.py
+RUN chmod +x /usr/local/bin/build_tools.py
 
-# Setup PATH to use esp-idf and gcc-5.2.0
-RUN touch /root/.bashrc && \
- echo export PATH="\$PATH:/workspace/xtensa-esp32-elf/bin" >> /root/.bashrc && \
- echo export IDF_PATH=/workspace/esp-idf >> /root/.bashrc
-
-# OPTIONAL: Install vim for text editing in Bash
-RUN apt-get update && apt-get install -y vim
-
-WORKDIR /workspace/squeezelite-esp32
-CMD ["bash"]
+WORKDIR /workspaces/squeezelite-esp32

Makefile

@@ -1,22 +0,0 @@
-# build system (Jenkins) should pass the following
-#export PROJECT_BUILD_NAME="${build_version_prefix}${BUILD_NUMBER}"
-#export PROJECT_BUILD_TARGET="${config_target}"
-
-#PROJECT_BUILD_NAME?=local
-#PROJECT_CONFIG_TARGET?=custom
-#PROJECT_NAME?=squeezelite.$(PROJECT_CONFIG_TARGET)
-#PROJECT_VER?="$(PROJECT_BUILD_NAME)-$(PROJECT_CONFIG_TARGET)"
-
-
-
-#recovery: PROJECT_NAME:=recovery.$(PROJECT_CONFIG_TARGET)
-#recovery: EXTRA_CPPFLAGS+=-DRECOVERY_APPLICATION=1
-
-PROJECT_NAME?=squeezelite
-EXTRA_CPPFLAGS+=  -I$(PROJECT_PATH)/main 
-
-#/-Wno-error=maybe-uninitialized 
-include $(IDF_PATH)/make/project.mk 
-
-# for future gcc version, this could be needed: CPPFLAGS+= -Wno-error=format-overflow -Wno-error=stringop-truncation
-

Makefile_std.mk

@@ -1,3 +0,0 @@
-PROJECT_NAME?= squeezelite
-EXTRA_COMPONENT_DIRS := $(PROJECT_PATH)/esp-dsp
-include $(IDF_PATH)/make/project.mk

README.md

@@ -1,74 +1,104 @@
-![Cross-Build](https://github.com/sle118/squeezelite-esp32/workflows/Cross-Build/badge.svg?branch=master-cmake)
+[![Platform Build](https://github.com/sle118/squeezelite-esp32/actions/workflows/Platform_build.yml/badge.svg)](https://github.com/sle118/squeezelite-esp32/actions/workflows/Platform_build.yml)
 # Squeezelite-esp32
-## What is this
-Squeezelite-esp32 is an audio software suite made to run on espressif's ESP32 wifi (b/g/n) and bluetooth chipset. It offers the following capabilities
+## Forewords
+**More and more people seems to use this without a LMS server, just for BT, AirPlay or Spotify. It's fine but understand that squeezeliteESP32 is primarily a Logitech Media Server player and has been designed around that concept. All the others are add-ons stitched to it, so other modes have their shortcomings. So please make sure you read [this](#Additional-configuration-notes-from-the-Web-UI) before opening an issue**
+## What is this?
+Squeezelite-esp32 is an audio software suite made to run on espressif's esp32 and esp32-s3 wifi (b/g/n) and bluetooth chipsets. It offers the following capabilities
 
 - Stream your local music and connect to all major on-line music providers (Spotify, Deezer, Tidal, Qobuz) using [Logitech Media Server - a.k.a LMS](https://forums.slimdevices.com/) and enjoy multi-room audio synchronization. LMS can be extended by numerous plugins and can be controlled using a Web browser or dedicated applications (iPhone, Android). It can also send audio to UPnP, Sonos, ChromeCast and AirPlay speakers/devices.
-- Stream from a Bluetooth device (iPhone, Android)
-- Stream from an AirPlay controller (iPhone, iTunes ...) and enjoy synchronization multiroom as well (although it's AirPlay 1 only)
+- Stream from a **Bluetooth** device (iPhone, Android)
+- Stream from an **AirPlay** controller (iPhone, iTunes ...) and enjoy synchronization multiroom as well (although it's AirPlay 1 only)
+- Stream directly from **Spotify** using SpotifyConnect (thanks to [cspot](https://github.com/feelfreelinux/cspot)) - please read carefully [this](#spotify)
 
-Depending on the hardware connected to the ESP32, you can send audio to a local DAC, to SPDIF or to a Bluetooth speaker. The bare minimum required hardware is a WROVER module with 4MB of Flash and 4MB of PSRAM (https://www.espressif.com/en/products/modules/esp32). With that module standalone, just apply power and you can stream to a Bluetooth speaker. You can also send audio to most I2S DAC as well as to SPDIF receivers using just a cable or an optical transducer.
+Depending on the hardware connected to the esp32, you can send audio to a local DAC, to SPDIF or to a Bluetooth speaker. The bare minimum required hardware is a WROVER module with 4MB of Flash and 4MB of PSRAM (https://www.espressif.com/en/products/modules/esp32). With that module standalone, just apply power and you can stream to a Bluetooth speaker. You can also send audio to most I2S DAC as well as to SPDIF receivers using just a cable or an optical transducer.
 
 But squeezelite-esp32 is highly extensible and you can add
 
-- Buttons and Rotary Encoder and map/combine them to various functions (play, pause, volume, next ...)
-- IR receiver (no pullup resistor or capacitor needed, just the 38kHz receiver)
-- Monochrome, GrayScale or Color displays using SPI or I2C (supported drivers are SH1106, SSD1306, SSD1322, SSD1326/7, SSD1351, ST7735, ST7789 and ILI9341).
+- [Buttons](#buttons) and [Rotary Encoder](#rotary-encoder) and map/combine them to various functions (play, pause, volume, next ...)
+- [GPIO expander](#gpio-expanders) (buttons, led and rotary)
+- [IR receiver](#infrared) (no pullup resistor or capacitor needed, just the 38kHz receiver)
+- [Monochrome, GrayScale or Color displays](#display) using SPI or I2C (supported drivers are SH1106, SSD1306, SSD1322, SSD1326/7, SSD1351, ST7735, ST7789 and ILI9341).
+- [LED strip](#led-strip) for VU-meter 
+- [Ethernet](#ethernet) using a Microchip LAN8720 with RMII interface or Davicom DM9051/W5500 over SPI.
 
 Other features include
 
- - Resampling 
- - 10-bands equalizer
+ - Resampling (16 bits mode)
+ - 10-bands equalizer (16 bits mode)
  - Automatic initial setup using any WiFi device 
  - Full web interface for further configuration/management
  - Firmware over-the-air update 
 
+To control the equalizer or use the display on LMS, a new player model is required and this is provided through a plugin that is part of LMS' 3rd party repositories
+
 ## Performances 
 *(opinions presented here so I = @philippe44)*
 The main build of squeezelite-esp32 is a 16 bits internal core with all calculations in 32 bits or float precision. This is a design choice I've made to preserve CPU performances (it is already stretching a lot the esp32 chipset) and optimize memory usage as we only have 4MB of usable RAM. Some might correctly comment that the WROVER module have 8MB of RAM, but the processor is only able to address 4MB and the remaining 4MB must be paginated by smaller blocks and I don't have patience to that. 
 
 Now, when I did the porting of squeezelite to esp32, I've also made the core 16 or 32 bits compatible at compile-time. So far, it works in 32 bits but less tests have been done. You can chose to compile it in 32 bits mode. I'm not very interested above 16 bits samples because it does not bring anything (I have an engineering background in theory of information). 
 
-| Capability                 |16 bits|32 bits| comment         						         |	
-|----------------------------|-------|-------|-------------------------------------------------------------------|
-| max sampling rate          |  192k |  96k  | 192k is very challenging, especially when combined with display   |
-| max bit depth              |  16   |  24   | 24 bits are truncated in 16 bits mode                             | 
-| spdif			     |16 bits|20 bits|		                                                         |
-| mp3, aac, opus, ogg/vorbis |  48k  |  48k  |		                                                         |
-| alac, flac, ogg/flac       |  96k  |  96k  | 		                                                         |
-| pcm, wav, aif              |  192k |  96k  |		                                                         |
-| equalizer                  |   Y   |   N   | 48kHz max (after resampling) - equalization skipped on 96k tracks |
-| resampling                 |   Y   |   N   |		                                                         |
-| cross-fade                 |  10s  |  <5s  | depends on buffer size and sampling rate		                 |
+| Capability                 |16 bits|32 bits| comment         						          |	
+|----------------------------|-------|-------|--------------------------------------------------------------------|
+| max sampling rate          |  192k |  96k  | 192k is very challenging, especially when combined with display    |
+| max bit depth              |  16   |  24   | 24 bits are truncated in 16 bits mode                              | 
+| spdif			     |16 bits|20 bits|		                                                          |
+| mp3, aac, opus, ogg/vorbis |  48k  |  48k  |		                                                          |
+| alac, flac, ogg/flac       |  96k  |  96k  | 		                                                          |
+| pcm, wav, aif              |  192k |  96k  |		                                                          |
+| equalizer                  |   Y   |   N   | 48kHz max (after resampling) - equalization skipped on >48k tracks |
+| resampling                 |   Y   |   N   |		                                                          |
+| cross-fade                 |  10s  |  <5s  | depends on buffer size and sampling rate		                  |
 
 The esp32 must run at 240 MHz, with Quad-SPI I/O at 80 MHz and a clock of 40 Mhz. Still, it's a lot to run, especially knowing that it has a serial Flash and PSRAM, so kudos to Espressif for their chipset optimization. Now, to have all the decoding, resampling, equalizing, gain, display, spectrum/vu is a very (very) delicate equilibrium between use of internal /external RAM, tasks priorities and buffer handling. It is not perfect and the more you push the system to the limit, the higher the risk that some files would not play (see below). In general, the display will always have the lowest priority and you'll notice slowdown in scrolling and VU/Spectrum refresh rates. Now, even display thread has some critical section and impacts the capabilities. For example, a 16 bits-depth color display with low SPI speed might prevent 24/96 flac to work but still work with pcm 24/96
 
 In 16 bits mode, although 192 kHz is reported as max rate, it's highly recommended to limit reported sampling rate to 96k (-Z 96000). Note that some high-speed 24/96k on-line streams might stutter because of TCP/IP stack performances. It is usually due to the fact that the server sends small packets of data and the esp32 cannot receive encoded audio fast enough, regardless of task priority settings (I've tried to tweak that a fair bit). The best option in that case is to let LMS proxy the stream as it will provide larger chunks and a "smoother" stream that can then be handled.
 
 Note as well that some codecs consume more CPU than others or have not been optimized as much. I've done my best to tweak these, but that level of optimization includes writing some assembly which is painful. One very demanding codec is AAC when files are encoded with SBR. It allows reconstruction of upper part of spectrum and thus higher sampling rate, but the codec spec is such that this is optional, you can decode simply lower band and accept lower sampling rate - See the AAC_DISABLE_SBR option below.
+
+**IMPORTANT: on esp32 (not esp32-s3), using Spotify with SPDIF produces stuttering audio when "stats" are enabled. You MUST disable them**
+
 ## Supported Hardware
 Any esp32-based hardware with at least 4MB of flash and 4MB of PSRAM will be capable of running squeezelite-esp32 and there are various boards that include such chip. A few are mentionned below, but any should work. You can find various help & instructions [here](https://forums.slimdevices.com/showthread.php?112697-ANNOUNCE-Squeezelite-ESP32-(dedicated-thread))
 
 **For the sake of clarity, WROOM modules DO NOT work as they don't include PSRAM. Some designs might add it externally, but it's (very) unlikely.**
+
 ### Raw WROVER module
 Per above description, a [WROVER module](https://www.espressif.com/en/products/modules/esp32) is enough to run Squeezelite-esp32, but that requires a bit of tinkering to extend it to have analogue audio or hardware buttons (e.g.) 
 
 Please note that when sending to a Bluetooth speaker (source), only 44.1 kHz can be used, so you either let LMS do the resampling, but you must make sure it only sends 44.1kHz tracks or enable internal resampling (using -R) option. If you connect a DAC, choice of sample rates will depends on its capabilities. See below for more details.
 
 Most DAC will work out-of-the-box with simply an I2S connection, but some require specific commands to be sent using I2C. See DAC option below to understand how to send these dedicated commands. There is build-in support for TAS575x, TAS5780, TAS5713 and AC101 DAC.
+
+### Raw WROOM esp32-s3 module
+The esp32-s3 based modules like [this](https://www.espressif.com/sites/default/files/documentation/esp32-s3-wroom-1_wroom-1u_datasheet_en.pdf) are also supported but requires esp-idf 4.4. It is not yet part of official releases, but it compiles & runs. The s3 does not have bluetooth audio. Note that CPU performances are greatly enhanced.
+
 ### SqueezeAMP
 This is the main hardware companion of Squeezelite-esp32 and has been developped together. Details on capabilities can be found [here](https://forums.slimdevices.com/showthread.php?110926-pre-ANNOUNCE-SqueezeAMP-and-SqueezeliteESP32) and [here](https://github.com/philippe44/SqueezeAMP).
 
-if you want to rebuild, use the `squeezelite-esp32-SqueezeAmp-sdkconfig.defaults` configuration file.
+If you want to rebuild, use the `squeezelite-esp32-SqueezeAmp-sdkconfig.defaults` configuration file.
 
 NB: You can use the pre-build binaries SqueezeAMP4MBFlash which has all the hardware I/O set properly. You can also use the generic binary I2S4MBFlash in which case the NVS parameters shall be set to get the exact same behavior
-- set_GPIO: 12=green,13=red,34=jack,2=spkfault
-- batt_config: channel=7,scale=20.24
-- dac_config: model=TAS57xx,bck=33,ws=25,do=32,sda=27,scl=26,mute=14:0
-- spdif_config: bck=33,ws=25,do=15
+- set_GPIO: `12=green,13=red,34=jack,2=spkfault`
+- bat_config: `channel=7,scale=20.24`
+- dac_config: `model=TAS57xx,bck=33,ws=25,do=32,sda=27,scl=26,mute=14:0`
+- spdif_config: `bck=33,ws=25,do=15`
+
+The IR can be used as a wake-up signal using (setting `sleep_config` with `wake=0:0`). It's a pull-up so it stays at 1 when not receiving anything which means it cannot be used in conjuction with other wake-up IOs. See [Sleeping](#sleeping) for more details regarding the limitation of waking-up upon multiple inputs.
+
+### MuseLuxe
+This portable battery-powered [speaker](https://raspiaudio.com/produit/esp-muse-luxe) is compatible with squeezelite-esp32 for which there is a dedicated build supplied with every update. If you want to rebuild, use the `squeezelite-esp32-Muse-sdkconfig.defaults` configuration file.
+
+NB: You can use the pre-build binaries Muse4MBFlash which has all the hardware I/O set properly. You can also use the generic binary I2S4MBFlash in which case the NVS parameters shall be set to get the exact same behavior
+- target: `muse`
+- bat_config: `channel=5,scale=7.48,atten=3,cells=1`
+- spi_config: `"mosi=15,miso=2,clk=14` *(this one is probably optional)*
+- dac_config: `model=I2S,bck=5,ws=25,do=26,di=35,i2c=16,sda=18,scl=23,mck=0`
+- dac_controlset: `{"init":[ {"reg":0,"val":128}, {"reg":0,"val":0}, {"reg":25,"val":4}, {"reg":1,"val":80}, {"reg":2,"val":0},	{"reg":8,"val":0}, {"reg":4,"val":192},	{"reg":0,"val":18}, {"reg":1,"val":0}, {"reg":23,"val":24}, {"reg":24,"val":2}, {"reg":38,"val":9}, {"reg":39,"val":144}, {"reg":42,"val":144}, {"reg":43,"val":128}, {"reg":45,"val":128}, {"reg":27,"val":0}, {"reg":26,"val":0}, {"reg":2,"val":240}, {"reg":2,"val":0},	{"reg":29,"val":28}, {"reg":4,"val":48}, {"reg":25,"val":0}, {"reg":46,"val":33}, {"reg":47,"val":33} ]}`
+- actrls_config: buttons
+- define a "buttons" variable with: `[{"gpio":32, "pull":true, "debounce":10, "normal":{"pressed":"ACTRLS_VOLDOWN"}}, {"gpio":19, "pull":true, "debounce":40, "normal":{"pressed":"ACTRLS_VOLUP"}}, {"gpio":12, "pull":true, "debounce":40, "long_press":1000, "normal":{"pressed":"ACTRLS_TOGGLE"},"longpress":{"pressed":"ACTRLS_POWER"}}]`
 
 ### ESP32-A1S
-Works with [ESP32-A1S](https://docs.ai-thinker.com/esp32-a1s) module that includes audio codec and headset output. You still need to use a demo board like [this](https://www.aliexpress.com/item/4001060963585.html) or an external amplifier if you want direct speaker connection. Note that there is a version with AC101 codec and another one with ES8388 (see below)
+Works with [ESP32-A1S](https://docs.ai-thinker.com/esp32-a1s) module that includes audio codec and headset output. You still need to use a demo board like [this](https://aliexpress.com/item/4000130915903.html) or an external amplifier if you want direct speaker connection. Note that there is a version with AC101 codec and another one with ES8388 with probably two variants - these boards are a mess (see below)
 
 The board shown above has the following IO set
 - amplifier: GPIO21
@@ -84,27 +114,32 @@ The board shown above has the following IO set
 (note that some GPIO need pullups)
 
 So a possible config would be
-- set_GPIO: 21=amp,22=green:0,39=jack:0
-- dac_config: model=AC101,bck=27,ws=26,do=25,di=35,sda=33,scl=32 for ES83881
+- set_GPIO: `21=amp,22=green:0,39=jack:0`
 - a button mapping: 
-```
-[{"gpio":5,"normal":{"pressed":"ACTRLS_TOGGLE"}},{"gpio":18,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_NEXT"}}, {"gpio":23,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLDOWN"},"shifted":{"pressed":"ACTRLS_PREV"}}]
-```
-for AC101
-- dac_config: model=AC101,bck=27,ws=26,do=25,di=35,sda=33,scl=32
+	```json
+	[{"gpio":5,"normal":{"pressed":"ACTRLS_TOGGLE"}},{"gpio":18,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_NEXT"}}, {"gpio":23,"pull":true,"shifter_gpio":5,"normal":{"pressed":"ACTRLS_VOLDOWN"},"shifted":{"pressed":"ACTRLS_PREV"}}]
+	```
+for **AC101**
+- dac_config: `model=AC101,bck=27,ws=26,do=25,di=35,sda=33,scl=32`
  
-for ES8388 (not avail for now)
-- dac_config model=ES8388,bck=27,ws=26,do=25,sda=18,scl=23,i2c=16
-- dac_controlset: {"init":[{"reg":4,"val":60},{"reg":8,"val":0},{"reg":23,"val":24}]} (replace 24 by 32 for 32 bits bmode)
-### T-WATCH2020 by LilyGo
-This is a fun [smartwatch](http://www.lilygo.cn/prod_view.aspx?TypeId=50036&Id=1290&FId=t3:50036:3) based on ESP32. It has a 240x240 ST7789 screen and onboard audio. Not very useful to listen to anything but it works. This is an example of a device that requires an I2C set of commands for its dac (see below). There is a build-option if you decide to rebuild everything by yourself, otherwise the I2S default option works with the following parameters
+for **ES8388** (it seems that there are variants with same version number - a total mess)
+- dac_config: `model=ES8388,bck=5,ws=25,do=26,sda=18,scl=23,i2c=16`
+or
+- dac_config: `model=ES8388,bck=27,ws=25,do=26,sda=33,scl=32,i2c=16`
+
+### T-WATCH2020 by LilyGo
+This is a fun [smartwatch](http://www.lilygo.cn/prod_view.aspx?TypeId=50036&Id=1290&FId=t3:50036:3) based on ESP32. It has a 240x240 ST7789 screen and onboard audio. Not very useful to listen to anything but it works. This is an example of a device that requires an I2C set of commands for its DAC/APU (see below). There is a build-option if you decide to rebuild everything by yourself, otherwise the I2S default option works with the following parameters
+
+- dac_config: `model=I2S,bck=26,ws=25,do=33,i2c=53,sda=21,scl=22`
+- dac_controlset:
+	```json
+	{ "init": [ {"reg":41, "val":128}, {"reg":18, "val":255} ], "poweron": [ {"reg":18, "val":64, "mode":"or"} ], "poweroff": [ {"reg":18, "val":191, "mode":"and"} ] }
+	```
+- spi_config: `dc=27,data=19,clk=18`
+- display_config: `SPI,driver=ST7789,width=240,height=240,cs=5,back=12,speed=16000000,HFlip,VFlip`
 
-- dac_config: model=I2S,bck=26,ws=25,do=33,i2c=106,sda=21,scl=22
-- dac_controlset: { "init": [ {"reg":41, "val":128}, {"reg":18, "val":255} ], "poweron": [ {"reg":18, "val":64, "mode":"or"} ], "poweroff": [ {"reg":18, "val":191, "mode":"and"} ] }
-- spi_config: dc=27,data=19,clk=18
-- display_config: SPI,driver=ST7789,width=240,height=240,cs=5,back=12,speed=16000000,HFlip,VFlip
 ### ESP32-WROVER + I2S DAC
-Squeezelite-esp32 requires esp32 chipset and 4MB PSRAM. ESP32-WROVER meets these requirements. To get an audio output an I2S DAC can be used. Cheap PCM5102 I2S DACs work others may also work. PCM5012 DACs can be hooked up via:
+Squeezelite-esp32 requires esp32 chipset and 4MB PSRAM. ESP32-WROVER meets these requirements. To get an audio output an I2S DAC can be used. Cheap PCM5102 I2S DACs work but many others also do. PCM5012 DACs can be hooked up via:
 
 I2S - WROVER  
 VCC - 3.3V  
@@ -128,49 +163,60 @@ And the super cool project https://github.com/rochuck/squeeze-amp-too
 ## Configuration
 To access NVS, in the webUI, go to credits and select "shows nvs editor". Go into the NVS editor tab to change NFS parameters. In syntax description below \<\> means a value while \[\] describe optional parameters. 
 
+As mentionned above, there are a few dedicated builds that are provided today: SqueezeAMP and Muse but if you build it yourself, you can also create a build for T-WATCH2020. The default build is a generic firmware named I2S which can be configured through NVS to produce *exactly* the same results than dedicated builds. The difference is that parameters must be entered and can accidently be erased. The GUI provides a great help to load "known config sets" as well. 
+
+By design choice, there is no code that is only embedded for a given version, all code is always there. The philosophy is to minimize as much as possible platform-specific code and use of specific `#ifdef` is prohibited, no matter what. So if you want to add your own platfrom, please look **very hard** at the `main\KConfig.projbuild` to see how you can, using parameters below, make your device purely a configuration-based solution. When there is really no other option, look at `targets\<target>` to add your own code. I will not accept PR for code that can avoid creating such dedicated code whenever possible. The NVS "target" will be used to call target-specific code then, but again this is purely runtime, not compile-time.
+
 ### I2C
 The NVS parameter "i2c_config" set the i2c's gpio used for generic purpose (e.g. display). Leave it blank to disable I2C usage. Note that on SqueezeAMP, port must be 1. Default speed is 400000 but some display can do up to 800000 or more. Syntax is
 ```
 sda=<gpio>,scl=<gpio>[,port=0|1][,speed=<speed>]
 ```
-<strong>Please note that you can not use the same GPIO or port as the DAC</strong>
+**Please note that you can not use the same GPIO or port as the DAC.**
+
 ### SPI
-The NVS parameter "spi_config" set the spi's gpio used for generic purpose (e.g. display). Leave it blank to disable SPI usage. The DC parameter is needed for displays. Syntax is
+The esp32 has 4 SPI sub-systems, one is unaccessible so numbering is 0..2 and SPI0 is reserved for Flash/PSRAM. The NVS parameter "spi_config" set the spi's gpio used for generic purpose (e.g. display). Leave it blank to disable SPI usage. The DC parameter is needed for displays. Syntax is
 ```
-data=<gpio>,clk=<gpio>[,dc=<gpio>][,host=1|2]
+data|mosi=<gpio>,clk=<gpio>[,dc=<gpio>][,host=1|2][,miso=<gpio>]
 ``` 
+Default and only "host" is 1 as others are used already by flash and spiram. The optional "miso" (MasterInSlaveOut) parameter is only used when SPI bus is bi-directional and shared with other peripheral like ethernet, gpio expander. Note that "data" can also be named "mosi" (MasterOutSlaveIn). 
 ### DAC/I2S
-The NVS parameter "dac_config" set the gpio used for i2s communication with your DAC. You can define the defaults at compile time but nvs parameter takes precedence except for SqueezeAMP and A1S where these are forced at runtime. Syntax is
+The NVS parameter "dac_config" set the gpio used for i2s communication with your DAC. You can define the defaults at compile time but nvs parameter takes precedence except for named configurations
 ```
-bck=<gpio>,ws=<gpio>,do=<gpio>[,mute=<gpio>[:0|1][,model=TAS57xx|TAS5713|AC101|I2S][,sda=<gpio>,scl=gpio[,i2c=<addr>]]
+bck=<gpio>,ws=<gpio>,do=<gpio>[,mck=0|1|2][,mute=<gpio>[:0|1][,model=TAS57xx|TAS5713|AC101|WM8978|ES8388|I2S][,sda=<gpio>,scl=<gpio>[,i2c=<addr>]]
 ```
-if "model" is not set or is not recognized, then default "I2S" is used. I2C parameters are optional an only needed if your dac requires an I2C control (See 'dac_controlset' below). Note that "i2c" parameters are decimal, hex notation is not allowed.
+if "model" is not set or is not recognized, then default "I2S" is used. The option "mck" is used for some codecs that require a master clock (although they should not). By default GPIO0 is used as MCLK and only recent builds (post mid-2023) can use 1 or 2. Also be aware that this cannot coexit with RMII Ethernet (see ethernet section below). I2C parameters are optional and only needed if your DAC requires an I2C control (See 'dac_controlset' below). Note that "i2c" parameters are decimal, hex notation is not allowed.
 
-The parameter "dac_controlset" allows definition of simple commands to be sent over i2c for init, power on and off using a JSON syntax:
+So far, TAS57xx, TAS5713, AC101, WM8978 and ES8388 are recognized models where the proper init sequence/volume/power controls are sent. For other codecs that might require an I2C commands, please use the parameter "dac_controlset" that allows definition of simple commands to be sent over i2c for init, power, speaker and headset on and off using a JSON syntax:
+```json
+{ <command>: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
+  <command>: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
+  ... }
 ```
-{ init: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
-  poweron: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ],
-  poweroff: [ {"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"}, ... {{"reg":<register>,"val":<value>,"mode":<nothing>|"or"|"and"} ] }
-```
-This is standard JSON notation, so if you are not familiar with it, Google is your best friend. Be aware that the '...' means you can have as many entries as you want, it's not part of the syntax. Every section is optional, but it does not make sense to set i2c in the 'dac_config' parameter and not setting anything here. The parameter 'mode' allows to *or* the register with the value or to *and* it. Don't set 'mode' if you simply want to write. **Note that all values must be decimal**. You can use a validator like [this](https://jsonlint.com) to verify your syntax
+Where `<command>` is one of init, poweron, poweroff, speakeron, speakeroff, headseton, headsetoff
 
-NB: For well-known configuration, this is ignored
+This is standard JSON notation, so if you are not familiar with it, Google is your best friend. Be aware that the '...' means you can have as many entries as you want, it's not part of the syntax. Every section is optional, but it does not make sense to set i2c in the 'dac_config' parameter and not setting anything here. The parameter 'mode' allows to *or* the register with the value or to *and* it. Don't set 'mode' if you simply want to write. The 'val parameter can be an array [v1, v2,...] to write a serie of bytes in a single i2c burst (in that case 'mode' is ignored). **Note that all values must be decimal**. You can use a validator like [this](https://jsonlint.com) to verify your syntax
+
+The 'power' command is used when powering on/off the DAC after the idle period (see -C option of squeezelite) and the 'speaker/headset' commands are sent when switching between speakers and headsets (see headset jack detection).
+
+NB: For named configurations ((SqueezeAMP, Muse ... all except I2S), all this is ignored. For know codecs, the built-in sequences can be overwritten using dac_controlset
+
+**Please note that you can not use the same GPIO or port as the I2C.**
 
-<strong>Please note that you can not use the same GPIO or port as the I2C</strong>
 ### SPDIF
 The NVS parameter "spdif_config" sets the i2s's gpio needed for SPDIF. 
 
 SPDIF is made available by re-using i2s interface in a non-standard way, so although only one pin (DO) is needed, the controller must be fully initialized, so the bit clock (bck) and word clock (ws) must be set as well. As i2s and SPDIF are mutually exclusive, you can reuse the same IO if your hardware allows so.
 
-You can define the defaults at compile time but nvs parameter takes precedence except for SqueezeAMP where these are forced at runtime.
+You can define the defaults at compile time but nvs parameter takes precedence except for named configurations (SqueezeAMP, Muse ...)
 
 Leave it blank to disable SPDIF usage, you can also define them at compile time using "make menuconfig". Syntax is 
 ```
 bck=<gpio>,ws=<gpio>,do=<gpio>
 ```
-NB: For well-known configuration, this is ignored
+NB: For named configurations, this is ignored
 
-To optimize speed, a bit-manipulation trick is used and as a result, the bit depth is limited to 20 bits, even in 32 bits mode. As said before, this is more than enough for any human ear. In theory, it could be extended up to 23 bits but I don't see the need. Now, you can also get SPDIF using a specialized chip that offers a I2S interface like a DAC but spits out SPDIF (optical and coax). Refers to DAC chapter then.
+The maximum bit depth is 24 bits, even in 32 bits mode (this a SPDIF limitation - thank @UrbanLienert for theupdate from 20 to 24 bit). Now, you can also get SPDIF using a specialized chip that offers a I2S interface like a DAC but spits out SPDIF (optical and coax). Refers to DAC chapter then.
 
 If you want coax, you can also use a poor-man's trick to generate signal from a 3.3V GPIO. All that does is dividing the 3.3V to generate a 0.6V peak-to-peak and then remove DC
 ```
@@ -181,42 +227,42 @@ GPIO  ----210ohm-----------||---- coax S/PDIF signal out
                     |
 Ground -------------------------- coax signal ground
 ```
+
 ### Display
-The NVS parameter "display_config" sets the parameters for an optional display. Syntax is
+The NVS parameter "display_config" sets the parameters for an optional display. It can be I2C (see [here](#i2c) for shared bus) or SPI (see [here](#spi) for shared bus) Syntax is
 ```
 I2C,width=<pixels>,height=<pixels>[address=<i2c_address>][,reset=<gpio>][,HFlip][,VFlip][driver=SSD1306|SSD1326[:1|4]|SSD1327|SH1106]
-SPI,width=<pixels>,height=<pixels>,cs=<gpio>[,back=<gpio>][,reset=<gpio>][,speed=<speed>][,HFlip][,VFlip][driver=SSD1306|SSD1322|SSD1326[:1|4]|SSD1327|SH1106|SSD1675|ST7735|ST7789|ILI9341[:16|18][,rotate]]
+SPI,width=<pixels>,height=<pixels>,cs=<gpio>[,back=<gpio>][,reset=<gpio>][,speed=<speed>][,HFlip][,VFlip][driver=SSD1306|SSD1322|SSD1326[:1|4]|SSD1327|SH1106|SSD1675|ST7735|ST7789[:x=<offset>][:y=<offset>]|ILI9341[:16|18][,rotate]]
 ```
 - back: a LED backlight used by some older devices (ST7735). It is PWM controlled for brightness
-- reset: some display have a reset pin that is should normally be pulled up if unused
+- reset: some display have a reset pin that is should normally be pulled up if unused. Most displays require reset and will not initialize well otherwise.
 - VFlip and HFlip are optional can be used to change display orientation
 - rotate: for non-square *drivers*, move to portrait mode. Note that *width* and *height* must be inverted then
 - Default speed is 8000000 (8MHz) but SPI can work up to 26MHz or even 40MHz
-- SH1106 is 128x64 monochrome I2C/SPI [here]((https://www.waveshare.com/wiki/1.3inch_OLED_HAT))
+- SH1106 is 128x64 monochrome I2C/SPI [here](https://www.waveshare.com/wiki/1.3inch_OLED_HAT)
 - SSD1306 is 128x32 monochrome I2C/SPI [here](https://www.buydisplay.com/i2c-blue-0-91-inch-oled-display-module-128x32-arduino-raspberry-pi)
 - SSD1322 is 256x64 grayscale 16-levels SPI in multiple sizes [here](https://www.buydisplay.com/oled-display/oled-display-module?resolution=159) - it is very nice
 - SSD1326 is 256x32 monochrome or grayscale 16-levels SPI [here](https://www.aliexpress.com/item/32833603664.html?spm=a2g0o.productlist.0.0.2d19776cyQvsBi&algo_pvid=c7a3db92-e019-4095-8a28-dfdf0a087f98&algo_expid=c7a3db92-e019-4095-8a28-dfdf0a087f98-1&btsid=0ab6f81e15955375483301352e4208&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_)
 - SSD1327 is 128x128 16-level grayscale SPI [here](https://www.amazon.com/gp/product/B079N1LLG8/ref=ox_sc_act_title_1?smid=A1N6DLY3NQK2VM&psc=1) - artwork can be up to 96x96 with vertical vu-meter/spectrum
 - SSD1351 is 128x128 65k/262k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.5inch-rgb-oled-module.htm)
 - SSD1675 is an e-ink paper and is experimental as e-ink is really not suitable for LMS du to its very low refresh rate
-- ST7735 is a 128x160 65k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.8inch-lcd-module.htm). This needs a backlight control
+- ST7735 is a 128x160 65k color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/1.8inch-lcd-module.htm). This needs a backlight control. Some have X/Y offsets betwen the driver and the glass (green/black/red models) that can be added using "x" and "y" options (case sensitive!)
 - ST7789 is a 240x320 65k (262k not enabled) color SPI [here](https://www.waveshare.com/product/displays/lcd-oled/lcd-oled-3/2inch-lcd-module.htm). It also exist with 240x240 displays. See **rotate** for use in portrait mode
 - ILI9341 is another 240x320 65k (262k capable) color SPI. I've not used it much, the driver it has been provided by one external contributor to the project
 
-To use the display on LMS, add repository https://raw.githubusercontent.com/sle118/squeezelite-esp32/master/plugin/repo.xml. You will then be able to tweak how the vu-meter and spectrum analyzer are displayed, as well as size of artwork. You can also install the excellent plugin "Music Information Screen" which is super useful to tweak the layout.
+You can tweak how the vu-meter and spectrum analyzer are displayed, as well as size of artwork through a dedicated menu in player's settings (don't forget to add the plugin).
 
 The NVS parameter "metadata_config" sets how metadata is displayed for AirPlay and Bluetooth. Syntax is
 ```
-[format=<display_content>][,speed=<speed>][,pause=<pause>]
+[format=<display_content>][,speed=<speed>][,pause=<pause>][,artwork[:0|1]]
 ```
 - 'speed' is the scrolling speed in ms (default is 33ms)
-
 - 'pause' is the pause time between scrolls in ms (default is 3600ms)
-
-- 'format' can contain free text and any of the 3 keywords %artist%, %album%, %title%. Using that format string, the keywords are replaced by their value to build the string to be displayed. Note that the plain text following a keyword that happens to be empty during playback of a track will be removed. For example, if you have set format=%artist% - %title% and there is no artist in the metadata then only <title> will be displayed not " - <title>".
+- 'format' can contain free text and any of the 3 keywords `%artist%`, `%album%`, `%title%`. Using that format string, the keywords are replaced by their value to build the string to be displayed. Note that the plain text following a keyword that happens to be empty during playback of a track will be removed. For example, if you have set format=`%artist% - %title%` and there is no artist in the metadata then only `<title>` will be displayed not ` - <title>`.
+- 'artwork' enables coverart display, if available (does not work for Bluetooth). The optional parameter indicates if the artwork should be resized (1) to fit the available space. Note that the built-in resizer can only do 2,4 and 8 downsizing, so fit is not optimal. The artwork will be placed at the right of the display for landscape displays and underneath the two information lines for others (there is no user option to tweak that).
 
 ### Infrared
-You can use any IR receiver compatible with NEC protocol (38KHz). Vcc, GND and output are the only pins that need to be connected, no pullup, no filtering capacitor, it's a straight connection.
+You can use any IR receiver compatible with NEC protocol (38KHz) or RC5. Vcc, GND and output are the only pins that need to be connected, no pullup, no filtering capacitor, it's a straight connection.
 
 The IR codes are send "as is" to LMS, so only a Logitech SB remote from Boom, Classic or Touch will work. I think the file Slim_Devices_Remote.ir in the "server" directory of LMS can be modified to adapt to other codes, but I've not tried that.
 
@@ -229,26 +275,65 @@ The parameter "set_GPIO" is used to assign GPIO to various functions.
 
 GPIO can be set to GND provide or Vcc at boot. This is convenient to power devices that consume less than 40mA from the side connector. Be careful because there is no conflict checks being made wrt which GPIO you're changing, so you might damage your board or create a conflict here. 
 
-The \<amp\> parameter can use used to assign a GPIO that will be set to active level (default 1) when playback starts. It will be reset when squeezelite becomes idle. The idle timeout is set on the squeezelite command line through -C \<timeout\>
+The `<amp>` parameter can use used to assign a GPIO that will be set to active level (default 1) when playback starts. It will be reset when squeezelite becomes idle. The idle timeout is set on the squeezelite command line through `-C <timeout>`
+
+The `<power>` parameter can use used to assign a GPIO that will be set to active level (default 1) when player is powered on and reset when powered off (in LMS, does not apply to AirPlay, Spotify or BT).
 
 If you have an audio jack that supports insertion (use :0 or :1 to set the level when inserted), you can specify which GPIO it's connected to. Using the parameter jack_mutes_amp allows to mute the amp when headset (e.g.) is inserted.
 
-You can set the Green and Red status led as well with their respective active state (:0 or :1)
+You can set the Green and Red status led as well with their respective active state (:0 or :1) or specific the chipset if you use addressable RGB led.
 
-The \<ir\> parameter set the GPIO associated to an IR receiver. No need to add pullup or capacitor
+The `<ir>` parameter set the GPIO associated to an IR receiver. No need to add pullup or capacitor
 
 Syntax is:
 
 ```
-<gpio>=Vcc|GND|amp[:1|0]|ir|jack[:0|1]|green[:0|1]|red[:0|1]|spkfault[:0|1][,<repeated sequence for next GPIO>]
+<gpio>=Vcc|GND|amp[:1|0]|power[:1:0]|ir[:nec|rc5]|jack[:0|1]|green[:0|1|ws2812]|red[:0|1|ws2812]|spkfault[:0|1][,<repeated sequence for next GPIO>]
 ```
-You can define the defaults for jack, spkfault leds at compile time but nvs parameter takes precedence except for well-known configurations where these are forced at runtime.
+You can define the defaults for jack, spkfault leds at compile time but nvs parameter takes precedence except for named configurations ((SqueezeAMP, Muse ...) where these are forced at runtime.
+**Note that gpio 36 and 39 are input only and cannot use interrupt. When set to jack or speaker fault, a 100ms polling checks their value but that's expensive**
+ 
+### GPIO expanders
+It is possible to add GPIO expanders using I2C or SPI bus. They should mainly be used for buttons but they can support generic-purpose outputs as well. These additional GPIOs can be numbered starting from an arbitrary value (40 and above as esp32 has GPIO 0..39). Then these new "virtual" GPIOs from (e.g) 100 to 115 can be used in [button](#Buttons) configuration, [set_GPIO](#set-gpio) or other config settings.
+
+Each expander can support up to 32 GPIO. To use an expander for buttons, an interrupt must be provided, polling mode is not acceptable. An expander w/o interruption can still be configured, but only output will be usable. Note that the same interrupt can be shared accross expanders, as long as they are using open drain or open collectors (which they probably all do)
+
+The parameter "gpio_exp_config" is a semicolon (;) separated list with following syntax for each expander
+```
+model=<model>,addr=<addr>,[,port=system|dac][,base=<n>][,count=<n>][,intr=<gpio>][,cs=<gpio>][,speed=<Hz>]
+```	
+- model: pca9535, pca85xx, mcp23017 and mcp23s17 (SPI version)
+- addr: chip i2c/spi address (decimal)
+- port (I2C): use either "system" port (shared with display for example) or "dac" port (system is default)
+- cs (SPI): gpio used for Chip Select
+- speed (SPI): speed of the SPI bus for that device (in Hz)	
+- base: GPIO numbering offset to use everywhere else (default 40 on esp32 and 48 on esp32-s3)
+- count: number of GPIO of expander (default 16 - might be obsolted if model if sufficient to decide)
+- intr: real GPIO to use as interrupt.
+	
+Note that PWM ("led_brightness" below) is not supported for expanded GPIOs and they cannot be used for high speed or precise timing signals like CS, D/C, Reset and Ready. Buttons, rotary encoder, amplifier control and power are supported. Depending on the actual chipset, pullup or pulldown might be supported so you might have to add external resistors (only MCP23x17 does pullup). The pca8575 is not a great chip, it generate a fair bit of spurious interrupts when used for GPIO out. When using a SPI expander, the bus must be configured using shared [SPI](#SPI) bus
+
 ### LED 
-See §**set_GPIO** for how to set the green and red LEDs. In addition, their brightness can be controlled using the "led_brigthness" parameter. The syntax is
+See [set_GPIO](#set-gpio) for how to set the green and red LEDs (including addressable RGB ones). In addition, their brightness can be controlled using the "led_brigthness" parameter. The syntax is
 ```
 [green=0..100][,red=0..100]
 ```
-NB: For well-known configuration, this is ignored
+NB: For named configuration, GPIO affected to green and red LED cannot be changed but brightness option applies
+
+### LED Strip
+One LED strip with up to 255 addressable LEDs can be configured to offer enhanced visualizations.  The LED strip can also be controlled remotely though the LMS server (using the CLI interface).  Currently only WS2812B LEDs are supported.  Set the LED Strip configuration (or NVS led_vu_config) to `WS2812,length=<n>,gpio=<gpio>, where <n> is the number of leds in the strip (1..255), and <gpio> is the data pin.`  
+
+The latest LMS plugin update is required to set the visualizer mode and brightness, in the ESP32 settings page for the player.  The plugin also adds the following CLI command options
+```
+<playerid> led_visual [<mode>] [brightness(1-255)]
+  Toggles or selects the visulaizer mode.
+  The visualizer brighness can be controled using the optional <brighness> tag.
+
+<playerid> dmx <R,G,B|R,G,B,R,G,B ... R,G,B> [<offset>]
+  Sets the LED at position "offset" to any RGB color where "R"(red),"G"(green), and "B"(blue) are values from 0(off) to 255(max brightness).
+  Add additional RGB values to the delimited string to set multiple LEDs. 
+```
+
 ### Rotary Encoder
 One rotary encoder is supported, quadrature shift with press. Such encoders usually have 2 pins for encoders (A and B), and common C that must be set to ground and an optional SW pin for press. A, B and SW must be pulled up, so automatic pull-up is provided by ESP32, but you can add your own resistors. A bit of filtering on A and B (~470nF) helps for debouncing which is not made by software. 
 
@@ -273,14 +358,16 @@ The SW gpio is optional, you can re-affect it to a pure button if you prefer but
 
 See also the "IMPORTANT NOTE" on the "Buttons" section and remember that when 'lms_ctrls_raw' (see below) is activated, none of these knobonly,volume,longpress options apply, raw button codes (not actions) are simply sent to LMS
 
+**Note that gpio 36 and 39 are input only and cannot use interrupt, so they cannot be set to A or B. When using them for SW, a 100ms polling is used which is expensive**
+
 ### Buttons
 Buttons are described using a JSON string with the following syntax
-```
+```json
 [
-{"gpio":<num>,		
- "type":"BUTTON_LOW | BUTTON_HIGH",	
+{"gpio":<num>,
+ "type":"BUTTON_LOW | BUTTON_HIGH",
  "pull":[true|false],
- "long_press":<ms>, 
+ "long_press":<ms>,
  "debounce":<ms>,
  "shifter_gpio":<-1|num>,
  "normal": {"pressed":"<action>","released":"<action>"},
@@ -304,19 +391,22 @@ Where (all parameters are optionals except gpio)
  - "shifted": action to take when a button is pressed/released and shifted (see above/below)
  - "longshifted": action to take when a button is long-pressed/released and shifted (see above/below)
 
-Where \<action\> is either the name of another configuration to load (remap) or one amongst
+Where `<action>` is either the name of another configuration to load (remap) or one amongst
 
 ```
-ACTRLS_NONE, ACTRLS_VOLUP, ACTRLS_VOLDOWN, ACTRLS_TOGGLE, ACTRLS_PLAY, 
+ACTRLS_NONE, ACTRLS_POWER, ACTRLS_VOLUP, ACTRLS_VOLDOWN, ACTRLS_TOGGLE, ACTRLS_PLAY, 
 ACTRLS_PAUSE, ACTRLS_STOP, ACTRLS_REW, ACTRLS_FWD, ACTRLS_PREV, ACTRLS_NEXT, 
-BCTRLS_UP, BCTRLS_DOWN, BCTRLS_LEFT, BCTRLS_RIGHT,
-KNOB_LEFT, KNOB_RIGHT, KNOB_PUSH
+BCTRLS_UP, BCTRLS_DOWN, BCTRLS_LEFT, BCTRLS_RIGHT, 
+BCTRLS_PS1, BCTRLS_PS2, BCTRLS_PS3, BCTRLS_PS4, BCTRLS_PS5, BCTRLS_PS6, BCTRLS_PS7, BCTRLS_PS8, BCTRLS_PS9, BCTRLS_PS10,
+KNOB_LEFT, KNOB_RIGHT, KNOB_PUSH,
+ACTRLS_SLEEP,
 ```
-				
+Note that ACTRLS_SLEEP is not an actual button that can be sent to LMS, but it's a hook to activate deep sleep mode (see [Sleeping](#sleeping)).
+
 One you've created such a string, use it to fill a new NVS parameter with any name below 16(?) characters. You can have as many of these configs as you can. Then set the config parameter "actrls_config" with the name of your default config
 
 For example a config named "buttons" :
-```
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,"normal":{"pressed":"ACTRLS_VOLDOWN"},"longpress":{"pressed":"buttons_remap"}},
  {"gpio":5,"type":"BUTTON_LOW","pull":true,"shifter_gpio":4,"normal":{"pressed":"ACTRLS_VOLUP"}, "shifted":{"pressed":"ACTRLS_TOGGLE"}}]
 ``` 
@@ -325,7 +415,7 @@ Defines two buttons
 - second on GPIO 5, active low. When pressed it triggers a volume up command. If first button is pressed together with this button, then a play/pause toggle command is generated.
 
 While the config named "buttons_remap"
-```
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,"normal":{"pressed":"BCTRLS_DOWN"},"longpress":{"pressed":"buttons"}},
  {"gpio":5,"type":"BUTTON_LOW","pull":true,"shifter_gpio":4,"normal":{"pressed":"BCTRLS_UP"}}]
 ``` 
@@ -333,10 +423,14 @@ Defines two buttons
 - first on GPIO 4, active low. When pressed, it triggers a navigation down command. When pressed more than 1000ms, it changes the button configuration for the one described above
 - second on GPIO 5, active low. When pressed it triggers a navigation up command. That button, in that configuration, has no shift option
 
-Below is a difficult but functional 2-buttons interface for your decoding pleasure
+Below is a difficult but functional 2-buttons interface for your decoding pleasure:
 
-*buttons*
+`actrls_config`:
 ```
+buttons
+```
+`buttons`:
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,
  "normal":{"pressed":"ACTRLS_VOLDOWN"},
  "longpress":{"pressed":"buttons_remap"}},
@@ -346,8 +440,8 @@ Below is a difficult but functional 2-buttons interface for your decoding pleasu
  "longpress":{"pressed":"ACTRLS_NEXT"}}
 ]
 ```
-*buttons_remap*
-```
+`buttons_remap`:
+```json
 [{"gpio":4,"type":"BUTTON_LOW","pull":true,"long_press":1000,
  "normal":{"pressed":"BCTRLS_DOWN"},
  "longpress":{"pressed":"buttons"}},
@@ -358,21 +452,96 @@ Below is a difficult but functional 2-buttons interface for your decoding pleasu
  "longshifted":{"pressed":"BCTRLS_LEFT"}}
 ]
 ```
-<strong>IMPORTANT NOTE</strong>: LMS also supports the possibility to send 'raw' button codes. It's a bit complicated, so bear with me. Buttons can either be processed by SqueezeESP32 and mapped to a "function" like play/pause or they can be just sent to LMS as plain (raw) code and the full logic of press/release/longpress is handled by LMS, you don't have any control on that.
+**IMPORTANT NOTE**: LMS also supports the possibility to send 'raw' button codes. It's a bit complicated, so bear with me. Buttons can either be processed by SqueezeESP32 and mapped to a "function" like play/pause or they can be just sent to LMS as plain (raw) code and the full logic of press/release/longpress is handled by LMS, you don't have any control on that.
 
-The benefit of the "raw" mode is that you can build a player which is as close as possible to a Boom (e.g.) but you can't use the remapping function nor longress or shift logics to do your own mapping when you have a limited set of buttons. In 'raw' mode, all you really need to define is the mapping between the gpio and the button. As far as LMS is concerned, any other option in these JSON payloads does not matter. Now, when you use BT or AirPlay, the full JSON construct described above fully applies, so the shift, longpress, remapping options still work. 
+The benefit of the "raw" mode is that you can build a player which is as close as possible to a Boom (e.g.) but you can't use the remapping function nor longpress or shift logics to do your own mapping when you have a limited set of buttons. In 'raw' mode, all you really need to define is the mapping between the gpio and the button. As far as LMS is concerned, any other option in these JSON payloads does not matter. Now, when you use BT or AirPlay, the full JSON construct described above fully applies, so the shift, longpress, remapping options still work.
 
 **Be aware that when using non "raw" mode, the CLI (Command Line Interface) of LMS is used and *must* be available without password**
 
 There is no good or bad option, it's your choice. Use the NVS parameter "lms_ctrls_raw" to change that option
+	
+**Note that gpio 36 and 39 are input only and cannot use interrupt. When using them for a button, a 100ms polling is started which is expensive. Long press is also likely to not work very well**
+### Ethernet 
+Wired ethernet is supported by esp32 with various options but squeezeESP32 is only supporting a Microchip LAN8720 with a RMII interface like [this](https://www.aliexpress.com/item/32858432526.html) or SPI-ethernet bridges like Davicom DM9051 [that](https://www.amazon.com/dp/B08JLFWX9Z) or W5500 like [this](https://www.aliexpress.com/item/32312441357.html).
 
+**Note:** Touch buttons that can be find on some board like the LyraT V4.3 are not supported currently.
+
+#### RMII (LAN8720)	
+- RMII PHY wiring is fixed and can not be changed
+
+| GPIO   | RMII Signal | Notes        |
+| ------ | ----------- | ------------ |
+| GPIO21 | TX_EN       | EMAC_TX_EN   |
+| GPIO19 | TX0         | EMAC_TXD0    |
+| GPIO22 | TX1         | EMAC_TXD1    |
+| GPIO25 | RX0         | EMAC_RXD0    |
+| GPIO26 | RX1         | EMAC_RXD1    |
+| GPIO27 | CRS_DV      | EMAC_RX_DRV  |
+| GPIO0  | REF_CLK     | 50MHz clock  |
+
+- SMI (Serial Management Interface) wiring is not fixed and you can change it either in the configuration or using "eth_config" parameter with the following syntax:
+```
+model=lan8720,mdc=<gpio>,mdio=<gpio>[,rst=<gpio>]
+```
+Connecting a reset pin for the LAN8720 is optional but recommended to avoid that GPIO0 (50MHz input clock) locks the esp32 in download mode at boot time.
+- Clock
+	
+The APLL of the esp32 is required for the audio codec, so we **need** a LAN8720 that provides a 50MHz clock. That clock **must** be connected to GPIO0, there is no alternative. This means that if your DAC requires an MCLK, you need a recent build (later than mid-2023) to be able to select either GPIO 1 or 2.
+
+#### SPI (DM9051 or W5500)
+Ethernet over SPI is supported as well and requires less GPIOs but is obvsiously slower. SPI is the shared bus set with [spi_config](#spi). The "eth_config" parameter syntax becomes:
+```
+model=dm9051|w5500,cs=<gpio>,speed=<clk_in_Hz>,intr=<gpio>[,rst=<gpio>]
+```
+- To use the system SPI, shared with display (see spi_config) "host" must be set to -1. Any other value will reserve the SPI interface (careful of conflict with spi_config). The default "host" is 2 to avoid conflicting wiht default "spi_config" settings.
+- When not using system SPI, "mosi" for data out, "miso" for data in and "clk" **must** be set
+- The esp32 has a special I/O multiplexer for faster speed (up to 80 MHz) but that requires using specific GPIOs, which depends on SPI bus (See [here](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/spi_master.html) for more details)
+
+| Pin Name | SPI1 | SPI2 |
+| -------- | ---- | ---- |		
+| CS       |  15  |  5   |
+| SCLK	   |  14  |  18  |
+| MISO	   |  12  |  19  |
+| MOSI	   |  13  |  23  |
+	
 ### Battery / ADC
 The NVS parameter "bat_config" sets the ADC1 channel used to measure battery/DC voltage. The "atten" value attenuates the input voltage to the ADC input (the read value maintains a 0-1V rage) where: 0=no attenuation(0..800mV), 1=2.5dB attenuation(0..1.1V), 2=6dB attenuation(0..1.35V), 3=11dB attenuation(0..2.6V). Scale is a float ratio applied to every sample of the 12 bits ADC. A measure is taken every 10s and an average is made every 5 minutes (not a sliding window). Syntax is
 ```
-channel=0..7,scale=<scale>,cells=<2|3>,[atten=<0|1|2|3>]
+channel=0..7,scale=<scale>,cells=<1..3>[,atten=<0|1|2|3>]
 ```
-NB: Set parameter to empty to disable battery reading. For well-known configuration, this is ignored (except for SqueezeAMP where number of cells is required)
-# Configuration
+NB: Set parameter to empty to disable battery reading. For named configurations (SqueezeAMP, Muse ...), this is ignored (except for SqueezeAMP where number of cells is required)
+
+### Sleeping
+The esp32 can be put in deep sleep mode to save some power. How much really depends on the connected periperals, so best is to do your own measures. Waking-up from deep sleep is the equivalent of a reboot, but as the chip takes a few seconds to connect, it's still an efficient process.
+
+The esp32 can enter deep sleep after an audio inactivity timeout, after a button has been pressed, after a GPIO is set to a given level (there is a subtle difference, see below) or if the battery reaches a threashold. It wakes up only on some GPIO events. Note that *all* GPIO are isolated when sleeping (unless they are set with the `rtc`option) so you can not assume anything about their value, except that they will not drain current. The `rtc` option allows to keep some GPIO (from the RTC domain only) either pulled up or down. This can be useful if you want to keep some periperal active, for example a GPIO expander whose interrupt will be used to wake-up the system.
+
+The NVS parameter `sleep_config` is mostly used for setting sleep conditions
+```
+[delay=<mins>][,sleep=<gpio>[:0|1]][,wake=<gpio>[:0|1][|<gpio>[:0|1]...][,rtc=<gpio>[:0|1][|<gpio>[:0|1]...][,batt=<voltage>][,spurious=<mins>]
+```
+- delay: inactivity in **minutes** before going to sleep
+- spurious: when using IR, wake-up can be triggered by any activity on the allocated GPIO, hence other remotes may cause unwanted wake-up. This sets (in **minutes** - default is 1) an inactivity delay after which sleep resumes.
+- sleep: GPIO that will put the system into sleep and it can be a level 0 or 1.
+- wake: **list** of GPIOs that with cause it to wake up (reboot) with their respective values. In such list, GPIO's are separated by an actual '|'.
+- batt: threshold in **volts** under which the system will enter into sleep.
+
+The battery voltage is measured every 10 seconds and 30 values are averaged before producing a result. The result must be 3 times below the threshold to enter sleep, so it takes a total of 10\*30\*3 = 15 minutes.
+
+Be mindful that if the same GPIO is used to go to sleep and wakeup with the *same* level (in other word it's a transition/edge that triggers the action) the above will not work and the esp32 will immediately restart. In such case, you case use a button definition. The benefit of buttons is that not only can you re-use one actual button (e.g. 'stop') to make it the sleep trigger (using a long-press or a shift-press) but by selecting the ACTRLS_SLEEP action upon 'release', you can got to sleep upon release (1-0-1 transition) but also wake up upon another press (0 level applied on GPIO) because you only go to sleep *after* the GPIO returned to 1.
+
+Please see [buttons](#buttons) for detailed syntax.
+
+The option to use multiple GPIOs is very limited on esp32 and the esp-idf 4.3.x we are using: it is only possible to wake-up when **any** of the defined GPIO is set to 1. The fact that you can specify different levels in the wake list is irrelevant for now, it's just a provision for future upgrades to more recent versions of esp-idf.
+
+**Only the following GPIOs can be used to wake-up the esp32**
+- ESP32: 0, 2, 4, 12-15, 25-27, 32-39;
+- ESP32-S3: 0-21.
+
+Some have asked for a soft power on/off option. Although this is not built-in, it's easy to create yours as long as the regulator/power supply of the board can be controlled by Vcc or GND. Depending on how it is active, add a pull-up/down resistor to the regulator's control and connect it also to one GPIO of the esp32. Then using set_GPIO, set that GPIO to Vcc or GND. Use a hardware button that forces the regulator on with a pull- up/down and once the esp32 has booted, it will force the GPIO to the desired value maintaining the board on by software. To power it off by software, just use the deep sleep option which will suspend all GPIO hence switching off the regulator.
+
+# Software configuration
+
 ## Setup WiFi
 - Boot the esp, look for a new wifi access point showing up and connect to it. Default build ssid and passwords are "squeezelite"/"squeezelite". 
 - Once connected, navigate to 192.168.4.1 
@@ -381,7 +550,6 @@ NB: Set parameter to empty to disable battery reading. For well-known configurat
 - Once connection is established, note down the address the device received; this is the address you will use to configure it going forward 
 
 ## Setup squeezelite command line (optional)
-
 At this point, the device should have disabled its built-in access point and should be connected to a known WiFi network.
 - navigate to the address that was noted in step #1
 - Using the list of predefined options, choose the mode in which you want squeezelite to start
@@ -393,8 +561,16 @@ At this point, the device should have disabled its built-in access point and sho
 - The toggle switch should be set to 'ON' to ensure that squeezelite is active after booting (you might have to fiddle with it a few times)
 - You can enable accessto  NVS parameters under 'credits'
 
-## Monitor
+## Spotify
+By default, SqueezeESP32 will use ZeroConf to advertise its Spotify capabilties. This means that until at least one local Spotify Connect application controllers discovers and connects to it, SqueezeESP32 will not be registered to Spotify servers. As a consequence, Spotify's WebAPI will not be able to see it (for example, Home Assistant services will miss it). Once you are connected to it using for example Spotify Desktop app, it will be registered and displayed everywhere.
 
+If you want the player to be registered at start-up, you need to disable the ZeroConf option using the WebUI or `cspot_config::ZeroConf`. In that mode, the first time you run SqueezeESP32, it will be in ZeroConf mode and when you connect to it using a controller for the firt time, it receives and store credentials that will be used next time (after reboot). 
+
+Set ZeroConf to 1 will always force ZeroConf mode to be used. 
+
+The ZeroConf mode consumes less memory as it uses the built-in HTTP and mDNS servers to broadcast its capabilities. A Spotify controller will then discover these and trigger the SqueezeESP32 Spotify stack (cspot) to start. When the controller disconnects, the stack is shut down. In non-ZeroConf mode, the stack starts immediately (providing stored credentials are valid) and always run - a disconnect will not shut it down.
+
+## Monitor
 In addition of the esp-idf serial link monitor option, you can also enable a telnet server (see NVS parameters) where you'll have access to a ton of logs of what's happening inside the WROVER.
 
 ## Update Squeezelite
@@ -419,37 +595,67 @@ For example, so use a BT speaker named MySpeaker, accept audio up to 192kHz and
 	
 	squeezelite -o "BT -n 'BT <sinkname>'" -b 500:2000 -R -u m -Z 192000 -r "44100-44100"
 
-See squeezlite command line, but keys options are
+See squeezelite command line, but keys options are
 
 	- Z <rate> : tell LMS what is the max sample rate supported before LMS resamples
 	- R (see above)
 	- r "<minrate>-<maxrate>"
 	- C <sec> : set timeout to switch off amp gpio
 	- W : activate WAV and AIFF header parsing
+ 	- s <name>|-disable: connect to a specific server. Use -disable to not search for any server
+
+ **There is a safety feature to protect against WiFi/LMS connection loss that forces a reboot every few minutes when there is no LMS server detected. In case you don't want to use LMS at all, please set the server name to "-disable" on squeezelite command line ("-s -disable")**
+
 # Building everything yourself
+
 ## Setting up ESP-IDF
+
 ### Docker
-You can use docker to build squeezelite-esp32 (optional) 
-First you need to build the Docker container:
+A container-first workflow is recommended for this branch.
+
+This repository now provides:
+- a shared build image definition in `Dockerfile` (based on `espressif/idf:release-v5.5`)
+- a VS Code remote environment in `.devcontainer/devcontainer.json`
+
+#### VS Code Remote Dev Container (recommended)
+Open this repository in VS Code and run **Dev Containers: Reopen in Container**.  
+The container is connected to your current folder and uses the shared toolchain from `Dockerfile`.
+After opening, initialize submodules once:
+`git submodule update --init --recursive`
+
+#### Docker CLI
+Build the project image locally:
 ```
-docker build -t esp-idf .
+docker build -t squeezelite-esp32-dev:release-v5.5 .
 ```
-Then you need to run the container:
+Then run it interactively:
 ```
-docker run -i -t -v `pwd`:/workspace/squeezelite-esp32 esp-idf
+for windows:
+docker run --rm -v %cd%:/project -w /project -it squeezelite-esp32-dev:release-v5.5
+for linux:
+docker run --rm -v `pwd`:/project -w /project -it squeezelite-esp32-dev:release-v5.5
+```
+From inside the container:
+```
+. /opt/esp/idf/export.sh
+idf.py build
 ```
-The above command will mount this repo into the docker container and start a bash terminal
-for you to then follow the below build steps
 
 ### Manual Install of ESP-IDF
-You can install IDF manually on Linux or Windows (using the Subsystem for Linux) following the instructions at: https://www.instructables.com/id/ESP32-Development-on-Windows-Subsystem-for-Linux/ or see here https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/windows-setup.html for a direct install. 
+If you do not want containers, install ESP-IDF natively:
+1. Install ESP-IDF `release/v5.5`: https://github.com/espressif/esp-idf/tree/release/v5.5
+2. Run the standard ESP-IDF install/export steps for your OS.
+3. Install project Python tooling:
+   `python -m pip install pygit2 requests protobuf grpcio-tools`
+4. Install Node.js 16 and npm (used by `components/wifi-manager/webapp`).
+5. Initialize submodules:
+   `git submodule update --init --recursive`
 
-**Use the esp-idf 4.0 https://github.com/espressif/esp-idf/tree/release/v4.0 and a recent add esp-dsp (after 08/2020)**
-
-## Building Squeezelite-esp32
-When initially cloning the repo, make sure you do it recursively. For example: `git clone --recursive https://github.com/sle118/squeezelite-esp32.git`
+## Building SqueezeESP32
+When initially cloning the repo, make sure you do it recursively:
+`git clone --recursive https://github.com/sle118/squeezelite-esp32.git`
 	
-Don't forget to choose one of the config files in build_scripts/ and rename it sdkconfig.defaults or sdkconfig as many important WiFi/BT options are set there. **The codecs libraries will not be rebuilt by these scripts (it's a tedious process - see below)**
+Don't forget to choose one of the config files in `build-scripts/` and rename it `sdkconfig.defaults` or `sdkconfig` as many important WiFi/BT options are set there. **The codecs libraries will not be rebuilt by these scripts (it's a tedious process - see below)**
 
 Create and tweak your config using `idf.py menuconfig` then build binaries using `idf.py all`. It will build the recovery and the application (squeezelite). then use `idf.py flash` to write everything. Otherwise, if you just want to download squeezelite, do (assuming you have set ESPPORT (e.g. COM10) and ESPBAUD (e.g. 921600)
 ```
@@ -459,7 +665,9 @@ Use `idf.py monitor` to monitor the application (see esp-idf documentation)
 
 Note: You can use `idf.py build -DDEPTH=32` to build the 32 bits version and add the `-DVERSION=<your_version>` to add a custom version name (it will be 0.0-<your_version>). If you want to change the whole version string, see squeezelite.h. You can also disable the SBR extension of AAC codecs as it consumes a lot of CPU and might overload the esp32. Use `-DAAC_DISABLE_SBR=1` for that
 
-If you have already cloned the repository and you are getting compile errors on one of the submodules (e.g. telnet), run the following git command in the root of the repository location: `git submodule update --init --recursive`
+If you have already cloned the repository and you are getting compile errors on one of the submodules (e.g. telnet), run:
+`git submodule update --init --recursive`
+
 ### Rebuild codecs (highly recommended to NOT try that)
 - for codecs libraries, add -mlongcalls if you want to rebuild them, but you should not (use the provided ones in codecs/lib). if you really want to rebuild them, open an issue
 - libmad, libflac (no esp's version), libvorbis (tremor - not esp's version), alac work
@@ -475,8 +683,14 @@ If you have already cloned the repository and you are getting compile errors on
 	- per mad & few others, edit configure and change $ac_link to add -c (faking link)
 	- change ac_files to remove ''
 	- add DEPS_CFLAGS and DEPS_LIBS to avoid pkg-config to be required
-	- stack consumption can be very high with some codec variants, so set NONTHREADSAFE_PSEUDOSTACK and GLOBAL_STACK_SIZE=32000 and unset VAR_ARRAYS in config.h
+	- stack consumption can be very high with some codec variants, so set NONTHREADSAFE_PSEUDOSTACK and GLOBAL_STACK_SIZE=48000 and unset VAR_ARRAYS in config.h
 - libmad has been patched to avoid using a lot of stack and is not provided here. There is an issue with sync detection in 1.15.1b from where the original stack patch was done but since a few fixes have been made wrt sync detection. This 1.15.1b-10 found on debian fixes the issue where mad thinks it has reached sync but has not and so returns a wrong sample rate. It comes at the expense of 8KB (!) of code where a simple check in squeezelite/mad.c that next_frame[0] is 0xff and next_frame[1] & 0xf0 is 0xf0 does the trick ...
 
+# Hardware tips
+There is a possibility to have a software on/off where a temporary switch can power-up the esp32 which then will auto-sustain its power. Depending on the selected hardware, it a can also include a power-off by using a long press on the same button. 
+
+The auto-power is simply acheived by using `setGPIO` and forcing a GPIO to Vcc or GND and the sustain on/off requires a button creation whose longpress is an ACTRLS_SLEEP action (see also the [Sleeping](#sleeping) section). Credits [Renber78](http://github.com/Renber78) for schedmatics below
+
+![alt text](https://github.com/sle118/squeezelite-esp32/blob/7eb4b218e31aa4692c5280fbec4619f690032c4a/Soft%20Power.png)
+
 # Footnotes
-(1) SPDIF is made by tricking the I2S bus but this consumes a fair bit of CPU as it multiplies by four the throughput on the i2s bus. To optimize some computation, the parity of the spdif frames must always be 0, so at least one bit has to be available to force it. As SPDIF samples are 20+4 bits length maximum, the LSB is used for that purpose, so the bit 24 is randomly toggling. It does not matter for 16 bits samples but it has been chosen to truncate the last 4 bits for 24 bits samples. I'm sure that some smart dude can further optimize spdif_convert() and use the user bit instead. You're welcome to do a PR but, as said above, I (philippe44) am not interested by 24 bits mental illness :-) and I've already made an effort to provide 20 bits which already way more what's needed :-)

build-scripts/build_recovery_size.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+source /opt/esp/idf/export.sh >/dev/null 2>&1
+
+usage() {
+  cat <<'EOF'
+Usage:
+  build-scripts/build_recovery_size.sh <platform|defaults-file> [build-dir]
+
+Platform aliases:
+  i2s        -> build-scripts/I2S-4MFlash-sdkconfig.defaults
+  muse       -> build-scripts/Muse-sdkconfig.defaults
+  squeezeamp -> build-scripts/SqueezeAmp-sdkconfig.defaults
+
+Examples:
+  build-scripts/build_recovery_size.sh muse
+  build-scripts/build_recovery_size.sh i2s build-recovery-i2s
+  build-scripts/build_recovery_size.sh build-scripts/Muse-sdkconfig.defaults
+EOF
+}
+
+if [[ "${1:-}" == "" ]] || [[ "${1:-}" == "-h" ]] || [[ "${1:-}" == "--help" ]]; then
+  usage
+  exit 1
+fi
+
+PLATFORM_INPUT="$1"
+BUILD_DIR="${2:-}"
+
+case "${PLATFORM_INPUT,,}" in
+  i2s)
+    PLATFORM_DEFAULTS="build-scripts/I2S-4MFlash-sdkconfig.defaults"
+    ;;
+  muse)
+    PLATFORM_DEFAULTS="build-scripts/Muse-sdkconfig.defaults"
+    ;;
+  squeezeamp)
+    PLATFORM_DEFAULTS="build-scripts/SqueezeAmp-sdkconfig.defaults"
+    ;;
+  *)
+    PLATFORM_DEFAULTS="${PLATFORM_INPUT}"
+    ;;
+esac
+
+if [[ ! -f "${PLATFORM_DEFAULTS}" ]]; then
+  echo "Platform defaults file not found: ${PLATFORM_DEFAULTS}" >&2
+  usage
+  exit 2
+fi
+
+if [[ -z "${BUILD_DIR}" ]]; then
+  base="$(basename "${PLATFORM_DEFAULTS}")"
+  base="${base%-sdkconfig.defaults}"
+  BUILD_DIR="build-recovery-${base}"
+fi
+
+DEFAULTS="${PLATFORM_DEFAULTS};sdkconfig.recovery.defaults"
+echo "Using SDKCONFIG_DEFAULTS=${DEFAULTS}"
+echo "Build directory: ${BUILD_DIR}"
+
+# Build only the recovery ELF (skip squeezelite.elf target).
+idf.py -B "${BUILD_DIR}" -D SDKCONFIG_DEFAULTS="${DEFAULTS}" recovery.elf
+
+# Generate a standalone recovery.bin from the built ELF.
+python /opt/esp/idf/components/esptool_py/esptool/esptool.py \
+  --chip esp32 elf2image -o "${BUILD_DIR}/recovery.bin" "${BUILD_DIR}/recovery.elf" >/dev/null
+
+# Print recovery image size summary from map.
+python /opt/esp/idf/tools/idf_size.py "${BUILD_DIR}/recovery.map"
+
+# Print partition fit/overflow status for recovery.bin.
+python /opt/esp/idf/components/partition_table/check_sizes.py \
+  --offset 0x8000 partition --type app \
+  "${BUILD_DIR}/partition_table/partition-table.bin" \
+  "${BUILD_DIR}/recovery.bin" || true

build-scripts/lint_style.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+    cat <<'EOF'
+Usage: build-scripts/lint_style.sh [check|format]
+
+Commands:
+  check   Verify C/C++ style with clang-format (default)
+  format  Apply clang-format in place
+EOF
+}
+
+MODE="${1:-check}"
+if [[ "$MODE" != "check" && "$MODE" != "format" ]]; then
+    usage
+    exit 2
+fi
+
+if ! command -v clang-format >/dev/null 2>&1; then
+    echo "clang-format is required but was not found in PATH." >&2
+    exit 127
+fi
+
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+cd "$REPO_ROOT"
+
+declare -a PATHSPECS=(
+    "*.c"
+    "*.h"
+    "*.cc"
+    "*.cpp"
+    "*.hpp"
+    ":(exclude)build/**"
+    ":(exclude)managed_components/**"
+    ":(exclude)components/codecs/inc/**"
+    ":(exclude)components/esp-dsp/**"
+    ":(exclude)components/esp_http_server/**"
+    ":(exclude)components/spotify/cspot/**"
+    ":(exclude)components/squeezelite/**"
+    ":(exclude)components/telnet/libtelnet/**"
+    ":(exclude)components/tjpgd/**"
+    ":(exclude)components/wifi-manager/webapp/dist/**"
+    ":(exclude)components/wifi-manager/webapp/src/js/proto/**"
+)
+
+mapfile -t FILES < <(git ls-files -- "${PATHSPECS[@]}" | grep -E '^(components|main|test)/.*\.(c|h|cc|cpp|hpp)$' || true)
+
+if [[ ${#FILES[@]} -eq 0 ]]; then
+    echo "No C/C++ files matched lint scope."
+    exit 0
+fi
+
+if [[ "$MODE" == "format" ]]; then
+    printf '%s\0' "${FILES[@]}" | xargs -0 -r clang-format -i
+    echo "Formatted ${#FILES[@]} file(s)."
+    exit 0
+fi
+
+declare -a FAILING=()
+for file in "${FILES[@]}"; do
+    if ! clang-format --dry-run --Werror "$file" >/dev/null 2>&1; then
+        FAILING+=("$file")
+    fi
+done
+
+if [[ ${#FAILING[@]} -gt 0 ]]; then
+    echo "Style check failed in ${#FAILING[@]} file(s)."
+    echo "First failing files:"
+    printf '  - %s\n' "${FAILING[@]:0:30}"
+    echo "Run: build-scripts/lint_style.sh format"
+    exit 1
+fi
+
+echo "Style check passed for ${#FILES[@]} file(s)."

build-scripts/lxd_remote.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ENV_FILE="${LXD_ENV_FILE:-.lxd.env}"
+if [[ -f "$ENV_FILE" ]]; then
+  # shellcheck disable=SC1090
+  source "$ENV_FILE"
+fi
+
+: "${LXD_HOST:?Missing LXD_HOST (set in .lxd.env or environment)}"
+: "${LXD_SSH_USER:?Missing LXD_SSH_USER (set in .lxd.env or environment)}"
+
+LXD_SSH_PORT="${LXD_SSH_PORT:-22}"
+LXD_SSH_AUTH="${LXD_SSH_AUTH:-key}"
+LXD_SSH_PRIVATE_KEY_PATH="${LXD_SSH_PRIVATE_KEY_PATH:-}"
+LXD_WORKDIR="${LXD_WORKDIR:-}"
+
+expand_home() {
+  local p="$1"
+  if [[ "$p" == ~* ]]; then
+    printf '%s\n' "${HOME}${p:1}"
+  else
+    printf '%s\n' "$p"
+  fi
+}
+
+ssh_opts=(
+  -p "$LXD_SSH_PORT"
+  -o BatchMode=yes
+  -o ConnectTimeout=10
+  -o StrictHostKeyChecking=accept-new
+)
+
+if [[ "$LXD_SSH_AUTH" == "key" ]]; then
+  : "${LXD_SSH_PRIVATE_KEY_PATH:?Missing LXD_SSH_PRIVATE_KEY_PATH for key auth}"
+  key_path="$(expand_home "$LXD_SSH_PRIVATE_KEY_PATH")"
+  ssh_opts+=( -i "$key_path" )
+fi
+
+if [[ "${1:-}" == "heartbeat" ]]; then
+  shift
+  cmd='hostname && whoami && uptime && df -h /'
+else
+  if [[ "$#" -eq 0 ]]; then
+    cat <<'USAGE' >&2
+Usage:
+  build-scripts/lxd_remote.sh heartbeat
+  build-scripts/lxd_remote.sh <remote command...>
+
+Environment source: .lxd.env by default (override with LXD_ENV_FILE)
+USAGE
+    exit 2
+  fi
+
+  cmd="$*"
+fi
+
+if [[ -n "$LXD_WORKDIR" ]]; then
+  remote_cmd="cd $LXD_WORKDIR && ( $cmd )"
+else
+  remote_cmd="$cmd"
+fi
+
+exec ssh "${ssh_opts[@]}" "${LXD_SSH_USER}@${LXD_HOST}" "$remote_cmd"

build-scripts/ui_footprint_snapshot.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(git rev-parse --show-toplevel)"
+DIST_DIR="$ROOT/components/wifi-manager/webapp/dist"
+
+if [[ ! -d "$DIST_DIR" ]]; then
+    echo "dist directory not found: $DIST_DIR" >&2
+    echo "Build webapp first (e.g. npm run build in components/wifi-manager/webapp)." >&2
+    exit 1
+fi
+
+python - "$DIST_DIR" <<'PY'
+import os
+import sys
+import glob
+from datetime import datetime, timezone
+
+dist = sys.argv[1]
+
+def rel(p):
+    return os.path.relpath(p, start=os.getcwd())
+
+all_files = [p for p in glob.glob(os.path.join(dist, "**", "*"), recursive=True) if os.path.isfile(p)]
+ship_files = [p for p in all_files if p.endswith(".gz") or p.endswith(".png")]
+
+all_files_sorted = sorted([(os.path.getsize(p), p) for p in all_files], reverse=True)
+ship_sorted = sorted([(os.path.getsize(p), p) for p in ship_files], reverse=True)
+
+print(f"Snapshot UTC: {datetime.now(timezone.utc).isoformat(timespec='seconds')}")
+print(f"Dist dir: {rel(dist)}")
+print("")
+print(f"All dist files: {len(all_files)}")
+print(f"All dist bytes: {sum(s for s, _ in all_files_sorted)}")
+print(f"Shipped files (*.gz + *.png): {len(ship_sorted)}")
+print(f"Shipped bytes: {sum(s for s, _ in ship_sorted)}")
+print("")
+print("Top 15 dist files:")
+for size, path in all_files_sorted[:15]:
+    print(f"{size:9d}  {rel(path)}")
+print("")
+print("Shipped files:")
+for size, path in ship_sorted:
+    print(f"{size:9d}  {rel(path)}")
+PY

build_flash_cmd.sh

@@ -1,113 +0,0 @@
-#!/bin/bash
-echo 
-echo =================================================================
-echo Build flash command
-echo =================================================================
-# Location of partitions.csv relative to this script
-partitionsCsv="../partitions.csv"
-
-# File to output readme instructions to
-outputReadme="./flash_cmd.txt"
-
-# File to output bash script to
-outputBashScript="./writeSequeezeEsp.sh"
-
-# File to output bat script to
-outputBatScript="./writeSequeezeEsp.bat"
-
-# The name of partitions to ignore from partitions.csv
-paritionsToIgnore=(
-  "nvs"
-  "phy_init"
-  "storage"
-  "coredump"
-  "settings"
-)
-
-# Function that maps partition name to actual bin file
-# defaults to "[PARTION_NAME_FROM_CSV].bin"
-function partitionNameToBinFile {
-  if [[ "$1" == "otadata" ]]; then
-    echo "ota_data_initial.bin"
-  elif [[ "$1" == "ota_0" || "$1" == "factory" ]]; then
-    echo "squeezelite.bin"
-  else
-    echo $1.bin
-  fi
-}
-
-# write parameters for esptool.py
-writeParameters="$writeParameters write_flash"
-writeParameters="$writeParameters --flash_mode dio --flash_freq 80m --flash_size detect"
-
-# bootloader.bin and partitions.bin not in partitions.csv so manually add here
-partitionsParameters=" 0x1000 bootloader/bootloader.bin"
-partitionsParameters="$partitionsParameters 0x8000 partitions.bin"
-
-# ==============================================================================
-
-# Loop over partitions.csv and add partition bins and offsets to partitionsParameters
-
-for line in $($IDF_PATH/components/partition_table/gen_esp32part.py --quiet build/partitions.bin | grep '^[^#]')
-do
-  partitionName=$(echo $line | awk -F',' '{printf "%s", $1}' )
-  partitionOffset=$(echo $line |awk -F',' '{printf "%s", $4}' )
-  partitionFile=$(partitionNameToBinFile $partitionName)
-	
-  if [[ " ${paritionsToIgnore[@]} " =~ " ${partitionName} " ]]; then
-	continue
-  fi
-
-  partitionsParameters="$partitionsParameters $partitionOffset $partitionFile"
-  echo "$partitionsParameters"
-  
-done
-
-# Write README Instructions
-if [ ! -f "$outputReadme" ]; then
-  touch $outputReadme
-fi
-
-echo "" >> $outputReadme
-echo "====LINUX====" >> $outputReadme
-echo "To flash sequeezelite run the following script:" >> $outputReadme
-echo "$outputBashScript [PORT_HERE] [BAUD_RATE]" >> $outputReadme
-echo "e.g. $outputBashScript /dev/ttyUSB0 115200" >> $outputReadme
-echo "" >> $outputReadme
-echo "====WINDOWS====" >> $outputReadme
-echo "To flash sequeezelite run the following script:" >> $outputReadme
-echo "$outputBatScript [PORT_HERE] [BAUD_RATE]" >> $outputReadme
-echo "e.g. $outputBatScript COM11 115200" >> $outputReadme
-echo "" >> $outputReadme
-echo "If you don't know how to run the BAT file with arguments then you can" >> $outputReadme
-echo "edit the bat file in Notepad. Open the file up and edit the following:" >> $outputReadme
-echo "Change 'set port=%1' to 'set port=[PORT_HERE]'. E.g. 'set port=COM11'" >> $outputReadme
-echo "Change 'set baud=%2' to 'set baud=[BAUD_RATE]'. E.g. 'set baud=115200'" >> $outputReadme
-echo "" >> $outputReadme
-echo "====MANUAL====" >> $outputReadme
-echo "Python esptool.py --port [PORT_HERE] --baud [BAUD_RATE] $writeParameters $partitionsParameters" >> $outputReadme
-
-# Write Linux BASH File
-if [ ! -f "$outputBashScript" ]; then
-  touch $outputBashScript
-fi
-
-echo "#!/bin/bash" >> $outputBashScript
-echo >> $outputBashScript
-echo "port=\$1" >> $outputBashScript
-echo "baud=\$2" >> $outputBashScript
-linuxFlashCommand="Python esptool.py --port \$port --baud \$baud"
-echo "$linuxFlashCommand $writeParameters $partitionsParameters" >> $outputBashScript
-
-# Write Windows BAT File
-if [ ! -f "$outputBatScript" ]; then
-  touch $outputBatScript
-fi
-
-echo "echo off" >> $outputBatScript
-echo "" >> $outputBatScript
-echo "set port=%1" >> $outputBatScript
-echo "set baud=%2" >> $outputBatScript
-windowsFlashCommand="Python esptool.py --port %port% --baud %baud%"
-echo "$windowsFlashCommand $writeParameters $partitionsParameters" >> $outputBatScript
-

components/_override/CMakeLists.txt

@@ -0,0 +1,24 @@
+if(IDF_TARGET STREQUAL esp32 AND IDF_VERSION_MAJOR EQUAL 4 AND IDF_VERSION_MINOR LESS 4)
+    set(lib_dir ${build_dir}/esp-idf)
+    set(driver esp32/i2s.c)
+    string(REPLACE ".c" ".c.obj" driver_obj "${driver}")
+
+    idf_component_register( SRCS ${driver}
+                        REQUIRES driver           
+                        INCLUDE_DIRS ${IDF_PATH}/components/driver
+                        PRIV_INCLUDE_DIRS ${IDF_PATH}/components/driver/include/driver
+    )
+
+    # CMake is just a pile of crap
+    message(STATUS "!! overriding ${driver} !!")
+    message(STATUS "CAREFUL, LIBRARIES STRIPPING FROM DUPLICATED COMPONENTS DEPENDS ON THIS BEING REBUILD")
+
+    add_custom_command(
+                TARGET ${COMPONENT_LIB}
+                PRE_LINK
+                COMMAND xtensa-esp32-elf-ar -d ${lib_dir}/driver/libdriver.a ${driver_obj}
+                VERBATIM
+    )
+else()
+    message(STATUS "==> NO OVERRIDE <==")
+endif()

components/audio/inc/esp_equalizer.h

@@ -5,8 +5,7 @@
 #define _ESP_EQUALIZER_H
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /**
@@ -19,14 +18,14 @@ extern "C"
 *
 * @return     The equalizer handle.
 */
-void *esp_equalizer_init(int nch, int g_rate, int n_band, int use_xmms_original_freqs);
+void* esp_equalizer_init(int nch, int g_rate, int n_band, int use_xmms_original_freqs);
 
 /**
 * @brief     Uninitialize the equalizer handle.
 *
 * @param      handle   The the equalizer handle
 */
-void esp_equalizer_uninit(void *handle);
+void esp_equalizer_uninit(void* handle);
 
 /**
 * @brief      Process the data through the equalizer
@@ -39,7 +38,7 @@ void esp_equalizer_uninit(void *handle);
 *
 * @return     Length of pcm_buf after processing
 */
-int esp_equalizer_process(void *handle, unsigned char *pcm_buf, int length, int g_rate, int nch);
+int esp_equalizer_process(void* handle, unsigned char* pcm_buf, int length, int g_rate, int nch);
 
 /**
 * @brief      Set the number of sub-bands for the equalizer
@@ -49,7 +48,7 @@ int esp_equalizer_process(void *handle, unsigned char *pcm_buf, int length, int
 * @param      index   The index of audio sub-bands. e.g. 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.
 * @param      nch     The audio channel number
 */
-void esp_equalizer_set_band_value(void *handle, float value, int index, int nch);
+void esp_equalizer_set_band_value(void* handle, float value, int index, int nch);
 
 /**
 * @brief      Get the number of the equalizer sub-bands
@@ -58,7 +57,7 @@ void esp_equalizer_set_band_value(void *handle, float value, int index, int nch)
 *
 * @return     The number of the equalizer sub-bands
 */
-int esp_equalizer_get_band_count(void *handle);
+int esp_equalizer_get_band_count(void* handle);
 
 /**
 * @brief      Get the value of the equalizer sub-bands
@@ -69,7 +68,7 @@ int esp_equalizer_get_band_count(void *handle);
 *
 * @return     The number of the equalizer sub-bands
 */
-float esp_equalizer_get_band_value(void *handle, int index, int nch);
+float esp_equalizer_get_band_value(void* handle, int index, int nch);
 
 #ifdef __cplusplus
 }

components/audio/link_helper.c

@@ -1,3 +1 @@
-void dummy_obj() {
-	return;
-}
+void dummy_obj() { return; }

components/codecs/CMakeLists.txt

@@ -1,5 +1,5 @@
 idf_component_register(
-	   INCLUDE_DIRS .  ./inc  inc/alac inc/FLAC  inc/helix-aac inc/mad inc/ogg inc/opus inc/opusfile inc/resample16 inc/soxr inc/vorbis
+	   INCLUDE_DIRS . ./inc inc/alac inc/helix-aac inc/mad inc/resample16 inc/soxr inc/vorbis inc/opus
 )
 
 if (DEFINED AAC_DISABLE_SBR)
@@ -14,7 +14,6 @@ add_prebuilt_library(libvorbisidec 	lib/libvorbisidec.a )
 add_prebuilt_library(libogg 		lib/libogg.a )
 add_prebuilt_library(libalac 		lib/libalac.a ) 
 add_prebuilt_library(libresample16 	lib/libresample16.a ) 
-add_prebuilt_library(libopusfile 	lib/libopusfile.a ) 
 add_prebuilt_library(libopus 		lib/libopus.a ) 
 
 target_link_libraries(${COMPONENT_LIB} INTERFACE libmad)
@@ -24,5 +23,4 @@ target_link_libraries(${COMPONENT_LIB} INTERFACE libvorbisidec)
 target_link_libraries(${COMPONENT_LIB} INTERFACE libogg)
 target_link_libraries(${COMPONENT_LIB} INTERFACE libalac)
 target_link_libraries(${COMPONENT_LIB} INTERFACE libresample16)
-target_link_libraries(${COMPONENT_LIB} INTERFACE libopusfile)
 target_link_libraries(${COMPONENT_LIB} INTERFACE libopus)

components/codecs/inc/FLAC/all.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -35,8 +35,8 @@
 
 #include "export.h"
 
+#include "assert.h"
 #include "callback.h"
-#include "flac_assert.h"
 #include "format.h"
 #include "metadata.h"
 #include "ordinals.h"
@@ -52,7 +52,7 @@
  * level idea of the structure and how to find the information you
  * need.  As a prerequisite you should have at least a basic
  * knowledge of the FLAC format, documented
- * <A HREF="../format.html">here</A>.
+ * <A HREF="https://xiph.org/flac/format.html">here</A>.
  *
  * \section c_api FLAC C API
  *
@@ -64,7 +64,7 @@
  *
  * By writing a little code and linking against libFLAC, it is
  * relatively easy to add FLAC support to another program.  The
- * library is licensed under <A HREF="../license.html">Xiph's BSD license</A>.
+ * library is licensed under <A HREF="https://xiph.org/flac/license.html">Xiph's BSD license</A>.
  * Complete source code of libFLAC as well as the command-line
  * encoder and plugins is available and is a useful source of
  * examples.
@@ -97,7 +97,7 @@
  * example /usr/include/FLAC++/...).
  *
  * libFLAC++ is also licensed under
- * <A HREF="../license.html">Xiph's BSD license</A>.
+ * <A HREF="https://xiph.org/flac/license.html">Xiph's BSD license</A>.
  *
  * \section getting_started Getting Started
  *
@@ -113,7 +113,7 @@
  * functions through the links in top bar across this page.
  *
  * If you prefer a more hands-on approach, you can jump right to some
- * <A HREF="../documentation_example_code.html">example code</A>.
+ * <A HREF="https://xiph.org/flac/documentation_example_code.html">example code</A>.
  *
  * \section porting_guide Porting Guide
  *
@@ -147,7 +147,7 @@
  * library.
  *
  * Also, there are several places in the libFLAC code with comments marked
- * with "OPT:" where a #define can be changed to enable code that might be
+ * with "OPT:" where a \#define can be changed to enable code that might be
  * faster on a specific platform.  Experimenting with these can yield faster
  * binaries.
  */
@@ -159,9 +159,9 @@
  * the libraries to newer versions of FLAC.
  *
  * One simple facility for making porting easier that has been added
- * in FLAC 1.1.3 is a set of \c #defines in \c export.h of each
+ * in FLAC 1.1.3 is a set of \#defines in \c export.h of each
  * library's includes (e.g. \c include/FLAC/export.h).  The
- * \c #defines mirror the libraries'
+ * \#defines mirror the libraries'
  * <A HREF="http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning">libtool version numbers</A>,
  * e.g. in libFLAC there are \c FLAC_API_VERSION_CURRENT,
  * \c FLAC_API_VERSION_REVISION, and \c FLAC_API_VERSION_AGE.
@@ -176,7 +176,7 @@
  * #endif
  * \endcode
  *
- * The the source will work for multiple versions and the legacy code can
+ * The source will work for multiple versions and the legacy code can
  * easily be removed when the transition is complete.
  *
  * Another available symbol is FLAC_API_SUPPORTS_OGG_FLAC (defined in
@@ -321,7 +321,7 @@
  *
  * The \a bytes parameter to FLAC__StreamDecoderReadCallback,
  * FLAC__StreamEncoderReadCallback, and FLAC__StreamEncoderWriteCallback
- * is now \c size_t instead of \c unsigned.
+ * is now \c size_t instead of \c uint32_t.
  */
 
 /** \defgroup porting_1_1_3_to_1_1_4 Porting from FLAC 1.1.3 to 1.1.4
@@ -357,6 +357,85 @@
  * \c FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN
  */
 
+/** \defgroup porting_1_3_4_to_1_4_0 Porting from FLAC 1.3.4 to 1.4.0
+ *  \ingroup porting
+ *
+ *  \brief
+ *  This module describes porting from FLAC 1.3.4 to FLAC 1.4.0.
+ *
+ * \section porting_1_3_4_to_1_4_0_summary Summary
+ *
+ * Between FLAC 1.3.4 and FLAC 1.4.0, there have four breaking changes
+ * - the function get_client_data_from_decoder has been renamed to
+ *   FLAC__get_decoder_client_data
+ * - some data types in the FLAC__Frame struct have changed
+ * - all functions resizing metadata blocks now return the object
+ *   untouched if memory allocation fails, whereas previously the
+ *   handling varied and was more or less undefined
+ * - all functions accepting a filename now take UTF-8 encoded filenames
+ *   on Windows instead of filenames in the current codepage
+ *
+ * Furthermore, there have been the following additions
+ * - the functions FLAC__stream_encoder_set_limit_min_bitrate,
+ *   FLAC__stream_encoder_get_limit_min_bitrate,
+ *   FLAC::encoder::file::set_limit_min_bitrate() and
+ *   FLAC::encoder::file::get_limit_min_bitrate() have been added
+ * - Added FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA to the
+ *   FLAC__StreamDecoderErrorStatus enum
+ *
+ * \section porting_1_3_4_to_1_4_0_breaking Breaking changes
+ *
+ * The function \b get_client_data_from_decoder was added in FLAC 1.3.3
+ * but did not follow the API naming convention and was not properly
+ * exported. The function is now renamed and properly integrated as
+ * FLAC__stream_decoder_get_client_data
+ *
+ * To accomodate encoding and decoding 32-bit int PCM, some data types
+ * in the \b FLAC__frame struct were changed. Specifically, warmup
+ * in both the FLAC__Subframe_Fixed struc and the FLAC__Subframe_LPC
+ * struct is changed from FLAC__int32 to FLAC__int64. Also, value
+ * in the FLAC__Subframe_Constant is changed from FLAC__int32 to
+ * FLAC__int64. Finally, in FLAC__Subframe_Verbatim struct data is
+ * changes from a FLAC__int32 array to a union containing a FLAC__int32
+ * array and a FLAC__int64 array. Also, a new member is added,
+ * data_type, which clarifies whether the FLAC__int32 or FLAC__int64
+ * array is in use.
+ *
+ * Furthermore, the following functions now return the object untouched
+ * if memory allocation fails, whereas previously the handling varied
+ * and was more or less undefined
+ *
+ * - FLAC__metadata_object_seektable_resize_points
+ * - FLAC__metadata_object_vorbiscomment_resize_comments
+ * - FLAC__metadata_object_cuesheet_track_resize_indices
+ * - FLAC__metadata_object_cuesheet_resize_tracks
+ *
+ * The last breaking change is that all API functions taking a filename
+ * as an argument now, on Windows, must be supplied with that filename
+ * in the UTF-8 character encoding instead of using the current code
+ * page. libFLAC internally translates these UTF-8 encoded filenames to
+ * an appropriate representation to use with _wfopen. On all other
+ * systems, filename is passed to fopen without any translation, as it
+ * in libFLAC 1.3.4 and earlier.
+ *
+ * \section porting_1_3_4_to_1_4_0_additions Additions
+ *
+ * To aid in creating properly streamable FLAC files, a set of functions
+ * was added to make it possible to enfore a minimum bitrate to files
+ * created through libFLAC's stream_encoder.h interface. With this
+ * function enabled the resulting FLAC files have a minimum bitrate of
+ * 1bit/sample independent of the number of channels, i.e. 48kbit/s for
+ * 48kHz. This can be beneficial for streaming, as very low bitrates for
+ * silent sections compressed with 'constant' subframes can result in a
+ * bitrate of 1kbit/s, creating problems with clients that aren't aware
+ * of this possibility and buffer too much data.
+ *
+ * Finally, FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA was added to
+ * the FLAC__StreamDecoderErrorStatus enum to signal that the decoder
+ * encountered unreadable metadata.
+ *
+ */
+
 /** \defgroup flac FLAC C API
  *
  * The FLAC C API is the interface to libFLAC, a set of structures

components/codecs/inc/FLAC/assert.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2001-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -34,7 +34,11 @@
 #define FLAC__ASSERT_H
 
 /* we need this since some compilers (like MSVC) leave assert()s on release code (and we don't want to use their ASSERT) */
-#ifdef DEBUG
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+#define FLAC__ASSERT(x) if(!(x)) __builtin_abort();
+#define FLAC__ASSERT_DECLARATION(x) x
+#else
+#ifndef NDEBUG
 #include <assert.h>
 #define FLAC__ASSERT(x) assert(x)
 #define FLAC__ASSERT_DECLARATION(x) x
@@ -42,5 +46,6 @@
 #define FLAC__ASSERT(x)
 #define FLAC__ASSERT_DECLARATION(x)
 #endif
+#endif
 
 #endif

components/codecs/inc/FLAC/callback.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2004-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -165,15 +165,15 @@ typedef int (*FLAC__IOCallback_Close) (FLAC__IOHandle handle);
  *  required may be set to NULL.
  *
  *  If the seek requirement for an interface is optional, you can signify that
- *  a data sorce is not seekable by setting the \a seek field to \c NULL.
+ *  a data source is not seekable by setting the \a seek field to \c NULL.
  */
 typedef struct {
-	FLAC__IOCallback_Read read;
-	FLAC__IOCallback_Write write;
-	FLAC__IOCallback_Seek seek;
-	FLAC__IOCallback_Tell tell;
-	FLAC__IOCallback_Eof eof;
-	FLAC__IOCallback_Close close;
+	FLAC__IOCallback_Read read;   /**< See FLAC__IOCallbacks */
+	FLAC__IOCallback_Write write; /**< See FLAC__IOCallbacks */
+	FLAC__IOCallback_Seek seek;   /**< See FLAC__IOCallbacks */
+	FLAC__IOCallback_Tell tell;   /**< See FLAC__IOCallbacks */
+	FLAC__IOCallback_Eof eof;     /**< See FLAC__IOCallbacks */
+	FLAC__IOCallback_Close close; /**< See FLAC__IOCallbacks */
 } FLAC__IOCallbacks;
 
 /* \} */

components/codecs/inc/FLAC/export.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -36,7 +36,7 @@
 /** \file include/FLAC/export.h
  *
  *  \brief
- *  This module contains #defines and symbols for exporting function
+ *  This module contains \#defines and symbols for exporting function
  *  calls, and providing version information and compiled-in features.
  *
  *  See the \link flac_export export \endlink module.
@@ -46,25 +46,43 @@
  *  \ingroup flac
  *
  *  \brief
- *  This module contains #defines and symbols for exporting function
+ *  This module contains \#defines and symbols for exporting function
  *  calls, and providing version information and compiled-in features.
  *
- *  If you are compiling with MSVC and will link to the static library
- *  (libFLAC.lib) you should define FLAC__NO_DLL in your project to
- *  make sure the symbols are exported properly.
+ *  If you are compiling for Windows (with Visual Studio or MinGW for
+ *  example) and will link to the static library (libFLAC++.lib) you
+ *  should define FLAC__NO_DLL in your project to make sure the symbols
+ *  are exported properly.
  *
  * \{
  */
 
-#if defined(FLAC__NO_DLL)
-#define FLAC_API
+/** This \#define is used internally in libFLAC and its headers to make
+ * sure the correct symbols are exported when working with shared
+ * libraries. On Windows, this \#define is set to __declspec(dllexport)
+ * when compiling libFLAC into a library and to __declspec(dllimport)
+ * when the headers are used to link to that DLL. On non-Windows systems
+ * it is used to set symbol visibility.
+ *
+ * Because of this, the define FLAC__NO_DLL must be defined when linking
+ * to libFLAC statically or linking will fail.
+ */
+/* This has grown quite complicated. FLAC__NO_DLL is used by MSVC sln
+ * files and CMake, which build either static or shared. autotools can
+ * build static, shared or **both**. Therefore, DLL_EXPORT, which is set
+ * by libtool, must override FLAC__NO_DLL on building shared components
+ */
+#if defined(_WIN32)
 
-#elif defined(_MSC_VER)
+#if defined(FLAC__NO_DLL) && !(defined(DLL_EXPORT))
+#define FLAC_API
+#else
 #ifdef FLAC_API_EXPORTS
 #define	FLAC_API __declspec(dllexport)
 #else
 #define FLAC_API __declspec(dllimport)
 #endif
+#endif
 
 #elif defined(FLAC__USE_VISIBILITY_ATTR)
 #define FLAC_API __attribute__ ((visibility ("default")))
@@ -74,12 +92,12 @@
 
 #endif
 
-/** These #defines will mirror the libtool-based library version number, see
+/** These \#defines will mirror the libtool-based library version number, see
  * http://www.gnu.org/software/libtool/manual/libtool.html#Libtool-versioning
  */
-#define FLAC_API_VERSION_CURRENT 11
+#define FLAC_API_VERSION_CURRENT 12
 #define FLAC_API_VERSION_REVISION 0 /**< see above */
-#define FLAC_API_VERSION_AGE 3 /**< see above */
+#define FLAC_API_VERSION_AGE 0 /**< see above */
 
 #ifdef __cplusplus
 extern "C" {

components/codecs/inc/FLAC/format.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -60,7 +60,7 @@ extern "C" {
  *  structures used by the rest of the interfaces.
  *
  *  First, you should be familiar with the
- *  <A HREF="../format.html">FLAC format</A>.  Many of the values here
+ *  <A HREF="https://xiph.org/flac/format.html">FLAC format</A>.  Many of the values here
  *  follow directly from the specification.  As a user of libFLAC, the
  *  interesting parts really are the structures that describe the frame
  *  header and metadata blocks.
@@ -113,19 +113,16 @@ extern "C" {
 
 /** The maximum sample resolution permitted by libFLAC.
  *
- * \warning
  * FLAC__MAX_BITS_PER_SAMPLE is the limit of the FLAC format.  However,
- * the reference encoder/decoder is currently limited to 24 bits because
- * of prevalent 32-bit math, so make sure and use this value when
- * appropriate.
+ * the reference encoder/decoder used to be limited to 24 bits. This
+ * value was used to signal that limit.
  */
-#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (24u)
+#define FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE (32u)
 
 /** The maximum sample rate permitted by the format.  The value is
- *  ((2 ^ 16) - 1) * 10; see <A HREF="../format.html">FLAC format</A>
- *  as to why.
+ *  ((2 ^ 20) - 1)
  */
-#define FLAC__MAX_SAMPLE_RATE (655350u)
+#define FLAC__MAX_SAMPLE_RATE (1048575u)
 
 /** The maximum LPC order permitted by the format. */
 #define FLAC__MAX_LPC_ORDER (32u)
@@ -173,10 +170,10 @@ extern FLAC_API const FLAC__byte FLAC__STREAM_SYNC_STRING[4]; /* = "fLaC" */
 /** The 32-bit integer big-endian representation of the beginning of
  *  a FLAC stream.
  */
-extern FLAC_API const unsigned FLAC__STREAM_SYNC; /* = 0x664C6143 */
+extern FLAC_API const uint32_t FLAC__STREAM_SYNC; /* = 0x664C6143 */
 
 /** The length of the FLAC signature in bits. */
-extern FLAC_API const unsigned FLAC__STREAM_SYNC_LEN; /* = 32 bits */
+extern FLAC_API const uint32_t FLAC__STREAM_SYNC_LEN; /* = 32 bits */
 
 /** The length of the FLAC signature in bytes. */
 #define FLAC__STREAM_SYNC_LENGTH (4u)
@@ -213,26 +210,26 @@ extern FLAC_API const char * const FLAC__EntropyCodingMethodTypeString[];
  */
 typedef struct {
 
-	unsigned *parameters;
+	uint32_t *parameters;
 	/**< The Rice parameters for each context. */
 
-	unsigned *raw_bits;
+	uint32_t *raw_bits;
 	/**< Widths for escape-coded partitions.  Will be non-zero for escaped
 	 * partitions and zero for unescaped partitions.
 	 */
 
-	unsigned capacity_by_order;
+	uint32_t capacity_by_order;
 	/**< The capacity of the \a parameters and \a raw_bits arrays
 	 * specified as an order, i.e. the number of array elements
 	 * allocated is 2 ^ \a capacity_by_order.
 	 */
 } FLAC__EntropyCodingMethod_PartitionedRiceContents;
 
-/** Header for a Rice partitioned residual.  (c.f. <A HREF="../format.html#partitioned_rice">format specification</A>)
+/** Header for a Rice partitioned residual.  (c.f. <A HREF="https://xiph.org/flac/format.html#partitioned_rice">format specification</A>)
  */
 typedef struct {
 
-	unsigned order;
+	uint32_t order;
 	/**< The partition order, i.e. # of contexts = 2 ^ \a order. */
 
 	const FLAC__EntropyCodingMethod_PartitionedRiceContents *contents;
@@ -240,17 +237,17 @@ typedef struct {
 
 } FLAC__EntropyCodingMethod_PartitionedRice;
 
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN; /**< == 5 (bits) */
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN; /**< == 5 (bits) */
 
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER;
 /**< == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN)-1 */
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER;
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_ESCAPE_PARAMETER;
 /**< == (1<<FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN)-1 */
 
-/** Header for the entropy coding method.  (c.f. <A HREF="../format.html#residual">format specification</A>)
+/** Header for the entropy coding method.  (c.f. <A HREF="https://xiph.org/flac/format.html#residual">format specification</A>)
  */
 typedef struct {
 	FLAC__EntropyCodingMethodType type;
@@ -259,7 +256,7 @@ typedef struct {
 	} data;
 } FLAC__EntropyCodingMethod;
 
-extern FLAC_API const unsigned FLAC__ENTROPY_CODING_METHOD_TYPE_LEN; /**< == 2 (bits) */
+extern FLAC_API const uint32_t FLAC__ENTROPY_CODING_METHOD_TYPE_LEN; /**< == 2 (bits) */
 
 /*****************************************************************************/
 
@@ -279,30 +276,40 @@ typedef enum {
 extern FLAC_API const char * const FLAC__SubframeTypeString[];
 
 
-/** CONSTANT subframe.  (c.f. <A HREF="../format.html#subframe_constant">format specification</A>)
+/** CONSTANT subframe.  (c.f. <A HREF="https://xiph.org/flac/format.html#subframe_constant">format specification</A>)
  */
 typedef struct {
-	FLAC__int32 value; /**< The constant signal value. */
+	FLAC__int64 value; /**< The constant signal value. */
 } FLAC__Subframe_Constant;
 
+/** An enumeration of the possible verbatim subframe data types. */
+typedef enum {
+	FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT32, /**< verbatim subframe has 32-bit int */
+	FLAC__VERBATIM_SUBFRAME_DATA_TYPE_INT64 /**< verbatim subframe has 64-bit int */
+} FLAC__VerbatimSubframeDataType;
 
-/** VERBATIM subframe.  (c.f. <A HREF="../format.html#subframe_verbatim">format specification</A>)
+
+/** VERBATIM subframe.  (c.f. <A HREF="https://xiph.org/flac/format.html#subframe_verbatim">format specification</A>)
  */
 typedef struct {
-	const FLAC__int32 *data; /**< A pointer to verbatim signal. */
+	union {
+		const FLAC__int32 *int32; /**< A FLAC__int32 pointer to verbatim signal. */
+		const FLAC__int64 *int64; /**< A FLAC__int64 pointer to verbatim signal. */
+	} data;
+	FLAC__VerbatimSubframeDataType data_type;
 } FLAC__Subframe_Verbatim;
 
 
-/** FIXED subframe.  (c.f. <A HREF="../format.html#subframe_fixed">format specification</A>)
+/** FIXED subframe.  (c.f. <A HREF="https://xiph.org/flac/format.html#subframe_fixed">format specification</A>)
  */
 typedef struct {
 	FLAC__EntropyCodingMethod entropy_coding_method;
 	/**< The residual coding method. */
 
-	unsigned order;
+	uint32_t order;
 	/**< The polynomial order. */
 
-	FLAC__int32 warmup[FLAC__MAX_FIXED_ORDER];
+	FLAC__int64 warmup[FLAC__MAX_FIXED_ORDER];
 	/**< Warmup samples to prime the predictor, length == order. */
 
 	const FLAC__int32 *residual;
@@ -310,16 +317,16 @@ typedef struct {
 } FLAC__Subframe_Fixed;
 
 
-/** LPC subframe.  (c.f. <A HREF="../format.html#subframe_lpc">format specification</A>)
+/** LPC subframe.  (c.f. <A HREF="https://xiph.org/flac/format.html#subframe_lpc">format specification</A>)
  */
 typedef struct {
 	FLAC__EntropyCodingMethod entropy_coding_method;
 	/**< The residual coding method. */
 
-	unsigned order;
+	uint32_t order;
 	/**< The FIR order. */
 
-	unsigned qlp_coeff_precision;
+	uint32_t qlp_coeff_precision;
 	/**< Quantized FIR filter coefficient precision in bits. */
 
 	int quantization_level;
@@ -328,18 +335,18 @@ typedef struct {
 	FLAC__int32 qlp_coeff[FLAC__MAX_LPC_ORDER];
 	/**< FIR filter coefficients. */
 
-	FLAC__int32 warmup[FLAC__MAX_LPC_ORDER];
+	FLAC__int64 warmup[FLAC__MAX_LPC_ORDER];
 	/**< Warmup samples to prime the predictor, length == order. */
 
 	const FLAC__int32 *residual;
 	/**< The residual signal, length == (blocksize minus order) samples. */
 } FLAC__Subframe_LPC;
 
-extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /**< == 5 (bits) */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN; /**< == 5 (bits) */
 
 
-/** FLAC subframe structure.  (c.f. <A HREF="../format.html#subframe">format specification</A>)
+/** FLAC subframe structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#subframe">format specification</A>)
  */
 typedef struct {
 	FLAC__SubframeType type;
@@ -349,7 +356,7 @@ typedef struct {
 		FLAC__Subframe_LPC lpc;
 		FLAC__Subframe_Verbatim verbatim;
 	} data;
-	unsigned wasted_bits;
+	uint32_t wasted_bits;
 } FLAC__Subframe;
 
 /** == 1 (bit)
@@ -359,14 +366,14 @@ typedef struct {
  * mandatory value of \c 0 but in the future may take on the value \c 0 or \c 1
  * to mean something else.
  */
-extern FLAC_API const unsigned FLAC__SUBFRAME_ZERO_PAD_LEN;
-extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */
-extern FLAC_API const unsigned FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_ZERO_PAD_LEN;
+extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_LEN; /**< == 6 (bits) */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN; /**< == 1 (bit) */
 
-extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */
-extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */
-extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */
-extern FLAC_API const unsigned FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK; /**< = 0x40 */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK; /**< = 0x00 */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK; /**< = 0x02 */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK; /**< = 0x10 */
+extern FLAC_API const uint32_t FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK; /**< = 0x40 */
 
 /*****************************************************************************/
 
@@ -406,22 +413,22 @@ typedef enum {
 extern FLAC_API const char * const FLAC__FrameNumberTypeString[];
 
 
-/** FLAC frame header structure.  (c.f. <A HREF="../format.html#frame_header">format specification</A>)
+/** FLAC frame header structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#frame_header">format specification</A>)
  */
 typedef struct {
-	unsigned blocksize;
+	uint32_t blocksize;
 	/**< The number of samples per subframe. */
 
-	unsigned sample_rate;
+	uint32_t sample_rate;
 	/**< The sample rate in Hz. */
 
-	unsigned channels;
+	uint32_t channels;
 	/**< The number of channels (== number of subframes). */
 
 	FLAC__ChannelAssignment channel_assignment;
 	/**< The channel assignment for the frame. */
 
-	unsigned bits_per_sample;
+	uint32_t bits_per_sample;
 	/**< The sample resolution. */
 
 	FLAC__FrameNumberType number_type;
@@ -443,19 +450,19 @@ typedef struct {
 	 */
 } FLAC__FrameHeader;
 
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */
-extern FLAC_API const unsigned FLAC__FRAME_HEADER_CRC_LEN; /**< == 8 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC; /**< == 0x3ffe; the frame header sync code */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SYNC_LEN; /**< == 14 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_RESERVED_LEN; /**< == 1 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN; /**< == 1 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BLOCK_SIZE_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_SAMPLE_RATE_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN; /**< == 4 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN; /**< == 3 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_ZERO_PAD_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__FRAME_HEADER_CRC_LEN; /**< == 8 (bits) */
 
 
-/** FLAC frame footer structure.  (c.f. <A HREF="../format.html#frame_footer">format specification</A>)
+/** FLAC frame footer structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#frame_footer">format specification</A>)
  */
 typedef struct {
 	FLAC__uint16 crc;
@@ -465,10 +472,10 @@ typedef struct {
 	 */
 } FLAC__FrameFooter;
 
-extern FLAC_API const unsigned FLAC__FRAME_FOOTER_CRC_LEN; /**< == 16 (bits) */
+extern FLAC_API const uint32_t FLAC__FRAME_FOOTER_CRC_LEN; /**< == 16 (bits) */
 
 
-/** FLAC frame structure.  (c.f. <A HREF="../format.html#frame">format specification</A>)
+/** FLAC frame structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#frame">format specification</A>)
  */
 typedef struct {
 	FLAC__FrameHeader header;
@@ -489,31 +496,31 @@ typedef struct {
 typedef enum {
 
 	FLAC__METADATA_TYPE_STREAMINFO = 0,
-	/**< <A HREF="../format.html#metadata_block_streaminfo">STREAMINFO</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_streaminfo">STREAMINFO</A> block */
 
 	FLAC__METADATA_TYPE_PADDING = 1,
-	/**< <A HREF="../format.html#metadata_block_padding">PADDING</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_padding">PADDING</A> block */
 
 	FLAC__METADATA_TYPE_APPLICATION = 2,
-	/**< <A HREF="../format.html#metadata_block_application">APPLICATION</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_application">APPLICATION</A> block */
 
 	FLAC__METADATA_TYPE_SEEKTABLE = 3,
-	/**< <A HREF="../format.html#metadata_block_seektable">SEEKTABLE</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_seektable">SEEKTABLE</A> block */
 
 	FLAC__METADATA_TYPE_VORBIS_COMMENT = 4,
-	/**< <A HREF="../format.html#metadata_block_vorbis_comment">VORBISCOMMENT</A> block (a.k.a. FLAC tags) */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_vorbis_comment">VORBISCOMMENT</A> block (a.k.a. FLAC tags) */
 
 	FLAC__METADATA_TYPE_CUESHEET = 5,
-	/**< <A HREF="../format.html#metadata_block_cuesheet">CUESHEET</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_cuesheet">CUESHEET</A> block */
 
 	FLAC__METADATA_TYPE_PICTURE = 6,
-	/**< <A HREF="../format.html#metadata_block_picture">PICTURE</A> block */
+	/**< <A HREF="https://xiph.org/flac/format.html#metadata_block_picture">PICTURE</A> block */
 
 	FLAC__METADATA_TYPE_UNDEFINED = 7,
 	/**< marker to denote beginning of undefined type range; this number will increase as new metadata types are added */
 
-        FLAC__MAX_METADATA_TYPE = FLAC__MAX_METADATA_TYPE_CODE,
-        /**< No type will ever be greater than this. There is not enough room in the protocol block. */
+	FLAC__MAX_METADATA_TYPE = FLAC__MAX_METADATA_TYPE_CODE,
+	/**< No type will ever be greater than this. There is not enough room in the protocol block. */
 } FLAC__MetadataType;
 
 /** Maps a FLAC__MetadataType to a C string.
@@ -524,32 +531,32 @@ typedef enum {
 extern FLAC_API const char * const FLAC__MetadataTypeString[];
 
 
-/** FLAC STREAMINFO structure.  (c.f. <A HREF="../format.html#metadata_block_streaminfo">format specification</A>)
+/** FLAC STREAMINFO structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_streaminfo">format specification</A>)
  */
 typedef struct {
-	unsigned min_blocksize, max_blocksize;
-	unsigned min_framesize, max_framesize;
-	unsigned sample_rate;
-	unsigned channels;
-	unsigned bits_per_sample;
+	uint32_t min_blocksize, max_blocksize;
+	uint32_t min_framesize, max_framesize;
+	uint32_t sample_rate;
+	uint32_t channels;
+	uint32_t bits_per_sample;
 	FLAC__uint64 total_samples;
 	FLAC__byte md5sum[16];
 } FLAC__StreamMetadata_StreamInfo;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN; /**< == 128 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN; /**< == 16 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN; /**< == 16 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN; /**< == 24 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN; /**< == 24 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN; /**< == 20 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN; /**< == 3 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN; /**< == 5 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN; /**< == 36 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN; /**< == 128 (bits) */
 
 /** The total stream length of the STREAMINFO block in bytes. */
 #define FLAC__STREAM_METADATA_STREAMINFO_LENGTH (34u)
 
-/** FLAC PADDING structure.  (c.f. <A HREF="../format.html#metadata_block_padding">format specification</A>)
+/** FLAC PADDING structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_padding">format specification</A>)
  */
 typedef struct {
 	int dummy;
@@ -560,16 +567,16 @@ typedef struct {
 } FLAC__StreamMetadata_Padding;
 
 
-/** FLAC APPLICATION structure.  (c.f. <A HREF="../format.html#metadata_block_application">format specification</A>)
+/** FLAC APPLICATION structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_application">format specification</A>)
  */
 typedef struct {
 	FLAC__byte id[4];
 	FLAC__byte *data;
 } FLAC__StreamMetadata_Application;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_APPLICATION_ID_LEN; /**< == 32 (bits) */
 
-/** SeekPoint structure used in SEEKTABLE blocks.  (c.f. <A HREF="../format.html#seekpoint">format specification</A>)
+/** SeekPoint structure used in SEEKTABLE blocks.  (c.f. <A HREF="https://xiph.org/flac/format.html#seekpoint">format specification</A>)
  */
 typedef struct {
 	FLAC__uint64 sample_number;
@@ -579,13 +586,13 @@ typedef struct {
 	/**< The offset, in bytes, of the target frame with respect to
 	 * beginning of the first frame. */
 
-	unsigned frame_samples;
+	uint32_t frame_samples;
 	/**< The number of samples in the target frame. */
 } FLAC__StreamMetadata_SeekPoint;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /**< == 16 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN; /**< == 64 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN; /**< == 64 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN; /**< == 16 (bits) */
 
 /** The total stream length of a seek point in bytes. */
 #define FLAC__STREAM_METADATA_SEEKPOINT_LENGTH (18u)
@@ -597,7 +604,7 @@ extern FLAC_API const unsigned FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN
 extern FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
 
 
-/** FLAC SEEKTABLE structure.  (c.f. <A HREF="../format.html#metadata_block_seektable">format specification</A>)
+/** FLAC SEEKTABLE structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_seektable">format specification</A>)
  *
  * \note From the format specification:
  * - The seek points must be sorted by ascending sample number.
@@ -610,12 +617,12 @@ extern FLAC_API const FLAC__uint64 FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
  *   present in a stream.
  */
 typedef struct {
-	unsigned num_points;
+	uint32_t num_points;
 	FLAC__StreamMetadata_SeekPoint *points;
 } FLAC__StreamMetadata_SeekTable;
 
 
-/** Vorbis comment entry structure used in VORBIS_COMMENT blocks.  (c.f. <A HREF="../format.html#metadata_block_vorbis_comment">format specification</A>)
+/** Vorbis comment entry structure used in VORBIS_COMMENT blocks.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_vorbis_comment">format specification</A>)
  *
  *  For convenience, the APIs maintain a trailing NUL character at the end of
  *  \a entry which is not counted toward \a length, i.e.
@@ -626,10 +633,10 @@ typedef struct {
 	FLAC__byte *entry;
 } FLAC__StreamMetadata_VorbisComment_Entry;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN; /**< == 32 (bits) */
 
 
-/** FLAC VORBIS_COMMENT structure.  (c.f. <A HREF="../format.html#metadata_block_vorbis_comment">format specification</A>)
+/** FLAC VORBIS_COMMENT structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block_vorbis_comment">format specification</A>)
  */
 typedef struct {
 	FLAC__StreamMetadata_VorbisComment_Entry vendor_string;
@@ -637,11 +644,11 @@ typedef struct {
 	FLAC__StreamMetadata_VorbisComment_Entry *comments;
 } FLAC__StreamMetadata_VorbisComment;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN; /**< == 32 (bits) */
 
 
 /** FLAC CUESHEET track index structure.  (See the
- * <A HREF="../format.html#cuesheet_track_index">format specification</A> for
+ * <A HREF="https://xiph.org/flac/format.html#cuesheet_track_index">format specification</A> for
  * the full description of each field.)
  */
 typedef struct {
@@ -654,13 +661,13 @@ typedef struct {
 	/**< The index point number. */
 } FLAC__StreamMetadata_CueSheet_Index;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN; /**< == 3*8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN; /**< == 64 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN; /**< == 8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN; /**< == 3*8 (bits) */
 
 
 /** FLAC CUESHEET track structure.  (See the
- * <A HREF="../format.html#cuesheet_track">format specification</A> for
+ * <A HREF="https://xiph.org/flac/format.html#cuesheet_track">format specification</A> for
  * the full description of each field.)
  */
 typedef struct {
@@ -673,10 +680,10 @@ typedef struct {
 	char isrc[13];
 	/**< Track ISRC.  This is a 12-digit alphanumeric code plus a trailing \c NUL byte */
 
-	unsigned type:1;
+	uint32_t type:1;
 	/**< The track type: 0 for audio, 1 for non-audio. */
 
-	unsigned pre_emphasis:1;
+	uint32_t pre_emphasis:1;
 	/**< The pre-emphasis flag: 0 for no pre-emphasis, 1 for pre-emphasis. */
 
 	FLAC__byte num_indices;
@@ -687,17 +694,17 @@ typedef struct {
 
 } FLAC__StreamMetadata_CueSheet_Track;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN; /**< == 8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN; /**< == 64 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN; /**< == 8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN; /**< == 12*8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN; /**< == 6+13*8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN; /**< == 8 (bits) */
 
 
 /** FLAC CUESHEET structure.  (See the
- * <A HREF="../format.html#metadata_block_cuesheet">format specification</A>
+ * <A HREF="https://xiph.org/flac/format.html#metadata_block_cuesheet">format specification</A>
  * for the full description of each field.)
  */
 typedef struct {
@@ -713,7 +720,7 @@ typedef struct {
 	FLAC__bool is_cd;
 	/**< \c true if CUESHEET corresponds to a Compact Disc, else \c false. */
 
-	unsigned num_tracks;
+	uint32_t num_tracks;
 	/**< The number of tracks. */
 
 	FLAC__StreamMetadata_CueSheet_Track *tracks;
@@ -721,11 +728,11 @@ typedef struct {
 
 } FLAC__StreamMetadata_CueSheet;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN; /**< == 8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN; /**< == 128*8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN; /**< == 64 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN; /**< == 7+258*8 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN; /**< == 8 (bits) */
 
 
 /** An enumeration of the PICTURE types (see FLAC__StreamMetadataPicture and id3 v2.4 APIC tag). */
@@ -763,7 +770,7 @@ typedef enum {
 extern FLAC_API const char * const FLAC__StreamMetadata_Picture_TypeString[];
 
 /** FLAC PICTURE structure.  (See the
- * <A HREF="../format.html#metadata_block_picture">format specification</A>
+ * <A HREF="https://xiph.org/flac/format.html#metadata_block_picture">format specification</A>
  * for the full description of each field.)
  */
 typedef struct {
@@ -810,14 +817,14 @@ typedef struct {
 
 } FLAC__StreamMetadata_Picture;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_TYPE_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_COLORS_LEN; /**< == 32 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN; /**< == 32 (bits) */
 
 
 /** Structure that is used when a metadata block of unknown type is loaded.
@@ -829,9 +836,9 @@ typedef struct {
 } FLAC__StreamMetadata_Unknown;
 
 
-/** FLAC metadata block structure.  (c.f. <A HREF="../format.html#metadata_block">format specification</A>)
+/** FLAC metadata block structure.  (c.f. <A HREF="https://xiph.org/flac/format.html#metadata_block">format specification</A>)
  */
-typedef struct {
+typedef struct FLAC__StreamMetadata {
 	FLAC__MetadataType type;
 	/**< The type of the metadata block; used determine which member of the
 	 * \a data union to dereference.  If type >= FLAC__METADATA_TYPE_UNDEFINED
@@ -840,7 +847,7 @@ typedef struct {
 	FLAC__bool is_last;
 	/**< \c true if this metadata block is the last, else \a false */
 
-	unsigned length;
+	uint32_t length;
 	/**< Length, in bytes, of the block data as it appears in the stream. */
 
 	union {
@@ -857,9 +864,9 @@ typedef struct {
 	 * to use. */
 } FLAC__StreamMetadata;
 
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */
-extern FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_IS_LAST_LEN; /**< == 1 (bit) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_TYPE_LEN; /**< == 7 (bits) */
+extern FLAC_API const uint32_t FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bits) */
 
 /** The total stream length of a metadata block header in bytes. */
 #define FLAC__STREAM_METADATA_HEADER_LENGTH (4u)
@@ -880,7 +887,7 @@ extern FLAC_API const unsigned FLAC__STREAM_METADATA_LENGTH_LEN; /**< == 24 (bit
  *    \c true if the given sample rate conforms to the specification, else
  *    \c false.
  */
-FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate);
+FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(uint32_t sample_rate);
 
 /** Tests that a blocksize at the given sample rate is valid for the FLAC
  *  subset.
@@ -892,7 +899,7 @@ FLAC_API FLAC__bool FLAC__format_sample_rate_is_valid(unsigned sample_rate);
  *    \c true if the given blocksize conforms to the specification for the
  *    subset at the given sample rate, else \c false.
  */
-FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigned sample_rate);
+FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(uint32_t blocksize, uint32_t sample_rate);
 
 /** Tests that a sample rate is valid for the FLAC subset.  The subset rules
  *  for valid sample rates are slightly more complex since the rate has to
@@ -903,7 +910,7 @@ FLAC_API FLAC__bool FLAC__format_blocksize_is_subset(unsigned blocksize, unsigne
  *    \c true if the given sample rate conforms to the specification for the
  *    subset, else \c false.
  */
-FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(unsigned sample_rate);
+FLAC_API FLAC__bool FLAC__format_sample_rate_is_subset(uint32_t sample_rate);
 
 /** Check a Vorbis comment entry name to see if it conforms to the Vorbis
  *  comment specification.
@@ -926,14 +933,14 @@ FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_name_is_legal(const char *n
  *
  * \param value      A string to be checked.
  * \param length     A the length of \a value in bytes.  May be
- *                   \c (unsigned)(-1) to indicate that \a value is a plain
+ *                   \c (uint32_t)(-1) to indicate that \a value is a plain
  *                   UTF-8 NUL-terminated string.
  * \assert
  *    \code value != NULL \endcode
  * \retval FLAC__bool
  *    \c false if entry name is illegal, else \c true.
  */
-FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, unsigned length);
+FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__byte *value, uint32_t length);
 
 /** Check a Vorbis comment entry to see if it conforms to the Vorbis
  *  comment specification.
@@ -950,7 +957,7 @@ FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_value_is_legal(const FLAC__
  * \retval FLAC__bool
  *    \c false if entry name is illegal, else \c true.
  */
-FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, unsigned length);
+FLAC_API FLAC__bool FLAC__format_vorbiscomment_entry_is_legal(const FLAC__byte *entry, uint32_t length);
 
 /** Check a seek table to see if it conforms to the FLAC specification.
  *  See the format specification for limits on the contents of the
@@ -973,10 +980,10 @@ FLAC_API FLAC__bool FLAC__format_seektable_is_legal(const FLAC__StreamMetadata_S
  * \param seek_table  A pointer to a seek table to be sorted.
  * \assert
  *    \code seek_table != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    The number of duplicate seek points converted into placeholders.
  */
-FLAC_API unsigned FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table);
+FLAC_API uint32_t FLAC__format_seektable_sort(FLAC__StreamMetadata_SeekTable *seek_table);
 
 /** Check a cue sheet to see if it conforms to the FLAC specification.
  *  See the format specification for limits on the contents of the

components/codecs/inc/FLAC/metadata.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2001-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -93,7 +93,7 @@
  *  Efficient means the whole file is rewritten at most one time, and only
  *  when necessary.  Level 1 is not efficient only in the case that you
  *  cause more than one metadata block to grow or shrink beyond what can
- *  be accomodated by padding.  In this case you should probably use level
+ *  be accommodated by padding.  In this case you should probably use level
  *  2, which allows you to edit all the metadata for a file in memory and
  *  write it out all at once.
  *
@@ -134,6 +134,11 @@ extern "C" {
  *  STREAMINFO, VORBIS_COMMENT, CUESHEET, and PICTURE blocks, requiring
  *  only a filename.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  *  They try to skip any ID3v2 tag at the head of the file.
  *
  * \{
@@ -217,13 +222,13 @@ FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__Stre
  *                    matched exactly.  Use \c NULL to mean "any
  *                    description".
  * \param max_width   The maximum width in pixels desired.  Use
- *                    \c (unsigned)(-1) to mean "any width".
+ *                    \c (uint32_t)(-1) to mean "any width".
  * \param max_height  The maximum height in pixels desired.  Use
- *                    \c (unsigned)(-1) to mean "any height".
+ *                    \c (uint32_t)(-1) to mean "any height".
  * \param max_depth   The maximum color depth in bits-per-pixel desired.
- *                    Use \c (unsigned)(-1) to mean "any depth".
+ *                    Use \c (uint32_t)(-1) to mean "any depth".
  * \param max_colors  The maximum number of colors desired.  Use
- *                    \c (unsigned)(-1) to mean "any number of colors".
+ *                    \c (uint32_t)(-1) to mean "any number of colors".
  * \assert
  *    \code filename != NULL \endcode
  *    \code picture != NULL \endcode
@@ -234,7 +239,7 @@ FLAC_API FLAC__bool FLAC__metadata_get_cuesheet(const char *filename, FLAC__Stre
  *    error, a file decoder error, or the file contained no PICTURE
  *    block, and \a *picture will be set to \c NULL.
  */
-FLAC_API FLAC__bool FLAC__metadata_get_picture(const char *filename, FLAC__StreamMetadata **picture, FLAC__StreamMetadata_Picture_Type type, const char *mime_type, const FLAC__byte *description, unsigned max_width, unsigned max_height, unsigned max_depth, unsigned max_colors);
+FLAC_API FLAC__bool FLAC__metadata_get_picture(const char *filename, FLAC__StreamMetadata **picture, FLAC__StreamMetadata_Picture_Type type, const char *mime_type, const FLAC__byte *description, uint32_t max_width, uint32_t max_height, uint32_t max_depth, uint32_t max_colors);
 
 /* \} */
 
@@ -387,6 +392,11 @@ FLAC_API FLAC__Metadata_SimpleIteratorStatus FLAC__metadata_simple_iterator_stat
 /** Initialize the iterator to point to the first metadata block in the
  *  given FLAC file.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  * \param iterator             A pointer to an existing iterator.
  * \param filename             The path to the FLAC file.
  * \param read_only            If \c true, the FLAC file will be opened
@@ -497,13 +507,13 @@ FLAC_API FLAC__MetadataType FLAC__metadata_simple_iterator_get_block_type(const
  *    \code iterator != NULL \endcode
  *    \a iterator has been successfully initialized with
  *    FLAC__metadata_simple_iterator_init()
- * \retval unsigned
+ * \retval uint32_t
  *    The length of the metadata block at the current iterator position.
  *    The is same length as that in the
- *    <a href="http://xiph.org/flac/format.html#metadata_block_header">metadata block header</a>,
+ *    <a href="http://xiph.org/flhttps://xiph.org/flac/format.html#metadata_block_header">metadata block header</a>,
  *    i.e. the length of the metadata body that follows the header.
  */
-FLAC_API unsigned FLAC__metadata_simple_iterator_get_block_length(const FLAC__Metadata_SimpleIterator *iterator);
+FLAC_API uint32_t FLAC__metadata_simple_iterator_get_block_length(const FLAC__Metadata_SimpleIterator *iterator);
 
 /** Get the application ID of the \c APPLICATION block at the current
  *  position.  This avoids reading the actual block data which can save
@@ -667,7 +677,7 @@ FLAC_API FLAC__bool FLAC__metadata_simple_iterator_delete_block(FLAC__Metadata_S
  *
  * - Create a new chain using FLAC__metadata_chain_new().  A chain is a
  *   linked list of FLAC metadata blocks.
- * - Read all metadata into the the chain from a FLAC file using
+ * - Read all metadata into the chain from a FLAC file using
  *   FLAC__metadata_chain_read() or FLAC__metadata_chain_read_ogg() and
  *   check the status.
  * - Optionally, consolidate the padding using
@@ -764,7 +774,7 @@ typedef enum {
 	FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH,
 	/**< FLAC__metadata_chain_write() was called on a chain read by
 	 *   FLAC__metadata_chain_read_with_callbacks()/FLAC__metadata_chain_read_ogg_with_callbacks(),
-	 *   or 
+	 *   or
 	 *   FLAC__metadata_chain_write_with_callbacks()/FLAC__metadata_chain_write_with_callbacks_and_tempfile()
 	 *   was called on a chain read by
 	 *   FLAC__metadata_chain_read()/FLAC__metadata_chain_read_ogg().
@@ -819,6 +829,11 @@ FLAC_API void FLAC__metadata_chain_delete(FLAC__Metadata_Chain *chain);
 FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_Chain *chain);
 
 /** Read all metadata from a FLAC file into the chain.
+ *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
  *
  * \param chain    A pointer to an existing chain.
  * \param filename The path to the FLAC file to read.
@@ -833,6 +848,11 @@ FLAC_API FLAC__Metadata_ChainStatus FLAC__metadata_chain_status(FLAC__Metadata_C
 FLAC_API FLAC__bool FLAC__metadata_chain_read(FLAC__Metadata_Chain *chain, const char *filename);
 
 /** Read all metadata from an Ogg FLAC file into the chain.
+ *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
  *
  * \note Ogg FLAC metadata data writing is not supported yet and
  * FLAC__metadata_chain_write() will fail.
@@ -1373,12 +1393,13 @@ FLAC_API FLAC__bool FLAC__metadata_object_is_equal(const FLAC__StreamMetadata *b
  * \retval FLAC__bool
  *    \c false if \a copy is \c true and malloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, unsigned length, FLAC__bool copy);
+FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetadata *object, FLAC__byte *data, uint32_t length, FLAC__bool copy);
 
 /** Resize the seekpoint array.
  *
  *  If the size shrinks, elements will truncated; if it grows, new placeholder
- *  points will be added to the end.
+ *  points will be added to the end. If this function returns false, the
+ *  object is left untouched.
  *
  * \param object          A pointer to an existing SEEKTABLE object.
  * \param new_num_points  The desired length of the array; may be \c 0.
@@ -1390,7 +1411,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_application_set_data(FLAC__StreamMetad
  * \retval FLAC__bool
  *    \c false if memory allocation error, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, unsigned new_num_points);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMetadata *object, uint32_t new_num_points);
 
 /** Set a seekpoint in a seektable.
  *
@@ -1402,7 +1423,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_resize_points(FLAC__StreamMe
  *    \code object->type == FLAC__METADATA_TYPE_SEEKTABLE \endcode
  *    \code object->data.seek_table.num_points > point_num \endcode
  */
-FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point);
+FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *object, uint32_t point_num, FLAC__StreamMetadata_SeekPoint point);
 
 /** Insert a seekpoint into a seektable.
  *
@@ -1416,7 +1437,7 @@ FLAC_API void FLAC__metadata_object_seektable_set_point(FLAC__StreamMetadata *ob
  * \retval FLAC__bool
  *    \c false if memory allocation error, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, unsigned point_num, FLAC__StreamMetadata_SeekPoint point);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMetadata *object, uint32_t point_num, FLAC__StreamMetadata_SeekPoint point);
 
 /** Delete a seekpoint from a seektable.
  *
@@ -1429,7 +1450,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_insert_point(FLAC__StreamMet
  * \retval FLAC__bool
  *    \c false if memory allocation error, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, unsigned point_num);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_delete_point(FLAC__StreamMetadata *object, uint32_t point_num);
 
 /** Check a seektable to see if it conforms to the FLAC specification.
  *  See the format specification for limits on the contents of the
@@ -1459,7 +1480,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_is_legal(const FLAC__StreamM
  * \retval FLAC__bool
  *    \c false if memory allocation fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, unsigned num);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_placeholders(FLAC__StreamMetadata *object, uint32_t num);
 
 /** Append a specific seek point template to the end of a seek table.
  *
@@ -1494,7 +1515,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_point(FLAC__
  * \retval FLAC__bool
  *    \c false if memory allocation fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], unsigned num);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC__StreamMetadata *object, FLAC__uint64 sample_numbers[], uint32_t num);
 
 /** Append a set of evenly-spaced seek point templates to the end of a
  *  seek table.
@@ -1516,7 +1537,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_points(FLAC_
  * \retval FLAC__bool
  *    \c false if memory allocation fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, unsigned num, FLAC__uint64 total_samples);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points(FLAC__StreamMetadata *object, uint32_t num, FLAC__uint64 total_samples);
 
 /** Append a set of evenly-spaced seek point templates to the end of a
  *  seek table.
@@ -1544,7 +1565,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_point
  * \retval FLAC__bool
  *    \c false if memory allocation fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, unsigned samples, FLAC__uint64 total_samples);
+FLAC_API FLAC__bool FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata *object, uint32_t samples, FLAC__uint64 total_samples);
 
 /** Sort a seek table's seek points according to the format specification,
  *  removing duplicates.
@@ -1591,7 +1612,8 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__
 /** Resize the comment array.
  *
  *  If the size shrinks, elements will truncated; if it grows, new empty
- *  fields will be added to the end.
+ *  fields will be added to the end.  If this function returns false, the
+ *  object is left untouched.
  *
  * \param object            A pointer to an existing VORBIS_COMMENT object.
  * \param new_num_comments  The desired length of the array; may be \c 0.
@@ -1603,7 +1625,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_vendor_string(FLAC__
  * \retval FLAC__bool
  *    \c false if memory allocation fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, unsigned new_num_comments);
+FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__StreamMetadata *object, uint32_t new_num_comments);
 
 /** Sets a comment in a VORBIS_COMMENT block.
  *
@@ -1630,7 +1652,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_resize_comments(FLAC__St
  *    \c false if memory allocation fails or \a entry does not comply with the
  *    Vorbis comment specification, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy);
+FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__StreamMetadata *object, uint32_t comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy);
 
 /** Insert a comment in a VORBIS_COMMENT block at the given index.
  *
@@ -1660,7 +1682,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_set_comment(FLAC__Stream
  *    \c false if memory allocation fails or \a entry does not comply with the
  *    Vorbis comment specification, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, unsigned comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy);
+FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_insert_comment(FLAC__StreamMetadata *object, uint32_t comment_num, FLAC__StreamMetadata_VorbisComment_Entry entry, FLAC__bool copy);
 
 /** Appends a comment to a VORBIS_COMMENT block.
  *
@@ -1692,7 +1714,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_append_comment(FLAC__Str
  *  For convenience, a trailing NUL is added to the entry if it doesn't have
  *  one already.
  *
- *  Depending on the the value of \a all, either all or just the first comment
+ *  Depending on the value of \a all, either all or just the first comment
  *  whose field name(s) match the given entry's name will be replaced by the
  *  given entry.  If no comments match, \a entry will simply be appended.
  *
@@ -1733,7 +1755,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_replace_comment(FLAC__St
  * \retval FLAC__bool
  *    \c false if realloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, unsigned comment_num);
+FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_delete_comment(FLAC__StreamMetadata *object, uint32_t comment_num);
 
 /** Creates a Vorbis comment entry from NUL-terminated name and value strings.
  *
@@ -1789,7 +1811,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair
  * \retval FLAC__bool
  *    \c true if the field names match, else \c false
  */
-FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, unsigned field_name_length);
+FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC__StreamMetadata_VorbisComment_Entry entry, const char *field_name, uint32_t field_name_length);
 
 /** Find a Vorbis comment with the given field name.
  *
@@ -1808,7 +1830,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_vorbiscomment_entry_matches(const FLAC
  *    The offset in the comment array of the first comment whose field
  *    name matches \a field_name, or \c -1 if no match was found.
  */
-FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, unsigned offset, const char *field_name);
+FLAC_API int FLAC__metadata_object_vorbiscomment_find_entry_from(const FLAC__StreamMetadata *object, uint32_t offset, const char *field_name);
 
 /** Remove first Vorbis comment matching the given field name.
  *
@@ -1871,7 +1893,8 @@ FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_C
 /** Resize a track's index point array.
  *
  *  If the size shrinks, elements will truncated; if it grows, new blank
- *  indices will be added to the end.
+ *  indices will be added to the end. If this function returns false, the
+ *  track object is left untouched.
  *
  * \param object           A pointer to an existing CUESHEET object.
  * \param track_num        The index of the track to modify.  NOTE: this is not
@@ -1886,7 +1909,7 @@ FLAC_API void FLAC__metadata_object_cuesheet_track_delete(FLAC__StreamMetadata_C
  * \retval FLAC__bool
  *    \c false if memory allocation error, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, unsigned track_num, unsigned new_num_indices);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t new_num_indices);
 
 /** Insert an index point in a CUESHEET track at the given index.
  *
@@ -1909,7 +1932,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_resize_indices(FLAC__St
  * \retval FLAC__bool
  *    \c false if realloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num, FLAC__StreamMetadata_CueSheet_Index index);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num, FLAC__StreamMetadata_CueSheet_Index index);
 
 /** Insert a blank index point in a CUESHEET track at the given index.
  *
@@ -1933,7 +1956,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_index(FLAC__Stre
  * \retval FLAC__bool
  *    \c false if realloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num);
 
 /** Delete an index point in a CUESHEET track at the given index.
  *
@@ -1952,12 +1975,13 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_insert_blank_index(FLAC
  * \retval FLAC__bool
  *    \c false if realloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, unsigned track_num, unsigned index_num);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__StreamMetadata *object, uint32_t track_num, uint32_t index_num);
 
 /** Resize the track array.
  *
  *  If the size shrinks, elements will truncated; if it grows, new blank
- *  tracks will be added to the end.
+ *  tracks will be added to the end.  If this function returns false, the
+ *  object is left untouched.
  *
  * \param object            A pointer to an existing CUESHEET object.
  * \param new_num_tracks    The desired length of the array; may be \c 0.
@@ -1969,7 +1993,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_track_delete_index(FLAC__Stre
  * \retval FLAC__bool
  *    \c false if memory allocation error, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, unsigned new_num_tracks);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMetadata *object, uint32_t new_num_tracks);
 
 /** Sets a track in a CUESHEET block.
  *
@@ -1991,7 +2015,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_resize_tracks(FLAC__StreamMet
  * \retval FLAC__bool
  *    \c false if \a copy is \c true and malloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadata *object, uint32_t track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy);
 
 /** Insert a track in a CUESHEET block at the given index.
  *
@@ -2014,7 +2038,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_set_track(FLAC__StreamMetadat
  * \retval FLAC__bool
  *    \c false if \a copy is \c true and malloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, unsigned track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMetadata *object, uint32_t track_num, FLAC__StreamMetadata_CueSheet_Track *track, FLAC__bool copy);
 
 /** Insert a blank track in a CUESHEET block at the given index.
  *
@@ -2033,7 +2057,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_track(FLAC__StreamMeta
  * \retval FLAC__bool
  *    \c false if \a copy is \c true and malloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, unsigned track_num);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__StreamMetadata *object, uint32_t track_num);
 
 /** Delete a track in a CUESHEET block at the given index.
  *
@@ -2048,7 +2072,7 @@ FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_insert_blank_track(FLAC__Stre
  * \retval FLAC__bool
  *    \c false if realloc() fails, else \c true.
  */
-FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, unsigned track_num);
+FLAC_API FLAC__bool FLAC__metadata_object_cuesheet_delete_track(FLAC__StreamMetadata *object, uint32_t track_num);
 
 /** Check a cue sheet to see if it conforms to the FLAC specification.
  *  See the format specification for limits on the contents of the
@@ -2173,6 +2197,34 @@ FLAC_API FLAC__bool FLAC__metadata_object_picture_set_data(FLAC__StreamMetadata
  */
 FLAC_API FLAC__bool FLAC__metadata_object_picture_is_legal(const FLAC__StreamMetadata *object, const char **violation);
 
+
+/** Get the raw (binary) representation of a FLAC__StreamMetadata objeect.
+ *  After use, free() the returned buffer. The length of the buffer is
+ *  the length of the input metadata object plus 4 bytes for the header.
+ *
+ * \param object     A pointer to metadata block to be converted.
+ * \assert
+ *    \code object != NULL \endcode
+ * \retval FLAC__byte*
+ *    \c  NULL if there was an error, else a pointer to a buffer holding
+ *        the requested data.
+ */
+FLAC_API FLAC__byte * FLAC__metadata_object_get_raw(const FLAC__StreamMetadata *object);
+
+
+/** Turn a raw (binary) representation into a FLAC__StreamMetadata objeect.
+ *  The returned object must be deleted with FLAC__metadata_object_delete()
+ *  after use.
+ *
+ * \param buffer     A pointer to a buffer containing a binary representation
+ *                   to be converted to a FLAC__StreamMetadata object
+ * \param length     The length of the supplied buffer
+ * \retval FLAC__StreamMetadata*
+ *    \c  NULL if there was an error, else a pointer to a FLAC__StreamMetadata
+ *        holding the requested data.
+ */
+
+FLAC_API FLAC__StreamMetadata * FLAC__metadata_object_set_raw(FLAC__byte *buffer, FLAC__uint32 length);
 /* \} */
 
 #ifdef __cplusplus

components/codecs/inc/FLAC/ordinals.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,27 +33,10 @@
 #ifndef FLAC__ORDINALS_H
 #define FLAC__ORDINALS_H
 
-#if defined(_MSC_VER) && _MSC_VER < 1600
-
-/* Microsoft Visual Studio earlier than the 2010 version did not provide
- * the 1999 ISO C Standard header file <stdint.h>.
- */
-
-typedef __int8 FLAC__int8;
-typedef unsigned __int8 FLAC__uint8;
-
-typedef __int16 FLAC__int16;
-typedef __int32 FLAC__int32;
-typedef __int64 FLAC__int64;
-typedef unsigned __int16 FLAC__uint16;
-typedef unsigned __int32 FLAC__uint32;
-typedef unsigned __int64 FLAC__uint64;
-
-#else
-
-/* For MSVC 2010 and everything else which provides <stdint.h>. */
+/* This of course assumes C99 headers */
 
 #include <stdint.h>
+#include <stdbool.h>
 
 typedef int8_t FLAC__int8;
 typedef uint8_t FLAC__uint8;
@@ -65,22 +48,8 @@ typedef uint16_t FLAC__uint16;
 typedef uint32_t FLAC__uint32;
 typedef uint64_t FLAC__uint64;
 
-#endif
-
 typedef int FLAC__bool;
 
 typedef FLAC__uint8 FLAC__byte;
 
-
-#ifdef true
-#undef true
-#endif
-#ifdef false
-#undef false
-#endif
-#ifndef __cplusplus
-#define true 1
-#define false 0
-#endif
-
 #endif

components/codecs/inc/FLAC/stream_decoder.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -228,7 +228,7 @@ typedef enum {
 	 */
 
 	FLAC__STREAM_DECODER_ABORTED,
-	/**< The decoder was aborted by the read callback. */
+	/**< The decoder was aborted by the read or write callback. */
 
 	FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR,
 	/**< An error occurred allocating memory.  The decoder is in an invalid
@@ -422,7 +422,11 @@ extern FLAC_API const char * const FLAC__StreamDecoderWriteStatusString[];
  *  could be because the decoder encountered a valid frame made by a future
  *  version of the encoder which it cannot parse, or because of a false
  *  sync making it appear as though an encountered frame was generated by
- *  a future encoder.
+ *  a future encoder. \c FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA is
+ *  caused by finding data that doesn't fit a metadata block (too large
+ *  or too small) or finding inconsistencies in the metadata, for example
+ *  a PICTURE block with an image that exceeds the size of the metadata
+ *  block.
  */
 typedef enum {
 
@@ -435,9 +439,12 @@ typedef enum {
 	FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH,
 	/**< The frame's data did not match the CRC in the footer. */
 
-	FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM
+	FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM,
 	/**< The decoder encountered reserved fields in use in the stream. */
 
+	FLAC__STREAM_DECODER_ERROR_STATUS_BAD_METADATA
+	/**< The decoder encountered a corrupted metadata block. */
+
 } FLAC__StreamDecoderErrorStatus;
 
 /** Maps a FLAC__StreamDecoderErrorStatus to a C string.
@@ -674,7 +681,7 @@ typedef FLAC__bool (*FLAC__StreamDecoderEofCallback)(const FLAC__StreamDecoder *
  *                  samples of length \a frame->header.blocksize.
  *                  Channels will be ordered according to the FLAC
  *                  specification; see the documentation for the
- *                  <A HREF="../format.html#frame_header">frame header</A>.
+ *                  <A HREF="https://xiph.org/flac/format.html#frame_header">frame header</A>.
  * \param  client_data  The callee's client data set through
  *                      FLAC__stream_decoder_init_*().
  * \retval FLAC__StreamDecoderWriteStatus
@@ -920,7 +927,7 @@ FLAC_API FLAC__bool FLAC__stream_decoder_get_md5_checking(const FLAC__StreamDeco
  * \param  decoder  A decoder instance to query.
  * \assert
  *    \code decoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See above.
  */
 FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamDecoder *decoder);
@@ -932,10 +939,10 @@ FLAC_API FLAC__uint64 FLAC__stream_decoder_get_total_samples(const FLAC__StreamD
  * \param  decoder  A decoder instance to query.
  * \assert
  *    \code decoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See above.
  */
-FLAC_API unsigned FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder);
+FLAC_API uint32_t FLAC__stream_decoder_get_channels(const FLAC__StreamDecoder *decoder);
 
 /** Get the current channel assignment in the stream being decoded.
  *  Will only be valid after decoding has started and will contain the
@@ -956,10 +963,10 @@ FLAC_API FLAC__ChannelAssignment FLAC__stream_decoder_get_channel_assignment(con
  * \param  decoder  A decoder instance to query.
  * \assert
  *    \code decoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See above.
  */
-FLAC_API unsigned FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder);
+FLAC_API uint32_t FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDecoder *decoder);
 
 /** Get the current sample rate in Hz of the stream being decoded.
  *  Will only be valid after decoding has started and will contain the
@@ -968,10 +975,10 @@ FLAC_API unsigned FLAC__stream_decoder_get_bits_per_sample(const FLAC__StreamDec
  * \param  decoder  A decoder instance to query.
  * \assert
  *    \code decoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See above.
  */
-FLAC_API unsigned FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder);
+FLAC_API uint32_t FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder *decoder);
 
 /** Get the current blocksize of the stream being decoded.
  *  Will only be valid after decoding has started and will contain the
@@ -980,10 +987,10 @@ FLAC_API unsigned FLAC__stream_decoder_get_sample_rate(const FLAC__StreamDecoder
  * \param  decoder  A decoder instance to query.
  * \assert
  *    \code decoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See above.
  */
-FLAC_API unsigned FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder);
+FLAC_API uint32_t FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *decoder);
 
 /** Returns the decoder's current read position within the stream.
  *  The position is the byte offset from the start of the stream.
@@ -1006,6 +1013,16 @@ FLAC_API unsigned FLAC__stream_decoder_get_blocksize(const FLAC__StreamDecoder *
  */
 FLAC_API FLAC__bool FLAC__stream_decoder_get_decode_position(const FLAC__StreamDecoder *decoder, FLAC__uint64 *position);
 
+/** Return client_data from decoder.
+ *  The data pointed to by the pointer should not be modified.
+ *
+ * \param  decoder  A decoder instance.
+ * \retval const void *
+ *    The callee's client data set through FLAC__stream_decoder_init_*().
+ *    Do not modify the contents.
+ */
+FLAC_API const void *FLAC__stream_decoder_get_client_data(FLAC__StreamDecoder *decoder);
+
 /** Initialize the decoder instance to decode native FLAC streams.
  *
  *  This flavor of initialization sets up the decoder to decode from a
@@ -1184,7 +1201,7 @@ FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_stream(
  *                            Unless \a file is \c stdin, it will be closed
  *                            when FLAC__stream_decoder_finish() is called.
  *                            Note however that seeking will not work when
- *                            decoding from \c stdout since it is not seekable.
+ *                            decoding from \c stdin since it is not seekable.
  * \param  write_callback     See FLAC__StreamDecoderWriteCallback.  This
  *                            pointer must not be \c NULL.
  * \param  metadata_callback  See FLAC__StreamDecoderMetadataCallback.  This
@@ -1234,7 +1251,7 @@ FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_FILE(
  *                            Unless \a file is \c stdin, it will be closed
  *                            when FLAC__stream_decoder_finish() is called.
  *                            Note however that seeking will not work when
- *                            decoding from \c stdout since it is not seekable.
+ *                            decoding from \c stdin since it is not seekable.
  * \param  write_callback     See FLAC__StreamDecoderWriteCallback.  This
  *                            pointer must not be \c NULL.
  * \param  metadata_callback  See FLAC__StreamDecoderMetadataCallback.  This
@@ -1263,11 +1280,15 @@ FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_ogg_FILE(
 /** Initialize the decoder instance to decode native FLAC files.
  *
  *  This flavor of initialization sets up the decoder to decode from a plain
- *  native FLAC file.  If POSIX fopen() semantics are not sufficient, (for
- *  example, with Unicode filenames on Windows), you must use
- *  FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream()
+ *  native FLAC file.  If POSIX fopen() semantics are not sufficient, you must
+ *  use FLAC__stream_decoder_init_FILE(), or FLAC__stream_decoder_init_stream()
  *  and provide callbacks for the I/O.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  *  This function should be called after FLAC__stream_decoder_new() and
  *  FLAC__stream_decoder_set_*() but before any of the
  *  FLAC__stream_decoder_process_*() functions.  Will set and return the
@@ -1305,11 +1326,15 @@ FLAC_API FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_file(
 /** Initialize the decoder instance to decode Ogg FLAC files.
  *
  *  This flavor of initialization sets up the decoder to decode from a plain
- *  Ogg FLAC file.  If POSIX fopen() semantics are not sufficient, (for
- *  example, with Unicode filenames on Windows), you must use
+ *  Ogg FLAC file.  If POSIX fopen() semantics are not sufficient, you must use
  *  FLAC__stream_decoder_init_ogg_FILE(), or FLAC__stream_decoder_init_ogg_stream()
  *  and provide callbacks for the I/O.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  *  This function should be called after FLAC__stream_decoder_new() and
  *  FLAC__stream_decoder_set_*() but before any of the
  *  FLAC__stream_decoder_process_*() functions.  Will set and return the
@@ -1403,8 +1428,7 @@ FLAC_API FLAC__bool FLAC__stream_decoder_flush(FLAC__StreamDecoder *decoder);
  *  and is not seekable (i.e. no seek callback was provided or the seek
  *  callback returns \c FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED), it
  *  is the duty of the client to start feeding data from the beginning of
- *  the stream on the next FLAC__stream_decoder_process() or
- *  FLAC__stream_decoder_process_interleaved() call.
+ *  the stream on the next FLAC__stream_decoder_process_*() call.
  *
  * \param  decoder  A decoder instance.
  * \assert

components/codecs/inc/FLAC/stream_encoder.h

@@ -1,6 +1,6 @@
 /* libFLAC - Free Lossless Audio Codec library
  * Copyright (C) 2000-2009  Josh Coalson
- * Copyright (C) 2011-2014  Xiph.Org Foundation
+ * Copyright (C) 2011-2022  Xiph.Org Foundation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -129,8 +129,8 @@ extern "C" {
  * Unlike the decoders, the stream encoder has many options that can
  * affect the speed and compression ratio.  When setting these parameters
  * you should have some basic knowledge of the format (see the
- * <A HREF="../documentation_format_overview.html">user-level documentation</A>
- * or the <A HREF="../format.html">formal description</A>).  The
+ * <A HREF="https://xiph.org/flac/documentation_format_overview.html">user-level documentation</A>
+ * or the <A HREF="https://xiph.org/flac/format.html">formal description</A>).  The
  * FLAC__stream_encoder_set_*() functions themselves do not validate the
  * values as many are interdependent.  The FLAC__stream_encoder_init_*()
  * functions will do this, so make sure to pay attention to the state
@@ -311,8 +311,7 @@ typedef enum {
 
 	FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_BITS_PER_SAMPLE,
 	/**< The encoder has an invalid setting for bits-per-sample.
-	 * FLAC supports 4-32 bps but the reference encoder currently supports
-	 * only up to 24 bps.
+	 * FLAC supports 4-32 bps.
 	 */
 
 	FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_SAMPLE_RATE,
@@ -331,7 +330,7 @@ typedef enum {
 	/**< The specified block size is less than the maximum LPC order. */
 
 	FLAC__STREAM_ENCODER_INIT_STATUS_NOT_STREAMABLE,
-	/**< The encoder is bound to the <A HREF="../format.html#subset">Subset</A> but other settings violate it. */
+	/**< The encoder is bound to the <A HREF="https://xiph.org/flac/format.html#subset">Subset</A> but other settings violate it. */
 
 	FLAC__STREAM_ENCODER_INIT_STATUS_INVALID_METADATA,
 	/**< The metadata input to the encoder is invalid, in one of the following ways:
@@ -554,7 +553,7 @@ typedef FLAC__StreamEncoderReadStatus (*FLAC__StreamEncoderReadCallback)(const F
  * \retval FLAC__StreamEncoderWriteStatus
  *    The callee's return status.
  */
-typedef FLAC__StreamEncoderWriteStatus (*FLAC__StreamEncoderWriteCallback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data);
+typedef FLAC__StreamEncoderWriteStatus (*FLAC__StreamEncoderWriteCallback)(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, uint32_t samples, uint32_t current_frame, void *client_data);
 
 /** Signature for the seek callback.
  *
@@ -675,7 +674,7 @@ typedef void (*FLAC__StreamEncoderMetadataCallback)(const FLAC__StreamEncoder *e
  * \param  client_data      The callee's client data set through
  *                          FLAC__stream_encoder_init_*().
  */
-typedef void (*FLAC__StreamEncoderProgressCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data);
+typedef void (*FLAC__StreamEncoderProgressCallback)(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, uint32_t frames_written, uint32_t total_frames_estimate, void *client_data);
 
 
 /***********************************************************************
@@ -743,7 +742,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_ogg_serial_number(FLAC__StreamEncod
  */
 FLAC_API FLAC__bool FLAC__stream_encoder_set_verify(FLAC__StreamEncoder *encoder, FLAC__bool value);
 
-/** Set the <A HREF="../format.html#subset">Subset</A> flag.  If \c true,
+/** Set the <A HREF="https://xiph.org/flac/format.html#subset">Subset</A> flag.  If \c true,
  *  the encoder will comply with the Subset and will check the
  *  settings during FLAC__stream_encoder_init_*() to see if all settings
  *  comply.  If \c false, the settings may take advantage of the full
@@ -771,7 +770,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_streamable_subset(FLAC__StreamEncod
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the sample resolution of the input to be encoded.
  *
@@ -787,7 +786,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_channels(FLAC__StreamEncoder *encod
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the sample rate (in Hz) of the input to be encoded.
  *
@@ -799,7 +798,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_bits_per_sample(FLAC__StreamEncoder
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the compression level
  *
@@ -843,15 +842,15 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *en
  *  <td>max residual partition order</td>
  *  <td>rice parameter search dist</td>
  * </tr>
- * <tr>  <td><b>0</b></td> <td>false</td> <td>false</td> <td>tukey(0.5)<td>                                     <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
- * <tr>  <td><b>1</b></td> <td>true</td>  <td>true</td>  <td>tukey(0.5)<td>                                     <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
- * <tr>  <td><b>2</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5)<td>                                     <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
- * <tr>  <td><b>3</b></td> <td>false</td> <td>false</td> <td>tukey(0.5)<td>                                     <td>6</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>4</td> <td>0</td> </tr>
- * <tr>  <td><b>4</b></td> <td>true</td>  <td>true</td>  <td>tukey(0.5)<td>                                     <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>4</td> <td>0</td> </tr>
- * <tr>  <td><b>5</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5)<td>                                     <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>5</td> <td>0</td> </tr>
- * <tr>  <td><b>6</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5);partial_tukey(2)<td>                    <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
- * <tr>  <td><b>7</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5);partial_tukey(2)<td>                    <td>12</td> <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
- * <tr>  <td><b>8</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5);partial_tukey(2);punchout_tukey(3)</td> <td>12</td> <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
+ * <tr>  <td><b>0</b></td> <td>false</td> <td>false</td> <td>tukey(0.5)</td>         <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
+ * <tr>  <td><b>1</b></td> <td>true</td>  <td>true</td>  <td>tukey(0.5)</td>         <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
+ * <tr>  <td><b>2</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5)</td>         <td>0</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>3</td> <td>0</td> </tr>
+ * <tr>  <td><b>3</b></td> <td>false</td> <td>false</td> <td>tukey(0.5)</td>         <td>6</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>4</td> <td>0</td> </tr>
+ * <tr>  <td><b>4</b></td> <td>true</td>  <td>true</td>  <td>tukey(0.5)</td>         <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>4</td> <td>0</td> </tr>
+ * <tr>  <td><b>5</b></td> <td>true</td>  <td>false</td> <td>tukey(0.5)</td>         <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>5</td> <td>0</td> </tr>
+ * <tr>  <td><b>6</b></td> <td>true</td>  <td>false</td> <td>subdivide_tukey(2)</td> <td>8</td>  <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
+ * <tr>  <td><b>7</b></td> <td>true</td>  <td>false</td> <td>subdivide_tukey(2)</td> <td>12</td> <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
+ * <tr>  <td><b>8</b></td> <td>true</td>  <td>false</td> <td>subdivide_tukey(2)</td> <td>12</td> <td>0</td> <td>false</td> <td>false</td> <td>false</td> <td>0</td> <td>6</td> <td>0</td> </tr>
  * </table>
  *
  * \default \c 5
@@ -862,7 +861,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_sample_rate(FLAC__StreamEncoder *en
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the blocksize to use while encoding.
  *
@@ -877,13 +876,13 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_compression_level(FLAC__StreamEncod
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_blocksize(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set to \c true to enable mid-side encoding on stereo input.  The
  *  number of channels must be 2 for this to have any effect.  Set to
  *  \c false to use only independent channel coding.
  *
- * \default \c false
+ * \default \c true
  * \param  encoder  An encoder instance to set.
  * \param  value    Flag value (see above).
  * \assert
@@ -921,7 +920,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamE
  * \c blackman, \c blackman_harris_4term_92db, \c connes, \c flattop,
  * \c gauss(STDDEV), \c hamming, \c hann, \c kaiser_bessel, \c nuttall,
  * \c rectangle, \c triangle, \c tukey(P), \c partial_tukey(n[/ov[/P]]),
- * \c punchout_tukey(n[/ov[/P]]), \c welch.
+ * \c punchout_tukey(n[/ov[/P]]), \c subdivide_tukey(n[/P]), \c welch.
  *
  * For \c gauss(STDDEV), STDDEV specifies the standard deviation
  * (0<STDDEV<=0.5).
@@ -948,6 +947,20 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamE
  * and partial_tukey(3/0.3/0.5) are all valid. ov should be smaller than 1
  * and can be negative.
  *
+ * subdivide_tukey(n) is a more efficient reimplementation of
+ * partial_tukey and punchout_tukey taken together, recycling as much data
+ * as possible. It combines all possible non-redundant partial_tukey(n)
+ * and punchout_tukey(n) up to the n specified. Specifying
+ * subdivide_tukey(3) is equivalent to specifying tukey, partial_tukey(2),
+ * partial_tukey(3) and punchout_tukey(3), specifying subdivide_tukey(5)
+ * equivalently adds partial_tukey(4), punchout_tukey(4), partial_tukey(5)
+ * and punchout_tukey(5). To be able to reuse data as much as possible,
+ * the tukey taper is taken equal for all windows, and the P specified is
+ * applied for the smallest used window. In other words,
+ * subdivide_tukey(2/0.5) results in a taper equal to that of tukey(0.25)
+ * and subdivide_tukey(5) in a taper equal to that of tukey(0.1). The
+ * default P for subdivide_tukey when none is specified is 0.5.
+ *
  * Example specifications are \c "blackman" or
  * \c "hann;triangle;tukey(0.5);tukey(0.25);tukey(0.125)"
  *
@@ -963,6 +976,8 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_loose_mid_side_stereo(FLAC__StreamE
  * floating point array in which to store the window. Also note that the
  * values of P, STDDEV and ov are locale-specific, so if the comma
  * separator specified by the locale is a comma, a comma should be used.
+ * A locale-independent way is to specify using scientific notation,
+ * e.g. 5e-1 instad of 0.5 or 0,5.
  *
  * \default \c "tukey(0.5)"
  * \param  encoder        An encoder instance to set.
@@ -977,7 +992,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *en
 
 /** Set the maximum LPC order, or \c 0 to use only the fixed predictors.
  *
- * \default \c 0
+ * \default \c 8
  * \param  encoder  An encoder instance to set.
  * \param  value    See above.
  * \assert
@@ -985,16 +1000,12 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_apodization(FLAC__StreamEncoder *en
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the precision, in bits, of the quantized linear predictor
  *  coefficients, or \c 0 to let the encoder select it based on the
  *  blocksize.
  *
- * \note
- * In the current implementation, qlp_coeff_precision + bits_per_sample must
- * be less than 32.
- *
  * \default \c 0
  * \param  encoder  An encoder instance to set.
  * \param  value    See above.
@@ -1003,7 +1014,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_max_lpc_order(FLAC__StreamEncoder *
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_qlp_coeff_precision(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set to \c false to use only the specified quantized linear predictor
  *  coefficient precision, or \c true to search neighboring precision
@@ -1066,7 +1077,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_do_exhaustive_model_search(FLAC__St
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set the maximum partition order to search when coding the residual.
  *  This is used in tandem with
@@ -1081,7 +1092,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__
  *  all orders, using the mean of each context for its Rice parameter,
  *  and use the best.
  *
- * \default \c 0
+ * \default \c 5
  * \param  encoder  An encoder instance to set.
  * \param  value    See above.
  * \assert
@@ -1089,7 +1100,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_min_residual_partition_order(FLAC__
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Deprecated.  Setting this value has no effect.
  *
@@ -1101,7 +1112,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_max_residual_partition_order(FLAC__
  * \retval FLAC__bool
  *    \c false if the encoder is already initialized, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, unsigned value);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_rice_parameter_search_dist(FLAC__StreamEncoder *encoder, uint32_t value);
 
 /** Set an estimate of the total samples that will be encoded.
  *  This is merely an estimate and may be set to \c 0 if unknown.
@@ -1200,7 +1211,25 @@ FLAC_API FLAC__bool FLAC__stream_encoder_set_total_samples_estimate(FLAC__Stream
  *    \c false if the encoder is already initialized, or if
  *    \a num_blocks > 65535 if encoding to Ogg FLAC, else \c true.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, unsigned num_blocks);
+FLAC_API FLAC__bool FLAC__stream_encoder_set_metadata(FLAC__StreamEncoder *encoder, FLAC__StreamMetadata **metadata, uint32_t num_blocks);
+
+/** Set to \c true to make the encoder not output frames which contain
+ *  only constant subframes. This is beneficial for streaming
+ *  applications: very small frames can cause problems with buffering
+ *  as bitrates can drop as low 1kbit/s for CDDA audio encoded within
+ *  subset. The minimum bitrate for a FLAC file encoded with this
+ *  function used is raised to 1bit/sample (i.e. 48kbit/s for 48kHz
+ *  material).
+ *
+ * \default \c false
+ * \param  encoder  An encoder instance to set.
+ * \param  value    Flag value (see above).
+ * \assert
+ *    \code encoder != NULL \endcode
+ * \retval FLAC__bool
+ *    \c false if the encoder is already initialized, else \c true.
+ */
+FLAC_API FLAC__bool FLAC__stream_encoder_set_limit_min_bitrate(FLAC__StreamEncoder *encoder, FLAC__bool value);
 
 /** Get the current encoder state.
  *
@@ -1254,7 +1283,7 @@ FLAC_API const char *FLAC__stream_encoder_get_resolved_state_string(const FLAC__
  * \assert
  *    \code encoder != NULL \endcode
  */
-FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, unsigned *frame_number, unsigned *channel, unsigned *sample, FLAC__int32 *expected, FLAC__int32 *got);
+FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_sample, uint32_t *frame_number, uint32_t *channel, uint32_t *sample, FLAC__int32 *expected, FLAC__int32 *got);
 
 /** Get the "verify" flag.
  *
@@ -1266,7 +1295,7 @@ FLAC_API void FLAC__stream_encoder_get_verify_decoder_error_stats(const FLAC__St
  */
 FLAC_API FLAC__bool FLAC__stream_encoder_get_verify(const FLAC__StreamEncoder *encoder);
 
-/** Get the <A HREF="../format.html#subset>Subset</A> flag.
+/** Get the <A HREF="https://xiph.org/flac/format.html#subset">Subset</A> flag.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
@@ -1281,40 +1310,40 @@ FLAC_API FLAC__bool FLAC__stream_encoder_get_streamable_subset(const FLAC__Strea
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_channels().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_channels(const FLAC__StreamEncoder *encoder);
 
 /** Get the input sample resolution setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_bits_per_sample().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_bits_per_sample(const FLAC__StreamEncoder *encoder);
 
 /** Get the input sample rate setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_sample_rate().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_sample_rate(const FLAC__StreamEncoder *encoder);
 
 /** Get the blocksize setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_blocksize().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_blocksize(const FLAC__StreamEncoder *encoder);
 
 /** Get the "mid/side stereo coding" flag.
  *
@@ -1341,20 +1370,20 @@ FLAC_API FLAC__bool FLAC__stream_encoder_get_loose_mid_side_stereo(const FLAC__S
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_max_lpc_order().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_max_lpc_order(const FLAC__StreamEncoder *encoder);
 
 /** Get the quantized linear predictor coefficient precision setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_qlp_coeff_precision().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_qlp_coeff_precision(const FLAC__StreamEncoder *encoder);
 
 /** Get the qlp coefficient precision search flag.
  *
@@ -1391,30 +1420,30 @@ FLAC_API FLAC__bool FLAC__stream_encoder_get_do_exhaustive_model_search(const FL
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_min_residual_partition_order().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_min_residual_partition_order(const FLAC__StreamEncoder *encoder);
 
 /** Get maximum residual partition order setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_max_residual_partition_order().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_max_residual_partition_order(const FLAC__StreamEncoder *encoder);
 
 /** Get the Rice parameter search distance setting.
  *
  * \param  encoder  An encoder instance to query.
  * \assert
  *    \code encoder != NULL \endcode
- * \retval unsigned
+ * \retval uint32_t
  *    See FLAC__stream_encoder_set_rice_parameter_search_dist().
  */
-FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
+FLAC_API uint32_t FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC__StreamEncoder *encoder);
 
 /** Get the previously set estimate of the total samples to be encoded.
  *  The encoder merely mimics back the value given to
@@ -1429,6 +1458,16 @@ FLAC_API unsigned FLAC__stream_encoder_get_rice_parameter_search_dist(const FLAC
  */
 FLAC_API FLAC__uint64 FLAC__stream_encoder_get_total_samples_estimate(const FLAC__StreamEncoder *encoder);
 
+/** Get the "limit_min_bitrate" flag.
+ *
+ * \param  encoder  An encoder instance to query.
+ * \assert
+ *    \code encoder != NULL \endcode
+ * \retval FLAC__bool
+ *    See FLAC__stream_encoder_set_limit_min_bitrate().
+ */
+FLAC_API FLAC__bool FLAC__stream_encoder_get_limit_min_bitrate(const FLAC__StreamEncoder *encoder);
+
 /** Initialize the encoder instance to encode native FLAC streams.
  *
  *  This flavor of initialization sets up the encoder to encode to a
@@ -1633,11 +1672,15 @@ FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_ogg_FILE(FLAC__
 /** Initialize the encoder instance to encode native FLAC files.
  *
  *  This flavor of initialization sets up the encoder to encode to a plain
- *  FLAC file.  If POSIX fopen() semantics are not sufficient (for example,
- *  with Unicode filenames on Windows), you must use
+ *  FLAC file.  If POSIX fopen() semantics are not sufficient you must use
  *  FLAC__stream_encoder_init_FILE(), or FLAC__stream_encoder_init_stream()
  *  and provide callbacks for the I/O.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  *  This function should be called after FLAC__stream_encoder_new() and
  *  FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
  *  or FLAC__stream_encoder_process_interleaved().
@@ -1665,11 +1708,15 @@ FLAC_API FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_file(FLAC__Stre
 /** Initialize the encoder instance to encode Ogg FLAC files.
  *
  *  This flavor of initialization sets up the encoder to encode to a plain
- *  Ogg FLAC file.  If POSIX fopen() semantics are not sufficient (for example,
- *  with Unicode filenames on Windows), you must use
+ *  Ogg FLAC file.  If POSIX fopen() semantics are not sufficient, you must use
  *  FLAC__stream_encoder_init_ogg_FILE(), or FLAC__stream_encoder_init_ogg_stream()
  *  and provide callbacks for the I/O.
  *
+ *  On Windows, filename must be a UTF-8 encoded filename, which libFLAC
+ *  internally translates to an appropriate representation to use with
+ *  _wfopen. On all other systems, filename is passed to fopen without
+ *  any translation.
+ *
  *  This function should be called after FLAC__stream_encoder_new() and
  *  FLAC__stream_encoder_set_*() but before FLAC__stream_encoder_process()
  *  or FLAC__stream_encoder_process_interleaved().
@@ -1734,7 +1781,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder);
  *
  *  For applications where channel order is important, channels must
  *  follow the order as described in the
- *  <A HREF="../format.html#frame_header">frame header</A>.
+ *  <A HREF="https://xiph.org/flac/format.html#frame_header">frame header</A>.
  *
  * \param  encoder  An initialized encoder instance in the OK state.
  * \param  buffer   An array of pointers to each channel's signal.
@@ -1747,7 +1794,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_finish(FLAC__StreamEncoder *encoder);
  *    encoder state with FLAC__stream_encoder_get_state() to see what
  *    went wrong.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], unsigned samples);
+FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, const FLAC__int32 * const buffer[], uint32_t samples);
 
 /** Submit data for encoding.
  *  This version allows you to supply the input data where the channels
@@ -1763,7 +1810,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, c
  *
  *  For applications where channel order is important, channels must
  *  follow the order as described in the
- *  <A HREF="../format.html#frame_header">frame header</A>.
+ *  <A HREF="https://xiph.org/flac/format.html#frame_header">frame header</A>.
  *
  * \param  encoder  An initialized encoder instance in the OK state.
  * \param  buffer   An array of channel-interleaved data (see above).
@@ -1779,7 +1826,7 @@ FLAC_API FLAC__bool FLAC__stream_encoder_process(FLAC__StreamEncoder *encoder, c
  *    encoder state with FLAC__stream_encoder_get_state() to see what
  *    went wrong.
  */
-FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], unsigned samples);
+FLAC_API FLAC__bool FLAC__stream_encoder_process_interleaved(FLAC__StreamEncoder *encoder, const FLAC__int32 buffer[], uint32_t samples);
 
 /* \} */
 

components/codecs/inc/ogg/config_types.h

@@ -1,7 +1,7 @@
 #ifndef __CONFIG_TYPES_H__
 #define __CONFIG_TYPES_H__
 
-/* these are filled in by configure */
+/* these are filled in by configure or cmake*/
 #define INCLUDE_INTTYPES_H 1
 #define INCLUDE_STDINT_H 1
 #define INCLUDE_SYS_TYPES_H 1
@@ -21,5 +21,6 @@ typedef uint16_t ogg_uint16_t;
 typedef int32_t ogg_int32_t;
 typedef uint32_t ogg_uint32_t;
 typedef int64_t ogg_int64_t;
+typedef uint64_t ogg_uint64_t;
 
 #endif

components/codecs/inc/ogg/ogg.h

@@ -11,7 +11,6 @@
  ********************************************************************
 
  function: toplevel libogg include
- last mod: $Id$
 
  ********************************************************************/
 #ifndef _OGG_H

components/codecs/inc/ogg/os_types.h

@@ -10,8 +10,7 @@
  *                                                                  *
  ********************************************************************
 
- function: #ifdef jail to whip a few platforms into the UNIX ideal.
- last mod: $Id$
+ function: Define a consistent set of types on each platform.
 
  ********************************************************************/
 #ifndef _OS_TYPES_H
@@ -44,6 +43,7 @@
      typedef unsigned long long ogg_uint64_t;
 #  elif defined(__MWERKS__)
      typedef long long ogg_int64_t;
+     typedef unsigned long long ogg_uint64_t;
      typedef int ogg_int32_t;
      typedef unsigned int ogg_uint32_t;
      typedef short ogg_int16_t;
@@ -62,6 +62,7 @@
        typedef __int64 ogg_int64_t;
        typedef __int32 ogg_int32_t;
        typedef unsigned __int32 ogg_uint32_t;
+       typedef unsigned __int64 ogg_uint64_t;
        typedef __int16 ogg_int16_t;
        typedef unsigned __int16 ogg_uint16_t;
 #    endif
@@ -69,12 +70,13 @@
 
 #elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
 
-#  include <inttypes.h>
+#  include <sys/types.h>
    typedef int16_t ogg_int16_t;
-   typedef uint16_t ogg_uint16_t;
+   typedef u_int16_t ogg_uint16_t;
    typedef int32_t ogg_int32_t;
-   typedef uint32_t ogg_uint32_t;
+   typedef u_int32_t ogg_uint32_t;
    typedef int64_t ogg_int64_t;
+   typedef u_int64_t ogg_uint64_t;
 
 #elif defined(__HAIKU__)
 
@@ -85,6 +87,7 @@
    typedef int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long ogg_int64_t;
+   typedef unsigned long long ogg_uint64_t;
 
 #elif defined(__BEOS__)
 
@@ -95,6 +98,7 @@
    typedef int32_t ogg_int32_t;
    typedef uint32_t ogg_uint32_t;
    typedef int64_t ogg_int64_t;
+   typedef uint64_t ogg_uint64_t;
 
 #elif defined (__EMX__)
 
@@ -104,6 +108,8 @@
    typedef int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long ogg_int64_t;
+   typedef unsigned long long ogg_uint64_t;
+
 
 #elif defined (DJGPP)
 
@@ -112,11 +118,13 @@
    typedef int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long ogg_int64_t;
+   typedef unsigned long long ogg_uint64_t;
 
 #elif defined(R5900)
 
    /* PS2 EE */
    typedef long ogg_int64_t;
+   typedef unsigned long ogg_uint64_t;
    typedef int ogg_int32_t;
    typedef unsigned ogg_uint32_t;
    typedef short ogg_int16_t;
@@ -129,6 +137,7 @@
    typedef signed int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long int ogg_int64_t;
+   typedef unsigned long long int ogg_uint64_t;
 
 #elif defined(__TMS320C6X__)
 
@@ -138,6 +147,7 @@
    typedef signed int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long int ogg_int64_t;
+   typedef unsigned long long int ogg_uint64_t;
 
 #else
 

components/codecs/inc/opus/opus.h

@@ -198,7 +198,7 @@ OPUS_EXPORT OPUS_WARN_UNUSED_RESULT int opus_encoder_get_size(int channels);
  *                                     This must be one of 8000, 12000, 16000,
  *                                     24000, or 48000.
  * @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal
- * @param [in] application <tt>int</tt>: Coding mode (@ref OPUS_APPLICATION_VOIP/@ref OPUS_APPLICATION_AUDIO/@ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)
+ * @param [in] application <tt>int</tt>: Coding mode (one of @ref OPUS_APPLICATION_VOIP, @ref OPUS_APPLICATION_AUDIO, or @ref OPUS_APPLICATION_RESTRICTED_LOWDELAY)
  * @param [out] error <tt>int*</tt>: @ref opus_errorcodes
  * @note Regardless of the sampling rate and number channels selected, the Opus encoder
  * can switch to a lower audio bandwidth or number of channels if the bitrate
@@ -222,7 +222,7 @@ OPUS_EXPORT OPUS_WARN_UNUSED_RESULT OpusEncoder *opus_encoder_create(
  *                                      This must be one of 8000, 12000, 16000,
  *                                      24000, or 48000.
   * @param [in] channels <tt>int</tt>: Number of channels (1 or 2) in input signal
-  * @param [in] application <tt>int</tt>: Coding mode (OPUS_APPLICATION_VOIP/OPUS_APPLICATION_AUDIO/OPUS_APPLICATION_RESTRICTED_LOWDELAY)
+  * @param [in] application <tt>int</tt>: Coding mode (one of OPUS_APPLICATION_VOIP, OPUS_APPLICATION_AUDIO, or OPUS_APPLICATION_RESTRICTED_LOWDELAY)
   * @retval #OPUS_OK Success or @ref opus_errorcodes
   */
 OPUS_EXPORT int opus_encoder_init(

components/codecs/inc/opus/opus_custom.h

@@ -104,7 +104,8 @@ typedef struct OpusCustomDecoder OpusCustomDecoder;
 /** The mode contains all the information necessary to create an
     encoder. Both the encoder and decoder need to be initialized
     with exactly the same mode, otherwise the output will be
-    corrupted.
+    corrupted. The mode MUST NOT BE DESTROYED until the encoders and
+    decoders that use it are destroyed as well.
    @brief Mode configuration
  */
 typedef struct OpusCustomMode OpusCustomMode;
@@ -178,7 +179,7 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomEncoder *opus_custom_encode
 ) OPUS_ARG_NONNULL(1);
 
 
-/** Destroys a an encoder state.
+/** Destroys an encoder state.
   * @param[in] st <tt>OpusCustomEncoder*</tt>: State to be freed.
   */
 OPUS_CUSTOM_EXPORT void opus_custom_encoder_destroy(OpusCustomEncoder *st);
@@ -286,7 +287,7 @@ OPUS_CUSTOM_EXPORT OPUS_WARN_UNUSED_RESULT OpusCustomDecoder *opus_custom_decode
     int *error
 ) OPUS_ARG_NONNULL(1);
 
-/** Destroys a an decoder state.
+/** Destroys a decoder state.
   * @param[in] st <tt>OpusCustomDecoder*</tt>: State to be freed.
   */
 OPUS_CUSTOM_EXPORT void opus_custom_decoder_destroy(OpusCustomDecoder *st);

components/codecs/inc/opus/opus_defines.h

@@ -64,7 +64,7 @@ extern "C" {
 /**Export control for opus functions */
 
 #ifndef OPUS_EXPORT
-# if defined(WIN32)
+# if defined(_WIN32)
 #  if defined(OPUS_BUILD) && defined(DLL_EXPORT)
 #   define OPUS_EXPORT __declspec(dllexport)
 #  else
@@ -482,7 +482,8 @@ extern "C" {
   * @param[in] x <tt>opus_int32</tt>: Allowed values:
   * <dl>
   * <dt>0</dt><dd>Disable inband FEC (default).</dd>
-  * <dt>1</dt><dd>Enable inband FEC.</dd>
+  * <dt>1</dt><dd>Inband FEC enabled. If the packet loss rate is sufficiently high, Opus will automatically switch to SILK even at high rates to enable use of that FEC.</dd>
+  * <dt>2</dt><dd>Inband FEC enabled, but does not necessarily switch to SILK if we have music.</dd>
   * </dl>
   * @hideinitializer */
 #define OPUS_SET_INBAND_FEC(x) OPUS_SET_INBAND_FEC_REQUEST, __opus_check_int(x)
@@ -491,7 +492,8 @@ extern "C" {
   * @param[out] x <tt>opus_int32 *</tt>: Returns one of the following values:
   * <dl>
   * <dt>0</dt><dd>Inband FEC disabled (default).</dd>
-  * <dt>1</dt><dd>Inband FEC enabled.</dd>
+  * <dt>1</dt><dd>Inband FEC enabled. If the packet loss rate is sufficiently high, Opus will automatically switch to SILK even at high rates to enable use of that FEC.</dd>
+  * <dt>2</dt><dd>Inband FEC enabled, but does not necessarily switch to SILK if we have music.</dd>
   * </dl>
   * @hideinitializer */
 #define OPUS_GET_INBAND_FEC(x) OPUS_GET_INBAND_FEC_REQUEST, __opus_check_int_ptr(x)

components/codecs/inc/opusfile/opusfile.h

@@ -6,7 +6,7 @@
  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
  * THE libopusfile SOURCE CODE IS (C) COPYRIGHT 1994-2012           *
- * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
+ * by the Xiph.Org Foundation and contributors https://xiph.org/    *
  *                                                                  *
  ********************************************************************
 
@@ -28,7 +28,7 @@
     reference
     <tt><a href="https://www.xiph.org/ogg/doc/libogg/reference.html">libogg</a></tt>
     and
-    <tt><a href="https://mf4.xiph.org/jenkins/view/opus/job/opus/ws/doc/html/index.html">libopus</a></tt>
+    <tt><a href="https://opus-codec.org/docs/opus_api-1.3.1/">libopus</a></tt>
     libraries.
 
    <tt>libopusfile</tt> provides several sets of built-in routines for
@@ -58,7 +58,7 @@
     it is stored in the header to allow you to resample to it after decoding
     (the <tt>libopusfile</tt> API does not currently provide a resampler,
     but the
-    <a href="http://www.speex.org/docs/manual/speex-manual/node7.html#SECTION00760000000000000000">the
+    <a href="https://www.speex.org/docs/manual/speex-manual/node7.html#SECTION00760000000000000000">the
     Speex resampler</a> is a good choice if you need one).
    In general, if you are playing back the audio, you should leave it at
     48&nbsp;kHz, provided your audio hardware supports it.
@@ -68,7 +68,7 @@
 
    Opus files can contain anywhere from 1 to 255 channels of audio.
    The channel mappings for up to 8 channels are the same as the
-    <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
+    <a href="https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9">Vorbis
     mappings</a>.
    A special stereo API can convert everything to 2 channels, making it simple
     to support multichannel files in an application which only has stereo
@@ -147,18 +147,18 @@ typedef struct OggOpusFile       OggOpusFile;
 /**@endcond*/
 
 /**\defgroup error_codes Error Codes*/
-/*@{*/
+/**@{*/
 /**\name List of possible error codes
    Many of the functions in this library return a negative error code when a
     function fails.
    This list provides a brief explanation of the common errors.
    See each individual function for more details on what a specific error code
     means in that context.*/
-/*@{*/
+/**@{*/
 
 /**A request did not succeed.*/
 #define OP_FALSE         (-1)
-/*Currently not used externally.*/
+/**Currently not used externally.**/
 #define OP_EOF           (-2)
 /**There was a hole in the page sequence numbers (e.g., a page was corrupt or
     missing).*/
@@ -185,7 +185,7 @@ typedef struct OggOpusFile       OggOpusFile;
 #define OP_EBADHEADER    (-133)
 /**The ID header contained an unrecognized version number.*/
 #define OP_EVERSION      (-134)
-/*Currently not used at all.*/
+/**Currently not used at all.**/
 #define OP_ENOTAUDIO     (-135)
 /**An audio packet failed to decode properly.
    This is usually caused by a multistream Ogg packet where the durations of
@@ -200,11 +200,11 @@ typedef struct OggOpusFile       OggOpusFile;
 /**The first or last granule position of a link failed basic validity checks.*/
 #define OP_EBADTIMESTAMP (-139)
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup header_info Header Information*/
-/*@{*/
+/**@{*/
 
 /**The maximum number of channels in an Ogg Opus stream.*/
 #define OPUS_CHANNEL_COUNT_MAX (255)
@@ -284,7 +284,7 @@ struct OpusHead{
    A particular tag may occur more than once, and order is significant.
    The character set encoding for the strings is always UTF-8, but the tag
     names are limited to ASCII, and treated as case-insensitive.
-   See <a href="http://www.xiph.org/vorbis/doc/v-comment.html">the Vorbis
+   See <a href="https://www.xiph.org/vorbis/doc/v-comment.html">the Vorbis
     comment header specification</a> for details.
 
    In filling in this structure, <tt>libopusfile</tt> will null-terminate the
@@ -311,7 +311,7 @@ struct OpusTags{
 };
 
 /**\name Picture tag image formats*/
-/*@{*/
+/**@{*/
 
 /**The MIME type was not recognized, or the image data did not match the
     declared MIME type.*/
@@ -325,7 +325,7 @@ struct OpusTags{
 /**The image is a GIF.*/
 #define OP_PIC_FORMAT_GIF     (3)
 
-/*@}*/
+/**@}*/
 
 /**The contents of a METADATA_BLOCK_PICTURE tag.*/
 struct OpusPictureTag{
@@ -398,7 +398,7 @@ struct OpusPictureTag{
    These can be used to query the headers returned by <tt>libopusfile</tt>, or
     to parse Opus headers from sources other than an Ogg Opus stream, provided
     they use the same format.*/
-/*@{*/
+/**@{*/
 
 /**Parses the contents of the ID header packet of an Ogg Opus stream.
    \param[out] _head Returns the contents of the parsed packet.
@@ -671,12 +671,12 @@ void opus_picture_tag_init(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
    \param _pic The #OpusPictureTag structure to clear.*/
 void opus_picture_tag_clear(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
 
-/*@}*/
+/**@}*/
 
-/*@}*/
+/**@}*/
 
 /**\defgroup url_options URL Reading Options*/
-/*@{*/
+/**@{*/
 /**\name URL reading options
    Options for op_url_stream_create() and associated functions.
    These allow you to provide proxy configuration parameters, skip SSL
@@ -685,7 +685,7 @@ void opus_picture_tag_clear(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
     times, only the value specified by the last occurrence has an effect
     (unless otherwise specified).
    They may be expanded in the future.*/
-/*@{*/
+/**@{*/
 
 /**@cond PRIVATE*/
 
@@ -698,7 +698,7 @@ void opus_picture_tag_clear(OpusPictureTag *_pic) OP_ARG_NONNULL(1);
 #define OP_HTTP_PROXY_PASS_REQUEST            (6720)
 #define OP_GET_SERVER_INFO_REQUEST            (6784)
 
-#define OP_URL_OPT(_request) ((_request)+(char *)0)
+#define OP_URL_OPT(_request) ((char *)(_request))
 
 /*These macros trigger compilation errors or warnings if the wrong types are
    provided to one of the URL options.*/
@@ -843,11 +843,11 @@ void opus_server_info_clear(OpusServerInfo *_info) OP_ARG_NONNULL(1);
 #define OP_GET_SERVER_INFO(_info) \
  OP_URL_OPT(OP_GET_SERVER_INFO_REQUEST),OP_CHECK_SERVER_INFO_PTR(_info)
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup stream_callbacks Abstract Stream Reading Interface*/
-/*@{*/
+/**@{*/
 /**\name Functions for reading from streams
    These functions define the interface used to read from and seek in a stream
     of data.
@@ -856,7 +856,7 @@ void opus_server_info_clear(OpusServerInfo *_info) OP_ARG_NONNULL(1);
    These functions also include some convenience routines for working with
     standard <code>FILE</code> pointers, complete streams stored in a single
     block of memory, or URLs.*/
-/*@{*/
+/**@{*/
 
 /**Reads up to \a _nbytes bytes of data from \a _stream.
    \param      _stream The stream to read from.
@@ -1034,18 +1034,18 @@ OP_WARN_UNUSED_RESULT void *op_url_stream_vcreate(OpusFileCallbacks *_cb,
 OP_WARN_UNUSED_RESULT void *op_url_stream_create(OpusFileCallbacks *_cb,
  const char *_url,...) OP_ARG_NONNULL(1) OP_ARG_NONNULL(2);
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup stream_open_close Opening and Closing*/
-/*@{*/
+/**@{*/
 /**\name Functions for opening and closing streams
 
    These functions allow you to test a stream to see if it is Opus, open it,
     and close it.
    Several flavors are provided for each of the built-in stream types, plus a
     more general version which takes a set of application-provided callbacks.*/
-/*@{*/
+/**@{*/
 
 /**Test to see if this is an Opus stream.
    For good results, you will need at least 57 bytes (for a pure Opus-only
@@ -1159,20 +1159,16 @@ OP_WARN_UNUSED_RESULT OggOpusFile *op_open_url(const char *_url,
                          This value will be passed verbatim as the first
                           argument to all of the callbacks.
    \param _cb            The callbacks with which to access the stream.
-                         <code><a href="#op_read_func">read()</a></code> must
-                          be implemented.
-                         <code><a href="#op_seek_func">seek()</a></code> and
-                          <code><a href="#op_tell_func">tell()</a></code> may
-                          be <code>NULL</code>, or may always return -1 to
-                          indicate a stream is unseekable, but if
-                          <code><a href="#op_seek_func">seek()</a></code> is
-                          implemented and succeeds on a particular stream, then
-                          <code><a href="#op_tell_func">tell()</a></code> must
-                          also.
-                         <code><a href="#op_close_func">close()</a></code> may
-                          be <code>NULL</code>, but if it is not, it will be
-                          called when the \c OggOpusFile is destroyed by
-                          op_free().
+                         \ref op_read_func "read()" must be implemented.
+                         \ref op_seek_func "seek()" and \ref op_tell_func
+                          "tell()" may be <code>NULL</code>, or may always
+                          return -1 to indicate a stream is unseekable, but if
+                          \ref op_seek_func "seek()" is implemented and
+                          succeeds on a particular stream, then \ref
+                          op_tell_func "tell()" must also.
+                         \ref op_close_func "close()" may be <code>NULL</code>,
+                          but if it is not, it will be called when the \c
+                          OggOpusFile is destroyed by op_free().
                          It will not be called if op_open_callbacks() fails
                           with an error.
    \param _initial_data  An initial buffer of data from the start of the
@@ -1183,10 +1179,8 @@ OP_WARN_UNUSED_RESULT OggOpusFile *op_open_url(const char *_url,
                           stream to be opened, even if it is unseekable.
    \param _initial_bytes The number of bytes in \a _initial_data.
                          If the stream is seekable, its current position (as
-                          reported by
-                          <code><a href="#opus_tell_func">tell()</a></code>
-                          at the start of this function) must be equal to
-                          \a _initial_bytes.
+                          reported by \ref op_tell_func "tell()" at the start
+                          of this function) must be equal to \a _initial_bytes.
                          Otherwise, seeking to absolute positions will
                           generate inconsistent results.
    \param[out] _error    Returns 0 on success, or a failure code on error.
@@ -1206,11 +1200,10 @@ OP_WARN_UNUSED_RESULT OggOpusFile *op_open_url(const char *_url,
                             implemented, such as an unsupported channel
                             family.</dd>
                            <dt>#OP_EINVAL</dt>
-                           <dd><code><a href="#op_seek_func">seek()</a></code>
-                            was implemented and succeeded on this source, but
-                            <code><a href="#op_tell_func">tell()</a></code>
-                            did not, or the starting position indicator was
-                            not equal to \a _initial_bytes.</dd>
+                           <dd>\ref op_seek_func "seek()" was implemented and
+                            succeeded on this source, but \ref op_tell_func
+                            "tell()" did not, or the starting position
+                            indicator was not equal to \a _initial_bytes.</dd>
                            <dt>#OP_ENOTFORMAT</dt>
                            <dd>The stream contained a link that did not have
                             any logical Opus streams in it.</dd>
@@ -1341,20 +1334,16 @@ OP_WARN_UNUSED_RESULT OggOpusFile *op_test_url(const char *_url,
                          This value will be passed verbatim as the first
                           argument to all of the callbacks.
    \param _cb            The callbacks with which to access the stream.
-                         <code><a href="#op_read_func">read()</a></code> must
-                          be implemented.
-                         <code><a href="#op_seek_func">seek()</a></code> and
-                          <code><a href="#op_tell_func">tell()</a></code> may
-                          be <code>NULL</code>, or may always return -1 to
-                          indicate a stream is unseekable, but if
-                          <code><a href="#op_seek_func">seek()</a></code> is
-                          implemented and succeeds on a particular stream, then
-                          <code><a href="#op_tell_func">tell()</a></code> must
-                          also.
-                         <code><a href="#op_close_func">close()</a></code> may
-                          be <code>NULL</code>, but if it is not, it will be
-                          called when the \c OggOpusFile is destroyed by
-                          op_free().
+                         \ref op_read_func "read()" must be implemented.
+                         \ref op_seek_func "seek()" and \ref op_tell_func
+                          "tell()" may be <code>NULL</code>, or may always
+                          return -1 to indicate a stream is unseekable, but if
+                          \ref op_seek_func "seek()" is implemented and
+                          succeeds on a particular stream, then \ref
+                          op_tell_func "tell()" must also.
+                         \ref op_close_func "close()" may be <code>NULL</code>,
+                          but if it is not, it will be called when the \c
+                          OggOpusFile is destroyed by op_free().
                          It will not be called if op_open_callbacks() fails
                           with an error.
    \param _initial_data  An initial buffer of data from the start of the
@@ -1367,9 +1356,8 @@ OP_WARN_UNUSED_RESULT OggOpusFile *op_test_url(const char *_url,
    \param _initial_bytes The number of bytes in \a _initial_data.
                          If the stream is seekable, its current position (as
                           reported by
-                          <code><a href="#opus_tell_func">tell()</a></code>
-                          at the start of this function) must be equal to
-                          \a _initial_bytes.
+                          \ref op_tell_func "tell()" at the start of this
+                          function) must be equal to \a _initial_bytes.
                          Otherwise, seeking to absolute positions will
                           generate inconsistent results.
    \param[out] _error    Returns 0 on success, or a failure code on error.
@@ -1418,11 +1406,11 @@ int op_test_open(OggOpusFile *_of) OP_ARG_NONNULL(1);
    \param _of The \c OggOpusFile to free.*/
 void op_free(OggOpusFile *_of);
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup stream_info Stream Information*/
-/*@{*/
+/**@{*/
 /**\name Functions for obtaining information about streams
 
    These functions allow you to get basic information about a stream, including
@@ -1437,18 +1425,17 @@ void op_free(OggOpusFile *_of);
     streams returned by op_test_callbacks() or one of the associated
     convenience functions.
    Their documention will indicate so explicitly.*/
-/*@{*/
+/**@{*/
 
 /**Returns whether or not the stream being read is seekable.
    This is true if
    <ol>
-   <li>The <code><a href="#op_seek_func">seek()</a></code> and
-    <code><a href="#op_tell_func">tell()</a></code> callbacks are both
-    non-<code>NULL</code>,</li>
-   <li>The <code><a href="#op_seek_func">seek()</a></code> callback was
-    successfully executed at least once, and</li>
-   <li>The <code><a href="#op_tell_func">tell()</a></code> callback was
-    successfully able to report the position indicator afterwards.</li>
+   <li>The \ref op_seek_func "seek()" and \ref op_tell_func "tell()"
+    callbacks are both non-<code>NULL</code>,</li>
+   <li>The \ref op_seek_func "seek()" callback was successfully executed at
+    least once, and</li>
+   <li>The \ref op_tell_func "tell()" callback was successfully able to report
+    the position indicator afterwards.</li>
    </ol>
    This function may be called on partially-opened streams.
    \param _of The \c OggOpusFile whose seekable status is to be returned.
@@ -1638,11 +1625,11 @@ opus_int64 op_raw_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1);
    \retval #OP_EINVAL The stream was only partially open.*/
 ogg_int64_t op_pcm_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1);
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup stream_seeking Seeking*/
-/*@{*/
+/**@{*/
 /**\name Functions for seeking in Opus streams
 
    These functions let you seek in Opus streams, if the underlying stream
@@ -1667,7 +1654,7 @@ ogg_int64_t op_pcm_tell(const OggOpusFile *_of) OP_ARG_NONNULL(1);
     values as would be obtained by decoding the stream straight through.
    However, such differences are expected to be smaller than the loss
     introduced by Opus's lossy compression.*/
-/*@{*/
+/**@{*/
 
 /**Seek to a byte offset relative to the <b>compressed</b> data.
    This also scans packets to update the PCM cursor.
@@ -1702,11 +1689,11 @@ int op_raw_seek(OggOpusFile *_of,opus_int64 _byte_offset) OP_ARG_NONNULL(1);
                          seeking to the target destination was impossible.*/
 int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset) OP_ARG_NONNULL(1);
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 /**\defgroup stream_decoding Decoding*/
-/*@{*/
+/**@{*/
 /**\name Functions for decoding audio data
 
    These functions retrieve actual decoded audio data from the stream.
@@ -1744,7 +1731,7 @@ int op_pcm_seek(OggOpusFile *_of,ogg_int64_t _pcm_offset) OP_ARG_NONNULL(1);
    If you are reading from an <https:> URL (particularly if seeking is not
     supported), you should make sure to check for this error and warn the user
     appropriately.*/
-/*@{*/
+/**@{*/
 
 /**Indicates that the decoding callback should produce signed 16-bit
     native-endian output samples.*/
@@ -1890,7 +1877,7 @@ void op_set_dither_enabled(OggOpusFile *_of,int _enabled) OP_ARG_NONNULL(1);
                           signed native-endian 16-bit values at 48&nbsp;kHz
                           with a nominal range of <code>[-32768,32767)</code>.
                          Multiple channels are interleaved using the
-                          <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
+                          <a href="https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9">Vorbis
                           channel ordering</a>.
                          This must have room for at least \a _buf_size values.
    \param      _buf_size The number of values that can be stored in \a _pcm.
@@ -1972,7 +1959,7 @@ OP_WARN_UNUSED_RESULT int op_read(OggOpusFile *_of,
                           signed floats at 48&nbsp;kHz with a nominal range of
                           <code>[-1.0,1.0]</code>.
                          Multiple channels are interleaved using the
-                          <a href="http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-800004.3.9">Vorbis
+                          <a href="https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9">Vorbis
                           channel ordering</a>.
                          This must have room for at least \a _buf_size floats.
    \param      _buf_size The number of floats that can be stored in \a _pcm.
@@ -2150,8 +2137,8 @@ OP_WARN_UNUSED_RESULT int op_read_stereo(OggOpusFile *_of,
 OP_WARN_UNUSED_RESULT int op_read_float_stereo(OggOpusFile *_of,
  float *_pcm,int _buf_size) OP_ARG_NONNULL(1);
 
-/*@}*/
-/*@}*/
+/**@}*/
+/**@}*/
 
 # if OP_GNUC_PREREQ(4,0)
 #  pragma GCC visibility pop

components/display/CMakeLists.txt

@@ -1,10 +1,16 @@
-idf_component_register(SRC_DIRS . core core/ifaces  fonts
-						INCLUDE_DIRS . fonts core
-						REQUIRES platform_config tools esp_common
-						PRIV_REQUIRES services freertos driver           
-)
+# the JPEG library is in ROM but seems to fail randomly (PSRAM issue?)
+set(TJPGD tjpgd)
+
+idf_component_register(SRC_DIRS . core core/ifaces 
+						INCLUDE_DIRS . core
+						REQUIRES tools platform_config  esp_common spiffs
+						PRIV_REQUIRES services freertos driver ${TJPGD}
+						EMBED_FILES note.jpg )		
+
+if (NOT TJPGD)
+add_compile_definitions(TJPGD_ROM)												
+endif()
 
 set_source_files_properties(display.c
     PROPERTIES COMPILE_FLAGS
-   -Wno-format-overflow
-)
+   -Wno-format-overflow )

components/display/ILI9341.c

@@ -19,323 +19,364 @@
 
 #define SHADOW_BUFFER
 #define USE_IRAM
-#define PAGE_BLOCK		2048
-#define ENABLE_WRITE	0x2c
-#define MADCTL_MX  0x40
-#define TFT_RGB_BGR  0x08
+#define PAGE_BLOCK 2048
+#define ENABLE_WRITE 0x2c
+#define MADCTL_MX 0x40
+#define TFT_RGB_BGR 0x08
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a, b) (((a) < (b)) ? (a) : (b))
 
 static char TAG[] = "ILI9341";
 
-enum { ILI9341, ILI9341_24 };	//ILI9341_24 for future use...
+enum { ILI9341, ILI9341_24 }; //ILI9341_24 for future use...
 
 struct PrivateSpace {
-	uint8_t *iRAM, *Shadowbuffer;
-	struct {
-		uint16_t Height, Width;
-	} Offset;
-	uint8_t MADCtl, PageSize;
-	uint8_t Model;
+    uint8_t *iRAM, *Shadowbuffer;
+    struct {
+        uint16_t Height, Width;
+    } Offset;
+    uint8_t MADCtl, PageSize;
+    uint8_t Model;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void WriteByte( struct GDS_Device* Device, uint8_t Data ) {
-	Device->WriteData( Device, &Data, 1 );
+static void WriteByte(struct GDS_Device* Device, uint8_t Data) { Device->WriteData(Device, &Data, 1); }
+
+static void SetColumnAddress(struct GDS_Device* Device, uint16_t Start, uint16_t End) {
+    uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
+    Device->WriteCommand(Device, 0x2A);
+    Device->WriteData(Device, (uint8_t*)&Addr, 4);
 }
 
-static void SetColumnAddress( struct GDS_Device* Device, uint16_t Start, uint16_t End ) {
-	uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
-	Device->WriteCommand( Device, 0x2A );
-	Device->WriteData( Device, (uint8_t*) &Addr, 4 );
+static void SetRowAddress(struct GDS_Device* Device, uint16_t Start, uint16_t End) {
+    uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
+    Device->WriteCommand(Device, 0x2B);
+    Device->WriteData(Device, (uint8_t*)&Addr, 4);
 }
 
-static void SetRowAddress( struct GDS_Device* Device, uint16_t Start, uint16_t End ) {
-	uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
-	Device->WriteCommand( Device, 0x2B );
-	Device->WriteData( Device, (uint8_t*) &Addr, 4 );
-}
+static void Update16(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
 
-static void Update16( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
 #ifdef SHADOW_BUFFER
-	uint32_t *optr = (uint32_t*) Private->Shadowbuffer, *iptr = (uint32_t*) Device->Framebuffer;
-	int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
-	
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width is always a multiple of 2)
-		for (int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
+    uint32_t *optr = (uint32_t*)Private->Shadowbuffer, *iptr = (uint32_t*)Device->Framebuffer;
+    int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
 
-		// wait for a large enough window - careful that window size might increase by more than a line at once !
-		if (FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol *= 2;
-		LastCol = LastCol * 2 + 1;
-		SetRowAddress( Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
-		SetColumnAddress( Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 2;
-			
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize );
-		}	
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width is always a multiple of 2)
+        for(int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
 
-		FirstCol = Device->Width / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+        // wait for a large enough window - careful that window size might increase by more than a line at once !
+        if(FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
+
+        FirstCol *= 2;
+        LastCol = LastCol * 2 + 1;
+        SetRowAddress(Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
+        SetColumnAddress(Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 2;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+            }
+
+        FirstCol = Device->Width / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, Private->Offset.Width, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 2 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, Private->Offset.Width, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 2);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+        }
+    }
+#endif
 }
 
-static void Update24( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
+static void Update24(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
 #ifdef SHADOW_BUFFER
-	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
-	int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
+    uint16_t *optr = (uint16_t*)Private->Shadowbuffer, *iptr = (uint16_t*)Device->Framebuffer;
+    int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
 
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width always / by 2)
-		for (int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width always / by 2)
+        for(int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
 
-		// do we have enough to send (cols are divided by 3/2)
-		if (FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2 ) / 3) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol = (FirstCol * 2) / 3;
-		LastCol = (LastCol * 2 + 1 ) / 3; 
-		SetRowAddress( Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
-		SetColumnAddress( Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 3;
-					
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}	
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize );
-		}	
+        // do we have enough to send (cols are divided by 3/2)
+        if(FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2) / 3) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
 
-		FirstCol = (Device->Width * 3) / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+        FirstCol = (FirstCol * 2) / 3;
+        LastCol = (LastCol * 2 + 1) / 3;
+        SetRowAddress(Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
+        SetColumnAddress(Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 3;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+            }
+
+        FirstCol = (Device->Width * 3) / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, Private->Offset.Width, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 3 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, Private->Offset.Width, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 3);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+        }
+    }
+#endif
 }
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	ESP_LOGI(TAG, "SetLayout 197 HFlip=%d VFlip=%d Rotate=%d (1=true)", HFlip, VFlip, Rotate);
-	//        D/CX RDX WRX D17-8 D7 D6 D5 D4 D3  D2 D1 D0 HEX
-	//Command   0   1   ↑    XX  0  0  1  1  0   1  1  0  36h
-	//Parameter 1   1   ↑    XX  MY MX MV ML BGR MH 0  0  00
-	//Orientation 0: MADCtl = 0x80  =   1000 0000 (MY=1)
-	if ((Device->Height)>(Device->Width)){		//Resolution = 320x240
-		Private->MADCtl = (1 << 7);				// 0x80 = default (no Rotation an no Flip)
-		if (HFlip) {							//Flip Horizontal
-			int a = Private->MADCtl;
-			Private->MADCtl = (a ^ (1 << 7));
-		}
-		if (Rotate) {							//Rotate 180 degr.
-			int a = Private->MADCtl;
-			a = (a ^ (1 << 7));
-			Private->MADCtl = (a ^ (1 << 6));
-		}
-		if (VFlip) {							//Flip Vertical
-			int a = Private->MADCtl;
-			Private->MADCtl = (a ^ (1 << 6));
-		}
-	} else {									//Resolution = 240x320
-		Private->MADCtl = (1 << 5);				// 0x20 = default (no Rotation an no Flip)
-		if (HFlip) {							//Flip Horizontal
-			int a = Private->MADCtl;
-			Private->MADCtl = (a ^ (1 << 6));
-		}
-		if (Rotate) {							//Rotate 180 degr.
-			int a = Private->MADCtl;
-			a = (a ^ (1 << 7));
-			Private->MADCtl = (a ^ (1 << 6));
-		}
-		if (VFlip) {							//Flip Vertical
-			int a = Private->MADCtl;
-			Private->MADCtl = (a ^ (1 << 7));
-		}
-	}
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    ESP_LOGI(TAG, "SetLayout 197 HFlip=%d VFlip=%d Rotate=%d (1=true)", Layout->HFlip, Layout->VFlip, Layout->Rotate);
+    //        D/CX RDX WRX D17-8 D7 D6 D5 D4 D3  D2 D1 D0 HEX
+    //Command   0   1   ↑    XX  0  0  1  1  0   1  1  0  36h
+    //Parameter 1   1   ↑    XX  MY MX MV ML BGR MH 0  0  00
+    //Orientation 0: MADCtl = 0x80  =   1000 0000 (MY=1)
+    if((Device->Height) > (Device->Width)) { //Resolution = 320x240
+        Private->MADCtl = (1 << 7);          // 0x80 = default (no Rotation an no Flip)
+        if(Layout->HFlip) {                  //Flip Horizontal
+            int a = Private->MADCtl;
+            Private->MADCtl = (a ^ (1 << 7));
+        }
+        if(Layout->Rotate) { //Rotate 180 degr.
+            int a = Private->MADCtl;
+            a = (a ^ (1 << 7));
+            Private->MADCtl = (a ^ (1 << 6));
+        }
+        if(Layout->VFlip) { //Flip Vertical
+            int a = Private->MADCtl;
+            Private->MADCtl = (a ^ (1 << 6));
+        }
+    } else {                        //Resolution = 240x320
+        Private->MADCtl = (1 << 5); // 0x20 = default (no Rotation an no Flip)
+        if(Layout->HFlip) {         //Flip Horizontal
+            int a = Private->MADCtl;
+            Private->MADCtl = (a ^ (1 << 6));
+        }
+        if(Layout->Rotate) { //Rotate 180 degr.
+            int a = Private->MADCtl;
+            a = (a ^ (1 << 7));
+            Private->MADCtl = (a ^ (1 << 6));
+        }
+        if(Layout->VFlip) { //Flip Vertical
+            int a = Private->MADCtl;
+            Private->MADCtl = (a ^ (1 << 7));
+        }
+    }
 
-	ESP_LOGI(TAG, "SetLayout 255 Private->MADCtl=%hhu", Private->MADCtl);
+    Private->MADCtl = Layout->ColorSwap ? (Private->MADCtl | (1 << 3)) : (Private->MADCtl & ~(1 << 3));
 
-	Device->WriteCommand( Device, 0x36 );
-	WriteByte( Device, Private->MADCtl );
+    ESP_LOGI(TAG, "SetLayout 255 Private->MADCtl=%hhu", Private->MADCtl);
+
+    Device->WriteCommand(Device, 0x36);
+    WriteByte(Device, Private->MADCtl);
+
+    Device->WriteCommand(Device, Layout->Invert ? 0x21 : 0x20);
 
 #ifdef SHADOW_BUFFER
-	// force a full refresh (almost ...)
-	memset(Private->Shadowbuffer, 0xAA, Device->FramebufferSize);
-#endif	
-}	
-
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0x29 ); }	//DISPON =0x29
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0x28 ); }	//DISPOFF=0x28
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-	Device->WriteCommand( Device, 0x51 );
-	WriteByte( Device, Contrast );
-	
-	Device->SetContrast = NULL;
-	GDS_SetContrast( Device, Contrast );
-	Device->SetContrast = SetContrast;	// 0x00 value means the lowest brightness and 0xFF value means the highest brightness.
+    // force a full refresh (almost ...)
+    memset(Private->Shadowbuffer, 0xAA, Device->FramebufferSize);
+#endif
 }
 
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	int Depth = (Device->Depth + 8 - 1) / 8;
-	
-	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0x29); }  //DISPON =0x29
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0x28); } //DISPOFF=0x28
 
-#ifdef SHADOW_BUFFER	
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0x51);
+    WriteByte(Device, Contrast);
+
+    Device->SetContrast = NULL;
+    GDS_SetContrast(Device, Contrast);
+    Device->SetContrast = SetContrast; // 0x00 value means the lowest brightness and 0xFF value means the highest brightness.
+}
+
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    int Depth = (Device->Depth + 8 - 1) / 8;
+
+    Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
+
+#ifdef SHADOW_BUFFER
+    Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
 #endif
 #ifdef USE_IRAM
-	Private->iRAM = heap_caps_malloc( (Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+    Private->iRAM = heap_caps_malloc((Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
 #endif
 
-	ESP_LOGI(TAG, "ILI9341 with bit default-depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
-	
-	// Sleepout + Booster
-	Device->WriteCommand( Device, 0x11 );
-			
-	// set flip modes & contrast
-	GDS_SetContrast( Device, 0x7f );
-	Device->SetLayout( Device, false, false, false );
-	
-	// set screen depth (16/18) *** INTERFACE PIXEL FORMAT: 0x66=18 bit; 0x55=16 bit
-	Device->WriteCommand( Device, 0x3A );
-	if (Private->Model == ILI9341_24) WriteByte( Device, Device->Depth == 24 ? 0x66 : 0x55 );
-	else WriteByte( Device, Device->Depth == 24 ? 0x66 : 0x55 );
+    ESP_LOGI(TAG, "ILI9341 with bit default-depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
 
-	ESP_LOGI(TAG, "ILI9341_Init 312 device-depth %u, 0x66/0x55=0x%X", Device->Depth, Device->Depth == 24 ? 0x66 : 0x55);
+    // Sleepout + Booster
+    Device->WriteCommand(Device, 0x11);
 
-	// no Display Inversion (INVOFF=0x20 INVON=0x21)
-	Device->WriteCommand( Device, 0x20 );
+    // set flip modes & contrast
+    GDS_SetContrast(Device, 0x7f);
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
 
-	//Gamma Correction: Enable next two line and enabel one of the Test0x Section... or build you own 15 Parameter...
-	Device->WriteCommand( Device, 0xF2 ); WriteByte( Device, 0x03 );	// 3Gamma Function: Disable = default (0x02), Enable (0x03)
-	Device->WriteCommand( Device, 0x26 ); WriteByte( Device, 0x01 );	// Gamma curve selected (0x01, 0x02, 0x04, 0x08) - A maximum of 4 fixed gamma curves can be selected
-	//Gamma Correction Test01
-	Device->WriteCommand( Device, 0xE0 );								// Positive Gamma Correction (15 Parameter)
-	WriteByte( Device, 0x0F ); WriteByte( Device, 0x31 ); WriteByte( Device, 0x2B ); WriteByte( Device, 0x0C ); WriteByte( Device, 0x0E );
-	WriteByte( Device, 0x08 ); WriteByte( Device, 0x4E ); WriteByte( Device, 0xF1 ); WriteByte( Device, 0x37 ); WriteByte( Device, 0x07 );
-	WriteByte( Device, 0x10 ); WriteByte( Device, 0x03 ); WriteByte( Device, 0x0E ); WriteByte( Device, 0x09 ); WriteByte( Device, 0x00 );
-	Device->WriteCommand( Device, 0xE1 ); 								// Negative Gamma Correction (15 Parameter)
-	WriteByte( Device, 0x00 ); WriteByte( Device, 0x0E ); WriteByte( Device, 0x14 ); WriteByte( Device, 0x03 ); WriteByte( Device, 0x11 );
-	WriteByte( Device, 0x07 ); WriteByte( Device, 0x31 ); WriteByte( Device, 0xC1 ); WriteByte( Device, 0x48 ); WriteByte( Device, 0x08 );
-	WriteByte( Device, 0x0F ); WriteByte( Device, 0x0C ); WriteByte( Device, 0x31 ); WriteByte( Device, 0x36 ); WriteByte( Device, 0x0F );
-	 
-	// gone with the wind
-	Device->DisplayOn( Device );
-	Device->Update( Device );
+    // set screen depth (16/18) *** INTERFACE PIXEL FORMAT: 0x66=18 bit; 0x55=16 bit
+    Device->WriteCommand(Device, 0x3A);
+    if(Private->Model == ILI9341_24)
+        WriteByte(Device, Device->Depth == 24 ? 0x66 : 0x55);
+    else
+        WriteByte(Device, Device->Depth == 24 ? 0x66 : 0x55);
 
-	return true;
-}	
+    ESP_LOGI(TAG, "ILI9341_Init 312 device-depth %u, 0x66/0x55=0x%X", Device->Depth, Device->Depth == 24 ? 0x66 : 0x55);
+
+    // no Display Inversion (INVOFF=0x20 INVON=0x21)
+    Device->WriteCommand(Device, 0x20);
+
+    //Gamma Correction: Enable next two line and enabel one of the Test0x Section... or build you own 15 Parameter...
+    Device->WriteCommand(Device, 0xF2);
+    WriteByte(Device, 0x03); // 3Gamma Function: Disable = default (0x02), Enable (0x03)
+    Device->WriteCommand(Device, 0x26);
+    WriteByte(Device, 0x01); // Gamma curve selected (0x01, 0x02, 0x04, 0x08) - A maximum of 4 fixed gamma curves can be selected
+    //Gamma Correction Test01
+    Device->WriteCommand(Device, 0xE0); // Positive Gamma Correction (15 Parameter)
+    WriteByte(Device, 0x0F);
+    WriteByte(Device, 0x31);
+    WriteByte(Device, 0x2B);
+    WriteByte(Device, 0x0C);
+    WriteByte(Device, 0x0E);
+    WriteByte(Device, 0x08);
+    WriteByte(Device, 0x4E);
+    WriteByte(Device, 0xF1);
+    WriteByte(Device, 0x37);
+    WriteByte(Device, 0x07);
+    WriteByte(Device, 0x10);
+    WriteByte(Device, 0x03);
+    WriteByte(Device, 0x0E);
+    WriteByte(Device, 0x09);
+    WriteByte(Device, 0x00);
+    Device->WriteCommand(Device, 0xE1); // Negative Gamma Correction (15 Parameter)
+    WriteByte(Device, 0x00);
+    WriteByte(Device, 0x0E);
+    WriteByte(Device, 0x14);
+    WriteByte(Device, 0x03);
+    WriteByte(Device, 0x11);
+    WriteByte(Device, 0x07);
+    WriteByte(Device, 0x31);
+    WriteByte(Device, 0xC1);
+    WriteByte(Device, 0x48);
+    WriteByte(Device, 0x08);
+    WriteByte(Device, 0x0F);
+    WriteByte(Device, 0x0C);
+    WriteByte(Device, 0x31);
+    WriteByte(Device, 0x36);
+    WriteByte(Device, 0x0F);
+
+    // gone with the wind
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device ILI9341_X = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff,
-	.SetLayout = SetLayout,
-	.Update = Update16, .Init = Init,
-	.Mode = GDS_RGB565, .Depth = 16,
-};		
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetLayout = SetLayout,
+    .Update = Update16,
+    .Init = Init,
+    .Mode = GDS_RGB565,
+    .Depth = 16,
+};
 
-struct GDS_Device* ILI9341_Detect(char *Driver, struct GDS_Device* Device) {
-	uint8_t Model;
-	int Depth=16;		// 16bit colordepth
-	
-	if (strcasestr(Driver, "ILI9341")) Model = ILI9341;
-	else if (strcasestr(Driver, "ILI9341_24")) Model = ILI9341_24;	//for future use...
-	else return NULL;
-		
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-		
-	*Device = ILI9341_X;	
-	sscanf(Driver, "%*[^:]:%u", &Depth);		// NVS-Parameter driver=ILI9341[:16|18]
-	struct PrivateSpace* Private = (struct PrivateSpace*) Device->Private;
-	Private->Model = Model;
-		ESP_LOGI(TAG, "ILI9341_Detect 391 Driver= %s   Depth=%d", Driver, Depth);
+struct GDS_Device* ILI9341_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    uint8_t Model;
+    int Depth = 16; // 16bit colordepth
 
-	if (Depth == 18) {
-		Device->Mode = GDS_RGB888;
-		Device->Depth = 24;
-		Device->Update = Update24;
-	} 	
-	
-	if (Model == ILI9341_24) Device->SetContrast = SetContrast;
+    if(Driver->common.driver == sys_display_drivers_ILI9341)
+        Model = ILI9341;
+    else if(Driver->common.driver == sys_display_drivers_ILI9341_24)
+        Model = ILI9341_24;
+    else
+        return NULL;
 
-	return Device;
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+
+    *Device = ILI9341_X;
+    Depth = Driver->common.bitDepth != 0 ? Driver->common.bitDepth : Depth;
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->Model = Model;
+    ESP_LOGI(TAG, "ILI9341_Detect 391 Driver= %s   Depth=%d", Model == ILI9341 ? "ILI9341" : "ILI9341_24", Depth);
+
+    if(Depth == 18) {
+        Device->Mode = GDS_RGB888;
+        Device->Depth = 24;
+        Device->Update = Update24;
+    }
+
+    if(Model == ILI9341_24) Device->SetContrast = SetContrast;
+
+    return Device;
 }

components/display/SH1106.c

@@ -22,136 +22,144 @@
 static char TAG[] = "SH1106";
 
 struct PrivateSpace {
-	uint8_t *Shadowbuffer;
+    uint8_t* Shadowbuffer;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	// well, unfortunately this driver is 132 colums but most displays are 128...
-	if (Device->Width != 132) Start += 2;
-	Device->WriteCommand( Device, 0x10 | (Start >> 4) );
-	Device->WriteCommand( Device, 0x00 | (Start & 0x0f) );
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    // well, unfortunately this driver is 132 colums but most displays are 128...
+    if(Device->Width != 132) Start += 2;
+    Device->WriteCommand(Device, 0x10 | (Start >> 4));
+    Device->WriteCommand(Device, 0x00 | (Start & 0x0f));
 }
 
-static void SetPageAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0xB0 | Start );	
-}	
+static void SetPageAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) { Device->WriteCommand(Device, 0xB0 | Start); }
 
-static void Update( struct GDS_Device* Device ) {
+static void Update(struct GDS_Device* Device) {
 #ifdef SHADOW_BUFFER
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	// not sure the compiler does not have to redo all calculation in for loops, so local it is
-	int width = Device->Width, rows = Device->Height / 8;
-	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
-	
-	// by row, find first and last columns that have been updated
-	for (int r = 0; r < rows; r++) {
-		uint8_t first = 0, last;	
-		for (int c = 0; c < width; c++) {
-			if (*iptr != *optr) {
-				if (!first) first = c + 1;
-				last = c ;
-			}	
-			*optr++ = *iptr++;
-		}
-		
-		// now update the display by "byte rows"
-		if (first--) {
-			SetColumnAddress( Device, first, last );
-			SetPageAddress( Device, r, r);
-			Device->WriteData( Device, Private->Shadowbuffer + r*width + first, last - first + 1);
-		}
-	}	
-#else	
-	// SH1106 requires a page-by-page update and has no end Page/Column
-	for (int i = 0; i < Device->Height / 8 ; i++) {
-		SH1106_SetPageAddress( Device, i, 0);
-		SH1106_SetColumnAddress( Device, 0, 0);			
-		SH1106_WriteData( Device, Device->Framebuffer + i*Device->Width, Device->Width );
-	}	
-#endif	
-}
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    // not sure the compiler does not have to redo all calculation in for loops, so local it is
+    int width = Device->Width, rows = Device->Height / 8;
+    uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) {
-	Device->WriteCommand( Device, HFlip ? 0xA1 : 0xA0 );
-	Device->WriteCommand( Device, VFlip ? 0xC8 : 0xC0 );
-}	
+    // by row, find first and last columns that have been updated
+    for(int r = 0; r < rows; r++) {
+        uint8_t first = 0, last;
+        for(int c = 0; c < width; c++) {
+            if(*iptr != *optr) {
+                if(!first) first = c + 1;
+                last = c;
+            }
+            *optr++ = *iptr++;
+        }
 
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-    Device->WriteCommand( Device, 0x81 );
-    Device->WriteCommand( Device, Contrast );
-}
-
-static bool Init( struct GDS_Device* Device ) {
-#ifdef SHADOW_BUFFER	
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-#ifdef USE_IRAM
-	if (Device->IF == GDS_IF_SPI) Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-	else 
+        // now update the display by "byte rows"
+        if(first--) {
+            SetColumnAddress(Device, first, last);
+            SetPageAddress(Device, r, r);
+            Device->WriteData(Device, Private->Shadowbuffer + r * width + first, last - first + 1);
+        }
+    }
+#else
+    // SH1106 requires a page-by-page update and has no end Page/Column
+    for(int i = 0; i < Device->Height / 8; i++) {
+        SH1106_SetPageAddress(Device, i, 0);
+        SH1106_SetColumnAddress(Device, 0, 0);
+        SH1106_WriteData(Device, Device->Framebuffer + i * Device->Width, Device->Width);
+    }
 #endif
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	NullCheck( Private->Shadowbuffer, return false );
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
-#endif	
-		
-	// need to be off and disable display RAM
-	Device->DisplayOff( Device );
-    Device->WriteCommand( Device, 0xA5 );
-	
-	// charge pump regulator, do direct init
-	Device->WriteCommand( Device, 0xAD );
-	Device->WriteCommand( Device, 0x8B ); 
-			
-	// COM pins HW config (alternative:EN) - some display might need something difference
-	Device->WriteCommand( Device, 0xDA );
-	Device->WriteCommand( Device, 1 << 4);
-		
-	// MUX Ratio
-    Device->WriteCommand( Device, 0xA8 );
-    Device->WriteCommand( Device, Device->Height - 1);
-	// Display Offset
-    Device->WriteCommand( Device, 0xD3 );
-    Device->WriteCommand( Device, 0 );
-	// Display Start Line
-    Device->WriteCommand( Device, 0x40 + 0x00 );
-	Device->SetContrast( Device, 0x7F );
-	// set flip modes
-	Device->SetLayout( Device, false, false, false );
-	// no Display Inversion
-    Device->WriteCommand( Device, 0xA6 );
-	// set Clocks
-    Device->WriteCommand( Device, 0xD5 );
-    Device->WriteCommand( Device, ( 0x08 << 4 ) | 0x00 );
-		
-	// gone with the wind
-	Device->WriteCommand( Device, 0xA4 );
-	Device->DisplayOn( Device );
-	Device->Update( Device );
-	
-	return true;
-}	
+}
 
-static const struct GDS_Device SH1106 = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
-	.SetLayout = SetLayout,
-	.Update = Update, .Init = Init,
-	.Depth = 1,
-#if !defined SHADOW_BUFFER && defined USE_IRAM	
-	.Alloc = GDS_ALLOC_IRAM_SPI;
-#endif		
-};	
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    Device->WriteCommand(Device, Layout->HFlip ? 0xA1 : 0xA0);
+    Device->WriteCommand(Device, Layout->VFlip ? 0xC8 : 0xC0);
+    Device->WriteCommand(Device, Layout->Invert ? 0xA7 : 0xA6);
+}
 
-struct GDS_Device* SH1106_Detect(char *Driver, struct GDS_Device* Device) {
-	if (!strcasestr(Driver, "SH1106")) return NULL;
-	
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	*Device = SH1106;
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAF); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAE); }
 
-	ESP_LOGI(TAG, "SH1106 driver");
-	
-	return Device;
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0x81);
+    Device->WriteCommand(Device, Contrast);
+}
+
+static void SPIParams(int Speed, uint8_t* mode, uint16_t* CS_pre, uint8_t* CS_post) { *CS_post = Speed / (8 * 1000 * 1000); }
+
+static bool Init(struct GDS_Device* Device) {
+#ifdef SHADOW_BUFFER
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+#ifdef USE_IRAM
+    if(Device->IF == GDS_IF_SPI)
+        Private->Shadowbuffer = heap_caps_malloc(Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+    else
+#endif
+        Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    NullCheck(Private->Shadowbuffer, return false);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#endif
+
+    // need to be off and disable display RAM
+    Device->DisplayOff(Device);
+    Device->WriteCommand(Device, 0xA5);
+
+    // charge pump regulator, do direct init
+    Device->WriteCommand(Device, 0xAD);
+    Device->WriteCommand(Device, 0x8B);
+
+    // COM pins HW config (alternative:EN) - some display might need something difference
+    Device->WriteCommand(Device, 0xDA);
+    Device->WriteCommand(Device, 1 << 4);
+
+    // MUX Ratio
+    Device->WriteCommand(Device, 0xA8);
+    Device->WriteCommand(Device, Device->Height - 1);
+    // Display Offset
+    Device->WriteCommand(Device, 0xD3);
+    Device->WriteCommand(Device, 0);
+    // Display Start Line
+    Device->WriteCommand(Device, 0x40 + 0x00);
+    Device->SetContrast(Device, 0x7F);
+    // set flip modes
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+    // no Display Inversion
+    Device->WriteCommand(Device, 0xA6);
+    // set Clocks
+    Device->WriteCommand(Device, 0xD5);
+    Device->WriteCommand(Device, (0x08 << 4) | 0x00);
+
+    // gone with the wind
+    Device->WriteCommand(Device, 0xA4);
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
+
+static const struct GDS_Device SH1106 = {.DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetContrast = SetContrast,
+    .SetLayout = SetLayout,
+    .Update = Update,
+    .Init = Init,
+    .Depth = 1,
+    .SPIParams = SPIParams,
+#if !defined SHADOW_BUFFER && defined USE_IRAM
+    .Alloc = GDS_ALLOC_IRAM_SPI;
+#endif
+}
+;
+
+struct GDS_Device* SH1106_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    // if (!strcasestr(Driver, "SH1106")) return NULL;
+    if(Driver->common.driver != sys_display_drivers_SH1106) return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+    *Device = SH1106;
+
+    ESP_LOGI(TAG, "SH1106 driver");
+
+    return Device;
 }

components/display/SSD1306.c

@@ -22,151 +22,158 @@
 static char TAG[] = "SSD1306";
 
 struct PrivateSpace {
-	uint8_t *Shadowbuffer;
+    uint8_t* Shadowbuffer;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x21 );
-	Device->WriteCommand( Device, Start );
-	Device->WriteCommand( Device, End );
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x21);
+    Device->WriteCommand(Device, Start);
+    Device->WriteCommand(Device, End);
 }
-static void SetPageAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x22 );	
-	Device->WriteCommand( Device, Start );
-	Device->WriteCommand( Device, End );
+static void SetPageAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x22);
+    Device->WriteCommand(Device, Start);
+    Device->WriteCommand(Device, End);
 }
 
-static void Update( struct GDS_Device* Device ) {
+static void Update(struct GDS_Device* Device) {
 #ifdef SHADOW_BUFFER
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	// not sure the compiler does not have to redo all calculation in for loops, so local it is
-	int width = Device->Width, pages = Device->Height / 8;
-	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
-	int CurrentPage = -1, FirstCol = -1, LastCol = -1;
-	
-	// by row, find first and last columns that have been updated
-	for (int p = 0; p < pages; p++) {
-		uint8_t first = 0, last;	
-		for (int c = 0; c < width; c++) {
-			if (*iptr != *optr) {
-				if (!first) first = c + 1;
-				last = c ;
-			}	
-			*optr++ = *iptr++;
-		}
-		
-		// now update the display by "byte rows"
-		if (first--) {
-			// only set column when useful, saves a fair bit of CPU
-			if (first > FirstCol && first <= FirstCol + 4 && last < LastCol && last >= LastCol - 4) {
-				first = FirstCol;
-				last = LastCol;
-			} else {	
-				SetColumnAddress( Device, first, last );
-				FirstCol = first;
-				LastCol = last;
-			}
-			
-			// Set row only when needed, otherwise let auto-increment work
-			if (p != CurrentPage) SetPageAddress( Device, p, Device->Height / 8 - 1 );
-			CurrentPage = p + 1;
-			
-			// actual write
-			Device->WriteData( Device, Private->Shadowbuffer + p*width + first, last - first + 1);
-		}
-	}	
-#else	
-	// automatic counter and end Page/Column (we assume Height % 8 == 0)
-	SetColumnAddress( Device, 0, Device->Width - 1);
-	SetPageAddress( Device, 0, Device->Height / 8 - 1);
-	Device->WriteData( Device, Device->Framebuffer, Device->FramebufferSize );
-#endif	
-}
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    // not sure the compiler does not have to redo all calculation in for loops, so local it is
+    int width = Device->Width, pages = Device->Height / 8;
+    uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
+    int CurrentPage = -1, FirstCol = -1, LastCol = -1;
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	Device->WriteCommand( Device, HFlip ? 0xA1 : 0xA0 );
-	Device->WriteCommand( Device, VFlip ? 0xC8 : 0xC0 );
-}
-	
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
+    // by row, find first and last columns that have been updated
+    for(int p = 0; p < pages; p++) {
+        uint8_t first = 0, last;
+        for(int c = 0; c < width; c++) {
+            if(*iptr != *optr) {
+                if(!first) first = c + 1;
+                last = c;
+            }
+            *optr++ = *iptr++;
+        }
 
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-    Device->WriteCommand( Device, 0x81 );
-    Device->WriteCommand( Device, Contrast );
-}
+        // now update the display by "byte rows"
+        if(first--) {
+            // only set column when useful, saves a fair bit of CPU
+            if(first > FirstCol && first <= FirstCol + 4 && last < LastCol && last >= LastCol - 4) {
+                first = FirstCol;
+                last = LastCol;
+            } else {
+                SetColumnAddress(Device, first, last);
+                FirstCol = first;
+                LastCol = last;
+            }
 
-static bool Init( struct GDS_Device* Device ) {
-#ifdef SHADOW_BUFFER	
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-#ifdef USE_IRAM
-	if (Device->IF == GDS_IF_SPI) Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-	else 
+            // Set row only when needed, otherwise let auto-increment work
+            if(p != CurrentPage) SetPageAddress(Device, p, Device->Height / 8 - 1);
+            CurrentPage = p + 1;
+
+            // actual write
+            Device->WriteData(Device, Private->Shadowbuffer + p * width + first, last - first + 1);
+        }
+    }
+#else
+    // automatic counter and end Page/Column (we assume Height % 8 == 0)
+    SetColumnAddress(Device, 0, Device->Width - 1);
+    SetPageAddress(Device, 0, Device->Height / 8 - 1);
+    Device->WriteData(Device, Device->Framebuffer, Device->FramebufferSize);
 #endif
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	NullCheck( Private->Shadowbuffer, return false );
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
-#endif	
-		
-	// need to be off and disable display RAM
-	Device->DisplayOff( Device );
-    Device->WriteCommand( Device, 0xA5 );
-	
-	// charge pump regulator, do direct init
-	Device->WriteCommand( Device, 0x8D );
-	Device->WriteCommand( Device, 0x14 ); 
-			
-	// COM pins HW config (alternative:EN if 64, DIS if 32, remap:DIS) - some display might need something different
-	Device->WriteCommand( Device, 0xDA );
-	Device->WriteCommand( Device, ((Device->Height == 64 ? 1 : 0) << 4) | (0 < 5) );
-		
-	// MUX Ratio
-    Device->WriteCommand( Device, 0xA8 );
-    Device->WriteCommand( Device, Device->Height - 1);
-	// Display Offset
-    Device->WriteCommand( Device, 0xD3 );
-    Device->WriteCommand( Device, 0 );
-	// Display Start Line
-    Device->WriteCommand( Device, 0x40 + 0x00 );
-	Device->SetContrast( Device, 0x7F );
-	// set flip modes
-	Device->SetLayout( Device, false, false, false);
-	// no Display Inversion
-    Device->WriteCommand( Device, 0xA6 );
-	// set Clocks
-    Device->WriteCommand( Device, 0xD5 );
-    Device->WriteCommand( Device, ( 0x08 << 4 ) | 0x00 );
-	// set Adressing Mode Horizontal
-	Device->WriteCommand( Device, 0x20 );
-	Device->WriteCommand( Device, 0 );
-	
-	// gone with the wind
-	Device->WriteCommand( Device, 0xA4 );
-	Device->DisplayOn( Device );
-	Device->Update( Device );
-	
-	return true;
-}	
+}
+
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    Device->WriteCommand(Device, Layout->HFlip ? 0xA1 : 0xA0);
+    Device->WriteCommand(Device, Layout->VFlip ? 0xC8 : 0xC0);
+    Device->WriteCommand(Device, Layout->Invert ? 0xA7 : 0xA6);
+}
+
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAF); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAE); }
+
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0x81);
+    Device->WriteCommand(Device, Contrast);
+}
+
+static bool Init(struct GDS_Device* Device) {
+#ifdef SHADOW_BUFFER
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+#ifdef USE_IRAM
+    if(Device->IF == GDS_IF_SPI)
+        Private->Shadowbuffer = heap_caps_malloc(Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+    else
+#endif
+        Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    NullCheck(Private->Shadowbuffer, return false);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#endif
+
+    // need to be off and disable display RAM
+    Device->DisplayOff(Device);
+    Device->WriteCommand(Device, 0xA5);
+
+    // charge pump regulator, do direct init
+    Device->WriteCommand(Device, 0x8D);
+    Device->WriteCommand(Device, 0x14);
+
+    // COM pins HW config (alternative:EN if 64, DIS if 32, remap:DIS) - some display might need something different
+    Device->WriteCommand(Device, 0xDA);
+    Device->WriteCommand(Device, ((Device->Height == 64 ? 1 : 0) << 4) | (0 < 5));
+
+    // MUX Ratio
+    Device->WriteCommand(Device, 0xA8);
+    Device->WriteCommand(Device, Device->Height - 1);
+    // Display Offset
+    Device->WriteCommand(Device, 0xD3);
+    Device->WriteCommand(Device, 0);
+    // Display Start Line
+    Device->WriteCommand(Device, 0x40 + 0x00);
+    Device->SetContrast(Device, 0x7F);
+    // set flip modes
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+    // no Display Inversion
+    Device->WriteCommand(Device, 0xA6);
+    // set Clocks
+    Device->WriteCommand(Device, 0xD5);
+    Device->WriteCommand(Device, (0x08 << 4) | 0x00);
+    // set Adressing Mode Horizontal
+    Device->WriteCommand(Device, 0x20);
+    Device->WriteCommand(Device, 0);
+
+    // gone with the wind
+    Device->WriteCommand(Device, 0xA4);
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device SSD1306 = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
-	.SetLayout = SetLayout,
-	.Update = Update, .Init = Init,
-	.Mode = GDS_MONO, .Depth = 1,
-#if !defined SHADOW_BUFFER && defined USE_IRAM	
-	.Alloc = GDS_ALLOC_IRAM_SPI,
-#endif		
-};	
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetContrast = SetContrast,
+    .SetLayout = SetLayout,
+    .Update = Update,
+    .Init = Init,
+    .Mode = GDS_MONO,
+    .Depth = 1,
+#if !defined SHADOW_BUFFER && defined USE_IRAM
+    .Alloc = GDS_ALLOC_IRAM_SPI,
+#endif
+};
 
-struct GDS_Device* SSD1306_Detect(char *Driver, struct GDS_Device* Device) {
-	if (!strcasestr(Driver, "SSD1306")) return NULL;
-	
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	*Device = SSD1306;	
-	
-	ESP_LOGI(TAG, "SSD1306 driver");
-	
-	return Device;
+struct GDS_Device* SSD1306_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    if(Driver->common.driver != sys_display_drivers_SSD1306) return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+    *Device = SSD1306;
+
+    ESP_LOGI(TAG, "SSD1306 driver");
+
+    return Device;
 }

components/display/SSD1322.c

@@ -17,184 +17,189 @@
 #include "gds_private.h"
 
 #define SHADOW_BUFFER
-#define PAGE_BLOCK	1024
+#define PAGE_BLOCK 1024
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a, b) (((a) < (b)) ? (a) : (b))
 
 static char TAG[] = "SSD1322";
 
 struct PrivateSpace {
-	uint8_t *iRAM, *Shadowbuffer;
-	uint8_t ReMap, PageSize;
-	uint8_t Offset;
+    uint8_t *iRAM, *Shadowbuffer;
+    uint8_t ReMap, PageSize;
+    uint8_t Offset;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void WriteDataByte( struct GDS_Device* Device, uint8_t Data ) {
-	Device->WriteData( Device, &Data, 1);
+static void WriteDataByte(struct GDS_Device* Device, uint8_t Data) { Device->WriteData(Device, &Data, 1); }
+
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x15);
+    Device->WriteData(Device, &Start, 1);
+    Device->WriteData(Device, &End, 1);
+}
+static void SetRowAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x75);
+    Device->WriteData(Device, &Start, 1);
+    Device->WriteData(Device, &End, 1);
 }
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x15 );
-	Device->WriteData( Device, &Start, 1 );
-	Device->WriteData( Device, &End, 1 );
-}
-static void SetRowAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x75 );
-	Device->WriteData( Device, &Start, 1 );
-	Device->WriteData( Device, &End, 1 );
-}
+static void Update(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
+    // RAM is by columns of 4 pixels ...
+    SetColumnAddress(Device, Private->Offset, Private->Offset + Device->Width / 4 - 1);
 
-static void Update( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
-	// RAM is by columns of 4 pixels ...
-	SetColumnAddress( Device, Private->Offset, Private->Offset + Device->Width / 4 - 1);
-	
 #ifdef SHADOW_BUFFER
-	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
-	bool dirty = false;
-	
-	for (int r = 0, page = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width always / by 2)
-		for (int c = Device->Width / 2 / 2; --c >= 0;) {
-			if (*optr != *iptr) {
-				dirty = true;
-				*optr = *iptr;
-			}
-			iptr++; optr++;
-		}
-		
-		// one line done, check for page boundary
-		if (++page == Private->PageSize) {
-			if (dirty) {
-				uint16_t *optr = (uint16_t*) Private->iRAM, *iptr = (uint16_t*) (Private->Shadowbuffer + (r - page + 1) * Device->Width / 2);
-				SetRowAddress( Device, r - page + 1, r );
-				for (int i = page * Device->Width / 2 / 2; --i >= 0; iptr++) *optr++ = (*iptr >> 8) | (*iptr << 8);
-				//memcpy(Private->iRAM, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );
-				Device->WriteCommand( Device, 0x5c );
-				Device->WriteData( Device, Private->iRAM, Device->Width * page / 2 );
-				dirty = false;
-			}	
-			page = 0;
-		}	
-	}	
+    uint16_t *optr = (uint16_t*)Private->Shadowbuffer, *iptr = (uint16_t*)Device->Framebuffer;
+    bool dirty = false;
+
+    for(int r = 0, page = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width always / by 2)
+        for(int c = Device->Width / 2 / 2; --c >= 0;) {
+            if(*optr != *iptr) {
+                dirty = true;
+                *optr = *iptr;
+            }
+            iptr++;
+            optr++;
+        }
+
+        // one line done, check for page boundary
+        if(++page == Private->PageSize) {
+            if(dirty) {
+                uint16_t *optr = (uint16_t*)Private->iRAM, *iptr = (uint16_t*)(Private->Shadowbuffer + (r - page + 1) * Device->Width / 2);
+                SetRowAddress(Device, r - page + 1, r);
+                for(int i = page * Device->Width / 2 / 2; --i >= 0; iptr++) *optr++ = (*iptr >> 8) | (*iptr << 8);
+                //memcpy(Private->iRAM, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );
+                Device->WriteCommand(Device, 0x5c);
+                Device->WriteData(Device, Private->iRAM, Device->Width * page / 2);
+                dirty = false;
+            }
+            page = 0;
+        }
+    }
 #else
-	for (int r = 0; r < Device->Height; r += Private->PageSize) {
-		SetRowAddress( Device, r, r + Private->PageSize - 1 );
-		Device->WriteCommand( Device, 0x5c );
-		if (Private->iRAM) {
-			uint16_t *optr = (uint16_t*) Private->iRAM, *iptr = (uint16_t*) (Device->Framebuffer + r * Device->Width / 2);
-			for (int i = Private->PageSize * Device->Width / 2 / 2; --i >= 0; iptr++) *optr++ = (*iptr >> 8) | (*iptr << 8);
-			//memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
-			Device->WriteData( Device, Private->iRAM, Private->PageSize * Device->Width / 2 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
-		}	
-	}	
-#endif	
-}
-
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	Private->ReMap = HFlip ? (Private->ReMap & ~(1 << 1)) : (Private->ReMap | (1 << 1));
-	Private->ReMap = VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
-	Device->WriteCommand( Device, 0xA0 );
-	Device->WriteData( Device, &Private->ReMap, 1 );
-	WriteDataByte( Device, 0x11 );		
-}	
-
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-    Device->WriteCommand( Device, 0xC1 );
-    Device->WriteData( Device, &Contrast, 1 );
-}
-
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	
-	// these displays seems to be layout centered (1 column = 4 pixels of 4 bits each, little endian)
-	Private->Offset = (480 - Device->Width) / 4 / 2;
-	
-	// find a page size that is not too small is an integer of height
-	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width / 2));
-	while (Private->PageSize && Device->Height != (Device->Height / Private->PageSize) * Private->PageSize) Private->PageSize--;
-	
-#ifdef SHADOW_BUFFER	
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+    for(int r = 0; r < Device->Height; r += Private->PageSize) {
+        SetRowAddress(Device, r, r + Private->PageSize - 1);
+        Device->WriteCommand(Device, 0x5c);
+        if(Private->iRAM) {
+            uint16_t *optr = (uint16_t*)Private->iRAM, *iptr = (uint16_t*)(Device->Framebuffer + r * Device->Width / 2);
+            for(int i = Private->PageSize * Device->Width / 2 / 2; --i >= 0; iptr++) *optr++ = (*iptr >> 8) | (*iptr << 8);
+            //memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
+            Device->WriteData(Device, Private->iRAM, Private->PageSize * Device->Width / 2);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2);
+        }
+    }
 #endif
-	Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+}
 
-	ESP_LOGI(TAG, "SSD1322 with offset %u, page %u, iRAM %p", Private->Offset, Private->PageSize, Private->iRAM);
-			
-	// need to be off and disable display RAM
-	Device->DisplayOff( Device );
-    Device->WriteCommand( Device, 0xA5 );
-	
-	// Display Offset
-    Device->WriteCommand( Device, 0xA2 );
-    WriteDataByte( Device, 0 );
-	
-	// Display Start Line
-    Device->WriteCommand( Device, 0xA1 );
-	WriteDataByte( Device, 0x00 );
-	
-	// set flip modes
-	Private->ReMap = 0;
-	Device->SetLayout( Device, false, false, false);
-	
-	// set Display Enhancement
-    Device->WriteCommand( Device, 0xB4 );
-	WriteDataByte( Device, 0xA0 );
-	WriteDataByte( Device, 0xB5 );
-	
-	// set Clocks
-    Device->WriteCommand( Device, 0xB3 );
-	WriteDataByte( Device, 0xB2 ); // 0x91 seems to be common but is too slow for 5.5'
-	
-	// set MUX
-	Device->WriteCommand( Device, 0xCA );
-	WriteDataByte( Device, Device->Height - 1 );
-	
-	// phase 1 & 2 period
-	Device->WriteCommand( Device, 0xB1 );
-	WriteDataByte( Device, 0xE3 );	// 0xE2 was recommended
-	
-	// set pre-charge V 
-	Device->WriteCommand( Device, 0xBB );
-	WriteDataByte( Device, 0x0F); // 0x1F causes column interferences 
-	
-	// set COM deselect voltage
-	Device->WriteCommand( Device, 0xBE );
-	WriteDataByte( Device, 0x07 );
-	
-	// no Display Inversion
-    Device->WriteCommand( Device, 0xA6 );
-	
-	// gone with the wind
-	Device->DisplayOn( Device );
-	Device->Update( Device );
-	
-	return true;
-}	
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->ReMap = Layout->HFlip ? (Private->ReMap & ~(1 << 1)) : (Private->ReMap | (1 << 1));
+    Private->ReMap = Layout->VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
+    Device->WriteCommand(Device, 0xA0);
+    Device->WriteData(Device, &Private->ReMap, 1);
+    WriteDataByte(Device, 0x11);
+    Device->WriteCommand(Device, Layout->Invert ? 0xA7 : 0xA6);
+}
+
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAF); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAE); }
+
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0xC1);
+    Device->WriteData(Device, &Contrast, 1);
+}
+
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
+    // these displays seems to be layout centered (1 column = 4 pixels of 4 bits each, little endian)
+    Private->Offset = (480 - Device->Width) / 4 / 2;
+
+    // find a page size that is not too small is an integer of height
+    Private->PageSize = min(8, PAGE_BLOCK / (Device->Width / 2));
+    while(Private->PageSize && Device->Height != (Device->Height / Private->PageSize) * Private->PageSize) Private->PageSize--;
+
+#ifdef SHADOW_BUFFER
+    Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+#endif
+    Private->iRAM = heap_caps_malloc(Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+
+    ESP_LOGI(TAG, "SSD1322 with offset %u, page %u, iRAM %p", Private->Offset, Private->PageSize, Private->iRAM);
+
+    // need to be off and disable display RAM
+    Device->DisplayOff(Device);
+    Device->WriteCommand(Device, 0xA5);
+
+    // Display Offset
+    Device->WriteCommand(Device, 0xA2);
+    WriteDataByte(Device, 0);
+
+    // Display Start Line
+    Device->WriteCommand(Device, 0xA1);
+    WriteDataByte(Device, 0x00);
+
+    // set flip modes
+    Private->ReMap = 0;
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+
+    // set Display Enhancement
+    Device->WriteCommand(Device, 0xB4);
+    WriteDataByte(Device, 0xA0);
+    WriteDataByte(Device, 0xB5);
+
+    // set Clocks
+    Device->WriteCommand(Device, 0xB3);
+    WriteDataByte(Device, 0xB2); // 0x91 seems to be common but is too slow for 5.5'
+
+    // set MUX
+    Device->WriteCommand(Device, 0xCA);
+    WriteDataByte(Device, Device->Height - 1);
+
+    // phase 1 & 2 period
+    Device->WriteCommand(Device, 0xB1);
+    WriteDataByte(Device, 0xE3); // 0xE2 was recommended
+
+    // set pre-charge V
+    Device->WriteCommand(Device, 0xBB);
+    WriteDataByte(Device, 0x0F); // 0x1F causes column interferences
+
+    // set COM deselect voltage
+    Device->WriteCommand(Device, 0xBE);
+    WriteDataByte(Device, 0x07);
+
+    // no Display Inversion
+    Device->WriteCommand(Device, 0xA6);
+
+    // gone with the wind
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device SSD1322 = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
-	.SetLayout = SetLayout,
-	.Update = Update, .Init = Init,
-	.Mode = GDS_GRAYSCALE, .Depth = 4,
-};	
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetContrast = SetContrast,
+    .SetLayout = SetLayout,
+    .Update = Update,
+    .Init = Init,
+    .Mode = GDS_GRAYSCALE,
+    .Depth = 4,
+};
 
-struct GDS_Device* SSD1322_Detect(char *Driver, struct GDS_Device* Device) {
-	if (!strcasestr(Driver, "SSD1322")) return NULL;
-		
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	
-	*Device = SSD1322;	
-			
-	return Device;
+struct GDS_Device* SSD1322_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    if(Driver->common.driver != sys_display_drivers_SSD1322) return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+
+    *Device = SSD1322;
+
+    return Device;
 }

components/display/SSD132x.c

@@ -18,332 +18,349 @@
 
 #define SHADOW_BUFFER
 #define USE_IRAM
-#define PAGE_BLOCK	1024
+#define PAGE_BLOCK 1024
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a, b) (((a) < (b)) ? (a) : (b))
 
 static char TAG[] = "SSD132x";
 
 enum { SSD1326, SSD1327 };
 
 struct PrivateSpace {
-	uint8_t *iRAM, *Shadowbuffer;
-	uint8_t ReMap, PageSize;
-	uint8_t Model;
+    uint8_t *iRAM, *Shadowbuffer;
+    uint8_t ReMap, PageSize;
+    uint8_t Model;
 };
 
-static const unsigned char BitReverseTable256[] = 
-{
-  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 
-  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 
-  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 
-  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 
-  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 
-  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
-  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 
-  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
-  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
-  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 
-  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
-  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
-  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 
-  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
-  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 
-  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
-};
+static const unsigned char BitReverseTable256[] = {0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF};
 
 // Functions are not declared to minimize # of lines
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x15 );
-	Device->WriteCommand( Device, Start );
-	Device->WriteCommand( Device, End );
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x15);
+    Device->WriteCommand(Device, Start);
+    Device->WriteCommand(Device, End);
 }
-static void SetRowAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	// can be by row, not by page (see Update Optimization)
-	Device->WriteCommand( Device, 0x75 );
-	Device->WriteCommand( Device, Start );
-	Device->WriteCommand( Device, End );
+static void SetRowAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    // can be by row, not by page (see Update Optimization)
+    Device->WriteCommand(Device, 0x75);
+    Device->WriteCommand(Device, Start);
+    Device->WriteCommand(Device, End);
 }
 
-static void Update4( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
-	// always update by full lines
-	SetColumnAddress( Device, 0, Device->Width / 2 - 1);
-	
+static void Update4(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
+    // always update by full lines
+    SetColumnAddress(Device, 0, Device->Width / 2 - 1);
+
 #ifdef SHADOW_BUFFER
-	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
-	bool dirty = false;
-	
-	for (int r = 0, page = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width always / by 2)
-		for (int c = Device->Width / 2 / 2; --c >= 0;) {
-			if (*optr != *iptr) {
-				dirty = true;
-				*optr = *iptr;
-			}
-			iptr++; optr++;
-		}
-		
-		// one line done, check for page boundary
-		if (++page == Private->PageSize) {
-			if (dirty) {
-				SetRowAddress( Device, r - page + 1, r );
-				// own use of IRAM has not proven to be much better than letting SPI do its copy
-				if (Private->iRAM) {
-					memcpy(Private->iRAM, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );
-					Device->WriteData( Device, Private->iRAM, Device->Width * page / 2 );
-				} else	{
-					Device->WriteData( Device, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2 );					
-				}	
-				dirty = false;
-			}	
-			page = 0;
-		}	
-	}	
+    uint16_t *optr = (uint16_t*)Private->Shadowbuffer, *iptr = (uint16_t*)Device->Framebuffer;
+    bool dirty = false;
+
+    for(int r = 0, page = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width always / by 2)
+        for(int c = Device->Width / 2 / 2; --c >= 0;) {
+            if(*optr != *iptr) {
+                dirty = true;
+                *optr = *iptr;
+            }
+            iptr++;
+            optr++;
+        }
+
+        // one line done, check for page boundary
+        if(++page == Private->PageSize) {
+            if(dirty) {
+                SetRowAddress(Device, r - page + 1, r);
+                // own use of IRAM has not proven to be much better than letting SPI do its copy
+                if(Private->iRAM) {
+                    memcpy(Private->iRAM, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2);
+                    Device->WriteData(Device, Private->iRAM, Device->Width * page / 2);
+                } else {
+                    Device->WriteData(Device, Private->Shadowbuffer + (r - page + 1) * Device->Width / 2, page * Device->Width / 2);
+                }
+                dirty = false;
+            }
+            page = 0;
+        }
+    }
 #else
-	for (int r = 0; r < Device->Height; r += Private->PageSize) {
-		SetRowAddress( Device, r, r + Private->PageSize - 1 );
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
-			Device->WriteData( Device, Private->iRAM, Private->PageSize * Device->Width / 2 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2 );
-		}	
-	}	
-#endif	
+    for(int r = 0; r < Device->Height; r += Private->PageSize) {
+        SetRowAddress(Device, r, r + Private->PageSize - 1);
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2);
+            Device->WriteData(Device, Private->iRAM, Private->PageSize * Device->Width / 2);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width / 2, Private->PageSize * Device->Width / 2);
+        }
+    }
+#endif
 }
 
 /* 
  We have to make a choice here: either we go by row one by one and send lots of 
  small packets on the serial interface or we do a page of N rows once at least
  a change has been detected. So far, choice is to go one-by-one
-*/ 
-static void Update1( struct GDS_Device* Device ) {
+*/
+static void Update1(struct GDS_Device* Device) {
 #ifdef SHADOW_BUFFER
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	// not sure the compiler does not have to redo all calculation in for loops, so local it is
-	int width = Device->Width / 8, rows = Device->Height;
-	uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
-	int CurrentRow = -1, FirstCol = -1, LastCol = -1;
-	
-	// by row, find first and last columns that have been updated
-	for (int r = 0; r < rows; r++) {
-		uint8_t first = 0, last;	
-		for (int c = 0; c < width; c++) {
-			if (*iptr != *optr) {
-				if (!first) first = c + 1;
-				last = c ;
-			}	
-			*optr++ = *iptr++;
-		}
-		
-		// now update the display by "byte rows"
-		if (first--) {
-			// only set column when useful, saves a fair bit of CPU
-			if (first > FirstCol && first <= FirstCol + 4 && last < LastCol && last >= LastCol - 4) {
-				first = FirstCol;
-				last = LastCol;
-			} else {	
-				SetColumnAddress( Device, first, last );
-				FirstCol = first;
-				LastCol = last;
-			}
-			
-			// Set row only when needed, otherwise let auto-increment work
-			if (r != CurrentRow) SetRowAddress( Device, r, Device->Height - 1 );
-			CurrentRow = r + 1;
-			
-			// actual write
-			Device->WriteData( Device, Private->Shadowbuffer + r*width + first, last - first + 1 );
-		}
-	}	
-#else	
-	// automatic counter and end Row/Column
-	SetColumnAddress( Device, 0, Device->Width / 8 - 1);
-	SetRowAddress( Device, 0, Device->Height - 1);
-	Device->WriteData( Device, Device->Framebuffer, Device->FramebufferSize );
-#endif	
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    // not sure the compiler does not have to redo all calculation in for loops, so local it is
+    int width = Device->Width / 8, rows = Device->Height;
+    uint8_t *optr = Private->Shadowbuffer, *iptr = Device->Framebuffer;
+    int CurrentRow = -1, FirstCol = -1, LastCol = -1;
+
+    // by row, find first and last columns that have been updated
+    for(int r = 0; r < rows; r++) {
+        uint8_t first = 0, last;
+        for(int c = 0; c < width; c++) {
+            if(*iptr != *optr) {
+                if(!first) first = c + 1;
+                last = c;
+            }
+            *optr++ = *iptr++;
+        }
+
+        // now update the display by "byte rows"
+        if(first--) {
+            // only set column when useful, saves a fair bit of CPU
+            if(first > FirstCol && first <= FirstCol + 4 && last < LastCol && last >= LastCol - 4) {
+                first = FirstCol;
+                last = LastCol;
+            } else {
+                SetColumnAddress(Device, first, last);
+                FirstCol = first;
+                LastCol = last;
+            }
+
+            // Set row only when needed, otherwise let auto-increment work
+            if(r != CurrentRow) SetRowAddress(Device, r, Device->Height - 1);
+            CurrentRow = r + 1;
+
+            // actual write
+            Device->WriteData(Device, Private->Shadowbuffer + r * width + first, last - first + 1);
+        }
+    }
+#else
+    // automatic counter and end Row/Column
+    SetColumnAddress(Device, 0, Device->Width / 8 - 1);
+    SetRowAddress(Device, 0, Device->Height - 1);
+    Device->WriteData(Device, Device->Framebuffer, Device->FramebufferSize);
+#endif
 }
 
 // in 1 bit mode, SSD1326 has a different memory map than SSD1306 and SH1106
-static void IRAM_ATTR _DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-    uint32_t XBit = ( X & 0x07 );
-    uint8_t* FBOffset = Device->Framebuffer + ( ( Y * Device->Width + X ) >> 3 );
+static void IRAM_ATTR _DrawPixel1Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint32_t XBit = (X & 0x07);
+    uint8_t* FBOffset = Device->Framebuffer + ((Y * Device->Width + X) >> 3);
 
-    if ( Color == GDS_COLOR_XOR ) {
-        *FBOffset ^= BIT( 7 - XBit );
+    if(Color == GDS_COLOR_XOR) {
+        *FBOffset ^= BIT(7 - XBit);
     } else {
-		// we might be able to save the 7-Xbit using BitRemap (A0 bit 2)
-        *FBOffset = ( Color == GDS_COLOR_BLACK ) ?  *FBOffset & ~BIT( XBit ) : *FBOffset | BIT( XBit );
+        // we might be able to save the 7-Xbit using BitRemap (A0 bit 2)
+        *FBOffset = (Color == GDS_COLOR_BLACK) ? *FBOffset & ~BIT(XBit) : *FBOffset | BIT(XBit);
     }
 }
 
-static void ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
-	uint8_t _Color = Color == GDS_COLOR_BLACK ? 0: 0xff;
-	int Width = Device->Width >> 3;
-	uint8_t *optr = Device->Framebuffer;
-	
-	for (int r = y1; r <= y2; r++) {
-		int c = x1;
-		// for a row that is not on a boundary, not column opt can be done, so handle all columns on that line
-		while (c & 0x07 && c <= x2) _DrawPixel1Fast( Device, c++, r, Color );
-		// at this point we are aligned on column boundary
-		int chunk = (x2 - c + 1) >> 3;
-		memset(optr + Width * r + (c >> 3), _Color, chunk );
-		c += chunk * 8;
-		while (c <= x2) _DrawPixel1Fast( Device, c++, r, Color );
-	}
+static void ClearWindow(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color) {
+    uint8_t _Color = Color == GDS_COLOR_BLACK ? 0 : 0xff;
+    int Width = Device->Width >> 3;
+    uint8_t* optr = Device->Framebuffer;
+
+    for(int r = y1; r <= y2; r++) {
+        int c = x1;
+        // for a row that is not on a boundary, not column opt can be done, so handle all columns on that line
+        while(c & 0x07 && c <= x2) _DrawPixel1Fast(Device, c++, r, Color);
+        // at this point we are aligned on column boundary
+        int chunk = (x2 - c + 1) >> 3;
+        memset(optr + Width * r + (c >> 3), _Color, chunk);
+        c += chunk * 8;
+        while(c <= x2) _DrawPixel1Fast(Device, c++, r, Color);
+    }
 }
 
-static void DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color ) {
-	if (!Height) Height = Device->Height;
-	if (!Width) Width = Device->Width;
-	int DWidth = Device->Width >> 3;
-	
-	// Two consecutive bits of source data are split over two different bytes of framebuffer
-	for (int c = 0; c < Width; c++) {
-		uint8_t shift = c & 0x07, bit = ~(1 << shift);
-		uint8_t *optr = Device->Framebuffer + (c >> 3);
-		
-		// we need to linearize code to let compiler better optimize
-		for (int r = Height >> 3; --r >= 0;) {
-			uint8_t Byte = BitReverseTable256[*Data++];
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth; Byte >>= 1;
-			*optr = (*optr & bit) | ((Byte & 0x01) << shift); optr += DWidth;
-		}	
-	}
+static void DrawBitmapCBR(struct GDS_Device* Device, uint8_t* Data, int Width, int Height, int Color) {
+    if(!Height) Height = Device->Height;
+    if(!Width) Width = Device->Width;
+    int DWidth = Device->Width >> 3;
+
+    // Two consecutive bits of source data are split over two different bytes of framebuffer
+    for(int c = 0; c < Width; c++) {
+        uint8_t shift = c & 0x07, bit = ~(1 << shift);
+        uint8_t* optr = Device->Framebuffer + (c >> 3);
+
+        // we need to linearize code to let compiler better optimize
+        for(int r = Height >> 3; --r >= 0;) {
+            uint8_t Byte = BitReverseTable256[*Data++];
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+            Byte >>= 1;
+            *optr = (*optr & bit) | ((Byte & 0x01) << shift);
+            optr += DWidth;
+        }
+    }
 }
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	if (Private->Model == SSD1326) {
-		Private->ReMap = HFlip ? (Private->ReMap | ((1 << 0) | (1 << 2))) : (Private->ReMap & ~((1 << 0) | (1 << 2)));
-		Private->ReMap = HFlip ? (Private->ReMap | (1 << 1)) : (Private->ReMap & ~(1 << 1));		
-	} else {
-		Private->ReMap = VFlip ? (Private->ReMap | ((1 << 0) | (1 << 1))) : (Private->ReMap & ~((1 << 0) | (1 << 1)));
-		Private->ReMap = VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
-	}	
-	Device->WriteCommand( Device, 0xA0 );
-	Device->WriteCommand( Device, Private->ReMap );
-}	
-
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-    Device->WriteCommand( Device, 0x81 );
-    Device->WriteCommand( Device, Contrast );
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    if(Private->Model == SSD1326) {
+        Private->ReMap = Layout->HFlip ? (Private->ReMap | ((1 << 0) | (1 << 2))) : (Private->ReMap & ~((1 << 0) | (1 << 2)));
+        Private->ReMap = Layout->HFlip ? (Private->ReMap | (1 << 1)) : (Private->ReMap & ~(1 << 1));
+    } else {
+        Private->ReMap = Layout->VFlip ? (Private->ReMap | ((1 << 0) | (1 << 1))) : (Private->ReMap & ~((1 << 0) | (1 << 1)));
+        Private->ReMap = Layout->VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
+    }
+    Device->WriteCommand(Device, 0xA0);
+    Device->WriteCommand(Device, Private->ReMap);
+    Device->WriteCommand(Device, Layout->Invert ? 0xA7 : 0xA4);
 }
 
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	
-	// find a page size that is not too small is an integer of height
-	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width / 2));
-	while (Private->PageSize && Device->Height != (Device->Height / Private->PageSize) * Private->PageSize) Private->PageSize--;
-	
-#ifdef SHADOW_BUFFER	
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAF); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAE); }
+
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0x81);
+    Device->WriteCommand(Device, Contrast);
+}
+
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
+    // find a page size that is not too small is an integer of height
+    Private->PageSize = min(8, PAGE_BLOCK / (Device->Width / 2));
+    while(Private->PageSize && Device->Height != (Device->Height / Private->PageSize) * Private->PageSize) Private->PageSize--;
+
+#ifdef SHADOW_BUFFER
 #ifdef USE_IRAM
-	if (Device->IF == GDS_IF_SPI) {
-		if (Device->Depth == 1) {
-			Private->Shadowbuffer = heap_caps_malloc( Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-		} else {
-			Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-			Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-		}	
-	} else
+    if(Device->IF == GDS_IF_SPI) {
+        if(Device->Depth == 1) {
+            Private->Shadowbuffer = heap_caps_malloc(Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+        } else {
+            Private->Shadowbuffer = malloc(Device->FramebufferSize);
+            Private->iRAM = heap_caps_malloc(Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+        }
+    } else
 #endif
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+        Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
 #else
-#ifdef USE_IRAM	
-	if (Device->Depth == 4 && Device->IF == GDS_IF_SPI) Private->iRAM = heap_caps_malloc( Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-#endif	
+#ifdef USE_IRAM
+    if(Device->Depth == 4 && Device->IF == GDS_IF_SPI)
+        Private->iRAM = heap_caps_malloc(Private->PageSize * Device->Width / 2, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+#endif
 #endif
 
-	ESP_LOGI(TAG, "SSD1326/7 with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
-			
-	// need to be off and disable display RAM
-	Device->DisplayOff( Device );
-    Device->WriteCommand( Device, 0xA5 );
-	
-	// need COM split (6)
-	Private->ReMap = 1 << 6;
-	// MUX Ratio
-    Device->WriteCommand( Device, 0xA8 );
-    Device->WriteCommand( Device, Device->Height - 1);
-	// Display Offset
-    Device->WriteCommand( Device, 0xA2 );
-    Device->WriteCommand( Device, 0 );
-	// Display Start Line
-    Device->WriteCommand( Device, 0xA1 );
-	Device->WriteCommand( Device, 0x00 );
-	Device->SetContrast( Device, 0x7F );
-	// set flip modes
-	Device->SetLayout( Device, false, false, false );
-	// no Display Inversion
-    Device->WriteCommand( Device, 0xA6 );
-	// set Clocks
-    Device->WriteCommand( Device, 0xB3 );
-    Device->WriteCommand( Device, ( 0x08 << 4 ) | 0x00 );
-	// set Adressing Mode Horizontal
-	Private->ReMap |= (0 << 2);
-	// set monotchrome mode if required
-	if (Device->Depth == 1) Private->ReMap |= (1 << 4);
-	// write ReMap byte
-	Device->WriteCommand( Device, 0xA0 );
-	Device->WriteCommand( Device, Private->ReMap );		
-		
-	// gone with the wind
-	Device->WriteCommand( Device, 0xA4 );
-	Device->DisplayOn( Device );
-	Device->Update( Device );
-	
-	return true;
-}	
+    ESP_LOGI(TAG, "SSD1326/7 with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
+
+    // need to be off and disable display RAM
+    Device->DisplayOff(Device);
+    Device->WriteCommand(Device, 0xA5);
+
+    // need COM split (6)
+    Private->ReMap = 1 << 6;
+    // MUX Ratio
+    Device->WriteCommand(Device, 0xA8);
+    Device->WriteCommand(Device, Device->Height - 1);
+    // Display Offset
+    Device->WriteCommand(Device, 0xA2);
+    Device->WriteCommand(Device, 0);
+    // Display Start Line
+    Device->WriteCommand(Device, 0xA1);
+    Device->WriteCommand(Device, 0x00);
+    Device->SetContrast(Device, 0x7F);
+    // set flip modes
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+    // no Display Inversion
+    Device->WriteCommand(Device, 0xA6);
+    // set Clocks
+    Device->WriteCommand(Device, 0xB3);
+    Device->WriteCommand(Device, (0x08 << 4) | 0x00);
+    // set Adressing Mode Horizontal
+    Private->ReMap |= (0 << 2);
+    // set monotchrome mode if required
+    if(Device->Depth == 1) Private->ReMap |= (1 << 4);
+    // write ReMap byte
+    Device->WriteCommand(Device, 0xA0);
+    Device->WriteCommand(Device, Private->ReMap);
+
+    // gone with the wind
+    Device->WriteCommand(Device, 0xA4);
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device SSD132x = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
-	.SetLayout = SetLayout,
-	.Update = Update4, .Init = Init,
-	.Mode = GDS_GRAYSCALE, .Depth = 4,
-};	
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetContrast = SetContrast,
+    .SetLayout = SetLayout,
+    .Update = Update4,
+    .Init = Init,
+    .Mode = GDS_GRAYSCALE,
+    .Depth = 4,
+};
 
-struct GDS_Device* SSD132x_Detect(char *Driver, struct GDS_Device* Device) {
-	uint8_t Model;
-	int Depth;
-		
-	if (strcasestr(Driver, "SSD1326")) Model = SSD1326;
-	else if (strcasestr(Driver, "SSD1327")) Model = SSD1327;
-	else return NULL;
-	
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	
-	*Device = SSD132x;	
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	Private->Model = Model;
-		
-	sscanf(Driver, "%*[^:]:%u", &Depth);
-		
-	if (Model == SSD1326 && Depth == 1) {
-		Device->Update = Update1;
-		Device->DrawPixelFast = _DrawPixel1Fast;
-		Device->DrawBitmapCBR = DrawBitmapCBR;
-		Device->ClearWindow = ClearWindow;
-		Device->Depth = 1;		
-		Device->Mode = GDS_MONO;
-#if !defined SHADOW_BUFFER && defined USE_IRAM	
-		Device->Alloc = GDS_ALLOC_IRAM_SPI;
-#endif	
-	}
-	
-	return Device;
+struct GDS_Device* SSD132x_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    uint8_t Model;
+    int Depth;
+
+    if(Driver->common.driver == sys_display_drivers_SSD1326)
+        Model = SSD1326;
+    else if(Driver->common.driver == sys_display_drivers_SSD1327)
+        Model = SSD1327;
+    return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+
+    *Device = SSD132x;
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->Model = Model;
+
+    Depth = Driver->common.bitDepth != 0 ? Driver->common.bitDepth : 1;
+
+    if(Model == SSD1326 && Depth == 1) {
+        Device->Update = Update1;
+        Device->DrawPixelFast = _DrawPixel1Fast;
+        Device->DrawBitmapCBR = DrawBitmapCBR;
+        Device->ClearWindow = ClearWindow;
+        Device->Depth = 1;
+        Device->Mode = GDS_MONO;
+#if !defined SHADOW_BUFFER && defined USE_IRAM
+        Device->Alloc = GDS_ALLOC_IRAM_SPI;
+#endif
+    }
+
+    return Device;
 }

components/display/SSD1351.c

@@ -18,269 +18,277 @@
 
 #define SHADOW_BUFFER
 #define USE_IRAM
-#define PAGE_BLOCK		2048
-#define ENABLE_WRITE	0x5c
+#define PAGE_BLOCK 2048
+#define ENABLE_WRITE 0x5c
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a, b) (((a) < (b)) ? (a) : (b))
 
 static char TAG[] = "SSD1351";
 
 struct PrivateSpace {
-	uint8_t *iRAM, *Shadowbuffer;
-	uint8_t ReMap, PageSize;
+    uint8_t *iRAM, *Shadowbuffer;
+    uint8_t ReMap, PageSize;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void WriteByte( struct GDS_Device* Device, uint8_t Data ) {
-	Device->WriteData( Device, &Data, 1 );
+static void WriteByte(struct GDS_Device* Device, uint8_t Data) { Device->WriteData(Device, &Data, 1); }
+
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x15);
+    WriteByte(Device, Start);
+    WriteByte(Device, End);
+}
+static void SetRowAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    Device->WriteCommand(Device, 0x75);
+    WriteByte(Device, Start);
+    WriteByte(Device, End);
 }
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x15 );
-	WriteByte( Device, Start );
-	WriteByte( Device, End );
-}
-static void SetRowAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	Device->WriteCommand( Device, 0x75 );
-	WriteByte( Device, Start );
-	WriteByte( Device, End );
-}
+static void Update16(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
 
-static void Update16( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
 #ifdef SHADOW_BUFFER
-	uint32_t *optr = (uint32_t*) Private->Shadowbuffer, *iptr = (uint32_t*) Device->Framebuffer;
-	int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
-	
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width is always a multiple of 2)
-		for (int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
+    uint32_t *optr = (uint32_t*)Private->Shadowbuffer, *iptr = (uint32_t*)Device->Framebuffer;
+    int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
 
-		// wait for a large enough window - careful that window size might increase by more than a line at once !
-		if (FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol *= 2;
-		LastCol = LastCol * 2 + 1;
-		SetRowAddress( Device, FirstRow, LastRow );
-		SetColumnAddress( Device, FirstCol, LastCol );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 2;
-			
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM < PAGE_BLOCK && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize );
-		}	
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width is always a multiple of 2)
+        for(int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
 
-		FirstCol = Device->Width / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+        // wait for a large enough window - careful that window size might increase by more than a line at once !
+        if(FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
+
+        FirstCol *= 2;
+        LastCol = LastCol * 2 + 1;
+        SetRowAddress(Device, FirstRow, LastRow);
+        SetColumnAddress(Device, FirstCol, LastCol);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 2;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM < PAGE_BLOCK && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+            }
+
+        FirstCol = Device->Width / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, 0, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, r, r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);		
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 2 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, 0, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, r, r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 2);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+        }
+    }
+#endif
 }
 
-static void Update24( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
-		
+static void Update24(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
+
 #ifdef SHADOW_BUFFER
-	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
-	
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width always / by 2)
-		for (int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
-		
-		// do we have enough to send (cols are divided by 3/2)
-		if (FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2 + 3 - 1) / 3) * (r - FirstRow + 1) * 3 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol = (FirstCol * 2) / 3;
-		LastCol = (LastCol * 2 + 1) / 3; 
-		SetRowAddress( Device, FirstRow, LastRow );
-		SetColumnAddress( Device, FirstCol, LastCol );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 3;
-					
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM < PAGE_BLOCK && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}	
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize );
-		}	
+    uint16_t *optr = (uint16_t*)Private->Shadowbuffer, *iptr = (uint16_t*)Device->Framebuffer;
 
-		FirstCol = (Device->Width * 3) / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width always / by 2)
+        for(int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
+
+        // do we have enough to send (cols are divided by 3/2)
+        if(FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2 + 3 - 1) / 3) * (r - FirstRow + 1) * 3 < PAGE_BLOCK && r != Device->Height - 1)) continue;
+
+        FirstCol = (FirstCol * 2) / 3;
+        LastCol = (LastCol * 2 + 1) / 3;
+        SetRowAddress(Device, FirstRow, LastRow);
+        SetColumnAddress(Device, FirstCol, LastCol);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 3;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM < PAGE_BLOCK && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+            }
+
+        FirstCol = (Device->Width * 3) / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, 0, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, r, r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 3 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, 0, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, r, r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 3);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+        }
+    }
+#endif
 }
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	Private->ReMap = HFlip ? (Private->ReMap & ~(1 << 1)) : (Private->ReMap | (1 << 1));
-	Private->ReMap = VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
-	Device->WriteCommand( Device, 0xA0 );
-	WriteByte( Device, Private->ReMap );
-}	
-
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAF ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0xAE ); }
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-    Device->WriteCommand( Device, 0xC7 );
-	WriteByte( Device, Contrast >> 4);
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->ReMap = Layout->HFlip ? (Private->ReMap & ~(1 << 1)) : (Private->ReMap | (1 << 1));
+    Private->ReMap = Layout->VFlip ? (Private->ReMap | (1 << 4)) : (Private->ReMap & ~(1 << 4));
+    Device->WriteCommand(Device, 0xA0);
+    WriteByte(Device, Private->ReMap);
+    Device->WriteCommand(Device, Layout->Invert ? 0xA7 : 0xA6);
 }
 
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	int Depth = (Device->Depth + 8 - 1) / 8;
-	
-	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
-	
-#ifdef SHADOW_BUFFER	
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAF); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0xAE); }
+
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0xC7);
+    WriteByte(Device, Contrast >> 4);
+}
+
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    int Depth = (Device->Depth + 8 - 1) / 8;
+
+    Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
+
+#ifdef SHADOW_BUFFER
+    Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
 #endif
 #ifdef USE_IRAM
-	Private->iRAM = heap_caps_malloc( (Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+    Private->iRAM = heap_caps_malloc((Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
 #endif
 
-	ESP_LOGI(TAG, "SSD1351 with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
-	
-	// unlock (specially 0xA2)
-	Device->WriteCommand( Device, 0xFD);
-	WriteByte(Device, 0xB1);
-		
-	// set clocks
-	/*
+    ESP_LOGI(TAG, "SSD1351 with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
+
+    // unlock (specially 0xA2)
+    Device->WriteCommand(Device, 0xFD);
+    WriteByte(Device, 0xB1);
+
+    // set clocks
+    /*
     Device->WriteCommand( Device, 0xB3 );
     WriteByte( Device, ( 0x08 << 4 ) | 0x00 );
 	*/
 
-	// need to be off and disable display RAM
-	Device->DisplayOff( Device );
+    // need to be off and disable display RAM
+    Device->DisplayOff(Device);
 
-	// need COM split (5)
-	Private->ReMap = (1 << 5);
-	
-	// Display Offset
-    Device->WriteCommand( Device, 0xA2 );
-    WriteByte( Device, 0x00 );
+    // need COM split (5)
+    Private->ReMap = (1 << 5);
 
-	// Display Start Line
-    Device->WriteCommand( Device, 0xA1 );
-	WriteByte( Device, 0x00 );
-	
-	// set flip modes & contrast
-	Device->SetContrast( Device, 0x7F );
-	Device->SetLayout( Device, false, false, false );
-	
-	// set Adressing Mode Horizontal
-	Private->ReMap |= (0 << 2);
-	// set screen depth (16/18)
-	if (Device->Depth == 24) Private->ReMap |= (0x02 << 6);
-	// write ReMap byte
-	Device->WriteCommand( Device, 0xA0 );
-	WriteByte( Device, Private->ReMap );		
-	
-	// no Display Inversion
-    Device->WriteCommand( Device, 0xA6 );	
-	
-	// gone with the wind
-	Device->DisplayOn( Device );
-	Device->Update( Device );
-	
-	return true;
-}	
+    // Display Offset
+    Device->WriteCommand(Device, 0xA2);
+    WriteByte(Device, 0x00);
+
+    // Display Start Line
+    Device->WriteCommand(Device, 0xA1);
+    WriteByte(Device, 0x00);
+
+    // set flip modes & contrast
+    Device->SetContrast(Device, 0x7F);
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+
+    // set Adressing Mode Horizontal
+    Private->ReMap |= (0 << 2);
+    // set screen depth (16/18)
+    if(Device->Depth == 24) Private->ReMap |= (0x02 << 6);
+    // write ReMap byte
+    Device->WriteCommand(Device, 0xA0);
+    WriteByte(Device, Private->ReMap);
+
+    // no Display Inversion
+    Device->WriteCommand(Device, 0xA6);
+
+    // gone with the wind
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device SSD1351 = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff, .SetContrast = SetContrast,
-	.SetLayout = SetLayout,
-	.Update = Update16, .Init = Init,
-	.Mode = GDS_RGB565, .Depth = 16,
-};	
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetContrast = SetContrast,
+    .SetLayout = SetLayout,
+    .Update = Update16,
+    .Init = Init,
+    .Mode = GDS_RGB565,
+    .Depth = 16,
+};
 
-struct GDS_Device* SSD1351_Detect(char *Driver, struct GDS_Device* Device) {
-	int Depth;
-	
-	if (!strcasestr(Driver, "SSD1351")) return NULL;
-	
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	
-	*Device = SSD1351;	
-	sscanf(Driver, "%*[^:]:%u", &Depth);
-	
-	if (Depth == 18) {
-		Device->Mode = GDS_RGB666;
-		Device->Depth = 24;
-		Device->Update = Update24;
-	} 	
-	
-	return Device;
+struct GDS_Device* SSD1351_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    int Depth;
+
+    if(Driver->common.driver != sys_display_drivers_SSD1351) return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+
+    *Device = SSD1351;
+    Depth = Driver->common.bitDepth != 0 ? Driver->common.bitDepth : 18;
+
+    if(Depth == 18) {
+        Device->Mode = GDS_RGB666;
+        Device->Depth = 24;
+        Device->Update = Update24;
+    }
+
+    return Device;
 }

components/display/SSD1675.c

@@ -13,6 +13,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "driver/gpio.h"
+#include "esp_rom_gpio.h"
 #include <esp_log.h>
 
 #include "gds.h"
@@ -21,231 +22,351 @@
 static char TAG[] = "SSD1675";
 
 const unsigned char EPD_lut_full_update[] = {
-    0x80,0x60,0x40,0x00,0x00,0x00,0x00,             //LUT0: BB:     VS 0 ~7
-    0x10,0x60,0x20,0x00,0x00,0x00,0x00,             //LUT1: BW:     VS 0 ~7
-    0x80,0x60,0x40,0x00,0x00,0x00,0x00,             //LUT2: WB:     VS 0 ~7
-    0x10,0x60,0x20,0x00,0x00,0x00,0x00,             //LUT3: WW:     VS 0 ~7
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT4: VCOM:   VS 0 ~7
-    0x03,0x03,0x00,0x00,0x02,                       // TP0 A~D RP0
-    0x09,0x09,0x00,0x00,0x02,                       // TP1 A~D RP1
-    0x03,0x03,0x00,0x00,0x02,                       // TP2 A~D RP2
-    0x00,0x00,0x00,0x00,0x00,                       // TP3 A~D RP3
-    0x00,0x00,0x00,0x00,0x00,                       // TP4 A~D RP4
-    0x00,0x00,0x00,0x00,0x00,                       // TP5 A~D RP5
-    0x00,0x00,0x00,0x00,0x00,                       // TP6 A~D RP6
-    0x15,0x41,0xA8,0x32,0x30,0x0A,
+    0x80,
+    0x60,
+    0x40,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT0: BB:     VS 0 ~7
+    0x10,
+    0x60,
+    0x20,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT1: BW:     VS 0 ~7
+    0x80,
+    0x60,
+    0x40,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT2: WB:     VS 0 ~7
+    0x10,
+    0x60,
+    0x20,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT3: WW:     VS 0 ~7
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT4: VCOM:   VS 0 ~7
+    0x03,
+    0x03,
+    0x00,
+    0x00,
+    0x02, // TP0 A~D RP0
+    0x09,
+    0x09,
+    0x00,
+    0x00,
+    0x02, // TP1 A~D RP1
+    0x03,
+    0x03,
+    0x00,
+    0x00,
+    0x02, // TP2 A~D RP2
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP3 A~D RP3
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP4 A~D RP4
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP5 A~D RP5
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP6 A~D RP6
+    0x15,
+    0x41,
+    0xA8,
+    0x32,
+    0x30,
+    0x0A,
 };
 
-const unsigned char EPD_lut_partial_update[]= { //20 bytes
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT0: BB:     VS 0 ~7
-    0x80,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT1: BW:     VS 0 ~7
-    0x40,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT2: WB:     VS 0 ~7
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT3: WW:     VS 0 ~7
-    0x00,0x00,0x00,0x00,0x00,0x00,0x00,             //LUT4: VCOM:   VS 0 ~7
-    0x0A,0x00,0x00,0x00,0x00,                       // TP0 A~D RP0
-    0x00,0x00,0x00,0x00,0x00,                       // TP1 A~D RP1
-    0x00,0x00,0x00,0x00,0x00,                       // TP2 A~D RP2
-    0x00,0x00,0x00,0x00,0x00,                       // TP3 A~D RP3
-    0x00,0x00,0x00,0x00,0x00,                       // TP4 A~D RP4
-    0x00,0x00,0x00,0x00,0x00,                       // TP5 A~D RP5
-    0x00,0x00,0x00,0x00,0x00,                       // TP6 A~D RP6
-    0x15,0x41,0xA8,0x32,0x30,0x0A,
+const unsigned char EPD_lut_partial_update[] = {
+    //20 bytes
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT0: BB:     VS 0 ~7
+    0x80,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT1: BW:     VS 0 ~7
+    0x40,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT2: WB:     VS 0 ~7
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT3: WW:     VS 0 ~7
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, //LUT4: VCOM:   VS 0 ~7
+    0x0A,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP0 A~D RP0
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP1 A~D RP1
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP2 A~D RP2
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP3 A~D RP3
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP4 A~D RP4
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP5 A~D RP5
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00, // TP6 A~D RP6
+    0x15,
+    0x41,
+    0xA8,
+    0x32,
+    0x30,
+    0x0A,
 };
 
 struct PrivateSpace {
-	int	ReadyPin;
-	uint16_t Height;
+    int ReadyPin;
+    uint16_t Height;
 };
 
 // Functions are not declared to minimize # of lines
 
-void WaitReady( struct GDS_Device* Device) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	if (Private->ReadyPin >= 0) {
-		int count = 4*1000;
-		while (gpio_get_level( Private->ReadyPin ) && count) {
-			vTaskDelay( pdMS_TO_TICKS(100) );
-			count -= 100;
-		}	
-	} else {
-		vTaskDelay( pdMS_TO_TICKS(2000) );
-	}	
-}	
-
-static void WriteByte( struct GDS_Device* Device, uint8_t Data ) {
-	Device->WriteData( Device, &Data, 1 );
+void WaitReady(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    if(Private->ReadyPin >= 0) {
+        int count = 4 * 1000;
+        while(gpio_get_level(Private->ReadyPin) && count) {
+            vTaskDelay(pdMS_TO_TICKS(100));
+            count -= 100;
+        }
+    } else {
+        vTaskDelay(pdMS_TO_TICKS(2000));
+    }
 }
 
-static void SetColumnAddress( struct GDS_Device* Device, uint8_t Start, uint8_t End ) {
-	// start might be greater than end if we decrement
-	Device->WriteCommand( Device, 0x44 );
-	Device->WriteData( Device, &Start, 1 );
-	Device->WriteData( Device, &End, 1 );
-	
-	// we obviously want to start ... from the start
-	Device->WriteCommand( Device, 0x4e );	
-	WriteByte( Device, Start );
+static void WriteByte(struct GDS_Device* Device, uint8_t Data) { Device->WriteData(Device, &Data, 1); }
+
+static void SetColumnAddress(struct GDS_Device* Device, uint8_t Start, uint8_t End) {
+    // start might be greater than end if we decrement
+    Device->WriteCommand(Device, 0x44);
+    Device->WriteData(Device, &Start, 1);
+    Device->WriteData(Device, &End, 1);
+
+    // we obviously want to start ... from the start
+    Device->WriteCommand(Device, 0x4e);
+    WriteByte(Device, Start);
 }
-static void SetRowAddress( struct GDS_Device* Device, uint16_t Start, uint16_t End ) {
-	// start might be greater than end if we decrement
-	Device->WriteCommand( Device, 0x45 );	
-	WriteByte( Device, Start );
-	WriteByte( Device, Start >> 8 );
-	WriteByte( Device, End );
-	WriteByte( Device, End >> 8 );
-	
-	// we obviously want to start ... from the start
-	Device->WriteCommand( Device, 0x4f );	
-	WriteByte( Device, Start );
-	WriteByte( Device, Start >> 8 );
+static void SetRowAddress(struct GDS_Device* Device, uint16_t Start, uint16_t End) {
+    // start might be greater than end if we decrement
+    Device->WriteCommand(Device, 0x45);
+    WriteByte(Device, Start);
+    WriteByte(Device, Start >> 8);
+    WriteByte(Device, End);
+    WriteByte(Device, End >> 8);
+
+    // we obviously want to start ... from the start
+    Device->WriteCommand(Device, 0x4f);
+    WriteByte(Device, Start);
+    WriteByte(Device, Start >> 8);
 }
 
-static void Update( struct GDS_Device* Device ) {
-	uint8_t *iptr = Device->Framebuffer;
-	
-	Device->WriteCommand( Device, 0x24 );
-	
-	// this is awfully slow, but e-ink are slow anyway ...
-	for (int i = Device->FramebufferSize; --i >= 0;) {
-		WriteByte( Device, ~*iptr++ );
-	}	
-	
-	Device->WriteCommand( Device, 0x22 ); 
-    WriteByte( Device, 0xC7);
-    Device->WriteCommand( Device, 0X20 );
+static void Update(struct GDS_Device* Device) {
+    uint8_t* iptr = Device->Framebuffer;
 
-	WaitReady( Device );
+    Device->WriteCommand(Device, 0x24);
+
+    // this is awfully slow, but e-ink are slow anyway ...
+    for(int i = Device->FramebufferSize; --i >= 0;) { WriteByte(Device, ~*iptr++); }
+
+    Device->WriteCommand(Device, 0x22);
+    WriteByte(Device, 0xC7);
+    Device->WriteCommand(Device, 0X20);
+
+    WaitReady(Device);
 }
 
 // remember that for these ELD drivers W and H are "inverted"
-static inline void _DrawPixel( struct GDS_Device* Device, int X, int Y, int Color ) {
-    uint32_t YBit = ( Y & 0x07 );
-    Y>>= 3;
+static inline void _DrawPixel(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint32_t YBit = (Y & 0x07);
+    Y >>= 3;
 
-    uint8_t* FBOffset = Device->Framebuffer + ( ( Y * Device->Width ) + X );
-    *FBOffset = ( Color == GDS_COLOR_BLACK ) ? *FBOffset & ~BIT( 7-YBit ) : *FBOffset | BIT( 7-YBit );
-}	
-
-static void ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
-	for (int r = y1; r <= y2; r++) {
-		for (int c = x1; c <= x2; c++) {
-			_DrawPixel( Device, c, r, Color );
-		}	
-	}
+    uint8_t* FBOffset = Device->Framebuffer + ((Y * Device->Width) + X);
+    *FBOffset = (Color == GDS_COLOR_BLACK) ? *FBOffset & ~BIT(7 - YBit) : *FBOffset | BIT(7 - YBit);
 }
 
-static void DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color ) {
-	if (!Height) Height = Device->Height;
-	if (!Width) Width = Device->Width;
-	
-	// just do row/column swap
-	for (int r = 0; r < Height; r++) {
-		uint8_t *optr = Device->Framebuffer + r*Device->Width, *iptr = Data + r;
-		for (int c = Width; --c >= 0;) {
-			*optr++ = *iptr;
-			iptr += Height;
-		}	
-	}
+static void ClearWindow(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color) {
+    for(int r = y1; r <= y2; r++) {
+        for(int c = x1; c <= x2; c++) { _DrawPixel(Device, c, r, Color); }
+    }
 }
 
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	
-	// need to re-adjust framebuffer because these are non % 8 
-	Private->Height = Device->Height;
-	if (Device->Height & 0x07) Device->Height = ((Device->Height >> 3) + 1) << 3;
-	
-	Device->FramebufferSize = Device->Width * Device->Height / 8;
-	Device->Framebuffer = calloc(1, Device->FramebufferSize);
-	NullCheck( Device->Framebuffer, return false );
-	
-	if (Private->ReadyPin >= 0) {
-		gpio_pad_select_gpio( Private->ReadyPin );
-		gpio_set_pull_mode( Private->ReadyPin, GPIO_PULLUP_ONLY);
-		gpio_set_direction( Private->ReadyPin, GPIO_MODE_INPUT );
-	}
-	
-	// soft reset	
-	vTaskDelay(pdMS_TO_TICKS( 2000 ));
-    Device->WriteCommand( Device, 0x12 ); 	
-	WaitReady( Device );
-	
-	Device->WriteCommand( Device, 0x74 ); 			
-    WriteByte( Device, 0x54 );
-	Device->WriteCommand( Device, 0x7e ); 			
-    WriteByte( Device, 0x3B );
-	
-	Device->WriteCommand( Device, 0x3c );	
-    WriteByte( Device, 0x03 );
-	
-	Device->WriteCommand( Device, 0x2c );	
-    WriteByte( Device, 0x55 );
+static void DrawBitmapCBR(struct GDS_Device* Device, uint8_t* Data, int Width, int Height, int Color) {
+    if(!Height) Height = Device->Height;
+    if(!Width) Width = Device->Width;
 
-	Device->WriteCommand( Device, 0x03 );	
-	WriteByte( Device, EPD_lut_full_update[70] );
-	
-	Device->WriteCommand( Device, 0x04 );	
-	WriteByte( Device, EPD_lut_full_update[71] );
-	WriteByte( Device, EPD_lut_full_update[72] );
-	WriteByte( Device, EPD_lut_full_update[73] );
-	
-	Device->WriteCommand( Device, 0x3a );	
-	WriteByte( Device, EPD_lut_full_update[74] );
-	Device->WriteCommand( Device, 0x3b );	
-	WriteByte( Device, EPD_lut_full_update[75] );
-	
-	Device->WriteCommand( Device, 0X32 );	
-	for (int i = 0; i < 70; i++) {
-		WriteByte( Device, EPD_lut_full_update[i] );
-	}	
+    // just do row/column swap
+    for(int r = 0; r < Height; r++) {
+        uint8_t *optr = Device->Framebuffer + r * Device->Width, *iptr = Data + r;
+        for(int c = Width; --c >= 0;) {
+            *optr++ = *iptr;
+            iptr += Height;
+        }
+    }
+}
 
-	// now deal with funny X/Y layout (W and H are "inverted")
-	Device->WriteCommand( Device, 0x01 );
-    WriteByte( Device, Device->Width - 1 );
-    WriteByte( Device, (Device->Width - 1) >> 8 );
-    WriteByte( Device, (0 << 0) );		
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
 
-	/* 
+    // need to re-adjust framebuffer because these are non % 8
+    Private->Height = Device->Height;
+    if(Device->Height & 0x07) Device->Height = ((Device->Height >> 3) + 1) << 3;
+
+    Device->FramebufferSize = Device->Width * Device->Height / 8;
+    Device->Framebuffer = calloc(1, Device->FramebufferSize);
+    NullCheck(Device->Framebuffer, return false);
+
+    if(Private->ReadyPin >= 0) {
+        esp_rom_gpio_pad_select_gpio(Private->ReadyPin);
+        gpio_set_pull_mode(Private->ReadyPin, GPIO_PULLUP_ONLY);
+        gpio_set_direction(Private->ReadyPin, GPIO_MODE_INPUT);
+    }
+
+    // soft reset
+    vTaskDelay(pdMS_TO_TICKS(2000));
+    Device->WriteCommand(Device, 0x12);
+    WaitReady(Device);
+
+    Device->WriteCommand(Device, 0x74);
+    WriteByte(Device, 0x54);
+    Device->WriteCommand(Device, 0x7e);
+    WriteByte(Device, 0x3B);
+
+    Device->WriteCommand(Device, 0x3c);
+    WriteByte(Device, 0x03);
+
+    Device->WriteCommand(Device, 0x2c);
+    WriteByte(Device, 0x55);
+
+    Device->WriteCommand(Device, 0x03);
+    WriteByte(Device, EPD_lut_full_update[70]);
+
+    Device->WriteCommand(Device, 0x04);
+    WriteByte(Device, EPD_lut_full_update[71]);
+    WriteByte(Device, EPD_lut_full_update[72]);
+    WriteByte(Device, EPD_lut_full_update[73]);
+
+    Device->WriteCommand(Device, 0x3a);
+    WriteByte(Device, EPD_lut_full_update[74]);
+    Device->WriteCommand(Device, 0x3b);
+    WriteByte(Device, EPD_lut_full_update[75]);
+
+    Device->WriteCommand(Device, 0X32);
+    for(int i = 0; i < 70; i++) { WriteByte(Device, EPD_lut_full_update[i]); }
+
+    // now deal with funny X/Y layout (W and H are "inverted")
+    Device->WriteCommand(Device, 0x01);
+    WriteByte(Device, Device->Width - 1);
+    WriteByte(Device, (Device->Width - 1) >> 8);
+    WriteByte(Device, (0 << 0));
+
+    /* 
 	 Start from 0, Ymax, incX, decY. Starting from X=Height would be difficult
 	 as we would hit the extra bits added because height % 8 != 0 and they are
 	 not written by the DrawPixel. By starting from X=0 we are aligned and 
 	 doing incY is like a clockwise 90° rotation (vs otherwise we would virtually 
 	 do a counter-clockwise rotation but again have the "border" issue.
-	*/ 
-	Device->WriteCommand( Device, 0x11 ); 			
-	WriteByte( Device, (1 << 2) | (0 << 1) | (1 << 0));
-		
-	// must be in order with increment/decrement i.e start might be > end if we decrement
-	SetColumnAddress( Device, 0x0, (Device->Height >> 3) - 1 );
-	SetRowAddress ( Device, Device->Width - 1, 0 );
+	*/
+    Device->WriteCommand(Device, 0x11);
+    WriteByte(Device, (1 << 2) | (0 << 1) | (1 << 0));
 
-	WaitReady( Device );
-	
-	Update( Device );
-	
-	return true;
-}	
+    // must be in order with increment/decrement i.e start might be > end if we decrement
+    SetColumnAddress(Device, 0x0, (Device->Height >> 3) - 1);
+    SetRowAddress(Device, Device->Width - 1, 0);
+
+    WaitReady(Device);
+
+    Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device SSD1675 = {
-	.DrawBitmapCBR = DrawBitmapCBR, .ClearWindow = ClearWindow,
-	.DrawPixelFast = _DrawPixel,
-	.Update = Update, .Init = Init,
-	.Mode = GDS_MONO, .Depth = 1,
-	.Alloc = GDS_ALLOC_NONE,
-};	
+    .DrawBitmapCBR = DrawBitmapCBR,
+    .ClearWindow = ClearWindow,
+    .DrawPixelFast = _DrawPixel,
+    .Update = Update,
+    .Init = Init,
+    .Mode = GDS_MONO,
+    .Depth = 1,
+    .Alloc = GDS_ALLOC_NONE,
+};
 
-struct GDS_Device* SSD1675_Detect(char *Driver, struct GDS_Device* Device) {
-	if (!strcasestr(Driver, "SSD1675")) return NULL;
-	
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-	*Device = SSD1675;	
-	
-	char *p;
-	struct PrivateSpace* Private = (struct PrivateSpace*) Device->Private;
-	Private->ReadyPin = -1;
-	if ((p = strcasestr(Driver, "ready")) != NULL) Private->ReadyPin = atoi(strchr(p, '=') + 1);
-	
-	ESP_LOGI(TAG, "SSD1675 driver with ready GPIO %d", Private->ReadyPin);
-	
-	return Device;
-}
+struct GDS_Device* SSD1675_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    if(Driver->common.driver != sys_display_drivers_SSD1675) return NULL;
+
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+    *Device = SSD1675;
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->ReadyPin = -1;
+    if(Driver->common.ready >= 0) { Private->ReadyPin = Driver->common.ready; }
+
+    ESP_LOGI(TAG, "SSD1675 driver with ready GPIO %d", Private->ReadyPin);
+
+    return Device;
+}

components/display/ST77xx.c

@@ -18,281 +18,301 @@
 
 #define SHADOW_BUFFER
 #define USE_IRAM
-#define PAGE_BLOCK		2048
-#define ENABLE_WRITE	0x2c
+#define PAGE_BLOCK 2048
+#define ENABLE_WRITE 0x2c
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a, b) (((a) < (b)) ? (a) : (b))
 
 static char TAG[] = "ST77xx";
 
 enum { ST7735, ST7789 };
 
 struct PrivateSpace {
-	uint8_t *iRAM, *Shadowbuffer;
-	struct {
-		uint16_t Height, Width;
-	} Offset;
-	uint8_t MADCtl, PageSize;
-	uint8_t Model;
+    uint8_t *iRAM, *Shadowbuffer;
+    struct {
+        uint16_t Height, Width;
+    } Offset;
+    uint8_t MADCtl, PageSize;
+    uint8_t Model;
 };
 
 // Functions are not declared to minimize # of lines
 
-static void WriteByte( struct GDS_Device* Device, uint8_t Data ) {
-	Device->WriteData( Device, &Data, 1 );
+static void WriteByte(struct GDS_Device* Device, uint8_t Data) { Device->WriteData(Device, &Data, 1); }
+
+static void SetColumnAddress(struct GDS_Device* Device, uint16_t Start, uint16_t End) {
+    uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
+    Device->WriteCommand(Device, 0x2A);
+    Device->WriteData(Device, (uint8_t*)&Addr, 4);
 }
 
-static void SetColumnAddress( struct GDS_Device* Device, uint16_t Start, uint16_t End ) {
-	uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
-	Device->WriteCommand( Device, 0x2A );
-	Device->WriteData( Device, (uint8_t*) &Addr, 4 );
+static void SetRowAddress(struct GDS_Device* Device, uint16_t Start, uint16_t End) {
+    uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
+    Device->WriteCommand(Device, 0x2B);
+    Device->WriteData(Device, (uint8_t*)&Addr, 4);
 }
 
-static void SetRowAddress( struct GDS_Device* Device, uint16_t Start, uint16_t End ) {
-	uint32_t Addr = __builtin_bswap16(Start) | (__builtin_bswap16(End) << 16);
-	Device->WriteCommand( Device, 0x2B );
-	Device->WriteData( Device, (uint8_t*) &Addr, 4 );
-}
+static void Update16(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
 
-static void Update16( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
 #ifdef SHADOW_BUFFER
-	uint32_t *optr = (uint32_t*) Private->Shadowbuffer, *iptr = (uint32_t*) Device->Framebuffer;
-	int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
-	
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width is always a multiple of 2)
-		for (int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
+    uint32_t *optr = (uint32_t*)Private->Shadowbuffer, *iptr = (uint32_t*)Device->Framebuffer;
+    int FirstCol = Device->Width / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
 
-		// wait for a large enough window - careful that window size might increase by more than a line at once !
-		if (FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol *= 2;
-		LastCol = LastCol * 2 + 1;
-		SetRowAddress( Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
-		SetColumnAddress( Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 2;
-			
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize );
-		}	
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width is always a multiple of 2)
+        for(int c = 0; c < Device->Width / 2; c++, iptr++, optr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
 
-		FirstCol = Device->Width / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+        // wait for a large enough window - careful that window size might increase by more than a line at once !
+        if(FirstRow < 0 || ((LastCol - FirstCol + 1) * (r - FirstRow + 1) * 4 < PAGE_BLOCK && r != Device->Height - 1)) continue;
+
+        FirstCol *= 2;
+        LastCol = LastCol * 2 + 1;
+        SetRowAddress(Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
+        SetColumnAddress(Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 2;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 2, ChunkSize);
+            }
+
+        FirstCol = Device->Width / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, Private->Offset.Width, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 2 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, Private->Offset.Width, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 2);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 2, Height * Device->Width * 2);
+        }
+    }
+#endif
 }
 
-static void Update24( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-		
-#ifdef SHADOW_BUFFER
-	uint16_t *optr = (uint16_t*) Private->Shadowbuffer, *iptr = (uint16_t*) Device->Framebuffer;
-	int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;  
-	
-	for (int r = 0; r < Device->Height; r++) {
-		// look for change and update shadow (cheap optimization = width always / by 2)
-		for (int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
-			if (*optr != *iptr) {
-				*optr = *iptr;
-				if (c < FirstCol) FirstCol = c;	
-				if (c > LastCol) LastCol = c;
-				if (FirstRow < 0) FirstRow = r;
-				LastRow = r;
-			}
-		}
-		
-		// do we have enough to send (cols are divided by 3/2)
-		if (FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2 + 3 - 1) / 3) * (r - FirstRow + 1) * 3 < PAGE_BLOCK && r != Device->Height - 1)) continue;
-		
-		FirstCol = (FirstCol * 2) / 3;
-		LastCol = (LastCol * 2 + 1) / 3; 
-		SetRowAddress( Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
-		SetColumnAddress( Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width );
-		Device->WriteCommand( Device, ENABLE_WRITE );
-			
-		int ChunkSize = (LastCol - FirstCol + 1) * 3;
-					
-		// own use of IRAM has not proven to be much better than letting SPI do its copy
-		if (Private->iRAM) {
-			uint8_t *optr = Private->iRAM;
-			for (int i = FirstRow; i <= LastRow; i++) {
-				memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
-				optr += ChunkSize;
-				if (optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
-				Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
-				optr = Private->iRAM;
-			}	
-		} else for (int i = FirstRow; i <= LastRow; i++) {
-			Device->WriteData( Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize );
-		}	
+static void Update24(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
 
-		FirstCol = (Device->Width * 3) / 2; LastCol = 0;
-		FirstRow = -1;
-	}	
+#ifdef SHADOW_BUFFER
+    uint16_t *optr = (uint16_t*)Private->Shadowbuffer, *iptr = (uint16_t*)Device->Framebuffer;
+    int FirstCol = (Device->Width * 3) / 2, LastCol = 0, FirstRow = -1, LastRow = 0;
+
+    for(int r = 0; r < Device->Height; r++) {
+        // look for change and update shadow (cheap optimization = width always / by 2)
+        for(int c = 0; c < (Device->Width * 3) / 2; c++, optr++, iptr++) {
+            if(*optr != *iptr) {
+                *optr = *iptr;
+                if(c < FirstCol) FirstCol = c;
+                if(c > LastCol) LastCol = c;
+                if(FirstRow < 0) FirstRow = r;
+                LastRow = r;
+            }
+        }
+
+        // do we have enough to send (cols are divided by 3/2)
+        if(FirstRow < 0 || ((((LastCol - FirstCol + 1) * 2 + 3 - 1) / 3) * (r - FirstRow + 1) * 3 < PAGE_BLOCK && r != Device->Height - 1)) continue;
+
+        FirstCol = (FirstCol * 2) / 3;
+        LastCol = (LastCol * 2 + 1) / 3;
+        SetRowAddress(Device, FirstRow + Private->Offset.Height, LastRow + Private->Offset.Height);
+        SetColumnAddress(Device, FirstCol + Private->Offset.Width, LastCol + Private->Offset.Width);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        int ChunkSize = (LastCol - FirstCol + 1) * 3;
+
+        // own use of IRAM has not proven to be much better than letting SPI do its copy
+        if(Private->iRAM) {
+            uint8_t* optr = Private->iRAM;
+            for(int i = FirstRow; i <= LastRow; i++) {
+                memcpy(optr, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+                optr += ChunkSize;
+                if(optr - Private->iRAM <= (PAGE_BLOCK - ChunkSize) && i < LastRow) continue;
+                Device->WriteData(Device, Private->iRAM, optr - Private->iRAM);
+                optr = Private->iRAM;
+            }
+        } else
+            for(int i = FirstRow; i <= LastRow; i++) {
+                Device->WriteData(Device, Private->Shadowbuffer + (i * Device->Width + FirstCol) * 3, ChunkSize);
+            }
+
+        FirstCol = (Device->Width * 3) / 2;
+        LastCol = 0;
+        FirstRow = -1;
+    }
 #else
-	// always update by full lines
-	SetColumnAddress( Device, Private->Offset.Width, Device->Width - 1);
-	
-	for (int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
-		int Height = min(Private->PageSize, Device->Height - r);
-		
-		SetRowAddress( Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1 );
-		Device->WriteCommand(Device, ENABLE_WRITE);
-		
-		if (Private->iRAM) {
-			memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-			Device->WriteData( Device, Private->iRAM, Height * Device->Width * 3 );
-		} else	{
-			Device->WriteData( Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3 );
-		}	
-	}	
-#endif	
+    // always update by full lines
+    SetColumnAddress(Device, Private->Offset.Width, Device->Width - 1);
+
+    for(int r = 0; r < Device->Height; r += min(Private->PageSize, Device->Height - r)) {
+        int Height = min(Private->PageSize, Device->Height - r);
+
+        SetRowAddress(Device, Private->Offset.Height + r, Private->Offset.Height + r + Height - 1);
+        Device->WriteCommand(Device, ENABLE_WRITE);
+
+        if(Private->iRAM) {
+            memcpy(Private->iRAM, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+            Device->WriteData(Device, Private->iRAM, Height * Device->Width * 3);
+        } else {
+            Device->WriteData(Device, Device->Framebuffer + r * Device->Width * 3, Height * Device->Width * 3);
+        }
+    }
+#endif
 }
 
-static void SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { 
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	
-	Private->MADCtl = HFlip ? (Private->MADCtl | (1 << 7)) : (Private->MADCtl & ~(1 << 7));
-	Private->MADCtl = VFlip ? (Private->MADCtl | (1 << 6)) : (Private->MADCtl & ~(1 << 6));
-	Private->MADCtl = Rotate ? (Private->MADCtl | (1 << 5)) : (Private->MADCtl & ~(1 << 5));
-	
-	Device->WriteCommand( Device, 0x36 );
-	WriteByte( Device, Private->MADCtl );
-	
-	if (Private->Model == ST7789) {
-		if (Rotate) Private->Offset.Width = HFlip ? 320 - Device->Width : 0;
-		else Private->Offset.Height = HFlip ? 320 - Device->Height : 0;
-	}
+static void SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+
+    if(Private->Model == ST7789) {
+        if(Layout->Rotate)
+            Private->Offset.Width += Layout->HFlip ? 320 - Device->Width : 0;
+        else
+            Private->Offset.Height += Layout->HFlip ? 320 - Device->Height : 0;
+        Device->WriteCommand(Device, Layout->Invert ? 0x20 : 0x21);
+    } else {
+        Device->WriteCommand(Device, Layout->Invert ? 0x21 : 0x20);
+    }
+
+    Private->MADCtl = Layout->HFlip ? (Private->MADCtl | (1 << 7)) : (Private->MADCtl & ~(1 << 7));
+    Private->MADCtl = Layout->VFlip ? (Private->MADCtl | (1 << 6)) : (Private->MADCtl & ~(1 << 6));
+    Private->MADCtl = Layout->Rotate ? (Private->MADCtl | (1 << 5)) : (Private->MADCtl & ~(1 << 5));
+    Private->MADCtl = Layout->ColorSwap ? (Private->MADCtl & ~(1 << 3)) : (Private->MADCtl | (1 << 3));
+
+    Device->WriteCommand(Device, 0x36);
+    WriteByte(Device, Private->MADCtl);
 
 #ifdef SHADOW_BUFFER
-	// force a full refresh (almost ...)
-	memset(Private->Shadowbuffer, 0xAA, Device->FramebufferSize);
-#endif	
-}	
-
-static void DisplayOn( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0x29 ); }
-static void DisplayOff( struct GDS_Device* Device ) { Device->WriteCommand( Device, 0x28 ); }
-
-static void SetContrast( struct GDS_Device* Device, uint8_t Contrast ) {
-	Device->WriteCommand( Device, 0x51 );
-	WriteByte( Device, Contrast );
-	
-	Device->SetContrast = NULL;
-	GDS_SetContrast( Device, Contrast );
-	Device->SetContrast = SetContrast;
+    // force a full refresh (almost ...)
+    memset(Private->Shadowbuffer, 0xAA, Device->FramebufferSize);
+#endif
 }
 
-static bool Init( struct GDS_Device* Device ) {
-	struct PrivateSpace *Private = (struct PrivateSpace*) Device->Private;
-	int Depth = (Device->Depth + 8 - 1) / 8;
-	
-	Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
+static void DisplayOn(struct GDS_Device* Device) { Device->WriteCommand(Device, 0x29); }
+static void DisplayOff(struct GDS_Device* Device) { Device->WriteCommand(Device, 0x28); }
 
-#ifdef SHADOW_BUFFER	
-	Private->Shadowbuffer = malloc( Device->FramebufferSize );	
-	memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
+static void SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    Device->WriteCommand(Device, 0x51);
+    WriteByte(Device, Contrast);
+
+    Device->SetContrast = NULL;
+    GDS_SetContrast(Device, Contrast);
+    Device->SetContrast = SetContrast;
+}
+
+static bool Init(struct GDS_Device* Device) {
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    int Depth = (Device->Depth + 8 - 1) / 8;
+
+    Private->PageSize = min(8, PAGE_BLOCK / (Device->Width * Depth));
+
+#ifdef SHADOW_BUFFER
+    Private->Shadowbuffer = malloc(Device->FramebufferSize);
+    memset(Private->Shadowbuffer, 0xFF, Device->FramebufferSize);
 #endif
 #ifdef USE_IRAM
-	Private->iRAM = heap_caps_malloc( (Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
+    Private->iRAM = heap_caps_malloc((Private->PageSize + 1) * Device->Width * Depth, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
 #endif
 
-	ESP_LOGI(TAG, "ST77xx with bit depth %u, page %u, iRAM %p", Device->Depth, Private->PageSize, Private->iRAM);
-	
-	// Sleepout + Booster
-	Device->WriteCommand( Device, 0x11 );
-		
-	// need BGR & Address Mode
-	Private->MADCtl = 1 << 3;
-	Device->WriteCommand( Device, 0x36 );
-	WriteByte( Device, Private->MADCtl );		
-		
-	// set flip modes & contrast
-	GDS_SetContrast( Device, 0x7f );
-	Device->SetLayout( Device, false, false, false );
-	
-	// set screen depth (16/18)
-	Device->WriteCommand( Device, 0x3A );
-	if (Private->Model == ST7789) WriteByte( Device, Device->Depth == 24 ? 0x066 : 0x55 );
-	else WriteByte( Device, Device->Depth == 24 ? 0x06 : 0x05 );
-	
-	// no Display Inversion
-    Device->WriteCommand( Device, Private->Model == ST7735 ? 0x20 : 0x21 );	
-		
-	// gone with the wind
-	Device->DisplayOn( Device );
-	Device->Update( Device );
+    ESP_LOGI(TAG, "ST77xx with bit depth %u, offsets %hu:%hu, page %u, iRAM %p", Device->Depth, Private->Offset.Height, Private->Offset.Width,
+        Private->PageSize, Private->iRAM);
 
-	return true;
-}	
+    // Sleepout + Booster
+    Device->WriteCommand(Device, 0x11);
+
+    // need BGR & Address Mode
+    Private->MADCtl = 1 << 3;
+    Device->WriteCommand(Device, 0x36);
+    WriteByte(Device, Private->MADCtl);
+
+    // set flip modes & contrast
+    GDS_SetContrast(Device, 0x7f);
+    struct GDS_Layout Layout = {};
+    Device->SetLayout(Device, &Layout);
+
+    // set screen depth (16/18)
+    Device->WriteCommand(Device, 0x3A);
+    if(Private->Model == ST7789)
+        WriteByte(Device, Device->Depth == 24 ? 0x066 : 0x55);
+    else
+        WriteByte(Device, Device->Depth == 24 ? 0x06 : 0x05);
+
+    // gone with the wind
+    Device->DisplayOn(Device);
+    Device->Update(Device);
+
+    return true;
+}
 
 static const struct GDS_Device ST77xx = {
-	.DisplayOn = DisplayOn, .DisplayOff = DisplayOff,
-	.SetLayout = SetLayout,
-	.Update = Update16, .Init = Init,
-	.Mode = GDS_RGB565, .Depth = 16,
-};		
+    .DisplayOn = DisplayOn,
+    .DisplayOff = DisplayOff,
+    .SetLayout = SetLayout,
+    .Update = Update16,
+    .Init = Init,
+    .Mode = GDS_RGB565,
+    .Depth = 16,
+};
 
-struct GDS_Device* ST77xx_Detect(char *Driver, struct GDS_Device* Device) {
-	uint8_t Model;
-	int Depth;
-		
-	if (strcasestr(Driver, "ST7735")) Model = ST7735;
-	else if (strcasestr(Driver, "ST7789")) Model = ST7789;
-	else return NULL;
-		
-	if (!Device) Device = calloc(1, sizeof(struct GDS_Device));
-		
-	*Device = ST77xx;	
-	sscanf(Driver, "%*[^:]:%u", &Depth);
-	struct PrivateSpace* Private = (struct PrivateSpace*) Device->Private;
-	Private->Model = Model;
-	
-	if (Depth == 18) {
-		Device->Mode = GDS_RGB666;
-		Device->Depth = 24;
-		Device->Update = Update24;
-	} 	
-	
-	if (Model == ST7789) Device->SetContrast = SetContrast;
+struct GDS_Device* ST77xx_Detect(sys_display_config* Driver, struct GDS_Device* Device) {
+    uint8_t Model;
+    int Depth;
+    if(Driver->common.driver == sys_display_drivers_ST7735)
+        Model = ST7735;
+    else if(Driver->common.driver == sys_display_drivers_ST7789)
+        Model = ST7789;
+    else
+        return NULL;
 
-	return Device;
+    if(!Device) Device = calloc(1, sizeof(struct GDS_Device));
+
+    *Device = ST77xx;
+    Depth = Driver->common.bitDepth != 0 ? Driver->common.bitDepth : 18;
+
+    struct PrivateSpace* Private = (struct PrivateSpace*)Device->Private;
+    Private->Model = Model;
+
+    if(Driver->common.has_offsets) {
+        Private->Offset.Height = Driver->common.offsets.height;
+        Private->Offset.Width = Driver->common.offsets.width;
+    }
+
+    if(Depth == 18) {
+        Device->Mode = GDS_RGB666;
+        Device->Depth = 24;
+        Device->Update = Update24;
+    }
+
+    if(Model == ST7789) Device->SetContrast = SetContrast;
+
+    return Device;
 }

components/display/core/gds.c

@@ -15,232 +15,259 @@
 #include "driver/gpio.h"
 #include "driver/ledc.h"
 #include "esp_log.h"
-
+#include "Config.h"
 #include "gds.h"
 #include "gds_private.h"
 
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+#define LEDC_SPEED_MODE LEDC_LOW_SPEED_MODE
+#else
+#define LEDC_SPEED_MODE LEDC_HIGH_SPEED_MODE
+#endif
+extern bool gds_init_fonts();
 static struct GDS_Device Display;
 static struct GDS_BacklightPWM PWMConfig;
 
 static char TAG[] = "gds";
 
-struct GDS_Device* GDS_AutoDetect( char *Driver, GDS_DetectFunc* DetectFunc[], struct GDS_BacklightPWM* PWM ) {
-	if (!Driver) return NULL;
-	if (PWM) PWMConfig = *PWM;
-	
-	for (int i = 0; DetectFunc[i]; i++) {
-		if (DetectFunc[i](Driver, &Display)) {
-			if (PWM && PWM->Init) {
-				ledc_timer_config_t PWMTimer = {
-						.duty_resolution = LEDC_TIMER_13_BIT,
-						.freq_hz = 5000,                   
-						.speed_mode = LEDC_HIGH_SPEED_MODE,
-						.timer_num = PWMConfig.Timer,
-					};
-				ledc_timer_config(&PWMTimer);
-			}	
-			ESP_LOGD(TAG, "Detected driver %p with PWM %d", &Display, PWM ? PWM->Init : 0);			
-			return &Display;
-		}	
-	}
-	
-	return NULL;
+struct GDS_Device* GDS_AutoDetect(sys_display_config* Driver, GDS_DetectFunc* DetectFunc[], struct GDS_BacklightPWM* PWM) {
+    if(!Driver->has_common || Driver->common.driver == sys_display_drivers_UNSPECIFIED) return NULL;
+    if(PWM) PWMConfig = *PWM;
+
+    for(int i = 0; DetectFunc[i]; i++) {
+        if(DetectFunc[i](Driver, &Display)) {
+            if(PWM && PWM->Init) {
+                ledc_timer_config_t PWMTimer = {
+                    .duty_resolution = LEDC_TIMER_13_BIT,
+                    .freq_hz = 5000,
+                    .speed_mode = LEDC_SPEED_MODE,
+                    .timer_num = PWMConfig.Timer,
+                };
+                ledc_timer_config(&PWMTimer);
+            }
+            ESP_LOGD(TAG, "Detected driver %p with PWM %d", &Display, PWM ? PWM->Init : 0);
+            return &Display;
+        }
+    }
+
+    return NULL;
 }
 
 void GDS_ClearExt(struct GDS_Device* Device, bool full, ...) {
-	bool commit = true;
-	
-	if (full) {
-		GDS_Clear( Device, GDS_COLOR_BLACK ); 
-	} else {
-		va_list args;
-		va_start(args, full);
-		commit = va_arg(args, int);
-		int x1 = va_arg(args, int), y1 = va_arg(args, int), x2 = va_arg(args, int), y2 = va_arg(args, int);
-		if (x2 < 0) x2 = Device->Width - 1;
-		if (y2 < 0) y2 = Device->Height - 1;
-		GDS_ClearWindow( Device, x1, y1, x2, y2, GDS_COLOR_BLACK );
-		va_end(args);
-	}
-	
-	Device->Dirty = true;
-	if (commit)	GDS_Update(Device);		
-}	
+    bool commit = true;
 
-void GDS_Clear( struct GDS_Device* Device, int Color ) {
-	if (Color == GDS_COLOR_BLACK) memset( Device->Framebuffer, 0, Device->FramebufferSize );
-	else if (Device->Depth == 1) memset( Device->Framebuffer, 0xff, Device->FramebufferSize );
-	else if (Device->Depth == 4) memset( Device->Framebuffer, Color | (Color << 4), Device->FramebufferSize );
-	else if (Device->Depth == 8) memset( Device->Framebuffer, Color, Device->FramebufferSize );
-	else GDS_ClearWindow(Device, 0, 0, -1, -1, Color);
-	Device->Dirty = true;
+    if(full) {
+        GDS_Clear(Device, GDS_COLOR_BLACK);
+    } else {
+        va_list args;
+        va_start(args, full);
+        commit = va_arg(args, int);
+        int x1 = va_arg(args, int), y1 = va_arg(args, int), x2 = va_arg(args, int), y2 = va_arg(args, int);
+        if(x2 < 0) x2 = Device->Width - 1;
+        if(y2 < 0) y2 = Device->Height - 1;
+        GDS_ClearWindow(Device, x1, y1, x2, y2, GDS_COLOR_BLACK);
+        va_end(args);
+    }
+
+    Device->Dirty = true;
+    if(commit) GDS_Update(Device);
 }
 
-#define CLEAR_WINDOW(x1,y1,x2,y2,F,W,C,T,N)				\
-	for (int y = y1; y <= y2; y++) {					\
-		T *Ptr = (T*) F + (y * W + x1)*N;				\
-		for (int c = (x2 - x1)*N; c-- >= 0; *Ptr++ = C);	\
-	}
-
-void GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color ) {
-	// -1 means up to width/height
-	if (x2 < 0) x2 = Device->Width - 1;
-	if (y2 < 0) y2 = Device->Height - 1;
-	
-	// driver can provide own optimized clear window
-	if (Device->ClearWindow) {
-		Device->ClearWindow( Device, x1, y1, x2, y2, Color );
-	} else if (Device->Depth == 1) {
-		// single shot if we erase all screen
-		if (x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
-			memset( Device->Framebuffer, Color == GDS_COLOR_BLACK ? 0 : 0xff, Device->FramebufferSize );
-		} else {
-			uint8_t _Color = Color == GDS_COLOR_BLACK ? 0: 0xff;
-			uint8_t Width = Device->Width >> 3;
-			uint8_t *optr = Device->Framebuffer;
-			// try to do byte processing as much as possible
-			for (int r = y1; r <= y2;) {
-				int c = x1;
-				// for a row that is not on a boundary, no optimization possible
-				while (r & 0x07 && r <= y2) {
-					for (c = x1; c <= x2; c++) DrawPixelFast( Device, c, r, Color );
-					r++;
-				}
-				// go fast if we have more than 8 lines to write
-				if (r + 8 <= y2) {
-					memset(optr + Width * r + x1, _Color, x2 - x1 + 1);
-					r += 8;
-				} else while (r <= y2) {
-					for (c = x1; c <= x2; c++) DrawPixelFast( Device, c, r, Color );
-					r++;
-				}
-			}
-		}
-	} if (Device->Depth == 4) {
-		if (x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
-			// we assume color is 0..15
-			memset( Device->Framebuffer, Color | (Color << 4), Device->FramebufferSize );
-		} else {
-			uint8_t _Color = Color | (Color << 4);
-			int Width = Device->Width;
-			uint8_t *optr = Device->Framebuffer;
-			// try to do byte processing as much as possible
-			for (int r = y1; r <= y2; r++) {
-				int c = x1;
-				if (c & 0x01) DrawPixelFast( Device, c++, r, Color);
-				int chunk = (x2 - c + 1) >> 1;
-				memset(optr + ((r * Width + c)  >> 1), _Color, chunk);
-				if (c + chunk <= x2) DrawPixelFast( Device, x2, r, Color);
-			}
-		}	
-	} else if (Device->Depth == 8) {
-		CLEAR_WINDOW(x1,y1,x2,y2,Device->Framebuffer,Device->Width,Color,uint8_t,1);
-	} else if (Device->Depth == 16) {
-		CLEAR_WINDOW(x1,y1,x2,y2,Device->Framebuffer,Device->Width,Color,uint16_t,1);
-	} else if (Device->Depth == 24) {
-		CLEAR_WINDOW(x1,y1,x2,y2,Device->Framebuffer,Device->Width,Color,uint8_t,3);
-	} else {
-		for (int y = y1; y <= y2; y++) {
-			for (int x = x1; x <= x2; x++) {
-				DrawPixelFast( Device, x, y, Color);
-			}
-		}
-	}
-	
-	// make sure diplay will do update
-	Device->Dirty = true;
+void GDS_Clear(struct GDS_Device* Device, int Color) {
+    if(Color == GDS_COLOR_BLACK)
+        memset(Device->Framebuffer, 0, Device->FramebufferSize);
+    else if(Device->Depth == 1)
+        memset(Device->Framebuffer, 0xff, Device->FramebufferSize);
+    else if(Device->Depth == 4)
+        memset(Device->Framebuffer, Color | (Color << 4), Device->FramebufferSize);
+    else if(Device->Depth == 8)
+        memset(Device->Framebuffer, Color, Device->FramebufferSize);
+    else
+        GDS_ClearWindow(Device, 0, 0, -1, -1, Color);
+    Device->Dirty = true;
 }
 
-void GDS_Update( struct GDS_Device* Device ) {
-	if (Device->Dirty) Device->Update( Device );
-	Device->Dirty = false;
+#define CLEAR_WINDOW(x1, y1, x2, y2, F, W, C, T, N)                                                                                                  \
+    for(int y = y1; y <= y2; y++) {                                                                                                                  \
+        T* Ptr = (T*)F + (y * W + x1) * N;                                                                                                           \
+        for(int c = (x2 - x1) * N; c-- >= 0; *Ptr++ = C);                                                                                            \
+    }
+
+void GDS_ClearWindow(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color) {
+    // -1 means up to width/height
+    if(x2 < 0) x2 = Device->Width - 1;
+    if(y2 < 0) y2 = Device->Height - 1;
+
+    // driver can provide own optimized clear window
+    if(Device->ClearWindow) {
+        Device->ClearWindow(Device, x1, y1, x2, y2, Color);
+    } else if(Device->Depth == 1) {
+        // single shot if we erase all screen
+        if(x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
+            memset(Device->Framebuffer, Color == GDS_COLOR_BLACK ? 0 : 0xff, Device->FramebufferSize);
+        } else {
+            uint8_t _Color = Color == GDS_COLOR_BLACK ? 0 : 0xff;
+            uint8_t Width = Device->Width >> 3;
+            uint8_t* optr = Device->Framebuffer;
+            // try to do byte processing as much as possible
+            for(int r = y1; r <= y2;) {
+                int c = x1;
+                // for a row that is not on a boundary, no optimization possible
+                while(r & 0x07 && r <= y2) {
+                    for(c = x1; c <= x2; c++) DrawPixelFast(Device, c, r, Color);
+                    r++;
+                }
+                // go fast if we have more than 8 lines to write
+                if(r + 8 <= y2) {
+                    memset(optr + Width * r + x1, _Color, x2 - x1 + 1);
+                    r += 8;
+                } else
+                    while(r <= y2) {
+                        for(c = x1; c <= x2; c++) DrawPixelFast(Device, c, r, Color);
+                        r++;
+                    }
+            }
+        }
+    }
+    if(Device->Depth == 4) {
+        if(x2 - x1 == Device->Width - 1 && y2 - y1 == Device->Height - 1) {
+            // we assume color is 0..15
+            memset(Device->Framebuffer, Color | (Color << 4), Device->FramebufferSize);
+        } else {
+            uint8_t _Color = Color | (Color << 4);
+            int Width = Device->Width;
+            uint8_t* optr = Device->Framebuffer;
+            // try to do byte processing as much as possible
+            for(int r = y1; r <= y2; r++) {
+                int c = x1;
+                if(c & 0x01) DrawPixelFast(Device, c++, r, Color);
+                int chunk = (x2 - c + 1) >> 1;
+                memset(optr + ((r * Width + c) >> 1), _Color, chunk);
+                if(c + chunk <= x2) DrawPixelFast(Device, x2, r, Color);
+            }
+        }
+    } else if(Device->Depth == 8) {
+        CLEAR_WINDOW(x1, y1, x2, y2, Device->Framebuffer, Device->Width, Color, uint8_t, 1);
+    } else if(Device->Depth == 16) {
+        CLEAR_WINDOW(x1, y1, x2, y2, Device->Framebuffer, Device->Width, Color, uint16_t, 1);
+    } else if(Device->Depth == 24) {
+        CLEAR_WINDOW(x1, y1, x2, y2, Device->Framebuffer, Device->Width, Color, uint8_t, 3);
+    } else {
+        for(int y = y1; y <= y2; y++) {
+            for(int x = x1; x <= x2; x++) { DrawPixelFast(Device, x, y, Color); }
+        }
+    }
+
+    // make sure diplay will do update
+    Device->Dirty = true;
 }
 
-bool GDS_Reset( struct GDS_Device* Device ) {
-	if ( Device->RSTPin >= 0 ) {
-		gpio_set_level( Device->RSTPin, 0 );
-		vTaskDelay( pdMS_TO_TICKS( 100 ) );
-        gpio_set_level( Device->RSTPin, 1 );
+void GDS_Update(struct GDS_Device* Device) {
+    if(Device->Dirty) Device->Update(Device);
+    Device->Dirty = false;
+}
+
+bool GDS_Reset(struct GDS_Device* Device) {
+    if(Device->RSTPin >= 0) {
+        gpio_set_level(Device->RSTPin, 0);
+        vTaskDelay(pdMS_TO_TICKS(100));
+        gpio_set_level(Device->RSTPin, 1);
     }
     return true;
 }
 
-bool GDS_Init( struct GDS_Device* Device ) {
-	
-	if (Device->Depth > 8) Device->FramebufferSize = Device->Width * Device->Height * ((8 + Device->Depth - 1) / 8);
-	else Device->FramebufferSize = (Device->Width * Device->Height) / (8 / Device->Depth);
-	
-	// allocate FB unless explicitely asked not to
-	if (!(Device->Alloc & GDS_ALLOC_NONE)) {
-		if ((Device->Alloc & GDS_ALLOC_IRAM) || ((Device->Alloc & GDS_ALLOC_IRAM_SPI) && Device->IF == GDS_IF_SPI)) {
-			Device->Framebuffer = heap_caps_calloc( 1, Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA );
-		} else {
-			Device->Framebuffer = calloc( 1, Device->FramebufferSize );
-		}	
-		NullCheck( Device->Framebuffer, return false );
-	}	
-	
-	if (Device->Backlight.Pin >= 0) {
-		Device->Backlight.Channel = PWMConfig.Channel++;
-		Device->Backlight.PWM = PWMConfig.Max - 1;
+bool GDS_Init(struct GDS_Device* Device) {
 
-		ledc_channel_config_t PWMChannel = {
-            .channel    = Device->Backlight.Channel,
-            .duty       = Device->Backlight.PWM,
-            .gpio_num   = Device->Backlight.Pin,
-            .speed_mode = LEDC_HIGH_SPEED_MODE,
-            .hpoint     = 0,
-            .timer_sel  = PWMConfig.Timer,
+    if(Device->Depth > 8)
+        Device->FramebufferSize = Device->Width * Device->Height * ((8 + Device->Depth - 1) / 8);
+    else
+        Device->FramebufferSize = (Device->Width * Device->Height) / (8 / Device->Depth);
+
+    // allocate FB unless explicitely asked not to
+    if(!(Device->Alloc & GDS_ALLOC_NONE)) {
+        if((Device->Alloc & GDS_ALLOC_IRAM) || ((Device->Alloc & GDS_ALLOC_IRAM_SPI) && Device->IF == GDS_IF_SPI)) {
+            Device->Framebuffer = heap_caps_calloc(1, Device->FramebufferSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_DMA);
+        } else {
+            Device->Framebuffer = calloc(1, Device->FramebufferSize);
+        }
+        NullCheck(Device->Framebuffer, return false);
+    }
+
+    if(Device->Backlight.Pin >= 0) {
+        Device->Backlight.Channel = PWMConfig.Channel++;
+        Device->Backlight.PWM = PWMConfig.Max - 1;
+
+        ledc_channel_config_t PWMChannel = {
+            .channel = Device->Backlight.Channel,
+            .duty = Device->Backlight.PWM,
+            .gpio_num = Device->Backlight.Pin,
+            .speed_mode = LEDC_SPEED_MODE,
+            .hpoint = 0,
+            .timer_sel = PWMConfig.Timer,
         };
-		
-		ledc_channel_config(&PWMChannel);
-	}
-	
-	bool Res = Device->Init( Device );
-	if (!Res && Device->Framebuffer) free(Device->Framebuffer);
-	return Res;
+
+        ledc_channel_config(&PWMChannel);
+    }
+
+    bool Res = Device->Init(Device);
+    if(Res) { Res = gds_init_fonts(); }
+    if(!Res && Device->Framebuffer) free(Device->Framebuffer);
+
+    return Res;
 }
 
-int GDS_GrayMap( struct GDS_Device* Device, uint8_t Level) {
-	switch(Device->Mode) {
-		case GDS_MONO: return Level;
-		case GDS_GRAYSCALE: return Level >> (8 - Device->Depth);
-		case GDS_RGB332:
-			Level >>= 5;	
-			return (Level << 6) | (Level << 3) | (Level >> 1);
-		case GDS_RGB444:	
-			Level >>= 4;
-			return (Level << 8) | (Level << 4) | Level;
-		case GDS_RGB555:	
-			Level >>= 3;
-			return (Level << 10) | (Level << 5) | Level;			
-		case GDS_RGB565:	
-			Level >>= 2;
-			return ((Level & ~0x01) << 10) | (Level << 5) | (Level >> 1);						
-		case GDS_RGB666:	
-			Level >>= 2;
-			return (Level << 12) | (Level << 6) | Level;									
-		case GDS_RGB888:	
-			return (Level << 16) | (Level << 8) | Level;												
-	}
-	
-	return -1;
+int GDS_GrayMap(struct GDS_Device* Device, uint8_t Level) {
+    switch(Device->Mode) {
+    case GDS_MONO:
+        return Level;
+    case GDS_GRAYSCALE:
+        return Level >> (8 - Device->Depth);
+    case GDS_RGB332:
+        Level >>= 5;
+        return (Level << 6) | (Level << 3) | (Level >> 1);
+    case GDS_RGB444:
+        Level >>= 4;
+        return (Level << 8) | (Level << 4) | Level;
+    case GDS_RGB555:
+        Level >>= 3;
+        return (Level << 10) | (Level << 5) | Level;
+    case GDS_RGB565:
+        Level >>= 2;
+        return ((Level & ~0x01) << 10) | (Level << 5) | (Level >> 1);
+    case GDS_RGB666:
+        Level >>= 2;
+        return (Level << 12) | (Level << 6) | Level;
+    case GDS_RGB888:
+        return (Level << 16) | (Level << 8) | Level;
+    }
+
+    return -1;
 }
 
-void GDS_SetContrast( struct GDS_Device* Device, uint8_t Contrast ) { 
-	if (Device->SetContrast) Device->SetContrast( Device, Contrast ); 
-	else if (Device->Backlight.Pin >= 0) {
-		Device->Backlight.PWM = PWMConfig.Max * powf(Contrast / 255.0, 3);
-		ledc_set_duty( LEDC_HIGH_SPEED_MODE, Device->Backlight.Channel, Device->Backlight.PWM );
-		ledc_update_duty( LEDC_HIGH_SPEED_MODE, Device->Backlight.Channel );		
-	}
+void GDS_SetContrast(struct GDS_Device* Device, uint8_t Contrast) {
+    if(Device->SetContrast)
+        Device->SetContrast(Device, Contrast);
+    else if(Device->Backlight.Pin >= 0) {
+        Device->Backlight.PWM = PWMConfig.Max * powf(Contrast / 255.0, 3);
+        ledc_set_duty(LEDC_SPEED_MODE, Device->Backlight.Channel, Device->Backlight.PWM);
+        ledc_update_duty(LEDC_SPEED_MODE, Device->Backlight.Channel);
+    }
 }
-	
-void GDS_SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate ) { if (Device->SetLayout) Device->SetLayout( Device, HFlip, VFlip, Rotate ); }
-void GDS_SetDirty( struct GDS_Device* Device ) { Device->Dirty = true; }
-int	GDS_GetWidth( struct GDS_Device* Device ) { return Device ? Device->Width : 0; }
-int	GDS_GetHeight( struct GDS_Device* Device ) { return Device ? Device->Height : 0; }
-int	GDS_GetDepth( struct GDS_Device* Device ) { return Device ? Device->Depth : 0; }
-int	GDS_GetMode( struct GDS_Device* Device ) { return Device ? Device->Mode : 0; }
-void GDS_DisplayOn( struct GDS_Device* Device ) { if (Device->DisplayOn) Device->DisplayOn( Device ); }
-void GDS_DisplayOff( struct GDS_Device* Device ) { if (Device->DisplayOff) Device->DisplayOff( Device ); }
+
+void GDS_SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout) {
+    if(Device->SetLayout) Device->SetLayout(Device, Layout);
+}
+void GDS_SetDirty(struct GDS_Device* Device) { Device->Dirty = true; }
+int GDS_GetWidth(struct GDS_Device* Device) { return Device ? Device->Width : 0; }
+void GDS_SetTextWidth(struct GDS_Device* Device, int TextWidth) {
+    Device->TextWidth = Device && TextWidth && TextWidth < Device->Width ? TextWidth : Device->Width;
+}
+int GDS_GetHeight(struct GDS_Device* Device) { return Device ? Device->Height : 0; }
+int GDS_GetDepth(struct GDS_Device* Device) { return Device ? Device->Depth : 0; }
+int GDS_GetMode(struct GDS_Device* Device) { return Device ? Device->Mode : 0; }
+void GDS_DisplayOn(struct GDS_Device* Device) {
+    if(Device->DisplayOn) Device->DisplayOn(Device);
+}
+void GDS_DisplayOff(struct GDS_Device* Device) {
+    if(Device->DisplayOff) Device->DisplayOff(Device);
+}

components/display/core/gds.h

@@ -3,6 +3,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "Config.h"
 
 /* NOTE for drivers:
  The build-in DrawPixel(Fast), DrawCBR and ClearWindow have optimized for 1 bit 
@@ -11,39 +12,46 @@
  other depth, you  must supply the DrawPixelFast. The built-in 1 bit depth function 
  are only for screen with vertical framing (1 byte = 8 lines). For example SSD1326 in 
  monochrome mode is not such type of screen, SH1106 and SSD1306 are
-*/ 
+*/
 
 // this is an ordered enum, do not change!
 enum { GDS_MONO = 0, GDS_GRAYSCALE, GDS_RGB332, GDS_RGB444, GDS_RGB555, GDS_RGB565, GDS_RGB666, GDS_RGB888 };
-		
+
 #define GDS_COLOR_BLACK (0)
 #define GDS_COLOR_WHITE (-1)
-#define GDS_COLOR_XOR 	(256)
+#define GDS_COLOR_XOR (256)
 
 struct GDS_Device;
 struct GDS_FontDef;
-struct GDS_BacklightPWM { 
-	int Channel, Timer, Max;
-	bool Init;
+struct GDS_BacklightPWM {
+    int Channel, Timer, Max;
+    bool Init;
+};
+struct GDS_Layout {
+    bool HFlip, VFlip;
+    bool Rotate;
+    bool Invert;
+    bool ColorSwap;
 };
 
-typedef struct GDS_Device* GDS_DetectFunc(char *Driver, struct GDS_Device *Device);
+typedef struct GDS_Device* GDS_DetectFunc(sys_display_config* Driver, struct GDS_Device* Device);
 
-struct GDS_Device*	GDS_AutoDetect( char *Driver, GDS_DetectFunc* DetectFunc[], struct GDS_BacklightPWM *PWM );
+struct GDS_Device* GDS_AutoDetect(sys_display_config* Driver, GDS_DetectFunc* DetectFunc[], struct GDS_BacklightPWM* PWM);
 
-void 	GDS_SetContrast( struct GDS_Device* Device, uint8_t Contrast );
-void 	GDS_DisplayOn( struct GDS_Device* Device );
-void 	GDS_DisplayOff( struct GDS_Device* Device ); 
-void 	GDS_Update( struct GDS_Device* Device );
-void 	GDS_SetLayout( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate );
-void 	GDS_SetDirty( struct GDS_Device* Device );
-int 	GDS_GetWidth( struct GDS_Device* Device );
-int 	GDS_GetHeight( struct GDS_Device* Device );
-int 	GDS_GetDepth( struct GDS_Device* Device );
-int 	GDS_GetMode( struct GDS_Device* Device );
-int 	GDS_GrayMap( struct GDS_Device* Device, uint8_t Level );
-void 	GDS_ClearExt( struct GDS_Device* Device, bool full, ...);
-void 	GDS_Clear( struct GDS_Device* Device, int Color );
-void 	GDS_ClearWindow( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color );
+void GDS_SetContrast(struct GDS_Device* Device, uint8_t Contrast);
+void GDS_DisplayOn(struct GDS_Device* Device);
+void GDS_DisplayOff(struct GDS_Device* Device);
+void GDS_Update(struct GDS_Device* Device);
+void GDS_SetLayout(struct GDS_Device* Device, struct GDS_Layout* Layout);
+void GDS_SetDirty(struct GDS_Device* Device);
+int GDS_GetWidth(struct GDS_Device* Device);
+void GDS_SetTextWidth(struct GDS_Device* Device, int TextWidth);
+int GDS_GetHeight(struct GDS_Device* Device);
+int GDS_GetDepth(struct GDS_Device* Device);
+int GDS_GetMode(struct GDS_Device* Device);
+int GDS_GrayMap(struct GDS_Device* Device, uint8_t Level);
+void GDS_ClearExt(struct GDS_Device* Device, bool full, ...);
+void GDS_Clear(struct GDS_Device* Device, int Color);
+void GDS_ClearWindow(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color);
 
 #endif

components/display/core/gds_default_if.h

@@ -7,11 +7,11 @@ extern "C" {
 
 struct GDS_Device;
 
-bool GDS_I2CInit( int PortNumber, int SDA, int SCL, int speed );
-bool GDS_I2CAttachDevice( struct GDS_Device* Device, int Width, int Height, int I2CAddress, int RSTPin, int BacklightPin );
+bool GDS_I2CInit(int PortNumber, int SDA, int SCL, int speed);
+bool GDS_I2CAttachDevice(struct GDS_Device* Device, int Width, int Height, int I2CAddress, int RSTPin, int BacklightPin);
 
-bool GDS_SPIInit( int SPI, int DC );
-bool GDS_SPIAttachDevice( struct GDS_Device* Device, int Width, int Height, int CSPin, int RSTPin, int Speed, int BacklightPin );
+bool GDS_SPIInit(int SPI, int DC);
+bool GDS_SPIAttachDevice(struct GDS_Device* Device, int Width, int Height, int CSPin, int RSTPin, int Speed, int BacklightPin, int Mode);
 
 #ifdef __cplusplus
 }

components/display/core/gds_draw.c

@@ -17,320 +17,409 @@
 #include "gds.h"
 #include "gds_draw.h"
 
-static const unsigned char BitReverseTable256[] = 
-{
-  0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, 
-  0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 
-  0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 
-  0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, 
-  0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 
-  0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
-  0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, 
-  0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
-  0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
-  0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, 
-  0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
-  0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
-  0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, 
-  0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
-  0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 
-  0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
-};
+static const unsigned char BitReverseTable256[] = {0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+    0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
+    0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+    0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
+    0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+    0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
+    0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+    0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
+    0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+    0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
+    0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF};
 
-__attribute__( ( always_inline ) ) static inline void SwapInt( int* a, int* b ) {
+__attribute__((always_inline)) static inline void SwapInt(int* a, int* b) {
     int Temp = *b;
 
     *b = *a;
     *a = Temp;
 }
 
-void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	DrawPixelFast( Device, X, Y, Color );
-}
+void IRAM_ATTR GDS_DrawPixelFast(struct GDS_Device* Device, int X, int Y, int Color) { DrawPixelFast(Device, X, Y, Color); }
 
-void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int X, int Y, int Color ) {
-	DrawPixel( Device, X, Y, Color );
-}
+void IRAM_ATTR GDS_DrawPixel(struct GDS_Device* Device, int X, int Y, int Color) { DrawPixel(Device, X, Y, Color); }
 
-void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color ) {
+void GDS_DrawHLine(struct GDS_Device* Device, int x, int y, int Width, int Color) {
     int XEnd = x + Width;
 
-	Device->Dirty = true;
-	
-	if (x < 0) x = 0;
-	if (XEnd >= Device->Width) XEnd = Device->Width - 1;
-	
-	if (y < 0) y = 0;
-	else if (y >= Device->Height) y = Device->Height - 1;
+    Device->Dirty = true;
 
-    for ( ; x < XEnd; x++ ) DrawPixelFast( Device, x, y, Color );
+    if(x < 0) x = 0;
+    if(XEnd >= Device->Width) XEnd = Device->Width - 1;
+
+    if(y < 0)
+        y = 0;
+    else if(y >= Device->Height)
+        y = Device->Height - 1;
+
+    for(; x < XEnd; x++) DrawPixelFast(Device, x, y, Color);
 }
 
-void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color ) {
+void GDS_DrawVLine(struct GDS_Device* Device, int x, int y, int Height, int Color) {
     int YEnd = y + Height;
 
-	Device->Dirty = true;
-	
-	if (x < 0) x = 0;
-	if (x >= Device->Width) x = Device->Width - 1;
-	
-	if (y < 0) y = 0;
-	else if (YEnd >= Device->Height) YEnd = Device->Height - 1;
+    Device->Dirty = true;
 
-    for ( ; y < YEnd; y++ ) DrawPixel( Device, x, y, Color );
+    if(x < 0) x = 0;
+    if(x >= Device->Width) x = Device->Width - 1;
+
+    if(y < 0)
+        y = 0;
+    else if(YEnd >= Device->Height)
+        YEnd = Device->Height - 1;
+
+    for(; y < YEnd; y++) DrawPixel(Device, x, y, Color);
 }
 
-static inline void DrawWideLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
-    int dx = ( x1 - x0 );
-    int dy = ( y1 - y0 );
+static inline void DrawWideLine(struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color) {
+    int dx = (x1 - x0);
+    int dy = (y1 - y0);
     int Error = 0;
     int Incr = 1;
     int x = x0;
     int y = y0;
 
-    if ( dy < 0 ) {
+    if(dy < 0) {
         Incr = -1;
         dy = -dy;
     }
 
-    Error = ( dy * 2 ) - dx;
+    Error = (dy * 2) - dx;
 
-    for ( ; x < x1; x++ ) {
-        if ( IsPixelVisible( Device, x, y ) == true ) {
-            DrawPixelFast( Device, x, y, Color );
+    for(; x < x1; x++) {
+        if(IsPixelVisible(Device, x, y) == true) { DrawPixelFast(Device, x, y, Color); }
+
+        if(Error > 0) {
+            Error -= (dx * 2);
+            y += Incr;
         }
 
-        if ( Error > 0 ) {
-            Error-= ( dx * 2 );
-            y+= Incr;
-        }
-
-        Error+= ( dy * 2 );
+        Error += (dy * 2);
     }
 }
 
-static inline void DrawTallLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
-    int dx = ( x1 - x0 );
-    int dy = ( y1 - y0 );
+static inline void DrawTallLine(struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color) {
+    int dx = (x1 - x0);
+    int dy = (y1 - y0);
     int Error = 0;
     int Incr = 1;
     int x = x0;
     int y = y0;
 
-    if ( dx < 0 ) {
+    if(dx < 0) {
         Incr = -1;
         dx = -dx;
     }
 
-    Error = ( dx * 2 ) - dy;
+    Error = (dx * 2) - dy;
 
-    for ( ; y < y1; y++ ) {
-        if ( IsPixelVisible( Device, x, y ) == true ) {
-            DrawPixelFast( Device, x, y, Color );
+    for(; y < y1; y++) {
+        if(IsPixelVisible(Device, x, y) == true) { DrawPixelFast(Device, x, y, Color); }
+
+        if(Error > 0) {
+            Error -= (dy * 2);
+            x += Incr;
         }
 
-        if ( Error > 0 ) {
-            Error-= ( dy * 2 );
-            x+= Incr;
-        }
-
-        Error+= ( dx * 2 );
+        Error += (dx * 2);
     }
 }
 
-void GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color ) {
-    if ( x0 == x1 ) {
-        GDS_DrawVLine( Device, x0, y0, ( y1 - y0 ), Color );
-    } else if ( y0 == y1 ) {
-        GDS_DrawHLine( Device, x0, y0, ( x1 - x0 ), Color );
+void GDS_DrawLine(struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color) {
+    if(x0 == x1) {
+        GDS_DrawVLine(Device, x0, y0, (y1 - y0), Color);
+    } else if(y0 == y1) {
+        GDS_DrawHLine(Device, x0, y0, (x1 - x0), Color);
     } else {
-		Device->Dirty = true;
-        if ( abs( x1 - x0 ) > abs( y1 - y0 ) ) {
+        Device->Dirty = true;
+        if(abs(x1 - x0) > abs(y1 - y0)) {
             /* Wide ( run > rise ) */
-            if ( x0 > x1 ) {
-                SwapInt( &x0, &x1 );
-                SwapInt( &y0, &y1 );
+            if(x0 > x1) {
+                SwapInt(&x0, &x1);
+                SwapInt(&y0, &y1);
             }
 
-            DrawWideLine( Device, x0, y0, x1, y1, Color );
+            DrawWideLine(Device, x0, y0, x1, y1, Color);
         } else {
             /* Tall ( rise > run ) */
-            if ( y0 > y1 ) {
-                SwapInt( &y0, &y1 );
-                SwapInt( &x0, &x1 );
+            if(y0 > y1) {
+                SwapInt(&y0, &y1);
+                SwapInt(&x0, &x1);
             }
 
-            DrawTallLine( Device, x0, y0, x1, y1, Color );
+            DrawTallLine(Device, x0, y0, x1, y1, Color);
         }
     }
 }
 
-void GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill ) {
-    int Width = ( x2 - x1 );
-    int Height = ( y2 - y1 );
+void GDS_DrawBox(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill) {
+    int Width = (x2 - x1);
+    int Height = (y2 - y1);
 
-	Device->Dirty = true;
-	
-    if ( Fill == false ) {
+    Device->Dirty = true;
+
+    if(Fill == false) {
         /* Top side */
-        GDS_DrawHLine( Device, x1, y1, Width, Color );
+        GDS_DrawHLine(Device, x1, y1, Width, Color);
 
         /* Bottom side */
-        GDS_DrawHLine( Device, x1, y1 + Height, Width, Color );
+        GDS_DrawHLine(Device, x1, y1 + Height, Width, Color);
 
         /* Left side */
-        GDS_DrawVLine( Device, x1, y1, Height, Color );
+        GDS_DrawVLine(Device, x1, y1, Height, Color);
 
         /* Right side */
-        GDS_DrawVLine( Device, x1 + Width, y1, Height, Color );
+        GDS_DrawVLine(Device, x1 + Width, y1, Height, Color);
     } else {
         /* Fill the box by drawing horizontal lines */
-        for ( ; y1 <= y2; y1++ ) {
-            GDS_DrawHLine( Device, x1, y1, Width, Color );
-        }
+        for(; y1 <= y2; y1++) { GDS_DrawHLine(Device, x1, y1, Width, Color); }
     }
 }
 
-
 /****************************************************************************************
  * Process graphic display data from column-oriented data (MSbit first)
  */
-void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color ) {
-	if (!Height) Height = Device->Height;
-	if (!Width) Width = Device->Width;
-		
-	if (Device->DrawBitmapCBR) {
-		Device->DrawBitmapCBR( Device, Data, Width, Height, Color );
-	} else if (Device->Depth == 1) {
-		
-		Height >>= 3;
-		
-		// need to do row/col swap and bit-reverse
-		for (int r = 0; r < Height; r++) {
-			uint8_t *optr = Device->Framebuffer + r*Device->Width, *iptr = Data + r;
-			for (int c = Width; --c >= 0;) {
-				*optr++ = BitReverseTable256[*iptr];
-				iptr += Height;
-			}	
-		}
-	} else if (Device->Depth == 4)	{
-		uint8_t *optr = Device->Framebuffer;
-		int LineLen = Device->Width >> 1;
-		
-		Height >>= 3;
-		Color &= 0x0f;
-		
-		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
-			uint8_t Byte = BitReverseTable256[*Data++];
-			// we need to linearize code to let compiler better optimize
-			if (c & 0x01) {
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0x0f) | (((Byte & 0x01)*Color)<<4); optr += LineLen; 
-			} else {
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen; Byte >>= 1;
-				*optr = (*optr & 0xf0) | (((Byte & 0x01)*Color)); optr += LineLen;
-			}	
-			// end of a column, move to next one
-			if (++r == Height) { c++; r = 0; optr = Device->Framebuffer + (c >> 1); }		
-		}
-	} else if (Device->Depth == 8) {
-		uint8_t *optr = Device->Framebuffer;
-		int LineLen = Device->Width;
-	
-		Height >>= 3;
-			
-		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
-			uint8_t Byte = BitReverseTable256[*Data++];
-		
-			// we need to linearize code to let compiler better optimize
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; 
+void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t* Data, int Width, int Height, int Color) {
+    if(!Height) Height = Device->Height;
+    if(!Width) Width = Device->Width;
 
-			// end of a column, move to next one
-			if (++r == Height) { c++; r = 0; optr = Device->Framebuffer + c; }		
-		}	
-	} else if (Device->Depth == 16) {
-		uint16_t *optr = (uint16_t*) Device->Framebuffer;
-		int LineLen = Device->Width;
-	
-		Height >>= 3;
-		Color = __builtin_bswap16(Color);
-	
-		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
-			uint8_t Byte = BitReverseTable256[*Data++];
-		
-			// we need to linearize code to let compiler better optimize
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			*optr = ((Byte & 0x01) * Color); optr += LineLen; 
+    if(Device->DrawBitmapCBR) {
+        Device->DrawBitmapCBR(Device, Data, Width, Height, Color);
+    } else if(Device->Depth == 1) {
 
-			// end of a column, move to next one
-			if (++r == Height) { c++; r = 0; optr = (uint16_t*) Device->Framebuffer + c; }		
-		}
-	} else if (Device->Depth == 24) {
-		uint8_t *optr = Device->Framebuffer;
-		int LineLen = Device->Width * 3;
-		
-		Height >>= 3;
-		if (Device->Mode == GDS_RGB666) Color = ((Color << 4) & 0xff0000) | ((Color << 2) & 0xff00) | (Color & 0x00ff);
-			
-		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
-			uint8_t Byte = BitReverseTable256[*Data++];
-		
-			// we need to linearize code to let compiler better optimize		
-			#define SET24(O,D) O[0]=(D)>>16; O[1]=(D)>>8; O[2]=(D);
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen; Byte >>= 1;
-			SET24(optr,(Byte & 0x01) * Color); optr += LineLen;
+        Height >>= 3;
 
-			// end of a column, move to next one
-			if (++r == Height) { c++; r = 0; optr = Device->Framebuffer + c * 3; }		
-		}
-	} else {
-		Height >>= 3;
-		
-		// don't know bitdepth, use brute-force solution
-		for (int i = Width * Height, r = 0, c = 0; --i >= 0;) {
-			uint8_t Byte = *Data++;
-			DrawPixelFast( Device, c, (r << 3) + 7, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 6, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 5, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 4, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 3, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 2, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 1, (Byte & 0x01) * Color ); Byte >>= 1;
-			DrawPixelFast( Device, c, (r << 3) + 0, (Byte & 0x01) * Color ); 
-			if (++r == Height) { c++; r = 0; }			
-		}
-		/* for better understanding, here is the mundane version 
+        // need to do row/col swap and bit-reverse
+        for(int r = 0; r < Height; r++) {
+            uint8_t *optr = Device->Framebuffer + r * Device->Width, *iptr = Data + r;
+            for(int c = Width; --c >= 0;) {
+                *optr++ = BitReverseTable256[*iptr];
+                iptr += Height;
+            }
+        }
+    } else if(Device->Depth == 4) {
+        uint8_t* optr = Device->Framebuffer;
+        int LineLen = Device->Width >> 1;
+
+        Height >>= 3;
+        Color &= 0x0f;
+
+        for(int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+            uint8_t Byte = BitReverseTable256[*Data++];
+            // we need to linearize code to let compiler better optimize
+            if(c & 0x01) {
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0x0f) | (((Byte & 0x01) * Color) << 4);
+                optr += LineLen;
+            } else {
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+                Byte >>= 1;
+                *optr = (*optr & 0xf0) | (((Byte & 0x01) * Color));
+                optr += LineLen;
+            }
+            // end of a column, move to next one
+            if(++r == Height) {
+                c++;
+                r = 0;
+                optr = Device->Framebuffer + (c >> 1);
+            }
+        }
+    } else if(Device->Depth == 8) {
+        uint8_t* optr = Device->Framebuffer;
+        int LineLen = Device->Width;
+
+        Height >>= 3;
+
+        for(int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+            uint8_t Byte = BitReverseTable256[*Data++];
+
+            // we need to linearize code to let compiler better optimize
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+
+            // end of a column, move to next one
+            if(++r == Height) {
+                c++;
+                r = 0;
+                optr = Device->Framebuffer + c;
+            }
+        }
+    } else if(Device->Depth == 16) {
+        uint16_t* optr = (uint16_t*)Device->Framebuffer;
+        int LineLen = Device->Width;
+
+        Height >>= 3;
+        Color = __builtin_bswap16(Color);
+
+        for(int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+            uint8_t Byte = BitReverseTable256[*Data++];
+
+            // we need to linearize code to let compiler better optimize
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            *optr = ((Byte & 0x01) * Color);
+            optr += LineLen;
+
+            // end of a column, move to next one
+            if(++r == Height) {
+                c++;
+                r = 0;
+                optr = (uint16_t*)Device->Framebuffer + c;
+            }
+        }
+    } else if(Device->Depth == 24) {
+        uint8_t* optr = Device->Framebuffer;
+        int LineLen = Device->Width * 3;
+
+        Height >>= 3;
+        if(Device->Mode == GDS_RGB666) Color = ((Color << 4) & 0xff0000) | ((Color << 2) & 0xff00) | (Color & 0x00ff);
+
+        for(int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+            uint8_t Byte = BitReverseTable256[*Data++];
+
+// we need to linearize code to let compiler better optimize
+#define SET24(O, D)                                                                                                                                  \
+    O[0] = (D) >> 16;                                                                                                                                \
+    O[1] = (D) >> 8;                                                                                                                                 \
+    O[2] = (D);
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+            Byte >>= 1;
+            SET24(optr, (Byte & 0x01) * Color);
+            optr += LineLen;
+
+            // end of a column, move to next one
+            if(++r == Height) {
+                c++;
+                r = 0;
+                optr = Device->Framebuffer + c * 3;
+            }
+        }
+    } else {
+        Height >>= 3;
+
+        // don't know bitdepth, use brute-force solution
+        for(int i = Width * Height, r = 0, c = 0; --i >= 0;) {
+            uint8_t Byte = *Data++;
+            DrawPixelFast(Device, c, (r << 3) + 7, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 6, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 5, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 4, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 3, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 2, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 1, (Byte & 0x01) * Color);
+            Byte >>= 1;
+            DrawPixelFast(Device, c, (r << 3) + 0, (Byte & 0x01) * Color);
+            if(++r == Height) {
+                c++;
+                r = 0;
+            }
+        }
+        /* for better understanding, here is the mundane version 
 		for (int x = 0; x < Width; x++) {
 			for (int y = 0; y < Height; y++) {
 				uint8_t Byte = *Data++;
@@ -345,7 +434,7 @@ void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t *Data, int Width, int
 			}
 		}
 		*/
-	}
-	
-	Device->Dirty = true;
+    }
+
+    Device->Dirty = true;
 }

components/display/core/gds_draw.h

@@ -5,7 +5,7 @@
  * https://opensource.org/licenses/MIT
  * 
  */
- 
+
 #ifndef _GDS_DRAW_H_
 #define _GDS_DRAW_H_
 
@@ -17,14 +17,14 @@
 extern "C" {
 #endif
 
-void IRAM_ATTR GDS_DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color );
-void IRAM_ATTR GDS_DrawPixel( struct GDS_Device* Device, int X, int Y, int Color );
-void GDS_DrawHLine( struct GDS_Device* Device, int x, int y, int Width, int Color );
-void GDS_DrawVLine( struct GDS_Device* Device, int x, int y, int Height, int Color );
-void GDS_DrawLine( struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color );
-void GDS_DrawBox( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill );
-// draw a bitmap with source 1-bit depth organized in column and col0 = bit7 of byte 0 
-void GDS_DrawBitmapCBR( struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color);
+void IRAM_ATTR GDS_DrawPixelFast(struct GDS_Device* Device, int X, int Y, int Color);
+void IRAM_ATTR GDS_DrawPixel(struct GDS_Device* Device, int X, int Y, int Color);
+void GDS_DrawHLine(struct GDS_Device* Device, int x, int y, int Width, int Color);
+void GDS_DrawVLine(struct GDS_Device* Device, int x, int y, int Height, int Color);
+void GDS_DrawLine(struct GDS_Device* Device, int x0, int y0, int x1, int y1, int Color);
+void GDS_DrawBox(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color, bool Fill);
+// draw a bitmap with source 1-bit depth organized in column and col0 = bit7 of byte 0
+void GDS_DrawBitmapCBR(struct GDS_Device* Device, uint8_t* Data, int Width, int Height, int Color);
 
 #ifdef __cplusplus
 }

components/display/core/gds_err.h

@@ -3,36 +3,39 @@
 
 #include <esp_log.h>
 
-#define GDS_DoAbort( )
+#define GDS_DoAbort()
 
-#if ! defined NullCheck
-    #define NullCheck( ptr, retexpr ) { \
-        if ( ptr == NULL ) { \
-            ESP_LOGE( __FUNCTION__, "%s == NULL", #ptr ); \
-            GDS_DoAbort( ); \
-            retexpr; \
-        } \
+#if !defined NullCheck
+#define NullCheck(ptr, retexpr)                                                                                                                      \
+    {                                                                                                                                                \
+        if(ptr == NULL) {                                                                                                                            \
+            ESP_LOGE(__FUNCTION__, "%s == NULL", #ptr);                                                                                              \
+            GDS_DoAbort();                                                                                                                           \
+            retexpr;                                                                                                                                 \
+        }                                                                                                                                            \
     }
 #endif
 
-#if ! defined ESP_ERROR_CHECK_NONFATAL
-    #define ESP_ERROR_CHECK_NONFATAL( expr, retexpr ) { \
-        esp_err_t __err_rc = ( expr ); \
-        if ( __err_rc != ESP_OK ) { \
-            ESP_LOGE( __FUNCTION__, "%s != ESP_OK, result: %d", #expr, __err_rc ); \
-            GDS_DoAbort( ); \
-            retexpr; \
-        } \
+#if !defined ESP_ERROR_CHECK_NONFATAL
+#define ESP_ERROR_CHECK_NONFATAL(expr, retexpr)                                                                                                      \
+    {                                                                                                                                                \
+        esp_err_t __err_rc = (expr);                                                                                                                 \
+        if(__err_rc != ESP_OK) {                                                                                                                     \
+            ESP_LOGE(__FUNCTION__, "%s != ESP_OK, result: %d", #expr, __err_rc);                                                                     \
+            GDS_DoAbort();                                                                                                                           \
+            retexpr;                                                                                                                                 \
+        }                                                                                                                                            \
     }
 #endif
 
-#if ! defined CheckBounds
-    #define CheckBounds( expr, retexpr ) { \
-        if ( expr ) { \
-            ESP_LOGE( __FUNCTION__, "Line %d: %s", __LINE__, #expr ); \
-            GDS_DoAbort( ); \
-            retexpr; \
-        } \
+#if !defined CheckBounds
+#define CheckBounds(expr, retexpr)                                                                                                                   \
+    {                                                                                                                                                \
+        if(expr) {                                                                                                                                   \
+            ESP_LOGE(__FUNCTION__, "Line %d: %s", __LINE__, #expr);                                                                                  \
+            GDS_DoAbort();                                                                                                                           \
+            retexpr;                                                                                                                                 \
+        }                                                                                                                                            \
     }
 #endif
 

components/display/core/gds_font.c

@@ -14,25 +14,77 @@
 #include "gds_font.h"
 #include "gds_draw.h"
 #include "gds_err.h"
+#include "esp_spiffs.h"
+#include "esp_log.h"
+#include "esp_heap_caps.h"
+#include "tools.h"
+static const char* TAG = "gds_font";
+struct GDS_FontDef* Font_droid_sans_fallback_11x13 = NULL;
+struct GDS_FontDef* Font_line_1 = NULL;
+struct GDS_FontDef* Font_line_2 = NULL;
 
-static int RoundUpFontHeight( const struct GDS_FontDef* Font ) {
+// struct GDS_FontDef * Font_droid_sans_fallback_15x17 = NULL;
+// struct GDS_FontDef * Font_droid_sans_fallback_24x28 = NULL;
+// struct GDS_FontDef * Font_droid_sans_mono_7x13 = NULL;
+// struct GDS_FontDef * Font_droid_sans_mono_13x24 = NULL;
+// struct GDS_FontDef * Font_droid_sans_mono_16x31 = NULL;
+// struct GDS_FontDef * Font_liberation_mono_9x15 = NULL;
+// struct GDS_FontDef * Font_liberation_mono_13x21 = NULL;
+// struct GDS_FontDef * Font_liberation_mono_17x30 = NULL;
+// struct GDS_FontDef * Font_Tarable7Seg_16x32 = NULL;
+// struct GDS_FontDef * Font_Tarable7Seg_32x64 = NULL;
+
+static bool LoadFont(struct GDS_FontDef** fontPtr, const char* fileName) {
+    if(!fontPtr) {
+        ESP_LOGE(TAG, "Invalid pointer for LoadFont");
+        return false;
+    }
+    char font_file_name[CONFIG_SPIFFS_OBJ_NAME_LEN + 1] = {0};
+    snprintf(font_file_name, sizeof(font_file_name), "/spiffs/fonts/%s", fileName);
+    // Allocate DMA-capable memory for the font
+    struct GDS_FontDef* loadedFont = load_file_dma(NULL, font_file_name);
+
+    // Check if allocation succeeded
+    if(loadedFont == NULL) {
+        ESP_LOGE(TAG, "Failed to load font");
+        return false;
+    }
+    // Update the pointer
+    *fontPtr = loadedFont;
+
+    ESP_LOGI(TAG, "Successfully loaded font: %s", fileName);
+    return true;
+}
+bool gds_init_fonts() {
+    bool success = true;
+
+    // Load the Font_droid_sans_fallback_11x13
+    if(!LoadFont(&Font_droid_sans_fallback_11x13, "droid_sans_fb_11x13.bin")) { success = false; }
+
+    // Load the Font_line_1
+    if(!LoadFont(&Font_line_1, "line_1.bin")) { success = false; }
+
+    // Load the Font_line_2
+    if(!LoadFont(&Font_line_2, "line_2.bin")) { success = false; }
+
+    return success;
+}
+static int RoundUpFontHeight(const struct GDS_FontDef* Font) {
     int Height = Font->Height;
 
-    if ( ( Height % 8 ) != 0 ) {
-        return ( ( Height + 7 ) / 8 ) * 8;
-    }
+    if((Height % 8) != 0) { return ((Height + 7) / 8) * 8; }
 
     return Height;
 }
 
-static const uint8_t* GetCharPtr( const struct GDS_FontDef* Font, char Character ) {
-    return &Font->FontData[ ( Character - Font->StartChar ) * ( ( Font->Width * ( RoundUpFontHeight( Font ) / 8 ) ) + 1 ) ];
+static const uint8_t* GetCharPtr(const struct GDS_FontDef* Font, char Character) {
+    return &Font->FontData[(Character - Font->StartChar) * ((Font->Width * (RoundUpFontHeight(Font) / 8)) + 1)];
 }
 
-void GDS_FontDrawChar( struct GDS_Device* Device, char Character, int x, int y, int Color ) {
+void GDS_FontDrawChar(struct GDS_Device* Device, char Character, int x, int y, int Color) {
     const uint8_t* GlyphData = NULL;
     int GlyphColumnLen = 0;
-    int CharStartX =  0;
+    int CharStartX = 0;
     int CharStartY = 0;
     int CharWidth = 0;
     int CharHeight = 0;
@@ -44,227 +96,204 @@ void GDS_FontDrawChar( struct GDS_Device* Device, char Character, int x, int y,
     int YBit = 0;
     int i = 0;
 
-    NullCheck( ( GlyphData = GetCharPtr( Device->Font, Character ) ), return );
+    NullCheck((GlyphData = GetCharPtr(Device->Font, Character)), return);
 
-    if ( Character >= Device->Font->StartChar && Character <= Device->Font->EndChar ) {
+    if(Character >= Device->Font->StartChar && Character <= Device->Font->EndChar) {
         /* The first byte in the glyph data is the width of the character in pixels, skip over */
         GlyphData++;
-        GlyphColumnLen = RoundUpFontHeight( Device->Font ) / 8;
-        
-        CharWidth = GDS_FontGetCharWidth( Device, Character );
-        CharHeight = GDS_FontGetHeight( Device );
+        GlyphColumnLen = RoundUpFontHeight(Device->Font) / 8;
+
+        CharWidth = GDS_FontGetCharWidth(Device, Character);
+        CharHeight = GDS_FontGetHeight(Device);
 
         CharStartX = x;
         CharStartY = y;
-        
+
         CharEndX = CharStartX + CharWidth;
         CharEndY = CharStartY + CharHeight;
 
         /* If the character is partially offscreen offset the end by
         * distance between (coord) and 0.
         */
-        OffsetX = ( CharStartX < 0 ) ? abs( CharStartX ) : 0;
-        OffsetY = ( CharStartY < 0 ) ? abs( CharStartY ) : 0;
+        OffsetX = (CharStartX < 0) ? abs(CharStartX) : 0;
+        OffsetY = (CharStartY < 0) ? abs(CharStartY) : 0;
 
         /* This skips into the proper column within the glyph data */
-        GlyphData+= ( OffsetX * GlyphColumnLen );
+        GlyphData += (OffsetX * GlyphColumnLen);
 
-        CharStartX+= OffsetX;
-        CharStartY+= OffsetY;
+        CharStartX += OffsetX;
+        CharStartY += OffsetY;
 
         /* Do not attempt to draw if this character is entirely offscreen */
-        if ( CharEndX < 0 || CharStartX >= Device->Width || CharEndY < 0 || CharStartY >= Device->Height ) {
-            ClipDebug( x, y );
+        if(CharEndX < 0 || CharStartX >= Device->TextWidth || CharEndY < 0 || CharStartY >= Device->Height) {
+            ClipDebug(x, y);
             return;
         }
 
         /* Do not attempt to draw past the end of the screen */
-        CharEndX = ( CharEndX >= Device->Width ) ? Device->Width - 1 : CharEndX;
-        CharEndY = ( CharEndY >= Device->Height ) ? Device->Height - 1 : CharEndY;
-		Device->Dirty = true;
+        CharEndX = (CharEndX >= Device->TextWidth) ? Device->TextWidth - 1 : CharEndX;
+        CharEndY = (CharEndY >= Device->Height) ? Device->Height - 1 : CharEndY;
+        Device->Dirty = true;
 
-        for ( x = CharStartX; x < CharEndX; x++ ) {
-            for ( y = CharStartY, i = 0; y < CharEndY && i < CharHeight; y++, i++ ) {
-                YByte = ( i + OffsetY ) / 8;
-                YBit = ( i + OffsetY ) & 0x07;
+        for(x = CharStartX; x < CharEndX; x++) {
+            for(y = CharStartY, i = 0; y < CharEndY && i < CharHeight; y++, i++) {
+                YByte = (i + OffsetY) / 8;
+                YBit = (i + OffsetY) & 0x07;
 
-                if ( GlyphData[ YByte ] & BIT( YBit ) ) {
-                    DrawPixel( Device, x, y, Color );
-                }            
+                if(GlyphData[YByte] & BIT(YBit)) { DrawPixel(Device, x, y, Color); }
             }
 
-            GlyphData+= GlyphColumnLen;
+            GlyphData += GlyphColumnLen;
         }
     }
 }
 
-bool GDS_SetFont( struct GDS_Device* Display, const struct GDS_FontDef* Font ) {
+const struct GDS_FontDef* GDS_SetFont(struct GDS_Device* Display, const struct GDS_FontDef* Font) {
+    const struct GDS_FontDef* OldFont = Display->Font;
+
     Display->FontForceProportional = false;
     Display->FontForceMonospace = false;
     Display->Font = Font;
 
-    return true;
+    return OldFont;
 }
 
-void GDS_FontForceProportional( struct GDS_Device* Display, bool Force ) {
-    Display->FontForceProportional = Force;
-}
+void GDS_FontForceProportional(struct GDS_Device* Display, bool Force) { Display->FontForceProportional = Force; }
 
-void GDS_FontForceMonospace( struct GDS_Device* Display, bool Force ) {
-    Display->FontForceMonospace = Force;
-}
+void GDS_FontForceMonospace(struct GDS_Device* Display, bool Force) { Display->FontForceMonospace = Force; }
 
-int GDS_FontGetWidth( struct GDS_Device* Display ) {
-    return Display->Font->Width;
-}
+int GDS_FontGetWidth(struct GDS_Device* Display) { return Display->Font->Width; }
 
-int GDS_FontGetHeight( struct GDS_Device* Display ) {
-    return Display->Font->Height;
-}
+int GDS_FontGetHeight(struct GDS_Device* Display) { return Display->Font->Height; }
 
-int GDS_FontGetCharWidth( struct GDS_Device* Display, char Character ) {
+int GDS_FontGetCharWidth(struct GDS_Device* Display, char Character) {
     const uint8_t* CharPtr = NULL;
     int Width = 0;
 
-    if ( Character >= Display->Font->StartChar && Character <= Display->Font->EndChar ) {
-        CharPtr = GetCharPtr( Display->Font, Character );
+    if(Character >= Display->Font->StartChar && Character <= Display->Font->EndChar) {
+        CharPtr = GetCharPtr(Display->Font, Character);
+        Width = (Display->Font->Monospace == true) ? Display->Font->Width : *CharPtr;
+        if(Display->FontForceMonospace == true) { Width = Display->Font->Width; }
 
-        Width = ( Display->Font->Monospace == true ) ? Display->Font->Width : *CharPtr;
-
-        if ( Display->FontForceMonospace == true ) {
-            Width = Display->Font->Width;
-        }
-
-        if ( Display->FontForceProportional == true ) {
-            Width = *CharPtr;
-        }
+        if(Display->FontForceProportional == true) { Width = *CharPtr; }
     }
 
     return Width;
 }
 
-int GDS_FontGetMaxCharsPerRow( struct GDS_Device* Display ) {
-    return Display->Width / Display->Font->Width;
-}
+int GDS_FontGetMaxCharsPerRow(struct GDS_Device* Display) { return Display->TextWidth / Display->Font->Width; }
 
-int GDS_FontGetMaxCharsPerColumn( struct GDS_Device* Display ) {
-    return Display->Height / Display->Font->Height;    
-}
+int GDS_FontGetMaxCharsPerColumn(struct GDS_Device* Display) { return Display->Height / Display->Font->Height; }
 
-int GDS_FontGetCharHeight( struct GDS_Device* Display ) {
-    return Display->Font->Height;
-}
+int GDS_FontGetCharHeight(struct GDS_Device* Display) { return Display->Font->Height; }
 
-int GDS_FontMeasureString( struct GDS_Device* Display, const char* Text ) {
+int GDS_FontMeasureString(struct GDS_Device* Display, const char* Text) {
     int Width = 0;
     int Len = 0;
 
-    NullCheck( Text, return 0 );
+    NullCheck(Text, return 0);
 
-    for ( Len = strlen( Text ); Len >= 0; Len--, Text++ ) {
-        if ( *Text >= Display->Font->StartChar && *Text <= Display->Font->EndChar ) {
-            Width+= GDS_FontGetCharWidth( Display, *Text );
-        }
+    for(Len = strlen(Text); Len >= 0; Len--, Text++) {
+        if(*Text >= Display->Font->StartChar && *Text <= Display->Font->EndChar) { Width += GDS_FontGetCharWidth(Display, *Text); }
     }
-
     return Width;
 }
 
-void GDS_FontDrawString( struct GDS_Device* Display, int x, int y, const char* Text, int Color ) {
+void GDS_FontDrawString(struct GDS_Device* Display, int x, int y, const char* Text, int Color) {
     int Len = 0;
     int i = 0;
 
-    NullCheck( Text, return );
+    NullCheck(Text, return);
 
-    for ( Len = strlen( Text ), i = 0; i < Len; i++ ) {
-        GDS_FontDrawChar( Display, *Text, x, y, Color );
+    for(Len = strlen(Text), i = 0; i < Len; i++) {
+        GDS_FontDrawChar(Display, *Text, x, y, Color);
 
-        x+= GDS_FontGetCharWidth( Display, *Text );
+        x += GDS_FontGetCharWidth(Display, *Text);
         Text++;
     }
 }
 
-void GDS_FontDrawAnchoredString( struct GDS_Device* Display, TextAnchor Anchor, const char* Text, int Color ) {
+void GDS_FontDrawAnchoredString(struct GDS_Device* Display, TextAnchor Anchor, const char* Text, int Color) {
     int x = 0;
     int y = 0;
 
-    NullCheck( Text, return );
+    NullCheck(Text, return);
 
-    GDS_FontGetAnchoredStringCoords( Display, &x, &y, Anchor, Text );
-    GDS_FontDrawString( Display, x, y, Text, Color );
+    GDS_FontGetAnchoredStringCoords(Display, &x, &y, Anchor, Text);
+    GDS_FontDrawString(Display, x, y, Text, Color);
 }
 
-void GDS_FontGetAnchoredStringCoords( struct GDS_Device* Display, int* OutX, int* OutY, TextAnchor Anchor, const char* Text ) {
+void GDS_FontGetAnchoredStringCoords(struct GDS_Device* Display, int* OutX, int* OutY, TextAnchor Anchor, const char* Text) {
     int StringWidth = 0;
     int StringHeight = 0;
 
-    NullCheck( OutX, return );
-    NullCheck( OutY, return );
-    NullCheck( Text, return );
+    NullCheck(OutX, return);
+    NullCheck(OutY, return);
+    NullCheck(Text, return);
 
-    StringWidth = GDS_FontMeasureString( Display, Text );
-    StringHeight = GDS_FontGetCharHeight( Display );
+    StringWidth = GDS_FontMeasureString(Display, Text);
+    StringHeight = GDS_FontGetCharHeight(Display);
 
-    switch ( Anchor ) {
-        case TextAnchor_East: {
-            *OutY = ( Display->Height / 2 ) - ( StringHeight / 2 );
-            *OutX = ( Display->Width - StringWidth );
+    switch(Anchor) {
+    case TextAnchor_East: {
+        *OutY = (Display->Height / 2) - (StringHeight / 2);
+        *OutX = (Display->TextWidth - StringWidth);
 
-            break;
-        }
-        case TextAnchor_West: {
-            *OutY = ( Display->Height / 2 ) - ( StringHeight / 2 );
-            *OutX = 0;
+        break;
+    }
+    case TextAnchor_West: {
+        *OutY = (Display->Height / 2) - (StringHeight / 2);
+        *OutX = 0;
 
-            break;
-        }
-        case TextAnchor_North: {
-            *OutX = ( Display->Width / 2 ) - ( StringWidth / 2 );
-            *OutY = 0;
+        break;
+    }
+    case TextAnchor_North: {
+        *OutX = (Display->TextWidth / 2) - (StringWidth / 2);
+        *OutY = 0;
 
-            break;
-        }
-        case TextAnchor_South: {
-            *OutX = ( Display->Width / 2 ) - ( StringWidth / 2 );
-            *OutY = ( Display->Height - StringHeight );
-            
-            break;
-        }
-        case TextAnchor_NorthEast: {
-            *OutX = ( Display->Width - StringWidth );
-            *OutY = 0;
+        break;
+    }
+    case TextAnchor_South: {
+        *OutX = (Display->TextWidth / 2) - (StringWidth / 2);
+        *OutY = (Display->Height - StringHeight);
 
-            break;
-        }
-        case TextAnchor_NorthWest: {
-            *OutY = 0;
-            *OutX = 0;
+        break;
+    }
+    case TextAnchor_NorthEast: {
+        *OutX = (Display->TextWidth - StringWidth);
+        *OutY = 0;
 
-            break;
-        }
-        case TextAnchor_SouthEast: {
-            *OutY = ( Display->Height - StringHeight );
-            *OutX = ( Display->Width - StringWidth );
+        break;
+    }
+    case TextAnchor_NorthWest: {
+        *OutY = 0;
+        *OutX = 0;
 
-            break;
-        }
-        case TextAnchor_SouthWest: {
-            *OutY = ( Display->Height - StringHeight );
-            *OutX = 0;
+        break;
+    }
+    case TextAnchor_SouthEast: {
+        *OutY = (Display->Height - StringHeight);
+        *OutX = (Display->TextWidth - StringWidth);
 
-            break;
-        }
-        case TextAnchor_Center: {
-            *OutY = ( Display->Height / 2 ) - ( StringHeight / 2 );
-            *OutX = ( Display->Width / 2 ) - ( StringWidth / 2 );
+        break;
+    }
+    case TextAnchor_SouthWest: {
+        *OutY = (Display->Height - StringHeight);
+        *OutX = 0;
 
-            break;
-        }
-        default: {
-            *OutX = 128;
-            *OutY = 64;
-            
-            break;
-        }
+        break;
+    }
+    case TextAnchor_Center: {
+        *OutY = (Display->Height / 2) - (StringHeight / 2);
+        *OutX = (Display->TextWidth / 2) - (StringWidth / 2);
+
+        break;
+    }
+    default: {
+        *OutX = 128;
+        *OutY = 64;
+
+        break;
+    }
     };
 }

components/display/core/gds_font.h

@@ -21,18 +21,21 @@ struct GDS_Device;
  * 'b': [Glyph width][Pixel column 0][Pixel column 1]...
  * 'c': And so on...
  */
- 
+
+#pragma pack(push, 1) // Disable padding
 struct GDS_FontDef {
-    const uint8_t* FontData;
+    const void* dummy; // 4 bytes (assuming 32-bit pointers)
 
-    int Width;
-    int Height;
+    int Width;      // 4 bytes
+    int Height;     // 4 bytes
+    int StartChar;  // 4 bytes
+    int EndChar;    // 4 bytes
+    bool Monospace; // 1 byte
 
-    int StartChar;
-    int EndChar;
-
-    bool Monospace;
+    uint8_t padding[3];       // 3 bytes padding to align to 24 bytes
+    const uint8_t FontData[]; // 4 bytes (assuming 32-bit pointers)
 };
+#pragma pack(pop) // Re-enable padding
 
 typedef enum {
     TextAnchor_East = 0,
@@ -45,44 +48,45 @@ typedef enum {
     TextAnchor_SouthWest,
     TextAnchor_Center
 } TextAnchor;
+bool gds_init_fonts();
+const struct GDS_FontDef* GDS_SetFont(struct GDS_Device* Display, const struct GDS_FontDef* Font);
 
-bool GDS_SetFont( struct GDS_Device* Display, const struct GDS_FontDef* Font );
+void GDS_FontForceProportional(struct GDS_Device* Display, bool Force);
+void GDS_FontForceMonospace(struct GDS_Device* Display, bool Force);
 
-void GDS_FontForceProportional( struct GDS_Device* Display, bool Force );
-void GDS_FontForceMonospace( struct GDS_Device* Display, bool Force );
+int GDS_FontGetWidth(struct GDS_Device* Display);
+int GDS_FontGetHeight(struct GDS_Device* Display);
 
-int GDS_FontGetWidth( struct GDS_Device* Display );
-int GDS_FontGetHeight( struct GDS_Device* Display );
+int GDS_FontGetMaxCharsPerRow(struct GDS_Device* Display);
+int GDS_FontGetMaxCharsPerColumn(struct GDS_Device* Display);
 
-int GDS_FontGetMaxCharsPerRow( struct GDS_Device* Display );
-int GDS_FontGetMaxCharsPerColumn( struct GDS_Device* Display );
+int GDS_FontGetCharWidth(struct GDS_Device* Display, char Character);
+int GDS_FontGetCharHeight(struct GDS_Device* Display);
+int GDS_FontMeasureString(struct GDS_Device* Display, const char* Text);
+int GDS_FontMeasureStringLine(struct GDS_Device* Display, int Line, const char* Text);
 
-int GDS_FontGetCharWidth( struct GDS_Device* Display, char Character );
-int GDS_FontGetCharHeight( struct GDS_Device* Display );
-int GDS_FontMeasureString( struct GDS_Device* Display, const char* Text );\
+void GDS_FontDrawChar(struct GDS_Device* Display, char Character, int x, int y, int Color);
+void GDS_FontDrawString(struct GDS_Device* Display, int x, int y, const char* Text, int Color);
+void GDS_FontDrawAnchoredString(struct GDS_Device* Display, TextAnchor Anchor, const char* Text, int Color);
+void GDS_FontGetAnchoredStringCoords(struct GDS_Device* Display, int* OutX, int* OutY, TextAnchor Anchor, const char* Text);
 
-void GDS_FontDrawChar( struct GDS_Device* Display, char Character, int x, int y, int Color );
-void GDS_FontDrawString( struct GDS_Device* Display, int x, int y, const char* Text, int Color );
-void GDS_FontDrawAnchoredString( struct GDS_Device* Display, TextAnchor Anchor, const char* Text, int Color );
-void GDS_FontGetAnchoredStringCoords( struct GDS_Device* Display, int* OutX, int* OutY, TextAnchor Anchor, const char* Text );
+extern struct GDS_FontDef* Font_droid_sans_fallback_11x13;
+// const struct GDS_FontDef * Font_droid_sans_fallback_15x17;
+// const struct GDS_FontDef * Font_droid_sans_fallback_24x28;
 
-extern const struct GDS_FontDef Font_droid_sans_fallback_11x13;
-extern const struct GDS_FontDef Font_droid_sans_fallback_15x17;
-extern const struct GDS_FontDef Font_droid_sans_fallback_24x28;
+// const struct GDS_FontDef * Font_droid_sans_mono_7x13;
+// const struct GDS_FontDef * Font_droid_sans_mono_13x24;
+// const struct GDS_FontDef * Font_droid_sans_mono_16x31;
 
-extern const struct GDS_FontDef Font_droid_sans_mono_7x13;
-extern const struct GDS_FontDef Font_droid_sans_mono_13x24;
-extern const struct GDS_FontDef Font_droid_sans_mono_16x31;
+// const struct GDS_FontDef * Font_liberation_mono_9x15;
+// const struct GDS_FontDef * Font_liberation_mono_13x21;
+// const struct GDS_FontDef * Font_liberation_mono_17x30;
 
-extern const struct GDS_FontDef Font_liberation_mono_9x15;
-extern const struct GDS_FontDef Font_liberation_mono_13x21;
-extern const struct GDS_FontDef Font_liberation_mono_17x30;
+// const struct GDS_FontDef * Font_Tarable7Seg_16x32;
+// const struct GDS_FontDef * Font_Tarable7Seg_32x64;
 
-extern const struct GDS_FontDef Font_Tarable7Seg_16x32;
-extern const struct GDS_FontDef Font_Tarable7Seg_32x64;
-
-extern const struct GDS_FontDef Font_line_1;
-extern const struct GDS_FontDef Font_line_2;
+extern struct GDS_FontDef* Font_line_1;
+extern struct GDS_FontDef* Font_line_2;
 
 #ifdef __cplusplus
 }

components/display/core/gds_image.c

@@ -5,35 +5,39 @@
  * https://opensource.org/licenses/MIT
  * 
  */
- 
+
 #include <string.h>
 #include "math.h"
+#ifdef TJPGD_ROM
 #include "esp32/rom/tjpgd.h"
+#else
+#include "tjpgd.h"
+#endif
 #include "esp_log.h"
 
 #include "gds.h"
 #include "gds_private.h"
 #include "gds_image.h"
 
-const char TAG[] = "ImageDec";
+const static char TAG[] = "ImageDec";
 
-#define SCRATCH_SIZE	3100
+#define SCRATCH_SIZE 3100
 
 //Data that is passed from the decoder function to the infunc/outfunc functions.
 typedef struct {
-    const unsigned char *InData;	// Pointer to jpeg data
-    int InPos;						// Current position in jpeg data
-	int Width, Height;	
-	uint8_t Mode;
-	union {
-		void *OutData;
-		struct {						// DirectDraw
-			struct GDS_Device *Device;
-			int XOfs, YOfs;
-			int XMin, YMin;
-			int Depth;
-		};	
-	};	
+    const unsigned char* InData; // Pointer to jpeg data
+    int InPos;                   // Current position in jpeg data
+    int Width, Height;
+    uint8_t Mode;
+    union {
+        void* OutData;
+        struct { // DirectDraw
+            struct GDS_Device* Device;
+            int XOfs, YOfs;
+            int XMin, YMin;
+            int Depth;
+        };
+    };
 } JpegCtx;
 
 /****************************************************************************************
@@ -42,192 +46,182 @@ typedef struct {
  * monochrome (0.2125 * color.r) + (0.7154 * color.g) + (0.0721 * color.b)
  * grayscale (0.3 * R) + (0.59 * G) + (0.11 * B) )
  */
-static inline int Scaler332(uint8_t *Pixels) {
-	return (Pixels[2] & ~0x1f) | ((Pixels[1] & ~0x1f) >> 3) | (Pixels[0] >> 6);
-}
+static inline int Scaler332(uint8_t* Pixels) { return (Pixels[2] & ~0x1f) | ((Pixels[1] & ~0x1f) >> 3) | (Pixels[0] >> 6); }
 
-static inline int Scaler444(uint8_t *Pixels) {
-	return ((Pixels[2] & ~0x0f) << 4) | (Pixels[1] & ~0x0f) | (Pixels[0] >> 4);
-}
+static inline int Scaler444(uint8_t* Pixels) { return ((Pixels[2] & ~0x0f) << 4) | (Pixels[1] & ~0x0f) | (Pixels[0] >> 4); }
 
-static inline int Scaler555(uint8_t *Pixels) {
-	return ((Pixels[2] & ~0x07) << 7) | ((Pixels[1] & ~0x07) << 2) | (Pixels[0] >> 3);
-}
+static inline int Scaler555(uint8_t* Pixels) { return ((Pixels[2] & ~0x07) << 7) | ((Pixels[1] & ~0x07) << 2) | (Pixels[0] >> 3); }
 
-static inline int Scaler565(uint8_t *Pixels) {
-	return ((Pixels[2] & ~0x07) << 8) | ((Pixels[1] & ~0x03) << 3) | (Pixels[0] >> 3);
-}
+static inline int Scaler565(uint8_t* Pixels) { return ((Pixels[2] & ~0x07) << 8) | ((Pixels[1] & ~0x03) << 3) | (Pixels[0] >> 3); }
 
-static inline int Scaler666(uint8_t *Pixels) {
-	return ((Pixels[2] & ~0x03) << 10) | ((Pixels[1] & ~0x03) << 4) | (Pixels[0] >> 2);
-}
+static inline int Scaler666(uint8_t* Pixels) { return ((Pixels[2] & ~0x03) << 10) | ((Pixels[1] & ~0x03) << 4) | (Pixels[0] >> 2); }
 
-static inline int Scaler888(uint8_t *Pixels) {
-	return (Pixels[2] << 16) | (Pixels[1] << 8) | Pixels[0];
-}
+static inline int Scaler888(uint8_t* Pixels) { return (Pixels[2] << 16) | (Pixels[1] << 8) | Pixels[0]; }
 
-static inline int ScalerGray(uint8_t *Pixels) {
-	return (Pixels[2] * 14 + Pixels[1] * 76 + Pixels[0] * 38) >> 7;
-}
+static inline int ScalerGray(uint8_t* Pixels) { return (Pixels[2] * 14 + Pixels[1] * 76 + Pixels[0] * 38) >> 7; }
 
-static unsigned InHandler(JDEC *Decoder, uint8_t *Buf, unsigned Len) {
-    JpegCtx *Context = (JpegCtx*) Decoder->device;
-    if (Buf) memcpy(Buf, Context->InData +  Context->InPos, Len);
+static unsigned InHandler(JDEC* Decoder, uint8_t* Buf, unsigned Len) {
+    JpegCtx* Context = (JpegCtx*)Decoder->device;
+    if(Buf) memcpy(Buf, Context->InData + Context->InPos, Len);
     Context->InPos += Len;
     return Len;
 }
 
-#define OUTHANDLER(F)										\
-	for (int y = Frame->top; y <= Frame->bottom; y++) {		\
-		for (int x = Frame->left; x <= Frame->right; x++) {	\
-			OutData[Context->Width * y + x] = F(Pixels);	\
-			Pixels += 3;									\
-		}													\
-	}	
-	
-#define OUTHANDLER24(F)													\
-	for (int y = Frame->top; y <= Frame->bottom; y++) {					\
-		uint8_t *p = OutData + (Context->Width * y + Frame->left) * 3;	\
-		for (int c = Frame->right - Frame->left; c-- >= 0;) {			\
-			uint32_t v = F(Pixels);										\
-			*p++ = v; *p++ = v >> 8; *p++ = v >> 16;					\
-			Pixels += 3;												\
-		}																\
-	}		
+#define OUTHANDLER(F)                                                                                                                                \
+    for(int y = Frame->top; y <= Frame->bottom; y++) {                                                                                               \
+        for(int x = Frame->left; x <= Frame->right; x++) {                                                                                           \
+            OutData[Context->Width * y + x] = F(Pixels);                                                                                             \
+            Pixels += 3;                                                                                                                             \
+        }                                                                                                                                            \
+    }
 
-static unsigned OutHandler(JDEC *Decoder, void *Bitmap, JRECT *Frame) {
-	JpegCtx *Context = (JpegCtx*) Decoder->device;
-    uint8_t *Pixels = (uint8_t*) Bitmap;
+#define OUTHANDLER24(F)                                                                                                                              \
+    for(int y = Frame->top; y <= Frame->bottom; y++) {                                                                                               \
+        uint8_t* p = OutData + (Context->Width * y + Frame->left) * 3;                                                                               \
+        for(int c = Frame->right - Frame->left; c-- >= 0;) {                                                                                         \
+            uint32_t v = F(Pixels);                                                                                                                  \
+            *p++ = v;                                                                                                                                \
+            *p++ = v >> 8;                                                                                                                           \
+            *p++ = v >> 16;                                                                                                                          \
+            Pixels += 3;                                                                                                                             \
+        }                                                                                                                                            \
+    }
+
+static unsigned OutHandler(JDEC* Decoder, void* Bitmap, JRECT* Frame) {
+    JpegCtx* Context = (JpegCtx*)Decoder->device;
+    uint8_t* Pixels = (uint8_t*)Bitmap;
+
+    // decoded image is RGB888
+    if(Context->Mode == GDS_RGB888) {
+        uint8_t* OutData = (uint8_t*)Context->OutData;
+        OUTHANDLER24(Scaler888);
+    } else if(Context->Mode == GDS_RGB666) {
+        uint8_t* OutData = (uint8_t*)Context->OutData;
+        OUTHANDLER24(Scaler666);
+    } else if(Context->Mode == GDS_RGB565) {
+        uint16_t* OutData = (uint16_t*)Context->OutData;
+        OUTHANDLER(Scaler565);
+    } else if(Context->Mode == GDS_RGB555) {
+        uint16_t* OutData = (uint16_t*)Context->OutData;
+        OUTHANDLER(Scaler555);
+    } else if(Context->Mode == GDS_RGB444) {
+        uint16_t* OutData = (uint16_t*)Context->OutData;
+        OUTHANDLER(Scaler444);
+    } else if(Context->Mode == GDS_RGB332) {
+        uint8_t* OutData = (uint8_t*)Context->OutData;
+        OUTHANDLER(Scaler332);
+    } else if(Context->Mode <= GDS_GRAYSCALE) {
+        uint8_t* OutData = (uint8_t*)Context->OutData;
+        OUTHANDLER(ScalerGray);
+    }
 
-	// decoded image is RGB888
-	if (Context->Mode == GDS_RGB888) {
-		uint8_t *OutData = (uint8_t*) Context->OutData;		
-		OUTHANDLER24(Scaler888);
-	} else if (Context->Mode == GDS_RGB666) {
-		uint8_t *OutData = (uint8_t*) Context->OutData;		
-		OUTHANDLER24(Scaler666);		
-	} else if (Context->Mode == GDS_RGB565) {
-		uint16_t *OutData = (uint16_t*) Context->OutData;
-		OUTHANDLER(Scaler565);		
-	} else if (Context->Mode == GDS_RGB555) {
-		uint16_t *OutData = (uint16_t*) Context->OutData;
-		OUTHANDLER(Scaler555);				
-	} else if (Context->Mode == GDS_RGB444) {
-		uint16_t *OutData = (uint16_t*) Context->OutData;
-		OUTHANDLER(Scaler444);						
-	} else if (Context->Mode == GDS_RGB332) {
-		uint8_t *OutData = (uint8_t*) Context->OutData;
-		OUTHANDLER(Scaler332);						
-	} else if (Context->Mode <= GDS_GRAYSCALE) { 	 
-		uint8_t *OutData = (uint8_t*) Context->OutData;		
-		OUTHANDLER(ScalerGray);
-	}
-    
     return 1;
 }
 
-// Convert the RGB888 to destination color plane, use DrawPixel and not "fast" 
-// version as X,Y may be beyond screen				
-#define OUTHANDLERDIRECT(F,S)																		\
-	for (int y = Frame->top; y <= Frame->bottom; y++) {												\
-		if (y < Context->YMin) continue;															\
-		for (int x = Frame->left; x <= Frame->right; x++) {											\
-			if (x < Context->XMin) continue;														\
-			DrawPixel( Context->Device, x + Context->XOfs, y + Context->YOfs, F(Pixels) >> S);	\
-			Pixels += 3;																			\
-		}																							\
-	}
-	
-static unsigned OutHandlerDirect(JDEC *Decoder, void *Bitmap, JRECT *Frame) {
-	JpegCtx *Context = (JpegCtx*) Decoder->device;
-    uint8_t *Pixels = (uint8_t*) Bitmap;
-	int Shift = 8 - Context->Depth;
-	
-	// decoded image is RGB888, shift only make sense for grayscale
-	if (Context->Mode == GDS_RGB888) {
-		OUTHANDLERDIRECT(Scaler888, 0);
-	} else if (Context->Mode == GDS_RGB666) {
-		OUTHANDLERDIRECT(Scaler666, 0);		
-	} else if (Context->Mode == GDS_RGB565) {
-		OUTHANDLERDIRECT(Scaler565, 0);		
-	} else if (Context->Mode == GDS_RGB555) {
-		OUTHANDLERDIRECT(Scaler555, 0);				
-	} else if (Context->Mode == GDS_RGB444) {
-		OUTHANDLERDIRECT(Scaler444, 0);						
-	} else if (Context->Mode == GDS_RGB332) {
-		OUTHANDLERDIRECT(Scaler332, 0);						
-	} else if (Context->Mode <= GDS_GRAYSCALE) { 	 
-		OUTHANDLERDIRECT(ScalerGray, Shift);
-	}
-    
+// Convert the RGB888 to destination color plane, use DrawPixel and not "fast"
+// version as X,Y may be beyond screen
+#define OUTHANDLERDIRECT(F, S)                                                                                                                       \
+    for(int y = Frame->top; y <= Frame->bottom; y++) {                                                                                               \
+        if(y < Context->YMin) continue;                                                                                                              \
+        for(int x = Frame->left; x <= Frame->right; x++) {                                                                                           \
+            if(x < Context->XMin) continue;                                                                                                          \
+            DrawPixel(Context->Device, x + Context->XOfs, y + Context->YOfs, F(Pixels) >> S);                                                        \
+            Pixels += 3;                                                                                                                             \
+        }                                                                                                                                            \
+    }
+
+static unsigned OutHandlerDirect(JDEC* Decoder, void* Bitmap, JRECT* Frame) {
+    JpegCtx* Context = (JpegCtx*)Decoder->device;
+    uint8_t* Pixels = (uint8_t*)Bitmap;
+    int Shift = 8 - Context->Depth;
+
+    // decoded image is RGB888, shift only make sense for grayscale
+    if(Context->Mode == GDS_RGB888) {
+        OUTHANDLERDIRECT(Scaler888, 0);
+    } else if(Context->Mode == GDS_RGB666) {
+        OUTHANDLERDIRECT(Scaler666, 0);
+    } else if(Context->Mode == GDS_RGB565) {
+        OUTHANDLERDIRECT(Scaler565, 0);
+    } else if(Context->Mode == GDS_RGB555) {
+        OUTHANDLERDIRECT(Scaler555, 0);
+    } else if(Context->Mode == GDS_RGB444) {
+        OUTHANDLERDIRECT(Scaler444, 0);
+    } else if(Context->Mode == GDS_RGB332) {
+        OUTHANDLERDIRECT(Scaler332, 0);
+    } else if(Context->Mode <= GDS_GRAYSCALE) {
+        OUTHANDLERDIRECT(ScalerGray, Shift);
+    }
+
     return 1;
 }
 
 //Decode the embedded image into pixel lines that can be used with the rest of the logic.
-static void* DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale, bool SizeOnly, int RGB_Mode) {
+static void* DecodeJPEG(uint8_t* Source, int* Width, int* Height, float Scale, bool SizeOnly, int RGB_Mode) {
     JDEC Decoder;
     JpegCtx Context;
-	char *Scratch = calloc(SCRATCH_SIZE, 1);
-	
-    if (!Scratch) {
+    char* Scratch = malloc(SCRATCH_SIZE);
+
+    if(!Scratch) {
         ESP_LOGE(TAG, "Cannot allocate workspace");
         return NULL;
     }
 
-	Context.OutData = NULL;
+    Context.OutData = NULL;
     Context.InData = Source;
     Context.InPos = 0;
-	        
+
     //Prepare and decode the jpeg.
-    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*) &Context);
-	if (Width) *Width = Decoder.width;
-	if (Height) *Height = Decoder.height;
-	Decoder.scale = Scale;
+    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*)&Context);
+    if(Width) *Width = Decoder.width;
+    if(Height) *Height = Decoder.height;
+    Decoder.scale = Scale;
 
-    if (Res == JDR_OK && !SizeOnly) {
-		if (RGB_Mode <= GDS_RGB332) Context.OutData = malloc(Decoder.width * Decoder.height);
-		else if (RGB_Mode < GDS_RGB666) Context.OutData = malloc(Decoder.width * Decoder.height * 2);
-		else if (RGB_Mode <= GDS_RGB888) Context.OutData = malloc(Decoder.width * Decoder.height * 3);
-		
-		// find the scaling factor
-		uint8_t N = 0, ScaleInt =  ceil(1.0 / Scale);
-		ScaleInt--; ScaleInt |= ScaleInt >> 1; ScaleInt |= ScaleInt >> 2; ScaleInt++;
-		while (ScaleInt >>= 1) N++;
-		if (N > 3) {
-			ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
-			N = 3;
-		}	
-		
-		// ready to decode		
-		if (Context.OutData) {
-			Context.Width = Decoder.width / (1 << N);
-			Context.Height = Decoder.height / (1 << N);
-			Context.Mode = RGB_Mode;
-			if (Width) *Width = Context.Width;
-			if (Height) *Height = Context.Height;
-			Res = jd_decomp(&Decoder, OutHandler, N);
-			if (Res != JDR_OK) {
-				ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res);
-			}	
-		} else {
-			ESP_LOGE(TAG, "Can't allocate bitmap %dx%d or invalid mode %d", Decoder.width, Decoder.height, RGB_Mode);			
-		}	
-	} else if (!SizeOnly) {
+    if(Res == JDR_OK && !SizeOnly) {
+        if(RGB_Mode <= GDS_RGB332)
+            Context.OutData = malloc(Decoder.width * Decoder.height);
+        else if(RGB_Mode < GDS_RGB666)
+            Context.OutData = malloc(Decoder.width * Decoder.height * 2);
+        else if(RGB_Mode <= GDS_RGB888)
+            Context.OutData = malloc(Decoder.width * Decoder.height * 3);
+
+        // find the scaling factor
+        uint8_t N = 0, ScaleInt = ceil(1.0 / Scale);
+        ScaleInt--;
+        ScaleInt |= ScaleInt >> 1;
+        ScaleInt |= ScaleInt >> 2;
+        ScaleInt++;
+        while(ScaleInt >>= 1) N++;
+        if(N > 3) {
+            ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
+            N = 3;
+        }
+
+        // ready to decode
+        if(Context.OutData) {
+            Context.Width = Decoder.width / (1 << N);
+            Context.Height = Decoder.height / (1 << N);
+            Context.Mode = RGB_Mode;
+            if(Width) *Width = Context.Width;
+            if(Height) *Height = Context.Height;
+            Res = jd_decomp(&Decoder, OutHandler, N);
+            if(Res != JDR_OK) { ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res); }
+        } else {
+            ESP_LOGE(TAG, "Can't allocate bitmap %dx%d or invalid mode %d", Decoder.width, Decoder.height, RGB_Mode);
+        }
+    } else if(!SizeOnly) {
         ESP_LOGE(TAG, "Image decoder: jd_prepare failed (%d)", Res);
-    }    
+    }
 
-	// free scratch area
-    if (Scratch) free(Scratch);
+    // free scratch area
+    if(Scratch) free(Scratch);
     return Context.OutData;
 }
 
-void* GDS_DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale, int RGB_Mode) {
-	return DecodeJPEG(Source, Width, Height, Scale, false, RGB_Mode);
-}	
+void* GDS_DecodeJPEG(uint8_t* Source, int* Width, int* Height, float Scale, int RGB_Mode) {
+    return DecodeJPEG(Source, Width, Height, Scale, false, RGB_Mode);
+}
 
-void GDS_GetJPEGSize(uint8_t *Source, int *Width, int *Height) {
-	DecodeJPEG(Source, Width, Height, 1, true, -1);
-}	
+void GDS_GetJPEGSize(uint8_t* Source, int* Width, int* Height) { DecodeJPEG(Source, Width, Height, 1, true, -1); }
 
 /****************************************************************************************
  * RGB conversion (24 bits: RRRRRRRRGGGGGGGGBBBBBBBB and 16 bits 565: RRRRRGGGGGGBBBBB = B31..B0)
@@ -235,146 +229,144 @@ void GDS_GetJPEGSize(uint8_t *Source, int *Width, int *Height) {
  * monochrome (0.2125 * color.r) + (0.7154 * color.g) + (0.0721 * color.b)
  * grayscale (0.3 * R) + (0.59 * G) + (0.11 * B) )
  */
- 
-static inline int ToGray888(uint8_t **Pixel) {
-	uint32_t v = *(*Pixel)++; v |= *(*Pixel)++ << 8; v |= *(*Pixel)++ << 16; 
-	return (((v & 0xff) * 14) + ((v >> 8) & 0xff) * 76 + ((v >> 16) * 38) + 1) >> 7;
-} 
- 
-static inline int ToGray666(uint8_t **Pixel) {
-	uint32_t v = *(*Pixel)++; v |= *(*Pixel)++ << 8; v |= *(*Pixel)++ << 16; 
-	return (((v & 0x3f) * 14) + ((v >> 6) & 0x3f) * 76 + ((v >> 12) * 38) + 1) >> 7;
+
+static inline int ToGray888(uint8_t** Pixel) {
+    uint32_t v = *(*Pixel)++;
+    v |= *(*Pixel)++ << 8;
+    v |= *(*Pixel)++ << 16;
+    return (((v & 0xff) * 14) + ((v >> 8) & 0xff) * 76 + ((v >> 16) * 38) + 1) >> 7;
 }
 
-static inline int ToGray565(uint16_t **Pixel) {
-	uint16_t v = *(*Pixel)++; 
-	return ((((v & 0x1f) * 14) << 1) + ((v >> 5) & 0x3f) * 76 + (((v >> 11) * 38) << 1) + 1) >> 7;
+static inline int ToGray666(uint8_t** Pixel) {
+    uint32_t v = *(*Pixel)++;
+    v |= *(*Pixel)++ << 8;
+    v |= *(*Pixel)++ << 16;
+    return (((v & 0x3f) * 14) + ((v >> 6) & 0x3f) * 76 + ((v >> 12) * 38) + 1) >> 7;
 }
 
-static inline int ToGray555(uint16_t **Pixel) {
-	uint16_t v = *(*Pixel)++; 
-	return ((v & 0x1f) * 14 + ((v >> 5) & 0x1f) * 76 + (v >> 10) * 38) >> 7;
+static inline int ToGray565(uint16_t** Pixel) {
+    uint16_t v = *(*Pixel)++;
+    return ((((v & 0x1f) * 14) << 1) + ((v >> 5) & 0x3f) * 76 + (((v >> 11) * 38) << 1) + 1) >> 7;
 }
 
-static inline int ToGray444(uint16_t **Pixel) {
-	uint16_t v = *(*Pixel)++; 
-	return ((v & 0x0f) * 14 + ((v >> 4) & 0x0f) * 76 + (v >> 8) * 38) >> 7;
+static inline int ToGray555(uint16_t** Pixel) {
+    uint16_t v = *(*Pixel)++;
+    return ((v & 0x1f) * 14 + ((v >> 5) & 0x1f) * 76 + (v >> 10) * 38) >> 7;
 }
 
-static inline int ToGray332(uint8_t **Pixel) {
-	uint8_t v = *(*Pixel)++; 
-	return ((((v & 0x3) * 14) << 1) + ((v >> 2) & 0x7) * 76 + (v >> 5) * 38 + 1) >> 7;
+static inline int ToGray444(uint16_t** Pixel) {
+    uint16_t v = *(*Pixel)++;
+    return ((v & 0x0f) * 14 + ((v >> 4) & 0x0f) * 76 + (v >> 8) * 38) >> 7;
 }
 
-static inline int ToSelf(uint8_t **Pixel) {
-	return *(*Pixel)++; 
+static inline int ToGray332(uint8_t** Pixel) {
+    uint8_t v = *(*Pixel)++;
+    return ((((v & 0x3) * 14) << 1) + ((v >> 2) & 0x7) * 76 + (v >> 5) * 38 + 1) >> 7;
 }
-	
-#define DRAW_GRAYRGB(S,F)													\
-	if (Scale > 0) {														\
-		for (int r = 0; r < Height; r++) {									\
-			for (int c = 0; c < Width; c++) {								\
-				DrawPixel( Device, c + x, r + y, F(S) >> Scale);		\
-			}																\
-		}																	\
-	} else {																\
-		for (int r = 0; r < Height; r++) {									\
-			for (int c = 0; c < Width; c++) {								\
-				DrawPixel( Device, c + x, r + y, F(S) << -Scale);	\
-			}																\
-		}																	\
-	}									
-	
-#define DRAW_RGB(T)										\
-	T *S = (T*) Image;									\
-	for (int r = 0; r < Height; r++) {					\
-		for (int c = 0; c < Width; c++) {				\
-			DrawPixel(Device, c + x, r + y, *S++);	\
-		}												\
-	}																	
-	
-#define DRAW_RGB24													\
-	uint8_t *S = (uint8_t*) Image;									\
-	for (int r = 0; r < Height; r++) {								\
-		for (int c = 0; c < Width; c++) {							\
-			uint32_t v = *S++; v |= *S++ << 8; v |= *S++ << 16;		\
-			DrawPixel(Device, c + x, r + y, v);					\
-		}															\
-	}	
+
+static inline int ToSelf(uint8_t** Pixel) { return *(*Pixel)++; }
+
+#define DRAW_GRAYRGB(S, F)                                                                                                                           \
+    if(Scale > 0) {                                                                                                                                  \
+        for(int r = 0; r < Height; r++) {                                                                                                            \
+            for(int c = 0; c < Width; c++) { DrawPixel(Device, c + x, r + y, F(S) >> Scale); }                                                       \
+        }                                                                                                                                            \
+    } else {                                                                                                                                         \
+        for(int r = 0; r < Height; r++) {                                                                                                            \
+            for(int c = 0; c < Width; c++) { DrawPixel(Device, c + x, r + y, F(S) << -Scale); }                                                      \
+        }                                                                                                                                            \
+    }
+
+#define DRAW_RGB(T)                                                                                                                                  \
+    T* S = (T*)Image;                                                                                                                                \
+    for(int r = 0; r < Height; r++) {                                                                                                                \
+        for(int c = 0; c < Width; c++) { DrawPixel(Device, c + x, r + y, *S++); }                                                                    \
+    }
+
+#define DRAW_RGB24                                                                                                                                   \
+    uint8_t* S = (uint8_t*)Image;                                                                                                                    \
+    for(int r = 0; r < Height; r++) {                                                                                                                \
+        for(int c = 0; c < Width; c++) {                                                                                                             \
+            uint32_t v = *S++;                                                                                                                       \
+            v |= *S++ << 8;                                                                                                                          \
+            v |= *S++ << 16;                                                                                                                         \
+            DrawPixel(Device, c + x, r + y, v);                                                                                                      \
+        }                                                                                                                                            \
+    }
 
 /****************************************************************************************
  *  Decode the embedded image into pixel lines that can be used with the rest of the logic.
  */
-void GDS_DrawRGB( struct GDS_Device* Device, uint8_t *Image, int x, int y, int Width, int Height, int RGB_Mode ) {
+void GDS_DrawRGB(struct GDS_Device* Device, uint8_t* Image, int x, int y, int Width, int Height, int RGB_Mode) {
 
-	// don't do anything if driver supplies a draw function
-	if (Device->DrawRGB) {
-		Device->DrawRGB( Device, Image, x, y, Width, Height, RGB_Mode );
-		Device->Dirty = true;	
-		return;
-	}
-	
-	// RGB type displays
-	if (Device->Mode > GDS_GRAYSCALE) {
-		// image must match the display mode!
-		if (Device->Mode != RGB_Mode) {
-			ESP_LOGE(TAG, "non-matching display & image mode %u %u", Device->Mode, RGB_Mode);
-			return;
-		}	
-		
-		if (RGB_Mode == GDS_RGB332) {
-			DRAW_RGB(uint8_t);
-		} else if (RGB_Mode < GDS_RGB666) {
-			DRAW_RGB(uint16_t);
-		} else {
-			DRAW_RGB24;
-		}	
-		
-		Device->Dirty = true;
-		return;
-	}
-	
-	// set the right scaler when displaying grayscale
-	if (RGB_Mode <= GDS_GRAYSCALE) {
-		int Scale = 8 - Device->Depth;
-		DRAW_GRAYRGB(&Image,ToSelf);
-	} else if (RGB_Mode == GDS_RGB332) {
-		int Scale = 3 - Device->Depth;		
-		DRAW_GRAYRGB(&Image,ToGray332);
-	} else if (RGB_Mode < GDS_RGB666)	{
-		if (RGB_Mode == GDS_RGB565) {
-			int Scale = 6 - Device->Depth;
-			DRAW_GRAYRGB((uint16_t**)&Image,ToGray565);
-		} else if (RGB_Mode == GDS_RGB555) {
-			int Scale = 5 - Device->Depth;
-			DRAW_GRAYRGB((uint16_t**)&Image,ToGray555);
-		} else if (RGB_Mode == GDS_RGB444) {
-			int Scale = 4 - Device->Depth; 
-			DRAW_GRAYRGB((uint16_t**)&Image,ToGray444)
-		}	
-	} else {
-		if (RGB_Mode == GDS_RGB666) {
-			int Scale = 6 - Device->Depth;
-			DRAW_GRAYRGB(&Image,ToGray666);
-		} else if (RGB_Mode == GDS_RGB888) {
-			int Scale = 8 - Device->Depth;
-			DRAW_GRAYRGB(&Image,ToGray888);
-		}	
-	} 
-	
-	Device->Dirty = true;	
+    // don't do anything if driver supplies a draw function
+    if(Device->DrawRGB) {
+        Device->DrawRGB(Device, Image, x, y, Width, Height, RGB_Mode);
+        Device->Dirty = true;
+        return;
+    }
+
+    // RGB type displays
+    if(Device->Mode > GDS_GRAYSCALE) {
+        // image must match the display mode!
+        if(Device->Mode != RGB_Mode) {
+            ESP_LOGE(TAG, "non-matching display & image mode %u %u", Device->Mode, RGB_Mode);
+            return;
+        }
+
+        if(RGB_Mode == GDS_RGB332) {
+            DRAW_RGB(uint8_t);
+        } else if(RGB_Mode < GDS_RGB666) {
+            DRAW_RGB(uint16_t);
+        } else {
+            DRAW_RGB24;
+        }
+
+        Device->Dirty = true;
+        return;
+    }
+
+    // set the right scaler when displaying grayscale
+    if(RGB_Mode <= GDS_GRAYSCALE) {
+        int Scale = 8 - Device->Depth;
+        DRAW_GRAYRGB(&Image, ToSelf);
+    } else if(RGB_Mode == GDS_RGB332) {
+        int Scale = 3 - Device->Depth;
+        DRAW_GRAYRGB(&Image, ToGray332);
+    } else if(RGB_Mode < GDS_RGB666) {
+        if(RGB_Mode == GDS_RGB565) {
+            int Scale = 6 - Device->Depth;
+            DRAW_GRAYRGB((uint16_t**)&Image, ToGray565);
+        } else if(RGB_Mode == GDS_RGB555) {
+            int Scale = 5 - Device->Depth;
+            DRAW_GRAYRGB((uint16_t**)&Image, ToGray555);
+        } else if(RGB_Mode == GDS_RGB444) {
+            int Scale = 4 - Device->Depth;
+            DRAW_GRAYRGB((uint16_t**)&Image, ToGray444)
+        }
+    } else {
+        if(RGB_Mode == GDS_RGB666) {
+            int Scale = 6 - Device->Depth;
+            DRAW_GRAYRGB(&Image, ToGray666);
+        } else if(RGB_Mode == GDS_RGB888) {
+            int Scale = 8 - Device->Depth;
+            DRAW_GRAYRGB(&Image, ToGray888);
+        }
+    }
+
+    Device->Dirty = true;
 }
 
 /****************************************************************************************
  *  Decode the embedded image into pixel lines that can be used with the rest of the logic.
  */
-bool GDS_DrawJPEG(struct GDS_Device* Device, uint8_t *Source, int x, int y, int Fit) {
+bool GDS_DrawJPEG(struct GDS_Device* Device, uint8_t* Source, int x, int y, int Fit) {
     JDEC Decoder;
     JpegCtx Context;
-	bool Ret = false;
-	char *Scratch = calloc(SCRATCH_SIZE, 1);
-	
-    if (!Scratch) {
+    bool Ret = false;
+    char* Scratch = malloc(SCRATCH_SIZE);
+
+    if(!Scratch) {
         ESP_LOGE(TAG, "Cannot allocate workspace");
         return NULL;
     }
@@ -382,57 +374,63 @@ bool GDS_DrawJPEG(struct GDS_Device* Device, uint8_t *Source, int x, int y, int
     // Populate fields of the JpegCtx struct.
     Context.InData = Source;
     Context.InPos = 0;
-	Context.XOfs = x;
-	Context.YOfs = y;
-	Context.Device = Device;
-	Context.Depth = Device->Depth;
-        
+    Context.XOfs = x;
+    Context.YOfs = y;
+    Context.Device = Device;
+    Context.Depth = Device->Depth;
+
     //Prepare and decode the jpeg.
-    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*) &Context);
-	Context.Width = Decoder.width;
-	Context.Height = Decoder.height;
-	
-    if (Res == JDR_OK) {
-		uint8_t N = 0;
-		
-		// do we need to fit the image
-		if (Fit & GDS_IMAGE_FIT) {
-			float XRatio = (Device->Width - x) / (float) Decoder.width, YRatio = (Device->Height - y) / (float) Decoder.height;
-			uint8_t Ratio = XRatio < YRatio ? ceil(1/XRatio) : ceil(1/YRatio);
-			Ratio--; Ratio |= Ratio >> 1; Ratio |= Ratio >> 2; Ratio++;
-			while (Ratio >>= 1) N++;
-			if (N > 3) {
-				ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
-				N = 3;
-			}	
-			Context.Width /= 1 << N;
-			Context.Height /= 1 << N;
-		} 
-		
-		// then place it
-		if (Fit & GDS_IMAGE_CENTER_X) Context.XOfs = (Device->Width + x - Context.Width) / 2;
-		else if (Fit & GDS_IMAGE_RIGHT) Context.XOfs = Device->Width - Context.Width;
-		if (Fit & GDS_IMAGE_CENTER_Y) Context.YOfs = (Device->Height + y - Context.Height) / 2;
-		else if (Fit & GDS_IMAGE_BOTTOM) Context.YOfs = Device->Height - Context.Height;
+    int Res = jd_prepare(&Decoder, InHandler, Scratch, SCRATCH_SIZE, (void*)&Context);
+    Context.Width = Decoder.width;
+    Context.Height = Decoder.height;
 
-		Context.XMin = x - Context.XOfs;
-		Context.YMin = y - Context.YOfs;
-		Context.Mode = Device->Mode;
-					
-		// do decompress & draw
-		Res = jd_decomp(&Decoder, OutHandlerDirect, N);
-		if (Res == JDR_OK) {
-			Device->Dirty = true;
-			Ret = true;
-		} else {	
-			ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res);
-		}	
-	} else {	
+    if(Res == JDR_OK) {
+        uint8_t N = 0;
+
+        // do we need to fit the image
+        if(Fit & GDS_IMAGE_FIT) {
+            float XRatio = (Device->Width - x) / (float)Decoder.width, YRatio = (Device->Height - y) / (float)Decoder.height;
+            uint8_t Ratio = XRatio < YRatio ? ceil(1 / XRatio) : ceil(1 / YRatio);
+            Ratio--;
+            Ratio |= Ratio >> 1;
+            Ratio |= Ratio >> 2;
+            Ratio++;
+            while(Ratio >>= 1) N++;
+            if(N > 3) {
+                ESP_LOGW(TAG, "Image will not fit %dx%d", Decoder.width, Decoder.height);
+                N = 3;
+            }
+            Context.Width /= 1 << N;
+            Context.Height /= 1 << N;
+        }
+
+        // then place it
+        if(Fit & GDS_IMAGE_CENTER_X)
+            Context.XOfs = (Device->Width + x - Context.Width) / 2;
+        else if(Fit & GDS_IMAGE_RIGHT)
+            Context.XOfs = Device->Width - Context.Width;
+        if(Fit & GDS_IMAGE_CENTER_Y)
+            Context.YOfs = (Device->Height + y - Context.Height) / 2;
+        else if(Fit & GDS_IMAGE_BOTTOM)
+            Context.YOfs = Device->Height - Context.Height;
+
+        Context.XMin = x - Context.XOfs;
+        Context.YMin = y - Context.YOfs;
+        Context.Mode = Device->Mode;
+
+        // do decompress & draw
+        Res = jd_decomp(&Decoder, OutHandlerDirect, N);
+        if(Res == JDR_OK) {
+            Device->Dirty = true;
+            Ret = true;
+        } else {
+            ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", Res);
+        }
+    } else {
         ESP_LOGE(TAG, "Image decoder: jd_prepare failed (%d)", Res);
-    }    
-      
-	// free scratch area
-    if (Scratch) free(Scratch);
-	return Ret;
-}
+    }
 
+    // free scratch area
+    if(Scratch) free(Scratch);
+    return Ret;
+}

components/display/core/gds_image.h

@@ -5,7 +5,7 @@
  * https://opensource.org/licenses/MIT
  * 
  */
- 
+
 #pragma once
 
 #include <stdint.h>
@@ -16,17 +16,17 @@
 struct GDS_Device;
 
 // Fit options for GDS_DrawJPEG
-#define GDS_IMAGE_LEFT		0x00
-#define GDS_IMAGE_CENTER_X	0x01
-#define GDS_IMAGE_RIGHT		0x04
-#define GDS_IMAGE_TOP		0x00
-#define GDS_IMAGE_BOTTOM	0x08
-#define GDS_IMAGE_CENTER_Y	0x02
-#define GDS_IMAGE_CENTER	(GDS_IMAGE_CENTER_X | GDS_IMAGE_CENTER_Y)
-#define GDS_IMAGE_FIT		0x10	// re-scale by a factor of 2^N (up to 3)
+#define GDS_IMAGE_LEFT 0x00
+#define GDS_IMAGE_CENTER_X 0x01
+#define GDS_IMAGE_RIGHT 0x04
+#define GDS_IMAGE_TOP 0x00
+#define GDS_IMAGE_BOTTOM 0x08
+#define GDS_IMAGE_CENTER_Y 0x02
+#define GDS_IMAGE_CENTER (GDS_IMAGE_CENTER_X | GDS_IMAGE_CENTER_Y)
+#define GDS_IMAGE_FIT 0x10 // re-scale by a factor of 2^N (up to 3)
 
 // Width and Height can be NULL if you already know them (actual scaling is closest ^2)
-void*	 	GDS_DecodeJPEG(uint8_t *Source, int *Width, int *Height, float Scale, int RGB_Mode);	// can be 8, 16 or 24 bits per pixel in return
-void	 	GDS_GetJPEGSize(uint8_t *Source, int *Width, int *Height);
-bool 		GDS_DrawJPEG( struct GDS_Device* Device, uint8_t *Source, int x, int y, int Fit);	
-void 		GDS_DrawRGB( struct GDS_Device* Device, uint8_t *Image, int x, int y, int Width, int Height, int RGB_Mode );
+void* GDS_DecodeJPEG(uint8_t* Source, int* Width, int* Height, float Scale, int RGB_Mode); // can be 8, 16 or 24 bits per pixel in return
+void GDS_GetJPEGSize(uint8_t* Source, int* Width, int* Height);
+bool GDS_DrawJPEG(struct GDS_Device* Device, uint8_t* Source, int x, int y, int Fit);
+void GDS_DrawRGB(struct GDS_Device* Device, uint8_t* Image, int x, int y, int Width, int Height, int RGB_Mode);

components/display/core/gds_private.h

@@ -5,7 +5,7 @@
  * https://opensource.org/licenses/MIT
  * 
  */
- 
+
 #ifndef _GDS_PRIVATE_H_
 #define _GDS_PRIVATE_H_
 
@@ -15,44 +15,43 @@
 #include "gds.h"
 #include "gds_err.h"
 
-#define GDS_ALLOC_NONE		0x80
-#define GDS_ALLOC_IRAM		0x01
-#define GDS_ALLOC_IRAM_SPI	0x02
+#define GDS_ALLOC_NONE 0x80
+#define GDS_ALLOC_IRAM 0x01
+#define GDS_ALLOC_IRAM_SPI 0x02
 
 #define GDS_CLIPDEBUG_NONE 0
 #define GDS_CLIPDEBUG_WARNING 1
 #define GDS_CLIPDEBUG_ERROR 2
 
 #if CONFIG_GDS_CLIPDEBUG == GDS_CLIPDEBUG_NONE
-    /*
+/*
      * Clip silently with no console output.
      */
-    #define ClipDebug( x, y )
+#define ClipDebug(x, y)
 #elif CONFIG_GDS_CLIPDEBUG == GDS_CLIPDEBUG_WARNING
-    /*
+/*
      * Log clipping to the console as a warning.
      */
-    #define ClipDebug( x, y ) { \
-        ESP_LOGW( __FUNCTION__, "Line %d: Pixel at %d, %d CLIPPED", __LINE__, x, y ); \
-    }
+#define ClipDebug(x, y)                                                                                                                              \
+    { ESP_LOGW(__FUNCTION__, "Line %d: Pixel at %d, %d CLIPPED", __LINE__, x, y); }
 #elif CONFIG_GDS_CLIPDEBUG == GDS_CLIPDEBUG_ERROR
-    /*
+/*
      * Log clipping as an error to the console.
      * Also invokes an abort with stack trace.
      */
-    #define ClipDebug( x, y ) { \
-        ESP_LOGE( __FUNCTION__, "Line %d: Pixel at %d, %d CLIPPED, ABORT", __LINE__, x, y ); \
-        abort( ); \
+#define ClipDebug(x, y)                                                                                                                              \
+    {                                                                                                                                                \
+        ESP_LOGE(__FUNCTION__, "Line %d: Pixel at %d, %d CLIPPED, ABORT", __LINE__, x, y);                                                           \
+        abort();                                                                                                                                     \
     }
 #endif
 
+#define GDS_ALWAYS_INLINE __attribute__((always_inline))
 
-#define GDS_ALWAYS_INLINE __attribute__( ( always_inline ) )
+#define MAX_LINES 8
 
-#define MAX_LINES	8
-
-#if ! defined BIT
-#define BIT( n ) ( 1 << ( n ) )
+#if !defined BIT
+#define BIT(n) (1 << (n))
 #endif
 
 struct GDS_Device;
@@ -61,100 +60,95 @@ struct GDS_FontDef;
 /*
  * These can optionally return a succeed/fail but are as of yet unused in the driver.
  */
-typedef bool ( *WriteCommandProc ) ( struct GDS_Device* Device, uint8_t Command );
-typedef bool ( *WriteDataProc ) ( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength );
+typedef bool (*WriteCommandProc)(struct GDS_Device* Device, uint8_t Command);
+typedef bool (*WriteDataProc)(struct GDS_Device* Device, const uint8_t* Data, size_t DataLength);
 
 struct spi_device_t;
 typedef struct spi_device_t* spi_device_handle_t;
 
-#define GDS_IF_SPI	0
-#define GDS_IF_I2C	1
+#define GDS_IF_SPI 0
+#define GDS_IF_I2C 1
 
 struct GDS_Device {
-	uint8_t IF;
-	int8_t RSTPin;
-	struct {
-		int8_t Pin, Channel;
-		int PWM;	
-	} Backlight;
-	union {
-		// I2C Specific
-		struct {
-			uint8_t Address;
-		};
-		// SPI specific
-		struct {
-			spi_device_handle_t SPIHandle;
-			int8_t CSPin;
-		};
-	};	
-	
-    // cooked text mode
-	struct {
-		int16_t Y, Space;
-		const struct GDS_FontDef* Font;
-	} Lines[MAX_LINES];
-	
-	uint16_t Width;
-    uint16_t Height;
-	uint8_t Depth, Mode;
-	
-	uint8_t	Alloc;	
-	uint8_t* Framebuffer;
-    uint32_t FramebufferSize;
-	bool Dirty;
+    uint8_t IF;
+    int8_t RSTPin;
+    struct {
+        int8_t Pin, Channel;
+        int PWM;
+    } Backlight;
+    union {
+        // I2C Specific
+        struct {
+            uint8_t Address;
+        };
+        // SPI specific
+        struct {
+            spi_device_handle_t SPIHandle;
+            int8_t CSPin;
+        };
+    };
 
-	// default fonts when using direct draw	
-	const struct GDS_FontDef* Font;
+    // cooked text mode
+    struct {
+        int16_t Y, Space;
+        const struct GDS_FontDef* Font;
+    } Lines[MAX_LINES];
+
+    uint16_t Width, TextWidth;
+    uint16_t Height;
+    uint8_t Depth, Mode;
+
+    uint8_t Alloc;
+    uint8_t* Framebuffer;
+    uint32_t FramebufferSize;
+    bool Dirty;
+
+    // default fonts when using direct draw
+    const struct GDS_FontDef* Font;
     bool FontForceProportional;
     bool FontForceMonospace;
 
-	// various driver-specific method
-	// must always provide 
-	bool (*Init)( struct GDS_Device* Device);
-	void (*Update)( struct GDS_Device* Device );
-	// may provide if supported
-	void (*SetContrast)( struct GDS_Device* Device, uint8_t Contrast );
-	void (*DisplayOn)( struct GDS_Device* Device );
-	void (*DisplayOff)( struct GDS_Device* Device );
-	void (*SetLayout)( struct GDS_Device* Device, bool HFlip, bool VFlip, bool Rotate );
-	// must provide for depth other than 1 (vertical) and 4 (may provide for optimization)
-	void (*DrawPixelFast)( struct GDS_Device* Device, int X, int Y, int Color );
-	void (*DrawBitmapCBR)(struct GDS_Device* Device, uint8_t *Data, int Width, int Height, int Color );
-	// may provide for optimization
-	void (*DrawRGB)( struct GDS_Device* Device, uint8_t *Image,int x, int y, int Width, int Height, int RGB_Mode );
-	void (*ClearWindow)( struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color );
-		    
-	// interface-specific methods	
+    // various driver-specific method
+    // must always provide
+    bool (*Init)(struct GDS_Device* Device);
+    void (*Update)(struct GDS_Device* Device);
+    // may provide if supported
+    void (*SetContrast)(struct GDS_Device* Device, uint8_t Contrast);
+    void (*DisplayOn)(struct GDS_Device* Device);
+    void (*DisplayOff)(struct GDS_Device* Device);
+    void (*SetLayout)(struct GDS_Device* Device, struct GDS_Layout* Layout);
+    // must provide for depth other than 1 (vertical) and 4 (may provide for optimization)
+    void (*DrawPixelFast)(struct GDS_Device* Device, int X, int Y, int Color);
+    void (*DrawBitmapCBR)(struct GDS_Device* Device, uint8_t* Data, int Width, int Height, int Color);
+    // may provide for optimization
+    void (*DrawRGB)(struct GDS_Device* Device, uint8_t* Image, int x, int y, int Width, int Height, int RGB_Mode);
+    void (*ClearWindow)(struct GDS_Device* Device, int x1, int y1, int x2, int y2, int Color);
+    // may provide for tweaking
+    void (*SPIParams)(int Speed, uint8_t* mode, uint16_t* CS_pre, uint8_t* CS_post);
+
+    // interface-specific methods
     WriteCommandProc WriteCommand;
     WriteDataProc WriteData;
 
-	// 32 bytes for whatever the driver wants (should be aligned as it's 32 bits)	
-	uint32_t Private[8];
+    // 32 bytes for whatever the driver wants (should be aligned as it's 32 bits)
+    uint32_t Private[8];
 };
 
-bool GDS_Reset( struct GDS_Device* Device );
-bool GDS_Init( struct GDS_Device* Device );
+bool GDS_Reset(struct GDS_Device* Device);
+bool GDS_Init(struct GDS_Device* Device);
 
-static inline bool IsPixelVisible( struct GDS_Device* Device, int x, int y )  {
-    bool Result = (
-        ( x >= 0 ) &&
-        ( x < Device->Width ) &&
-        ( y >= 0 ) &&
-        ( y < Device->Height )
-    ) ? true : false;
+static inline bool IsPixelVisible(struct GDS_Device* Device, int x, int y) {
+    bool Result = ((x >= 0) && (x < Device->Width) && (y >= 0) && (y < Device->Height)) ? true : false;
 
 #if CONFIG_GDS_CLIPDEBUG > 0
-    if ( Result == false ) {
-        ClipDebug( x, y );
-    }
+    if(Result == false) { ClipDebug(x, y); }
 #endif
 
     return Result;
 }
 
-static inline void DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-    uint32_t YBit = ( Y & 0x07 );
+static inline void DrawPixel1Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint32_t YBit = (Y & 0x07);
     uint8_t* FBOffset;
 
     /* 
@@ -163,60 +157,67 @@ static inline void DrawPixel1Fast( struct GDS_Device* Device, int X, int Y, int
      * Dividing Y by 8 gives us which row the pixel is in but not
      * the bit position.
      */
-    Y>>= 3;
+    Y >>= 3;
 
-    FBOffset = Device->Framebuffer + ( ( Y * Device->Width ) + X );
+    FBOffset = Device->Framebuffer + ((Y * Device->Width) + X);
 
-    if ( Color == GDS_COLOR_XOR ) {
-        *FBOffset ^= BIT( YBit );
+    if(Color == GDS_COLOR_XOR) {
+        *FBOffset ^= BIT(YBit);
     } else {
-        *FBOffset = ( Color == GDS_COLOR_BLACK ) ? *FBOffset & ~BIT( YBit ) : *FBOffset | BIT( YBit );
+        *FBOffset = (Color == GDS_COLOR_BLACK) ? *FBOffset & ~BIT(YBit) : *FBOffset | BIT(YBit);
     }
 }
 
-static inline void DrawPixel4Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	uint8_t* FBOffset = Device->Framebuffer + ( (Y * Device->Width >> 1) + (X >> 1));
-	*FBOffset = X & 0x01 ? (*FBOffset & 0x0f) | ((Color & 0x0f) << 4) : ((*FBOffset & 0xf0) | (Color & 0x0f));
+static inline void DrawPixel4Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint8_t* FBOffset = Device->Framebuffer + ((Y * Device->Width >> 1) + (X >> 1));
+    *FBOffset = X & 0x01 ? (*FBOffset & 0x0f) | ((Color & 0x0f) << 4) : ((*FBOffset & 0xf0) | (Color & 0x0f));
 }
 
-static inline void DrawPixel8Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	Device->Framebuffer[Y * Device->Width + X] = Color;
-}
+static inline void DrawPixel8Fast(struct GDS_Device* Device, int X, int Y, int Color) { Device->Framebuffer[Y * Device->Width + X] = Color; }
 
 // assumes that Color is 16 bits R..RG..GB..B from MSB to LSB and FB wants 1st serialized byte to start with R
-static inline void DrawPixel16Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	uint16_t* FBOffset = (uint16_t*) Device->Framebuffer + Y * Device->Width + X;
-	*FBOffset = __builtin_bswap16(Color);
+static inline void DrawPixel16Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint16_t* FBOffset = (uint16_t*)Device->Framebuffer + Y * Device->Width + X;
+    *FBOffset = __builtin_bswap16(Color);
 }
 
-// assumes that Color is 18 bits RGB from MSB to LSB RRRRRRGGGGGGBBBBBB, so byte[0] is B 
-// FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = xxRRRRRR xxGGGGGG xxBBBBBB 
-static inline void DrawPixel18Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
-	*FBOffset++ = Color >> 12; *FBOffset++ = (Color >> 6) & 0x3f; *FBOffset = Color & 0x3f;
+// assumes that Color is 18 bits RGB from MSB to LSB RRRRRRGGGGGGBBBBBB, so byte[0] is B
+// FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = xxRRRRRR xxGGGGGG xxBBBBBB
+static inline void DrawPixel18Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
+    *FBOffset++ = Color >> 12;
+    *FBOffset++ = (Color >> 6) & 0x3f;
+    *FBOffset = Color & 0x3f;
 }
 
-// assumes that Color is 24 bits RGB from MSB to LSB RRRRRRRRGGGGGGGGBBBBBBBB, so byte[0] is B 
-// FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = RRRRRRRR GGGGGGGG BBBBBBBB 
-static inline void DrawPixel24Fast( struct GDS_Device* Device, int X, int Y, int Color ) {
-	uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
-	*FBOffset++ = Color >> 16; *FBOffset++ = Color >> 8; *FBOffset = Color;
+// assumes that Color is 24 bits RGB from MSB to LSB RRRRRRRRGGGGGGGGBBBBBBBB, so byte[0] is B
+// FB is 3-bytes packets and starts with R for serialization so 0,1,2 ... = RRRRRRRR GGGGGGGG BBBBBBBB
+static inline void DrawPixel24Fast(struct GDS_Device* Device, int X, int Y, int Color) {
+    uint8_t* FBOffset = Device->Framebuffer + (Y * Device->Width + X) * 3;
+    *FBOffset++ = Color >> 16;
+    *FBOffset++ = Color >> 8;
+    *FBOffset = Color;
 }
 
-static inline void IRAM_ATTR DrawPixelFast( struct GDS_Device* Device, int X, int Y, int Color ) {
-    if (Device->DrawPixelFast) Device->DrawPixelFast( Device, X, Y, Color );
-	else if (Device->Depth == 4) DrawPixel4Fast( Device, X, Y, Color );
-	else if (Device->Depth == 1) DrawPixel1Fast( Device, X, Y, Color );
-	else if (Device->Depth == 16) DrawPixel16Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 24 && Device->Mode == GDS_RGB666) DrawPixel18Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 24 && Device->Mode == GDS_RGB888) DrawPixel24Fast( Device, X, Y, Color );	
-	else if (Device->Depth == 8) DrawPixel8Fast( Device, X, Y, Color );	
-}	
+static inline void IRAM_ATTR DrawPixelFast(struct GDS_Device* Device, int X, int Y, int Color) {
+    if(Device->DrawPixelFast)
+        Device->DrawPixelFast(Device, X, Y, Color);
+    else if(Device->Depth == 4)
+        DrawPixel4Fast(Device, X, Y, Color);
+    else if(Device->Depth == 1)
+        DrawPixel1Fast(Device, X, Y, Color);
+    else if(Device->Depth == 16)
+        DrawPixel16Fast(Device, X, Y, Color);
+    else if(Device->Depth == 24 && Device->Mode == GDS_RGB666)
+        DrawPixel18Fast(Device, X, Y, Color);
+    else if(Device->Depth == 24 && Device->Mode == GDS_RGB888)
+        DrawPixel24Fast(Device, X, Y, Color);
+    else if(Device->Depth == 8)
+        DrawPixel8Fast(Device, X, Y, Color);
+}
 
-static inline void IRAM_ATTR DrawPixel( struct GDS_Device* Device, int x, int y, int Color ) {
-    if ( IsPixelVisible( Device, x, y ) == true ) {
-        DrawPixelFast( Device, x, y, Color );
-    }
+static inline void IRAM_ATTR DrawPixel(struct GDS_Device* Device, int x, int y, int Color) {
+    if(IsPixelVisible(Device, x, y) == true) { DrawPixelFast(Device, x, y, Color); }
 }
 
 #endif

components/display/core/gds_text.c

@@ -17,177 +17,193 @@
 #include "gds_draw.h"
 #include "gds_text.h"
 
-#define max(a,b) (((a) > (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
 
 static char TAG[] = "gds";
 
 /****************************************************************************************
  *  Set fonts for each line in text mode
  */
-static const struct GDS_FontDef *GuessFont( struct GDS_Device *Device, int FontType) {
-	switch(FontType) {
-	case GDS_FONT_LINE_1:	
-		return &Font_line_1;
-	case GDS_FONT_LINE_2:	
-		return &Font_line_2;
-	case GDS_FONT_SMALL:	
-		return &Font_droid_sans_fallback_11x13;	
-	case GDS_FONT_MEDIUM:			
-	default:		
-		return &Font_droid_sans_fallback_15x17;	
+static const struct GDS_FontDef* GuessFont(struct GDS_Device* Device, int FontType) {
+    switch(FontType) {
+    case GDS_FONT_DEFAULT:
+        return Device->Font;
+    case GDS_FONT_LINE_1:
+        return Font_line_1;
+    case GDS_FONT_LINE_2:
+        return Font_line_2;
+    case GDS_FONT_MEDIUM:
+        //return &Font_droid_sans_fallback_15x17;
+    case GDS_FONT_SMALL:
+    default:
+        return Font_droid_sans_fallback_11x13;
 #ifdef USE_LARGE_FONTS
-	case GDS_FONT_LARGE:	
-		return &Font_droid_sans_fallback_24x28;
-		break;		
-	case GDS_FONT_SEGMENT:			
-		if (Device->Height == 32) return &Font_Tarable7Seg_16x32;
-		else return &Font_Tarable7Seg_32x64;
+    case GDS_FONT_LARGE:
+        return &Font_droid_sans_fallback_24x28;
+    case GDS_FONT_SEGMENT:
+        if(Device->Height == 32)
+            return &Font_Tarable7Seg_16x32;
+        else
+            return &Font_Tarable7Seg_32x64;
 #else
-	case GDS_FONT_LARGE:	
-	case GDS_FONT_SEGMENT:			
-		ESP_LOGW(TAG, "large fonts disabled");
-		return &Font_droid_sans_fallback_15x17;
-		break;		
-#endif	
-	}
+    case GDS_FONT_LARGE:
+    case GDS_FONT_SEGMENT:
+        ESP_LOGW(TAG, "large fonts disabled");
+        //return &Font_droid_sans_fallback_15x17;
+        return Font_droid_sans_fallback_11x13;
+#endif
+    }
 }
 
-
 /****************************************************************************************
  *  Set fonts for each line in text mode
  */
 bool GDS_TextSetFontAuto(struct GDS_Device* Device, int N, int FontType, int Space) {
-	const struct GDS_FontDef *Font = GuessFont( Device, FontType );
-	return GDS_TextSetFont( Device, N, Font, Space );
+    const struct GDS_FontDef* Font = GuessFont(Device, FontType);
+    return GDS_TextSetFont(Device, N, Font, Space);
 }
 
 /****************************************************************************************
  *  Set fonts for each line in text mode
  */
-bool GDS_TextSetFont(struct GDS_Device* Device, int N, const struct GDS_FontDef *Font, int Space) {
-	if (--N >= MAX_LINES) return false;
+bool GDS_TextSetFont(struct GDS_Device* Device, int N, const struct GDS_FontDef* Font, int Space) {
+    if(--N >= MAX_LINES) return false;
 
-	Device->Lines[N].Font = Font;
-	
-	// re-calculate lines absolute position
-	Device->Lines[N].Space = Space;
-	Device->Lines[0].Y = Device->Lines[0].Space;
-	for (int i = 1; i <= N; i++) Device->Lines[i].Y = Device->Lines[i-1].Y + Device->Lines[i-1].Font->Height + Device->Lines[i].Space;
-		
-	ESP_LOGI(TAG, "Adding line %u at %d (height:%u)", N + 1, Device->Lines[N].Y, Device->Lines[N].Font->Height);
-	
-	if (Device->Lines[N].Y + Device->Lines[N].Font->Height > Device->Height) {
-		ESP_LOGW(TAG, "line does not fit display");
-		return false;
-	}
-	
-	return true;
+    Device->Lines[N].Font = Font;
+
+    // re-calculate lines absolute position
+    Device->Lines[N].Space = Space;
+    Device->Lines[0].Y = Device->Lines[0].Space;
+    for(int i = 1; i <= N; i++) Device->Lines[i].Y = Device->Lines[i - 1].Y + Device->Lines[i - 1].Font->Height + Device->Lines[i].Space;
+
+    ESP_LOGI(TAG, "Adding line %u at %d (height:%u)", N + 1, Device->Lines[N].Y, Device->Lines[N].Font->Height);
+
+    if(Device->Lines[N].Y + Device->Lines[N].Font->Height > Device->Height) {
+        ESP_LOGW(TAG, "line does not fit display");
+        return false;
+    }
+
+    return true;
 }
 
 /****************************************************************************************
  * 
  */
-bool GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char *Text) {
-	int Width, X = Pos;
+bool GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char* Text) {
+    int Width, X = Pos;
 
-	// counting 1..n
-	N--;
-	
-	GDS_SetFont( Device, Device->Lines[N].Font );	
-	if (Attr & GDS_TEXT_MONOSPACE) GDS_FontForceMonospace( Device, true );
-	
-	Width = GDS_FontMeasureString( Device, Text );
-	
-	// adjusting position, erase only EoL for rigth-justified
-	if (Pos == GDS_TEXT_RIGHT) X = Device->Width - Width - 1;
-	else if (Pos == GDS_TEXT_CENTER) X = (Device->Width - Width) / 2;
-	
-	// erase if requested
-	if (Attr & GDS_TEXT_CLEAR) {
-		int Y_min = max(0, Device->Lines[N].Y), Y_max = max(0, Device->Lines[N].Y + Device->Lines[N].Font->Height);
-		for (int c = (Attr & GDS_TEXT_CLEAR_EOL) ? X : 0; c < Device->Width; c++) 
-			for (int y = Y_min; y < Y_max; y++)
-				DrawPixelFast( Device, c, y, GDS_COLOR_BLACK );
-	}
-		
-	GDS_FontDrawString( Device, X, Device->Lines[N].Y, Text, GDS_COLOR_WHITE );
-	
-	ESP_LOGD(TAG, "displaying %s line %u (x:%d, attr:%u)", Text, N+1, X, Attr);
-	
-	// update whole display if requested
-	Device->Dirty = true;
-	if (Attr & GDS_TEXT_UPDATE) GDS_Update( Device );
-		
-	return Width + X < Device->Width;
+    // counting 1..n
+    N--;
+
+    GDS_SetFont(Device, Device->Lines[N].Font);
+    if(Attr & GDS_TEXT_MONOSPACE) GDS_FontForceMonospace(Device, true);
+
+    Width = GDS_FontMeasureString(Device, Text);
+
+    // adjusting position, erase only EoL for rigth-justified
+    if(Pos == GDS_TEXT_RIGHT)
+        X = Device->TextWidth - Width - 1;
+    else if(Pos == GDS_TEXT_CENTER)
+        X = (Device->TextWidth - Width) / 2;
+
+    // erase if requested
+    if(Attr & GDS_TEXT_CLEAR) {
+        int Y_min = max(0, Device->Lines[N].Y), Y_max = max(0, Device->Lines[N].Y + Device->Lines[N].Font->Height);
+        for(int c = (Attr & GDS_TEXT_CLEAR_EOL) ? X : 0; c < Device->TextWidth; c++)
+            for(int y = Y_min; y < Y_max; y++) DrawPixelFast(Device, c, y, GDS_COLOR_BLACK);
+    }
+
+    GDS_FontDrawString(Device, X, Device->Lines[N].Y, Text, GDS_COLOR_WHITE);
+
+    ESP_LOGD(TAG, "displaying %s line %u (x:%d, attr:%u)", Text, N + 1, X, Attr);
+
+    // update whole display if requested
+    Device->Dirty = true;
+    if(Attr & GDS_TEXT_UPDATE) GDS_Update(Device);
+
+    return Width + X < Device->TextWidth;
+}
+
+/****************************************************************************************
+ * 
+ */
+int GDS_GetTextWidth(struct GDS_Device* Device, int N, int Attr, char* Text) {
+    const struct GDS_FontDef* Font = GDS_SetFont(Device, Device->Lines[N - 1].Font);
+
+    if(Attr & GDS_TEXT_MONOSPACE) GDS_FontForceMonospace(Device, true);
+    int Width = GDS_FontMeasureString(Device, Text);
+    GDS_SetFont(Device, Font);
+
+    return Width;
 }
 
 /****************************************************************************************
  * Try to align string for better scrolling visual. there is probably much better to do
  */
-int GDS_TextStretch(struct GDS_Device* Device, int N, char *String, int Max) {
-	char Space[] = "     ";
-	int Len = strlen(String), Extra = 0, Boundary;
-	
-	N--;
-	
-	// we might already fit
-	GDS_SetFont( Device, Device->Lines[N].Font );	
-	if (GDS_FontMeasureString( Device, String ) <= Device->Width) return 0;
-		
-	// add some space for better visual 
-	strncat(String, Space, Max-Len);
-	String[Max] = '\0';
-	Len = strlen(String);
-	
-	// mark the end of the extended string
-	Boundary = GDS_FontMeasureString( Device, String );
-			
-	// add a full display width	
-	while (Len < Max && GDS_FontMeasureString( Device, String ) - Boundary < Device->Width) {
-		String[Len++] = String[Extra++];
-		String[Len] = '\0';
-	}
-		
-	return Boundary;
+int GDS_TextStretch(struct GDS_Device* Device, int N, char* String, int Max) {
+    char Space[] = "     ";
+    int Len = strlen(String), Extra = 0, Boundary;
+
+    N--;
+
+    // we might already fit
+    GDS_SetFont(Device, Device->Lines[N].Font);
+    if(GDS_FontMeasureString(Device, String) <= Device->TextWidth) return 0;
+
+    // add some space for better visual
+    strncat(String, Space, Max - Len);
+    String[Max] = '\0';
+    Len = strlen(String);
+
+    // mark the end of the extended string
+    Boundary = GDS_FontMeasureString(Device, String);
+
+    // add a full display width
+    while(Len < Max && GDS_FontMeasureString(Device, String) - Boundary < Device->TextWidth) {
+        String[Len++] = String[Extra++];
+        String[Len] = '\0';
+    }
+
+    return Boundary;
 }
 
 /****************************************************************************************
  * 
  */
-void GDS_TextPos(struct GDS_Device* Device, int FontType, int Where, int Attr, char *Text, ...) {
-	va_list args;
+void GDS_TextPos(struct GDS_Device* Device, int FontType, int Where, int Attr, char* Text, ...) {
+    va_list args;
 
-	TextAnchor Anchor = TextAnchor_Center;	
-	
-	if (Attr & GDS_TEXT_CLEAR) GDS_Clear( Device, GDS_COLOR_BLACK );
-	
-	if (!Text) return;
-	
-	va_start(args, Text);
-	
-	switch(Where) {
-	case GDS_TEXT_TOP_LEFT: 
-	default:
-		Anchor = TextAnchor_NorthWest; 
-		break;
-	case GDS_TEXT_MIDDLE_LEFT:
-		Anchor = TextAnchor_West;
-		break;
-	case GDS_TEXT_BOTTOM_LEFT:
-		Anchor = TextAnchor_SouthWest;
-		break;
-	case GDS_TEXT_CENTERED:
-		Anchor = TextAnchor_Center;
-		break;
-	}	
-	
-	ESP_LOGD(TAG, "Displaying %s at %u with attribute %u", Text, Anchor, Attr);
-	
-	GDS_SetFont( Device, GuessFont( Device, FontType ) );	
-	GDS_FontDrawAnchoredString( Device, Anchor, Text, GDS_COLOR_WHITE );
-	
-	Device->Dirty = true;
-	if (Attr & GDS_TEXT_UPDATE) GDS_Update( Device );
-	
-	va_end(args);
+    TextAnchor Anchor = TextAnchor_Center;
+
+    if(Attr & GDS_TEXT_CLEAR) GDS_Clear(Device, GDS_COLOR_BLACK);
+
+    if(!Text) return;
+
+    va_start(args, Text);
+
+    switch(Where) {
+    case GDS_TEXT_TOP_LEFT:
+    default:
+        Anchor = TextAnchor_NorthWest;
+        break;
+    case GDS_TEXT_MIDDLE_LEFT:
+        Anchor = TextAnchor_West;
+        break;
+    case GDS_TEXT_BOTTOM_LEFT:
+        Anchor = TextAnchor_SouthWest;
+        break;
+    case GDS_TEXT_CENTERED:
+        Anchor = TextAnchor_Center;
+        break;
+    }
+
+    ESP_LOGD(TAG, "Displaying %s at %u with attribute %u", Text, Anchor, Attr);
+
+    GDS_SetFont(Device, GuessFont(Device, FontType));
+    GDS_FontDrawAnchoredString(Device, Anchor, Text, GDS_COLOR_WHITE);
+
+    Device->Dirty = true;
+    if(Attr & GDS_TEXT_UPDATE) GDS_Update(Device);
+
+    va_end(args);
 }

components/display/core/gds_text.h

@@ -10,26 +10,36 @@
 
 #include "gds_font.h"
 
-#define GDS_TEXT_CLEAR 		0x01
-#define	GDS_TEXT_CLEAR_EOL	0x02
-#define GDS_TEXT_UPDATE		0x04
-#define GDS_TEXT_MONOSPACE	0x08
+#define GDS_TEXT_CLEAR 0x01
+#define GDS_TEXT_CLEAR_EOL 0x02
+#define GDS_TEXT_UPDATE 0x04
+#define GDS_TEXT_MONOSPACE 0x08
 
 // these ones are for 'Pos' parameter of TextLine
-#define GDS_TEXT_LEFT 	0
-#define GDS_TEXT_RIGHT	0xff00
-#define	GDS_TEXT_CENTER 0xff01
+#define GDS_TEXT_LEFT 0
+#define GDS_TEXT_RIGHT 0xff00
+#define GDS_TEXT_CENTER 0xff01
 
 // these ones are for the 'Where' parameter of TextPos
 enum { GDS_TEXT_TOP_LEFT, GDS_TEXT_MIDDLE_LEFT, GDS_TEXT_BOTTOM_LEFT, GDS_TEXT_CENTERED };
 
-enum { GDS_FONT_DEFAULT, GDS_FONT_LINE_1, GDS_FONT_LINE_2, GDS_FONT_SEGMENT, 
-	   GDS_FONT_TINY, GDS_FONT_SMALL, GDS_FONT_MEDIUM, GDS_FONT_LARGE, GDS_FONT_FONT_HUGE };
-	   
+enum {
+    GDS_FONT_DEFAULT,
+    GDS_FONT_LINE_1,
+    GDS_FONT_LINE_2,
+    GDS_FONT_SEGMENT,
+    GDS_FONT_TINY,
+    GDS_FONT_SMALL,
+    GDS_FONT_MEDIUM,
+    GDS_FONT_LARGE,
+    GDS_FONT_FONT_HUGE
+};
+
 struct GDS_Device;
-	   
-bool 	GDS_TextSetFontAuto(struct GDS_Device* Device, int N, int FontType, int Space);
-bool 	GDS_TextSetFont(struct GDS_Device* Device, int N, const struct GDS_FontDef *Font, int Space);
-bool 	GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char *Text);
-int 	GDS_TextStretch(struct GDS_Device* Device, int N, char *String, int Max);
-void 	GDS_TextPos(struct GDS_Device* Device, int FontType, int Where, int Attr, char *Text, ...);
+
+bool GDS_TextSetFontAuto(struct GDS_Device* Device, int N, int FontType, int Space);
+bool GDS_TextSetFont(struct GDS_Device* Device, int N, const struct GDS_FontDef* Font, int Space);
+bool GDS_TextLine(struct GDS_Device* Device, int N, int Pos, int Attr, char* Text);
+int GDS_GetTextWidth(struct GDS_Device* Device, int N, int Attr, char* Text);
+int GDS_TextStretch(struct GDS_Device* Device, int N, char* String, int Max);
+void GDS_TextPos(struct GDS_Device* Device, int FontType, int Where, int Attr, char* Text, ...);

components/display/core/ifaces/default_if_i2c.c

@@ -22,9 +22,9 @@ static int I2CWait;
 static const int GDS_I2C_COMMAND_MODE = 0x80;
 static const int GDS_I2C_DATA_MODE = 0x40;
 
-static bool I2CDefaultWriteBytes( int Address, bool IsCommand, const uint8_t* Data, size_t DataLength );
-static bool I2CDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command );
-static bool I2CDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength );
+static bool I2CDefaultWriteBytes(int Address, bool IsCommand, const uint8_t* Data, size_t DataLength);
+static bool I2CDefaultWriteCommand(struct GDS_Device* Device, uint8_t Command);
+static bool I2CDefaultWriteData(struct GDS_Device* Device, const uint8_t* Data, size_t DataLength);
 
 /*
  * Initializes the i2c master with the parameters specified
@@ -32,24 +32,24 @@ static bool I2CDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data,
  * 
  * Returns true on successful init of the i2c bus.
  */
-bool GDS_I2CInit( int PortNumber, int SDA, int SCL, int Speed ) {
-	I2CPortNumber = PortNumber;
-	
-	I2CWait = pdMS_TO_TICKS( Speed ? (250 * 250000) / Speed : 250 );
-	
-	if (SDA != -1 && SCL != -1) {
-		i2c_config_t Config = { 0 };
+bool GDS_I2CInit(int PortNumber, int SDA, int SCL, int Speed) {
+    I2CPortNumber = PortNumber;
+
+    I2CWait = pdMS_TO_TICKS(Speed ? (250 * 250000) / Speed : 250);
+
+    if(SDA != -1 && SCL != -1) {
+        i2c_config_t Config = {0};
 
         Config.mode = I2C_MODE_MASTER;
-		Config.sda_io_num = SDA;
-		Config.sda_pullup_en = GPIO_PULLUP_ENABLE;
-		Config.scl_io_num = SCL;
-		Config.scl_pullup_en = GPIO_PULLUP_ENABLE;
-		Config.master.clk_speed = Speed ? Speed : 400000;
+        Config.sda_io_num = SDA;
+        Config.sda_pullup_en = GPIO_PULLUP_ENABLE;
+        Config.scl_io_num = SCL;
+        Config.scl_pullup_en = GPIO_PULLUP_ENABLE;
+        Config.master.clk_speed = Speed ? Speed : 400000;
 
-		ESP_ERROR_CHECK_NONFATAL( i2c_param_config( I2CPortNumber, &Config ), return false );
-		ESP_ERROR_CHECK_NONFATAL( i2c_driver_install( I2CPortNumber, Config.mode, 0, 0, 0 ), return false );
-	}	
+        ESP_ERROR_CHECK_NONFATAL(i2c_param_config(I2CPortNumber, &Config), return false);
+        ESP_ERROR_CHECK_NONFATAL(i2c_driver_install(I2CPortNumber, Config.mode, 0, 0, 0), return false);
+    }
 
     return true;
 }
@@ -66,63 +66,63 @@ bool GDS_I2CInit( int PortNumber, int SDA, int SCL, int Speed ) {
  * 
  * Returns true on successful init of display.
  */
-bool GDS_I2CAttachDevice( struct GDS_Device* Device, int Width, int Height, int I2CAddress, int RSTPin, int BacklightPin ) {
-    NullCheck( Device, return false );
+bool GDS_I2CAttachDevice(struct GDS_Device* Device, int Width, int Height, int I2CAddress, int RSTPin, int BacklightPin) {
+    NullCheck(Device, return false);
 
     Device->WriteCommand = I2CDefaultWriteCommand;
     Device->WriteData = I2CDefaultWriteData;
     Device->Address = I2CAddress;
     Device->RSTPin = RSTPin;
-	Device->Backlight.Pin = BacklightPin;	
-	Device->IF = GDS_IF_I2C;
-	Device->Width = Width;
-	Device->Height = Height;
-	
-	if ( RSTPin >= 0 ) {
-        ESP_ERROR_CHECK_NONFATAL( gpio_set_direction( RSTPin, GPIO_MODE_OUTPUT ), return false );
-        ESP_ERROR_CHECK_NONFATAL( gpio_set_level( RSTPin, 1 ), return false );
-		GDS_Reset( Device );
+    Device->Backlight.Pin = BacklightPin;
+    Device->IF = GDS_IF_I2C;
+    Device->Width = Device->TextWidth = Width;
+    Device->Height = Height;
+
+    if(RSTPin >= 0) {
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_direction(RSTPin, GPIO_MODE_OUTPUT), return false);
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_level(RSTPin, 1), return false);
+        GDS_Reset(Device);
     }
-	
-    return GDS_Init( Device );
+
+    return GDS_Init(Device);
 }
 
-static bool I2CDefaultWriteBytes( int Address, bool IsCommand, const uint8_t* Data, size_t DataLength ) {
+static bool I2CDefaultWriteBytes(int Address, bool IsCommand, const uint8_t* Data, size_t DataLength) {
     i2c_cmd_handle_t* CommandHandle = NULL;
     static uint8_t ModeByte = 0;
 
-    NullCheck( Data, return false );
+    NullCheck(Data, return false);
 
-    if ( ( CommandHandle = i2c_cmd_link_create( ) ) != NULL ) {
-        ModeByte = ( IsCommand == true ) ? GDS_I2C_COMMAND_MODE: GDS_I2C_DATA_MODE;
+    if((CommandHandle = i2c_cmd_link_create()) != NULL) {
+        ModeByte = (IsCommand == true) ? GDS_I2C_COMMAND_MODE : GDS_I2C_DATA_MODE;
 
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_start( CommandHandle ), goto error );
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_write_byte( CommandHandle, ( Address << 1 ) | I2C_MASTER_WRITE, true ), goto error );
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_write_byte( CommandHandle, ModeByte, true ), goto error );
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_write( CommandHandle, ( uint8_t* ) Data, DataLength, true ), goto error );
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_stop( CommandHandle ), goto error );
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_start(CommandHandle), goto error);
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_write_byte(CommandHandle, (Address << 1) | I2C_MASTER_WRITE, true), goto error);
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_write_byte(CommandHandle, ModeByte, true), goto error);
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_write(CommandHandle, (uint8_t*)Data, DataLength, true), goto error);
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_stop(CommandHandle), goto error);
 
-        ESP_ERROR_CHECK_NONFATAL( i2c_master_cmd_begin( I2CPortNumber, CommandHandle, I2CWait ), goto error );
-        i2c_cmd_link_delete( CommandHandle );
+        ESP_ERROR_CHECK_NONFATAL(i2c_master_cmd_begin(I2CPortNumber, CommandHandle, I2CWait), goto error);
+        i2c_cmd_link_delete(CommandHandle);
     }
 
     return true;
-	
+
 error:
-	if (CommandHandle) i2c_cmd_link_delete( CommandHandle );
-	return false;
+    if(CommandHandle) i2c_cmd_link_delete(CommandHandle);
+    return false;
 }
 
-static bool I2CDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command ) {
-    uint8_t CommandByte = ( uint8_t ) Command;
-	
-    NullCheck( Device, return false );
-    return I2CDefaultWriteBytes( Device->Address, true, ( const uint8_t* ) &CommandByte, 1 );
+static bool I2CDefaultWriteCommand(struct GDS_Device* Device, uint8_t Command) {
+    uint8_t CommandByte = (uint8_t)Command;
+
+    NullCheck(Device, return false);
+    return I2CDefaultWriteBytes(Device->Address, true, (const uint8_t*)&CommandByte, 1);
 }
 
-static bool I2CDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength ) {
-    NullCheck( Device, return false );
-    NullCheck( Data, return false );
+static bool I2CDefaultWriteData(struct GDS_Device* Device, const uint8_t* Data, size_t DataLength) {
+    NullCheck(Device, return false);
+    NullCheck(Data, return false);
 
-    return I2CDefaultWriteBytes( Device->Address, false, Data, DataLength );
+    return I2CDefaultWriteBytes(Device->Address, false, Data, DataLength);
 }

components/display/core/ifaces/default_if_spi.c

@@ -24,88 +24,98 @@ static const int GDS_SPI_Data_Mode = 1;
 static spi_host_device_t SPIHost;
 static int DCPin;
 
-static bool SPIDefaultWriteBytes( spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength );
-static bool SPIDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command );
-static bool SPIDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength );
+static bool SPIDefaultWriteBytes(spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength);
+static bool SPIDefaultWriteCommand(struct GDS_Device* Device, uint8_t Command);
+static bool SPIDefaultWriteData(struct GDS_Device* Device, const uint8_t* Data, size_t DataLength);
 
-bool GDS_SPIInit( int SPI, int DC ) {
-	SPIHost = SPI;
-	DCPin = DC;
+bool GDS_SPIInit(int SPI, int DC) {
+    SPIHost = SPI;
+    DCPin = DC;
     return true;
 }
 
-bool GDS_SPIAttachDevice( struct GDS_Device* Device, int Width, int Height, int CSPin, int RSTPin, int BackLightPin, int Speed ) {
-    spi_device_interface_config_t SPIDeviceConfig;
+bool GDS_SPIAttachDevice(struct GDS_Device* Device, int Width, int Height, int CSPin, int RSTPin, int BackLightPin, int Speed, int Mode) {
+    spi_device_interface_config_t SPIDeviceConfig = {};
     spi_device_handle_t SPIDevice;
 
-    NullCheck( Device, return false );
-	
-	if (CSPin >= 0) {
-		ESP_ERROR_CHECK_NONFATAL( gpio_set_direction( CSPin, GPIO_MODE_OUTPUT ), return false );
-		ESP_ERROR_CHECK_NONFATAL( gpio_set_level( CSPin, 0 ), return false );
-	}	
-	
-    memset( &SPIDeviceConfig, 0, sizeof( spi_device_interface_config_t ) );
+    NullCheck(Device, return false);
+
+    if(CSPin >= 0) {
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_direction(CSPin, GPIO_MODE_OUTPUT), return false);
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_level(CSPin, 0), return false);
+    }
 
     SPIDeviceConfig.clock_speed_hz = Speed > 0 ? Speed : SPI_MASTER_FREQ_8M;
     SPIDeviceConfig.spics_io_num = CSPin;
     SPIDeviceConfig.queue_size = 1;
-	SPIDeviceConfig.flags = SPI_DEVICE_NO_DUMMY;
+    SPIDeviceConfig.mode = Mode;
+    SPIDeviceConfig.flags = SPI_DEVICE_NO_DUMMY;
+    if(Device->SPIParams)
+        Device->SPIParams(SPIDeviceConfig.clock_speed_hz, &SPIDeviceConfig.mode, &SPIDeviceConfig.cs_ena_pretrans, &SPIDeviceConfig.cs_ena_posttrans);
 
-    ESP_ERROR_CHECK_NONFATAL( spi_bus_add_device( SPIHost, &SPIDeviceConfig, &SPIDevice ), return false );
-	
-	Device->WriteCommand = SPIDefaultWriteCommand;
+    ESP_ERROR_CHECK_NONFATAL(spi_bus_add_device(SPIHost, &SPIDeviceConfig, &SPIDevice), return false);
+
+    Device->WriteCommand = SPIDefaultWriteCommand;
     Device->WriteData = SPIDefaultWriteData;
     Device->SPIHandle = SPIDevice;
     Device->RSTPin = RSTPin;
     Device->CSPin = CSPin;
-	Device->Backlight.Pin = BackLightPin;	
-	Device->IF = GDS_IF_SPI;
-	Device->Width = Width;
-	Device->Height = Height;
-	
-	if ( RSTPin >= 0 ) {
-        ESP_ERROR_CHECK_NONFATAL( gpio_set_direction( RSTPin, GPIO_MODE_OUTPUT ), return false );
-        ESP_ERROR_CHECK_NONFATAL( gpio_set_level( RSTPin, 0 ), return false );
-		GDS_Reset( Device );
+    Device->Backlight.Pin = BackLightPin;
+    Device->IF = GDS_IF_SPI;
+    Device->Width = Device->TextWidth = Width;
+    Device->Height = Height;
+
+    if(RSTPin >= 0) {
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_direction(RSTPin, GPIO_MODE_OUTPUT), return false);
+        ESP_ERROR_CHECK_NONFATAL(gpio_set_level(RSTPin, 0), return false);
+        GDS_Reset(Device);
     }
-	
-	return GDS_Init( Device );
+
+    return GDS_Init(Device);
 }
 
-static bool SPIDefaultWriteBytes( spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength ) {
-    spi_transaction_t SPITransaction = { 0 };
+static bool SPIDefaultWriteBytes(spi_device_handle_t SPIHandle, int WriteMode, const uint8_t* Data, size_t DataLength) {
+    spi_transaction_t SPITransaction = {};
 
-    NullCheck( SPIHandle, return false );
-    NullCheck( Data, return false );
+    NullCheck(SPIHandle, return false);
+    NullCheck(Data, return false);
 
-    if ( DataLength > 0 ) {
-		gpio_set_level( DCPin, WriteMode );
-		
-		SPITransaction.length = DataLength * 8;
-		SPITransaction.tx_buffer = Data;
-            
-		// only do polling as we don't have contention on SPI (otherwise DMA for transfers > 16 bytes)		
-		ESP_ERROR_CHECK_NONFATAL( spi_device_polling_transmit(SPIHandle, &SPITransaction), return false );
+    if(DataLength > 0) {
+        gpio_set_level(DCPin, WriteMode);
+
+        SPITransaction.length = DataLength * 8;
+
+        if(DataLength <= 4) {
+            SPITransaction.flags = SPI_TRANS_USE_TXDATA;
+            SPITransaction.tx_data[0] = *Data++;
+            SPITransaction.tx_data[1] = *Data++;
+            SPITransaction.tx_data[2] = *Data++;
+            SPITransaction.tx_data[3] = *Data;
+        } else {
+            SPITransaction.tx_buffer = Data;
+        }
+
+        // only do polling as we don't have contention on SPI (otherwise DMA for transfers > 16 bytes)
+        ESP_ERROR_CHECK_NONFATAL(spi_device_polling_transmit(SPIHandle, &SPITransaction), return false);
     }
 
     return true;
 }
 
-static bool SPIDefaultWriteCommand( struct GDS_Device* Device, uint8_t Command ) {
+static bool SPIDefaultWriteCommand(struct GDS_Device* Device, uint8_t Command) {
     static uint8_t CommandByte = 0;
 
-    NullCheck( Device, return false );
-    NullCheck( Device->SPIHandle, return false );
+    NullCheck(Device, return false);
+    NullCheck(Device->SPIHandle, return false);
 
     CommandByte = Command;
 
-    return SPIDefaultWriteBytes( Device->SPIHandle, GDS_SPI_Command_Mode, &CommandByte, 1 );
+    return SPIDefaultWriteBytes(Device->SPIHandle, GDS_SPI_Command_Mode, &CommandByte, 1);
 }
 
-static bool SPIDefaultWriteData( struct GDS_Device* Device, const uint8_t* Data, size_t DataLength ) {
-    NullCheck( Device, return false );
-    NullCheck( Device->SPIHandle, return false );
+static bool SPIDefaultWriteData(struct GDS_Device* Device, const uint8_t* Data, size_t DataLength) {
+    NullCheck(Device, return false);
+    NullCheck(Device->SPIHandle, return false);
 
-    return SPIDefaultWriteBytes( Device->SPIHandle, GDS_SPI_Data_Mode, Data, DataLength );
+    return SPIDefaultWriteBytes(Device->SPIHandle, GDS_SPI_Data_Mode, Data, DataLength);
 }

components/display/display.c

@@ -12,412 +12,479 @@
 #include <arpa/inet.h>
 #include "esp_log.h"
 #include "globdefs.h"
-#include "platform_config.h"
 #include "tools.h"
+#include "accessors.h"
 #include "display.h"
+#include "services.h"
 #include "gds.h"
 #include "gds_default_if.h"
 #include "gds_draw.h"
 #include "gds_text.h"
 #include "gds_font.h"
+#include "gds_image.h"
+#include "Config.h"
+static const char* TAG = "display";
 
-static const char *TAG = "display";
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
 
-#define min(a,b) (((a) < (b)) ? (a) : (b))
-#define max(a,b) (((a) > (b)) ? (a) : (b))
+#define DISPLAYER_STACK_SIZE (3 * 1024)
+#define SCROLLABLE_SIZE 384
+#define HEADER_SIZE 64
+#define DEFAULT_SLEEP 3600
+#define ARTWORK_BORDER 1
 
-#define DISPLAYER_STACK_SIZE 	(3*1024)
-#define SCROLLABLE_SIZE			384
-#define HEADER_SIZE				64
-#define	DEFAULT_SLEEP			3600
+extern const uint8_t default_artwork[] asm("_binary_note_jpg_start");
 
 static EXT_RAM_ATTR struct {
-	TaskHandle_t task;
-	SemaphoreHandle_t mutex;
-	int pause, speed, by;
-	enum { DISPLAYER_DOWN, DISPLAYER_IDLE, DISPLAYER_ACTIVE } state;
-	char header[HEADER_SIZE + 1];
-	char string[SCROLLABLE_SIZE + 1];
-	int offset, boundary;
-	char *metadata_config;
-	bool timer, refresh;
-	uint32_t elapsed, duration;
-	TickType_t tick;
+    TaskHandle_t task;
+    SemaphoreHandle_t mutex;
+    int pause, speed, by;
+    enum { DISPLAYER_DOWN, DISPLAYER_IDLE, DISPLAYER_ACTIVE } state;
+    char header[HEADER_SIZE + 1];
+    char string[SCROLLABLE_SIZE + 1];
+    int offset, boundary;
+    sys_metadata_config* metadata_config;
+    bool timer, refresh;
+    uint32_t elapsed;
+    struct {
+        uint32_t value;
+        char string[8]; // H:MM:SS
+        bool visible;
+    } duration;
+    struct {
+        bool enable, active;
+        bool fit;
+        bool updated;
+        int tick;
+        int offset;
+    } artwork;
+    TickType_t tick;
 } displayer;
 
-static const char *known_drivers[] = {"SH1106",
-		"SSD1306",
-		"SSD1322",
-		"SSD1326",
-		"SSD1327",
-		"SSD1675",
-		"SSD1351",
-		"ST7735",
-		"ST7789",
-		"ILI9341",
-		NULL
-	};
-static void displayer_task(void *args);
+static void displayer_task(void* args);
+static void display_sleep(void);
 
-struct GDS_Device *display;   
+struct GDS_Device* display;
+bool (*display_bus)(void* from, enum display_bus_cmd_e cmd) = NULL;
 extern GDS_DetectFunc SSD1306_Detect, SSD132x_Detect, SH1106_Detect, SSD1675_Detect, SSD1322_Detect, SSD1351_Detect, ST77xx_Detect, ILI9341_Detect;
-GDS_DetectFunc *drivers[] = { SH1106_Detect, SSD1306_Detect, SSD132x_Detect, SSD1675_Detect, SSD1322_Detect, SSD1351_Detect, ST77xx_Detect, ILI9341_Detect, NULL };
+GDS_DetectFunc* drivers[] = {
+    SH1106_Detect, SSD1306_Detect, SSD132x_Detect, SSD1675_Detect, SSD1322_Detect, SSD1351_Detect, ST77xx_Detect, ILI9341_Detect, NULL};
 
 /****************************************************************************************
  * 
  */
-void display_init(char *welcome) {
-	bool init = false;
-	char *config = config_alloc_get_str("display_config", CONFIG_DISPLAY_CONFIG, "N/A");
-	
-	int width = -1, height = -1, backlight_pin = -1;
-	char *p, *drivername = strstr(config, "driver");
+void display_init(char* welcome) {
+    bool init = false;
+    int width = -1, height = -1, backlight_pin = -1, RST_pin = -1;
+    sys_display_config* sys_display;
+    sys_display_common* common;
 
-	if ((p = strcasestr(config, "width")) != NULL) width = atoi(strchr(p, '=') + 1);
-	if ((p = strcasestr(config, "height")) != NULL) height = atoi(strchr(p, '=') + 1);
-	if ((p = strcasestr(config, "back")) != NULL) backlight_pin = atoi(strchr(p, '=') + 1);	
-		
-	// query drivers to see if we have a match
-	ESP_LOGI(TAG, "Trying to configure display with %s", config);
-	if (backlight_pin >= 0) {
-		struct GDS_BacklightPWM PWMConfig = { .Channel = pwm_system.base_channel++, .Timer = pwm_system.timer, .Max = pwm_system.max, .Init = false	};
-		display = GDS_AutoDetect(drivername, drivers, &PWMConfig);
-	} else {
-		display = GDS_AutoDetect(drivername, drivers, NULL);
-	}
+    if(!SYS_DISPLAY(sys_display) || !SYS_DISPLAY_COMMON(common) || common->driver == sys_display_drivers_UNSPECIFIED) {
+        ESP_LOGI(TAG, "No display configuration");
+        return;
+    }
+    // // so far so good
+    if(common->width == 0 || common->height == 0) {
+        ESP_LOGE(TAG, "Misconfigured display missing data");
+        return;
+    }
+    ESP_LOGI(TAG, "Initializing display type %s, driver: %s", sys_dev_common_types_name(sys_display->type), sys_display_drivers_name(common->driver));
+    if(common->back >= 0) {
+        struct GDS_BacklightPWM PWMConfig = {.Channel = pwm_system.base_channel++, .Timer = pwm_system.timer, .Max = pwm_system.max, .Init = false};
+        display = GDS_AutoDetect(sys_display, drivers, &PWMConfig);
+    } else {
+        display = GDS_AutoDetect(sys_display, drivers, NULL);
+    }
 
-	// so far so good
-	if (display && width > 0 && height > 0) {
-		int RST_pin = -1;
-		if ((p = strcasestr(config, "reset")) != NULL) RST_pin = atoi(strchr(p, '=') + 1);
-		
-		// Detect driver interface
-		if (strstr(config, "I2C") && i2c_system_port != -1) {
-			int address = 0x3C;
-				
-			if ((p = strcasestr(config, "address")) != NULL) address = atoi(strchr(p, '=') + 1);
-				
-			init = true;
-			GDS_I2CInit( i2c_system_port, -1, -1, i2c_system_speed ) ;
-			GDS_I2CAttachDevice( display, width, height, address, RST_pin, backlight_pin );
-		
-			ESP_LOGI(TAG, "Display is I2C on port %u", address);
-		} else if (strstr(config, "SPI") && spi_system_host != -1) {
-			int CS_pin = -1, speed = 0;
-		
-			if ((p = strcasestr(config, "cs")) != NULL) CS_pin = atoi(strchr(p, '=') + 1);
-			if ((p = strcasestr(config, "speed")) != NULL) speed = atoi(strchr(p, '=') + 1);
-		
-			init = true;
-			GDS_SPIInit( spi_system_host, spi_system_dc_gpio );
-			GDS_SPIAttachDevice( display, width, height, CS_pin, RST_pin, backlight_pin, speed );
-				
-			ESP_LOGI(TAG, "Display is SPI host %u with cs:%d", spi_system_host, CS_pin);
-		} else {
-			display = NULL;
-			ESP_LOGI(TAG, "Unsupported display interface or serial link not configured");
-		}
-	} else {
-		display = NULL;
-		ESP_LOGW(TAG, "No display driver");
-	}	
-	
-	if (init) {
-		static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__ ((aligned (4)));
-		static EXT_RAM_ATTR StackType_t xStack[DISPLAYER_STACK_SIZE] __attribute__ ((aligned (4)));
-		
-		GDS_SetLayout( display, strcasestr(config, "HFlip"), strcasestr(config, "VFlip"), strcasestr(config, "rotate"));
-		GDS_SetFont(display, &Font_droid_sans_fallback_15x17 );
-		GDS_TextPos(display, GDS_FONT_MEDIUM, GDS_TEXT_CENTERED, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, welcome);
+    if(display) {
+        RST_pin = common->reset;
+        backlight_pin = common->back;
+        width = common->width;
+        height = common->height;
 
-		// start the task that will handle scrolling & counting
-		displayer.mutex = xSemaphoreCreateMutex();
-		displayer.by = 2;
-		displayer.pause = 3600;
-		displayer.speed = 33;
-		displayer.task = xTaskCreateStatic( (TaskFunction_t) displayer_task, "common_displayer", DISPLAYER_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
-		
-		// set lines for "fixed" text mode
-		GDS_TextSetFontAuto(display, 1, GDS_FONT_LINE_1, -3);
-		GDS_TextSetFontAuto(display, 2, GDS_FONT_LINE_2, -3);
-		
-		displayer.metadata_config = config_alloc_get(NVS_TYPE_STR, "metadata_config");
-	}
-	
-	free(config);
+        // Detect driver interface
+        if(sys_display->which_dispType == sys_display_config_i2c_tag && platform->dev.i2c.port != sys_i2c_port_UNSPECIFIED) {
+            int address = 0x3C;
+
+            address = sys_display->dispType.i2c.address;
+            init = true;
+            GDS_I2CInit(platform->dev.i2c.port - sys_i2c_port_PORT0, -1, -1, platform->dev.i2c.speed);
+            GDS_I2CAttachDevice(display, width, height, address, RST_pin, backlight_pin);
+
+            ESP_LOGI(TAG, "Display is I2C on port %u", address);
+        } else if(sys_display->which_dispType == sys_display_config_spi_tag && spi_system_host != -1) {
+            int CS_pin = -1, speed = 0, mode = 0;
+            CS_pin = sys_display->dispType.spi.cs;
+            speed = sys_display->dispType.spi.speed;
+            mode = sys_display->dispType.spi.mode;
+
+            init = true;
+            GDS_SPIInit(spi_system_host, spi_system_dc_gpio);
+            GDS_SPIAttachDevice(display, width, height, CS_pin, RST_pin, backlight_pin, speed, mode);
+
+            ESP_LOGI(TAG, "Display is SPI host %u with cs:%d", spi_system_host, CS_pin);
+        } else {
+            display = NULL;
+            ESP_LOGI(TAG, "Unsupported display interface or serial link not configured");
+        }
+    }
+
+    if(init) {
+        static DRAM_ATTR StaticTask_t xTaskBuffer __attribute__((aligned(4)));
+        static EXT_RAM_ATTR StackType_t xStack[DISPLAYER_STACK_SIZE] __attribute__((aligned(4)));
+        struct GDS_Layout Layout = {.HFlip = platform->dev.display.common.HFlip,
+            .VFlip = platform->dev.display.common.VFlip,
+            .Rotate = platform->dev.display.common.rotate,
+            .Invert = platform->dev.display.common.invert,
+            .ColorSwap = platform->dev.display.common.colow_swap};
+
+        GDS_SetLayout(display, &Layout);
+        GDS_SetFont(display, Font_line_2);
+        GDS_TextPos(display, GDS_FONT_DEFAULT, GDS_TEXT_CENTERED, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, welcome);
+
+        // start the task that will handle scrolling & counting
+        displayer.mutex = xSemaphoreCreateMutex();
+        displayer.by = 2;
+        displayer.pause = 3600;
+        displayer.speed = 33;
+        displayer.task = xTaskCreateStatic(
+            (TaskFunction_t)displayer_task, "common_displayer", DISPLAYER_STACK_SIZE, NULL, ESP_TASK_PRIO_MIN + 1, xStack, &xTaskBuffer);
+
+        // set lines for "fixed" text mode
+        GDS_TextSetFontAuto(display, 1, GDS_FONT_LINE_1, -3);
+        GDS_TextSetFontAuto(display, 2, GDS_FONT_LINE_2, -3);
+
+        if(platform->has_services && platform->services.has_metadata) {
+            displayer.metadata_config = &platform->services.metadata;
+
+            // leave room for artwork is display is horizontal-style
+            if(displayer.metadata_config->has_artwork && displayer.metadata_config->artwork.enabled) {
+#pragma message("todo: check for resize flag and possibly offsets?")
+                displayer.artwork.enable = true;
+                displayer.artwork.fit = true;
+                if(height <= 64 && width > height * 2) displayer.artwork.offset = width - height - ARTWORK_BORDER;
+            }
+        }
+
+        // and finally register ourselves to power off upon deep sleep
+        services_sleep_setsuspend(display_sleep);
+    }
 }
 
+/****************************************************************************************
+ * 
+ */
+static void display_sleep(void) { GDS_DisplayOff(display); }
+
 /****************************************************************************************
  * This is not thread-safe as displayer_task might be in the middle of line drawing
  * but it won't crash (I think) and making it thread-safe would be complicated for a
  * feature which is secondary (the LMS version of scrolling is thread-safe)
  */
-static void displayer_task(void *args) {
-	int scroll_sleep = 0, timer_sleep;
-		
-	while (1) {
-		// suspend ourselves if nothing to do
-		if (displayer.state < DISPLAYER_ACTIVE) {
-			if (displayer.state == DISPLAYER_IDLE) GDS_TextLine(display, 2, 0, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.string);
-			vTaskSuspend(NULL);
-			scroll_sleep = 0;
-			GDS_ClearExt(display, true);
-			GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_UPDATE, displayer.header);
-		} else if (displayer.refresh) {
-			// little trick when switching master while in IDLE and missing it
-			GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.header);	
-			displayer.refresh = false;			
-		}
-		
-		// we have been waken up before our requested time
-		if (scroll_sleep <= 10) {
-			// something to scroll (or we'll wake-up every pause ms ... no big deal)
-			if (*displayer.string && displayer.state == DISPLAYER_ACTIVE) {
-				xSemaphoreTake(displayer.mutex, portMAX_DELAY);
-				
-				// need to work with local copies as we don't want to suspend caller
-				int offset = -displayer.offset;
-				char *string = strdup(displayer.string);
-				scroll_sleep = displayer.offset ? displayer.speed : displayer.pause;
-				displayer.offset = displayer.offset >= displayer.boundary ? 0 : (displayer.offset + min(displayer.by, displayer.boundary - displayer.offset));			
-				
-				xSemaphoreGive(displayer.mutex);				
-				
-				// now display using safe copies, can be lengthy
-				GDS_TextLine(display, 2, offset, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, string);
-				free(string);
-			} else {
-				scroll_sleep = DEFAULT_SLEEP;
-			}	
-		}	
-		
-		// handler elapsed track time
-		if (displayer.timer && displayer.state == DISPLAYER_ACTIVE) {
-			char counter[16];
-			TickType_t tick = xTaskGetTickCount();
-			uint32_t elapsed = (tick - displayer.tick) * portTICK_PERIOD_MS;
-			
-			if (elapsed >= 1000) {
-				xSemaphoreTake(displayer.mutex, portMAX_DELAY);
-				displayer.tick = tick;
-				displayer.elapsed += elapsed / 1000;
-				xSemaphoreGive(displayer.mutex);				
-				if (displayer.elapsed < 3600) snprintf(counter, 16, "%5u:%02u", displayer.elapsed / 60, displayer.elapsed % 60);
-				else snprintf(counter, 16, "%2u:%02u:%02u", displayer.elapsed / 3600, (displayer.elapsed % 3600) / 60, displayer.elapsed % 60);
-				GDS_TextLine(display, 1, GDS_TEXT_RIGHT, (GDS_TEXT_CLEAR | GDS_TEXT_CLEAR_EOL) | GDS_TEXT_UPDATE, counter);
-				timer_sleep = 1000;
-			} else timer_sleep = max(1000 - elapsed, 0);	
-		} else timer_sleep = DEFAULT_SLEEP;
-		
-		// then sleep the min amount of time
-		int sleep = min(scroll_sleep, timer_sleep);
-		ESP_LOGD(TAG, "timers s:%d t:%d", scroll_sleep, timer_sleep);
-		scroll_sleep -= sleep;
-		vTaskDelay(sleep / portTICK_PERIOD_MS);
-	}
-}	
+static void displayer_task(void* args) {
+    int scroll_sleep = 0, timer_sleep;
+
+    while(1) {
+        // suspend ourselves if nothing to do
+        if(displayer.state < DISPLAYER_ACTIVE) {
+            if(displayer.state == DISPLAYER_IDLE) GDS_TextLine(display, 2, 0, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.string);
+            vTaskSuspend(NULL);
+            scroll_sleep = 0;
+            GDS_ClearExt(display, true);
+            GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_UPDATE, displayer.header);
+        } else if(displayer.refresh) {
+            // little trick when switching master while in IDLE and missing it
+            GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, displayer.header);
+            displayer.refresh = false;
+        }
+
+        // we have been waken up before our requested time
+        if(scroll_sleep <= 10) {
+            // something to scroll (or we'll wake-up every pause ms ... no big deal)
+            if(*displayer.string && displayer.state == DISPLAYER_ACTIVE) {
+                xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+
+                // need to work with local copies as we don't want to suspend caller
+                int offset = -displayer.offset;
+                char* string = strdup(displayer.string);
+                scroll_sleep = displayer.offset ? displayer.speed : displayer.pause;
+                displayer.offset =
+                    displayer.offset >= displayer.boundary ? 0 : (displayer.offset + min(displayer.by, displayer.boundary - displayer.offset));
+
+                xSemaphoreGive(displayer.mutex);
+
+                // now display using safe copies, can be lengthy
+                GDS_TextLine(display, 2, offset, GDS_TEXT_CLEAR | GDS_TEXT_UPDATE, string);
+                free(string);
+            } else {
+                scroll_sleep = DEFAULT_SLEEP;
+            }
+        }
+
+        // handler elapsed track time
+        if(displayer.timer && displayer.state == DISPLAYER_ACTIVE) {
+            char line[19] = "-", *_line = line + 1; // [-]H:MM:SS / H:MM:SS
+            TickType_t tick = xTaskGetTickCount();
+            uint32_t elapsed = (tick - displayer.tick) * portTICK_PERIOD_MS;
+
+            if(elapsed >= 1000) {
+                xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+                displayer.tick = tick;
+                elapsed = displayer.elapsed += elapsed / 1000;
+                xSemaphoreGive(displayer.mutex);
+
+                // when we have duration but no space, display remaining time
+                if(displayer.duration.value && !displayer.duration.visible) elapsed = displayer.duration.value - elapsed;
+
+                if(elapsed < 3600)
+                    sprintf(_line, "%lu:%02lu", (unsigned long)(elapsed / 60), (unsigned long)(elapsed % 60));
+                else
+                    sprintf(_line, "%lu:%02lu:%02lu", (unsigned long)((elapsed / 3600) % 100), (unsigned long)((elapsed % 3600) / 60),
+                        (unsigned long)(elapsed % 60));
+
+                // concatenate if we have room for elapsed / duration
+                if(displayer.duration.visible) {
+                    strcat(_line, "/");
+                    strcat(_line, displayer.duration.string);
+                } else if(displayer.duration.value) {
+                    _line--;
+                }
+
+                // just re-write the whole line it's easier
+                GDS_TextLine(display, 1, GDS_TEXT_LEFT, GDS_TEXT_CLEAR, displayer.header);
+                GDS_TextLine(display, 1, GDS_TEXT_RIGHT, GDS_TEXT_UPDATE, _line);
+
+                // if we have not received artwork after 5s, display a default icon
+                if(displayer.artwork.active && !displayer.artwork.updated && tick - displayer.artwork.tick > pdMS_TO_TICKS(5000)) {
+                    ESP_LOGI(TAG, "no artwork received, setting default");
+                    displayer_artwork((uint8_t*)default_artwork);
+                }
+                timer_sleep = 1000;
+            } else
+                timer_sleep = max(1000 - elapsed, 0);
+        } else
+            timer_sleep = DEFAULT_SLEEP;
+
+        // then sleep the min amount of time
+        int sleep = min(scroll_sleep, timer_sleep);
+        ESP_LOGD(TAG, "timers s:%d t:%d", scroll_sleep, timer_sleep);
+        scroll_sleep -= sleep;
+        vTaskDelay(sleep / portTICK_PERIOD_MS);
+    }
+}
 
 /****************************************************************************************
  * 
  */
-void displayer_metadata(char *artist, char *album, char *title) {
-	char *string = displayer.string, *p;
-	int len = SCROLLABLE_SIZE;
-	
-	// need a display!
-	if (!display) return;
-	
-	// just do title if there is no config set
-	if (!displayer.metadata_config) {
-		strncpy(displayer.string, title ? title : "", SCROLLABLE_SIZE);
-		return;
-	}
-	
-	xSemaphoreTake(displayer.mutex, portMAX_DELAY);
-	
-	// format metadata parameters and write them directly
-	if ((p = strcasestr(displayer.metadata_config, "format")) != NULL) {
-		char token[16], *q;
-		int space = len;
-		bool skip = false;
-			
-		displayer.string[0] = '\0';	
-		p = strchr(displayer.metadata_config, '=');
-			
-		while (p++) {
-			// find token and copy what's after when reaching last one
-			if (sscanf(p, "%*[^%%]%%%[^%]%%", token) < 0) {
-				q = strchr(p, ',');
-				strncat(string, p, q ? min(q - p, space) : space);
-				break;
-			}
+void displayer_artwork(uint8_t* data) {
+    if(!displayer.artwork.active) return;
 
-			// copy what's before token (be safe)
-			if ((q = strchr(p, '%')) == NULL) break;
-			
-			// skip whatever is after a token if this token is empty
-			if (!skip) {
-				strncat(string, p, min(q - p, space));
-				space = len - strlen(string);
-			}	
+    int x = displayer.artwork.offset ? displayer.artwork.offset + ARTWORK_BORDER : 0;
+    int y = x ? 0 : 32;
+    GDS_ClearWindow(display, x, y, -1, -1, GDS_COLOR_BLACK);
+    if(data) {
+        displayer.artwork.updated = true;
+        GDS_DrawJPEG(display, data, x, y, GDS_IMAGE_CENTER | (displayer.artwork.fit ? GDS_IMAGE_FIT : 0));
+    } else {
+        displayer.artwork.updated = false;
+        displayer.artwork.tick = xTaskGetTickCount();
+    }
+}
 
-			// then copy token's content
-			if (!strncasecmp(q + 1, "artist", 6) && artist) strncat(string, p = artist, space);
-			else if (!strncasecmp(q + 1, "album", 5) && album) strncat(string, p = album, space);
-			else if (!strncasecmp(q + 1, "title", 5) && title) strncat(string, p = title, space);
-			space = len - strlen(string);
-				
-			// flag to skip the data following an empty field
-			if (*p) skip = false;
-			else skip = true;
+/****************************************************************************************
+ * 
+ */
+bool displayer_can_artwork(void) { return displayer.artwork.active; }
 
-			// advance to next separator
-			p = strchr(q + 1, '%');
-		}
-	} else {
-		strncpy(string, title ? title : "", SCROLLABLE_SIZE);
-	}
-	
-	// get optional scroll speed & pause
-	if ((p = strcasestr(displayer.metadata_config, "speed")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.speed);
-	if ((p = strcasestr(displayer.metadata_config, "pause")) != NULL) sscanf(p, "%*[^=]=%d", &displayer.pause);
-	
-	displayer.offset = 0;	
-	utf8_decode(displayer.string);
-	ESP_LOGI(TAG, "playing %s", displayer.string);
-	displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
-		
-	xSemaphoreGive(displayer.mutex);
-}	
+/****************************************************************************************
+ * 
+ */
+void displayer_metadata(char* artist, char* album, char* title) {
+    char *string = displayer.string, *p;
+    int len = SCROLLABLE_SIZE;
+
+    // need a display!
+    if(!display) return;
+
+    // just do title if there is no config set
+    if(!displayer.metadata_config) {
+        strncpy(displayer.string, title ? title : "", SCROLLABLE_SIZE);
+        return;
+    }
+
+    xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+
+    // format metadata parameters and write them directly
+    if(strlen(displayer.metadata_config->format) > 0) {
+        char token[16], *q;
+        int space = len;
+        bool skip = false;
+
+        displayer.string[0] = '\0';
+        p = strchr(displayer.metadata_config->format, '=');
+
+        while(p++) {
+            // find token and copy what's after when reaching last one
+            if(sscanf(p, "%*[^%%]%%%[^%]%%", token) < 0) {
+                q = strchr(p, ',');
+                strncat(string, p, q ? min(q - p, space) : space);
+                break;
+            }
+
+            // copy what's before token (be safe)
+            if((q = strchr(p, '%')) == NULL) break;
+
+            // skip whatever is after a token if this token is empty
+            if(!skip) {
+                strncat(string, p, min(q - p, space));
+                space = len - strlen(string);
+            }
+
+            // then copy token's content
+            if(!strncasecmp(q + 1, "artist", 6) && artist)
+                strncat(string, p = artist, space);
+            else if(!strncasecmp(q + 1, "album", 5) && album)
+                strncat(string, p = album, space);
+            else if(!strncasecmp(q + 1, "title", 5) && title)
+                strncat(string, p = title, space);
+            space = len - strlen(string);
+
+            // flag to skip the data following an empty field
+            if(*p)
+                skip = false;
+            else
+                skip = true;
+
+            // advance to next separator
+            p = strchr(q + 1, '%');
+        }
+    } else {
+        strncpy(string, title ? title : "", SCROLLABLE_SIZE);
+    }
+    if(displayer.metadata_config->speed <= 0) displayer.metadata_config->speed = displayer.speed;
+    if(displayer.metadata_config->pause <= 0) displayer.metadata_config->pause = displayer.pause;
+    displayer.metadata_config->speed = displayer.speed;
+    displayer.offset = 0;
+    utf8_decode(displayer.string);
+    ESP_LOGI(TAG, "playing %s", displayer.string);
+    displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
+
+    xSemaphoreGive(displayer.mutex);
+}
 
 /****************************************************************************************
  *
  */
-void displayer_scroll(char *string, int speed, int pause) {
-	// need a display!
-	if (!display) return;
-	
-	xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+void displayer_scroll(char* string, int speed, int pause) {
+    // need a display!
+    if(!display) return;
 
-	if (speed) displayer.speed = speed;
-	if (pause) displayer.pause = pause;
-	displayer.offset = 0;	
-	strncpy(displayer.string, string, SCROLLABLE_SIZE);
-	displayer.string[SCROLLABLE_SIZE] = '\0';
-	displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
-		
-	xSemaphoreGive(displayer.mutex);
+    xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+
+    if(speed) displayer.speed = speed;
+    if(pause) displayer.pause = pause;
+    displayer.offset = 0;
+    strncpy(displayer.string, string, SCROLLABLE_SIZE);
+    displayer.string[SCROLLABLE_SIZE] = '\0';
+    displayer.boundary = GDS_TextStretch(display, 2, displayer.string, SCROLLABLE_SIZE);
+
+    xSemaphoreGive(displayer.mutex);
 }
 
 /****************************************************************************************
  * 
  */
 void displayer_timer(enum displayer_time_e mode, int elapsed, int duration) {
-	// need a display!
-	if (!display) return;
-	
-	xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+    // need a display!
+    if(!display) return;
 
-	if (elapsed >= 0) displayer.elapsed = elapsed / 1000;	
-	if (duration >= 0) displayer.duration = duration / 1000;
-	if (displayer.timer) displayer.tick = xTaskGetTickCount();
-		
-	xSemaphoreGive(displayer.mutex);
-}	
+    xSemaphoreTake(displayer.mutex, portMAX_DELAY);
+
+    if(displayer.timer) displayer.tick = xTaskGetTickCount();
+    if(elapsed >= 0) displayer.elapsed = elapsed / 1000;
+    if(duration > 0) {
+        displayer.duration.visible = true;
+        displayer.duration.value = duration / 1000;
+
+        if(displayer.duration.value > 3600)
+            sprintf(displayer.duration.string, "%lu:%02lu:%02lu", (unsigned long)((displayer.duration.value / 3600) % 10),
+                (unsigned long)((displayer.duration.value % 3600) / 60), (unsigned long)(displayer.duration.value % 60));
+        else
+            sprintf(displayer.duration.string, "%lu:%02lu", (unsigned long)(displayer.duration.value / 60),
+                (unsigned long)(displayer.duration.value % 60));
+
+        char* buf;
+        asprintf(&buf, "%s %s/%s", displayer.header, displayer.duration.string, displayer.duration.string);
+        if(GDS_GetTextWidth(display, 1, 0, buf) > GDS_GetWidth(display)) {
+            ESP_LOGW(TAG, "Can't fit duration %s (%d) on screen using elapsed only", buf, GDS_GetTextWidth(display, 1, 0, buf));
+            displayer.duration.visible = false;
+        }
+        free(buf);
+    } else if(!duration) {
+        displayer.duration.visible = false;
+        displayer.duration.value = 0;
+    }
+
+    xSemaphoreGive(displayer.mutex);
+}
 
 /****************************************************************************************
  * See above comment
  */
 void displayer_control(enum displayer_cmd_e cmd, ...) {
-	va_list args;
-	
-	if (!display) return;
-	
-	va_start(args, cmd);
-	xSemaphoreTake(displayer.mutex, portMAX_DELAY);
-		
-	switch(cmd) {
-	case DISPLAYER_ACTIVATE: {	
-		char *header = va_arg(args, char*);
-		strncpy(displayer.header, header, HEADER_SIZE);
-		displayer.header[HEADER_SIZE] = '\0';
-		displayer.state = DISPLAYER_ACTIVE;
-		displayer.timer = false;
-		displayer.refresh = true;
-		displayer.string[0] = '\0';
-		displayer.elapsed = displayer.duration = 0;
-		displayer.offset = displayer.boundary = 0;
-		display_bus(&displayer, DISPLAY_BUS_TAKE);
-		vTaskResume(displayer.task);
-		break;
-	}	
-	case DISPLAYER_SUSPEND:		
-		// task will display the line 2 from beginning and suspend
-		displayer.state = DISPLAYER_IDLE;
-		display_bus(&displayer, DISPLAY_BUS_GIVE);
-		break;		
-	case DISPLAYER_SHUTDOWN:
-		// let the task self-suspend (we might be doing i2c_write)
-		displayer.state = DISPLAYER_DOWN;
-		display_bus(&displayer, DISPLAY_BUS_GIVE);
-		break;
-	case DISPLAYER_TIMER_RUN:
-		if (!displayer.timer) {
-			display_bus(&displayer, DISPLAY_BUS_TAKE);
-			displayer.timer = true;		
-			displayer.tick = xTaskGetTickCount();		
-		}	
-		break;
-	case DISPLAYER_TIMER_PAUSE:
-		displayer.timer = false;
-		break;
-	default:
-		break;
-	}	
-	
-	xSemaphoreGive(displayer.mutex);
-	va_end(args);
-}
+    va_list args;
 
-/****************************************************************************************
- *
- */
-bool display_is_valid_driver(const char * driver){
-	return display_conf_get_driver_name(driver)!=NULL;
-}
+    if(!display) return;
 
-/****************************************************************************************
- *
- */
-const char *display_conf_get_driver_name(const char * driver){
-	for(uint8_t i=0;known_drivers[i]!=NULL && strlen(known_drivers[i])>0;i++ ){
-		if(strcasestr(driver,known_drivers[i])){
-			return known_drivers[i];
-		}
-	}
-	return NULL;
-}
+    va_start(args, cmd);
+    xSemaphoreTake(displayer.mutex, portMAX_DELAY);
 
-/****************************************************************************************
- *
- */
-char * display_get_supported_drivers(void){
-	int total_size = 1;
-	char * supported_drivers=NULL;
-	const char * separator = "|";
-	int separator_len = strlen(separator);
+    switch(cmd) {
+    case DISPLAYER_ACTIVATE: {
+        char* header = va_arg(args, char*);
+        displayer.artwork.active = displayer.artwork.enable && va_arg(args, int);
+        strncpy(displayer.header, header, HEADER_SIZE);
+        displayer.header[HEADER_SIZE] = '\0';
+        displayer.state = DISPLAYER_ACTIVE;
+        displayer.timer = false;
+        displayer.refresh = true;
+        displayer.string[0] = '\0';
+        displayer.elapsed = displayer.duration.value = 0;
+        displayer.duration.visible = false;
+        displayer.offset = displayer.boundary = 0;
+        display_bus(&displayer, DISPLAY_BUS_TAKE);
+        if(displayer.artwork.active) GDS_SetTextWidth(display, displayer.artwork.offset);
+        vTaskResume(displayer.task);
+        break;
+    }
+    case DISPLAYER_SUSPEND:
+        // task will display the line 2 from beginning and suspend
+        displayer.state = DISPLAYER_IDLE;
+        displayer_artwork(NULL);
+        display_bus(&displayer, DISPLAY_BUS_GIVE);
+        break;
+    case DISPLAYER_SHUTDOWN:
+        // let the task self-suspend (we might be doing i2c_write)
+        GDS_SetTextWidth(display, 0);
+        displayer_artwork(NULL);
+        displayer.state = DISPLAYER_DOWN;
+        display_bus(&displayer, DISPLAY_BUS_GIVE);
+        break;
+    case DISPLAYER_TIMER_RUN:
+        if(!displayer.timer) {
+            display_bus(&displayer, DISPLAY_BUS_TAKE);
+            displayer.timer = true;
+            displayer.tick = xTaskGetTickCount();
+        }
+        break;
+    case DISPLAYER_TIMER_PAUSE:
+        displayer.timer = false;
+        break;
+    default:
+        break;
+    }
 
-	for(uint8_t i=0;known_drivers[i]!=NULL && strlen(known_drivers[i])>0;i++ ){
-		total_size += strlen(known_drivers[i])+separator_len;
-	}
-	total_size+=2;
-	supported_drivers = malloc(total_size);
-	memset(supported_drivers,0x00,total_size);
-	strcat(supported_drivers,"<");
-	for(uint8_t i=0;known_drivers[i]!=NULL && strlen(known_drivers[i])>0;i++ ){
-		supported_drivers = strcat(supported_drivers,known_drivers[i]);
-		supported_drivers = strcat(supported_drivers,separator);
-	}
-	strcat(supported_drivers,">");
-	return supported_drivers;
+    xSemaphoreGive(displayer.mutex);
+    va_end(args);
 }

components/display/display.h

@@ -10,7 +10,6 @@
 
 #include "gds.h"
 
-
 /* 
  The displayer is not thread-safe and the caller must ensure use its own 
  mutexes if it wants something better. Especially, text() line() and draw()
@@ -24,19 +23,18 @@
  The display_bus() shall be subscribed by other displayers so that at least
  when this one (the main) wants to take control over display, it can signal
  that to others
-*/ 
-extern struct GDS_Device *display;
-  
-enum displayer_cmd_e 	{ DISPLAYER_SHUTDOWN, DISPLAYER_ACTIVATE, DISPLAYER_SUSPEND, DISPLAYER_TIMER_PAUSE, DISPLAYER_TIMER_RUN };
-enum displayer_time_e 	{ DISPLAYER_ELAPSED, DISPLAYER_REMAINING };
+*/
+extern struct GDS_Device* display;
+
+enum displayer_cmd_e { DISPLAYER_SHUTDOWN, DISPLAYER_ACTIVATE, DISPLAYER_SUSPEND, DISPLAYER_TIMER_PAUSE, DISPLAYER_TIMER_RUN };
+enum displayer_time_e { DISPLAYER_ELAPSED, DISPLAYER_REMAINING };
 
 enum display_bus_cmd_e { DISPLAY_BUS_TAKE, DISPLAY_BUS_GIVE };
-bool (*display_bus)(void *from, enum display_bus_cmd_e cmd);
-const char *display_conf_get_driver_name(const char * driver);
-bool display_is_valid_driver(const char * driver);
+extern bool (*display_bus)(void* from, enum display_bus_cmd_e cmd);
 
-void displayer_scroll(char *string, int speed, int pause);
+void displayer_scroll(char* string, int speed, int pause);
 void displayer_control(enum displayer_cmd_e cmd, ...);
-void displayer_metadata(char *artist, char *album, char *title);
+void displayer_metadata(char* artist, char* album, char* title);
+void displayer_artwork(uint8_t* data);
 void displayer_timer(enum displayer_time_e mode, int elapsed, int duration);
-char * display_get_supported_drivers(void);
+bool displayer_can_artwork(void);

components/display/fonts/LICENSE-liberation-mono

@@ -1,102 +0,0 @@
-Digitized data copyright (c) 2010 Google Corporation
-	with Reserved Font Arimo, Tinos and Cousine.
-Copyright (c) 2012 Red Hat, Inc.
-	with Reserved Font Name Liberation.
-
-This Font Software is licensed under the SIL Open Font License,
-Version 1.1.
-
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-
-PREAMBLE The goals of the Open Font License (OFL) are to stimulate
-worldwide development of collaborative font projects, to support the font
-creation efforts of academic and linguistic communities, and to provide
-a free and open framework in which fonts may be shared and improved in
-partnership with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves.
-The fonts, including any derivative works, can be bundled, embedded,
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works.  The fonts and derivatives,
-however, cannot be released under any other type of license.  The
-requirement for fonts to remain under this license does not apply to
-any document created using the fonts or their derivatives.
-
- 
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such.
-This may include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components
-as distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting ? in part or in whole ?
-any of the components of the Original Version, by changing formats or
-by porting the Font Software to a new environment.
-
-"Author" refers to any designer, engineer, programmer, technical writer
-or other person who contributed to the Font Software.
-
-
-PERMISSION & CONDITIONS
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,in
-   Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-   redistributed and/or sold with any software, provided that each copy
-   contains the above copyright notice and this license. These can be
-   included either as stand-alone text files, human-readable headers or
-   in the appropriate machine-readable metadata fields within text or
-   binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-   Name(s) unless explicit written permission is granted by the
-   corresponding Copyright Holder. This restriction only applies to the
-   primary font name as presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-   Software shall not be used to promote, endorse or advertise any
-   Modified Version, except to acknowledge the contribution(s) of the
-   Copyright Holder(s) and the Author(s) or with their explicit written
-   permission.
-
-5) The Font Software, modified or unmodified, in part or in whole, must
-   be distributed entirely under this license, and must not be distributed
-   under any other license. The requirement for fonts to remain under
-   this license does not apply to any document created using the Font
-   Software.
-
-
- 
-TERMINATION
-This license becomes null and void if any of the above conditions are not met.
-
- 
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.  IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
-DEALINGS IN THE FONT SOFTWARE.
-

components/display/fonts/font_droid_sans_fallback_11x13.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011 
-//http://www.mikroe.com 
-
-//GLCD FontName : Droid_Sans_Fallback11x13
-//GLCD FontSize : 11 x 13
-
-static const uint8_t Droid_Sans_Fallback11x13[ ] = {
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x02, 0x00, 0x00, 0xFC, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x05, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x07, 0x00, 0x00, 0x10, 0x01, 0xFC, 0x07, 0x10, 0x01, 0x10, 0x01, 0xFC, 0x07, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x06, 0x00, 0x00, 0x30, 0x02, 0x48, 0x04, 0xFC, 0x0F, 0x88, 0x04, 0x10, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x08, 0x00, 0x00, 0x08, 0x02, 0x14, 0x01, 0x94, 0x00, 0x48, 0x02, 0x20, 0x05, 0x10, 0x05, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char %
-    0x06, 0x00, 0x00, 0x98, 0x03, 0x64, 0x04, 0x98, 0x04, 0x00, 0x03, 0x80, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x02, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x03, 0x00, 0x00, 0xF8, 0x0F, 0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x03, 0x00, 0x00, 0x04, 0x10, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x04, 0x00, 0x00, 0x14, 0x00, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x06, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0xE0, 0x03, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x03, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x05, 0x00, 0x00, 0x00, 0x06, 0x80, 0x01, 0x60, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x06, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x04, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x06, 0x00, 0x00, 0x08, 0x06, 0x04, 0x05, 0x84, 0x04, 0x44, 0x04, 0x38, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x06, 0x00, 0x00, 0x08, 0x02, 0x04, 0x04, 0x44, 0x04, 0x44, 0x04, 0xB8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x06, 0x00, 0x00, 0x80, 0x01, 0x60, 0x01, 0x18, 0x01, 0xFC, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x06, 0x00, 0x00, 0x7C, 0x02, 0x24, 0x04, 0x24, 0x04, 0x24, 0x04, 0xC4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x06, 0x00, 0x00, 0xF8, 0x03, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x88, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x04, 0x07, 0xC4, 0x00, 0x34, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x06, 0x00, 0x00, 0xB8, 0x03, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0xB8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x06, 0x00, 0x00, 0x38, 0x02, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x02, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x03, 0x00, 0x00, 0x00, 0x08, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x05, 0x00, 0x00, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x06, 0x00, 0x00, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x05, 0x00, 0x00, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x06, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x84, 0x05, 0x44, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x0B, 0x00, 0x00, 0xE0, 0x01, 0x18, 0x06, 0x08, 0x04, 0xC4, 0x08, 0x24, 0x09, 0x24, 0x09, 0xE4, 0x08, 0x08, 0x09, 0x18, 0x01, 0xE0, 0x01, // Code for char @
-    0x07, 0x00, 0x06, 0xC0, 0x01, 0x30, 0x01, 0x0C, 0x01, 0x30, 0x01, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char A
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0xB8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x02, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x04, 0x44, 0x04, 0x44, 0x02, 0xC8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x02, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x04, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x04, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char K
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x30, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x30, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x18, 0x00, 0x60, 0x00, 0x80, 0x00, 0x00, 0x03, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x04, 0x06, 0xF8, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0xB8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x06, 0x00, 0x00, 0x38, 0x02, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x88, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0xFC, 0x07, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x07, 0x0C, 0x00, 0x70, 0x00, 0x80, 0x01, 0x00, 0x06, 0x80, 0x01, 0x70, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char V
-    0x0B, 0x0C, 0x00, 0x70, 0x00, 0x80, 0x01, 0x00, 0x06, 0x80, 0x01, 0x70, 0x00, 0x80, 0x01, 0x00, 0x06, 0x80, 0x01, 0x70, 0x00, 0x0C, 0x00, // Code for char W
-    0x07, 0x0C, 0x06, 0x10, 0x01, 0xA0, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x07, 0x0C, 0x00, 0x10, 0x00, 0x20, 0x00, 0xC0, 0x07, 0x20, 0x00, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x07, 0x04, 0x06, 0x04, 0x05, 0x84, 0x04, 0x44, 0x04, 0x24, 0x04, 0x14, 0x04, 0x0C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x03, 0x00, 0x00, 0xFC, 0x1F, 0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x05, 0x00, 0x00, 0x1C, 0x00, 0x60, 0x00, 0x80, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x03, 0x00, 0x00, 0x04, 0x10, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x06, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x06, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char _
-    0x03, 0x00, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x03, 0x00, 0x00, 0xF8, 0x07, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x06, 0x00, 0x00, 0xC0, 0x13, 0x20, 0x14, 0x20, 0x14, 0x20, 0x14, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x40, 0x00, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x02, 0x00, 0x00, 0xE4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x02, 0x00, 0x00, 0xE4, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x02, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x08, 0x00, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x07, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x06, 0x00, 0x00, 0xE0, 0x07, 0x40, 0x00, 0x20, 0x00, 0x20, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x06, 0x00, 0x00, 0xE0, 0x1F, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x03, 0x00, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x05, 0x00, 0x00, 0x40, 0x02, 0xA0, 0x04, 0x20, 0x05, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x03, 0x00, 0x00, 0xF8, 0x03, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x06, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x02, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x06, 0x00, 0x00, 0x60, 0x00, 0x80, 0x01, 0x00, 0x06, 0x80, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x08, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x06, 0x80, 0x01, 0x60, 0x00, 0x80, 0x01, 0x00, 0x06, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char w
-    0x05, 0x00, 0x00, 0x60, 0x06, 0x80, 0x01, 0x80, 0x01, 0x60, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x05, 0x00, 0x10, 0xE0, 0x11, 0x00, 0x0E, 0x00, 0x02, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x05, 0x00, 0x00, 0x20, 0x06, 0x20, 0x05, 0xA0, 0x04, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x04, 0x00, 0x00, 0x40, 0x00, 0xBC, 0x07, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x02, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x04, 0x00, 0x00, 0x02, 0x08, 0xBC, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x07, 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0x10, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x03, 0xF8, 0x07, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x02, 0x00, 0x00, 0xD0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x0C, 0x20, 0x04, 0x30, 0x04, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x05, 0x00, 0x00, 0x58, 0x07, 0xE4, 0x04, 0x44, 0x04, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x06, 0x00, 0x00, 0x74, 0x01, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x74, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x06, 0x00, 0x00, 0x5C, 0x01, 0x60, 0x01, 0xC0, 0x07, 0x60, 0x01, 0x5C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x02, 0x00, 0x00, 0x7C, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x06, 0x00, 0x00, 0x68, 0x04, 0x94, 0x08, 0x24, 0x09, 0x44, 0x0A, 0x88, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x03, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x09, 0x00, 0x00, 0x70, 0x00, 0x88, 0x00, 0x24, 0x01, 0x54, 0x01, 0x54, 0x01, 0x04, 0x01, 0x88, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ©
-    0x04, 0x00, 0x00, 0xB4, 0x00, 0xAC, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x06, 0x00, 0x00, 0x00, 0x01, 0x80, 0x02, 0x40, 0x05, 0x80, 0x02, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x06, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x03, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x08, 0x00, 0x00, 0x70, 0x00, 0x88, 0x00, 0x74, 0x01, 0x34, 0x01, 0x54, 0x01, 0x88, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ®
-    0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¯
-    0x04, 0x00, 0x00, 0x08, 0x00, 0x14, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x06, 0x00, 0x00, 0x40, 0x04, 0x40, 0x04, 0xF0, 0x05, 0x40, 0x04, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x03, 0x64, 0x00, 0x54, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x03, 0x44, 0x00, 0x54, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x03, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x06, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x04, 0x00, 0x04, 0xE0, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x06, 0x00, 0x00, 0x38, 0x00, 0x7C, 0x00, 0xFC, 0x0F, 0x04, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x02, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x03, 0x00, 0x00, 0x08, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x04, 0x00, 0x00, 0xBC, 0x00, 0xA4, 0x00, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x06, 0x00, 0x00, 0x40, 0x04, 0x80, 0x02, 0x40, 0x05, 0x80, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x08, 0x00, 0x00, 0x08, 0x02, 0x7C, 0x01, 0x80, 0x00, 0x40, 0x00, 0x20, 0x03, 0x90, 0x02, 0xC8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¼
-    0x08, 0x00, 0x00, 0x08, 0x02, 0x7C, 0x01, 0x80, 0x00, 0x40, 0x00, 0x60, 0x06, 0x50, 0x05, 0x88, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ½
-    0x08, 0x00, 0x00, 0x44, 0x02, 0x54, 0x01, 0xA8, 0x00, 0x40, 0x00, 0x20, 0x03, 0x90, 0x02, 0xC8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¾
-    0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x11, 0xD0, 0x10, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x07, 0x00, 0x06, 0xC0, 0x01, 0x31, 0x01, 0x0E, 0x01, 0x30, 0x01, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char À
-    0x07, 0x00, 0x06, 0xC0, 0x01, 0x30, 0x01, 0x0E, 0x01, 0x31, 0x01, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Á
-    0x07, 0x00, 0x06, 0xC0, 0x01, 0x34, 0x01, 0x0A, 0x01, 0x34, 0x01, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Â
-    0x07, 0x00, 0x06, 0xC2, 0x01, 0x31, 0x01, 0x0F, 0x01, 0x32, 0x01, 0xC1, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ã
-    0x07, 0x00, 0x06, 0xC2, 0x01, 0x30, 0x01, 0x0C, 0x01, 0x30, 0x01, 0xC2, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ä
-    0x07, 0x00, 0x06, 0xC0, 0x01, 0x32, 0x01, 0x0D, 0x01, 0x32, 0x01, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Å
-    0x09, 0x00, 0x06, 0xC0, 0x01, 0xB0, 0x00, 0x8C, 0x00, 0xFC, 0x07, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, // Code for char Æ
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x04, 0x14, 0x04, 0x1C, 0x04, 0x04, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x45, 0x04, 0x46, 0x04, 0x44, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char È
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x44, 0x04, 0x46, 0x04, 0x45, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char É
-    0x06, 0x00, 0x00, 0xFC, 0x07, 0x46, 0x04, 0x45, 0x04, 0x46, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ê
-    0x06, 0x00, 0x00, 0xFE, 0x07, 0x44, 0x04, 0x44, 0x04, 0x44, 0x04, 0x06, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ë
-    0x02, 0x02, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x03, 0x00, 0x00, 0xFC, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x03, 0x04, 0x00, 0xFA, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x03, 0x02, 0x00, 0xFC, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x07, 0x40, 0x00, 0xFC, 0x07, 0x44, 0x04, 0x44, 0x04, 0x04, 0x04, 0x08, 0x02, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x07, 0x00, 0x00, 0xFE, 0x07, 0x19, 0x00, 0x61, 0x00, 0x82, 0x00, 0x02, 0x03, 0xFD, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x05, 0x04, 0x06, 0x04, 0x04, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x06, 0x04, 0x05, 0x04, 0x04, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x06, 0x04, 0x05, 0x04, 0x05, 0x04, 0x06, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x07, 0x00, 0x00, 0xFA, 0x03, 0x05, 0x04, 0x05, 0x04, 0x06, 0x04, 0x06, 0x04, 0xF9, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x07, 0x00, 0x00, 0xF8, 0x03, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x06, 0x00, 0x00, 0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01, 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x07, 0x00, 0x00, 0xF8, 0x07, 0x04, 0x07, 0xC4, 0x04, 0x34, 0x04, 0x0C, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x04, 0x01, 0x04, 0x02, 0x04, 0x00, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x04, 0x02, 0x04, 0x01, 0x04, 0x00, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x02, 0x04, 0x01, 0x04, 0x01, 0x04, 0x02, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x02, 0x04, 0x00, 0x04, 0x00, 0x04, 0x02, 0x04, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x07, 0x0C, 0x00, 0x10, 0x00, 0x20, 0x00, 0xC2, 0x07, 0x21, 0x00, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x07, 0x00, 0x00, 0xFC, 0x07, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x06, 0x00, 0x00, 0xF8, 0x07, 0x04, 0x00, 0x44, 0x04, 0x78, 0x04, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA4, 0x04, 0xA8, 0x04, 0xA0, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA0, 0x04, 0xA8, 0x04, 0xA4, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA8, 0x04, 0xA4, 0x04, 0xA8, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x06, 0x00, 0x00, 0x08, 0x03, 0xA4, 0x04, 0xAC, 0x04, 0xA8, 0x04, 0xC4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA4, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x06, 0x00, 0x00, 0x00, 0x03, 0xA4, 0x04, 0xAA, 0x04, 0xA4, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x0A, 0x00, 0x00, 0x00, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC0, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC0, 0x02, 0x00, 0x00, // Code for char æ
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x14, 0x20, 0x1C, 0x20, 0x04, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0xA4, 0x04, 0xA8, 0x04, 0xA0, 0x04, 0xC0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0xA0, 0x04, 0xA8, 0x04, 0xA4, 0x04, 0xC0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0xA8, 0x04, 0xA4, 0x04, 0xA8, 0x04, 0xC0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x06, 0x00, 0x00, 0xC4, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x02, 0x04, 0x00, 0xE8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x04, 0x00, 0x00, 0x00, 0x00, 0xE8, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x04, 0x00, 0x00, 0x08, 0x00, 0xE4, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char î
-    0x04, 0x00, 0x00, 0x04, 0x00, 0xE0, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x06, 0x00, 0x00, 0x80, 0x03, 0x54, 0x04, 0x48, 0x04, 0x74, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x06, 0x00, 0x00, 0xE8, 0x07, 0x44, 0x00, 0x2C, 0x00, 0x28, 0x00, 0xC4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x24, 0x04, 0x28, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x28, 0x04, 0x24, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x06, 0x00, 0x00, 0xC0, 0x03, 0x28, 0x04, 0x24, 0x04, 0x28, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x06, 0x00, 0x00, 0xC8, 0x03, 0x24, 0x04, 0x2C, 0x04, 0x28, 0x04, 0xC4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x06, 0x00, 0x00, 0xC4, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC4, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x06, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0xA0, 0x02, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x06, 0x00, 0x00, 0xC0, 0x07, 0x20, 0x06, 0xA0, 0x05, 0x60, 0x04, 0xE0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x06, 0x00, 0x00, 0xE0, 0x03, 0x04, 0x04, 0x08, 0x04, 0x00, 0x02, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x06, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x04, 0x08, 0x04, 0x04, 0x02, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x06, 0x00, 0x00, 0xE0, 0x03, 0x08, 0x04, 0x04, 0x04, 0x08, 0x02, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x06, 0x00, 0x00, 0xE4, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x02, 0xE4, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x05, 0x00, 0x10, 0xE0, 0x11, 0x08, 0x0E, 0x04, 0x02, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x06, 0x00, 0x00, 0xFC, 0x1F, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x05, 0x00, 0x10, 0xE4, 0x11, 0x00, 0x0E, 0x00, 0x02, 0xE4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_fallback_11x13 = {
-    Droid_Sans_Fallback11x13,
-    11,
-    13,
-    ' ',
-    '\xFF',
-    false
-};

components/display/fonts/font_droid_sans_fallback_15x17.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011 
-//http://www.mikroe.com 
-
-//GLCD FontName : Droid_Sans_Fallback15x17
-//GLCD FontSize : 15 x 17
-
-static const uint8_t Droid_Sans_Fallback15x17[ ] = {
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x02, 0x00, 0x00, 0x00, 0xF8, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x05, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x08, 0x00, 0x04, 0x00, 0x40, 0x3C, 0x00, 0xC0, 0x07, 0x00, 0x78, 0x04, 0x00, 0x40, 0x3C, 0x00, 0xC0, 0x07, 0x00, 0x78, 0x04, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x07, 0x00, 0x00, 0x00, 0xF0, 0x18, 0x00, 0x08, 0x21, 0x00, 0x08, 0x7F, 0x00, 0xFC, 0x21, 0x00, 0x08, 0x21, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x08, 0x01, 0x00, 0x08, 0x21, 0x00, 0x08, 0x19, 0x00, 0xF0, 0x06, 0x00, 0x00, 0x01, 0x00, 0xC0, 0x1E, 0x00, 0x30, 0x21, 0x00, 0x08, 0x21, 0x00, 0x00, 0x21, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char %
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x70, 0x21, 0x00, 0x88, 0x20, 0x00, 0x88, 0x21, 0x00, 0x88, 0x22, 0x00, 0x70, 0x14, 0x00, 0x00, 0x18, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x02, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x05, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x60, 0x60, 0x00, 0x10, 0x80, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x04, 0x08, 0x00, 0x01, 0x10, 0x80, 0x00, 0x60, 0x60, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x05, 0x10, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x04, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x02, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x04, 0x00, 0x38, 0x00, 0x00, 0x07, 0x00, 0xE0, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x07, 0x00, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x07, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x08, 0x28, 0x00, 0x08, 0x24, 0x00, 0x08, 0x22, 0x00, 0x08, 0x21, 0x00, 0xF0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x07, 0x00, 0x00, 0x00, 0x30, 0x18, 0x00, 0x08, 0x20, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0xF0, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x80, 0x05, 0x00, 0x40, 0x04, 0x00, 0x30, 0x04, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x07, 0x00, 0x00, 0x00, 0xF8, 0x19, 0x00, 0x88, 0x20, 0x00, 0x88, 0x20, 0x00, 0x88, 0x20, 0x00, 0x88, 0x20, 0x00, 0x08, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x07, 0x00, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x08, 0x21, 0x00, 0x88, 0x20, 0x00, 0x88, 0x20, 0x00, 0x88, 0x20, 0x00, 0x30, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x20, 0x00, 0x08, 0x1C, 0x00, 0x08, 0x03, 0x00, 0xC8, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x07, 0x00, 0x00, 0x00, 0xF0, 0x1E, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0xF0, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x07, 0x00, 0x00, 0x00, 0xF0, 0x19, 0x00, 0x08, 0x22, 0x00, 0x08, 0x22, 0x00, 0x08, 0x22, 0x00, 0x08, 0x21, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x02, 0x00, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x40, 0x04, 0x00, 0x40, 0x04, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x08, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x08, 0x00, 0x00, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x40, 0x04, 0x00, 0x40, 0x04, 0x00, 0x80, 0x02, 0x00, 0x80, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x07, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x27, 0x00, 0x88, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0xC0, 0x60, 0x00, 0x20, 0x80, 0x00, 0x10, 0x9E, 0x00, 0x90, 0x21, 0x01, 0x48, 0x20, 0x01, 0x48, 0x20, 0x01, 0x48, 0x10, 0x01, 0x48, 0x3C, 0x01, 0xD0, 0x23, 0x01, 0x10, 0xA0, 0x00, 0x60, 0x10, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x00, // Code for char @
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x60, 0x02, 0x00, 0x18, 0x02, 0x00, 0x60, 0x02, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char A
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x90, 0x12, 0x00, 0x60, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x10, 0x11, 0x00, 0x20, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x02, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0x40, 0x02, 0x00, 0x20, 0x04, 0x00, 0x10, 0x08, 0x00, 0x08, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char K
-    0x08, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x0C, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x20, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x20, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x10, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x24, 0x00, 0x08, 0x28, 0x00, 0x10, 0x10, 0x00, 0x30, 0x38, 0x00, 0xC0, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x90, 0x03, 0x00, 0x60, 0x1C, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x09, 0x00, 0x00, 0x00, 0x60, 0x08, 0x00, 0x90, 0x10, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x10, 0x12, 0x00, 0x20, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x09, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x09, 0x18, 0x00, 0x00, 0x60, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x60, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char V
-    0x0F, 0x38, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x38, 0x00, 0x00, 0x06, 0x00, 0x80, 0x01, 0x00, 0x60, 0x00, 0x00, 0x18, 0x00, 0x00, 0x60, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x38, 0x00, 0x00, 0x06, 0x00, 0xC0, 0x01, 0x00, 0x38, 0x00, 0x00, // Code for char W
-    0x0A, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x20, 0x08, 0x00, 0x40, 0x04, 0x00, 0x80, 0x03, 0x00, 0x80, 0x03, 0x00, 0x40, 0x04, 0x00, 0x20, 0x08, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x09, 0x18, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x30, 0x00, 0x08, 0x28, 0x00, 0x08, 0x26, 0x00, 0x08, 0x21, 0x00, 0xC8, 0x20, 0x00, 0x28, 0x20, 0x00, 0x18, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x04, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x04, 0x18, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x03, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char _
-    0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x07, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x07, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x12, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x12, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x04, 0x40, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x48, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x07, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x40, 0x20, 0x01, 0x40, 0x20, 0x01, 0x40, 0x20, 0x01, 0x80, 0x10, 0x01, 0xC0, 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, // Code for char g
-    0x07, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x02, 0x00, 0x00, 0x00, 0xC8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x02, 0x00, 0x00, 0x01, 0xC8, 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, // Code for char j
-    0x08, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x05, 0x00, 0x80, 0x08, 0x00, 0x40, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x02, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x07, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x05, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x07, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x24, 0x00, 0x40, 0x24, 0x00, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x03, 0x40, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x07, 0xC0, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x03, 0x00, 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, // Code for char v
-    0x0B, 0xC0, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x08, 0x00, 0x00, 0x38, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char w
-    0x07, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x06, 0x00, 0x00, 0x09, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x07, 0xC0, 0x00, 0x01, 0x00, 0x03, 0x01, 0x00, 0x8C, 0x00, 0x00, 0x70, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x03, 0x00, 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, // Code for char y
-    0x07, 0x00, 0x00, 0x00, 0x40, 0x30, 0x00, 0x40, 0x28, 0x00, 0x40, 0x24, 0x00, 0x40, 0x22, 0x00, 0x40, 0x21, 0x00, 0xC0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x05, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0xF0, 0xFD, 0x00, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x05, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xF0, 0xFD, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x08, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x04, 0xF8, 0x3F, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x02, 0x00, 0x00, 0x00, 0x40, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0xD0, 0x00, 0x40, 0x3C, 0x00, 0xC0, 0x23, 0x00, 0xB0, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x07, 0x00, 0x21, 0x00, 0xF0, 0x31, 0x00, 0x08, 0x2F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x30, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x07, 0x00, 0x00, 0x00, 0x40, 0x0B, 0x00, 0x80, 0x04, 0x00, 0x40, 0x08, 0x00, 0x40, 0x08, 0x00, 0x80, 0x04, 0x00, 0x40, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x07, 0x18, 0x05, 0x00, 0x60, 0x05, 0x00, 0x80, 0x05, 0x00, 0x00, 0x3F, 0x00, 0x80, 0x05, 0x00, 0x60, 0x05, 0x00, 0x18, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xF9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x07, 0x00, 0x00, 0x00, 0x70, 0xC7, 0x00, 0x88, 0x08, 0x01, 0x88, 0x08, 0x01, 0x08, 0x11, 0x01, 0x08, 0x11, 0x01, 0x30, 0xEE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x04, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x0B, 0xC0, 0x07, 0x00, 0x20, 0x08, 0x00, 0x10, 0x10, 0x00, 0xC8, 0x27, 0x00, 0x28, 0x28, 0x00, 0x28, 0x28, 0x00, 0x28, 0x28, 0x00, 0x48, 0x24, 0x00, 0x10, 0x10, 0x00, 0x20, 0x08, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ©
-    0x05, 0x00, 0x00, 0x00, 0x40, 0x02, 0x00, 0xA8, 0x02, 0x00, 0xA8, 0x02, 0x00, 0xF0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x09, 0x00, 0x80, 0x10, 0x00, 0x00, 0x06, 0x00, 0x00, 0x09, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x04, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x0B, 0xC0, 0x07, 0x00, 0x20, 0x08, 0x00, 0x10, 0x10, 0x00, 0xE8, 0x2F, 0x00, 0x28, 0x21, 0x00, 0x28, 0x21, 0x00, 0x28, 0x23, 0x00, 0xC8, 0x2C, 0x00, 0x10, 0x10, 0x00, 0x20, 0x08, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ®
-    0x08, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¯
-    0x05, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x48, 0x00, 0x00, 0x48, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x21, 0x00, 0x00, 0x21, 0x00, 0xE0, 0x2F, 0x00, 0x00, 0x21, 0x00, 0x00, 0x21, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x04, 0x10, 0x01, 0x00, 0x88, 0x01, 0x00, 0x48, 0x01, 0x00, 0x30, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x04, 0x90, 0x00, 0x00, 0x08, 0x01, 0x00, 0x28, 0x01, 0x00, 0xD0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x08, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x08, 0xF0, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xF8, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x40, 0x01, 0x00, 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, // Code for char ¸
-    0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x05, 0x00, 0x00, 0x00, 0x70, 0x02, 0x00, 0x88, 0x02, 0x00, 0x88, 0x02, 0x00, 0x70, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x07, 0x00, 0x00, 0x00, 0x80, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x06, 0x00, 0x80, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x0B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xF8, 0x21, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x06, 0x00, 0x00, 0x01, 0x00, 0xC0, 0x18, 0x00, 0x20, 0x14, 0x00, 0x10, 0x12, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¼
-    0x0C, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xF8, 0x21, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x06, 0x00, 0x00, 0x01, 0x00, 0xC0, 0x00, 0x00, 0x20, 0x22, 0x00, 0x10, 0x31, 0x00, 0x08, 0x29, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ½
-    0x0B, 0x90, 0x00, 0x00, 0x08, 0x01, 0x00, 0x28, 0x21, 0x00, 0xD0, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x06, 0x00, 0x00, 0x01, 0x00, 0xC0, 0x18, 0x00, 0x20, 0x14, 0x00, 0x10, 0x12, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¾
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x10, 0x01, 0x40, 0x0E, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 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, // Code for char ¿
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x61, 0x02, 0x00, 0x1A, 0x02, 0x00, 0x60, 0x02, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char À
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x60, 0x02, 0x00, 0x1A, 0x02, 0x00, 0x61, 0x02, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Á
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x62, 0x02, 0x00, 0x19, 0x02, 0x00, 0x62, 0x02, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Â
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x82, 0x03, 0x00, 0x61, 0x02, 0x00, 0x1B, 0x02, 0x00, 0x62, 0x02, 0x00, 0x81, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ã
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x82, 0x03, 0x00, 0x60, 0x02, 0x00, 0x18, 0x02, 0x00, 0x60, 0x02, 0x00, 0x82, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ä
-    0x09, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x03, 0x00, 0x62, 0x02, 0x00, 0x1D, 0x02, 0x00, 0x62, 0x02, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Å
-    0x0E, 0x00, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x04, 0x00, 0x30, 0x04, 0x00, 0x08, 0x04, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, // Code for char Æ
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x01, 0x08, 0x60, 0x01, 0x08, 0xA0, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x09, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char È
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x09, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char É
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x09, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ê
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x0A, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ë
-    0x02, 0x01, 0x00, 0x00, 0xFA, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x03, 0x00, 0x00, 0x00, 0xFA, 0x3F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x03, 0x02, 0x00, 0x00, 0xF9, 0x3F, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x03, 0x02, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x0A, 0x00, 0x01, 0x00, 0xF8, 0x3F, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x21, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x10, 0x00, 0x00, 0x22, 0x00, 0x00, 0xC1, 0x00, 0x00, 0x03, 0x01, 0x00, 0x02, 0x06, 0x00, 0x01, 0x08, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x09, 0x20, 0x00, 0x0A, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x0A, 0x20, 0x00, 0x09, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x0A, 0x20, 0x00, 0x09, 0x20, 0x00, 0x09, 0x20, 0x00, 0x0A, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x0A, 0x20, 0x00, 0x09, 0x20, 0x00, 0x0B, 0x20, 0x00, 0x0A, 0x20, 0x00, 0x11, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x30, 0x18, 0x00, 0x10, 0x10, 0x00, 0x0A, 0x20, 0x00, 0x08, 0x20, 0x00, 0x08, 0x20, 0x00, 0x0A, 0x20, 0x00, 0x10, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x08, 0x00, 0x00, 0x00, 0x20, 0x08, 0x00, 0x40, 0x04, 0x00, 0x80, 0x02, 0x00, 0x00, 0x01, 0x00, 0x80, 0x02, 0x00, 0x40, 0x04, 0x00, 0x20, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x27, 0x00, 0x30, 0x18, 0x00, 0x10, 0x18, 0x00, 0x08, 0x24, 0x00, 0x08, 0x22, 0x00, 0x88, 0x21, 0x00, 0x48, 0x20, 0x00, 0x30, 0x10, 0x00, 0x30, 0x18, 0x00, 0xC8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x01, 0x20, 0x00, 0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x02, 0x20, 0x00, 0x01, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x20, 0x00, 0x02, 0x20, 0x00, 0x01, 0x20, 0x00, 0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x0A, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x02, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x02, 0x20, 0x00, 0x00, 0x10, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x09, 0x18, 0x00, 0x00, 0x20, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02, 0x3F, 0x00, 0x81, 0x00, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x09, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x20, 0x08, 0x00, 0x40, 0x04, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x08, 0x00, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x08, 0x00, 0x00, 0x08, 0x10, 0x00, 0x88, 0x21, 0x00, 0x70, 0x22, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x48, 0x22, 0x00, 0x50, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x50, 0x22, 0x00, 0x48, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x50, 0x22, 0x00, 0x48, 0x22, 0x00, 0x50, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x50, 0x22, 0x00, 0x48, 0x22, 0x00, 0x58, 0x22, 0x00, 0x50, 0x22, 0x00, 0x88, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x50, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x50, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x08, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x48, 0x22, 0x00, 0x54, 0x22, 0x00, 0x48, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1C, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x1F, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x80, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char æ
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x01, 0x40, 0x60, 0x01, 0x40, 0xA0, 0x00, 0x80, 0x10, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x12, 0x00, 0x48, 0x22, 0x00, 0x50, 0x22, 0x00, 0x80, 0x12, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x12, 0x00, 0x50, 0x22, 0x00, 0x48, 0x22, 0x00, 0x80, 0x12, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x12, 0x00, 0x50, 0x22, 0x00, 0x48, 0x22, 0x00, 0x90, 0x12, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x90, 0x12, 0x00, 0x40, 0x22, 0x00, 0x40, 0x22, 0x00, 0x90, 0x12, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x02, 0x08, 0x00, 0x00, 0xD0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x03, 0x00, 0x00, 0x00, 0xD0, 0x3F, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x03, 0x10, 0x00, 0x00, 0xC8, 0x3F, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char î
-    0x03, 0x10, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x00, 0xA8, 0x20, 0x00, 0x90, 0x20, 0x00, 0xB0, 0x20, 0x00, 0xC8, 0x20, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x90, 0x00, 0x00, 0x48, 0x00, 0x00, 0x58, 0x00, 0x00, 0x50, 0x00, 0x00, 0x88, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x48, 0x20, 0x00, 0x50, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x50, 0x20, 0x00, 0x48, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x10, 0x00, 0x50, 0x20, 0x00, 0x48, 0x20, 0x00, 0x50, 0x20, 0x00, 0x80, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x90, 0x10, 0x00, 0x48, 0x20, 0x00, 0x58, 0x20, 0x00, 0x50, 0x20, 0x00, 0x88, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x90, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x90, 0x10, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x40, 0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x80, 0x10, 0x00, 0x40, 0x28, 0x00, 0x40, 0x26, 0x00, 0x40, 0x21, 0x00, 0x80, 0x10, 0x00, 0x40, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x20, 0x00, 0x00, 0x10, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x10, 0x20, 0x00, 0x08, 0x20, 0x00, 0x00, 0x10, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x20, 0x00, 0x10, 0x20, 0x00, 0x08, 0x20, 0x00, 0x10, 0x10, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x07, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x10, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x10, 0x10, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x07, 0xC0, 0x00, 0x01, 0x00, 0x03, 0x01, 0x00, 0x8C, 0x00, 0x10, 0x70, 0x00, 0x08, 0x0C, 0x00, 0x00, 0x03, 0x00, 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, // Code for char ý
-    0x07, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x80, 0x10, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x07, 0xC0, 0x00, 0x01, 0x00, 0x03, 0x01, 0x10, 0x8C, 0x00, 0x00, 0x70, 0x00, 0x00, 0x0C, 0x00, 0x10, 0x03, 0x00, 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  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_fallback_15x17 = {
-    Droid_Sans_Fallback15x17,
-    15,
-    17,
-    ' ',
-    '\xFF',
-    false
-};

components/display/fonts/font_droid_sans_fallback_24x28.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Droid_Sans_Fallback24x28
-//GLCD FontSize : 24 x 28
-
-static const uint8_t Droid_Sans_Fallback24x28[ ] = {
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x73, 0x00, 0xE0, 0xFF, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, 0x0C, 0x7F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x80, 0xFF, 0x03, 0x00, 0xE0, 0x0F, 0x63, 0x00, 0x60, 0x0C, 0x7F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x80, 0xFF, 0x03, 0x00, 0xE0, 0x0F, 0x03, 0x00, 0x60, 0x0C, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0C, 0x00, 0x80, 0x1F, 0x3C, 0x00, 0xC0, 0x38, 0x30, 0x00, 0xE0, 0x30, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0xF0, 0xFF, 0x01, 0xF8, 0x7F, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0xE0, 0x30, 0x00, 0xC0, 0xC0, 0x30, 0x00, 0xC0, 0xC1, 0x1F, 0x00, 0x80, 0x81, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xE0, 0x70, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x40, 0x00, 0xE0, 0x70, 0x70, 0x00, 0xC0, 0x3F, 0x3E, 0x00, 0x80, 0x9F, 0x0F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x9F, 0x1F, 0x00, 0xC0, 0xC7, 0x3F, 0x00, 0xE0, 0xE0, 0x70, 0x00, 0x20, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0xE0, 0x70, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char %
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x80, 0xC7, 0x38, 0x00, 0xC0, 0x6F, 0x70, 0x00, 0xE0, 0x7C, 0x60, 0x00, 0x60, 0x38, 0x60, 0x00, 0x60, 0xF0, 0x60, 0x00, 0x60, 0xD8, 0x61, 0x00, 0xE0, 0x8C, 0x73, 0x00, 0xC0, 0x0F, 0x37, 0x00, 0x80, 0x07, 0x3E, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xC0, 0x77, 0x00, 0x00, 0xC0, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x03, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x0F, 0xE0, 0x01, 0xC0, 0x01, 0x00, 0x07, 0x60, 0x00, 0x00, 0x0C, 0x20, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x06, 0x20, 0x00, 0x00, 0x08, 0x60, 0x00, 0x00, 0x0C, 0xC0, 0x01, 0x00, 0x07, 0x00, 0x0F, 0xE0, 0x01, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x02, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x07, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0xC0, 0x03, 0x3C, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x03, 0x3C, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x60, 0x00, 0x80, 0x03, 0x78, 0x00, 0xC0, 0x01, 0x7C, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x63, 0x00, 0x60, 0x80, 0x63, 0x00, 0x60, 0xC0, 0x61, 0x00, 0xE0, 0xE0, 0x60, 0x00, 0xC0, 0x70, 0x60, 0x00, 0xC0, 0x3F, 0x60, 0x00, 0x00, 0x0F, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x80, 0x03, 0x1C, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x60, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0xC0, 0x78, 0x70, 0x00, 0xC0, 0x6F, 0x38, 0x00, 0x80, 0xC7, 0x1F, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x0C, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xE0, 0x06, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x0E, 0x06, 0x00, 0x00, 0x07, 0x06, 0x00, 0xC0, 0x01, 0x06, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x3E, 0x1C, 0x00, 0xE0, 0x3F, 0x38, 0x00, 0xE0, 0x33, 0x70, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x38, 0x30, 0x00, 0x60, 0x70, 0x38, 0x00, 0x60, 0xE0, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0xFF, 0x1F, 0x00, 0xC0, 0x33, 0x3C, 0x00, 0xC0, 0x30, 0x30, 0x00, 0xE0, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0x60, 0x38, 0x70, 0x00, 0xC0, 0x70, 0x38, 0x00, 0xC0, 0xE1, 0x1F, 0x00, 0x80, 0xC1, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x40, 0x00, 0x60, 0x00, 0x78, 0x00, 0x60, 0x00, 0x3E, 0x00, 0x60, 0x80, 0x0F, 0x00, 0x60, 0xF0, 0x01, 0x00, 0x60, 0x7C, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x80, 0x8F, 0x3F, 0x00, 0xC0, 0xDF, 0x31, 0x00, 0xC0, 0xF8, 0x70, 0x00, 0x60, 0x70, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x70, 0x60, 0x00, 0xC0, 0xF8, 0x70, 0x00, 0xC0, 0xDF, 0x31, 0x00, 0x80, 0x8F, 0x3F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x18, 0x00, 0x80, 0x7F, 0x38, 0x00, 0xC0, 0xE1, 0x30, 0x00, 0xE0, 0xC0, 0x61, 0x00, 0x60, 0x80, 0x61, 0x00, 0x60, 0x80, 0x61, 0x00, 0x60, 0x80, 0x61, 0x00, 0x60, 0x80, 0x71, 0x00, 0xC0, 0xC0, 0x30, 0x00, 0xC0, 0x43, 0x3C, 0x00, 0x80, 0xFF, 0x0F, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x70, 0x02, 0x00, 0x1C, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00, 0x9C, 0x03, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x9C, 0x03, 0x00, 0x00, 0x98, 0x01, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x80, 0x73, 0x00, 0x60, 0xC0, 0x73, 0x00, 0x60, 0x60, 0x00, 0x00, 0xE0, 0x30, 0x00, 0x00, 0xC0, 0x38, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0x3E, 0xE0, 0x01, 0x00, 0x07, 0x80, 0x03, 0x80, 0x83, 0x1F, 0x03, 0x80, 0xE1, 0x3F, 0x07, 0xC0, 0x70, 0x70, 0x06, 0xC0, 0x38, 0x60, 0x0E, 0x60, 0x1C, 0x60, 0x0C, 0x60, 0x0C, 0x60, 0x0C, 0x60, 0x0C, 0x30, 0x0C, 0x60, 0x0C, 0x18, 0x0C, 0x60, 0x1C, 0x3E, 0x0C, 0x60, 0xF8, 0x7F, 0x0C, 0xE0, 0xFC, 0x61, 0x0C, 0xC0, 0x1C, 0x60, 0x06, 0xC0, 0x01, 0x70, 0x04, 0x80, 0x03, 0x38, 0x00, 0x00, 0x0F, 0x1C, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char @
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0xC0, 0x07, 0x03, 0x00, 0xE0, 0x01, 0x03, 0x00, 0x60, 0x00, 0x03, 0x00, 0xE0, 0x03, 0x03, 0x00, 0x80, 0x0F, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char A
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0xC0, 0xF0, 0x70, 0x00, 0xC0, 0xDF, 0x30, 0x00, 0x00, 0x8F, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x80, 0x07, 0x1E, 0x00, 0xC0, 0x01, 0x38, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x80, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0xC0, 0x60, 0x00, 0x60, 0xC0, 0x60, 0x00, 0xC0, 0xC0, 0x70, 0x00, 0xC0, 0xC0, 0x30, 0x00, 0x80, 0xC1, 0x38, 0x00, 0x00, 0xC7, 0x7F, 0x00, 0x00, 0xC6, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xEE, 0x00, 0x00, 0x00, 0xC7, 0x03, 0x00, 0x80, 0x03, 0x07, 0x00, 0xC0, 0x01, 0x0E, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x60, 0x00, 0x70, 0x00, 0x20, 0x00, 0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char K
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0xE0, 0x60, 0x00, 0x00, 0xC0, 0x71, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x64, 0x00, 0x60, 0x00, 0x6E, 0x00, 0xE0, 0x00, 0x3C, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x01, 0x3C, 0x00, 0x80, 0x07, 0x7E, 0x00, 0x00, 0xFE, 0xE7, 0x00, 0x00, 0xF8, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0xE0, 0x00, 0x00, 0x60, 0xA0, 0x01, 0x00, 0xC0, 0xB0, 0x07, 0x00, 0xC0, 0x1F, 0x3F, 0x00, 0x00, 0x0F, 0x78, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0F, 0x1E, 0x00, 0x80, 0x1F, 0x38, 0x00, 0xC0, 0x18, 0x30, 0x00, 0xE0, 0x30, 0x70, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0x70, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0xC0, 0xE0, 0x30, 0x00, 0xC0, 0xC1, 0x38, 0x00, 0x80, 0x83, 0x1F, 0x00, 0x00, 0x03, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x0E, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x11, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char V
-    0x18, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, // Code for char W
-    0x11, 0x00, 0x00, 0x40, 0x00, 0x20, 0x00, 0x60, 0x00, 0x60, 0x00, 0x70, 0x00, 0xE0, 0x00, 0x1C, 0x00, 0x80, 0x03, 0x0E, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x8E, 0x01, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x8E, 0x01, 0x00, 0x00, 0x07, 0x07, 0x00, 0x80, 0x03, 0x0E, 0x00, 0xE0, 0x00, 0x18, 0x00, 0x60, 0x00, 0x70, 0x00, 0x20, 0x00, 0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x10, 0x20, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x60, 0x00, 0x78, 0x00, 0x60, 0x00, 0x7C, 0x00, 0x60, 0x00, 0x67, 0x00, 0x60, 0x80, 0x63, 0x00, 0x60, 0xC0, 0x61, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x38, 0x60, 0x00, 0x60, 0x1C, 0x60, 0x00, 0x60, 0x0E, 0x60, 0x00, 0xE0, 0x03, 0x60, 0x00, 0xE0, 0x01, 0x60, 0x00, 0xE0, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x07, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x05, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x0E, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char _
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 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, // Code for char `
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x1C, 0x73, 0x00, 0x00, 0x8C, 0x63, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x31, 0x00, 0x00, 0x9C, 0x31, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x70, 0x00, 0x00, 0x18, 0x30, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xB8, 0x39, 0x00, 0x00, 0x9C, 0x31, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x9C, 0x61, 0x00, 0x00, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x07, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x0C, 0x00, 0x00, 0x60, 0x0C, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x03, 0x00, 0xF0, 0x1F, 0x07, 0x00, 0x38, 0x38, 0x0E, 0x00, 0x1C, 0x70, 0x0C, 0x00, 0x0C, 0x60, 0x0C, 0x00, 0x0C, 0x60, 0x0C, 0x00, 0x0C, 0x60, 0x0C, 0x00, 0x0C, 0x30, 0x0C, 0x00, 0x18, 0x30, 0x06, 0x00, 0xFC, 0xFF, 0x07, 0x00, 0xFC, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xFC, 0x7F, 0x00, 0x60, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x04, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x60, 0xFC, 0xFF, 0x0F, 0x60, 0xFC, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x30, 0x07, 0x00, 0x00, 0x18, 0x0E, 0x00, 0x00, 0x0C, 0x1C, 0x00, 0x00, 0x04, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0x18, 0x30, 0x00, 0x00, 0x1C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x18, 0x00, 0x00, 0xF8, 0x38, 0x00, 0x00, 0xDC, 0x71, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x63, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, 0x1C, 0x33, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x06, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x12, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char w
-    0x0C, 0x00, 0x04, 0x40, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x70, 0x1C, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x70, 0x1C, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x0C, 0x00, 0xF0, 0x03, 0x0C, 0x00, 0x80, 0x0F, 0x0E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x70, 0x00, 0x00, 0x0C, 0x78, 0x00, 0x00, 0x0C, 0x7C, 0x00, 0x00, 0x0C, 0x6E, 0x00, 0x00, 0x0C, 0x67, 0x00, 0x00, 0x8C, 0x63, 0x00, 0x00, 0xCC, 0x61, 0x00, 0x00, 0xEC, 0x60, 0x00, 0x00, 0x7C, 0x60, 0x00, 0x00, 0x3C, 0x60, 0x00, 0x00, 0x1C, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00, 0x80, 0xFF, 0xFC, 0x03, 0xC0, 0x7F, 0xF8, 0x07, 0xE0, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x08, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0xE0, 0x00, 0x00, 0x0C, 0xC0, 0x7F, 0xF8, 0x07, 0x80, 0xFF, 0xFC, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x7F, 0x00, 0x30, 0x00, 0x40, 0x00, 0x30, 0x00, 0x40, 0x00, 0x30, 0x00, 0x40, 0x00, 0xF0, 0xFF, 0x7F, 0x00, 0xF0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9C, 0xFF, 0x0F, 0x00, 0x9C, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x03, 0x00, 0x1C, 0xF0, 0x00, 0x00, 0x0C, 0x6E, 0x00, 0x00, 0xEC, 0x61, 0x00, 0x00, 0x1E, 0x60, 0x00, 0x80, 0x1D, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x70, 0x00, 0x00, 0x7F, 0x38, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xE0, 0x33, 0x00, 0x60, 0x60, 0x30, 0x00, 0x60, 0x60, 0x30, 0x00, 0x60, 0x60, 0x30, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x03, 0x60, 0x00, 0x00, 0x03, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0xF7, 0x0E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF7, 0x0E, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x0E, 0x20, 0x00, 0x00, 0x00, 0xE0, 0x60, 0x06, 0x00, 0xC0, 0x61, 0x06, 0x00, 0x80, 0x67, 0x06, 0x00, 0x00, 0x7E, 0x06, 0x00, 0x00, 0x78, 0x06, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x78, 0x06, 0x00, 0x00, 0x7E, 0x06, 0x00, 0x80, 0x67, 0x06, 0x00, 0xC0, 0x61, 0x06, 0x00, 0xE0, 0x60, 0x06, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x3F, 0xF8, 0x0F, 0xE0, 0x3F, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0xF3, 0x03, 0x03, 0xC0, 0x1F, 0x07, 0x07, 0xE0, 0x1C, 0x0E, 0x06, 0x60, 0x18, 0x0C, 0x0C, 0x60, 0x38, 0x1C, 0x0C, 0x60, 0x30, 0x18, 0x0C, 0x60, 0x70, 0x38, 0x0C, 0xC0, 0x60, 0x70, 0x0E, 0xC0, 0xC1, 0xF8, 0x07, 0x80, 0xC1, 0xCF, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x08, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x12, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x80, 0x03, 0x1C, 0x00, 0xC0, 0xF9, 0x38, 0x00, 0xC0, 0xFC, 0x33, 0x00, 0x60, 0x0E, 0x66, 0x00, 0x60, 0x02, 0x64, 0x00, 0x60, 0x02, 0x64, 0x00, 0x60, 0x02, 0x64, 0x00, 0x60, 0x06, 0x66, 0x00, 0x60, 0x0C, 0x63, 0x00, 0xC0, 0x08, 0x31, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x03, 0x1C, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ©
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x40, 0x1C, 0x01, 0x00, 0x60, 0x3E, 0x01, 0x00, 0x20, 0x23, 0x01, 0x00, 0x20, 0x21, 0x01, 0x00, 0x20, 0x21, 0x01, 0x00, 0x20, 0x11, 0x01, 0x00, 0xE0, 0x3F, 0x01, 0x00, 0xC0, 0x3F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x12, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x80, 0x03, 0x1C, 0x00, 0xC0, 0x01, 0x38, 0x00, 0xC0, 0xFE, 0x37, 0x00, 0x60, 0xFE, 0x67, 0x00, 0x60, 0x42, 0x60, 0x00, 0x60, 0x42, 0x60, 0x00, 0x60, 0xC2, 0x60, 0x00, 0x60, 0xE6, 0x63, 0x00, 0x60, 0x3E, 0x67, 0x00, 0xC0, 0x3C, 0x34, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x03, 0x1C, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ®
-    0x0D, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¯
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0xFF, 0x6F, 0x00, 0x00, 0xFF, 0x6F, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x08, 0x80, 0x20, 0x00, 0x00, 0xC0, 0x38, 0x00, 0x00, 0x60, 0x38, 0x00, 0x00, 0x20, 0x3C, 0x00, 0x00, 0x20, 0x2E, 0x00, 0x00, 0x20, 0x26, 0x00, 0x00, 0xE0, 0x23, 0x00, 0x00, 0xC0, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x07, 0x40, 0x18, 0x00, 0x00, 0x60, 0x38, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0xE0, 0x3D, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0xFC, 0xFF, 0x0F, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x0D, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xE0, 0x3F, 0x00, 0x00, 0xE0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0F, 0x01, 0x00, 0xC0, 0x1F, 0x01, 0x00, 0x60, 0x30, 0x01, 0x00, 0x20, 0x20, 0x01, 0x00, 0x20, 0x20, 0x01, 0x00, 0x60, 0x30, 0x01, 0x00, 0xC0, 0x1F, 0x01, 0x00, 0x80, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x13, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xE0, 0x3F, 0x40, 0x00, 0xE0, 0x3F, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x08, 0x1C, 0x00, 0x00, 0x04, 0x12, 0x00, 0x00, 0x83, 0x11, 0x00, 0x80, 0xC0, 0x7F, 0x00, 0x40, 0xC0, 0x7F, 0x00, 0x20, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¼
-    0x14, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0xE0, 0x3F, 0x20, 0x00, 0xE0, 0x3F, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x41, 0x00, 0x00, 0x84, 0x71, 0x00, 0x00, 0xC3, 0x70, 0x00, 0x80, 0x40, 0x78, 0x00, 0x40, 0x40, 0x5C, 0x00, 0x20, 0x40, 0x4C, 0x00, 0x00, 0xC0, 0x47, 0x00, 0x00, 0x80, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ½
-    0x13, 0x40, 0x18, 0x00, 0x00, 0x60, 0x38, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x20, 0x22, 0x40, 0x00, 0xE0, 0x3D, 0x20, 0x00, 0xC0, 0x1D, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x08, 0x1C, 0x00, 0x00, 0x04, 0x12, 0x00, 0x00, 0x83, 0x11, 0x00, 0x80, 0xC0, 0x7F, 0x00, 0x40, 0xC0, 0x7F, 0x00, 0x20, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¾
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x38, 0x06, 0x00, 0x00, 0x18, 0x0E, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x9C, 0x07, 0x0C, 0x00, 0x9C, 0x03, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x02, 0x3E, 0x03, 0x00, 0xC6, 0x07, 0x03, 0x00, 0xEE, 0x01, 0x03, 0x00, 0x6E, 0x00, 0x03, 0x00, 0xE8, 0x03, 0x03, 0x00, 0x80, 0x0F, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char À
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0xC0, 0x07, 0x03, 0x00, 0xE8, 0x01, 0x03, 0x00, 0x6E, 0x00, 0x03, 0x00, 0xEE, 0x03, 0x03, 0x00, 0x86, 0x0F, 0x03, 0x00, 0x02, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Á
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x08, 0xF8, 0x03, 0x00, 0x0C, 0x3E, 0x03, 0x00, 0xCE, 0x07, 0x03, 0x00, 0xE6, 0x01, 0x03, 0x00, 0x66, 0x00, 0x03, 0x00, 0xEE, 0x03, 0x03, 0x00, 0x8C, 0x0F, 0x03, 0x00, 0x08, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Â
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x0C, 0x3E, 0x03, 0x00, 0xCE, 0x07, 0x03, 0x00, 0xE6, 0x01, 0x03, 0x00, 0x66, 0x00, 0x03, 0x00, 0xEC, 0x03, 0x03, 0x00, 0x8C, 0x0F, 0x03, 0x00, 0x0E, 0x3E, 0x03, 0x00, 0x06, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ã
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x0E, 0x3E, 0x03, 0x00, 0xCE, 0x07, 0x03, 0x00, 0xE0, 0x01, 0x03, 0x00, 0x60, 0x00, 0x03, 0x00, 0xE0, 0x03, 0x03, 0x00, 0x8E, 0x0F, 0x03, 0x00, 0x0E, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ä
-    0x11, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0xCE, 0x07, 0x03, 0x00, 0xF1, 0x01, 0x03, 0x00, 0x71, 0x00, 0x03, 0x00, 0xF1, 0x03, 0x03, 0x00, 0x8E, 0x0F, 0x03, 0x00, 0x00, 0x3E, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Å
-    0x18, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x0E, 0x03, 0x00, 0x80, 0x03, 0x03, 0x00, 0xC0, 0x01, 0x03, 0x00, 0x60, 0x00, 0x03, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, // Code for char Æ
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x80, 0x07, 0x1E, 0x00, 0xC0, 0x01, 0x38, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x08, 0x60, 0x00, 0xE0, 0x09, 0x60, 0x00, 0xE0, 0x09, 0x60, 0x00, 0x60, 0x0F, 0x60, 0x00, 0x60, 0x06, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x80, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x62, 0x60, 0x60, 0x00, 0x66, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x68, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char È
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x68, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x66, 0x60, 0x60, 0x00, 0x62, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char É
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x68, 0x60, 0x60, 0x00, 0x6C, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x66, 0x60, 0x60, 0x00, 0x66, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x6C, 0x60, 0x60, 0x00, 0x68, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ê
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x6E, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ë
-    0x05, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xEE, 0xFF, 0x7F, 0x00, 0xEE, 0xFF, 0x7F, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE8, 0xFF, 0x7F, 0x00, 0xEE, 0xFF, 0x7F, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x07, 0x0C, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0xE6, 0xFF, 0x7F, 0x00, 0xE6, 0xFF, 0x7F, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x06, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x11, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0C, 0x0E, 0x00, 0x00, 0x0E, 0x1C, 0x00, 0x00, 0x06, 0x70, 0x00, 0x00, 0x06, 0xE0, 0x00, 0x00, 0x0C, 0x80, 0x03, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x06, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x62, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x68, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0x68, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0xE2, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xE8, 0x00, 0x70, 0x00, 0x6C, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0xEC, 0x00, 0x70, 0x00, 0xC8, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xEC, 0x00, 0x70, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x66, 0x00, 0x60, 0x00, 0x6C, 0x00, 0x60, 0x00, 0x6C, 0x00, 0x60, 0x00, 0xEE, 0x00, 0x70, 0x00, 0xC6, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x80, 0x01, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xEE, 0x00, 0x70, 0x00, 0x6E, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x6E, 0x00, 0x60, 0x00, 0xEE, 0x00, 0x70, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x38, 0x00, 0x80, 0x07, 0x1E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x0E, 0x0E, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x0E, 0x0E, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x41, 0x00, 0x00, 0xFE, 0x67, 0x00, 0x80, 0x07, 0x3E, 0x00, 0x80, 0x01, 0x1C, 0x00, 0xC0, 0x00, 0x36, 0x00, 0xE0, 0x00, 0x73, 0x00, 0x60, 0x80, 0x61, 0x00, 0x60, 0xC0, 0x60, 0x00, 0x60, 0x60, 0x60, 0x00, 0x60, 0x30, 0x60, 0x00, 0x60, 0x18, 0x60, 0x00, 0xE0, 0x0C, 0x70, 0x00, 0xC0, 0x06, 0x30, 0x00, 0x80, 0x03, 0x38, 0x00, 0xC0, 0x07, 0x1E, 0x00, 0x60, 0xFE, 0x07, 0x00, 0x20, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x30, 0x00, 0x02, 0x00, 0x60, 0x00, 0x06, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x08, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x08, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x06, 0x00, 0x60, 0x00, 0x02, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x08, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x06, 0x00, 0x60, 0x00, 0x06, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x0C, 0x00, 0x60, 0x00, 0x08, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x30, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x60, 0x00, 0x0E, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x10, 0x20, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x08, 0xE0, 0x7F, 0x00, 0x0E, 0xE0, 0x7F, 0x00, 0x0E, 0x70, 0x00, 0x00, 0x06, 0x1C, 0x00, 0x00, 0x02, 0x0E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x07, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 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, // Code for char Þ
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x70, 0x38, 0x00, 0xE0, 0xFC, 0x70, 0x00, 0xC0, 0xCF, 0x61, 0x00, 0x80, 0x83, 0x61, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x1C, 0x73, 0x00, 0x20, 0x8C, 0x63, 0x00, 0x60, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x80, 0x8C, 0x31, 0x00, 0x00, 0x9C, 0x31, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x1C, 0x73, 0x00, 0x00, 0x8C, 0x63, 0x00, 0x80, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x31, 0x00, 0x20, 0x9C, 0x31, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x80, 0x1C, 0x73, 0x00, 0xC0, 0x8C, 0x63, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x31, 0x00, 0xC0, 0x9C, 0x31, 0x00, 0x80, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0xC0, 0x1C, 0x73, 0x00, 0xE0, 0x8C, 0x63, 0x00, 0x60, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x61, 0x00, 0xC0, 0x8C, 0x61, 0x00, 0xC0, 0x8C, 0x31, 0x00, 0xE0, 0x9C, 0x31, 0x00, 0x60, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x1C, 0x73, 0x00, 0xE0, 0x8C, 0x63, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x31, 0x00, 0xE0, 0x9C, 0x31, 0x00, 0xE0, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x1C, 0x73, 0x00, 0x00, 0x8C, 0x63, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x10, 0x8D, 0x61, 0x00, 0x10, 0x8D, 0x61, 0x00, 0x10, 0x8D, 0x31, 0x00, 0xE0, 0x9C, 0x31, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x1E, 0x00, 0x00, 0x38, 0x3F, 0x00, 0x00, 0x18, 0x73, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x71, 0x00, 0x00, 0x9C, 0x31, 0x00, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0xB8, 0x39, 0x00, 0x00, 0x8C, 0x71, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x9C, 0x61, 0x00, 0x00, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char æ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x08, 0x00, 0x0C, 0xE0, 0x09, 0x00, 0x0C, 0xE0, 0x09, 0x00, 0x0C, 0x60, 0x0F, 0x00, 0x18, 0x70, 0x06, 0x00, 0x38, 0x38, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xB8, 0x39, 0x00, 0x20, 0x9C, 0x31, 0x00, 0x60, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x80, 0x8C, 0x61, 0x00, 0x00, 0x9C, 0x61, 0x00, 0x00, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xB8, 0x39, 0x00, 0x00, 0x9C, 0x31, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x80, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x60, 0x9C, 0x61, 0x00, 0x20, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x80, 0xB8, 0x39, 0x00, 0xC0, 0x9C, 0x31, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x61, 0x00, 0x60, 0x8C, 0x61, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0xC0, 0x9C, 0x61, 0x00, 0x80, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xB8, 0x39, 0x00, 0xE0, 0x9C, 0x31, 0x00, 0xE0, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0x8C, 0x61, 0x00, 0xE0, 0x9C, 0x61, 0x00, 0xE0, 0xB8, 0x31, 0x00, 0x00, 0xF0, 0x39, 0x00, 0x00, 0xE0, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x04, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0xFC, 0x7F, 0x00, 0x80, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFC, 0x7F, 0x00, 0xE0, 0xFC, 0x7F, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x07, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0xFC, 0x7F, 0x00, 0x60, 0xFC, 0x7F, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 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, // Code for char î
-    0x07, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x20, 0x1D, 0x70, 0x00, 0xA0, 0x0D, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0xC0, 0x0C, 0x60, 0x00, 0xC0, 0x0D, 0x60, 0x00, 0x60, 0x1F, 0x70, 0x00, 0x20, 0x3E, 0x38, 0x00, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0xC0, 0xFC, 0x7F, 0x00, 0xE0, 0x18, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x60, 0x0C, 0x00, 0x00, 0xC0, 0x0C, 0x00, 0x00, 0xC0, 0x0C, 0x00, 0x00, 0xE0, 0x1C, 0x00, 0x00, 0x60, 0xF8, 0x7F, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x20, 0x1C, 0x70, 0x00, 0x60, 0x0C, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0x80, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x80, 0x0C, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0x60, 0x1C, 0x70, 0x00, 0x20, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x80, 0x38, 0x38, 0x00, 0xC0, 0x1C, 0x70, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0x60, 0x0C, 0x60, 0x00, 0x60, 0x0C, 0x60, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0xC0, 0x1C, 0x70, 0x00, 0x80, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0xC0, 0x38, 0x38, 0x00, 0xE0, 0x1C, 0x70, 0x00, 0x60, 0x0C, 0x60, 0x00, 0x60, 0x0C, 0x60, 0x00, 0xC0, 0x0C, 0x60, 0x00, 0xC0, 0x0C, 0x60, 0x00, 0xE0, 0x1C, 0x70, 0x00, 0x60, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x38, 0x38, 0x00, 0xE0, 0x1C, 0x70, 0x00, 0xE0, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0xE0, 0x1C, 0x70, 0x00, 0xE0, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x67, 0x0E, 0x00, 0x00, 0x67, 0x0E, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x4F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x1C, 0x7C, 0x00, 0x00, 0x0C, 0x66, 0x00, 0x00, 0x0C, 0x63, 0x00, 0x00, 0x8C, 0x61, 0x00, 0x00, 0xCC, 0x60, 0x00, 0x00, 0x7C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xC4, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x20, 0x00, 0x70, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x60, 0x00, 0x80, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x30, 0x00, 0x60, 0x00, 0x30, 0x00, 0x20, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x80, 0xFC, 0x3F, 0x00, 0xC0, 0x00, 0x70, 0x00, 0xE0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x80, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0xE0, 0xFC, 0x3F, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x30, 0x00, 0xE0, 0xFC, 0x7F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x0C, 0x00, 0xF0, 0x03, 0x0C, 0x00, 0x80, 0x0F, 0x0E, 0x80, 0x00, 0xFE, 0x07, 0xE0, 0x00, 0xF0, 0x01, 0xE0, 0x00, 0x7E, 0x00, 0x60, 0x80, 0x0F, 0x00, 0x20, 0xF0, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x0F, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x0C, 0x60, 0x00, 0x00, 0x1C, 0x70, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x0C, 0xE0, 0xF0, 0x03, 0x0C, 0xE0, 0x80, 0x0F, 0x0E, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x7E, 0x00, 0xE0, 0x80, 0x0F, 0x00, 0xE0, 0xF0, 0x03, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_fallback_24x28 = {
-    Droid_Sans_Fallback24x28,
-    24,
-    28,
-    ' ',
-    '\xFF',
-    false
-};

components/display/fonts/font_droid_sans_mono_13x24.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Droid_Sans_Mono13x24
-//GLCD FontSize : 13 x 24
-
-static const uint8_t Droid_Sans_Mono13x24[ ] = {
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x07, 0x07, 0xF0, 0x7F, 0x07, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x0C, 0x00, 0x60, 0x00, 0x00, 0x63, 0x06, 0x00, 0xF3, 0x07, 0x00, 0x7F, 0x00, 0xF0, 0x63, 0x00, 0x30, 0x63, 0x00, 0x00, 0x63, 0x06, 0x00, 0xF3, 0x07, 0x00, 0x7F, 0x00, 0xF0, 0x63, 0x00, 0x30, 0x63, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x01, 0xC0, 0x07, 0x03, 0x60, 0x0C, 0x03, 0x60, 0x0C, 0x03, 0xF8, 0xFF, 0x0F, 0x60, 0x18, 0x03, 0x60, 0x18, 0x03, 0x60, 0xF0, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x0C, 0xE0, 0x03, 0x00, 0xF0, 0x07, 0x04, 0x10, 0x04, 0x07, 0x10, 0x84, 0x01, 0xF0, 0xE7, 0x00, 0xE0, 0x3B, 0x00, 0x00, 0xEE, 0x03, 0x80, 0xF3, 0x07, 0xC0, 0x10, 0x04, 0x70, 0x10, 0x04, 0x10, 0xF0, 0x07, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x00, // Code for char %
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0xE0, 0xF1, 0x03, 0xF0, 0x1F, 0x06, 0x30, 0x0E, 0x06, 0x30, 0x1C, 0x06, 0x30, 0x3E, 0x06, 0xF0, 0x63, 0x06, 0xE0, 0xC1, 0x03, 0x00, 0xC0, 0x01, 0x00, 0xF0, 0x07, 0x00, 0x30, 0x06, 0x00, 0x00, 0x04, // Code for char &
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFF, 0x03, 0xC0, 0x03, 0x0F, 0xE0, 0x00, 0x1C, 0x30, 0x00, 0x30, 0x10, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x20, 0x30, 0x00, 0x30, 0xE0, 0x00, 0x1C, 0xC0, 0x03, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x04, 0x00, 0xC0, 0x0E, 0x00, 0x80, 0x07, 0x00, 0xF8, 0x01, 0x00, 0x88, 0x03, 0x00, 0xC0, 0x0E, 0x00, 0xC0, 0x04, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x80, 0xFF, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x03, 0x00, 0xF0, 0x00, 0x00, 0x1C, 0x00, 0x80, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x70, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0x60, 0x00, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x60, 0x00, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x60, 0x00, 0x00, 0x20, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x06, 0x60, 0x00, 0x07, 0x30, 0x80, 0x07, 0x30, 0xC0, 0x06, 0x30, 0x60, 0x06, 0x30, 0x30, 0x06, 0x30, 0x1C, 0x06, 0xE0, 0x0F, 0x06, 0xC0, 0x03, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char 2
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x02, 0x20, 0x00, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x1A, 0x07, 0xE0, 0xFB, 0x03, 0xC0, 0xF1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xDC, 0x00, 0x00, 0xCE, 0x00, 0x00, 0xC3, 0x00, 0xC0, 0xC1, 0x00, 0x60, 0xC0, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x02, 0xF0, 0x0F, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x1C, 0x03, 0x30, 0xF8, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x19, 0x03, 0x60, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x04, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x07, 0x30, 0xF8, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0B, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x04, 0x30, 0x00, 0x07, 0x30, 0xE0, 0x03, 0x30, 0xF8, 0x00, 0x30, 0x1E, 0x00, 0xB0, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0xC0, 0xF1, 0x03, 0xE0, 0x13, 0x06, 0x30, 0x1E, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x1E, 0x06, 0xE0, 0x1F, 0x06, 0xC0, 0xF1, 0x03, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0B, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0xE0, 0x0F, 0x06, 0x70, 0x18, 0x04, 0x30, 0x18, 0x04, 0x30, 0x10, 0x06, 0x30, 0x18, 0x06, 0x30, 0x18, 0x03, 0x60, 0xCC, 0x03, 0xC0, 0xFF, 0x01, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x07, 0x80, 0x03, 0x07, 0x80, 0x03, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x3C, 0x80, 0x03, 0x3E, 0x80, 0x03, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x24, 0x00, 0x00, 0x66, 0x00, 0x00, 0x42, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x81, 0x00, 0x80, 0x81, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x81, 0x01, 0x00, 0x81, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x42, 0x00, 0x00, 0x66, 0x00, 0x00, 0x24, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x60, 0x07, 0x30, 0x70, 0x07, 0x30, 0x18, 0x07, 0x30, 0x0C, 0x00, 0xE0, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x0D, 0x00, 0xFE, 0x00, 0x80, 0xC7, 0x03, 0xC0, 0x00, 0x06, 0x60, 0x3C, 0x0C, 0x30, 0xEE, 0x18, 0x10, 0x83, 0x18, 0x10, 0x81, 0x10, 0x10, 0xC1, 0x10, 0x30, 0x71, 0x10, 0x20, 0x7F, 0x18, 0x60, 0x80, 0x08, 0xC0, 0xE3, 0x00, 0x00, 0x3F, 0x00, // Code for char @
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x7E, 0x00, 0x80, 0x6F, 0x00, 0xF0, 0x61, 0x00, 0x30, 0x60, 0x00, 0xF0, 0x61, 0x00, 0x80, 0x6F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char A
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x1E, 0x03, 0xE0, 0xFB, 0x03, 0xC0, 0xF1, 0x01, 0x00, 0x00, 0x00, // Code for char B
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0xC1, 0x03, 0x60, 0x00, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char C
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x60, 0x00, 0x03, 0xE0, 0xC1, 0x01, 0xC0, 0xFF, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char E
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x81, 0x03, 0x60, 0x00, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0xFC, 0x07, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, // Code for char G
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x00, // Code for char H
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x08, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x1B, 0x00, 0x80, 0x71, 0x00, 0xC0, 0xC0, 0x00, 0x60, 0x80, 0x03, 0x30, 0x00, 0x07, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char K
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char L
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0xE0, 0x01, 0x00, 0x00, 0x3E, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x1E, 0x00, 0xE0, 0x01, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x00, // Code for char M
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0xE0, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x07, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x80, 0x03, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x00, // Code for char N
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x80, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0xE0, 0x80, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x10, 0x00, 0x60, 0x18, 0x00, 0xE0, 0x0F, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x80, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x1E, 0xE0, 0x80, 0x3B, 0xC0, 0xFF, 0x71, 0x00, 0x7F, 0x20, 0x00, 0x00, 0x00, // Code for char Q
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x18, 0x00, 0x30, 0x18, 0x00, 0x30, 0x18, 0x00, 0x30, 0x38, 0x00, 0x30, 0x78, 0x00, 0x60, 0xEC, 0x01, 0xE0, 0x87, 0x03, 0xC0, 0x03, 0x07, 0x00, 0x00, 0x04, // Code for char R
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x06, 0xE0, 0x07, 0x06, 0x30, 0x0E, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x18, 0x06, 0x30, 0x18, 0x06, 0x30, 0xF0, 0x03, 0x20, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x0B, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x0D, 0x10, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x06, 0x00, 0xC0, 0x07, 0x00, 0xF8, 0x00, 0x00, 0x1F, 0x00, 0xE0, 0x07, 0x00, 0xF0, 0x00, 0x00, 0x10, 0x00, 0x00, // Code for char V
-    0x0D, 0x70, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x06, 0x00, 0xE0, 0x03, 0x00, 0x3C, 0x00, 0x00, 0x02, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x06, 0x00, 0xFC, 0x07, 0xF0, 0x3F, 0x00, 0x70, 0x00, 0x00, // Code for char W
-    0x0C, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x70, 0x00, 0x07, 0xE0, 0x80, 0x03, 0x80, 0xE3, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE3, 0x01, 0xE0, 0x80, 0x03, 0x30, 0x00, 0x07, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char X
-    0x0C, 0x10, 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xF8, 0x07, 0x00, 0xFC, 0x07, 0x00, 0x0E, 0x00, 0x80, 0x03, 0x00, 0xE0, 0x00, 0x00, 0x70, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x0C, 0x00, 0x00, 0x00, 0x30, 0x00, 0x06, 0x30, 0x00, 0x07, 0x30, 0xC0, 0x07, 0x30, 0x60, 0x06, 0x30, 0x30, 0x06, 0x30, 0x1C, 0x06, 0x30, 0x06, 0x06, 0xB0, 0x03, 0x06, 0xF0, 0x01, 0x06, 0x70, 0x00, 0x06, 0x30, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char Z
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x3F, 0xF0, 0xFF, 0x3F, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x07, 0x00, 0x00, 0x1C, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0xF0, 0xFF, 0x3F, 0xF0, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x07, 0x00, 0x80, 0x03, 0x00, 0xE0, 0x00, 0x00, 0x30, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x07, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x0D, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x20, // Code for char _
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0x80, 0x21, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x04, 0x80, 0x11, 0x06, 0x80, 0x11, 0x06, 0x80, 0x11, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x03, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x03, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x03, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFF, 0x03, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x03, 0x03, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x33, 0x03, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x00, 0x33, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF8, 0xFF, 0x07, 0x98, 0x00, 0x00, 0x98, 0x00, 0x00, 0x98, 0x00, 0x00, 0x98, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x1E, 0x7C, 0x00, 0xBF, 0xC7, 0x80, 0xE1, 0xC7, 0x80, 0x40, 0x86, 0x80, 0x40, 0x86, 0x80, 0x40, 0xC6, 0x80, 0x61, 0xC6, 0x80, 0x3F, 0x46, 0x80, 0x1E, 0x7E, 0x80, 0x00, 0x3C, 0x00, 0x00, 0x00, // Code for char g
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x07, 0x00, 0x03, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x00, 0x04, 0x80, 0x00, 0x04, 0x80, 0x00, 0x04, 0x98, 0xFF, 0x07, 0x98, 0xFF, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x80, 0x00, 0xC0, 0x80, 0x00, 0xC0, 0x80, 0x00, 0xC0, 0x80, 0x00, 0xC0, 0x80, 0x00, 0xC0, 0x98, 0xFF, 0x7F, 0x98, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x07, 0x00, 0x30, 0x00, 0x00, 0x38, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE6, 0x00, 0x00, 0x83, 0x01, 0x80, 0x01, 0x07, 0x80, 0x00, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char k
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x08, 0x00, 0x04, 0x08, 0x00, 0x04, 0x08, 0x00, 0x04, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x0B, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0xFF, 0x07, 0x00, 0xFE, 0x07, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0xFF, 0x07, 0x00, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x03, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x03, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x03, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFF, 0x03, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x03, 0x03, 0x80, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x03, 0x00, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x06, 0x00, 0x0F, 0x06, 0x80, 0x19, 0x06, 0x80, 0x11, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x61, 0x06, 0x80, 0xE1, 0x03, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x00, 0x00, 0xE0, 0xFF, 0x03, 0xF0, 0xFF, 0x07, 0x80, 0x00, 0x06, 0x80, 0x00, 0x06, 0x80, 0x00, 0x06, 0x80, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x80, 0xFF, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x3E, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x04, 0x00, 0xC0, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x3E, 0x00, 0x80, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x0D, 0x80, 0x01, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x06, 0x00, 0xF0, 0x03, 0x00, 0x3F, 0x00, 0x80, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x06, 0x00, 0xF8, 0x03, 0x80, 0x3F, 0x00, 0x80, 0x01, 0x00, // Code for char w
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x01, 0x06, 0x80, 0x03, 0x03, 0x00, 0xCE, 0x01, 0x00, 0x7C, 0x00, 0x00, 0x30, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xCE, 0x01, 0x80, 0x83, 0x03, 0x80, 0x01, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char x
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x80, 0x07, 0xC0, 0x00, 0x1E, 0xC0, 0x00, 0xF8, 0xC0, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0x1E, 0x00, 0xC0, 0x07, 0x00, 0xF8, 0x00, 0x00, 0x3E, 0x00, 0x80, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x06, 0x80, 0x00, 0x07, 0x80, 0xC0, 0x05, 0x80, 0xE0, 0x04, 0x80, 0x30, 0x04, 0x80, 0x18, 0x04, 0x80, 0x0E, 0x04, 0x80, 0x03, 0x04, 0x80, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x38, 0x00, 0xE0, 0xEF, 0x1F, 0xE0, 0xCF, 0x1F, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0x30, 0xE0, 0xCF, 0x1F, 0xE0, 0xEF, 0x1F, 0x00, 0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x08, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x04, 0xC0, 0xFF, 0x03, 0x40, 0x00, 0x02, 0x40, 0x00, 0x02, 0xC0, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x7F, 0x80, 0xF3, 0x7F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x80, 0x7F, 0x00, 0x80, 0xC1, 0x00, 0xC0, 0x80, 0x01, 0xC0, 0x80, 0x01, 0xF0, 0x80, 0x07, 0xF0, 0x80, 0x07, 0xC0, 0x80, 0x01, 0xC0, 0x80, 0x01, 0xC0, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x08, 0x06, 0x00, 0x08, 0x06, 0xC0, 0xFF, 0x07, 0xE0, 0xFF, 0x06, 0x30, 0x08, 0x06, 0x30, 0x08, 0x06, 0x30, 0x08, 0x06, 0x30, 0x08, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char £
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xC3, 0x00, 0x00, 0xC3, 0x00, 0x00, 0xC3, 0x00, 0x00, 0xC3, 0x00, 0x00, 0xFF, 0x00, 0x80, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x0B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xF0, 0x90, 0x00, 0xE0, 0x93, 0x00, 0x00, 0x9F, 0x00, 0x00, 0xF8, 0x07, 0x00, 0xF8, 0x07, 0x00, 0x9F, 0x00, 0xE0, 0x93, 0x00, 0x70, 0x90, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0xFF, 0xF8, 0x07, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x06, 0xF8, 0x1F, 0x06, 0x98, 0x31, 0x04, 0x88, 0x21, 0x04, 0x18, 0x63, 0x06, 0x18, 0xFF, 0x03, 0x10, 0xDE, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x0D, 0x00, 0x7F, 0x00, 0xC0, 0xC1, 0x01, 0x60, 0x00, 0x03, 0x20, 0x3E, 0x02, 0x10, 0x7F, 0x04, 0x90, 0xC1, 0x04, 0x90, 0x80, 0x04, 0x90, 0x80, 0x04, 0x90, 0xC1, 0x04, 0x20, 0x00, 0x02, 0x60, 0x00, 0x03, 0xC0, 0xC1, 0x01, 0x00, 0x7F, 0x00, // Code for char ©
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x90, 0x07, 0x00, 0x90, 0x04, 0x00, 0x90, 0x04, 0x00, 0xF0, 0x03, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x0D, 0x00, 0x7F, 0x00, 0xC0, 0xC1, 0x01, 0x60, 0x00, 0x03, 0x20, 0x00, 0x02, 0x90, 0xFF, 0x04, 0x90, 0xFF, 0x04, 0x90, 0x08, 0x04, 0x90, 0x1C, 0x04, 0x90, 0x77, 0x04, 0x20, 0xC7, 0x02, 0x60, 0x80, 0x03, 0xC0, 0xC1, 0x01, 0x00, 0x7F, 0x00, // Code for char ®
-    0x0D, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, // Code for char ¯
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE0, 0x03, 0x00, 0x30, 0x06, 0x00, 0x10, 0x04, 0x00, 0x30, 0x06, 0x00, 0xE0, 0x03, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x18, 0x06, 0x00, 0x18, 0x06, 0x00, 0x18, 0x06, 0x00, 0x18, 0x06, 0x80, 0xFF, 0x06, 0x80, 0xFF, 0x06, 0x00, 0x18, 0x06, 0x00, 0x18, 0x06, 0x00, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x10, 0x0E, 0x00, 0x10, 0x0B, 0x00, 0xF0, 0x09, 0x00, 0xE0, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x90, 0x08, 0x00, 0x90, 0x08, 0x00, 0x70, 0x0F, 0x00, 0x60, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x38, 0x00, 0x00, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x0B, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0xF0, 0x1F, 0x00, 0xF8, 0x3F, 0x00, 0xF8, 0x3F, 0x00, 0xF8, 0x3F, 0x00, 0xF8, 0xFF, 0x3F, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0xF8, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x98, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0xF0, 0x03, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0xE0, 0x03, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0x00, 0x8C, 0x01, 0x00, 0xF8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0x00, 0x8C, 0x01, 0x00, 0xF8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x0C, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0xF0, 0x0F, 0x04, 0xF0, 0x0F, 0x07, 0x00, 0xC0, 0x01, 0x00, 0x70, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x87, 0x01, 0xC0, 0xC1, 0x01, 0x70, 0x30, 0x01, 0x10, 0xF8, 0x07, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x00, // Code for char ¼
-    0x0C, 0x20, 0x00, 0x00, 0x30, 0x00, 0x04, 0xF0, 0x0F, 0x07, 0xF0, 0xCF, 0x01, 0x00, 0x70, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x01, 0x06, 0x70, 0x08, 0x07, 0x10, 0x88, 0x05, 0x00, 0xF8, 0x04, 0x00, 0x70, 0x04, 0x00, 0x00, 0x00, // Code for char ½
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x90, 0x08, 0x00, 0x90, 0x08, 0x06, 0x70, 0x8F, 0x03, 0x60, 0xE7, 0x00, 0x00, 0x38, 0x00, 0x00, 0x8E, 0x01, 0x80, 0xC3, 0x01, 0xE0, 0x30, 0x01, 0x30, 0xF8, 0x07, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x00, // Code for char ¾
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x3F, 0x00, 0x80, 0x61, 0x00, 0x80, 0x61, 0x80, 0xC3, 0x60, 0x80, 0x73, 0x60, 0x80, 0x13, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x7E, 0x00, 0x81, 0x6F, 0x00, 0xF3, 0x61, 0x00, 0x37, 0x60, 0x00, 0xF4, 0x61, 0x00, 0x80, 0x6F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char À
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x7E, 0x00, 0x80, 0x6F, 0x00, 0xF0, 0x61, 0x00, 0x34, 0x60, 0x00, 0xF7, 0x61, 0x00, 0x83, 0x6F, 0x00, 0x01, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char Á
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x04, 0x7E, 0x00, 0x86, 0x6F, 0x00, 0xF3, 0x61, 0x00, 0x31, 0x60, 0x00, 0xF3, 0x61, 0x00, 0x86, 0x6F, 0x00, 0x04, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char Â
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x06, 0x7E, 0x00, 0x83, 0x6F, 0x00, 0xF3, 0x61, 0x00, 0x33, 0x60, 0x00, 0xF6, 0x61, 0x00, 0x86, 0x6F, 0x00, 0x06, 0x7E, 0x00, 0x03, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char Ã
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x7E, 0x00, 0x83, 0x6F, 0x00, 0xF3, 0x61, 0x00, 0x30, 0x60, 0x00, 0xF0, 0x61, 0x00, 0x83, 0x6F, 0x00, 0x03, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char Ä
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x80, 0x07, 0x00, 0xF0, 0x03, 0x00, 0x7E, 0x00, 0x8E, 0x6F, 0x00, 0xF1, 0x61, 0x00, 0x31, 0x60, 0x00, 0xF1, 0x61, 0x00, 0x8E, 0x6F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x80, 0x07, 0x00, 0x00, 0x04, // Code for char Å
-    0x0C, 0x00, 0x00, 0x07, 0x00, 0xF8, 0x07, 0xC0, 0x7F, 0x00, 0xF0, 0x33, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char Æ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0xC1, 0x03, 0x60, 0x00, 0x03, 0x30, 0x00, 0x86, 0x30, 0x00, 0x9E, 0x30, 0x00, 0xFE, 0x30, 0x00, 0x66, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x20, 0x00, 0x06, 0x00, 0x00, 0x00, // Code for char Ç
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x31, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x37, 0x0C, 0x06, 0x34, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char È
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x34, 0x0C, 0x06, 0x37, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x31, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char É
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x34, 0x0C, 0x06, 0x36, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x31, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x36, 0x0C, 0x06, 0x34, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char Ê
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x33, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x33, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x00, 0x00, 0x00, // Code for char Ë
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x31, 0x00, 0x06, 0x33, 0x00, 0x06, 0xF7, 0xFF, 0x07, 0xF4, 0xFF, 0x07, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0xF4, 0xFF, 0x07, 0xF7, 0xFF, 0x07, 0x33, 0x00, 0x06, 0x31, 0x00, 0x06, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x34, 0x00, 0x06, 0x36, 0x00, 0x06, 0xF3, 0xFF, 0x07, 0xF1, 0xFF, 0x07, 0x33, 0x00, 0x06, 0x36, 0x00, 0x06, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x33, 0x00, 0x06, 0x33, 0x00, 0x06, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x33, 0x00, 0x06, 0x33, 0x00, 0x06, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x0C, 0x00, 0x0C, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x0C, 0x06, 0x30, 0x00, 0x06, 0x60, 0x00, 0x03, 0xE0, 0xC1, 0x01, 0xC0, 0xFF, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0xE6, 0x00, 0x00, 0x83, 0x03, 0x00, 0x03, 0x07, 0x00, 0x03, 0x1C, 0x00, 0x06, 0x70, 0x00, 0x06, 0xE0, 0x00, 0x06, 0x80, 0x03, 0xF3, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x80, 0x03, 0x31, 0x00, 0x06, 0x33, 0x00, 0x06, 0x37, 0x00, 0x06, 0x34, 0x00, 0x06, 0x30, 0x00, 0x06, 0xE0, 0x80, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x80, 0x03, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x34, 0x00, 0x06, 0x37, 0x00, 0x06, 0x33, 0x00, 0x06, 0xE1, 0x80, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE4, 0x80, 0x03, 0x36, 0x00, 0x06, 0x33, 0x00, 0x06, 0x31, 0x00, 0x06, 0x33, 0x00, 0x06, 0x36, 0x00, 0x06, 0xE4, 0x80, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE6, 0x80, 0x03, 0x33, 0x00, 0x06, 0x33, 0x00, 0x06, 0x33, 0x00, 0x06, 0x36, 0x00, 0x06, 0x36, 0x00, 0x06, 0xE6, 0x80, 0x03, 0xC3, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0xC0, 0xFF, 0x01, 0xE0, 0x80, 0x03, 0x33, 0x00, 0x06, 0x33, 0x00, 0x06, 0x30, 0x00, 0x06, 0x30, 0x00, 0x06, 0x33, 0x00, 0x06, 0xE3, 0x80, 0x03, 0xC0, 0xFF, 0x01, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x23, 0x00, 0x00, 0x14, 0x00, 0x00, 0x08, 0x00, 0x00, 0x14, 0x00, 0x00, 0x22, 0x00, 0x80, 0x41, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x04, 0xC0, 0xFF, 0x07, 0xE0, 0x80, 0x03, 0x30, 0xC0, 0x06, 0x30, 0x30, 0x06, 0x30, 0x1C, 0x06, 0x30, 0x06, 0x06, 0xB0, 0x03, 0x06, 0xE0, 0x80, 0x03, 0xF0, 0xFF, 0x01, 0x10, 0x7F, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x03, 0x01, 0x00, 0x06, 0x03, 0x00, 0x06, 0x07, 0x00, 0x06, 0x04, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x04, 0x00, 0x06, 0x07, 0x00, 0x06, 0x03, 0x00, 0x06, 0x01, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xF0, 0xFF, 0x03, 0x04, 0x00, 0x03, 0x06, 0x00, 0x06, 0x03, 0x00, 0x06, 0x01, 0x00, 0x06, 0x03, 0x00, 0x06, 0x06, 0x00, 0x06, 0x04, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x06, 0x03, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x03, 0x00, 0x06, 0x03, 0x00, 0x03, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x0C, 0x10, 0x00, 0x00, 0x70, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x03, 0x00, 0x00, 0x0E, 0x00, 0x04, 0xF8, 0x07, 0x07, 0xFC, 0x07, 0x03, 0x0E, 0x00, 0x81, 0x03, 0x00, 0xE0, 0x00, 0x00, 0x70, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x80, 0x63, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x07, 0xF0, 0xFF, 0x07, 0x18, 0x00, 0x00, 0x18, 0x00, 0x06, 0x18, 0x0E, 0x06, 0x18, 0x1F, 0x06, 0x98, 0x19, 0x06, 0xF0, 0x31, 0x06, 0xF0, 0xE0, 0x03, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, // Code for char ß
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0x80, 0x21, 0x06, 0x88, 0x31, 0x06, 0x98, 0x31, 0x04, 0xB8, 0x11, 0x06, 0xA0, 0x11, 0x06, 0x80, 0x11, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0x80, 0x21, 0x06, 0x80, 0x31, 0x06, 0xA0, 0x31, 0x04, 0xB8, 0x11, 0x06, 0x98, 0x11, 0x06, 0x88, 0x11, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0xA0, 0x21, 0x06, 0xB0, 0x31, 0x06, 0x98, 0x31, 0x04, 0x88, 0x11, 0x06, 0x98, 0x11, 0x06, 0xB0, 0x11, 0x03, 0x20, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0xB0, 0x21, 0x06, 0x98, 0x31, 0x06, 0x98, 0x31, 0x04, 0x98, 0x11, 0x06, 0xB0, 0x11, 0x06, 0xB0, 0x11, 0x03, 0x30, 0xFF, 0x03, 0x18, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0x80, 0x21, 0x06, 0x98, 0x31, 0x06, 0x98, 0x31, 0x04, 0x80, 0x11, 0x06, 0x80, 0x11, 0x06, 0x98, 0x11, 0x03, 0x18, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE1, 0x03, 0x80, 0x21, 0x06, 0x9C, 0x31, 0x06, 0xA2, 0x31, 0x04, 0xA2, 0x11, 0x06, 0xA2, 0x11, 0x06, 0x9C, 0x11, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x0D, 0x00, 0xC0, 0x03, 0x00, 0xE1, 0x07, 0x80, 0x31, 0x06, 0x80, 0x11, 0x06, 0x80, 0x11, 0x02, 0x00, 0xFF, 0x01, 0x00, 0xFF, 0x03, 0x80, 0x33, 0x03, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3E, 0x02, // Code for char æ
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x03, 0x00, 0x03, 0x03, 0x80, 0x01, 0x86, 0x80, 0x01, 0x9E, 0x80, 0x01, 0xFE, 0x80, 0x01, 0x66, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x33, 0x03, 0x88, 0x31, 0x06, 0x98, 0x31, 0x06, 0xB8, 0x31, 0x06, 0xA0, 0x31, 0x06, 0x80, 0x31, 0x06, 0x00, 0x33, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x33, 0x03, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0xA0, 0x31, 0x06, 0xB8, 0x31, 0x06, 0x98, 0x31, 0x06, 0x08, 0x33, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x20, 0x33, 0x03, 0xB0, 0x31, 0x06, 0x98, 0x31, 0x06, 0x88, 0x31, 0x06, 0x98, 0x31, 0x06, 0xB0, 0x31, 0x06, 0x20, 0x33, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x33, 0x03, 0x98, 0x31, 0x06, 0x98, 0x31, 0x06, 0x80, 0x31, 0x06, 0x80, 0x31, 0x06, 0x98, 0x31, 0x06, 0x18, 0x33, 0x06, 0x00, 0x3F, 0x06, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x00, 0x04, 0x88, 0x00, 0x04, 0x98, 0x00, 0x04, 0xB8, 0xFF, 0x07, 0xA0, 0xFF, 0x07, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x00, 0x04, 0x80, 0x00, 0x04, 0x80, 0x00, 0x04, 0xA0, 0xFF, 0x07, 0xB8, 0xFF, 0x07, 0x18, 0x00, 0x04, 0x08, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x00, 0x04, 0xA0, 0x00, 0x04, 0xB0, 0x00, 0x04, 0x98, 0xFF, 0x07, 0x88, 0xFF, 0x07, 0x18, 0x00, 0x04, 0x30, 0x00, 0x04, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char î
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0x00, 0x04, 0x98, 0x00, 0x04, 0x98, 0x00, 0x04, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x18, 0x00, 0x04, 0x18, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x0C, 0x03, 0xD8, 0x06, 0x06, 0x50, 0x06, 0x06, 0x70, 0x06, 0x06, 0x70, 0x06, 0x06, 0xF0, 0x06, 0x06, 0xD8, 0x0D, 0x03, 0x10, 0xFF, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x07, 0xB0, 0xFF, 0x07, 0x18, 0x03, 0x00, 0x98, 0x01, 0x00, 0x98, 0x01, 0x00, 0xB0, 0x01, 0x00, 0xB0, 0x01, 0x00, 0x30, 0xFF, 0x07, 0x18, 0xFE, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x03, 0x03, 0x88, 0x01, 0x06, 0x98, 0x01, 0x06, 0xB8, 0x01, 0x06, 0xA0, 0x01, 0x06, 0x80, 0x01, 0x06, 0x00, 0x03, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0xA0, 0x01, 0x06, 0xB8, 0x01, 0x06, 0x98, 0x01, 0x06, 0x08, 0x03, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x20, 0x03, 0x03, 0xB0, 0x01, 0x06, 0x98, 0x01, 0x06, 0x88, 0x01, 0x06, 0x98, 0x01, 0x06, 0xB0, 0x01, 0x06, 0x20, 0x03, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x30, 0x03, 0x03, 0x98, 0x01, 0x06, 0x98, 0x01, 0x06, 0x98, 0x01, 0x06, 0xB0, 0x01, 0x06, 0xB0, 0x01, 0x06, 0x30, 0x03, 0x03, 0x18, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x03, 0x03, 0x98, 0x01, 0x06, 0x98, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x98, 0x01, 0x06, 0x18, 0x03, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x80, 0x99, 0x01, 0x80, 0x99, 0x01, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x03, 0x07, 0x80, 0x81, 0x07, 0x80, 0xE1, 0x06, 0x80, 0x31, 0x06, 0x80, 0x1D, 0x06, 0x80, 0x0F, 0x06, 0x80, 0x03, 0x03, 0x80, 0xFF, 0x01, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x80, 0xFF, 0x03, 0x08, 0x00, 0x06, 0x18, 0x00, 0x06, 0x38, 0x00, 0x06, 0x20, 0x00, 0x06, 0x00, 0x00, 0x03, 0x80, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x80, 0xFF, 0x03, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x20, 0x00, 0x06, 0x38, 0x00, 0x06, 0x18, 0x00, 0x03, 0x88, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0xA0, 0xFF, 0x03, 0x30, 0x00, 0x06, 0x18, 0x00, 0x06, 0x08, 0x00, 0x06, 0x18, 0x00, 0x06, 0x30, 0x00, 0x03, 0xA0, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x80, 0xFF, 0x03, 0x18, 0x00, 0x06, 0x18, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x18, 0x00, 0x03, 0x98, 0xFF, 0x07, 0x80, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x80, 0x07, 0xC0, 0x00, 0x1E, 0xC0, 0x00, 0xF8, 0xC0, 0x00, 0xC0, 0x7F, 0x20, 0x00, 0x1E, 0x38, 0xC0, 0x07, 0x18, 0xF8, 0x00, 0x08, 0x3E, 0x00, 0x80, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0x00, 0x03, 0x03, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x01, 0x06, 0x80, 0x03, 0x03, 0x00, 0xFF, 0x03, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x80, 0x07, 0xC0, 0x00, 0x1E, 0xC0, 0x18, 0xF8, 0xC0, 0x18, 0xC0, 0x7F, 0x00, 0x00, 0x1E, 0x00, 0xC0, 0x07, 0x18, 0xF8, 0x00, 0x18, 0x3E, 0x00, 0x80, 0x07, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_mono_13x24 = {
-    Droid_Sans_Mono13x24,
-    13,
-    24,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_droid_sans_mono_16x31.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Droid_Sans_Mono16x31
-//GLCD FontSize : 16 x 31
-
-static const uint8_t Droid_Sans_Mono16x31[ ] = {
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0xC0, 0x01, 0xC0, 0xFF, 0xE7, 0x01, 0xC0, 0xFF, 0xE7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x30, 0x0C, 0x00, 0x00, 0x30, 0xCC, 0x01, 0x00, 0x30, 0xFF, 0x01, 0x00, 0xFE, 0x1F, 0x00, 0xC0, 0x7F, 0x0C, 0x00, 0xC0, 0x31, 0x0C, 0x00, 0x00, 0x30, 0x0C, 0x00, 0x00, 0x30, 0xCC, 0x01, 0x00, 0x30, 0xFF, 0x01, 0x00, 0xFC, 0x3F, 0x00, 0xC0, 0xFF, 0x0C, 0x00, 0xC0, 0x31, 0x0C, 0x00, 0x00, 0x30, 0x0C, 0x00, 0x00, 0x30, 0x00, 0x00, // Code for char #
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x60, 0x00, 0x00, 0x7F, 0xE0, 0x00, 0x00, 0x73, 0xC0, 0x00, 0x80, 0xE1, 0xC0, 0x00, 0x80, 0xC1, 0xC0, 0x00, 0xE0, 0xFF, 0xFF, 0x07, 0xE0, 0xFF, 0xFF, 0x07, 0x80, 0x81, 0xC1, 0x00, 0x80, 0x81, 0x73, 0x00, 0x80, 0x03, 0x7F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x10, 0x00, 0x1F, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xC0, 0x60, 0x00, 0x01, 0xC0, 0x60, 0xC0, 0x01, 0xC0, 0x60, 0xF0, 0x00, 0xC0, 0x60, 0x3C, 0x00, 0x80, 0x3F, 0x0F, 0x00, 0x00, 0xDF, 0x03, 0x00, 0x00, 0xE0, 0x7D, 0x00, 0x00, 0x78, 0xFE, 0x00, 0x00, 0x1E, 0x83, 0x01, 0x80, 0x07, 0x83, 0x01, 0xC0, 0x01, 0x83, 0x01, 0x40, 0x00, 0x83, 0x01, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x7C, 0x00, // Code for char %
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x0F, 0xFF, 0x00, 0x80, 0xBF, 0xC1, 0x01, 0xC0, 0xF9, 0x81, 0x01, 0xC0, 0xE0, 0x81, 0x01, 0xC0, 0xE0, 0x83, 0x01, 0xC0, 0xF0, 0xC7, 0x01, 0xC0, 0x39, 0xCE, 0x00, 0x80, 0x1F, 0xFC, 0x00, 0x00, 0x0F, 0x78, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xDF, 0x01, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char &
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xFE, 0xFD, 0x03, 0x00, 0x0F, 0x80, 0x07, 0x80, 0x03, 0x00, 0x0E, 0xC0, 0x01, 0x00, 0x1C, 0x40, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x10, 0xC0, 0x01, 0x00, 0x1C, 0x80, 0x03, 0x00, 0x0E, 0x00, 0x0F, 0x80, 0x07, 0x00, 0xFE, 0xFD, 0x03, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0xE3, 0x00, 0x00, 0x00, 0xFA, 0x00, 0x00, 0x70, 0x3E, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF0, 0x1E, 0x00, 0x00, 0x00, 0x7A, 0x00, 0x00, 0x00, 0xE2, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 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, // Code for char ,
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 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, // Code for char .
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x3F, 0xFE, 0x00, 0x80, 0x01, 0xC0, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x3F, 0xFE, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x01, 0x80, 0x03, 0xE0, 0x01, 0x80, 0x01, 0xF0, 0x01, 0xC0, 0x01, 0xB8, 0x01, 0xC0, 0x00, 0x9C, 0x01, 0xC0, 0x00, 0x8E, 0x01, 0xC0, 0x00, 0x87, 0x01, 0xC0, 0xC1, 0x83, 0x01, 0x80, 0xF3, 0x81, 0x01, 0x80, 0x7F, 0x80, 0x01, 0x00, 0x3E, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xE1, 0x80, 0x01, 0x80, 0xBB, 0xC1, 0x00, 0x80, 0x3F, 0xF7, 0x00, 0x00, 0x1F, 0x7F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x19, 0x00, 0x00, 0xF0, 0x18, 0x00, 0x00, 0x38, 0x18, 0x00, 0x00, 0x1E, 0x18, 0x00, 0x00, 0x07, 0x18, 0x00, 0xC0, 0x01, 0x18, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x01, 0xC0, 0x67, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0xE0, 0x80, 0x01, 0xC0, 0xC0, 0xC0, 0x00, 0xC0, 0xC0, 0xF3, 0x00, 0xC0, 0x80, 0x7F, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0xFF, 0xFB, 0x00, 0x80, 0xC7, 0xC0, 0x00, 0x80, 0x61, 0x80, 0x01, 0xC0, 0x61, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0x60, 0x80, 0x01, 0xC0, 0xE0, 0xC0, 0x01, 0xC0, 0xC0, 0xF1, 0x00, 0xC0, 0xC0, 0x7F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x01, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x00, 0xF8, 0x01, 0xC0, 0x00, 0x7E, 0x00, 0xC0, 0x80, 0x1F, 0x00, 0xC0, 0xE0, 0x03, 0x00, 0xC0, 0xF8, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x1F, 0xFE, 0x00, 0x80, 0x3F, 0xE7, 0x00, 0xC0, 0xF3, 0xC1, 0x01, 0xC0, 0xE0, 0x81, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xE0, 0x81, 0x01, 0xC0, 0xF3, 0xC1, 0x01, 0x80, 0x3F, 0xE7, 0x00, 0x00, 0x1F, 0x7E, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xFF, 0x81, 0x01, 0x80, 0xC7, 0x81, 0x01, 0xC0, 0x81, 0x83, 0x01, 0xC0, 0x00, 0x83, 0x01, 0xC0, 0x00, 0x83, 0x01, 0xC0, 0x00, 0xC3, 0x01, 0xC0, 0x00, 0xC3, 0x00, 0x80, 0x81, 0xF1, 0x00, 0x80, 0xEF, 0x7F, 0x00, 0x00, 0xFF, 0x1F, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xE0, 0x01, 0x00, 0x78, 0xE0, 0x01, 0x00, 0x78, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x78, 0xC0, 0x1F, 0x00, 0x78, 0xC0, 0x07, 0x00, 0x78, 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, // Code for char ;
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x0C, 0x18, 0x00, 0x00, 0x0C, 0x18, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x0C, 0x18, 0x00, 0x00, 0x0C, 0x18, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x18, 0x0C, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0x60, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x00, 0xE7, 0x01, 0xC0, 0x80, 0xC7, 0x01, 0xC0, 0xC0, 0x01, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0x61, 0x00, 0x00, 0x80, 0x7B, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x10, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x0E, 0xE0, 0x01, 0x00, 0x03, 0x80, 0x01, 0x80, 0xC1, 0x0F, 0x03, 0x80, 0xF0, 0x1F, 0x06, 0xC0, 0x70, 0x38, 0x06, 0xC0, 0x18, 0x30, 0x06, 0xC0, 0x18, 0x30, 0x06, 0xC0, 0x18, 0x18, 0x06, 0xC0, 0xF8, 0x0F, 0x06, 0x80, 0xF9, 0x1F, 0x06, 0x80, 0x03, 0x30, 0x02, 0x00, 0x07, 0x30, 0x03, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xF0, 0x07, 0x00, // Code for char @
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x80, 0x1F, 0x06, 0x00, 0xC0, 0x03, 0x06, 0x00, 0xC0, 0x03, 0x06, 0x00, 0x80, 0x1F, 0x06, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char A
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xE1, 0x80, 0x01, 0x80, 0xFF, 0xC1, 0x01, 0x80, 0x3F, 0xFF, 0x00, 0x00, 0x1F, 0x7F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x07, 0xF0, 0x00, 0x80, 0x03, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x01, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x03, 0xE0, 0x00, 0x80, 0x07, 0x70, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x07, 0xE0, 0x00, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x81, 0xC1, 0x01, 0x80, 0x81, 0xFF, 0x01, 0x80, 0x80, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xB8, 0x07, 0x00, 0x00, 0x1E, 0x1E, 0x00, 0x00, 0x07, 0x3C, 0x00, 0x80, 0x03, 0xF8, 0x00, 0xC0, 0x01, 0xE0, 0x01, 0xC0, 0x00, 0xC0, 0x01, 0x40, 0x00, 0x00, 0x01, // Code for char K
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x07, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x80, 0x7F, 0x00, 0x00, 0xFC, 0x07, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xE0, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x03, 0xE0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x03, 0xE0, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x01, 0x03, 0x00, 0xC0, 0x81, 0x01, 0x00, 0x80, 0xFF, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x03, 0xE0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x03, 0xC0, 0x01, 0xC0, 0x07, 0x80, 0x03, 0xE0, 0x0E, 0x00, 0xFF, 0x7F, 0x1C, 0x00, 0xFE, 0x3F, 0x38, 0x00, 0xF8, 0x0F, 0x10, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x07, 0x00, 0xC0, 0x80, 0x0F, 0x00, 0xC0, 0xC1, 0x3E, 0x00, 0x80, 0xFF, 0xF8, 0x00, 0x00, 0x7F, 0xE0, 0x01, 0x00, 0x3E, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0xC0, 0x00, 0x80, 0x3F, 0xC0, 0x01, 0x80, 0x7B, 0x80, 0x01, 0xC0, 0xE1, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x80, 0xC3, 0x01, 0xC0, 0x01, 0xE7, 0x00, 0x80, 0x01, 0x7F, 0x00, 0x80, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xF8, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x10, 0x40, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char V
-    0x10, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0xFF, 0x01, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0x00, 0xC0, 0x03, 0x00, 0x00, // Code for char W
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x03, 0xE0, 0x01, 0x00, 0x0F, 0x78, 0x00, 0x00, 0x3E, 0x1E, 0x00, 0x00, 0x78, 0x0F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x78, 0x0F, 0x00, 0x00, 0x1E, 0x3E, 0x00, 0x00, 0x0F, 0xF8, 0x00, 0xC0, 0x03, 0xE0, 0x01, 0xC0, 0x00, 0xC0, 0x01, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char Y
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x00, 0xE0, 0x01, 0xC0, 0x00, 0xF0, 0x01, 0xC0, 0x00, 0xBC, 0x01, 0xC0, 0x00, 0x9E, 0x01, 0xC0, 0x00, 0x87, 0x01, 0xC0, 0xC0, 0x83, 0x01, 0xC0, 0xE0, 0x81, 0x01, 0xC0, 0x70, 0x80, 0x01, 0xC0, 0x3C, 0x80, 0x01, 0xC0, 0x1E, 0x80, 0x01, 0xC0, 0x07, 0x80, 0x01, 0xC0, 0x03, 0x80, 0x01, 0xC0, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x1F, 0xC0, 0xFF, 0xFF, 0x1F, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0xFF, 0xFF, 0x1F, 0xC0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, // Code for char _
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x30, 0xFC, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0xC6, 0x00, 0x00, 0x78, 0x66, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0x00, 0xE0, 0x70, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0xC0, 0x01, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFB, 0x00, 0x00, 0x70, 0xE0, 0x00, 0x00, 0x38, 0xC0, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0x80, 0x01, 0x00, 0x10, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0x38, 0xC0, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x30, 0xC0, 0x00, 0x00, 0xE0, 0x70, 0x00, 0xF0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x30, 0xC6, 0x00, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x38, 0x86, 0x01, 0x00, 0xF0, 0x86, 0x01, 0x00, 0xE0, 0xC7, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xF0, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0xE0, 0x03, 0x3E, 0x00, 0xF0, 0xE7, 0x33, 0x00, 0x30, 0xFE, 0x61, 0x00, 0x18, 0x9C, 0x61, 0x00, 0x18, 0x8C, 0x61, 0x00, 0x18, 0x8C, 0x61, 0x00, 0x18, 0x8C, 0x61, 0x00, 0x18, 0x8C, 0x61, 0x00, 0x38, 0x86, 0x61, 0x00, 0xF8, 0x87, 0x71, 0x00, 0xF8, 0x83, 0x33, 0x00, 0x18, 0x00, 0x3F, 0x00, 0x18, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x70, 0xF8, 0xFF, 0x01, 0x70, 0xF8, 0xFF, 0x01, 0x20, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x00, 0x18, 0x00, 0x60, 0x70, 0x18, 0x00, 0x38, 0x70, 0xF8, 0xFF, 0x3F, 0x70, 0xF8, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xC0, 0x3C, 0x00, 0x00, 0x60, 0x78, 0x00, 0x00, 0x30, 0xE0, 0x00, 0x00, 0x18, 0xC0, 0x01, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x00, 0x80, 0x01, 0x30, 0x00, 0x80, 0x01, 0x30, 0x00, 0x80, 0x01, 0x30, 0x00, 0x80, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0xF0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0x38, 0xC0, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x30, 0xC0, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0xE0, 0x70, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0xC0, 0x01, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0x38, 0xC0, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x30, 0xC0, 0x00, 0x00, 0xE0, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xC0, 0x00, 0x00, 0xF0, 0x81, 0x01, 0x00, 0xB8, 0x83, 0x01, 0x00, 0x18, 0x83, 0x01, 0x00, 0x18, 0x87, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x8E, 0x01, 0x00, 0x18, 0xCC, 0x01, 0x00, 0x38, 0xFC, 0x00, 0x00, 0x10, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0x00, 0x18, 0xE0, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x7F, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x10, 0x00, 0x38, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x38, 0x00, 0x00, // Code for char w
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0xC0, 0x01, 0x00, 0x70, 0xE0, 0x00, 0x00, 0xE0, 0x78, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xE0, 0x78, 0x00, 0x00, 0x70, 0xE0, 0x00, 0x00, 0x38, 0xC0, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x60, 0x00, 0x78, 0x00, 0x60, 0x00, 0xF8, 0x01, 0x60, 0x00, 0xE0, 0x07, 0x60, 0x00, 0x00, 0x3F, 0x70, 0x00, 0x00, 0xFC, 0x3C, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0xC0, 0x01, 0x00, 0x18, 0xE0, 0x01, 0x00, 0x18, 0xB8, 0x01, 0x00, 0x18, 0x9C, 0x01, 0x00, 0x18, 0x8E, 0x01, 0x00, 0x18, 0x87, 0x01, 0x00, 0x98, 0x83, 0x01, 0x00, 0xD8, 0x81, 0x01, 0x00, 0xF8, 0x80, 0x01, 0x00, 0x78, 0x80, 0x01, 0x00, 0x38, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xFF, 0xFF, 0x07, 0x80, 0xFF, 0xFC, 0x0F, 0xC0, 0x01, 0x00, 0x0C, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x7F, 0xF0, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x00, 0x00, 0x18, 0xC0, 0x01, 0x00, 0x0C, 0x80, 0xFF, 0xFC, 0x0F, 0x00, 0xFF, 0xFF, 0x07, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x03, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0xC0, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x3F, 0x00, 0x78, 0xFE, 0x3F, 0x00, 0x78, 0xFC, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x3E, 0x1F, 0x00, 0x00, 0x0E, 0x1C, 0x00, 0x00, 0x07, 0x38, 0x00, 0x00, 0x03, 0x30, 0x00, 0xC0, 0x03, 0xF0, 0x01, 0xC0, 0x03, 0xF0, 0x01, 0x00, 0x03, 0x30, 0x00, 0x00, 0x03, 0x30, 0x00, 0x00, 0x03, 0x30, 0x00, 0x00, 0x03, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x81, 0x01, 0x00, 0x80, 0xC1, 0x01, 0x00, 0xFF, 0xFF, 0x01, 0x80, 0xFF, 0xBF, 0x01, 0x80, 0x83, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x80, 0x81, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0xEE, 0x1D, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0xEE, 0x1D, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x33, 0x00, 0x00, 0x1F, 0x33, 0x00, 0x00, 0x7C, 0x33, 0x00, 0x00, 0xF0, 0x33, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xE0, 0x33, 0x00, 0x00, 0x7C, 0x33, 0x00, 0x00, 0x1F, 0x33, 0x00, 0xC0, 0x07, 0x33, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, 0xE0, 0x7F, 0xF0, 0x3F, 0xE0, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xF1, 0xC0, 0x00, 0xE0, 0xFB, 0x81, 0x01, 0x70, 0x8F, 0x83, 0x01, 0x30, 0x0E, 0x83, 0x01, 0x30, 0x0E, 0x87, 0x01, 0x30, 0x0C, 0x86, 0x01, 0x30, 0x1C, 0x8E, 0x01, 0x30, 0x18, 0xDF, 0x00, 0x70, 0xF8, 0xFF, 0x00, 0x20, 0xE0, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x10, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0x07, 0x70, 0x00, 0x80, 0xE1, 0xC3, 0x00, 0x80, 0xF8, 0x8F, 0x00, 0xC0, 0x18, 0x8C, 0x01, 0xC0, 0x0C, 0x98, 0x01, 0x40, 0x0C, 0x18, 0x01, 0x40, 0x0C, 0x18, 0x01, 0xC0, 0x0C, 0x98, 0x01, 0xC0, 0x0C, 0x98, 0x01, 0x80, 0x00, 0x80, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x00, 0x07, 0x70, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0xF0, 0x07, 0x00, // Code for char ©
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0xC0, 0x3C, 0x00, 0x00, 0xC0, 0x36, 0x00, 0x00, 0xC0, 0x32, 0x00, 0x00, 0xC0, 0x32, 0x00, 0x00, 0xC0, 0x12, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x10, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0x07, 0x70, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x00, 0x80, 0x00, 0xC0, 0xFC, 0x9F, 0x01, 0xC0, 0xFC, 0x9F, 0x01, 0x40, 0x8C, 0x01, 0x01, 0x40, 0x8C, 0x03, 0x01, 0xC0, 0x8C, 0x87, 0x01, 0xC0, 0xF8, 0x9E, 0x01, 0x80, 0x78, 0x98, 0x00, 0x80, 0x01, 0xD0, 0x00, 0x00, 0x07, 0x70, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0xF0, 0x07, 0x00, // Code for char ®
-    0x10, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, // Code for char ¯
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xFE, 0x9F, 0x01, 0x00, 0xFE, 0x9F, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0xC0, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0x00, 0x00, 0xC0, 0xE0, 0x00, 0x00, 0xC0, 0xF0, 0x00, 0x00, 0xC0, 0xD8, 0x00, 0x00, 0xC0, 0xDC, 0x00, 0x00, 0xC0, 0xCF, 0x00, 0x00, 0x80, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC4, 0x00, 0x00, 0xC0, 0xC4, 0x00, 0x00, 0xC0, 0xCC, 0x00, 0x00, 0xC0, 0x7B, 0x00, 0x00, 0x80, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0xF8, 0xFF, 0x7F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xF0, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF, 0x0F, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x0F, 0xF0, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0x00, 0xC0, 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, // Code for char ¹
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0xC0, 0x30, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x10, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0x01, 0xC0, 0xFF, 0xC0, 0x01, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xE0, 0x61, 0x00, 0x00, 0x78, 0x78, 0x00, 0x00, 0x1E, 0x6C, 0x00, 0x80, 0x07, 0x66, 0x00, 0xC0, 0x01, 0x63, 0x00, 0x40, 0x80, 0xFF, 0x01, 0x00, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x60, 0x00, // Code for char ¼
-    0x10, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x01, 0xC0, 0xFF, 0xC0, 0x01, 0xC0, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x07, 0x81, 0x01, 0xC0, 0x81, 0xC1, 0x01, 0x40, 0x80, 0xE1, 0x01, 0x00, 0x80, 0xB1, 0x01, 0x00, 0x80, 0xB9, 0x01, 0x00, 0x80, 0x9F, 0x01, // Code for char ½
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC4, 0x00, 0x01, 0xC0, 0xC4, 0xC0, 0x01, 0xC0, 0xCC, 0xF0, 0x00, 0xC0, 0x7B, 0x3C, 0x00, 0x80, 0x7B, 0x0F, 0x00, 0x00, 0xC0, 0x63, 0x00, 0x00, 0xE0, 0x79, 0x00, 0x00, 0x78, 0x6C, 0x00, 0x00, 0x1E, 0x66, 0x00, 0x80, 0x07, 0x63, 0x00, 0xC0, 0x81, 0xFF, 0x01, 0x40, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x60, 0x00, // Code for char ¾
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xE0, 0x1D, 0x00, 0x00, 0x70, 0x38, 0x00, 0x00, 0x30, 0x30, 0x00, 0x38, 0x1E, 0x30, 0x00, 0x78, 0x0E, 0x30, 0x00, 0x38, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x01, 0xFE, 0x06, 0x00, 0x83, 0x1F, 0x06, 0x00, 0xC7, 0x03, 0x06, 0x00, 0xCE, 0x03, 0x06, 0x00, 0x88, 0x1F, 0x06, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char À
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x80, 0x1F, 0x06, 0x00, 0xC8, 0x03, 0x06, 0x00, 0xCE, 0x03, 0x06, 0x00, 0x87, 0x1F, 0x06, 0x00, 0x03, 0xFE, 0x06, 0x00, 0x01, 0xF0, 0x07, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char Á
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x08, 0xF0, 0x07, 0x00, 0x0C, 0xFE, 0x06, 0x00, 0x86, 0x1F, 0x06, 0x00, 0xC7, 0x03, 0x06, 0x00, 0xC3, 0x03, 0x06, 0x00, 0x87, 0x1F, 0x06, 0x00, 0x06, 0xFE, 0x06, 0x00, 0x0C, 0xF0, 0x07, 0x00, 0x08, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char Â
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x0C, 0xF0, 0x07, 0x00, 0x07, 0xFE, 0x06, 0x00, 0x83, 0x1F, 0x06, 0x00, 0xC3, 0x03, 0x06, 0x00, 0xC6, 0x03, 0x06, 0x00, 0x8C, 0x1F, 0x06, 0x00, 0x0C, 0xFE, 0x06, 0x00, 0x0E, 0xF0, 0x07, 0x00, 0x03, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char Ã
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x0E, 0xFE, 0x06, 0x00, 0x8E, 0x1F, 0x06, 0x00, 0xC4, 0x03, 0x06, 0x00, 0xC0, 0x03, 0x06, 0x00, 0x84, 0x1F, 0x06, 0x00, 0x0E, 0xFE, 0x06, 0x00, 0x0E, 0xF0, 0x07, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char Ä
-    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x3C, 0xFE, 0x06, 0x00, 0xEE, 0x1F, 0x06, 0x00, 0xC2, 0x03, 0x06, 0x00, 0xC2, 0x03, 0x06, 0x00, 0xFE, 0x1F, 0x06, 0x00, 0x3C, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x01, // Code for char Å
-    0x0F, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xFC, 0x01, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xC0, 0x1F, 0x06, 0x00, 0xC0, 0x00, 0x06, 0x00, 0xC0, 0x00, 0x06, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char Æ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x07, 0xF0, 0x00, 0x80, 0x03, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x41, 0xC0, 0x00, 0x80, 0x45, 0xC0, 0x00, 0x80, 0x6F, 0xC0, 0x00, 0x80, 0x79, 0xC0, 0x00, 0x80, 0x39, 0xC0, 0x01, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC1, 0xC0, 0x80, 0x01, 0xC3, 0xC0, 0x80, 0x01, 0xC7, 0xC0, 0x80, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xC8, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char È
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC8, 0xC0, 0x80, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xC7, 0xC0, 0x80, 0x01, 0xC3, 0xC0, 0x80, 0x01, 0xC1, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char É
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC8, 0xFF, 0xFF, 0x01, 0xCC, 0xC0, 0x80, 0x01, 0xC6, 0xC0, 0x80, 0x01, 0xC7, 0xC0, 0x80, 0x01, 0xC3, 0xC0, 0x80, 0x01, 0xC7, 0xC0, 0x80, 0x01, 0xC6, 0xC0, 0x80, 0x01, 0xCC, 0xC0, 0x80, 0x01, 0xC8, 0xC0, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ê
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xC4, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC4, 0xC0, 0x80, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xCE, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ë
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC1, 0x00, 0x80, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC7, 0xFF, 0xFF, 0x01, 0xCE, 0xFF, 0xFF, 0x01, 0xC8, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC8, 0xFF, 0xFF, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC1, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC8, 0x00, 0x80, 0x01, 0xCC, 0x00, 0x80, 0x01, 0xC6, 0x00, 0x80, 0x01, 0xC7, 0xFF, 0xFF, 0x01, 0xC3, 0xFF, 0xFF, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xC6, 0x00, 0x80, 0x01, 0xCC, 0x00, 0x80, 0x01, 0xC8, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC4, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC4, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x0F, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0x80, 0x01, 0xC0, 0xC0, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x03, 0xE0, 0x00, 0x80, 0x07, 0x70, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0xCC, 0x03, 0x00, 0x00, 0x07, 0x0F, 0x00, 0x00, 0x03, 0x7C, 0x00, 0x00, 0x03, 0xF0, 0x01, 0x00, 0x06, 0xC0, 0x07, 0x00, 0x0C, 0x00, 0x1F, 0x00, 0x0C, 0x00, 0x78, 0x00, 0x0E, 0x00, 0xE0, 0x01, 0xC3, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x03, 0xE0, 0x00, 0xC1, 0x01, 0xC0, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC8, 0x00, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x01, 0x80, 0x03, 0xE0, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x03, 0xE0, 0x00, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC8, 0x00, 0x80, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xC3, 0x01, 0xC0, 0x01, 0x81, 0x03, 0xE0, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x88, 0x03, 0xE0, 0x00, 0xCC, 0x01, 0xC0, 0x01, 0xC6, 0x00, 0x80, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC7, 0x00, 0x80, 0x01, 0xC6, 0x01, 0xC0, 0x01, 0x8C, 0x03, 0xE0, 0x00, 0x08, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x8C, 0x03, 0xE0, 0x00, 0xC7, 0x01, 0xC0, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC3, 0x00, 0x80, 0x01, 0xC6, 0x00, 0x80, 0x01, 0xCC, 0x00, 0x80, 0x01, 0xCC, 0x01, 0xC0, 0x01, 0x8E, 0x03, 0xE0, 0x00, 0x03, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x80, 0x03, 0xE0, 0x00, 0xCE, 0x01, 0xC0, 0x01, 0xCE, 0x00, 0x80, 0x01, 0xC4, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC4, 0x00, 0x80, 0x01, 0xCE, 0x01, 0xC0, 0x01, 0x8E, 0x03, 0xE0, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x1C, 0x1C, 0x00, 0x00, 0x38, 0x0E, 0x00, 0x00, 0x70, 0x07, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x70, 0x07, 0x00, 0x00, 0x38, 0x0E, 0x00, 0x00, 0x1C, 0x1C, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x01, 0x00, 0xFE, 0xFF, 0x03, 0x00, 0xFF, 0xFF, 0x01, 0x80, 0x03, 0xF8, 0x00, 0xC0, 0x01, 0xDC, 0x01, 0xC0, 0x00, 0x8F, 0x01, 0xC0, 0x80, 0x83, 0x01, 0xC0, 0xE0, 0x81, 0x01, 0xC0, 0x78, 0x80, 0x01, 0xC0, 0x3D, 0xC0, 0x01, 0x80, 0x0F, 0xE0, 0x00, 0x80, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0x40, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x01, 0x00, 0xC0, 0x01, 0x03, 0x00, 0x80, 0x01, 0x07, 0x00, 0x80, 0x01, 0x0E, 0x00, 0x80, 0x01, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xF8, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x08, 0x00, 0x80, 0x01, 0x0E, 0x00, 0x80, 0x01, 0x07, 0x00, 0x80, 0x01, 0x03, 0x00, 0xC0, 0x01, 0x01, 0x00, 0xF8, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x08, 0x00, 0xF8, 0x00, 0x0C, 0x00, 0xC0, 0x01, 0x06, 0x00, 0x80, 0x01, 0x07, 0x00, 0x80, 0x01, 0x03, 0x00, 0x80, 0x01, 0x07, 0x00, 0x80, 0x01, 0x06, 0x00, 0xC0, 0x01, 0x0C, 0x00, 0xF8, 0x00, 0xC8, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x0E, 0x00, 0xC0, 0x01, 0x0E, 0x00, 0x80, 0x01, 0x04, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x04, 0x00, 0x80, 0x01, 0x0E, 0x00, 0xC0, 0x01, 0x0E, 0x00, 0xF8, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x08, 0xC0, 0xFF, 0x01, 0x0E, 0x80, 0xFF, 0x01, 0x07, 0xE0, 0x03, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x01, 0x3C, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char Ý
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xC0, 0xFF, 0xFF, 0x01, 0x00, 0x06, 0x18, 0x00, 0x00, 0x06, 0x18, 0x00, 0x00, 0x06, 0x18, 0x00, 0x00, 0x06, 0x18, 0x00, 0x00, 0x06, 0x18, 0x00, 0x00, 0x0E, 0x1C, 0x00, 0x00, 0x0E, 0x0C, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x30, 0x00, 0x80, 0x01, 0x30, 0xF8, 0x80, 0x01, 0x30, 0xFC, 0x81, 0x01, 0x70, 0x8E, 0x83, 0x01, 0xE0, 0x87, 0x83, 0x01, 0xC0, 0x03, 0xEF, 0x01, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x30, 0xFC, 0x01, 0x20, 0x18, 0x86, 0x01, 0x60, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0xC0, 0x19, 0x86, 0x01, 0x00, 0x19, 0xC6, 0x00, 0x00, 0x78, 0x66, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x30, 0xFC, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x19, 0x86, 0x01, 0xC0, 0x19, 0x86, 0x01, 0xE0, 0x18, 0xC6, 0x00, 0x60, 0x78, 0x66, 0x00, 0x20, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x31, 0xFC, 0x01, 0x80, 0x19, 0x86, 0x01, 0xC0, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0x60, 0x18, 0x86, 0x01, 0xE0, 0x18, 0xC6, 0x00, 0xC0, 0x78, 0x66, 0x00, 0x80, 0xF1, 0xFF, 0x01, 0x00, 0xE1, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x80, 0x31, 0xFC, 0x01, 0xE0, 0x18, 0x86, 0x01, 0x60, 0x18, 0x86, 0x01, 0x60, 0x18, 0x86, 0x01, 0xC0, 0x18, 0x86, 0x01, 0x80, 0x19, 0xC6, 0x00, 0x80, 0x79, 0x66, 0x00, 0xC0, 0xF1, 0xFF, 0x01, 0x60, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x30, 0xFC, 0x01, 0xE0, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0x40, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x40, 0x18, 0xC6, 0x00, 0xE0, 0x78, 0x66, 0x00, 0xE0, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x00, 0x30, 0xFC, 0x01, 0xF0, 0x18, 0x86, 0x01, 0xB8, 0x19, 0x86, 0x01, 0x08, 0x19, 0x86, 0x01, 0x08, 0x19, 0x86, 0x01, 0xF8, 0x19, 0xC6, 0x00, 0xF0, 0x78, 0x66, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x30, 0xFC, 0x01, 0x00, 0x18, 0xCE, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x38, 0xC6, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF6, 0x00, 0x00, 0x18, 0xC6, 0x01, 0x00, 0x18, 0x86, 0x01, 0x00, 0x78, 0x86, 0x01, 0x00, 0xF0, 0x87, 0x01, 0x00, 0xC0, 0xC7, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char æ
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFB, 0x00, 0x00, 0x70, 0xE0, 0x00, 0x00, 0x38, 0xC0, 0x41, 0x00, 0x18, 0x80, 0x45, 0x00, 0x18, 0x80, 0x6F, 0x00, 0x18, 0x80, 0x79, 0x00, 0x18, 0x80, 0x39, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0x80, 0x01, 0x00, 0x10, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x20, 0x30, 0xC6, 0x00, 0x60, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0xC0, 0x19, 0x86, 0x01, 0x00, 0x19, 0x86, 0x01, 0x00, 0x38, 0x86, 0x01, 0x00, 0xF0, 0x86, 0x01, 0x00, 0xE0, 0xC7, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x30, 0xC6, 0x00, 0x00, 0x18, 0x86, 0x01, 0x00, 0x19, 0x86, 0x01, 0xC0, 0x19, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0x60, 0x38, 0x86, 0x01, 0x20, 0xF0, 0x86, 0x01, 0x00, 0xE0, 0xC7, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF1, 0xFF, 0x00, 0x80, 0x31, 0xC6, 0x00, 0xC0, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0x60, 0x18, 0x86, 0x01, 0xE0, 0x18, 0x86, 0x01, 0xC0, 0x38, 0x86, 0x01, 0x80, 0xF1, 0x86, 0x01, 0x00, 0xE1, 0xC7, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xE0, 0x30, 0xC6, 0x00, 0xE0, 0x18, 0x86, 0x01, 0x40, 0x18, 0x86, 0x01, 0x00, 0x18, 0x86, 0x01, 0x40, 0x18, 0x86, 0x01, 0xE0, 0x38, 0x86, 0x01, 0xE0, 0xF0, 0x86, 0x01, 0x00, 0xE0, 0xC7, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x20, 0x18, 0x80, 0x01, 0x60, 0x18, 0x80, 0x01, 0xE0, 0xF8, 0xFF, 0x01, 0xC0, 0xF9, 0xFF, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0xF9, 0xFF, 0x01, 0xC0, 0xF9, 0xFF, 0x01, 0xE0, 0x00, 0x80, 0x01, 0x60, 0x00, 0x80, 0x01, 0x20, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x19, 0x80, 0x01, 0x80, 0x19, 0x80, 0x01, 0xC0, 0x18, 0x80, 0x01, 0xE0, 0xF8, 0xFF, 0x01, 0x60, 0xF8, 0xFF, 0x01, 0xE0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char î
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0x40, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x40, 0x00, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0xE1, 0xFB, 0x00, 0x30, 0x73, 0xC0, 0x01, 0xF0, 0x31, 0x80, 0x01, 0xE0, 0x31, 0x80, 0x01, 0xC0, 0x30, 0x80, 0x01, 0xC0, 0x31, 0x80, 0x01, 0xE0, 0x67, 0xC0, 0x00, 0x30, 0xFF, 0xF9, 0x00, 0x20, 0xFC, 0x7F, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x80, 0xE1, 0x01, 0x00, 0xE0, 0x30, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0xC0, 0x18, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x80, 0x39, 0x00, 0x00, 0xC0, 0x79, 0x00, 0x00, 0x60, 0xF0, 0xFF, 0x01, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x20, 0x38, 0xC0, 0x00, 0x60, 0x18, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0xC0, 0x19, 0x80, 0x01, 0x00, 0x19, 0x80, 0x01, 0x00, 0x30, 0xC0, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0x38, 0xC0, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x19, 0x80, 0x01, 0xC0, 0x19, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0x60, 0x30, 0xC0, 0x00, 0x20, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF1, 0xF9, 0x00, 0x80, 0x39, 0xC0, 0x00, 0xC0, 0x18, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0x60, 0x18, 0x80, 0x01, 0xE0, 0x18, 0x80, 0x01, 0xC0, 0x30, 0xC0, 0x00, 0x80, 0xF1, 0xF9, 0x00, 0x00, 0xE1, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0xF1, 0xF9, 0x00, 0xE0, 0x38, 0xC0, 0x00, 0x60, 0x18, 0x80, 0x01, 0x60, 0x18, 0x80, 0x01, 0xC0, 0x18, 0x80, 0x01, 0x80, 0x19, 0x80, 0x01, 0x80, 0x31, 0xC0, 0x00, 0xC0, 0xF1, 0xF9, 0x00, 0x60, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xF0, 0xF9, 0x00, 0xE0, 0x38, 0xC0, 0x00, 0xE0, 0x18, 0x80, 0x01, 0x40, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x40, 0x18, 0x80, 0x01, 0xE0, 0x30, 0xC0, 0x00, 0xE0, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xCE, 0x1C, 0x00, 0x00, 0xCE, 0x1C, 0x00, 0x00, 0xCE, 0x1C, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xE0, 0xFF, 0x01, 0x00, 0xF0, 0xF9, 0x01, 0x00, 0x38, 0xE0, 0x01, 0x00, 0x18, 0xB8, 0x01, 0x00, 0x18, 0x9E, 0x01, 0x00, 0x98, 0x87, 0x01, 0x00, 0xD8, 0x81, 0x01, 0x00, 0xF0, 0xC0, 0x01, 0x00, 0xF8, 0xF9, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x20, 0x00, 0xC0, 0x01, 0x60, 0x00, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0xC0, 0x01, 0x80, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x01, 0x80, 0x01, 0xC0, 0x01, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0x60, 0x00, 0xC0, 0x00, 0x20, 0x00, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x01, 0xE0, 0x01, 0x80, 0x01, 0xC0, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0x60, 0x00, 0x80, 0x01, 0xE0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0xC0, 0x00, 0x80, 0x01, 0x70, 0x00, 0x00, 0xF9, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x01, 0xE0, 0x00, 0xC0, 0x01, 0xE0, 0x00, 0x80, 0x01, 0x40, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x40, 0x00, 0x80, 0x01, 0xE0, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0x70, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x60, 0x00, 0x78, 0x00, 0x60, 0x00, 0xF8, 0x01, 0x60, 0x00, 0xE0, 0x07, 0x60, 0x00, 0x00, 0x3F, 0x70, 0x00, 0x00, 0xFC, 0x3C, 0x00, 0x01, 0xE0, 0x1F, 0xC0, 0x01, 0xE0, 0x07, 0xE0, 0x00, 0xF8, 0x01, 0x60, 0x00, 0x3F, 0x00, 0x20, 0xC0, 0x0F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x7F, 0xF0, 0xFF, 0xFF, 0x7F, 0x00, 0xE0, 0x70, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x18, 0x80, 0x01, 0x00, 0x38, 0xC0, 0x01, 0x00, 0xF0, 0xF9, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x60, 0x00, 0x78, 0x00, 0x60, 0x00, 0xF8, 0x01, 0x60, 0x00, 0xE0, 0x07, 0x60, 0xE0, 0x00, 0x3F, 0x70, 0xE0, 0x00, 0xFC, 0x3C, 0x40, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xE0, 0x07, 0x40, 0x00, 0xF8, 0x01, 0xE0, 0x00, 0x3F, 0x00, 0xE0, 0xC0, 0x0F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_mono_16x31 = {
-    Droid_Sans_Mono16x31,
-    16,
-    31,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_droid_sans_mono_7x13.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Droid_Sans_Mono7x13
-//GLCD FontSize : 7 x 13
-
-static const uint8_t Droid_Sans_Mono7x13[ ] = {
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x05, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x06, 0x90, 0x00, 0xD0, 0x03, 0xBC, 0x00, 0xD0, 0x03, 0xBC, 0x00, 0x90, 0x00, 0x00, 0x00, // Code for char #
-    0x06, 0x00, 0x00, 0x18, 0x02, 0x24, 0x02, 0xFE, 0x07, 0x44, 0x02, 0xC4, 0x01, 0x00, 0x00, // Code for char $
-    0x07, 0x18, 0x00, 0x24, 0x02, 0x98, 0x01, 0x60, 0x00, 0x98, 0x01, 0x44, 0x02, 0x80, 0x01, // Code for char %
-    0x07, 0x00, 0x00, 0xDC, 0x01, 0x24, 0x02, 0x64, 0x02, 0x9C, 0x03, 0xC0, 0x03, 0x00, 0x02, // Code for char &
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x05, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x04, 0x08, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x06, 0x00, 0x00, 0x10, 0x00, 0x70, 0x00, 0x1C, 0x00, 0x70, 0x00, 0x10, 0x00, 0x00, 0x00, // Code for char *
-    0x06, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF0, 0x01, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char +
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x05, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x80, 0x01, 0x60, 0x00, 0x18, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char /
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char 0
-    0x04, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0xFC, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x04, 0x03, 0x84, 0x02, 0x44, 0x02, 0x38, 0x02, 0x00, 0x00, // Code for char 2
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0xD8, 0x01, 0x00, 0x00, // Code for char 3
-    0x06, 0x00, 0x00, 0xC0, 0x00, 0xB0, 0x00, 0x88, 0x00, 0xFC, 0x03, 0x80, 0x00, 0x00, 0x00, // Code for char 4
-    0x06, 0x00, 0x00, 0x3C, 0x02, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0xC4, 0x01, 0x00, 0x00, // Code for char 5
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x28, 0x02, 0x24, 0x02, 0x24, 0x02, 0xC4, 0x01, 0x00, 0x00, // Code for char 6
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x04, 0x02, 0xC4, 0x01, 0x34, 0x00, 0x0C, 0x00, 0x00, 0x00, // Code for char 7
-    0x06, 0x00, 0x00, 0xD8, 0x01, 0x24, 0x02, 0x24, 0x02, 0x64, 0x02, 0x98, 0x01, 0x00, 0x00, // Code for char 8
-    0x06, 0x00, 0x00, 0x38, 0x02, 0x44, 0x02, 0x44, 0x02, 0x44, 0x01, 0xF8, 0x00, 0x00, 0x00, // Code for char 9
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x30, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x06, 0x00, 0x00, 0x40, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x00, 0x00, // Code for char <
-    0x06, 0x00, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x00, 0x00, // Code for char =
-    0x06, 0x00, 0x00, 0x10, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char >
-    0x05, 0x00, 0x00, 0x04, 0x00, 0x44, 0x03, 0x24, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x07, 0xF0, 0x01, 0x08, 0x02, 0xE4, 0x05, 0x14, 0x05, 0xF4, 0x04, 0x08, 0x05, 0xF0, 0x00, // Code for char @
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB8, 0x00, 0x84, 0x00, 0xB8, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char A
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0xD8, 0x01, 0x00, 0x00, // Code for char B
-    0x06, 0x00, 0x00, 0xF0, 0x00, 0x0C, 0x03, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char C
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x04, 0x02, 0x04, 0x02, 0x0C, 0x01, 0xF0, 0x00, 0x00, 0x00, // Code for char D
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char E
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x00, 0x00, // Code for char F
-    0x06, 0x00, 0x00, 0xF0, 0x00, 0x0C, 0x03, 0x04, 0x02, 0x24, 0x02, 0xE4, 0x03, 0x00, 0x00, // Code for char G
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xFC, 0x03, 0x00, 0x00, // Code for char H
-    0x06, 0x00, 0x00, 0x04, 0x02, 0x04, 0x02, 0xFC, 0x03, 0x04, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char I
-    0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x20, 0x00, 0x50, 0x00, 0x88, 0x01, 0x04, 0x02, 0x00, 0x00, // Code for char K
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char L
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0xF0, 0x00, 0x00, 0x03, 0xF0, 0x00, 0xFC, 0x03, 0x00, 0x00, // Code for char M
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x18, 0x00, 0x60, 0x00, 0x80, 0x01, 0xFC, 0x03, 0x00, 0x00, // Code for char N
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char O
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x38, 0x00, 0x00, 0x00, // Code for char P
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x04, 0x02, 0x04, 0x02, 0x04, 0x06, 0xF8, 0x09, 0x00, 0x00, // Code for char Q
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x44, 0x00, 0x44, 0x00, 0xC4, 0x00, 0x38, 0x01, 0x00, 0x02, // Code for char R
-    0x06, 0x00, 0x00, 0x18, 0x02, 0x24, 0x02, 0x24, 0x02, 0x44, 0x02, 0xC4, 0x01, 0x00, 0x00, // Code for char S
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0xFC, 0x03, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char T
-    0x06, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char U
-    0x07, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x30, 0x00, 0x0C, 0x00, // Code for char V
-    0x07, 0x7C, 0x00, 0x80, 0x03, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x80, 0x03, 0x7C, 0x00, // Code for char W
-    0x07, 0x04, 0x02, 0x08, 0x01, 0x90, 0x00, 0x60, 0x00, 0x90, 0x00, 0x08, 0x01, 0x04, 0x02, // Code for char X
-    0x07, 0x04, 0x00, 0x18, 0x00, 0x20, 0x00, 0xC0, 0x03, 0x20, 0x00, 0x18, 0x00, 0x04, 0x00, // Code for char Y
-    0x06, 0x00, 0x00, 0x04, 0x03, 0x84, 0x02, 0x64, 0x02, 0x14, 0x02, 0x0C, 0x02, 0x00, 0x00, // Code for char Z
-    0x05, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x0F, 0x04, 0x08, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x18, 0x00, 0x60, 0x00, 0x80, 0x01, 0x00, 0x02, 0x00, 0x00, // Code for char BackSlash
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x04, 0x08, 0x04, 0x08, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x06, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x04, 0x00, 0x38, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char ^
-    0x07, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, // Code for char _
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x50, 0x02, 0x50, 0x02, 0x50, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char a
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char b
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x00, 0x00, // Code for char c
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xFC, 0x03, 0x00, 0x00, // Code for char d
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x50, 0x02, 0x50, 0x02, 0x50, 0x02, 0x60, 0x02, 0x00, 0x00, // Code for char e
-    0x06, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0xFC, 0x03, 0x14, 0x00, 0x14, 0x00, 0x00, 0x00, // Code for char f
-    0x07, 0x00, 0x00, 0x60, 0x0F, 0x90, 0x12, 0x90, 0x12, 0x90, 0x12, 0x70, 0x12, 0x10, 0x0C, // Code for char g
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0xE0, 0x03, 0x00, 0x00, // Code for char h
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x10, 0x02, 0xF4, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char i
-    0x05, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF4, 0x0F, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x07, 0x00, 0x00, 0xFC, 0x03, 0x40, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x00, 0x02, // Code for char k
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x04, 0x02, 0xFC, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char l
-    0x06, 0x00, 0x00, 0xF0, 0x03, 0x10, 0x00, 0xF0, 0x03, 0x10, 0x00, 0xF0, 0x03, 0x00, 0x00, // Code for char m
-    0x06, 0x00, 0x00, 0xF0, 0x03, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0xE0, 0x03, 0x00, 0x00, // Code for char n
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char o
-    0x06, 0x00, 0x00, 0xF0, 0x1F, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char p
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xF0, 0x1F, 0x00, 0x00, // Code for char q
-    0x06, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, // Code for char r
-    0x06, 0x00, 0x00, 0x60, 0x02, 0x50, 0x02, 0x50, 0x02, 0x90, 0x02, 0x90, 0x01, 0x00, 0x00, // Code for char s
-    0x06, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0xFC, 0x03, 0x10, 0x02, 0x10, 0x02, 0x00, 0x00, // Code for char t
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char u
-    0x06, 0x00, 0x00, 0x30, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xC0, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char v
-    0x07, 0xF0, 0x00, 0x00, 0x03, 0xE0, 0x00, 0x10, 0x00, 0xE0, 0x01, 0x00, 0x03, 0xF0, 0x00, // Code for char w
-    0x06, 0x00, 0x00, 0x10, 0x02, 0x20, 0x01, 0xC0, 0x00, 0x20, 0x01, 0x10, 0x02, 0x00, 0x00, // Code for char x
-    0x06, 0x00, 0x00, 0x30, 0x10, 0xC0, 0x10, 0x00, 0x0F, 0xC0, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char y
-    0x06, 0x00, 0x00, 0x10, 0x02, 0x10, 0x03, 0xD0, 0x02, 0x30, 0x02, 0x10, 0x02, 0x00, 0x00, // Code for char z
-    0x06, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0xB8, 0x07, 0x04, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char {
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x06, 0x00, 0x00, 0x04, 0x08, 0x04, 0x08, 0xB8, 0x07, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char }
-    0x06, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x60, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char ~
-    0x03, 0xF8, 0x07, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x06, 0x00, 0x00, 0xF0, 0x00, 0x08, 0x01, 0x0C, 0x03, 0x08, 0x01, 0x08, 0x01, 0x00, 0x00, // Code for char ¢
-    0x06, 0x00, 0x00, 0x20, 0x02, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char £
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xF0, 0x01, 0x00, 0x00, // Code for char ¤
-    0x06, 0x00, 0x00, 0x04, 0x00, 0x78, 0x01, 0xC0, 0x03, 0x78, 0x01, 0x04, 0x00, 0x00, 0x00, // Code for char ¥
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x06, 0x00, 0x00, 0x6C, 0x02, 0x54, 0x02, 0x94, 0x02, 0x94, 0x02, 0x64, 0x01, 0x00, 0x00, // Code for char §
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x07, 0xF8, 0x01, 0x04, 0x02, 0x64, 0x02, 0x94, 0x02, 0x94, 0x02, 0x04, 0x02, 0xF8, 0x01, // Code for char ©
-    0x05, 0x00, 0x00, 0x74, 0x00, 0x54, 0x00, 0x54, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x06, 0x00, 0x00, 0x40, 0x00, 0xB0, 0x01, 0x00, 0x00, 0x40, 0x00, 0xB0, 0x01, 0x00, 0x00, // Code for char «
-    0x06, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xC0, 0x01, 0x00, 0x00, // Code for char ¬
-    0x05, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x07, 0xF8, 0x01, 0x04, 0x02, 0xF4, 0x02, 0x54, 0x02, 0xB4, 0x02, 0x04, 0x02, 0xF8, 0x01, // Code for char ®
-    0x07, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, // Code for char ¯
-    0x05, 0x00, 0x00, 0x18, 0x00, 0x24, 0x00, 0x24, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x06, 0x00, 0x00, 0x40, 0x02, 0x40, 0x02, 0xF0, 0x03, 0x40, 0x02, 0x40, 0x02, 0x00, 0x00, // Code for char ±
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x64, 0x00, 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x54, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x06, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char µ
-    0x06, 0x00, 0x00, 0x38, 0x00, 0x7C, 0x00, 0xFC, 0x07, 0x04, 0x00, 0xFC, 0x07, 0x00, 0x00, // Code for char ¶
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x05, 0x00, 0x00, 0x38, 0x00, 0x44, 0x00, 0x44, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x06, 0x00, 0x00, 0xB0, 0x01, 0x40, 0x00, 0x00, 0x00, 0xB0, 0x01, 0x40, 0x00, 0x00, 0x00, // Code for char »
-    0x07, 0x04, 0x00, 0x7C, 0x02, 0x80, 0x01, 0x60, 0x00, 0x98, 0x01, 0x44, 0x01, 0xE0, 0x03, // Code for char ¼
-    0x07, 0x04, 0x00, 0x7C, 0x02, 0x80, 0x01, 0x60, 0x00, 0x38, 0x02, 0x24, 0x03, 0xE0, 0x02, // Code for char ½
-    0x07, 0x44, 0x00, 0x54, 0x02, 0xFC, 0x01, 0x60, 0x00, 0x98, 0x01, 0x44, 0x01, 0xE0, 0x03, // Code for char ¾
-    0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x09, 0xB0, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB8, 0x00, 0x85, 0x00, 0xB8, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char À
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB8, 0x00, 0x85, 0x00, 0xB8, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char Á
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB9, 0x00, 0x84, 0x00, 0xB9, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char Â
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB9, 0x00, 0x84, 0x00, 0xB9, 0x00, 0xC1, 0x01, 0x00, 0x02, // Code for char Ã
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xB9, 0x00, 0x84, 0x00, 0xB9, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char Ä
-    0x07, 0x00, 0x02, 0xC0, 0x01, 0xBF, 0x00, 0x85, 0x00, 0xBF, 0x00, 0xC0, 0x01, 0x00, 0x02, // Code for char Å
-    0x06, 0x00, 0x03, 0xF0, 0x00, 0x8C, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char Æ
-    0x06, 0x00, 0x00, 0xF0, 0x00, 0x0C, 0x03, 0x04, 0x12, 0x04, 0x0E, 0x04, 0x02, 0x00, 0x00, // Code for char Ç
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x25, 0x02, 0x24, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char È
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x25, 0x02, 0x24, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char É
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x25, 0x02, 0x24, 0x02, 0x25, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char Ê
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x25, 0x02, 0x24, 0x02, 0x25, 0x02, 0x24, 0x02, 0x00, 0x00, // Code for char Ë
-    0x06, 0x00, 0x00, 0x04, 0x02, 0x04, 0x02, 0xFD, 0x03, 0x04, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char Ì
-    0x06, 0x00, 0x00, 0x04, 0x02, 0x04, 0x02, 0xFD, 0x03, 0x04, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char Í
-    0x06, 0x00, 0x00, 0x04, 0x02, 0x05, 0x02, 0xFC, 0x03, 0x05, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char Î
-    0x06, 0x00, 0x00, 0x04, 0x02, 0x05, 0x02, 0xFC, 0x03, 0x05, 0x02, 0x04, 0x02, 0x00, 0x00, // Code for char Ï
-    0x06, 0x20, 0x00, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x0C, 0x01, 0xF0, 0x00, 0x00, 0x00, // Code for char Ð
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x19, 0x00, 0x60, 0x00, 0x81, 0x01, 0xFD, 0x03, 0x00, 0x00, // Code for char Ñ
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x04, 0x02, 0x05, 0x02, 0x04, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char Ò
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x04, 0x02, 0x05, 0x02, 0x04, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char Ó
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x05, 0x02, 0x04, 0x02, 0x05, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char Ô
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x05, 0x02, 0x04, 0x02, 0x05, 0x02, 0xF9, 0x01, 0x00, 0x00, // Code for char Õ
-    0x06, 0x00, 0x00, 0xF8, 0x01, 0x05, 0x02, 0x04, 0x02, 0x05, 0x02, 0xF8, 0x01, 0x00, 0x00, // Code for char Ö
-    0x06, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x00, 0x00, // Code for char ×
-    0x06, 0x00, 0x00, 0xF8, 0x03, 0x84, 0x03, 0x64, 0x02, 0x1C, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char Ø
-    0x06, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x02, 0x01, 0x02, 0x00, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char Ù
-    0x06, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x02, 0x01, 0x02, 0x00, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char Ú
-    0x06, 0x00, 0x00, 0xFC, 0x01, 0x01, 0x02, 0x00, 0x02, 0x01, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char Û
-    0x06, 0x00, 0x00, 0xFC, 0x01, 0x01, 0x02, 0x00, 0x02, 0x01, 0x02, 0xFC, 0x01, 0x00, 0x00, // Code for char Ü
-    0x07, 0x04, 0x00, 0x18, 0x00, 0x20, 0x00, 0xC1, 0x03, 0x20, 0x00, 0x18, 0x00, 0x04, 0x00, // Code for char Ý
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x70, 0x00, 0x00, 0x00, // Code for char Þ
-    0x06, 0x00, 0x00, 0xFC, 0x03, 0x04, 0x00, 0x64, 0x02, 0x5C, 0x02, 0x80, 0x03, 0x00, 0x00, // Code for char ß
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x52, 0x02, 0x54, 0x02, 0x50, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char à
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x50, 0x02, 0x54, 0x02, 0x52, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char á
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x54, 0x02, 0x52, 0x02, 0x54, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char â
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x56, 0x02, 0x52, 0x02, 0x54, 0x02, 0xE6, 0x03, 0x00, 0x00, // Code for char ã
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x54, 0x02, 0x50, 0x02, 0x54, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char ä
-    0x06, 0x00, 0x00, 0x90, 0x01, 0x57, 0x02, 0x55, 0x02, 0x57, 0x02, 0xE0, 0x03, 0x00, 0x00, // Code for char å
-    0x07, 0x90, 0x03, 0x50, 0x02, 0x50, 0x02, 0xE0, 0x01, 0x50, 0x02, 0x50, 0x02, 0x60, 0x02, // Code for char æ
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x10, 0x12, 0x10, 0x0E, 0x10, 0x02, 0x00, 0x00, // Code for char ç
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x52, 0x02, 0x54, 0x02, 0x50, 0x02, 0x60, 0x02, 0x00, 0x00, // Code for char è
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x50, 0x02, 0x54, 0x02, 0x52, 0x02, 0x60, 0x02, 0x00, 0x00, // Code for char é
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x54, 0x02, 0x52, 0x02, 0x54, 0x02, 0x60, 0x02, 0x00, 0x00, // Code for char ê
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x54, 0x02, 0x50, 0x02, 0x54, 0x02, 0x60, 0x02, 0x00, 0x00, // Code for char ë
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x12, 0x02, 0xF4, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char ì
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x10, 0x02, 0xF4, 0x03, 0x02, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char í
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x14, 0x02, 0xF2, 0x03, 0x04, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char î
-    0x06, 0x00, 0x00, 0x00, 0x02, 0x14, 0x02, 0xF0, 0x03, 0x04, 0x02, 0x00, 0x02, 0x00, 0x00, // Code for char ï
-    0x06, 0x00, 0x00, 0xC0, 0x01, 0x2C, 0x02, 0x24, 0x02, 0x3C, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ð
-    0x06, 0x00, 0x00, 0xF0, 0x03, 0x16, 0x00, 0x12, 0x00, 0x14, 0x00, 0xE6, 0x03, 0x00, 0x00, // Code for char ñ
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x12, 0x02, 0x14, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ò
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0x14, 0x02, 0x12, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ó
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x14, 0x02, 0x12, 0x02, 0x14, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ô
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x16, 0x02, 0x12, 0x02, 0x14, 0x02, 0xE6, 0x01, 0x00, 0x00, // Code for char õ
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x14, 0x02, 0x10, 0x02, 0x14, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ö
-    0x06, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x50, 0x01, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char ÷
-    0x06, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x03, 0xD0, 0x02, 0x30, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char ø
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x02, 0x02, 0x04, 0x02, 0x00, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char ù
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x02, 0x04, 0x02, 0x02, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char ú
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x04, 0x02, 0x02, 0x02, 0x04, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char û
-    0x06, 0x00, 0x00, 0xF0, 0x01, 0x04, 0x02, 0x00, 0x02, 0x04, 0x02, 0xF0, 0x03, 0x00, 0x00, // Code for char ü
-    0x06, 0x00, 0x00, 0x30, 0x10, 0xC0, 0x10, 0x04, 0x0F, 0xC2, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char ý
-    0x06, 0x00, 0x00, 0xFC, 0x1F, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, // Code for char þ
-    0x06, 0x00, 0x00, 0x30, 0x10, 0xC4, 0x10, 0x00, 0x0F, 0xC4, 0x01, 0x30, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_droid_sans_mono_7x13 = {
-    Droid_Sans_Mono7x13,
-    7,
-    13,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_liberation_mono_13x21.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Liberation_Mono13x21
-//GLCD FontSize : 13 x 21
-
-static const uint8_t Liberation_Mono13x21[ ] = {
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80, 0x01, 0xF8, 0x9F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x10, 0x00, 0x80, 0xD0, 0x01, 0x80, 0x7E, 0x00, 0xE0, 0x13, 0x00, 0x98, 0x10, 0x00, 0x80, 0x10, 0x00, 0x80, 0xD0, 0x01, 0x80, 0x7E, 0x00, 0xE0, 0x13, 0x00, 0x98, 0x10, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x0C, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0xF0, 0xE1, 0x00, 0x18, 0x81, 0x01, 0x08, 0x03, 0x01, 0x08, 0x02, 0x01, 0xFE, 0xFF, 0x07, 0x08, 0x02, 0x01, 0x08, 0x06, 0x01, 0x18, 0x84, 0x01, 0x70, 0xFC, 0x00, 0x40, 0x78, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x0D, 0xF0, 0x01, 0x00, 0xF8, 0x03, 0x01, 0x08, 0x82, 0x01, 0x08, 0x62, 0x00, 0xB8, 0x33, 0x00, 0xF0, 0x0D, 0x00, 0x00, 0x06, 0x00, 0x00, 0xFB, 0x00, 0xC0, 0xDC, 0x01, 0x60, 0x04, 0x01, 0x18, 0x04, 0x01, 0x08, 0xFC, 0x01, 0x00, 0xF8, 0x00, // Code for char %
-    0x0D, 0x00, 0x20, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x8C, 0x01, 0xF0, 0x07, 0x01, 0x98, 0x07, 0x01, 0x08, 0x0F, 0x01, 0x08, 0x19, 0x01, 0x88, 0xF1, 0x00, 0xF8, 0xE0, 0x00, 0x70, 0xF8, 0x00, 0x00, 0x9E, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, // Code for char &
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xE0, 0xFF, 0x03, 0x38, 0x00, 0x0E, 0x0C, 0x00, 0x18, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x0C, 0x00, 0x18, 0x38, 0x00, 0x0E, 0xF0, 0xFF, 0x07, 0xC0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xA0, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xB0, 0x01, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0xE0, 0x3F, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0xC0, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xC0, 0x01, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x78, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x07, 0x00, 0xC0, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x07, 0x01, 0x08, 0x07, 0x01, 0x08, 0x07, 0x01, 0x18, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x01, 0x20, 0x00, 0x01, 0x30, 0x00, 0x01, 0x10, 0x00, 0x01, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char 1
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x80, 0x01, 0x70, 0xE0, 0x01, 0x18, 0x60, 0x01, 0x08, 0x30, 0x01, 0x08, 0x18, 0x01, 0x08, 0x0C, 0x01, 0x18, 0x06, 0x01, 0xF0, 0x03, 0x01, 0xE0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x60, 0xE0, 0x00, 0x70, 0xC0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x18, 0x05, 0x01, 0xF0, 0xCD, 0x00, 0xF0, 0xFC, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x16, 0x00, 0x80, 0x13, 0x00, 0xC0, 0x10, 0x00, 0x60, 0x10, 0x00, 0x38, 0x10, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xF8, 0xE7, 0x00, 0xF8, 0xC7, 0x00, 0x08, 0x82, 0x01, 0x08, 0x01, 0x01, 0x08, 0x01, 0x01, 0x08, 0x01, 0x01, 0x08, 0x83, 0x01, 0x08, 0xC6, 0x00, 0x08, 0x7E, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0xF0, 0xFD, 0x00, 0x10, 0x82, 0x01, 0x08, 0x01, 0x01, 0x08, 0x01, 0x01, 0x08, 0x01, 0x01, 0x08, 0x83, 0x01, 0x30, 0xC6, 0x00, 0x30, 0xFE, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x80, 0x01, 0x08, 0xF8, 0x01, 0x08, 0x3E, 0x00, 0x88, 0x07, 0x00, 0xE8, 0x01, 0x00, 0x78, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0xF0, 0xFC, 0x00, 0xF0, 0xCD, 0x00, 0x18, 0x07, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x18, 0x07, 0x01, 0xF0, 0xCD, 0x00, 0xF0, 0xFC, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0B, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0xE0, 0xC7, 0x00, 0x30, 0xC6, 0x00, 0x18, 0x0C, 0x01, 0x08, 0x08, 0x01, 0x08, 0x08, 0x01, 0x08, 0x08, 0x01, 0x18, 0x84, 0x00, 0xF0, 0xF3, 0x00, 0xE0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC1, 0x01, 0xC0, 0xC1, 0x01, 0xC0, 0xC1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0xC0, 0xC1, 0x0F, 0xC0, 0xC1, 0x03, 0xC0, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x05, 0x00, 0x80, 0x0D, 0x00, 0x80, 0x0D, 0x00, 0x80, 0x08, 0x00, 0xC0, 0x18, 0x00, 0xC0, 0x18, 0x00, 0x40, 0x10, 0x00, 0x60, 0x30, 0x00, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x80, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x0C, 0x00, 0x00, 0x00, 0x60, 0x30, 0x00, 0x60, 0x30, 0x00, 0x40, 0x10, 0x00, 0xC0, 0x18, 0x00, 0xC0, 0x18, 0x00, 0x80, 0x08, 0x00, 0x80, 0x0D, 0x00, 0x80, 0x0D, 0x00, 0x00, 0x05, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x0B, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x70, 0x00, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x98, 0x01, 0x08, 0x9C, 0x01, 0x08, 0x06, 0x00, 0x18, 0x03, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x0D, 0x00, 0x18, 0x00, 0xC0, 0xFF, 0x01, 0x70, 0x00, 0x03, 0x18, 0x7E, 0x04, 0x88, 0xC3, 0x08, 0xC4, 0x80, 0x08, 0x44, 0x80, 0x08, 0x44, 0x60, 0x08, 0x84, 0xFF, 0x0C, 0xC8, 0x83, 0x04, 0x18, 0xC0, 0x02, 0xE0, 0x7F, 0x00, 0x00, 0x07, 0x00, // Code for char @
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0B, 0x00, 0x78, 0x08, 0x00, 0x18, 0x08, 0x00, 0x78, 0x08, 0x00, 0xE0, 0x0B, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char A
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x18, 0x03, 0x01, 0xF0, 0x85, 0x01, 0xF0, 0xFC, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x18, 0x00, 0x01, 0x30, 0x80, 0x00, 0x70, 0xE0, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x10, 0x80, 0x00, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char E
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x04, 0x01, 0x18, 0x04, 0x01, 0x30, 0x84, 0x01, 0x70, 0xFC, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xF8, 0xFF, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x06, 0x00, 0x00, 0x03, 0x00, 0x80, 0x0F, 0x00, 0xC0, 0x1C, 0x00, 0x60, 0x38, 0x00, 0x38, 0xF0, 0x00, 0x18, 0xC0, 0x01, 0x08, 0x80, 0x01, 0x00, 0x00, 0x01, // Code for char K
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char L
-    0x0C, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x38, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x07, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x38, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, // Code for char M
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x38, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x18, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x08, 0x0C, 0x00, 0x30, 0x06, 0x00, 0xF0, 0x07, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x07, 0x08, 0x00, 0x0F, 0x18, 0x80, 0x19, 0x70, 0xE0, 0x10, 0xE0, 0x7F, 0x10, 0x80, 0x1F, 0x10, 0x00, 0x00, 0x00, // Code for char Q
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x02, 0x00, 0x08, 0x0E, 0x00, 0x08, 0x3E, 0x00, 0x18, 0xF1, 0x00, 0xF0, 0xC1, 0x01, 0xE0, 0x80, 0x01, 0x00, 0x00, 0x00, // Code for char R
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xF0, 0xE1, 0x00, 0xB0, 0x83, 0x01, 0x08, 0x03, 0x01, 0x08, 0x02, 0x01, 0x08, 0x06, 0x01, 0x08, 0x06, 0x01, 0x18, 0x06, 0x01, 0x30, 0x8C, 0x01, 0x70, 0xFC, 0x00, 0x40, 0x78, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0xE0, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x0D, 0x08, 0x00, 0x00, 0x78, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x3E, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x80, 0x01, 0x00, 0xF0, 0x01, 0x00, 0x3E, 0x00, 0x80, 0x0F, 0x00, 0xF0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x08, 0x00, 0x00, // Code for char V
-    0x0D, 0x38, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x80, 0xFF, 0x01, 0x00, 0x80, 0x01, 0x00, 0xF8, 0x01, 0x80, 0x1F, 0x00, 0x80, 0x01, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x80, 0x01, 0x80, 0xFF, 0x01, 0xF8, 0x0F, 0x00, 0x38, 0x00, 0x00, // Code for char W
-    0x0C, 0x00, 0x00, 0x00, 0x08, 0x80, 0x01, 0x18, 0xC0, 0x01, 0x70, 0x70, 0x00, 0xE0, 0x38, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x07, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x38, 0x00, 0x70, 0x70, 0x00, 0x18, 0xC0, 0x01, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, // Code for char X
-    0x0C, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x07, 0x00, 0xC0, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x08, 0xC0, 0x01, 0x08, 0x70, 0x01, 0x08, 0x38, 0x01, 0x08, 0x0C, 0x01, 0x08, 0x07, 0x01, 0x88, 0x03, 0x01, 0xE8, 0x00, 0x01, 0x78, 0x00, 0x01, 0x38, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char Z
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x1F, 0xFC, 0xFF, 0x1F, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x38, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x78, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0xFC, 0xFF, 0x1F, 0xFC, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x80, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x00, 0x38, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x07, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x0D, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, // Code for char _
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x80, 0x9D, 0x01, 0x40, 0x04, 0x01, 0x40, 0x04, 0x01, 0x40, 0x04, 0x01, 0x40, 0x84, 0x00, 0xC0, 0x64, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char a
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x01, 0xFC, 0xFF, 0x01, 0x80, 0x80, 0x00, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0xC0, 0x80, 0x01, 0xC0, 0xE3, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE1, 0x00, 0xC0, 0x80, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x80, 0xFF, 0x00, 0x80, 0xE3, 0x01, 0xC0, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x80, 0x80, 0x00, 0xFC, 0xFF, 0x01, 0xFC, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xEB, 0x00, 0xC0, 0x88, 0x01, 0x40, 0x08, 0x01, 0x40, 0x08, 0x01, 0x40, 0x08, 0x01, 0xC0, 0x88, 0x01, 0x80, 0xCB, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x4C, 0x00, 0x00, 0x44, 0x00, 0x00, 0x44, 0x00, 0x00, 0x44, 0x00, 0x00, 0x44, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x04, 0x80, 0xE3, 0x0D, 0xC0, 0x00, 0x19, 0x40, 0x00, 0x11, 0x40, 0x00, 0x11, 0x40, 0x00, 0x11, 0x80, 0x80, 0x18, 0xC0, 0xFF, 0x0F, 0xC0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x01, 0xFC, 0xFF, 0x01, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0xCC, 0xFF, 0x01, 0xCC, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char i
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x18, 0xCC, 0xFF, 0x0F, 0xCC, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x01, 0xFC, 0xFF, 0x01, 0x00, 0x18, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x3B, 0x00, 0x80, 0x61, 0x00, 0xC0, 0xC0, 0x01, 0x40, 0x80, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char k
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x01, 0x04, 0x00, 0x01, 0x04, 0x00, 0x01, 0xFC, 0xFF, 0x01, 0xFC, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char l
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x80, 0xFF, 0x01, 0x80, 0x01, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x00, // Code for char m
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE3, 0x00, 0xC0, 0x80, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0xC0, 0x80, 0x01, 0x80, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x1F, 0xC0, 0xFF, 0x1F, 0x80, 0x80, 0x00, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x80, 0x01, 0xC0, 0xE3, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x80, 0xFF, 0x00, 0xC0, 0xE3, 0x01, 0xC0, 0x80, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x80, 0x80, 0x00, 0xC0, 0xFF, 0x1F, 0xC0, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x80, 0xC7, 0x00, 0xC0, 0x0C, 0x01, 0x40, 0x0C, 0x01, 0x40, 0x0C, 0x01, 0x40, 0x08, 0x01, 0x40, 0x18, 0x01, 0x80, 0xF9, 0x00, 0x00, 0xF1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0xF8, 0xFF, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x80, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x7C, 0x00, 0x00, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x0D, 0xC0, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x80, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x02, 0x00, 0x00, 0x1E, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x80, 0x01, 0x00, 0xFE, 0x01, 0xC0, 0x1F, 0x00, 0xC0, 0x00, 0x00, // Code for char w
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x80, 0x01, 0xC0, 0xC1, 0x00, 0x00, 0x73, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x63, 0x00, 0xC0, 0xC1, 0x00, 0xC0, 0x80, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char x
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x03, 0x10, 0x00, 0x0F, 0x10, 0x00, 0x3C, 0x18, 0x00, 0xE0, 0x0D, 0x00, 0x80, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x3C, 0x00, 0x00, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80, 0x01, 0x40, 0xC0, 0x01, 0x40, 0x70, 0x01, 0x40, 0x38, 0x01, 0x40, 0x0C, 0x01, 0x40, 0x06, 0x01, 0xC0, 0x03, 0x01, 0xC0, 0x01, 0x01, 0x40, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x1C, 0x00, 0xF0, 0xF7, 0x07, 0xF8, 0xE3, 0x0F, 0x04, 0x00, 0x18, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x04, 0x00, 0x10, 0x0C, 0x00, 0x18, 0xF8, 0xE3, 0x0F, 0xF0, 0xF7, 0x07, 0x00, 0x1C, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x05, 0xF0, 0xFF, 0x03, 0x10, 0x00, 0x02, 0x10, 0x00, 0x02, 0x10, 0x00, 0x02, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x0E, 0xC0, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x80, 0x3F, 0x00, 0xC0, 0x71, 0x00, 0x60, 0xC0, 0x00, 0x20, 0x80, 0x00, 0x38, 0x80, 0x03, 0x20, 0x80, 0x00, 0x20, 0x80, 0x00, 0xC0, 0x40, 0x00, 0xC0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0xC2, 0x01, 0xF0, 0x7F, 0x01, 0xF0, 0x0F, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x38, 0x00, 0x01, 0x30, 0x80, 0x01, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x2F, 0x00, 0x80, 0x3F, 0x00, 0xC0, 0x30, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0x40, 0x20, 0x00, 0xC0, 0x30, 0x00, 0x80, 0x19, 0x00, 0xC0, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x0C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x38, 0x24, 0x00, 0xF0, 0x24, 0x00, 0xC0, 0x25, 0x00, 0x00, 0x27, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x27, 0x00, 0xC0, 0x25, 0x00, 0xF0, 0x24, 0x00, 0x38, 0x24, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xE3, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x0E, 0x03, 0x78, 0x1F, 0x02, 0xCC, 0x19, 0x04, 0xC4, 0x10, 0x04, 0x84, 0x30, 0x04, 0x84, 0x31, 0x04, 0x84, 0x31, 0x04, 0x18, 0x7B, 0x02, 0x18, 0xCF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x0D, 0x80, 0x0F, 0x00, 0x60, 0x30, 0x00, 0x18, 0xC0, 0x00, 0x88, 0x8F, 0x00, 0x44, 0x10, 0x01, 0x24, 0x20, 0x01, 0x24, 0x20, 0x01, 0x24, 0x20, 0x01, 0x64, 0x30, 0x01, 0x48, 0x90, 0x00, 0x18, 0xC0, 0x00, 0x60, 0x30, 0x00, 0x80, 0x0F, 0x00, // Code for char ©
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE8, 0x03, 0x00, 0x24, 0x02, 0x00, 0x24, 0x02, 0x00, 0x24, 0x02, 0x00, 0x24, 0x01, 0x00, 0xF8, 0x03, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x36, 0x00, 0x80, 0xE3, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x08, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x77, 0x00, 0x80, 0xE3, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x0D, 0x80, 0x0F, 0x00, 0x60, 0x30, 0x00, 0x18, 0xC0, 0x00, 0xE8, 0xBF, 0x00, 0xE4, 0x3F, 0x01, 0x24, 0x02, 0x01, 0x24, 0x02, 0x01, 0x24, 0x0E, 0x01, 0x64, 0x3B, 0x01, 0xC8, 0xA1, 0x00, 0x18, 0xC0, 0x00, 0x60, 0x30, 0x00, 0x80, 0x0F, 0x00, // Code for char ®
-    0x0D, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, // Code for char ¯
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0x08, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0xC0, 0x7F, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, // Code for char ±
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, 0x00, 0x30, 0x0E, 0x00, 0x08, 0x0A, 0x00, 0x08, 0x09, 0x00, 0x88, 0x09, 0x00, 0xF8, 0x08, 0x00, 0x20, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x18, 0x0C, 0x00, 0x08, 0x08, 0x00, 0x88, 0x08, 0x00, 0x88, 0x08, 0x00, 0x78, 0x0F, 0x00, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x18, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x1F, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x60, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x0B, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF8, 0x03, 0x00, 0xF8, 0x03, 0x00, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0xF8, 0xFF, 0x0F, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x16, 0x00, 0x00, 0x14, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x00, 0x10, 0x08, 0x00, 0x18, 0x08, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x0C, 0x03, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x0C, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x0B, 0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x63, 0x00, 0x00, 0x36, 0x00, 0x00, 0x1C, 0x00, 0x80, 0x80, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x63, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x0D, 0x10, 0x00, 0x00, 0x10, 0x04, 0x00, 0xF8, 0x07, 0x01, 0x00, 0xC4, 0x01, 0x00, 0x60, 0x00, 0x00, 0x18, 0x00, 0x00, 0x66, 0x00, 0x80, 0x71, 0x00, 0x60, 0x48, 0x00, 0x18, 0x46, 0x00, 0x08, 0xFE, 0x01, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, // Code for char ¼
-    0x0C, 0x10, 0x00, 0x00, 0x10, 0x04, 0x00, 0xF8, 0x07, 0x01, 0x00, 0xC4, 0x01, 0x00, 0x60, 0x00, 0x00, 0x18, 0x00, 0x00, 0x06, 0x00, 0x80, 0x85, 0x01, 0x60, 0x46, 0x01, 0x18, 0x62, 0x01, 0x08, 0x32, 0x01, 0x00, 0x1E, 0x01, 0x00, 0x00, 0x00, // Code for char ½
-    0x0D, 0x10, 0x02, 0x00, 0x18, 0x06, 0x00, 0x48, 0x04, 0x01, 0x48, 0xC4, 0x01, 0xB8, 0x67, 0x00, 0x00, 0x19, 0x00, 0x00, 0x66, 0x00, 0x80, 0x71, 0x00, 0x60, 0x48, 0x00, 0x18, 0x46, 0x00, 0x08, 0xFE, 0x01, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, // Code for char ¾
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x07, 0x00, 0xE0, 0x07, 0x00, 0x60, 0x0C, 0x00, 0x30, 0x08, 0xC0, 0x1C, 0x08, 0xC0, 0x0C, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x04, 0x00, 0x00, 0x07, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, // Code for char ¿
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0B, 0x00, 0x79, 0x08, 0x00, 0x1B, 0x08, 0x00, 0x78, 0x08, 0x00, 0xE0, 0x0B, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char À
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0B, 0x00, 0x7A, 0x08, 0x00, 0x1B, 0x08, 0x00, 0x79, 0x08, 0x00, 0xE0, 0x0B, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char Á
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x02, 0x0F, 0x00, 0xE3, 0x0B, 0x00, 0x79, 0x08, 0x00, 0x18, 0x08, 0x00, 0x79, 0x08, 0x00, 0xE3, 0x0B, 0x00, 0x02, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char Â
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x03, 0x0F, 0x00, 0xE0, 0x0B, 0x00, 0x78, 0x08, 0x00, 0x19, 0x08, 0x00, 0x7A, 0x08, 0x00, 0xE2, 0x0B, 0x00, 0x01, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char Ã
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x0F, 0x00, 0xE3, 0x0B, 0x00, 0x78, 0x08, 0x00, 0x18, 0x08, 0x00, 0x78, 0x08, 0x00, 0xE3, 0x0B, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char Ä
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x78, 0x00, 0x00, 0x0F, 0x00, 0xE6, 0x0B, 0x00, 0x79, 0x08, 0x00, 0x19, 0x08, 0x00, 0x79, 0x08, 0x00, 0xE6, 0x0B, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x01, // Code for char Å
-    0x0D, 0x00, 0x00, 0x01, 0x00, 0xE0, 0x01, 0x00, 0x3C, 0x00, 0x80, 0x0F, 0x00, 0xF0, 0x09, 0x00, 0x18, 0x08, 0x00, 0x08, 0x08, 0x00, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, // Code for char Æ
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x11, 0x08, 0x00, 0x17, 0x08, 0x00, 0x15, 0x18, 0x00, 0x1D, 0x30, 0x80, 0x00, 0x70, 0xE0, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x09, 0x02, 0x01, 0x0B, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char È
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x0A, 0x02, 0x01, 0x0B, 0x02, 0x01, 0x09, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char É
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xFA, 0xFF, 0x01, 0x0B, 0x02, 0x01, 0x09, 0x02, 0x01, 0x08, 0x02, 0x01, 0x09, 0x02, 0x01, 0x0B, 0x02, 0x01, 0x0A, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char Ê
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x0B, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x0B, 0x02, 0x01, 0x08, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char Ë
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xF9, 0xFF, 0x01, 0xFB, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0xFA, 0xFF, 0x01, 0xFB, 0xFF, 0x01, 0x09, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x0A, 0x00, 0x01, 0x0B, 0x00, 0x01, 0xF9, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x09, 0x00, 0x01, 0x0B, 0x00, 0x01, 0x0A, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x0B, 0x00, 0x01, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x00, 0x01, 0x0B, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x0C, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x02, 0x01, 0x08, 0x00, 0x01, 0x10, 0x80, 0x00, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0x3B, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x01, 0x0F, 0x00, 0x02, 0x3C, 0x00, 0x02, 0xF0, 0x00, 0x01, 0xC0, 0x01, 0xF8, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x09, 0x00, 0x01, 0x0B, 0x00, 0x01, 0x08, 0x00, 0x01, 0x18, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x0A, 0x00, 0x01, 0x0B, 0x00, 0x01, 0x09, 0x00, 0x01, 0x18, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x72, 0xE0, 0x00, 0x1B, 0x80, 0x01, 0x09, 0x00, 0x01, 0x08, 0x00, 0x01, 0x09, 0x00, 0x01, 0x1B, 0x80, 0x01, 0x72, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x73, 0xE0, 0x00, 0x18, 0x80, 0x01, 0x08, 0x00, 0x01, 0x09, 0x00, 0x01, 0x0A, 0x00, 0x01, 0x1A, 0x80, 0x01, 0x71, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x7F, 0x00, 0x70, 0xE0, 0x00, 0x1B, 0x80, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x08, 0x00, 0x01, 0x1B, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x00, 0xC0, 0x18, 0x00, 0x80, 0x0D, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x07, 0x00, 0x80, 0x0F, 0x00, 0xC0, 0x1D, 0x00, 0xC0, 0x18, 0x00, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0x9F, 0x01, 0xE0, 0xFF, 0x00, 0x70, 0xE0, 0x00, 0x18, 0xB0, 0x01, 0x08, 0x0C, 0x01, 0x08, 0x06, 0x01, 0x08, 0x03, 0x01, 0xD8, 0x80, 0x01, 0x70, 0xE0, 0x00, 0xF0, 0x7F, 0x00, 0x98, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0xE0, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x01, 0x03, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x80, 0x01, 0x00, 0xE0, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0xF8, 0xFF, 0x00, 0x02, 0xE0, 0x00, 0x03, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x03, 0x80, 0x01, 0x02, 0xE0, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0xE0, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x03, 0x80, 0x01, 0x00, 0xE0, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x0C, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x02, 0xFF, 0x01, 0x03, 0xFE, 0x01, 0x01, 0x07, 0x00, 0xC0, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x20, 0x20, 0x00, 0x20, 0x20, 0x00, 0x20, 0x20, 0x00, 0x20, 0x20, 0x00, 0x60, 0x30, 0x00, 0xC0, 0x18, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x0C, 0x00, 0x00, 0x00, 0x80, 0xFF, 0x01, 0xF8, 0xFF, 0x01, 0x18, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x01, 0x84, 0x07, 0x01, 0xCC, 0x06, 0x01, 0x78, 0x0C, 0x01, 0x30, 0x98, 0x01, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x84, 0x9D, 0x01, 0x44, 0x04, 0x01, 0x4C, 0x04, 0x01, 0x58, 0x04, 0x01, 0x40, 0x84, 0x00, 0xC0, 0x64, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char à
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x80, 0x9D, 0x01, 0x40, 0x04, 0x01, 0x50, 0x04, 0x01, 0x58, 0x04, 0x01, 0x4C, 0x84, 0x00, 0xC4, 0x64, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char á
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x90, 0x9D, 0x01, 0x58, 0x04, 0x01, 0x4C, 0x04, 0x01, 0x44, 0x04, 0x01, 0x4C, 0x84, 0x00, 0xD8, 0x64, 0x00, 0x90, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char â
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x98, 0x9D, 0x01, 0x44, 0x04, 0x01, 0x44, 0x04, 0x01, 0x48, 0x04, 0x01, 0x50, 0x84, 0x00, 0xD0, 0x64, 0x00, 0x8C, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char ã
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x80, 0x9D, 0x01, 0x4C, 0x04, 0x01, 0x40, 0x04, 0x01, 0x40, 0x04, 0x01, 0x40, 0x84, 0x00, 0xCC, 0x64, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char ä
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x80, 0xF9, 0x00, 0x80, 0x9D, 0x01, 0x4C, 0x04, 0x01, 0x52, 0x04, 0x01, 0x52, 0x04, 0x01, 0x52, 0x84, 0x00, 0xCC, 0x64, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char å
-    0x0D, 0x00, 0x70, 0x00, 0x80, 0xF9, 0x01, 0xC0, 0x0C, 0x01, 0x40, 0x04, 0x01, 0x40, 0x84, 0x01, 0xC0, 0xFF, 0x00, 0x80, 0xFF, 0x00, 0xC0, 0x89, 0x01, 0x40, 0x08, 0x01, 0x40, 0x08, 0x01, 0xC0, 0x88, 0x01, 0x80, 0xCF, 0x00, 0x00, 0x4E, 0x00, // Code for char æ
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE1, 0x00, 0xC0, 0x80, 0x01, 0x40, 0x00, 0x11, 0x40, 0x00, 0x17, 0x40, 0x00, 0x15, 0x40, 0x00, 0x1D, 0x80, 0xC1, 0x00, 0x80, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xEB, 0x00, 0xC4, 0x88, 0x01, 0x44, 0x08, 0x01, 0x4C, 0x08, 0x01, 0x58, 0x08, 0x01, 0xC0, 0x88, 0x01, 0x80, 0xCB, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xEB, 0x00, 0xC0, 0x88, 0x01, 0x50, 0x08, 0x01, 0x58, 0x08, 0x01, 0x4C, 0x08, 0x01, 0xC4, 0x88, 0x01, 0x80, 0xCB, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x90, 0xEB, 0x00, 0xD8, 0x88, 0x01, 0x4C, 0x08, 0x01, 0x44, 0x08, 0x01, 0x4C, 0x08, 0x01, 0xD8, 0x88, 0x01, 0x90, 0xCB, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xEB, 0x00, 0xCC, 0x88, 0x01, 0x40, 0x08, 0x01, 0x40, 0x08, 0x01, 0x40, 0x08, 0x01, 0xCC, 0x88, 0x01, 0x80, 0xCB, 0x00, 0x00, 0xCF, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x01, 0x44, 0x00, 0x01, 0x44, 0x00, 0x01, 0xCC, 0xFF, 0x01, 0xD8, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char ì
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x50, 0x00, 0x01, 0xD8, 0xFF, 0x01, 0xCC, 0xFF, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char í
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x50, 0x00, 0x01, 0x58, 0x00, 0x01, 0x4C, 0x00, 0x01, 0xC4, 0xFF, 0x01, 0xCC, 0xFF, 0x01, 0x18, 0x00, 0x01, 0x10, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char î
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x4C, 0x00, 0x01, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x0C, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Code for char ï
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xC3, 0x00, 0xB4, 0x81, 0x01, 0x9C, 0x00, 0x01, 0x98, 0x00, 0x01, 0xB8, 0x00, 0x01, 0xF8, 0x81, 0x01, 0xEC, 0xC3, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x01, 0xD8, 0xFF, 0x01, 0x84, 0x00, 0x00, 0x44, 0x00, 0x00, 0x48, 0x00, 0x00, 0x50, 0x00, 0x00, 0x50, 0x00, 0x00, 0xCC, 0xFF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE3, 0x00, 0xC4, 0x80, 0x01, 0x44, 0x00, 0x01, 0x4C, 0x00, 0x01, 0x58, 0x00, 0x01, 0xC0, 0x80, 0x01, 0x80, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE3, 0x00, 0xC0, 0x80, 0x01, 0x50, 0x00, 0x01, 0x58, 0x00, 0x01, 0x4C, 0x00, 0x01, 0xC4, 0x80, 0x01, 0x80, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x90, 0xE3, 0x00, 0xD8, 0x80, 0x01, 0x4C, 0x00, 0x01, 0x44, 0x00, 0x01, 0x4C, 0x00, 0x01, 0xD8, 0x80, 0x01, 0x90, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x98, 0xE3, 0x00, 0xC4, 0x80, 0x01, 0x44, 0x00, 0x01, 0x48, 0x00, 0x01, 0x50, 0x00, 0x01, 0xD0, 0x80, 0x01, 0x8C, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x7F, 0x00, 0x80, 0xE3, 0x00, 0xCC, 0x80, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0xCC, 0x80, 0x01, 0x80, 0xE3, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x60, 0x32, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x80, 0xFF, 0x01, 0x80, 0xC1, 0x00, 0xC0, 0xA0, 0x01, 0x40, 0x10, 0x01, 0x40, 0x08, 0x01, 0x40, 0x04, 0x01, 0xC0, 0x83, 0x01, 0x80, 0xC1, 0x00, 0xC0, 0xFF, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xC4, 0xFF, 0x01, 0x04, 0x00, 0x01, 0x0C, 0x00, 0x01, 0x18, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x01, 0x10, 0x00, 0x01, 0x18, 0x00, 0x01, 0x0C, 0x00, 0x01, 0x04, 0x80, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xD0, 0xFF, 0x01, 0x18, 0x00, 0x01, 0x0C, 0x00, 0x01, 0x04, 0x00, 0x01, 0x0C, 0x00, 0x01, 0x18, 0x80, 0x00, 0xD0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0xC0, 0xFF, 0x01, 0x0C, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x0C, 0x80, 0x00, 0xC0, 0xFF, 0x01, 0xC0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x03, 0x10, 0x00, 0x0F, 0x10, 0x00, 0x3C, 0x18, 0x10, 0xE0, 0x0D, 0x18, 0x80, 0x07, 0x0C, 0xE0, 0x01, 0x04, 0x3C, 0x00, 0x00, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0x1F, 0xFC, 0xFF, 0x1F, 0x80, 0x80, 0x00, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x00, 0x01, 0x40, 0x80, 0x01, 0xC0, 0xE3, 0x00, 0x80, 0xFF, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x0C, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0xC0, 0x03, 0x10, 0x00, 0x0F, 0x10, 0x0C, 0x3C, 0x18, 0x00, 0xE0, 0x0D, 0x00, 0x80, 0x07, 0x00, 0xE0, 0x01, 0x0C, 0x3C, 0x00, 0x00, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_liberation_mono_13x21 = {
-    Liberation_Mono13x21,
-    13,
-    21,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_liberation_mono_17x30.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Liberation_Mono17x30
-//GLCD FontSize : 17 x 30
-
-static const uint8_t Liberation_Mono17x30[] = {
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xE3, 0x00, 0xE0, 0xFF, 0xE3, 0x00, 0xE0, 0xFF, 0xE3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x86, 0x00, 0x00, 0x0C, 0xFE, 0x00, 0x00, 0xEC, 0x3F, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xE0, 0x0F, 0x06, 0x00, 0x20, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0xE6, 0x00, 0x00, 0x0C, 0xFF, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0xC0, 0x3F, 0x06, 0x00, 0xE0, 0x0D, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x80, 0x0F, 0x38, 0x00, 0xC0, 0x1F, 0x70, 0x00, 0xC0, 0x39, 0x60, 0x00, 0xE0, 0x30, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0xF8, 0xFF, 0xFF, 0x03, 0xF8, 0xFF, 0xFF, 0x03, 0x60, 0xE0, 0xC0, 0x00, 0xE0, 0xC0, 0xC0, 0x00, 0xC0, 0xC1, 0x61, 0x00, 0xC0, 0x83, 0x7F, 0x00, 0x80, 0x83, 0x3F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x11, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x3F, 0x80, 0x00, 0xE0, 0x70, 0xC0, 0x00, 0x60, 0x60, 0x70, 0x00, 0x60, 0x60, 0x38, 0x00, 0xE0, 0x70, 0x0E, 0x00, 0xC0, 0x3F, 0x07, 0x00, 0x80, 0xDF, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x70, 0x3F, 0x00, 0x00, 0x9C, 0x7F, 0x00, 0x00, 0xCE, 0xE1, 0x00, 0x80, 0xC3, 0xC0, 0x00, 0xC0, 0xC1, 0xC0, 0x00, 0x60, 0xC0, 0xE1, 0x00, 0x20, 0x80, 0x7F, 0x00, 0x00, 0x00, 0x3F, 0x00, // Code for char %
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0xC0, 0x60, 0x00, 0xC0, 0x7F, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x00, 0xE0, 0xF0, 0xC0, 0x00, 0x60, 0xF0, 0xC3, 0x00, 0x60, 0x18, 0xC7, 0x00, 0x60, 0x18, 0x6E, 0x00, 0xE0, 0x0C, 0x7C, 0x00, 0xC0, 0x07, 0x3C, 0x00, 0x80, 0x83, 0x7F, 0x00, 0x00, 0xC0, 0xE7, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0x01, 0xC0, 0x3F, 0xF8, 0x07, 0xE0, 0x03, 0x80, 0x0F, 0x78, 0x00, 0x00, 0x3C, 0x38, 0x00, 0x00, 0x38, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x20, 0x38, 0x00, 0x00, 0x38, 0xF8, 0x00, 0x00, 0x3E, 0xE0, 0x03, 0x80, 0x0F, 0xC0, 0x3F, 0xF8, 0x07, 0x00, 0xFF, 0xFF, 0x01, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x80, 0x18, 0x00, 0x00, 0x80, 0x1D, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x80, 0x1D, 0x00, 0x00, 0x80, 0x08, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 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, // Code for char .
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC0, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x60, 0xE0, 0xC0, 0x00, 0x60, 0xE0, 0xC0, 0x00, 0x60, 0xE0, 0xC0, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x70, 0x00, 0xC0, 0x0F, 0x7E, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0x80, 0x01, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xE0, 0x00, 0x80, 0x03, 0xF0, 0x00, 0xC0, 0x03, 0xF8, 0x00, 0xC0, 0x00, 0xDC, 0x00, 0x60, 0x00, 0xCE, 0x00, 0x60, 0x00, 0xC7, 0x00, 0x60, 0x80, 0xC3, 0x00, 0x60, 0x80, 0xC1, 0x00, 0x60, 0xC0, 0xC1, 0x00, 0xE0, 0xF0, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x00, 0x80, 0x3F, 0xC0, 0x00, 0x00, 0x06, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x18, 0x00, 0x80, 0x03, 0x78, 0x00, 0xC0, 0x03, 0x78, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x70, 0xC0, 0x00, 0xE0, 0xF0, 0xE0, 0x00, 0xC0, 0xDF, 0x7B, 0x00, 0x80, 0x8F, 0x7F, 0x00, 0x00, 0x07, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xE0, 0x06, 0x00, 0x00, 0x38, 0x06, 0x00, 0x00, 0x1C, 0x06, 0x00, 0x00, 0x0E, 0x06, 0x00, 0x80, 0x03, 0x06, 0x00, 0xC0, 0x01, 0x06, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x18, 0x00, 0xE0, 0xFF, 0x38, 0x00, 0xE0, 0xFF, 0x70, 0x00, 0x60, 0x60, 0xE0, 0x00, 0x60, 0x20, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x70, 0x60, 0x00, 0x60, 0xE0, 0x79, 0x00, 0x60, 0xC0, 0x3F, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0xFF, 0x1F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x63, 0x70, 0x00, 0xE0, 0x60, 0xE0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0xE0, 0x70, 0xE0, 0x00, 0xC0, 0xE3, 0x79, 0x00, 0x80, 0xC3, 0x3F, 0x00, 0x00, 0x82, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0xFC, 0x00, 0x60, 0x00, 0xFF, 0x00, 0x60, 0xE0, 0x1F, 0x00, 0x60, 0xF8, 0x01, 0x00, 0x60, 0x7C, 0x00, 0x00, 0x60, 0x0F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1F, 0x00, 0x80, 0x9F, 0x3F, 0x00, 0xC0, 0xFF, 0x7B, 0x00, 0xE0, 0xF0, 0xE0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0xC0, 0xF0, 0xE0, 0x00, 0xC0, 0xFF, 0x7F, 0x00, 0x80, 0x9F, 0x3F, 0x00, 0x00, 0x06, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x08, 0x00, 0x80, 0xFF, 0x38, 0x00, 0xC0, 0xFF, 0x79, 0x00, 0xC0, 0x80, 0xE3, 0x00, 0x60, 0x00, 0xC3, 0x00, 0x60, 0x00, 0xC3, 0x00, 0x60, 0x00, 0xC3, 0x00, 0x60, 0x00, 0xC3, 0x00, 0xE0, 0x80, 0xE1, 0x00, 0xC0, 0xC1, 0x71, 0x00, 0xC0, 0x7F, 0x3F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0xF0, 0x00, 0x00, 0x0F, 0xF0, 0x00, 0x00, 0x0F, 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, // Code for char :
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x0F, 0xF0, 0x07, 0x00, 0x0F, 0xF0, 0x01, 0x00, 0x0F, 0x70, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xB0, 0x01, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x03, 0x18, 0x00, 0x00, 0x03, 0x18, 0x00, 0x80, 0x03, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x38, 0x00, 0x00, 0x03, 0x18, 0x00, 0x00, 0x03, 0x18, 0x00, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x06, 0x0C, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0xB0, 0x01, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0xE4, 0x00, 0x60, 0x00, 0xE7, 0x00, 0x60, 0x80, 0xE7, 0x00, 0x60, 0xC0, 0x01, 0x00, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x70, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x3F, 0xF8, 0x01, 0xC0, 0x03, 0x80, 0x03, 0xE0, 0xE0, 0x1F, 0x07, 0x70, 0xFC, 0x7F, 0x06, 0x30, 0x0E, 0x40, 0x0C, 0x18, 0x03, 0x40, 0x0C, 0x18, 0x01, 0x60, 0x0C, 0x18, 0x01, 0x30, 0x0C, 0x18, 0x86, 0x3F, 0x0C, 0x38, 0xFC, 0x7F, 0x06, 0x30, 0x7F, 0x40, 0x06, 0xE0, 0x01, 0x60, 0x03, 0xC0, 0x07, 0x3C, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char @
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xFE, 0x07, 0x00, 0xC0, 0x1F, 0x06, 0x00, 0xE0, 0x03, 0x06, 0x00, 0x60, 0x00, 0x06, 0x00, 0xE0, 0x03, 0x06, 0x00, 0xC0, 0x1F, 0x06, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char A
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0xE0, 0xF0, 0xE0, 0x00, 0xC0, 0xDF, 0x60, 0x00, 0xC0, 0x9F, 0x7F, 0x00, 0x00, 0x87, 0x3F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0xC0, 0x1F, 0x7F, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x03, 0x70, 0x00, 0x80, 0x07, 0x3C, 0x00, 0x00, 0x03, 0x1C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x70, 0x00, 0x80, 0x07, 0x3C, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0xC0, 0x0F, 0x7F, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0xE0, 0xC0, 0xC0, 0x00, 0xC0, 0xC1, 0x60, 0x00, 0x80, 0xC3, 0x7F, 0x00, 0x00, 0xC3, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0xCE, 0x03, 0x00, 0x00, 0x87, 0x0F, 0x00, 0xC0, 0x03, 0x1E, 0x00, 0xE0, 0x01, 0x3C, 0x00, 0xE0, 0x00, 0xF8, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char K
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFE, 0xFF, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0xE0, 0xFF, 0xEF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0x60, 0x80, 0x01, 0x00, 0xE0, 0xC0, 0x01, 0x00, 0xC0, 0xE1, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x03, 0x60, 0x00, 0xC0, 0x0F, 0xE0, 0x00, 0xE0, 0x0F, 0xC0, 0x01, 0x70, 0x1C, 0xC0, 0x07, 0x7C, 0x18, 0x80, 0xFF, 0x3F, 0x18, 0x00, 0xFE, 0x0F, 0x18, 0x00, 0xE0, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x01, 0x00, 0x60, 0xC0, 0x03, 0x00, 0x60, 0xC0, 0x0F, 0x00, 0xE0, 0xE0, 0x1E, 0x00, 0xC0, 0x71, 0x7C, 0x00, 0xC0, 0x7F, 0xF0, 0x00, 0x80, 0x3F, 0xE0, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x0F, 0x3C, 0x00, 0xC0, 0x1F, 0x7C, 0x00, 0xC0, 0x3F, 0x70, 0x00, 0xE0, 0x30, 0xE0, 0x00, 0x60, 0x70, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0xE0, 0xC0, 0x00, 0xE0, 0xC0, 0xE0, 0x00, 0xC0, 0xC3, 0x71, 0x00, 0xC0, 0x83, 0x7F, 0x00, 0x00, 0x83, 0x3F, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x11, 0x20, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x01, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFE, 0x01, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, // Code for char V
-    0x11, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, // Code for char W
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x01, 0xF8, 0x00, 0xC0, 0x03, 0x3C, 0x00, 0x80, 0x0F, 0x1F, 0x00, 0x00, 0x9E, 0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0x9E, 0x07, 0x00, 0x80, 0x0F, 0x1F, 0x00, 0xC0, 0x03, 0x3C, 0x00, 0xE0, 0x01, 0xF8, 0x00, 0x60, 0x00, 0xE0, 0x00, 0x20, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0xC0, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xF0, 0x00, 0x60, 0x00, 0xF8, 0x00, 0x60, 0x00, 0xDE, 0x00, 0x60, 0x00, 0xCF, 0x00, 0x60, 0x80, 0xC7, 0x00, 0x60, 0xE0, 0xC1, 0x00, 0x60, 0xF0, 0xC0, 0x00, 0x60, 0x78, 0xC0, 0x00, 0x60, 0x1E, 0xC0, 0x00, 0x60, 0x0F, 0xC0, 0x00, 0xE0, 0x07, 0xC0, 0x00, 0xE0, 0x01, 0xC0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x3F, 0xF8, 0xFF, 0xFF, 0x3F, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0xF8, 0xFF, 0xFF, 0x3F, 0xF8, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x3E, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x11, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, // Code for char _
-    0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xF7, 0x00, 0x00, 0xC7, 0xC1, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0x60, 0x00, 0x00, 0xC7, 0x30, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x1C, 0x38, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x0E, 0x70, 0x00, 0x00, 0x0E, 0x70, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x1C, 0x38, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x8E, 0x61, 0x00, 0x00, 0x87, 0xE1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x87, 0xC1, 0x00, 0x00, 0x86, 0xE1, 0x00, 0x00, 0xFE, 0x71, 0x00, 0x00, 0xFC, 0x31, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0x38, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x0C, 0x00, 0xFE, 0x7F, 0x1C, 0x00, 0x07, 0xE0, 0x1C, 0x00, 0x03, 0xC0, 0x38, 0x00, 0x03, 0xC0, 0x30, 0x00, 0x03, 0xC0, 0x30, 0x00, 0x03, 0xC0, 0x30, 0x00, 0x06, 0x60, 0x30, 0x00, 0x1C, 0x38, 0x1C, 0x00, 0xFF, 0xFF, 0x1F, 0x00, 0xFF, 0xFF, 0x0F, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x03, 0x00, 0x30, 0x00, 0x03, 0x00, 0x30, 0x00, 0x03, 0x00, 0x30, 0x00, 0x03, 0x00, 0x30, 0x00, 0x03, 0x00, 0x30, 0x00, 0x03, 0x00, 0x18, 0x38, 0xFF, 0xFF, 0x1F, 0x38, 0xFF, 0xFF, 0x0F, 0x38, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x1C, 0x1E, 0x00, 0x00, 0x0E, 0x3C, 0x00, 0x00, 0x07, 0xF0, 0x00, 0x00, 0x03, 0xE0, 0x00, 0x00, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x18, 0x00, 0xC0, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0xF8, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xE0, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x1C, 0x38, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x1C, 0x38, 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x7C, 0x70, 0x00, 0x00, 0xFE, 0x70, 0x00, 0x00, 0xE6, 0xE0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC1, 0x00, 0x00, 0xC3, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC3, 0x00, 0x00, 0x87, 0xE3, 0x00, 0x00, 0x0E, 0x7F, 0x00, 0x00, 0x0C, 0x3E, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0xC0, 0xFF, 0x3F, 0x00, 0xF0, 0xFF, 0x7F, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x11, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, // Code for char w
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x0F, 0x78, 0x00, 0x00, 0x3C, 0x3C, 0x00, 0x00, 0x78, 0x0E, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x78, 0x1E, 0x00, 0x00, 0x1C, 0x3C, 0x00, 0x00, 0x0F, 0xF8, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x30, 0x00, 0x3F, 0x00, 0x30, 0x00, 0xFC, 0x01, 0x30, 0x00, 0xE0, 0x07, 0x38, 0x00, 0x00, 0x3F, 0x1C, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x03, 0xF0, 0x00, 0x00, 0x03, 0xF8, 0x00, 0x00, 0x03, 0xDC, 0x00, 0x00, 0x03, 0xCF, 0x00, 0x00, 0x83, 0xC7, 0x00, 0x00, 0xC3, 0xC1, 0x00, 0x00, 0xF3, 0xC0, 0x00, 0x00, 0x7B, 0xC0, 0x00, 0x00, 0x3F, 0xC0, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xE0, 0x07, 0x00, 0xE0, 0x7F, 0xFE, 0x0F, 0xF0, 0x7F, 0xFE, 0x1F, 0x78, 0x00, 0x00, 0x3C, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x3F, 0xF8, 0xFF, 0xFF, 0x3F, 0xF8, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x30, 0x38, 0x00, 0x00, 0x3C, 0xF0, 0x7F, 0xFE, 0x1F, 0xE0, 0x7F, 0xFE, 0x0F, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x01, 0x60, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0xE0, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC7, 0xFF, 0x0F, 0x00, 0xC7, 0xFF, 0x0F, 0x00, 0xC7, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0x1F, 0x1F, 0x00, 0x00, 0x03, 0x1C, 0x00, 0x80, 0x03, 0x38, 0x00, 0x80, 0x01, 0x30, 0x00, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0xF0, 0x01, 0x80, 0x01, 0x30, 0x00, 0x80, 0x03, 0x38, 0x00, 0x00, 0x0F, 0x1E, 0x00, 0x00, 0x0E, 0x0E, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¢
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xE0, 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x80, 0xFF, 0xFF, 0x00, 0xC0, 0xFF, 0xDF, 0x00, 0xE0, 0xC0, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0x60, 0xC0, 0xC0, 0x00, 0xE0, 0xC0, 0xC0, 0x00, 0xC0, 0x01, 0xC0, 0x00, 0xC0, 0x01, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char £
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0xFB, 0x0D, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0x0E, 0x07, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0xFE, 0x07, 0x00, 0x00, 0xFB, 0x0D, 0x00, 0x00, 0x62, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¤
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xE0, 0xC0, 0x0C, 0x00, 0xE0, 0xC3, 0x0C, 0x00, 0x80, 0xC7, 0x0C, 0x00, 0x00, 0xDF, 0x0C, 0x00, 0x00, 0xFC, 0x0C, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0xFC, 0x0C, 0x00, 0x00, 0xDF, 0x0C, 0x00, 0x80, 0xC7, 0x0C, 0x00, 0xE0, 0xC3, 0x0C, 0x00, 0xE0, 0xC0, 0x0C, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¥
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xF8, 0x3F, 0xF8, 0x3F, 0xF8, 0x3F, 0xF8, 0x3F, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xE0, 0xF1, 0xC1, 0x01, 0xF0, 0xFB, 0xC1, 0x01, 0x30, 0x9B, 0x83, 0x03, 0x18, 0x0E, 0x03, 0x03, 0x18, 0x06, 0x06, 0x03, 0x18, 0x06, 0x06, 0x03, 0x18, 0x0C, 0x06, 0x03, 0x18, 0x0C, 0x06, 0x03, 0x38, 0x1C, 0x8F, 0x03, 0x70, 0xB8, 0xFF, 0x01, 0x60, 0xF8, 0xF9, 0x00, 0x00, 0xE0, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char §
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x11, 0x00, 0x70, 0x00, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xC0, 0x01, 0x1C, 0x00, 0x60, 0x00, 0x30, 0x00, 0x10, 0xFE, 0x41, 0x00, 0x10, 0xFF, 0x47, 0x00, 0x88, 0x01, 0x8C, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x01, 0x8C, 0x00, 0x10, 0x03, 0x46, 0x00, 0x10, 0x02, 0x42, 0x00, 0x60, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x18, 0x00, 0x00, 0xFF, 0x07, 0x00, 0x00, 0x70, 0x00, 0x00, // Code for char ©
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x3C, 0x00, 0x00, 0x60, 0x7E, 0x00, 0x00, 0x70, 0x67, 0x00, 0x00, 0x30, 0x63, 0x00, 0x00, 0x30, 0x63, 0x00, 0x00, 0x30, 0x63, 0x00, 0x00, 0x30, 0x33, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x70, 0x1C, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0x70, 0x1C, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char «
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¬
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x11, 0x00, 0x70, 0x00, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xC0, 0x01, 0x1C, 0x00, 0x60, 0x00, 0x30, 0x00, 0x10, 0x00, 0x40, 0x00, 0x90, 0xFF, 0x4F, 0x00, 0x88, 0x20, 0x80, 0x00, 0x88, 0x20, 0x80, 0x00, 0x88, 0x20, 0x80, 0x00, 0x88, 0xE0, 0x80, 0x00, 0x88, 0xF1, 0x83, 0x00, 0x10, 0x1F, 0x4F, 0x00, 0x10, 0x0E, 0x4C, 0x00, 0x60, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x18, 0x00, 0x00, 0xFF, 0x07, 0x00, 0x00, 0x70, 0x00, 0x00, // Code for char ®
-    0x11, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // Code for char ¯
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0xC0, 0x0C, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0xE0, 0x1C, 0x00, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0xC0, 0xFF, 0xCF, 0x00, 0xC0, 0xFF, 0xCF, 0x00, 0xC0, 0xFF, 0xCF, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ±
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x60, 0xE0, 0x00, 0x00, 0x70, 0xF0, 0x00, 0x00, 0x30, 0xD8, 0x00, 0x00, 0x30, 0xCC, 0x00, 0x00, 0x30, 0xC4, 0x00, 0x00, 0x70, 0xC3, 0x00, 0x00, 0xE0, 0xC1, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x70, 0xC0, 0x00, 0x00, 0x30, 0xC6, 0x00, 0x00, 0x30, 0xC6, 0x00, 0x00, 0x30, 0xC6, 0x00, 0x00, 0xF0, 0xEF, 0x00, 0x00, 0xE0, 0x7D, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char µ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xE0, 0xFF, 0xFF, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xE0, 0xFF, 0xFF, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¶
-    0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x20, 0xC0, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0x30, 0x60, 0x00, 0x00, 0x30, 0x60, 0x00, 0x00, 0x30, 0x60, 0x00, 0x00, 0x30, 0x70, 0x00, 0x00, 0xE0, 0x38, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x78, 0x3C, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x70, 0x1C, 0x00, 0x00, 0xE0, 0x0E, 0x00, 0x00, 0xC0, 0x07, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char »
-    0x11, 0x80, 0xC1, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x80, 0x00, 0x00, 0xC0, 0xE0, 0x00, 0x00, 0xC0, 0x38, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x0E, 0x3C, 0x00, 0x80, 0x03, 0x37, 0x00, 0xE0, 0x80, 0x31, 0x00, 0x20, 0xC0, 0x30, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0x30, 0x00, // Code for char ¼
-    0x11, 0x80, 0xC1, 0x00, 0x00, 0xC0, 0xC0, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x80, 0x00, 0x00, 0xC0, 0xE0, 0x00, 0x00, 0xC0, 0x38, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0xCE, 0xE0, 0x00, 0x80, 0xC3, 0xF0, 0x00, 0xE0, 0x60, 0xD8, 0x00, 0x20, 0x60, 0xC8, 0x00, 0x00, 0x60, 0xCC, 0x00, 0x00, 0xE0, 0xC7, 0x00, 0x00, 0xC0, 0xC1, 0x00, // Code for char ½
-    0x11, 0xC0, 0x60, 0x00, 0x00, 0xC0, 0x60, 0x00, 0x00, 0x60, 0xC0, 0x00, 0x00, 0x60, 0xC6, 0x80, 0x00, 0x60, 0xC6, 0xE0, 0x00, 0xE0, 0xFF, 0x38, 0x00, 0xC0, 0x79, 0x0E, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x0E, 0x3C, 0x00, 0x80, 0x03, 0x37, 0x00, 0xE0, 0x80, 0x31, 0x00, 0x20, 0xC0, 0x30, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0x30, 0x00, // Code for char ¾
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x0E, 0x06, 0x00, 0x00, 0x07, 0x0C, 0x00, 0x80, 0x03, 0x0C, 0x00, 0xE7, 0x01, 0x0C, 0x00, 0xE7, 0x00, 0x0C, 0x00, 0x27, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¿
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x01, 0xFE, 0x07, 0x00, 0xC3, 0x1F, 0x06, 0x00, 0xE7, 0x03, 0x06, 0x00, 0x6E, 0x00, 0x06, 0x00, 0xEC, 0x03, 0x06, 0x00, 0xC0, 0x1F, 0x06, 0x00, 0x00, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char À
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xFE, 0x07, 0x00, 0xC0, 0x1F, 0x06, 0x00, 0xE8, 0x03, 0x06, 0x00, 0x6E, 0x00, 0x06, 0x00, 0xE7, 0x03, 0x06, 0x00, 0xC3, 0x1F, 0x06, 0x00, 0x01, 0xFE, 0x06, 0x00, 0x01, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char Á
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x08, 0xF0, 0x07, 0x00, 0x0C, 0xFE, 0x07, 0x00, 0xC6, 0x1F, 0x06, 0x00, 0xE7, 0x03, 0x06, 0x00, 0x63, 0x00, 0x06, 0x00, 0xE7, 0x03, 0x06, 0x00, 0xC6, 0x1F, 0x06, 0x00, 0x0C, 0xFE, 0x06, 0x00, 0x08, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char Â
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x0E, 0xF0, 0x07, 0x00, 0x03, 0xFE, 0x07, 0x00, 0xC3, 0x1F, 0x06, 0x00, 0xE3, 0x03, 0x06, 0x00, 0x66, 0x00, 0x06, 0x00, 0xEC, 0x03, 0x06, 0x00, 0xCC, 0x1F, 0x06, 0x00, 0x0E, 0xFE, 0x06, 0x00, 0x07, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char Ã
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x07, 0xFE, 0x07, 0x00, 0xC7, 0x1F, 0x06, 0x00, 0xE0, 0x03, 0x06, 0x00, 0x60, 0x00, 0x06, 0x00, 0xE0, 0x03, 0x06, 0x00, 0xC7, 0x1F, 0x06, 0x00, 0x07, 0xFE, 0x06, 0x00, 0x07, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char Ä
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x18, 0xFE, 0x07, 0x00, 0xFC, 0x1F, 0x06, 0x00, 0xE6, 0x03, 0x06, 0x00, 0x66, 0x00, 0x06, 0x00, 0xE6, 0x03, 0x06, 0x00, 0xFE, 0x1F, 0x06, 0x00, 0x3C, 0xFE, 0x06, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xC0, 0x3F, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x80, 0x00, // Code for char Å
-    0x11, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xC0, 0x1F, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x00, 0x7E, 0x03, 0x00, 0xC0, 0x0F, 0x03, 0x00, 0xE0, 0x01, 0x03, 0x00, 0x60, 0x00, 0x03, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, // Code for char Æ
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0xC0, 0x1F, 0x7F, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x34, 0x60, 0x00, 0xC0, 0x37, 0x60, 0x00, 0xC0, 0x36, 0x60, 0x00, 0xC0, 0x1E, 0xE0, 0x00, 0xE0, 0x0C, 0xC0, 0x03, 0x70, 0x00, 0x80, 0x07, 0x3C, 0x00, 0x00, 0x03, 0x1C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ç
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x61, 0x60, 0xC0, 0x00, 0x63, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x6E, 0x60, 0xC0, 0x00, 0x6C, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char È
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x68, 0x60, 0xC0, 0x00, 0x6E, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x63, 0x60, 0xC0, 0x00, 0x61, 0x60, 0xC0, 0x00, 0x61, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char É
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE8, 0xFF, 0xFF, 0x00, 0x6C, 0x60, 0xC0, 0x00, 0x66, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x63, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x66, 0x60, 0xC0, 0x00, 0x6C, 0x60, 0xC0, 0x00, 0x68, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ê
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x67, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ë
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x61, 0x00, 0xC0, 0x00, 0x63, 0x00, 0xC0, 0x00, 0xE7, 0xFF, 0xFF, 0x00, 0xEE, 0xFF, 0xFF, 0x00, 0xEC, 0xFF, 0xFF, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ì
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE8, 0xFF, 0xFF, 0x00, 0xEE, 0xFF, 0xFF, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x63, 0x00, 0xC0, 0x00, 0x61, 0x00, 0xC0, 0x00, 0x61, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Í
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x68, 0x00, 0xC0, 0x00, 0x6C, 0x00, 0xC0, 0x00, 0x66, 0x00, 0xC0, 0x00, 0xE7, 0xFF, 0xFF, 0x00, 0xE3, 0xFF, 0xFF, 0x00, 0xE7, 0xFF, 0xFF, 0x00, 0x66, 0x00, 0xC0, 0x00, 0x6C, 0x00, 0xC0, 0x00, 0x68, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Î
-    0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ï
-    0x10, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x60, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x70, 0x00, 0x80, 0x07, 0x3C, 0x00, 0x80, 0xFF, 0x1F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ð
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xEE, 0xFE, 0xFF, 0x00, 0xE3, 0x07, 0x00, 0x00, 0x03, 0x1F, 0x00, 0x00, 0x03, 0x7C, 0x00, 0x00, 0x06, 0xF0, 0x01, 0x00, 0x0C, 0xC0, 0x0F, 0x00, 0x0C, 0x00, 0x3F, 0x00, 0x0E, 0x00, 0xF8, 0x00, 0xE7, 0xFF, 0xEF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ñ
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC1, 0x01, 0x70, 0x00, 0xE3, 0x00, 0xE0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x6E, 0x00, 0xC0, 0x00, 0x6C, 0x00, 0xC0, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ò
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC0, 0x01, 0x70, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x68, 0x00, 0xC0, 0x00, 0x6E, 0x00, 0xC0, 0x00, 0xE7, 0x00, 0xE0, 0x00, 0xC3, 0x01, 0x70, 0x00, 0xC1, 0x07, 0x7C, 0x00, 0x81, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ó
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC8, 0x07, 0x7C, 0x00, 0xCC, 0x01, 0x70, 0x00, 0xE6, 0x00, 0xE0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0x63, 0x00, 0xC0, 0x00, 0x67, 0x00, 0xC0, 0x00, 0xE6, 0x00, 0xE0, 0x00, 0xCC, 0x01, 0x70, 0x00, 0xC8, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ô
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xCE, 0x07, 0x7C, 0x00, 0xC3, 0x01, 0x70, 0x00, 0xE3, 0x00, 0xE0, 0x00, 0x63, 0x00, 0xC0, 0x00, 0x66, 0x00, 0xC0, 0x00, 0x6C, 0x00, 0xC0, 0x00, 0xEC, 0x00, 0xE0, 0x00, 0xCE, 0x01, 0x70, 0x00, 0xC7, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Õ
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC7, 0x01, 0x70, 0x00, 0xE7, 0x00, 0xE0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xE7, 0x00, 0xE0, 0x00, 0xC7, 0x01, 0x70, 0x00, 0xC7, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ö
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x07, 0x1C, 0x00, 0x00, 0x0E, 0x0E, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0xB8, 0x03, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x0E, 0x0E, 0x00, 0x00, 0x07, 0x1C, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xC0, 0x00, 0x00, 0xFE, 0xEF, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0xC0, 0x01, 0x7E, 0x00, 0xE0, 0x00, 0xE7, 0x00, 0x60, 0xC0, 0xC1, 0x00, 0x60, 0xE0, 0xC0, 0x00, 0x60, 0x30, 0xC0, 0x00, 0xE0, 0x1C, 0xE0, 0x00, 0xC0, 0x0F, 0x70, 0x00, 0xC0, 0x07, 0x7C, 0x00, 0x80, 0xFF, 0x3F, 0x00, 0xE0, 0xFE, 0x0F, 0x00, 0x60, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ø
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x01, 0x00, 0xE0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x0E, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xE0, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ù
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x08, 0x00, 0xC0, 0x00, 0x0E, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x01, 0x00, 0xE0, 0x00, 0xE1, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ú
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE8, 0xFF, 0x7F, 0x00, 0x0C, 0x00, 0xE0, 0x00, 0x06, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x06, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0xE0, 0x00, 0xE8, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Û
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0x1F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x7F, 0x00, 0x07, 0x00, 0xE0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xC0, 0x00, 0x07, 0x00, 0xE0, 0x00, 0xE7, 0xFF, 0x7F, 0x00, 0xE0, 0xFF, 0x3F, 0x00, 0xE0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ü
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x00, 0x08, 0xC0, 0xFF, 0x00, 0x0E, 0xF0, 0xFF, 0x00, 0x07, 0x78, 0x00, 0x00, 0x03, 0x1E, 0x00, 0x00, 0x81, 0x0F, 0x00, 0x00, 0xE1, 0x03, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ý
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x03, 0x0C, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x0E, 0x07, 0x00, 0x00, 0xFE, 0x03, 0x00, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Þ
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0xFF, 0x00, 0xE0, 0xFF, 0xFF, 0x00, 0xF0, 0xFF, 0xFF, 0x00, 0x38, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x60, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x18, 0x78, 0xC0, 0x00, 0x18, 0xFC, 0xC0, 0x00, 0x30, 0xCF, 0xC1, 0x00, 0xF0, 0xC7, 0xC1, 0x00, 0xE0, 0x81, 0xE7, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ß
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xF7, 0x00, 0x04, 0xC7, 0xC1, 0x00, 0x0C, 0xC3, 0xC0, 0x00, 0x1C, 0xC3, 0xC0, 0x00, 0x38, 0xC3, 0xC0, 0x00, 0x30, 0xC3, 0x60, 0x00, 0x00, 0xC7, 0x30, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char à
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xF7, 0x00, 0x00, 0xC7, 0xC1, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x20, 0xC3, 0xC0, 0x00, 0x38, 0xC3, 0xC0, 0x00, 0x1C, 0xC3, 0x60, 0x00, 0x0C, 0xC7, 0x30, 0x00, 0x04, 0xFE, 0x3F, 0x00, 0x04, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char á
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x20, 0x8E, 0xF7, 0x00, 0x30, 0xC7, 0xC1, 0x00, 0x18, 0xC3, 0xC0, 0x00, 0x1C, 0xC3, 0xC0, 0x00, 0x0C, 0xC3, 0xC0, 0x00, 0x1C, 0xC3, 0x60, 0x00, 0x18, 0xC7, 0x30, 0x00, 0x30, 0xFE, 0x3F, 0x00, 0x20, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char â
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x38, 0x8E, 0xF7, 0x00, 0x0C, 0xC7, 0xC1, 0x00, 0x0C, 0xC3, 0xC0, 0x00, 0x0C, 0xC3, 0xC0, 0x00, 0x18, 0xC3, 0xC0, 0x00, 0x30, 0xC3, 0x60, 0x00, 0x30, 0xC7, 0x30, 0x00, 0x38, 0xFE, 0x3F, 0x00, 0x1C, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ã
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xF7, 0x00, 0x38, 0xC7, 0xC1, 0x00, 0x38, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0x60, 0x00, 0x38, 0xC7, 0x30, 0x00, 0x38, 0xFE, 0x3F, 0x00, 0x38, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ä
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x3F, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xF7, 0x00, 0x0C, 0xC7, 0xC1, 0x00, 0x1E, 0xC3, 0xC0, 0x00, 0x33, 0xC3, 0xC0, 0x00, 0x33, 0xC3, 0xC0, 0x00, 0x33, 0xC3, 0x60, 0x00, 0x3F, 0xC7, 0x30, 0x00, 0x1E, 0xFE, 0x3F, 0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0xF8, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char å
-    0x11, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x8C, 0x7F, 0x00, 0x00, 0x8E, 0xFF, 0x00, 0x00, 0xC7, 0xC1, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0xC3, 0x70, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xBE, 0x7D, 0x00, 0x00, 0x87, 0xE1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x87, 0xC1, 0x00, 0x00, 0xFE, 0x71, 0x00, 0x00, 0xFC, 0x31, 0x00, 0x00, 0xE0, 0x01, 0x00, // Code for char æ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x34, 0x00, 0x03, 0xC0, 0x37, 0x00, 0x03, 0xC0, 0x36, 0x00, 0x03, 0xC0, 0x1E, 0x00, 0x07, 0xE0, 0x0C, 0x00, 0x0E, 0x70, 0x00, 0x00, 0x0E, 0x70, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ç
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x04, 0x8E, 0x61, 0x00, 0x0C, 0x87, 0xE1, 0x00, 0x1C, 0x83, 0xC1, 0x00, 0x38, 0x83, 0xC1, 0x00, 0x30, 0x83, 0xC1, 0x00, 0x00, 0x87, 0xC1, 0x00, 0x00, 0x86, 0xE1, 0x00, 0x00, 0xFE, 0x71, 0x00, 0x00, 0xFC, 0x31, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char è
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x8E, 0x61, 0x00, 0x00, 0x87, 0xE1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x20, 0x83, 0xC1, 0x00, 0x38, 0x83, 0xC1, 0x00, 0x1C, 0x87, 0xC1, 0x00, 0x0C, 0x86, 0xE1, 0x00, 0x04, 0xFE, 0x71, 0x00, 0x04, 0xFC, 0x31, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char é
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x20, 0xFE, 0x7F, 0x00, 0x30, 0x8E, 0x61, 0x00, 0x18, 0x87, 0xE1, 0x00, 0x1C, 0x83, 0xC1, 0x00, 0x0C, 0x83, 0xC1, 0x00, 0x1C, 0x83, 0xC1, 0x00, 0x18, 0x87, 0xC1, 0x00, 0x30, 0x86, 0xE1, 0x00, 0x20, 0xFE, 0x71, 0x00, 0x00, 0xFC, 0x31, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ê
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x38, 0x8E, 0x61, 0x00, 0x38, 0x87, 0xE1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x38, 0x87, 0xC1, 0x00, 0x38, 0x86, 0xE1, 0x00, 0x38, 0xFE, 0x71, 0x00, 0x00, 0xFC, 0x31, 0x00, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ë
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x04, 0x03, 0xC0, 0x00, 0x0C, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xC0, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x30, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ì
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x20, 0xFF, 0xFF, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x1C, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0xC0, 0x00, 0x04, 0x00, 0xC0, 0x00, 0x04, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char í
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x20, 0x03, 0xC0, 0x00, 0x30, 0x03, 0xC0, 0x00, 0x18, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xC0, 0x00, 0x0C, 0xFF, 0xFF, 0x00, 0x1C, 0xFF, 0xFF, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x20, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char î
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ï
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x40, 0xF8, 0x7C, 0x00, 0xC8, 0x1C, 0xE0, 0x00, 0x58, 0x0C, 0xC0, 0x00, 0x78, 0x0C, 0xC0, 0x00, 0x70, 0x0C, 0xC0, 0x00, 0x70, 0x0C, 0xC0, 0x00, 0xF0, 0x0D, 0xC0, 0x00, 0xD0, 0x1F, 0x60, 0x00, 0x18, 0xFF, 0x7C, 0x00, 0x10, 0xFE, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ð
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x0C, 0x1C, 0x00, 0x00, 0x0C, 0x06, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x18, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00, 0x38, 0x07, 0x00, 0x00, 0x1C, 0xFE, 0xFF, 0x00, 0x00, 0xFC, 0xFF, 0x00, 0x00, 0xE0, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ñ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x04, 0x06, 0x60, 0x00, 0x0C, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xC0, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x30, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xE0, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ò
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x20, 0x03, 0xC0, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xE0, 0x00, 0x0C, 0x06, 0x60, 0x00, 0x04, 0xFE, 0x7F, 0x00, 0x04, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ó
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x20, 0x7E, 0x7E, 0x00, 0x30, 0x06, 0x60, 0x00, 0x18, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xC0, 0x00, 0x0C, 0x03, 0xC0, 0x00, 0x1C, 0x03, 0xC0, 0x00, 0x18, 0x03, 0xE0, 0x00, 0x30, 0x06, 0x60, 0x00, 0x20, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ô
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x38, 0x7E, 0x7E, 0x00, 0x0C, 0x06, 0x60, 0x00, 0x0C, 0x03, 0xC0, 0x00, 0x0C, 0x03, 0xC0, 0x00, 0x18, 0x03, 0xC0, 0x00, 0x30, 0x03, 0xC0, 0x00, 0x30, 0x03, 0xE0, 0x00, 0x38, 0x06, 0x60, 0x00, 0x1C, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char õ
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x38, 0x06, 0x60, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x38, 0x03, 0xE0, 0x00, 0x38, 0x06, 0x60, 0x00, 0x38, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ö
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x80, 0x63, 0x1C, 0x00, 0x80, 0x63, 0x1C, 0x00, 0x80, 0x63, 0x1C, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ÷
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xDF, 0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x1E, 0x78, 0x00, 0x00, 0x06, 0x7C, 0x00, 0x00, 0x03, 0xC6, 0x00, 0x00, 0x03, 0xC3, 0x00, 0x00, 0x83, 0xC1, 0x00, 0x00, 0xC3, 0xC0, 0x00, 0x00, 0x63, 0xC0, 0x00, 0x00, 0x3F, 0x60, 0x00, 0x00, 0x1E, 0x78, 0x00, 0x00, 0xFE, 0x3F, 0x00, 0x00, 0xFB, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ø
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x04, 0x00, 0xE0, 0x00, 0x0C, 0x00, 0xC0, 0x00, 0x1C, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ù
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x20, 0x00, 0xC0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x1C, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0x60, 0x00, 0x04, 0x00, 0x30, 0x00, 0x04, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ú
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x20, 0xFF, 0x7F, 0x00, 0x30, 0x00, 0xE0, 0x00, 0x18, 0x00, 0xC0, 0x00, 0x1C, 0x00, 0xC0, 0x00, 0x0C, 0x00, 0xC0, 0x00, 0x1C, 0x00, 0xC0, 0x00, 0x18, 0x00, 0x60, 0x00, 0x30, 0x00, 0x30, 0x00, 0x20, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char û
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0xFF, 0x7F, 0x00, 0x38, 0x00, 0xE0, 0x00, 0x38, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x38, 0x00, 0x60, 0x00, 0x38, 0x00, 0x30, 0x00, 0x38, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ü
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x30, 0x00, 0x3F, 0x00, 0x30, 0x00, 0xFC, 0x01, 0x30, 0x00, 0xE0, 0x07, 0x38, 0x00, 0x00, 0x3F, 0x1C, 0x00, 0x00, 0xFC, 0x0F, 0x20, 0x00, 0xE0, 0x07, 0x38, 0x00, 0xF8, 0x01, 0x1C, 0x00, 0x3F, 0x00, 0x0C, 0xE0, 0x07, 0x00, 0x04, 0xFC, 0x01, 0x00, 0x04, 0x3F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ý
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x3F, 0xF8, 0xFF, 0xFF, 0x3F, 0x00, 0x1C, 0x38, 0x00, 0x00, 0x06, 0x60, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x03, 0xC0, 0x00, 0x00, 0x07, 0xE0, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char þ
-    0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x30, 0x00, 0x3F, 0x00, 0x30, 0x00, 0xFC, 0x01, 0x30, 0x38, 0xE0, 0x07, 0x38, 0x38, 0x00, 0x3F, 0x1C, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0xF8, 0x01, 0x38, 0x00, 0x3F, 0x00, 0x38, 0xE0, 0x07, 0x00, 0x38, 0xFC, 0x01, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_liberation_mono_17x30 = {
-    Liberation_Mono17x30,
-    17,
-    30,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_liberation_mono_9x15.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Liberation_Mono9x15
-//GLCD FontSize : 9 x 15
-
-static const uint8_t Liberation_Mono9x15[ ] = {
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x09, 0x00, 0x01, 0x20, 0x0D, 0xE0, 0x03, 0x3C, 0x01, 0x20, 0x01, 0x20, 0x0F, 0xF8, 0x01, 0x24, 0x01, 0x20, 0x00, // Code for char #
-    0x08, 0x00, 0x00, 0x38, 0x06, 0x6C, 0x0C, 0x44, 0x08, 0xFE, 0x1F, 0x44, 0x08, 0x8C, 0x08, 0x98, 0x07, 0x00, 0x00, // Code for char $
-    0x09, 0x38, 0x00, 0x44, 0x08, 0x44, 0x06, 0x7C, 0x01, 0xC0, 0x00, 0xA0, 0x0F, 0x98, 0x08, 0x84, 0x08, 0x00, 0x07, // Code for char %
-    0x09, 0x00, 0x03, 0x80, 0x0F, 0x78, 0x08, 0xC4, 0x08, 0x24, 0x0B, 0x24, 0x04, 0x18, 0x0F, 0x80, 0x08, 0x00, 0x08, // Code for char &
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x1F, 0x0C, 0x30, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x0C, 0x30, 0xF8, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x38, 0x00, 0x0E, 0x00, 0x38, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char +
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x06, 0x80, 0x03, 0xE0, 0x00, 0x38, 0x00, 0x0C, 0x00, 0x02, 0x00, 0x00, 0x00, // Code for char /
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0xC4, 0x08, 0x04, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char 0
-    0x08, 0x00, 0x00, 0x10, 0x08, 0x10, 0x08, 0x08, 0x08, 0xFC, 0x0F, 0xFC, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char 1
-    0x08, 0x00, 0x00, 0x10, 0x0C, 0x18, 0x0E, 0x04, 0x0B, 0x84, 0x09, 0x84, 0x08, 0x7C, 0x08, 0x38, 0x08, 0x00, 0x00, // Code for char 2
-    0x08, 0x00, 0x00, 0x10, 0x06, 0x18, 0x0C, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0xBC, 0x0C, 0x98, 0x07, 0x00, 0x00, // Code for char 3
-    0x08, 0x00, 0x00, 0x80, 0x01, 0x40, 0x01, 0x30, 0x01, 0x18, 0x01, 0x04, 0x01, 0xFC, 0x0F, 0x00, 0x01, 0x00, 0x00, // Code for char 4
-    0x08, 0x00, 0x00, 0x78, 0x06, 0x7C, 0x0C, 0x24, 0x08, 0x24, 0x08, 0x24, 0x08, 0x64, 0x04, 0xC0, 0x03, 0x00, 0x00, // Code for char 5
-    0x08, 0x00, 0x00, 0xE0, 0x03, 0xD8, 0x07, 0x24, 0x08, 0x24, 0x08, 0x24, 0x08, 0x6C, 0x0C, 0xC8, 0x07, 0x00, 0x00, // Code for char 6
-    0x08, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x0E, 0xC4, 0x03, 0x64, 0x00, 0x1C, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char 7
-    0x08, 0x00, 0x00, 0x98, 0x07, 0xBC, 0x0C, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0xBC, 0x0C, 0x98, 0x07, 0x00, 0x00, // Code for char 8
-    0x08, 0x00, 0x00, 0x70, 0x04, 0xDC, 0x0D, 0x04, 0x09, 0x04, 0x09, 0x04, 0x09, 0xD8, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char 9
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x30, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x08, 0x00, 0x00, 0x40, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xB0, 0x01, 0x10, 0x01, 0x10, 0x01, 0x08, 0x02, 0x00, 0x00, // Code for char <
-    0x08, 0x00, 0x00, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x00, 0x00, // Code for char =
-    0x08, 0x00, 0x00, 0x08, 0x02, 0x10, 0x01, 0x10, 0x01, 0xB0, 0x01, 0xA0, 0x00, 0xA0, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char >
-    0x08, 0x00, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x04, 0x09, 0x84, 0x09, 0xC4, 0x00, 0x6C, 0x00, 0x38, 0x00, 0x00, 0x00, // Code for char ?
-    0x09, 0xC0, 0x03, 0x38, 0x1C, 0xC4, 0x13, 0x32, 0x24, 0x12, 0x24, 0x92, 0x23, 0x76, 0x14, 0x0C, 0x16, 0xF0, 0x01, // Code for char @
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE0, 0x01, 0x38, 0x01, 0x04, 0x01, 0x3C, 0x01, 0xE0, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char A
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0xBC, 0x0C, 0x98, 0x07, 0x00, 0x00, // Code for char B
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x0C, 0x0C, 0x18, 0x06, 0x00, 0x00, // Code for char C
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char D
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char E
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x44, 0x00, 0x00, 0x00, // Code for char F
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x08, 0x84, 0x08, 0x88, 0x08, 0x90, 0x07, 0x00, 0x00, // Code for char G
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x00, 0x00, // Code for char H
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0xFC, 0x0F, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char I
-    0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x0E, 0x00, 0x08, 0x04, 0x08, 0x04, 0x0C, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x09, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x40, 0x00, 0xE0, 0x00, 0x90, 0x01, 0x0C, 0x06, 0x04, 0x0C, 0x00, 0x08, // Code for char K
-    0x08, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char L
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0x1C, 0x00, 0xE0, 0x00, 0x00, 0x01, 0xE0, 0x00, 0x1C, 0x00, 0xFC, 0x0F, 0x00, 0x00, // Code for char M
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x00, 0x07, 0x00, 0x0C, 0xFC, 0x0F, 0x00, 0x00, // Code for char N
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char O
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x84, 0x00, 0x84, 0x00, 0x84, 0x00, 0xCC, 0x00, 0x78, 0x00, 0x00, 0x00, // Code for char P
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x18, 0x04, 0x78, 0x18, 0x46, 0xF0, 0x43, 0x00, 0x00, // Code for char Q
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x00, 0x44, 0x00, 0xC4, 0x01, 0x6C, 0x07, 0x38, 0x0C, 0x00, 0x00, // Code for char R
-    0x08, 0x00, 0x00, 0x38, 0x06, 0x6C, 0x0C, 0x44, 0x08, 0x44, 0x08, 0xC4, 0x08, 0x8C, 0x0C, 0x98, 0x07, 0x00, 0x00, // Code for char S
-    0x08, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0xFC, 0x0F, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, // Code for char T
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x0E, 0xFC, 0x07, 0x00, 0x00, // Code for char U
-    0x09, 0x04, 0x00, 0x3C, 0x00, 0xE0, 0x01, 0x00, 0x07, 0x00, 0x08, 0x00, 0x07, 0xE0, 0x01, 0x3C, 0x00, 0x04, 0x00, // Code for char V
-    0x09, 0x1C, 0x00, 0xF8, 0x0F, 0x00, 0x0C, 0xC0, 0x03, 0x20, 0x00, 0xC0, 0x03, 0x00, 0x0C, 0xF8, 0x0F, 0x1C, 0x00, // Code for char W
-    0x08, 0x00, 0x00, 0x04, 0x0C, 0x18, 0x06, 0xB0, 0x01, 0xC0, 0x00, 0xB0, 0x01, 0x18, 0x06, 0x04, 0x0C, 0x00, 0x00, // Code for char X
-    0x08, 0x00, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x00, 0x0F, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x00, 0x00, // Code for char Y
-    0x08, 0x00, 0x00, 0x04, 0x0C, 0x04, 0x0B, 0x84, 0x09, 0xC4, 0x08, 0x34, 0x08, 0x1C, 0x08, 0x0C, 0x08, 0x00, 0x00, // Code for char Z
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x7F, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x08, 0x00, 0x00, 0x02, 0x00, 0x0C, 0x00, 0x38, 0x00, 0xE0, 0x00, 0x80, 0x03, 0x00, 0x06, 0x00, 0x08, 0x00, 0x00, // Code for char BackSlash
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0xFE, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x08, 0x00, 0x00, 0x00, 0x01, 0xE0, 0x00, 0x18, 0x00, 0x04, 0x00, 0x18, 0x00, 0xE0, 0x00, 0x00, 0x01, 0x00, 0x00, // Code for char ^
-    0x09, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, // Code for char _
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB0, 0x0D, 0x90, 0x08, 0x90, 0x08, 0x90, 0x04, 0xE0, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char a
-    0x08, 0x00, 0x00, 0xFE, 0x0F, 0xFE, 0x0F, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x70, 0x0E, 0xE0, 0x07, 0x00, 0x00, // Code for char b
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x60, 0x06, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x30, 0x0C, 0x20, 0x04, 0x00, 0x00, // Code for char c
-    0x08, 0x00, 0x00, 0xE0, 0x07, 0x70, 0x0E, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0xFE, 0x0F, 0xFE, 0x0F, 0x00, 0x00, // Code for char d
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0xA0, 0x06, 0x90, 0x08, 0x90, 0x08, 0x90, 0x08, 0xB0, 0x0C, 0xE0, 0x04, 0x00, 0x00, // Code for char e
-    0x08, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0xFC, 0x0F, 0x16, 0x00, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x00, 0x00, // Code for char f
-    0x08, 0x00, 0x00, 0xE0, 0x07, 0x70, 0x6E, 0x10, 0x48, 0x10, 0x48, 0x10, 0x48, 0xF0, 0x7F, 0xF0, 0x1F, 0x00, 0x00, // Code for char g
-    0x08, 0x00, 0x00, 0xFE, 0x0F, 0xFE, 0x0F, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x0F, 0xE0, 0x0F, 0x00, 0x00, // Code for char h
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x10, 0x08, 0x10, 0x08, 0xF2, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char i
-    0x06, 0x00, 0x00, 0x00, 0x40, 0x10, 0x40, 0x10, 0x40, 0x10, 0x60, 0xF2, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x08, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0x80, 0x01, 0xC0, 0x01, 0x60, 0x03, 0x30, 0x0C, 0x10, 0x08, 0x00, 0x00, // Code for char k
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x02, 0x08, 0x02, 0x08, 0xFE, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char l
-    0x08, 0x00, 0x00, 0xF0, 0x0F, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x0F, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x0F, 0x00, 0x00, // Code for char m
-    0x08, 0x00, 0x00, 0xF0, 0x0F, 0xF0, 0x0F, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x0F, 0xE0, 0x0F, 0x00, 0x00, // Code for char n
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x70, 0x0E, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x70, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char o
-    0x08, 0x00, 0x00, 0xF0, 0x7F, 0xF0, 0x7F, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x70, 0x0E, 0xE0, 0x07, 0x00, 0x00, // Code for char p
-    0x08, 0x00, 0x00, 0xE0, 0x07, 0x70, 0x0E, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0xF0, 0x7F, 0xF0, 0x7F, 0x00, 0x00, // Code for char q
-    0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x0F, 0xC0, 0x00, 0x30, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x00, // Code for char r
-    0x08, 0x00, 0x00, 0x00, 0x04, 0xF0, 0x0C, 0x90, 0x08, 0x90, 0x08, 0x10, 0x09, 0x30, 0x0F, 0x00, 0x06, 0x00, 0x00, // Code for char s
-    0x07, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0xFC, 0x0F, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0xF0, 0x0F, 0xF0, 0x0F, 0x00, 0x00, // Code for char u
-    0x08, 0x00, 0x00, 0x70, 0x00, 0xE0, 0x01, 0x00, 0x0F, 0x00, 0x08, 0x00, 0x07, 0xE0, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char v
-    0x09, 0x30, 0x00, 0xF0, 0x0F, 0x00, 0x0C, 0x80, 0x03, 0x40, 0x00, 0x80, 0x07, 0x00, 0x08, 0xF0, 0x0F, 0x30, 0x00, // Code for char w
-    0x08, 0x00, 0x00, 0x10, 0x08, 0x30, 0x04, 0xC0, 0x03, 0x80, 0x01, 0xC0, 0x03, 0x30, 0x0C, 0x10, 0x08, 0x00, 0x00, // Code for char x
-    0x08, 0x00, 0x00, 0x30, 0x40, 0xC0, 0x41, 0x00, 0x67, 0x00, 0x18, 0x00, 0x07, 0xC0, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char y
-    0x08, 0x00, 0x00, 0x10, 0x08, 0x10, 0x0E, 0x10, 0x0B, 0x90, 0x09, 0x50, 0x08, 0x30, 0x08, 0x10, 0x08, 0x00, 0x00, // Code for char z
-    0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x02, 0xFE, 0x7E, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x00, 0x00, // Code for char {
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x07, 0x00, 0x00, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x7E, 0x7F, 0x40, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xC0, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, // Code for char ~
-    0x03, 0xF0, 0x1F, 0x10, 0x10, 0xF0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char €
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‚
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ƒ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char „
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char …
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char †
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‡
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˆ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‰
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‹
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ‘
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ’
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char “
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ”
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char •
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char –
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char —
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ˜
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ™
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char š
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ›
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char œ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ž
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Ÿ
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char  
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¡
-    0x08, 0x00, 0x00, 0xE0, 0x01, 0x30, 0x03, 0x08, 0x04, 0x0C, 0x0C, 0x08, 0x04, 0x18, 0x06, 0x10, 0x02, 0x00, 0x00, // Code for char ¢
-    0x09, 0x40, 0x08, 0x40, 0x0C, 0xF8, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x44, 0x08, 0x0C, 0x08, 0x08, 0x0C, 0x00, 0x04, // Code for char £
-    0x08, 0x00, 0x00, 0xD0, 0x05, 0x60, 0x07, 0x10, 0x04, 0x10, 0x04, 0x10, 0x04, 0x60, 0x03, 0xD0, 0x05, 0x00, 0x00, // Code for char ¤
-    0x08, 0x00, 0x00, 0x8C, 0x02, 0xB8, 0x02, 0xE0, 0x02, 0x80, 0x0F, 0xE0, 0x02, 0x98, 0x02, 0x8C, 0x02, 0x00, 0x00, // Code for char ¥
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¦
-    0x08, 0x00, 0x00, 0x40, 0x08, 0xEE, 0x19, 0x12, 0x11, 0x12, 0x11, 0x12, 0x13, 0xA6, 0x1B, 0xE4, 0x0C, 0x00, 0x00, // Code for char §
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¨
-    0x09, 0xF0, 0x01, 0x0C, 0x06, 0xF6, 0x0D, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x16, 0x0D, 0x0C, 0x06, 0xF0, 0x01, // Code for char ©
-    0x07, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x00, 0x94, 0x00, 0x94, 0x00, 0x5C, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ª
-    0x08, 0x00, 0x00, 0x80, 0x00, 0x60, 0x03, 0x30, 0x06, 0x90, 0x04, 0xC0, 0x01, 0x20, 0x02, 0x10, 0x04, 0x00, 0x00, // Code for char «
-    0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xC0, 0x03, 0x00, 0x00, // Code for char ¬
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ­
-    0x09, 0xF0, 0x01, 0x0C, 0x06, 0xFE, 0x0F, 0x4A, 0x08, 0x4A, 0x08, 0xCA, 0x09, 0x36, 0x0E, 0x0C, 0x06, 0xF0, 0x01, // Code for char ®
-    0x09, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, // Code for char ¯
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char °
-    0x08, 0x00, 0x00, 0x40, 0x08, 0x40, 0x08, 0x40, 0x08, 0xF8, 0x0B, 0x40, 0x08, 0x40, 0x08, 0x40, 0x08, 0x00, 0x00, // Code for char ±
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0xC4, 0x00, 0xA4, 0x00, 0x94, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ²
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x84, 0x00, 0x94, 0x00, 0x94, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ³
-    0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ´
-    0x08, 0x00, 0x00, 0xF0, 0x7F, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x06, 0xF0, 0x0F, 0x00, 0x00, // Code for char µ
-    0x08, 0x00, 0x00, 0x38, 0x00, 0x7C, 0x00, 0x7C, 0x00, 0xFC, 0x3F, 0x04, 0x00, 0xFC, 0x3F, 0x04, 0x00, 0x00, 0x00, // Code for char ¶
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ·
-    0x04, 0x00, 0x00, 0x00, 0x50, 0x00, 0x50, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¸
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x88, 0x00, 0xFC, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ¹
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x84, 0x00, 0x84, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char º
-    0x08, 0x00, 0x00, 0x10, 0x04, 0x20, 0x02, 0xC0, 0x01, 0x90, 0x04, 0x30, 0x06, 0x60, 0x03, 0x80, 0x00, 0x00, 0x00, // Code for char »
-    0x09, 0x88, 0x00, 0xFC, 0x0C, 0x80, 0x03, 0xC0, 0x00, 0x30, 0x06, 0x0C, 0x05, 0xC0, 0x04, 0xC0, 0x0F, 0x00, 0x04, // Code for char ¼
-    0x09, 0x88, 0x00, 0xFC, 0x0C, 0x80, 0x03, 0xC0, 0x00, 0x30, 0x00, 0x8C, 0x0C, 0x40, 0x0A, 0x40, 0x0B, 0x80, 0x08, // Code for char ½
-    0x09, 0x48, 0x00, 0x94, 0x00, 0x94, 0x0C, 0x68, 0x03, 0xC0, 0x06, 0x30, 0x05, 0xCC, 0x04, 0xC0, 0x0F, 0x00, 0x04, // Code for char ¾
-    0x08, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x36, 0x00, 0x23, 0x90, 0x21, 0x90, 0x20, 0x00, 0x30, 0x00, 0x18, 0x00, 0x00, // Code for char ¿
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE0, 0x01, 0x38, 0x01, 0x04, 0x01, 0x3D, 0x01, 0xE0, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char À
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE0, 0x01, 0x38, 0x01, 0x05, 0x01, 0x3C, 0x01, 0xE0, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char Á
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE1, 0x01, 0x39, 0x01, 0x04, 0x01, 0x3D, 0x01, 0xE1, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char Â
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE1, 0x01, 0x38, 0x01, 0x05, 0x01, 0x3D, 0x01, 0xE1, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char Ã
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE1, 0x01, 0x39, 0x01, 0x04, 0x01, 0x3D, 0x01, 0xE1, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char Ä
-    0x09, 0x00, 0x08, 0x00, 0x0F, 0xE0, 0x01, 0x3F, 0x01, 0x05, 0x01, 0x3F, 0x01, 0xE0, 0x01, 0x00, 0x0F, 0x00, 0x08, // Code for char Å
-    0x09, 0x00, 0x08, 0x00, 0x07, 0xE0, 0x01, 0x1C, 0x01, 0x04, 0x01, 0xFC, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x00, 0x08, // Code for char Æ
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x58, 0x04, 0x58, 0x0C, 0x2C, 0x18, 0x06, 0x00, 0x00, // Code for char Ç
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x45, 0x08, 0x44, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char È
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x08, 0x45, 0x08, 0x44, 0x08, 0x44, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char É
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFD, 0x0F, 0x45, 0x08, 0x44, 0x08, 0x45, 0x08, 0x45, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Ê
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFD, 0x0F, 0x45, 0x08, 0x44, 0x08, 0x45, 0x08, 0x45, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Ë
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0xFC, 0x0F, 0x05, 0x08, 0x04, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Ì
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0xFD, 0x0F, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Í
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x05, 0x08, 0x05, 0x08, 0xFC, 0x0F, 0x05, 0x08, 0x05, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Î
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x05, 0x08, 0x05, 0x08, 0xFC, 0x0F, 0x05, 0x08, 0x05, 0x08, 0x04, 0x08, 0x00, 0x00, // Code for char Ï
-    0x08, 0x40, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x44, 0x08, 0x44, 0x08, 0x04, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Ð
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0x0D, 0x00, 0x30, 0x00, 0xC1, 0x00, 0x01, 0x07, 0x01, 0x0C, 0xFC, 0x0F, 0x00, 0x00, // Code for char Ñ
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x04, 0x08, 0x05, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Ò
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x18, 0x06, 0x04, 0x08, 0x05, 0x08, 0x04, 0x08, 0x18, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Ó
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x19, 0x06, 0x05, 0x08, 0x04, 0x08, 0x05, 0x08, 0x19, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Ô
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x19, 0x06, 0x04, 0x08, 0x05, 0x08, 0x05, 0x08, 0x19, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Õ
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0x19, 0x06, 0x05, 0x08, 0x04, 0x08, 0x05, 0x08, 0x19, 0x06, 0xF0, 0x03, 0x00, 0x00, // Code for char Ö
-    0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0xA0, 0x00, 0x40, 0x00, 0xA0, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, // Code for char ×
-    0x08, 0x00, 0x00, 0xF0, 0x0F, 0x18, 0x06, 0x04, 0x09, 0xC4, 0x08, 0x24, 0x08, 0x18, 0x06, 0xFC, 0x03, 0x00, 0x00, // Code for char Ø
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x08, 0x01, 0x08, 0x00, 0x0E, 0xFC, 0x07, 0x00, 0x00, // Code for char Ù
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x00, 0x0E, 0x00, 0x08, 0x01, 0x08, 0x00, 0x08, 0x00, 0x0E, 0xFC, 0x07, 0x00, 0x00, // Code for char Ú
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x01, 0x0E, 0x01, 0x08, 0x00, 0x08, 0x01, 0x08, 0x01, 0x0E, 0xFC, 0x07, 0x00, 0x00, // Code for char Û
-    0x08, 0x00, 0x00, 0xFC, 0x07, 0x01, 0x0E, 0x01, 0x08, 0x00, 0x08, 0x01, 0x08, 0x01, 0x0E, 0xFC, 0x07, 0x00, 0x00, // Code for char Ü
-    0x08, 0x00, 0x00, 0x0C, 0x00, 0x30, 0x00, 0xC0, 0x00, 0x01, 0x0F, 0xC0, 0x00, 0x30, 0x00, 0x0C, 0x00, 0x00, 0x00, // Code for char Ý
-    0x08, 0x00, 0x00, 0xFC, 0x0F, 0xFC, 0x0F, 0x10, 0x02, 0x10, 0x02, 0x10, 0x02, 0x30, 0x03, 0xE0, 0x01, 0x00, 0x00, // Code for char Þ
-    0x09, 0x00, 0x00, 0xFC, 0x0F, 0x06, 0x00, 0x02, 0x00, 0x02, 0x08, 0xE2, 0x08, 0x9E, 0x08, 0x00, 0x0F, 0x00, 0x02, // Code for char ß
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB2, 0x0D, 0x92, 0x08, 0x94, 0x08, 0x90, 0x04, 0xE0, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char à
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB0, 0x0D, 0x90, 0x08, 0x94, 0x08, 0x92, 0x04, 0xE2, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char á
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB4, 0x0D, 0x96, 0x08, 0x92, 0x08, 0x96, 0x04, 0xE4, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char â
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB6, 0x0D, 0x92, 0x08, 0x96, 0x08, 0x94, 0x04, 0xE6, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char ã
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB6, 0x0D, 0x96, 0x08, 0x90, 0x08, 0x96, 0x04, 0xE6, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char ä
-    0x09, 0x00, 0x00, 0x20, 0x07, 0xB0, 0x0D, 0x97, 0x08, 0x95, 0x08, 0x97, 0x04, 0xE0, 0x0F, 0x00, 0x08, 0x00, 0x08, // Code for char å
-    0x09, 0x00, 0x07, 0xB0, 0x0D, 0x90, 0x08, 0x90, 0x04, 0xE0, 0x07, 0x90, 0x08, 0x90, 0x08, 0xB0, 0x0C, 0xE0, 0x04, // Code for char æ
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x60, 0x06, 0x10, 0x08, 0x10, 0x58, 0x10, 0x58, 0x30, 0x2C, 0x20, 0x04, 0x00, 0x00, // Code for char ç
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0xA0, 0x06, 0x92, 0x08, 0x92, 0x08, 0x94, 0x08, 0xB0, 0x0C, 0xE0, 0x04, 0x00, 0x00, // Code for char è
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0xA0, 0x06, 0x90, 0x08, 0x94, 0x08, 0x92, 0x08, 0xB2, 0x0C, 0xE0, 0x04, 0x00, 0x00, // Code for char é
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0xA4, 0x06, 0x96, 0x08, 0x92, 0x08, 0x96, 0x08, 0xB4, 0x0C, 0xE0, 0x04, 0x00, 0x00, // Code for char ê
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0xA6, 0x06, 0x96, 0x08, 0x90, 0x08, 0x96, 0x08, 0xB6, 0x0C, 0xE0, 0x04, 0x00, 0x00, // Code for char ë
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x12, 0x08, 0x12, 0x08, 0xF4, 0x0F, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char ì
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x10, 0x08, 0x10, 0x08, 0xF4, 0x0F, 0x02, 0x08, 0x02, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char í
-    0x08, 0x00, 0x00, 0x04, 0x08, 0x16, 0x08, 0x12, 0x08, 0xF6, 0x0F, 0x04, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char î
-    0x08, 0x00, 0x00, 0x00, 0x08, 0x16, 0x08, 0x16, 0x08, 0xF0, 0x0F, 0x06, 0x08, 0x06, 0x08, 0x00, 0x08, 0x00, 0x00, // Code for char ï
-    0x08, 0x00, 0x00, 0xC0, 0x07, 0x68, 0x0C, 0x26, 0x08, 0x24, 0x08, 0x2C, 0x08, 0x72, 0x0C, 0xE0, 0x07, 0x00, 0x00, // Code for char ð
-    0x08, 0x00, 0x00, 0xF0, 0x0F, 0xF6, 0x0F, 0x12, 0x00, 0x16, 0x00, 0x14, 0x00, 0xF6, 0x0F, 0xE0, 0x0F, 0x00, 0x00, // Code for char ñ
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x70, 0x0E, 0x12, 0x08, 0x12, 0x08, 0x14, 0x08, 0x70, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char ò
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x70, 0x0E, 0x10, 0x08, 0x14, 0x08, 0x12, 0x08, 0x72, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char ó
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x74, 0x0E, 0x16, 0x08, 0x12, 0x08, 0x16, 0x08, 0x74, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char ô
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x76, 0x0E, 0x12, 0x08, 0x16, 0x08, 0x14, 0x08, 0x76, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char õ
-    0x08, 0x00, 0x00, 0xC0, 0x03, 0x76, 0x0E, 0x16, 0x08, 0x10, 0x08, 0x16, 0x08, 0x76, 0x06, 0xE0, 0x03, 0x00, 0x00, // Code for char ö
-    0x08, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x48, 0x02, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, // Code for char ÷
-    0x08, 0x00, 0x00, 0xE0, 0x0F, 0x30, 0x0C, 0x10, 0x0A, 0x90, 0x09, 0x50, 0x08, 0x30, 0x0C, 0xF0, 0x07, 0x00, 0x00, // Code for char ø
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x0F, 0x02, 0x08, 0x02, 0x08, 0x04, 0x08, 0xF0, 0x0F, 0xF0, 0x0F, 0x00, 0x00, // Code for char ù
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x0F, 0x00, 0x08, 0x04, 0x08, 0x02, 0x08, 0xF2, 0x0F, 0xF0, 0x0F, 0x00, 0x00, // Code for char ú
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0xF4, 0x0F, 0x06, 0x08, 0x02, 0x08, 0x06, 0x08, 0xF4, 0x0F, 0xF0, 0x0F, 0x00, 0x00, // Code for char û
-    0x08, 0x00, 0x00, 0xF0, 0x03, 0xF6, 0x0F, 0x06, 0x08, 0x00, 0x08, 0x06, 0x08, 0xF6, 0x0F, 0xF0, 0x0F, 0x00, 0x00, // Code for char ü
-    0x08, 0x00, 0x00, 0x30, 0x40, 0xC0, 0x41, 0x00, 0x67, 0x04, 0x18, 0x02, 0x07, 0xC2, 0x01, 0x30, 0x00, 0x00, 0x00, // Code for char ý
-    0x08, 0x00, 0x00, 0xFE, 0x7F, 0xFE, 0x7F, 0x10, 0x08, 0x10, 0x08, 0x10, 0x08, 0x70, 0x0E, 0xE0, 0x07, 0x00, 0x00, // Code for char þ
-    0x08, 0x00, 0x00, 0x30, 0x40, 0xC6, 0x41, 0x06, 0x67, 0x00, 0x18, 0x06, 0x07, 0xC6, 0x01, 0x30, 0x00, 0x00, 0x00  // Code for char ÿ
-};
-
-const struct GDS_FontDef Font_liberation_mono_9x15 = {
-    Liberation_Mono9x15,
-    9,
-    15,
-    ' ',
-    '\xFF',
-    true
-};

components/display/fonts/font_line_1.c

@@ -1,224 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011 
-//http://www.mikroe.com 
-
-//GLCD FontName : Square721_BT11x14
-//GLCD FontSize : 11 x 14
-
-static const uint8_t Square721_BT11x14[] = {
-        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
-        0x02, 0x00, 0x00, 0xF8, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char !
-        0x03, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char "
-        0x08, 0x00, 0x00, 0x00, 0x01, 0x40, 0x07, 0xE0, 0x01, 0x58, 0x07, 0xC0, 0x01, 0x78, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char #
-        0x07, 0x30, 0x03, 0x48, 0x04, 0x48, 0x04, 0xFC, 0x0F, 0x48, 0x04, 0x48, 0x04, 0x98, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char $
-        0x09, 0xF8, 0x00, 0x88, 0x00, 0x88, 0x00, 0xF8, 0x07, 0xE0, 0x00, 0xD8, 0x07, 0x40, 0x04, 0x40, 0x04, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00,  // Code for char %
-        0x08, 0x00, 0x00, 0x80, 0x03, 0x78, 0x04, 0x48, 0x04, 0xC8, 0x04, 0x08, 0x05, 0x98, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char &
-        0x02, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char '
-        0x03, 0x00, 0x00, 0xF8, 0x07, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char (
-        0x02, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char )
-        0x06, 0x00, 0x00, 0x10, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char *
-        0x08, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xF0, 0x07, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char +
-        0x02, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ,
-        0x04, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char -
-        0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
-        0x04, 0x00, 0x0C, 0x80, 0x03, 0x70, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char /
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 0
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x10, 0x04, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 1
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x30, 0x07, 0x08, 0x05, 0x88, 0x04, 0x88, 0x04, 0x88, 0x04, 0x70, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 2
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x08, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0xB8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 3
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x40, 0x01, 0x30, 0x01, 0x08, 0x01, 0xF8, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 4
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x78, 0x03, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x88, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 5
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0xD8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 6
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x04, 0x08, 0x03, 0x88, 0x00, 0x68, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 7
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x03, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0xB8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 8
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x06, 0x88, 0x04, 0x88, 0x04, 0x88, 0x04, 0x88, 0x04, 0xF0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 9
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char :
-        0x02, 0x00, 0x00, 0x20, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ;
-        0x07, 0x00, 0x00, 0x00, 0x01, 0x80, 0x01, 0x80, 0x02, 0x40, 0x02, 0x40, 0x04, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char <
-        0x07, 0x00, 0x00, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char =
-        0x07, 0x00, 0x00, 0x20, 0x04, 0x40, 0x04, 0x40, 0x02, 0x80, 0x02, 0x80, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char >
-        0x06, 0x00, 0x00, 0x30, 0x00, 0x08, 0x00, 0x88, 0x05, 0x88, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ?
-        0x0B, 0x00, 0x00, 0xC0, 0x03, 0x30, 0x04, 0xD0, 0x0F, 0x68, 0x0A, 0x28, 0x0A, 0xA8, 0x09, 0x68, 0x0A, 0x08, 0x0A, 0x10, 0x01, 0xE0, 0x00,  // Code for char @
-        0x08, 0x00, 0x00, 0x00, 0x06, 0xC0, 0x01, 0x30, 0x01, 0x08, 0x01, 0x70, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char A
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0xB8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char B
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x30, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char C
-        0x09, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00,  // Code for char D
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char E
-        0x07, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char F
-        0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x88, 0x04, 0x88, 0x04, 0x90, 0x03, 0x00, 0x00, 0x00, 0x00,  // Code for char G
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char H
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0xF8, 0x07, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char I
-        0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char J
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x40, 0x00, 0xE0, 0x00, 0x10, 0x01, 0x08, 0x06, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char K
-        0x07, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char L
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x38, 0x00, 0xC0, 0x01, 0x00, 0x06, 0x00, 0x07, 0xE0, 0x00, 0x18, 0x00, 0xF8, 0x07, 0x00, 0x00,  // Code for char M
-        0x09, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x18, 0x00, 0x20, 0x00, 0xC0, 0x00, 0x00, 0x01, 0x00, 0x06, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00,  // Code for char N
-        0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00,  // Code for char O
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char P
-        0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x05, 0x08, 0x06, 0xF0, 0x07, 0x00, 0x00, 0x00, 0x00,  // Code for char Q
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x78, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char R
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x78, 0x03, 0x48, 0x04, 0x48, 0x04, 0x88, 0x04, 0x88, 0x04, 0x98, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char S
-        0x07, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x07, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char T
-        0x08, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char U
-        0x08, 0x00, 0x00, 0x18, 0x00, 0x60, 0x00, 0x80, 0x03, 0x00, 0x04, 0x80, 0x03, 0x70, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char V
-        0x0B, 0x00, 0x00, 0x18, 0x00, 0xE0, 0x01, 0x00, 0x06, 0xC0, 0x03, 0x38, 0x00, 0x78, 0x00, 0x80, 0x03, 0x00, 0x06, 0xE0, 0x01, 0x18, 0x00,  // Code for char W
-        0x08, 0x00, 0x00, 0x08, 0x04, 0x18, 0x02, 0xA0, 0x01, 0xC0, 0x00, 0x20, 0x01, 0x18, 0x02, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char X
-        0x08, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x60, 0x00, 0x80, 0x07, 0x60, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Y
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x06, 0x08, 0x05, 0x88, 0x04, 0x48, 0x04, 0x28, 0x04, 0x18, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Z
-        0x03, 0x00, 0x00, 0xF8, 0x07, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char [
-        0x04, 0x18, 0x00, 0xE0, 0x00, 0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char BackSlash
-        0x02, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ]
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ^
-        0x06, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char _
-        0x03, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char `
-        0x06, 0x00, 0x00, 0xA0, 0x07, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char a
-        0x06, 0x00, 0x00, 0xF8, 0x07, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char b
-        0x06, 0x00, 0x00, 0xC0, 0x07, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0x40, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char c
-        0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char d
-        0x06, 0x00, 0x00, 0xE0, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xE0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char e
-        0x04, 0x20, 0x00, 0xF8, 0x07, 0x28, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char f
-        0x06, 0x00, 0x00, 0xC0, 0x13, 0x20, 0x14, 0x20, 0x14, 0x20, 0x14, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char g
-        0x06, 0x00, 0x00, 0xF8, 0x07, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char h
-        0x02, 0x00, 0x00, 0xE8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char i
-        0x02, 0x00, 0x10, 0xE8, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char j
-        0x05, 0x00, 0x00, 0xF8, 0x07, 0x80, 0x01, 0x60, 0x02, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char k
-        0x02, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char l
-        0x08, 0x00, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char m
-        0x06, 0x00, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char n
-        0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char o
-        0x06, 0x00, 0x00, 0xE0, 0x1F, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char p
-        0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x04, 0x20, 0x04, 0x20, 0x04, 0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char q
-        0x05, 0x00, 0x00, 0xE0, 0x07, 0x20, 0x00, 0x20, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char r
-        0x06, 0x00, 0x00, 0xE0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char s
-        0x05, 0x20, 0x00, 0xF0, 0x07, 0x20, 0x04, 0x20, 0x04, 0x20, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char t
-        0x06, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char u
-        0x05, 0x60, 0x00, 0x80, 0x03, 0x00, 0x04, 0x80, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char v
-        0x08, 0xE0, 0x00, 0x00, 0x07, 0x00, 0x07, 0xE0, 0x00, 0xE0, 0x01, 0x00, 0x06, 0x80, 0x07, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char w
-        0x05, 0x20, 0x04, 0x40, 0x03, 0x80, 0x01, 0x60, 0x02, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char x
-        0x05, 0x60, 0x00, 0x80, 0x13, 0x00, 0x0E, 0xC0, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char y
-        0x06, 0x00, 0x00, 0x20, 0x06, 0x20, 0x05, 0xA0, 0x04, 0x60, 0x04, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char z
-        0x05, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x78, 0x1F, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char {
-        0x03, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char |
-        0x05, 0x00, 0x00, 0x08, 0x10, 0x78, 0x1F, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char }
-        0x07, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x40, 0x00, 0x80, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ~
-        0x03, 0xF8, 0x07, 0x08, 0x04, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char €
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‚
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ƒ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char „
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char …
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char †
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‡
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ˆ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‰
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Š
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‹
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Œ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ž
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‘
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ’
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char “
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ”
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char •
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char –
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char —
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ˜
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ™
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char š
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ›
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char œ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ž
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ÿ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
-        0x02, 0x00, 0x00, 0xE8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¡
-        0x06, 0x00, 0x00, 0xC0, 0x03, 0x20, 0x0E, 0xE0, 0x05, 0x30, 0x04, 0x40, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¢
-        0x07, 0x00, 0x00, 0x80, 0x04, 0xF8, 0x07, 0x88, 0x04, 0x88, 0x04, 0x08, 0x04, 0x18, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char £
-        0x06, 0x08, 0x01, 0xF0, 0x00, 0x90, 0x00, 0x90, 0x00, 0xF0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¤
-        0x07, 0xA8, 0x00, 0xB0, 0x00, 0xE0, 0x00, 0x80, 0x07, 0xE0, 0x00, 0xB0, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¥
-        0x03, 0x00, 0x00, 0x00, 0x00, 0x78, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¦
-        0x05, 0xF8, 0x06, 0xA8, 0x04, 0x48, 0x05, 0x58, 0x05, 0xC0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char §
-        0x04, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¨
-        0x09, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0xC8, 0x04, 0x28, 0x05, 0x28, 0x05, 0xC8, 0x04, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char ©
-        0x05, 0x00, 0x00, 0x78, 0x00, 0x58, 0x00, 0x58, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ª
-        0x05, 0x00, 0x00, 0x00, 0x01, 0x80, 0x02, 0x00, 0x01, 0x80, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char «
-        0x07, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¬
-        0x04, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ­
-        0x09, 0x00, 0x00, 0xE0, 0x01, 0x10, 0x02, 0xE8, 0x05, 0xA8, 0x04, 0xA8, 0x05, 0x68, 0x06, 0x10, 0x02, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char ®
-        0x04, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¯
-        0x03, 0x38, 0x00, 0x28, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char °
-        0x08, 0x00, 0x00, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04, 0xF0, 0x05, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ±
-        0x05, 0x00, 0x00, 0xD8, 0x00, 0xC8, 0x00, 0xA8, 0x00, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ²
-        0x05, 0x00, 0x00, 0xD8, 0x00, 0x88, 0x00, 0xA8, 0x00, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ³
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ´
-        0x05, 0xC0, 0x07, 0x20, 0x04, 0x00, 0x04, 0x80, 0x03, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char µ
-        0x06, 0x00, 0x00, 0x78, 0x00, 0xF8, 0x07, 0x08, 0x00, 0xF8, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¶
-        0x02, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ·
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¸
-        0x04, 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¹
-        0x05, 0x00, 0x00, 0x78, 0x00, 0x48, 0x00, 0x48, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char º
-        0x05, 0x00, 0x00, 0x80, 0x02, 0x00, 0x01, 0x80, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char »
-        0x0A, 0x10, 0x00, 0x08, 0x00, 0xF8, 0x00, 0x00, 0x06, 0x80, 0x01, 0x70, 0x00, 0x88, 0x01, 0x80, 0x01, 0xC0, 0x07, 0x00, 0x01, 0x00, 0x00,  // Code for char ¼
-        0x0A, 0x10, 0x00, 0x08, 0x00, 0xF8, 0x00, 0x00, 0x06, 0x80, 0x01, 0x60, 0x00, 0x58, 0x07, 0x48, 0x05, 0x40, 0x05, 0xC0, 0x04, 0x00, 0x00,  // Code for char ½
-        0x0B, 0x00, 0x00, 0xC8, 0x00, 0x88, 0x00, 0x98, 0x04, 0xE8, 0x02, 0x80, 0x01, 0x40, 0x00, 0x30, 0x00, 0x88, 0x01, 0x80, 0x01, 0xC0, 0x07,  // Code for char ¾
-        0x05, 0x80, 0x07, 0x40, 0x04, 0x28, 0x04, 0x00, 0x04, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¿
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x32, 0x01, 0x0C, 0x01, 0x70, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char À
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x30, 0x01, 0x0C, 0x01, 0x72, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Á
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x34, 0x01, 0x0A, 0x01, 0x74, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Â
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x32, 0x01, 0x0A, 0x01, 0x72, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ã
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x32, 0x01, 0x08, 0x01, 0x72, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ä
-        0x07, 0x00, 0x06, 0xC0, 0x01, 0x37, 0x01, 0x0D, 0x01, 0x77, 0x01, 0x80, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Å
-        0x0B, 0x00, 0x03, 0xC0, 0x01, 0x20, 0x01, 0x18, 0x01, 0x08, 0x01, 0xF8, 0x07, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04,  // Code for char Æ
-        0x07, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x08, 0x14, 0x08, 0x1C, 0x08, 0x04, 0x30, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ç
-        0x07, 0x00, 0x00, 0xF8, 0x07, 0x4A, 0x04, 0x4C, 0x04, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char È
-        0x07, 0x00, 0x00, 0xF8, 0x07, 0x48, 0x04, 0x4C, 0x04, 0x4A, 0x04, 0x48, 0x04, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char É
-        0x07, 0x00, 0x00, 0xF8, 0x07, 0x4C, 0x04, 0x4A, 0x04, 0x4C, 0x04, 0x48, 0x04, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ê
-        0x07, 0x00, 0x00, 0xF8, 0x07, 0x4A, 0x04, 0x48, 0x04, 0x4A, 0x04, 0x48, 0x04, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ë
-        0x02, 0x02, 0x00, 0xFC, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ì
-        0x03, 0x00, 0x00, 0xFC, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Í
-        0x03, 0x04, 0x00, 0xFA, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Î
-        0x03, 0x02, 0x00, 0xF8, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ï
-        0x08, 0x40, 0x00, 0xF8, 0x07, 0x48, 0x04, 0x48, 0x04, 0x48, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ð
-        0x08, 0x00, 0x00, 0xF8, 0x07, 0x18, 0x00, 0x22, 0x00, 0xC2, 0x00, 0x02, 0x01, 0x00, 0x06, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ñ
-        0x08, 0x00, 0x00, 0xF0, 0x03, 0x0A, 0x04, 0x0C, 0x04, 0x08, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ò
-        0x08, 0x00, 0x00, 0xF0, 0x03, 0x08, 0x04, 0x0C, 0x04, 0x0A, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ó
-        0x08, 0x00, 0x00, 0xF0, 0x03, 0x0C, 0x04, 0x0A, 0x04, 0x0C, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ô
-        0x08, 0x00, 0x00, 0xF0, 0x03, 0x0A, 0x04, 0x0A, 0x04, 0x0A, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Õ
-        0x08, 0x00, 0x00, 0xF0, 0x03, 0x0A, 0x04, 0x08, 0x04, 0x0A, 0x04, 0x08, 0x04, 0x08, 0x04, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ö
-        0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x04, 0x40, 0x02, 0x80, 0x01, 0x80, 0x01, 0x40, 0x02, 0x20, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ×
-        0x08, 0x00, 0x00, 0xF0, 0x07, 0x08, 0x06, 0x08, 0x05, 0xC8, 0x04, 0x28, 0x04, 0x18, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ø
-        0x07, 0x00, 0x00, 0xF8, 0x03, 0x02, 0x04, 0x04, 0x04, 0x00, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ù
-        0x07, 0x00, 0x00, 0xF8, 0x03, 0x00, 0x04, 0x04, 0x04, 0x02, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ú
-        0x07, 0x00, 0x00, 0xF8, 0x03, 0x04, 0x04, 0x02, 0x04, 0x04, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Û
-        0x07, 0x00, 0x00, 0xF8, 0x03, 0x02, 0x04, 0x00, 0x04, 0x02, 0x04, 0x00, 0x04, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ü
-        0x07, 0x08, 0x00, 0x10, 0x00, 0x60, 0x00, 0x84, 0x07, 0x62, 0x00, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ý
-        0x07, 0x00, 0x00, 0xF8, 0x07, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Þ
-        0x06, 0x00, 0x00, 0xF0, 0x07, 0x08, 0x00, 0x48, 0x04, 0x48, 0x04, 0xB0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ß
-        0x06, 0x00, 0x00, 0xA8, 0x07, 0xB0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char à
-        0x06, 0x00, 0x00, 0xA0, 0x07, 0xB0, 0x04, 0xA8, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char á
-        0x06, 0x00, 0x00, 0xB0, 0x07, 0xA8, 0x04, 0xB0, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char â
-        0x06, 0x00, 0x00, 0xA8, 0x07, 0xA8, 0x04, 0xA8, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ã
-        0x06, 0x00, 0x00, 0xA8, 0x07, 0xA0, 0x04, 0xA8, 0x04, 0xA0, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ä
-        0x06, 0x00, 0x00, 0xA0, 0x07, 0xAE, 0x04, 0xAA, 0x04, 0xAE, 0x04, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char å
-        0x0A, 0x00, 0x00, 0xA0, 0x07, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xC0, 0x03, 0xA0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xE0, 0x02, 0x00, 0x00,  // Code for char æ
-        0x06, 0x00, 0x00, 0xC0, 0x07, 0x20, 0x14, 0x20, 0x1C, 0x20, 0x04, 0x40, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ç
-        0x06, 0x00, 0x00, 0xE8, 0x03, 0xB0, 0x04, 0xA0, 0x04, 0xA0, 0x04, 0xE0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00   // Code for char è
-        };
-
-const struct GDS_FontDef Font_line_1 = {
-    Square721_BT11x14,
-    11,
-    14,
-    ' ',
-    '\xFF',
-    false
-};

components/display/fonts/font_line_2.c

@@ -1,247 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011 
-//http://www.mikroe.com 
-
-//GLCD FontName : Archivo_Narrow18x24
-//GLCD FontSize : 18 x 24
-
-static const uint8_t Archivo_Narrow18x24[] = {
-        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x1F, 0x0E, 0xF0, 0xFF, 0x0E, 0xF0, 0x1F, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char !
-        0x08, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char "
-        0x0A, 0x00, 0xC0, 0x08, 0x00, 0xC3, 0x0F, 0x00, 0xFF, 0x0F, 0xC0, 0xFF, 0x00, 0xF0, 0xC3, 0x0C, 0x30, 0xC3, 0x0F, 0x00, 0xFF, 0x03, 0xF0, 0xFF, 0x00, 0xF0, 0xC3, 0x00, 0x10, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char #
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x87, 0x01, 0x80, 0x8F, 0x03, 0xC0, 0x9F, 0x03, 0xC0, 0x1D, 0x07, 0xF8, 0xFF, 0x1F, 0xC0, 0x39, 0x07, 0xC0, 0xF3, 0x03, 0x80, 0xF3, 0x03, 0x00, 0xE3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char $
-        0x10, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0xE0, 0x07, 0x00, 0x30, 0x0C, 0x08, 0x30, 0x0C, 0x0E, 0xE0, 0x87, 0x03, 0xC0, 0xC3, 0x01, 0x00, 0x70, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0E, 0x00, 0x80, 0xC3, 0x03, 0xC0, 0xE1, 0x07, 0x70, 0x30, 0x0C, 0x10, 0x30, 0x0C, 0x00, 0xE0, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char %
-        0x0E, 0x00, 0x00, 0x00, 0x80, 0xE1, 0x01, 0xE0, 0xF7, 0x03, 0xE0, 0xFF, 0x07, 0x70, 0x3E, 0x0F, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0xFD, 0x07, 0xE0, 0xFD, 0x03, 0x80, 0xFD, 0x01, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char &
-        0x04, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char '
-        0x06, 0x00, 0xFC, 0x01, 0x80, 0xFF, 0x0F, 0xE0, 0xFF, 0x3F, 0xF0, 0x01, 0x7C, 0x38, 0x00, 0xE0, 0x08, 0x00, 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,  // Code for char (
-        0x06, 0x08, 0x00, 0x80, 0x38, 0x00, 0xE0, 0xF0, 0x01, 0x7C, 0xE0, 0xFF, 0x3F, 0x80, 0xFF, 0x0F, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char )
-        0x08, 0x40, 0x02, 0x00, 0x60, 0x06, 0x00, 0xC0, 0x03, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xC0, 0x03, 0x00, 0x60, 0x06, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char *
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char +
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ,
-        0x06, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char -
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
-        0x05, 0x00, 0x00, 0x1C, 0x00, 0xE0, 0x1F, 0x80, 0xFF, 0x01, 0xF8, 0x0F, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char /
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0xFF, 0x03, 0xE0, 0xFF, 0x07, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0xFF, 0x07, 0xC0, 0xFF, 0x03, 0x00, 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,  // Code for char 0
-        0x0A, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x0E, 0xC0, 0x00, 0x0E, 0xE0, 0x00, 0x0E, 0xE0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 1
-        0x0A, 0x00, 0x00, 0x00, 0x80, 0x03, 0x0E, 0xE0, 0x83, 0x0F, 0xE0, 0xC3, 0x0F, 0x70, 0xE0, 0x0F, 0x70, 0xF0, 0x0E, 0x70, 0x7C, 0x0E, 0xE0, 0x3F, 0x0E, 0xE0, 0x0F, 0x0E, 0xC0, 0x03, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 2
-        0x0A, 0x00, 0x00, 0x00, 0x80, 0x81, 0x01, 0xE0, 0x81, 0x07, 0xE0, 0x81, 0x07, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0xE0, 0xFF, 0x07, 0xE0, 0xF7, 0x07, 0xC0, 0xC3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 3
-        0x0A, 0x00, 0xC0, 0x01, 0x00, 0xF0, 0x01, 0x00, 0xFC, 0x01, 0x80, 0xDF, 0x01, 0xF0, 0xC7, 0x01, 0xF0, 0xC1, 0x01, 0x30, 0xFC, 0x0F, 0x80, 0xFF, 0x0F, 0xC0, 0xFF, 0x0F, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 4
-        0x0A, 0x00, 0x00, 0x00, 0xF0, 0x9F, 0x01, 0xF0, 0x9F, 0x03, 0xF0, 0x9F, 0x07, 0x70, 0x0C, 0x0E, 0x70, 0x0E, 0x0E, 0x70, 0x0E, 0x0F, 0x70, 0xFE, 0x07, 0x70, 0xFC, 0x03, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 5
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0xFF, 0x03, 0xE0, 0xFF, 0x07, 0x70, 0x18, 0x0E, 0x70, 0x1C, 0x0E, 0xE0, 0x1D, 0x0E, 0xE0, 0xF9, 0x07, 0x80, 0xF9, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 6
-        0x0A, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x0F, 0x70, 0xE0, 0x0F, 0x70, 0xFC, 0x0F, 0x70, 0x7F, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 7
-        0x0A, 0x00, 0x00, 0x00, 0x80, 0xE3, 0x01, 0xE0, 0xF7, 0x07, 0xE0, 0xFF, 0x07, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0xE0, 0xFF, 0x07, 0xE0, 0xF7, 0x07, 0x80, 0xE3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 8
-        0x0A, 0x00, 0x00, 0x00, 0x80, 0x8F, 0x01, 0xE0, 0xBF, 0x07, 0xE0, 0xBF, 0x07, 0x70, 0x70, 0x0E, 0x70, 0x70, 0x0E, 0xF0, 0x38, 0x0E, 0xE0, 0xFF, 0x07, 0xC0, 0xFF, 0x03, 0x00, 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,  // Code for char 9
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char :
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x07, 0x4E, 0x00, 0x07, 0x7E, 0x00, 0x07, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ;
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x98, 0x01, 0x00, 0x9C, 0x03, 0x00, 0x0C, 0x03, 0x00, 0x0E, 0x07, 0x00, 0x06, 0x06, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char <
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char =
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0E, 0x00, 0x06, 0x06, 0x00, 0x0E, 0x07, 0x00, 0x0C, 0x03, 0x00, 0x9C, 0x03, 0x00, 0x98, 0x01, 0x00, 0xF8, 0x01, 0x00, 0xF0, 0x00, 0x00, 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,  // Code for char >
-        0x0A, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0xE0, 0x03, 0x00, 0xE0, 0x03, 0x00, 0x70, 0x00, 0x00, 0x70, 0xE0, 0x0E, 0x70, 0xF8, 0x0E, 0xE0, 0xFF, 0x0E, 0xE0, 0x1F, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ?
-        0x12, 0x00, 0xF8, 0x00, 0x00, 0xFF, 0x07, 0x80, 0x03, 0x1C, 0xC0, 0x00, 0x30, 0x60, 0x00, 0x60, 0x60, 0xC0, 0x63, 0x20, 0xE4, 0x47, 0x30, 0xE6, 0xC7, 0x30, 0x37, 0xC6, 0x30, 0x33, 0xC6, 0x30, 0xFF, 0xC3, 0x30, 0xFE, 0x67, 0x60, 0xFC, 0x07, 0x60, 0x00, 0x06, 0xC0, 0x00, 0x06, 0xC0, 0x01, 0x03, 0x00, 0xFF, 0x01, 0x00, 0x7C, 0x00,  // Code for char @
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x03, 0x80, 0xFF, 0x01, 0xF0, 0xCF, 0x01, 0xF0, 0xC1, 0x01, 0xF0, 0xC1, 0x01, 0xF0, 0xCF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char A
-        0x0D, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0xF0, 0x3F, 0x0F, 0xE0, 0xF7, 0x07, 0xC0, 0xF1, 0x07, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char B
-        0x0D, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x07, 0xE0, 0x81, 0x07, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0x00, 0x07, 0xE0, 0xC3, 0x07, 0xC0, 0xC3, 0x03, 0x00, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char C
-        0x0D, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char D
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char E
-        0x0A, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char F
-        0x0D, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x03, 0xC0, 0xFF, 0x07, 0xE0, 0x00, 0x07, 0x60, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x38, 0x0E, 0x70, 0x38, 0x06, 0xE0, 0x38, 0x07, 0xE0, 0xFB, 0x03, 0xC0, 0xFB, 0x0F, 0x00, 0xFB, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char G
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char H
-        0x04, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char I
-        0x09, 0x00, 0x80, 0x03, 0x00, 0x80, 0x07, 0x00, 0x80, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char J
-        0x0D, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x78, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x1F, 0x00, 0x80, 0x7F, 0x00, 0xC0, 0xFB, 0x01, 0xF0, 0xE1, 0x07, 0x70, 0x80, 0x0F, 0x30, 0x00, 0x0E, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char K
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char L
-        0x0F, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0x03, 0x00, 0xF0, 0x3F, 0x00, 0x00, 0xFF, 0x07, 0x00, 0xF0, 0x0F, 0x00, 0x80, 0x0F, 0x00, 0xFC, 0x07, 0xC0, 0x3F, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char M
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xE0, 0x07, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x7E, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xE0, 0x07, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char N
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE0, 0x81, 0x07, 0xE0, 0x00, 0x06, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char O
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x3C, 0x00, 0xE0, 0x1F, 0x00, 0xE0, 0x1F, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char P
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE0, 0x81, 0x07, 0xE0, 0x00, 0x06, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x1E, 0xE0, 0x00, 0x3F, 0xE0, 0x81, 0x3F, 0xC0, 0xFF, 0x33, 0x80, 0xFF, 0x21, 0x00, 0x7E, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Q
-        0x0D, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0x38, 0x00, 0x70, 0xF8, 0x00, 0x70, 0xF8, 0x03, 0xE0, 0xFF, 0x0F, 0xE0, 0x8F, 0x0F, 0x80, 0x07, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char R
-        0x0C, 0x00, 0x00, 0x00, 0x80, 0x83, 0x01, 0xE0, 0x8F, 0x03, 0xE0, 0x8F, 0x07, 0x70, 0x0E, 0x0F, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x38, 0x0E, 0xE0, 0x39, 0x0E, 0xE0, 0xF1, 0x07, 0x80, 0xF1, 0x07, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char S
-        0x0B, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char T
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0F, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char U
-        0x0D, 0x10, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0xFF, 0x03, 0x00, 0xF0, 0x0F, 0x00, 0x80, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xFE, 0x03, 0xC0, 0x7F, 0x00, 0xF0, 0x0F, 0x00, 0xF0, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char V
-        0x12, 0x30, 0x00, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x7F, 0x00, 0xC0, 0xFF, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0x80, 0x0F, 0x00, 0xFE, 0x0F, 0xF0, 0x7F, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x7F, 0x00, 0x80, 0xFF, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFF, 0x0F, 0xF0, 0x7F, 0x00, 0xF0, 0x03, 0x00, 0x30, 0x00, 0x00,  // Code for char W
-        0x0D, 0x00, 0x00, 0x08, 0x30, 0x00, 0x0E, 0xF0, 0x00, 0x0F, 0xF0, 0xC1, 0x07, 0xE0, 0xF7, 0x03, 0x80, 0xFF, 0x00, 0x00, 0x3E, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0xF7, 0x03, 0xF0, 0xC1, 0x0F, 0xF0, 0x00, 0x0F, 0x30, 0x00, 0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char X
-        0x0D, 0x10, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x07, 0x00, 0x80, 0x1F, 0x00, 0x00, 0xFE, 0x0F, 0x00, 0xF8, 0x0F, 0x00, 0xFE, 0x0F, 0x80, 0x1F, 0x00, 0xE0, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x30, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Y
-        0x0B, 0x00, 0x00, 0x0C, 0x70, 0x00, 0x0F, 0x70, 0xC0, 0x0F, 0x70, 0xE0, 0x0F, 0x70, 0xF8, 0x0F, 0x70, 0x7E, 0x0E, 0xF0, 0x1F, 0x0E, 0xF0, 0x07, 0x0E, 0xF0, 0x01, 0x0E, 0x70, 0x00, 0x0E, 0x30, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Z
-        0x06, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0x18, 0x00, 0xC0, 0x18, 0x00, 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,  // Code for char [
-        0x05, 0x38, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x80, 0xFF, 0x01, 0x00, 0xE0, 0x1F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char BackSlash
-        0x05, 0x18, 0x00, 0xC0, 0x18, 0x00, 0xC0, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 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,  // Code for char ]
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x1C, 0x00, 0x80, 0x1F, 0x00, 0xE0, 0x07, 0x00, 0xF0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x80, 0x1F, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ^
-        0x0A, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char _
-        0x05, 0x08, 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char `
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x00, 0xCE, 0x0F, 0x00, 0x6F, 0x0E, 0x00, 0x67, 0x06, 0x00, 0x67, 0x06, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char a
-        0x0B, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x00, 0x06, 0x06, 0x00, 0x06, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x0F, 0x0E, 0x00, 0xFE, 0x07, 0x00, 0xFE, 0x07, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char b
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFE, 0x07, 0x00, 0xFE, 0x07, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x9E, 0x07, 0x00, 0x9E, 0x07, 0x00, 0x98, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char c
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFE, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x06, 0x06, 0xF8, 0xFF, 0x07, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char d
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x7E, 0x07, 0x00, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char e
-        0x06, 0x00, 0x07, 0x00, 0xE0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x38, 0x07, 0x00, 0x38, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char f
-        0x0B, 0x00, 0x00, 0x18, 0x00, 0x9E, 0x3D, 0x00, 0xFF, 0x3F, 0x80, 0xFF, 0x33, 0x80, 0xB1, 0x33, 0x80, 0xB1, 0x33, 0x80, 0xB1, 0x33, 0x80, 0x3F, 0x33, 0x80, 0x3F, 0x3F, 0xC0, 0x1E, 0x1E, 0x40, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char g
-        0x0A, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char h
-        0x04, 0x00, 0x00, 0x00, 0x38, 0xFF, 0x0F, 0x38, 0xFF, 0x0F, 0x38, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char i
-        0x04, 0x00, 0x00, 0x38, 0x38, 0xFF, 0x3F, 0x38, 0xFF, 0x3F, 0x38, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char j
-        0x0A, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x00, 0x70, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xFE, 0x03, 0x00, 0x8F, 0x0F, 0x00, 0x03, 0x0F, 0x00, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char k
-        0x04, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0xF8, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char l
-        0x10, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char m
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char n
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x07, 0x0F, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0F, 0x00, 0xFE, 0x07, 0x00, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char o
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0x00, 0xFF, 0x3F, 0x00, 0xFE, 0x3F, 0x00, 0x06, 0x07, 0x00, 0x06, 0x07, 0x00, 0x07, 0x07, 0x00, 0x0F, 0x03, 0x00, 0xFE, 0x03, 0x00, 0xFE, 0x01, 0x00, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char p
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFE, 0x03, 0x00, 0xFF, 0x07, 0x00, 0x07, 0x07, 0x00, 0x07, 0x07, 0x00, 0x06, 0x07, 0x00, 0xFF, 0x3F, 0x00, 0xFF, 0x3F, 0x00, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char q
-        0x07, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0x0E, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char r
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x3E, 0x07, 0x00, 0x3F, 0x07, 0x00, 0x77, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x6F, 0x0E, 0x00, 0xEE, 0x07, 0x00, 0xCC, 0x07, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char s
-        0x06, 0x00, 0x07, 0x00, 0xE0, 0xFF, 0x03, 0xE0, 0xFF, 0x07, 0xE0, 0xFF, 0x0F, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char t
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char u
-        0x0A, 0x00, 0x03, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFC, 0x07, 0x00, 0xC0, 0x0F, 0x00, 0x80, 0x0F, 0x00, 0xF8, 0x07, 0x00, 0xFF, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char v
-        0x0F, 0x00, 0x01, 0x00, 0x00, 0x1F, 0x00, 0x00, 0xFF, 0x01, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0xF0, 0x0F, 0x00, 0xFF, 0x01, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x01, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0xF0, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char w
-        0x0A, 0x00, 0x01, 0x08, 0x00, 0x03, 0x0E, 0x00, 0x8F, 0x0F, 0x00, 0xFF, 0x07, 0x00, 0xFC, 0x01, 0x00, 0xF8, 0x01, 0x00, 0xFE, 0x07, 0x00, 0x8F, 0x0F, 0x00, 0x03, 0x0E, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char x
-        0x0A, 0x00, 0x01, 0x00, 0x00, 0x0F, 0xE0, 0x00, 0x7F, 0xE0, 0x00, 0xFC, 0xF3, 0x00, 0xE0, 0x7F, 0x00, 0x80, 0x3F, 0x00, 0xF8, 0x07, 0x00, 0xFF, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char y
-        0x09, 0x00, 0x07, 0x0C, 0x00, 0x07, 0x0F, 0x00, 0x87, 0x0F, 0x00, 0xE7, 0x0F, 0x00, 0xFF, 0x0E, 0x00, 0x7F, 0x0E, 0x00, 0x1F, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x03, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char z
-        0x07, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0xE0, 0xFF, 0x3F, 0xF0, 0xDF, 0x7F, 0xF8, 0x87, 0xFF, 0x18, 0x00, 0xC0, 0x18, 0x00, 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,  // Code for char {
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xF8, 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,  // Code for char |
-        0x07, 0x0C, 0x00, 0x60, 0x0C, 0x00, 0x60, 0xFC, 0xC3, 0x7F, 0xF8, 0xFF, 0x3F, 0xF0, 0xFF, 0x1F, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char }
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x30, 0x00, 0x00, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x30, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ~
-        0x06, 0xE0, 0xFF, 0x07, 0xE0, 0xFF, 0x07, 0x20, 0x00, 0x04, 0x20, 0x00, 0x04, 0xE0, 0xFF, 0x07, 0xE0, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char €
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‚
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ƒ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char „
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char …
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char †
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‡
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ˆ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‰
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Š
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‹
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Œ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ž
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ‘
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ’
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char “
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ”
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char •
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char –
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char —
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ˜
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ™
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char š
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ›
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char œ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ž
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ÿ
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC3, 0x3F, 0x80, 0xFB, 0x3F, 0x80, 0xC3, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¡
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xC0, 0x81, 0x03, 0xF8, 0xFF, 0x1F, 0xC0, 0x80, 0x03, 0xC0, 0xE3, 0x03, 0x80, 0xE3, 0x01, 0x00, 0xE3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¢
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x38, 0x0E, 0x80, 0xFF, 0x0F, 0xE0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x38, 0x0E, 0x70, 0x38, 0x0E, 0xF0, 0x01, 0x0E, 0xE0, 0x01, 0x0E, 0x80, 0x01, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char £
-        0x0A, 0x80, 0xBD, 0x01, 0x00, 0xFF, 0x00, 0x00, 0xC3, 0x00, 0x80, 0x81, 0x01, 0x80, 0x81, 0x01, 0x80, 0x81, 0x01, 0x80, 0x81, 0x01, 0x00, 0xC3, 0x00, 0x00, 0xFF, 0x00, 0x80, 0xBD, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¤
-        0x0B, 0x10, 0x00, 0x00, 0x70, 0x98, 0x01, 0xF0, 0x99, 0x01, 0xF0, 0x9F, 0x01, 0x80, 0xFF, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0xFF, 0x0F, 0xE0, 0x9F, 0x01, 0xF0, 0x99, 0x01, 0x70, 0x98, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¥
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x8F, 0x3F, 0xF0, 0x8F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¦
-        0x0A, 0x00, 0x00, 0x00, 0xE0, 0x39, 0x18, 0xE0, 0x7F, 0x38, 0xF0, 0xFF, 0x38, 0x30, 0xC7, 0x31, 0x30, 0xCE, 0x31, 0x30, 0x8E, 0x33, 0x70, 0xFC, 0x3F, 0x70, 0xF8, 0x3F, 0x60, 0x70, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char §
-        0x06, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¨
-        0x0D, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0x00, 0x03, 0x20, 0x7E, 0x04, 0x10, 0xFF, 0x08, 0x90, 0x81, 0x09, 0x90, 0x81, 0x09, 0x90, 0x81, 0x09, 0x10, 0xE7, 0x08, 0x20, 0x66, 0x04, 0x40, 0x00, 0x02, 0x80, 0x81, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ©
-        0x07, 0x00, 0x07, 0x00, 0xB0, 0x0F, 0x00, 0xB8, 0x0C, 0x00, 0x98, 0x04, 0x00, 0xF8, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ª
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x7C, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xC7, 0x01, 0x00, 0x11, 0x01, 0x00, 0x7C, 0x00, 0x00, 0xFE, 0x01, 0x00, 0xC7, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char «
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¬
-        0x06, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ­
-        0x0D, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xC0, 0x80, 0x03, 0x60, 0x00, 0x06, 0xA0, 0xFF, 0x05, 0x90, 0xFF, 0x09, 0x90, 0x19, 0x08, 0x90, 0x19, 0x08, 0x90, 0xFF, 0x08, 0x20, 0xE7, 0x05, 0x60, 0x00, 0x07, 0xC0, 0x81, 0x03, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ®
-        0x06, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¯
-        0x08, 0x00, 0x00, 0x00, 0xC0, 0x01, 0x00, 0xE0, 0x03, 0x00, 0x30, 0x06, 0x00, 0x30, 0x06, 0x00, 0x30, 0x06, 0x00, 0xE0, 0x03, 0x00, 0xC0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char °
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x0E, 0x00, 0x1C, 0x0E, 0x00, 0x1C, 0x0E, 0xC0, 0xFF, 0x0E, 0xC0, 0xFF, 0x0E, 0x00, 0x1C, 0x0E, 0x00, 0x1C, 0x0E, 0x00, 0x1C, 0x0E, 0x00, 0x1C, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ±
-        0x06, 0x70, 0x18, 0x00, 0x70, 0x1E, 0x00, 0x18, 0x1F, 0x00, 0x98, 0x1B, 0x00, 0xF0, 0x19, 0x00, 0x70, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ²
-        0x06, 0x30, 0x0C, 0x00, 0x30, 0x0C, 0x00, 0x98, 0x19, 0x00, 0x98, 0x19, 0x00, 0xF0, 0x0F, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ³
-        0x06, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x30, 0x00, 0x00, 0x38, 0x00, 0x00, 0x18, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ´
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x06, 0x00, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char µ
-        0x0A, 0x80, 0x07, 0x00, 0xC0, 0x1F, 0x00, 0xE0, 0x3F, 0x00, 0xF0, 0x3F, 0x00, 0xF0, 0xFF, 0x3F, 0xF0, 0xFF, 0x3F, 0x30, 0x00, 0x00, 0xF0, 0xFF, 0x3F, 0xF0, 0xFF, 0x3F, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¶
-        0x04, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ·
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x16, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¸
-        0x05, 0x20, 0x18, 0x00, 0x20, 0x18, 0x00, 0xF0, 0x1F, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¹
-        0x07, 0xE0, 0x03, 0x00, 0xF0, 0x07, 0x00, 0x18, 0x0C, 0x00, 0x18, 0x0C, 0x00, 0x18, 0x0C, 0x00, 0xF0, 0x07, 0x00, 0xE0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char º
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xC7, 0x01, 0x00, 0xFE, 0x01, 0x00, 0x7C, 0x00, 0x00, 0x11, 0x01, 0x00, 0xC7, 0x01, 0x00, 0xFE, 0x00, 0x00, 0x7C, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char »
-        0x0F, 0x60, 0x30, 0x00, 0x60, 0x30, 0x00, 0xF0, 0x3F, 0x00, 0xF0, 0x3F, 0x0C, 0x00, 0x30, 0x06, 0x00, 0x80, 0x03, 0x00, 0xE0, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x87, 0x03, 0xC0, 0xE1, 0x03, 0x60, 0x78, 0x03, 0x10, 0x88, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¼
-        0x0F, 0x60, 0x30, 0x00, 0x60, 0x30, 0x00, 0xF0, 0x3F, 0x08, 0xF0, 0x3F, 0x0C, 0x00, 0x30, 0x06, 0x00, 0xB0, 0x01, 0x00, 0xE0, 0x00, 0x00, 0x30, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x07, 0x00, 0x80, 0x39, 0x0C, 0x60, 0x3C, 0x0F, 0x10, 0x8C, 0x0F, 0x00, 0xFC, 0x0C, 0x00, 0x38, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ½
-        0x0F, 0x00, 0x00, 0x00, 0x40, 0x08, 0x00, 0x70, 0x38, 0x00, 0x30, 0x33, 0x08, 0xE0, 0x3F, 0x0E, 0xC0, 0x1C, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x30, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x87, 0x03, 0xC0, 0xE1, 0x03, 0x60, 0x78, 0x03, 0x30, 0x88, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¾
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0xC0, 0x1F, 0x00, 0xE0, 0x3F, 0xC0, 0x7D, 0x38, 0xC0, 0x3D, 0x38, 0xC0, 0x1D, 0x38, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ¿
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x03, 0x80, 0xFF, 0x01, 0xF2, 0xCF, 0x01, 0xF6, 0xC1, 0x01, 0xF6, 0xC1, 0x01, 0xF4, 0xCF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char À
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x03, 0x80, 0xFF, 0x01, 0xF4, 0xCF, 0x01, 0xF6, 0xC1, 0x01, 0xF6, 0xC1, 0x01, 0xF2, 0xCF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Á
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x03, 0x84, 0xFF, 0x01, 0xF6, 0xCF, 0x01, 0xF2, 0xC1, 0x01, 0xF2, 0xC1, 0x01, 0xF6, 0xCF, 0x01, 0x84, 0xFF, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Â
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x04, 0xFC, 0x03, 0x86, 0xFF, 0x01, 0xF2, 0xCF, 0x01, 0xF2, 0xC1, 0x01, 0xF6, 0xC1, 0x01, 0xF6, 0xCF, 0x01, 0x82, 0xFF, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ã
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x07, 0x86, 0xFF, 0x01, 0xF6, 0xCF, 0x01, 0xF0, 0xC0, 0x01, 0xF0, 0xC1, 0x01, 0xF6, 0xCF, 0x01, 0x86, 0xFF, 0x01, 0x00, 0xFC, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ä
-        0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0E, 0x00, 0xE0, 0x0F, 0x00, 0xFC, 0x07, 0x80, 0xFF, 0x01, 0xE6, 0xCF, 0x01, 0xE9, 0xC1, 0x01, 0xE9, 0xC1, 0x01, 0xE6, 0xDF, 0x01, 0x80, 0xFF, 0x01, 0x00, 0xFC, 0x0F, 0x00, 0xC0, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Å
-        0x12, 0x00, 0x00, 0x08, 0x00, 0x00, 0x0F, 0x00, 0xE0, 0x0F, 0x00, 0xF8, 0x03, 0x00, 0xFF, 0x01, 0xC0, 0xCF, 0x01, 0xF0, 0xC3, 0x01, 0xF0, 0xC0, 0x01, 0xF0, 0xCF, 0x01, 0xF0, 0xFF, 0x01, 0x70, 0xFF, 0x0F, 0x70, 0xFC, 0x0F, 0x70, 0x1C, 0x0F, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E,  // Code for char Æ
-        0x0D, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0xE0, 0xFF, 0x00, 0xF0, 0xFF, 0x01, 0x78, 0xC0, 0x01, 0x18, 0x80, 0x23, 0x1C, 0x80, 0x2F, 0x1C, 0x00, 0x3F, 0x1C, 0x80, 0x13, 0x38, 0xC0, 0x03, 0xF8, 0xF0, 0x01, 0xF0, 0xF0, 0x00, 0xC0, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ç
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x72, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x74, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char È
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x74, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x72, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char É
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF4, 0xFF, 0x0F, 0x76, 0x1C, 0x0E, 0x72, 0x1C, 0x0E, 0x72, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x74, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ê
-        0x0B, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF6, 0xFF, 0x0F, 0x76, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x76, 0x1C, 0x0E, 0x70, 0x1C, 0x0E, 0x70, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ë
-        0x04, 0x00, 0x00, 0x00, 0xF2, 0xFF, 0x0F, 0xF6, 0xFF, 0x0F, 0xF4, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ì
-        0x04, 0x00, 0x00, 0x00, 0xF4, 0xFF, 0x0F, 0xF6, 0xFF, 0x0F, 0xF2, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Í
-        0x06, 0x04, 0x00, 0x00, 0xF6, 0xFF, 0x0F, 0xF2, 0xFF, 0x0F, 0xF6, 0xFF, 0x0F, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Î
-        0x06, 0x06, 0x00, 0x00, 0xE6, 0xFF, 0x0F, 0xE0, 0xFF, 0x0F, 0xE0, 0xFF, 0x0F, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ï
-        0x0D, 0x00, 0x18, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x70, 0x18, 0x0E, 0x70, 0x18, 0x0E, 0x70, 0x18, 0x0E, 0x70, 0x00, 0x0E, 0xE0, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ð
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF4, 0xFF, 0x0F, 0xF6, 0xFF, 0x0F, 0xE2, 0x07, 0x00, 0x82, 0x1F, 0x00, 0x02, 0x7E, 0x00, 0x06, 0xF8, 0x01, 0x04, 0xE0, 0x07, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ñ
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE0, 0x81, 0x07, 0xE2, 0x00, 0x06, 0x76, 0x00, 0x0E, 0x76, 0x00, 0x0E, 0x74, 0x00, 0x0E, 0xE0, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ò
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE0, 0x81, 0x07, 0xE0, 0x00, 0x06, 0x74, 0x00, 0x0E, 0x76, 0x00, 0x0E, 0x76, 0x00, 0x0E, 0xE2, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ó
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE4, 0x81, 0x07, 0xE6, 0x00, 0x06, 0x76, 0x00, 0x0E, 0x72, 0x00, 0x0E, 0x76, 0x00, 0x0E, 0xE6, 0x00, 0x07, 0xE4, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ô
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE4, 0x81, 0x07, 0xE2, 0x00, 0x06, 0x72, 0x00, 0x0E, 0x72, 0x00, 0x0E, 0x72, 0x00, 0x0E, 0xE6, 0x00, 0x07, 0xE2, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Õ
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x80, 0xFF, 0x01, 0xC0, 0xFF, 0x03, 0xE6, 0x81, 0x07, 0xE6, 0x00, 0x06, 0x70, 0x00, 0x0E, 0x70, 0x00, 0x0E, 0x76, 0x00, 0x0E, 0xE6, 0x00, 0x07, 0xE0, 0x81, 0x07, 0xC0, 0xFF, 0x03, 0x80, 0xFF, 0x01, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ö
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x0E, 0x07, 0x00, 0x9C, 0x03, 0x00, 0xF8, 0x01, 0x00, 0xF0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF8, 0x01, 0x00, 0x9C, 0x03, 0x00, 0x0E, 0x07, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ×
-        0x0E, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x10, 0x80, 0xFF, 0x0D, 0xC0, 0xFF, 0x0F, 0xE0, 0x81, 0x07, 0xE0, 0xE0, 0x0E, 0x70, 0x70, 0x0E, 0x70, 0x18, 0x0E, 0x70, 0x0E, 0x0E, 0x70, 0x07, 0x07, 0xE0, 0x81, 0x07, 0xF0, 0xFF, 0x03, 0xB8, 0xFF, 0x01, 0x08, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ø
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x07, 0x02, 0x00, 0x0F, 0x06, 0x00, 0x0E, 0x06, 0x00, 0x0E, 0x04, 0x00, 0x0E, 0x00, 0x00, 0x0F, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ù
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x07, 0x00, 0x00, 0x0F, 0x04, 0x00, 0x0E, 0x06, 0x00, 0x0E, 0x06, 0x00, 0x0E, 0x02, 0x00, 0x0F, 0xF0, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ú
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF0, 0xFF, 0x03, 0xF4, 0xFF, 0x07, 0x04, 0x00, 0x0F, 0x06, 0x00, 0x0E, 0x02, 0x00, 0x0E, 0x06, 0x00, 0x0E, 0x04, 0x00, 0x0F, 0xF4, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Û
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x01, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x07, 0x06, 0x00, 0x0F, 0x06, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x0E, 0x06, 0x00, 0x0F, 0xF6, 0xFF, 0x07, 0xF0, 0xFF, 0x03, 0xF0, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ü
-        0x0D, 0x10, 0x00, 0x00, 0x70, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xF0, 0x07, 0x00, 0x80, 0x1F, 0x00, 0x04, 0xFE, 0x0F, 0x06, 0xF8, 0x0F, 0x02, 0xFE, 0x0F, 0x80, 0x1F, 0x00, 0xE0, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x30, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Ý
-        0x0C, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x80, 0xC3, 0x01, 0x80, 0xC3, 0x01, 0x80, 0xC3, 0x01, 0x80, 0xC3, 0x01, 0x80, 0xE3, 0x01, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char Þ
-        0x0B, 0x00, 0x00, 0x00, 0xC0, 0xFF, 0x0F, 0xE0, 0xFF, 0x0F, 0xF0, 0xFF, 0x0F, 0x38, 0x00, 0x00, 0x38, 0x1C, 0x0E, 0x38, 0x1C, 0x0E, 0x38, 0x1E, 0x0E, 0xF0, 0xFF, 0x07, 0xF0, 0xF3, 0x03, 0xC0, 0xE1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ß
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x08, 0xCE, 0x0F, 0x18, 0x6F, 0x0E, 0x38, 0x67, 0x06, 0x20, 0x67, 0x06, 0x00, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char à
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x00, 0xCE, 0x0F, 0x20, 0x6F, 0x0E, 0x30, 0x67, 0x06, 0x38, 0x67, 0x06, 0x18, 0xFF, 0x03, 0x08, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char á
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x20, 0xCE, 0x0F, 0x38, 0x6F, 0x0E, 0x18, 0x67, 0x06, 0x38, 0x67, 0x06, 0x30, 0xFF, 0x03, 0x20, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char â
-        0x0A, 0x00, 0x80, 0x03, 0x30, 0xCC, 0x07, 0x38, 0xCE, 0x0F, 0x18, 0x6F, 0x0E, 0x10, 0x67, 0x06, 0x30, 0x67, 0x06, 0x30, 0xFF, 0x03, 0x38, 0xFE, 0x07, 0x08, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ã
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x38, 0xCE, 0x0F, 0x38, 0x6F, 0x0E, 0x00, 0x67, 0x06, 0x00, 0x67, 0x06, 0x38, 0xFF, 0x03, 0x38, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ä
-        0x0A, 0x00, 0x80, 0x03, 0x00, 0xCC, 0x07, 0x00, 0xCE, 0x0F, 0x30, 0x6F, 0x0E, 0x48, 0x67, 0x06, 0x48, 0x67, 0x06, 0x30, 0xFF, 0x03, 0x00, 0xFE, 0x07, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char å
-        0x10, 0x00, 0x00, 0x00, 0x00, 0x8C, 0x03, 0x00, 0xCE, 0x07, 0x00, 0xCE, 0x0F, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x06, 0x00, 0xFE, 0x07, 0x00, 0xFE, 0x03, 0x00, 0xFE, 0x07, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x00, 0x7E, 0x07, 0x00, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char æ
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x8F, 0x00, 0x07, 0xBE, 0x00, 0x07, 0xBC, 0x00, 0x07, 0xEC, 0x00, 0x1E, 0x4F, 0x00, 0x1E, 0x07, 0x00, 0x18, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ç
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x08, 0xFC, 0x03, 0x08, 0xFE, 0x07, 0x18, 0x67, 0x0E, 0x30, 0x67, 0x0E, 0x20, 0x67, 0x0E, 0x00, 0x7E, 0x07, 0x00, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char è
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x00, 0xFE, 0x07, 0x20, 0x67, 0x0E, 0x30, 0x67, 0x0E, 0x38, 0x67, 0x0E, 0x08, 0x7E, 0x07, 0x08, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char é
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x30, 0xFE, 0x07, 0x38, 0x67, 0x0E, 0x18, 0x67, 0x0E, 0x38, 0x67, 0x0E, 0x30, 0x7E, 0x07, 0x20, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ê
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x38, 0xFC, 0x03, 0x38, 0xFE, 0x07, 0x00, 0x67, 0x0E, 0x00, 0x67, 0x0E, 0x38, 0x67, 0x0E, 0x38, 0x7E, 0x07, 0x00, 0x7C, 0x07, 0x00, 0x78, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ë
-        0x04, 0x08, 0x00, 0x00, 0x38, 0xFF, 0x0F, 0x30, 0xFF, 0x0F, 0x20, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ì
-        0x06, 0x00, 0x00, 0x00, 0x20, 0xFF, 0x0F, 0x30, 0xFF, 0x0F, 0x38, 0xFF, 0x0F, 0x08, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char í
-        0x06, 0x30, 0x00, 0x00, 0x38, 0xFF, 0x0F, 0x18, 0xFF, 0x0F, 0x38, 0xFF, 0x0F, 0x30, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char î
-        0x06, 0x38, 0x00, 0x00, 0x38, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x38, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ï
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x28, 0xFE, 0x07, 0x38, 0x07, 0x0F, 0x38, 0x07, 0x0E, 0xF8, 0x07, 0x0E, 0xF0, 0x07, 0x0F, 0xF0, 0xFF, 0x07, 0x30, 0xFF, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ð
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0x30, 0xFF, 0x0F, 0x18, 0xFE, 0x0F, 0x18, 0x06, 0x00, 0x10, 0x06, 0x00, 0x30, 0x07, 0x00, 0x30, 0xFF, 0x0F, 0x18, 0xFE, 0x0F, 0x00, 0xFC, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ñ
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x08, 0xFE, 0x07, 0x18, 0x07, 0x0F, 0x38, 0x07, 0x0E, 0x30, 0x07, 0x0E, 0x20, 0x07, 0x0F, 0x00, 0xFE, 0x07, 0x00, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ò
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x00, 0xFE, 0x07, 0x20, 0x07, 0x0F, 0x30, 0x07, 0x0E, 0x38, 0x07, 0x0E, 0x18, 0x07, 0x0F, 0x08, 0xFE, 0x07, 0x00, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ó
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x20, 0xFE, 0x07, 0x30, 0x07, 0x0F, 0x18, 0x07, 0x0E, 0x18, 0x07, 0x0E, 0x30, 0x07, 0x0F, 0x20, 0xFE, 0x07, 0x00, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ô
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x30, 0xFC, 0x03, 0x38, 0xFE, 0x07, 0x18, 0x07, 0x0F, 0x18, 0x07, 0x0E, 0x30, 0x07, 0x0E, 0x30, 0x07, 0x0F, 0x38, 0xFE, 0x07, 0x18, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char õ
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x01, 0x00, 0xFC, 0x03, 0x38, 0xFE, 0x07, 0x38, 0x07, 0x0F, 0x00, 0x07, 0x0E, 0x00, 0x07, 0x0E, 0x38, 0x07, 0x0F, 0x38, 0xFE, 0x07, 0x00, 0xFC, 0x03, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ö
-        0x0C, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xEE, 0x07, 0x00, 0xEE, 0x07, 0x00, 0xEE, 0x07, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ÷
-        0x0B, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x11, 0x00, 0xFC, 0x0F, 0x00, 0xFE, 0x07, 0x00, 0x87, 0x0F, 0x00, 0xE7, 0x0E, 0x00, 0x77, 0x0E, 0x00, 0x1E, 0x0F, 0x00, 0xFE, 0x07, 0x00, 0xFF, 0x03, 0x80, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ø
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x08, 0xFF, 0x07, 0x08, 0xFF, 0x0F, 0x18, 0x00, 0x0E, 0x30, 0x00, 0x06, 0x20, 0x00, 0x06, 0x00, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ù
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x20, 0x00, 0x0E, 0x30, 0x00, 0x06, 0x18, 0x00, 0x06, 0x08, 0xFF, 0x07, 0x08, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ú
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x07, 0x30, 0xFF, 0x0F, 0x38, 0x00, 0x0E, 0x18, 0x00, 0x06, 0x38, 0x00, 0x06, 0x30, 0xFF, 0x07, 0x00, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char û
-        0x0A, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x07, 0x38, 0xFF, 0x0F, 0x38, 0x00, 0x0E, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x38, 0xFF, 0x07, 0x38, 0xFF, 0x0F, 0x00, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ü
-        0x0A, 0x00, 0x01, 0x00, 0x00, 0x0F, 0xE0, 0x00, 0x7F, 0xE0, 0x20, 0xFC, 0xF3, 0x30, 0xE0, 0x7F, 0x38, 0x80, 0x3F, 0x18, 0xF8, 0x07, 0x08, 0xFF, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ý
-        0x0B, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0x00, 0x06, 0x06, 0x00, 0x06, 0x0E, 0x00, 0x07, 0x0E, 0x00, 0x0F, 0x0E, 0x00, 0xFE, 0x07, 0x00, 0xFE, 0x07, 0x00, 0xF8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char þ
-        0x0A, 0x00, 0x01, 0x00, 0x00, 0x1F, 0xE0, 0x38, 0xFF, 0xE0, 0x38, 0xFC, 0xF7, 0x00, 0xE0, 0x7F, 0x00, 0x00, 0x3F, 0x38, 0xF0, 0x0F, 0x38, 0xFF, 0x01, 0x00, 0x1F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00   // Code for char ÿ
-        };
-				
-const struct GDS_FontDef Font_line_2 = {
-    Archivo_Narrow18x24,
-    18,
-    24,
-    ' ',
-    '\xFF',
-    false
-};

components/display/fonts/font_tarable7seg_16x32.c

@@ -1,119 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Tarable7Seg_16x32
-//GLCD FontSize : 16 x 32
-
-static const uint8_t Tarable7Seg_16x32[ ] = {
-    0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char %
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x0F, 0xF0, 0x47, 0x06, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x60, 0xE2, 0x0F, 0xF0, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0xF0, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x02, 0x80, 0xF1, 0x47, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0xE2, 0x8F, 0x01, 0x40, 0xF0, 0x1F, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x80, 0x01, 0x40, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0xE2, 0x8F, 0xF1, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x8F, 0x01, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0xE0, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE2, 0x8F, 0x01, 0x40, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0x02, 0x80, 0xF1, 0x47, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x47, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0x02, 0x80, 0xF1, 0x47, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xE2, 0x0F, 0xF0, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x47, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0xE2, 0x8F, 0xF1, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE2, 0x8F, 0x01, 0x00, 0x06, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x06, 0xC0, 0x03, 0x00, 0xE2, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char @
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x07, 0x06, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x06, 0xC0, 0x03, 0x00, 0xE2, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char A
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x8F, 0xF1, 0x47, 0x00, 0xC0, 0x03, 0x60, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x60, 0x00, 0x80, 0xF1, 0x47, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x0F, 0xF0, 0x47, 0x06, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x80, 0xF1, 0x47, 0x00, 0xC0, 0x03, 0x60, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x60, 0xE0, 0x8F, 0xF1, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x47, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0x02, 0x80, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x07, 0x06, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x06, 0xC0, 0x03, 0x00, 0x02, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE2, 0x8F, 0x01, 0x40, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0xE2, 0x8F, 0xF1, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x8F, 0xF1, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0xE0, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0F, 0xF0, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x47, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0xE0, 0x0F, 0xF0, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x8F, 0xF1, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0xE0, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char K
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x0F, 0xF0, 0x47, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x02, 0x00, 0xF0, 0x07, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0xF0, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x80, 0xF1, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x80, 0xF1, 0x07, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x0F, 0xF0, 0x47, 0x06, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x60, 0xE2, 0x0F, 0xF0, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE2, 0x8F, 0xF1, 0x07, 0x06, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x06, 0xC0, 0x03, 0x00, 0xE2, 0x8F, 0x01, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE2, 0x8F, 0x01, 0x00, 0x06, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x0E, 0xC0, 0x03, 0x00, 0x06, 0xC0, 0x03, 0x00, 0xE2, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x0D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x80, 0xF1, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE2, 0x8F, 0x01, 0x40, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0x02, 0x80, 0xF1, 0x47, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xE2, 0x0F, 0xF0, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x0F, 0xF0, 0x47, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0xE0, 0x0F, 0xF0, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xF0, 0x47, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xF0, 0x47, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char V
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x0F, 0x00, 0x40, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x60, 0xE0, 0x0F, 0x00, 0x40, 0xF0, 0x1F, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char W
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xFC, 0x1F, 0xF0, 0x1F, 0xF8, 0x0F, 0xE0, 0x8F, 0xF1, 0x07, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0xC0, 0x03, 0x00, 0xE0, 0x8F, 0xF1, 0x07, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0xF0, 0x1F, 0x00, 0x00, 0xE0, 0x8F, 0x01, 0x40, 0x00, 0xC0, 0x03, 0x60, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x70, 0x00, 0xC0, 0x03, 0x60, 0xE0, 0x8F, 0xF1, 0x47, 0xF0, 0x1F, 0xF8, 0x0F, 0xF8, 0x3F, 0xFC, 0x1F, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0xF8, 0x0F, 0x02, 0x80, 0xF1, 0x47, 0x06, 0xC0, 0x03, 0x60, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x0E, 0xC0, 0x03, 0x70, 0x06, 0xC0, 0x03, 0x60, 0xE2, 0x8F, 0x01, 0x40, 0xF0, 0x1F, 0x00, 0x00, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char _
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char w
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char 
-};
-
-const struct GDS_FontDef Font_Tarable7Seg_16x32 = {
-    Tarable7Seg_16x32,
-    16,
-    32,
-    ' ',
-    'Z',
-    true
-};

components/display/fonts/font_tarable7seg_32x64.c

@@ -1,119 +0,0 @@
-#include <gds_font.h>
-
-//WARNING: This Font Require X-GLCD Lib.
-//         You can not use it with MikroE GLCD Lib.
-
-//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
-//MikroElektronika 2011
-//http://www.mikroe.com
-
-//GLCD FontName : Tarable7Seg_32x64
-//GLCD FontSize : 32 x 64
-
-static const uint8_t Tarable7Seg_32x64[ ] = {
-    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char !
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char "
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char #
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char $
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char %
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char &
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char '
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char (
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char )
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char *
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char +
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ,
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char -
-    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char .
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char /
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 0
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 1
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 2
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 3
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 4
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 5
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 6
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 7
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 8
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char 9
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char :
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ;
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char <
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char =
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char >
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ?
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char @
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char A
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char B
-    0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char C
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char D
-    0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char E
-    0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char F
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char G
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char H
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char I
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char J
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char K
-    0x1D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char L
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char M
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char N
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char O
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char P
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Q
-    0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char R
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char S
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char T
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char U
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char V
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xE0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char W
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x07, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char X
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE0, 0xFF, 0xFF, 0x1F, 0xF8, 0xFF, 0xFF, 0x47, 0xF0, 0xFF, 0xFF, 0x3F, 0xFC, 0xFF, 0xFF, 0x0F, 0xF8, 0xFF, 0xFF, 0x7F, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Y
-    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0x0F, 0x02, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x47, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x0E, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x70, 0x06, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x60, 0xE2, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x40, 0xF0, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xF8, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char Z
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char [
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char BackSlash
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ]
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ^
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char _
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char `
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char a
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char b
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char c
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char d
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char e
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char f
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char g
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char h
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char i
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char j
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char k
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char l
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char m
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char n
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char o
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char p
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char q
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char r
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char s
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char t
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char u
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char v
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char w
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char x
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char y
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char z
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char {
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char |
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char }
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Code for char ~
-    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // Code for char 
-};
-
-const struct GDS_FontDef Font_Tarable7Seg_32x64 = {
-    Tarable7Seg_32x64,
-    32,
-    64,
-    ' ',
-    'Z',
-    true
-};

components/driver_bt/CMakeLists.txt

@@ -1,6 +1,8 @@
-idf_component_register(	SRC_DIRS .
-						INCLUDE_DIRS .
-						PRIV_REQUIRES services bt display console tools platform_config
+if(IDF_TARGET STREQUAL "esp32")
+    idf_component_register(	SRC_DIRS .
+                            INCLUDE_DIRS .
+                            PRIV_REQUIRES services bt display console tools platform_config
 
 )
+endif()
 

components/driver_bt/bt_app_core - Copy.c.old

@@ -0,0 +1,172 @@
+/*
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/task.h"
+#include "esp_bt.h"
+#include "esp_bt_main.h"
+#include "esp_gap_bt_api.h"
+#include "bt_app_core.h"
+#include "tools.h"
+
+static const char *TAG = "btappcore";
+
+static void bt_app_task_handler(void *arg);
+static bool bt_app_send_msg(bt_app_msg_t *msg);
+static void bt_app_work_dispatched(bt_app_msg_t *msg);
+
+static xQueueHandle s_bt_app_task_queue;
+static bool running;
+
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
+{
+	ESP_LOGV(TAG,"%s event 0x%x, param len %d", __func__, event, param_len);
+
+    bt_app_msg_t msg;
+    memset(&msg, 0, sizeof(bt_app_msg_t));
+
+    msg.sig = BT_APP_SIG_WORK_DISPATCH;
+    msg.event = event;
+    msg.cb = p_cback;
+
+    if (param_len == 0) {
+        return bt_app_send_msg(&msg);
+    } else if (p_params && param_len > 0) {
+        if ((msg.param = clone_obj_psram(p_params, param_len)) != NULL) {
+            /* check if caller has provided a copy callback to do the deep copy */
+            if (p_copy_cback) {
+                p_copy_cback(&msg, msg.param, p_params);
+            }
+            return bt_app_send_msg(&msg);
+        }
+    }
+
+    return false;
+}
+
+static bool bt_app_send_msg(bt_app_msg_t *msg)
+{
+    if (msg == NULL) {
+        return false;
+    }
+
+    if (xQueueSend(s_bt_app_task_queue, msg, 10 / portTICK_PERIOD_MS) != pdTRUE) {
+    	ESP_LOGE(TAG,"%s xQueue send failed", __func__);
+        return false;
+    }
+    return true;
+}
+
+static void bt_app_work_dispatched(bt_app_msg_t *msg)
+{
+    if (msg->cb) {
+        msg->cb(msg->event, msg->param);
+    }
+}
+
+static void bt_app_task_handler(void *arg)
+{
+    bt_app_msg_t msg;
+	esp_err_t err;
+	
+	s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
+	
+	esp_bt_controller_mem_release(ESP_BT_MODE_BLE);
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+	
+    if ((err = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
+        ESP_LOGE(TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(err));
+        goto exit;
+    }
+
+    if ((err = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT)) != ESP_OK) {
+        ESP_LOGE(TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(err));
+		goto exit;
+    }
+
+    if ((err = esp_bluedroid_init()) != ESP_OK) {
+        ESP_LOGE(TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(err));
+		goto exit;
+    }
+
+    if ((err = esp_bluedroid_enable()) != ESP_OK) {
+        ESP_LOGE(TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(err));
+		goto exit;
+    }
+	
+	/* Bluetooth device name, connection mode and profile set up */
+	bt_app_work_dispatch((bt_av_hdl_stack_evt_t*) arg, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
+	
+#if (CONFIG_BT_SSP_ENABLED)
+    /* Set default parameters for Secure Simple Pairing */
+    esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
+    esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO;
+    esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
+#endif
+	
+	running = true;
+	
+	while (running) {
+        if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, (portTickType)portMAX_DELAY)) {
+        	ESP_LOGV(TAG,"%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
+			
+            switch (msg.sig) {
+            case BT_APP_SIG_WORK_DISPATCH:
+                bt_app_work_dispatched(&msg);
+                break;
+            default:
+                ESP_LOGW(TAG,"%s, unhandled sig: %d", __func__, msg.sig);
+                break;
+            }
+
+            if (msg.param) {
+                free(msg.param);
+            }
+        } else {
+        	ESP_LOGW(TAG,"No messaged received from queue.");
+        }
+    }
+	
+	ESP_LOGD(TAG, "bt_app_task shutting down");
+	
+	if (esp_bluedroid_disable() != ESP_OK) goto exit;
+	// this disable has a sleep timer BTA_DISABLE_DELAY in bt_target.h and 
+	// if we don't wait for it then disable crashes... don't know why
+	vTaskDelay(2*200 / portTICK_PERIOD_MS);	
+	
+    ESP_LOGD(TAG, "esp_bluedroid_disable called successfully");
+    if (esp_bluedroid_deinit() != ESP_OK) goto exit;
+	
+    ESP_LOGD(TAG, "esp_bluedroid_deinit called successfully");
+    if (esp_bt_controller_disable() != ESP_OK) goto exit;
+	
+    ESP_LOGD(TAG, "esp_bt_controller_disable called successfully");
+    if (esp_bt_controller_deinit() != ESP_OK) goto exit;
+	
+	ESP_LOGD(TAG, "bt stopped successfully");	
+
+exit:
+	vQueueDelete(s_bt_app_task_queue);
+	running = false;		
+    vTaskDelete(NULL);
+}
+
+void bt_app_task_start_up(bt_av_hdl_stack_evt_t* handler)
+{
+    xTaskCreate(bt_app_task_handler, "BtAppT", 4096, handler, configMAX_PRIORITIES - 3, NULL);
+}
+
+void bt_app_task_shut_down(void)
+{
+	running = false;
+}

components/driver_bt/bt_app_core.c

@@ -7,29 +7,29 @@
 */
 
 #include "bt_app_core.h"
-#include <stdint.h>
-#include "esp_system.h"
-#include <string.h>
-#include <stdbool.h>
+#include "esp_bt.h"
+#include "esp_bt_main.h"
+#include "esp_gap_bt_api.h"
 #include "esp_log.h"
-#include "freertos/xtensa_api.h"
-#include "freertos/FreeRTOSConfig.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "freertos/task.h"
+#include "tools.h"
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
 
-static const char * TAG = "btappcore";
+static const char* TAG = "btappcore";
 
-static void bt_app_task_handler(void *arg);
-static bool bt_app_send_msg(bt_app_msg_t *msg);
-static void bt_app_work_dispatched(bt_app_msg_t *msg);
+static void bt_app_task_handler(void* arg);
+static bool bt_app_send_msg(bt_app_msg_t* msg);
+static void bt_app_work_dispatched(bt_app_msg_t* msg);
 
-static xQueueHandle s_bt_app_task_queue = NULL;
-static xTaskHandle s_bt_app_task_handle = NULL;
+static QueueHandle_t s_bt_app_task_queue;
+static bool running;
 
-bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
-{
-	ESP_LOGV(TAG,"%s event 0x%x, param len %d", __func__, event, param_len);
+bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void* p_params, int param_len, bt_app_copy_cb_t p_copy_cback) {
+    ESP_LOGV(TAG, "%s event 0x%x, param len %d", __func__, event, param_len);
 
     bt_app_msg_t msg;
     memset(&msg, 0, sizeof(bt_app_msg_t));
@@ -38,15 +38,12 @@ bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, i
     msg.event = event;
     msg.cb = p_cback;
 
-    if (param_len == 0) {
+    if(param_len == 0) {
         return bt_app_send_msg(&msg);
-    } else if (p_params && param_len > 0) {
-        if ((msg.param = malloc(param_len)) != NULL) {
-            memcpy(msg.param, p_params, param_len);
+    } else if(p_params && param_len > 0) {
+        if((msg.param = clone_obj_psram(p_params, param_len)) != NULL) {
             /* check if caller has provided a copy callback to do the deep copy */
-            if (p_copy_cback) {
-                p_copy_cback(&msg, msg.param, p_params);
-            }
+            if(p_copy_cback) { p_copy_cback(&msg, msg.param, p_params); }
             return bt_app_send_msg(&msg);
         }
     }
@@ -54,69 +51,115 @@ bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, i
     return false;
 }
 
-static bool bt_app_send_msg(bt_app_msg_t *msg)
-{
-    if (msg == NULL) {
-        return false;
-    }
+static bool bt_app_send_msg(bt_app_msg_t* msg) {
+    if(msg == NULL) { return false; }
 
-    if (xQueueSend(s_bt_app_task_queue, msg, 10 / portTICK_RATE_MS) != pdTRUE) {
-    	ESP_LOGE(TAG,"%s xQueue send failed", __func__);
+    if(xQueueSend(s_bt_app_task_queue, msg, 10 / portTICK_PERIOD_MS) != pdTRUE) {
+        ESP_LOGE(TAG, "%s xQueue send failed", __func__);
         return false;
     }
     return true;
 }
 
-static void bt_app_work_dispatched(bt_app_msg_t *msg)
-{
-    if (msg->cb) {
-        msg->cb(msg->event, msg->param);
-    }
+static void bt_app_work_dispatched(bt_app_msg_t* msg) {
+    if(msg->cb) { msg->cb(msg->event, msg->param); }
 }
 
-static void bt_app_task_handler(void *arg)
-{
+static void bt_app_task_handler(void* arg) {
     bt_app_msg_t msg;
-    for (;;) {
-        if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, (portTickType)portMAX_DELAY)) {
-        	ESP_LOGV(TAG,"%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
-            switch (msg.sig) {
+    esp_err_t err;
+
+    s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
+
+    esp_bt_controller_mem_release(ESP_BT_MODE_BLE);
+    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
+    if(esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
+        if((err = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
+            ESP_LOGE(TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(err));
+            goto exit;
+        }
+
+        if((err = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT)) != ESP_OK) {
+            ESP_LOGE(TAG, "%s enable controller failed: %s\n", __func__, esp_err_to_name(err));
+            goto exit;
+        }
+
+        if((err = esp_bluedroid_init()) != ESP_OK) {
+            ESP_LOGE(TAG, "%s initialize bluedroid failed: %s\n", __func__, esp_err_to_name(err));
+            goto exit;
+        }
+
+        if((err = esp_bluedroid_enable()) != ESP_OK) {
+            ESP_LOGE(TAG, "%s enable bluedroid failed: %s\n", __func__, esp_err_to_name(err));
+            goto exit;
+        }
+    }
+
+    /* Bluetooth device name, connection mode and profile set up */
+    bt_app_work_dispatch((bt_av_hdl_stack_evt_t*)arg, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
+#if(CONFIG_BT_SSP_ENABLED)
+    /* Set default parameters for Secure Simple Pairing */
+    esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
+    esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO;
+    esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
+#endif
+
+    /*
+     * Set default parameters for Legacy Pairing
+     * Use variable pin, input pin code when pairing
+     */
+    esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE;
+    esp_bt_pin_code_t pin_code;
+    esp_bt_gap_set_pin(pin_type, 0, pin_code);
+
+    running = true;
+
+    while(running) {
+        if(pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, portMAX_DELAY)) {
+            ESP_LOGV(TAG, "%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
+
+            switch(msg.sig) {
             case BT_APP_SIG_WORK_DISPATCH:
                 bt_app_work_dispatched(&msg);
                 break;
             default:
-                ESP_LOGW(TAG,"%s, unhandled sig: %d", __func__, msg.sig);
+                ESP_LOGW(TAG, "%s, unhandled sig: %d", __func__, msg.sig);
                 break;
-            } // switch (msg.sig)
-
-            if (msg.param) {
-                free(msg.param);
             }
-        }
-        else
-        {
-        	ESP_LOGW(TAG,"No messaged received from queue.");
+
+            if(msg.param) { free(msg.param); }
+        } else {
+            ESP_LOGW(TAG, "No messaged received from queue.");
         }
     }
+
+    ESP_LOGD(TAG, "bt_app_task shutting down");
+
+    if(esp_bluedroid_disable() != ESP_OK) goto exit;
+    // this disable has a sleep timer BTA_DISABLE_DELAY in bt_target.h and
+    // if we don't wait for it then disable crashes... don't know why
+    vTaskDelay(2 * 200 / portTICK_PERIOD_MS);
+
+    ESP_LOGD(TAG, "esp_bluedroid_disable called successfully");
+    if(esp_bluedroid_deinit() != ESP_OK) goto exit;
+
+    ESP_LOGD(TAG, "esp_bluedroid_deinit called successfully");
+    if(esp_bt_controller_disable() != ESP_OK) goto exit;
+
+    ESP_LOGD(TAG, "esp_bt_controller_disable called successfully");
+    if(esp_bt_controller_deinit() != ESP_OK) goto exit;
+
+    ESP_LOGD(TAG, "bt stopped successfully");
+
+exit:
+    vQueueDelete(s_bt_app_task_queue);
+    running = false;
+    vTaskDelete(NULL);
 }
 
-void bt_app_task_start_up(void)
-{
+void bt_app_task_start_up(bt_av_hdl_stack_evt_t* handler) {
 
-    s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
-    assert(s_bt_app_task_queue!=NULL);
-    assert(xTaskCreate(bt_app_task_handler, "BtAppT", 4096, NULL, configMAX_PRIORITIES - 3, &s_bt_app_task_handle)==pdPASS);
-    return;
+    xTaskCreate(bt_app_task_handler, "BtAppT", 4096, handler, configMAX_PRIORITIES - 3, NULL);
 }
 
-void bt_app_task_shut_down(void)
-{
-    if (s_bt_app_task_handle) {
-        vTaskDelete(s_bt_app_task_handle);
-        s_bt_app_task_handle = NULL;
-    }
-    if (s_bt_app_task_queue) {
-        vQueueDelete(s_bt_app_task_queue);
-        s_bt_app_task_queue = NULL;
-    }
-}
+void bt_app_task_shut_down(void) { running = false; }