badvision · June 20, 2025 03:18
diff --git a/squix_font_editor.html b/squix_font_editor.html
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OLED Font Simulator - Squix 3.0 Format</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #1a1a1a;
            color: #ffffff;
            padding: 20px;
        }
        
        .container {
            max-width: 800px;
            margin: 0 auto;
        }
        
        .displays-container {
            display: flex;
            gap: 40px;
            align-items: flex-start;
            margin: 20px 0;
        }
        
        .display-section {
            display: flex;
            flex-direction: column;
            align-items: center;
        }
        
        .display-label {
            color: #ccc;
            font-size: 14px;
            margin-bottom: 10px;
            text-align: center;
        }
        
        .display {
            background-color: #000000;
            border: 2px solid #333;
            display: inline-block;
        }
        
        .display.large {
            /* Large display for detailed editing */
        }
        
        .display.small {
            /* Small display to simulate 1-inch OLED */
        }
        
        .pixel {
            display: inline-block;
            background-color: #000000;
        }
        
        .pixel.large {
            width: 6px;
            height: 6px;
        }
        
        .pixel.small {
            width: 1px;
            height: 1px;
        }
        
        .pixel.on {
            background-color: #96ceff;
        }
        
        .pixel.on.small {
            background-color: #96ceff;
            box-shadow: 0 0 2px 0.7px #96ceff;
        }
        
        .controls {
            margin: 20px 0;
        }
        
        input[type="text"] {
            width: 300px;
            padding: 8px;
            margin: 5px;
            background-color: #333;
            color: #fff;
            border: 1px solid #555;
        }
        
        button {
            padding: 10px 15px;
            margin: 5px;
            background-color: #4CAF50;
            color: white;
            border: none;
            cursor: pointer;
        }
        
        button:hover {
            background-color: #45a049;
        }
        
        .info {
            background-color: #333;
            padding: 10px;
            margin: 10px 0;
            border-radius: 5px;
        }
        
        .row {
            display: block;
            line-height: 0;
            font-size: 0;
        }
        
        .row.large {
            height: 6px;
        }
        
        .row.small {
            height: 1px;
        }
    </style>
 </head>
 <body>
    <div class="container">
        <h1>OLED Font Simulator - <a href="https://oleddisplay.squix.ch/">Squix 3.0 Format</a></h1>
        <p>Simulates a 64x32 OLED display using the exact font data from OLEDDisplayFonts.h</p>
        
        <div class="controls">
            <div style="margin-bottom: 10px;">
                <label for="fontSelect" style="color: #fff; margin-right: 10px;">Font:</label>
                <select id="fontSelect" onchange="changeFont()" style="padding: 5px; margin-right: 10px;">
                    <option value="ArialMT_Plain_10">ArialMT_Plain_10 (Original)</option>
                    <option value="ArialMT_Bold_10">ArialMT_Bold_10 (Original)</option>
                    <option value="Custom_font_10">Custom_font_10 (Modified)</option>
                    <option value="URW_Gothic_L_Book_10">URW_Gothic_L_Book_10 (Original)</option>
                </select>
            </div>
            <input type="text" id="textInput" placeholder="Enter text to display" value="Hello World!">
            <button onclick="renderText()">Render Text</button>
            <button onclick="clearDisplay()">Clear Display</button>
        </div>
        
        <div class="info">
            <div id="fontInfo">Font: ArialMT_Plain_10 (Width: 10, Height: 13)</div>
            <div>Display: 64x32 pixels</div>
            <div id="positionInfo">Position: (0, 0)</div>
        </div>
        
        <div class="displays-container">
            <div class="display-section">
                <div class="display-label">Large Preview (6x scale)</div>
                <div class="display large" id="displayLarge"></div>
            </div>
            <div class="display-section">
                <div class="display-label">1-inch OLED Simulation (1x scale)</div>
                <div class="display small" id="displaySmall"></div>
            </div>
        </div>
    </div>

    <!-- Font Editor Section -->
    <div style="margin-top: 40px; padding: 20px; border: 2px solid #666; border-radius: 10px; background: #2a2a2a;">
        <h2 style="color: #fff; margin-top: 0;">Font Editor</h2>
        
        <div style="display: flex; gap: 20px; margin-bottom: 20px;">
            <div>
                <label style="color: #fff;">Character:</label>
                <select id="charSelect" onchange="selectCharacterForEdit()" style="margin-left: 10px; padding: 5px;">
                    <!-- Will be populated by JavaScript -->
                </select>
            </div>
            <div>
                <label style="color: #fff;">Width:</label>
                <input type="number" id="charWidth" min="1" max="32" onchange="updateCharDimensions()" style="margin-left: 10px; width: 60px;">
            </div>
            <div>
                <label style="color: #fff;">Height:</label>
                <input type="number" id="charHeight" min="1" max="32" onchange="updateCharDimensions()" style="margin-left: 10px; width: 60px;">
            </div>
        </div>

        <div style="display: flex; gap: 30px;">
            <!-- Character Editor Grid -->
            <div>
                <h3 style="color: #fff;">Character Editor</h3>
                <div id="charEditor" style="display: inline-block; border: 1px solid #666; background: #000;">
                    <!-- Grid will be created by JavaScript -->
                </div>
                <div style="margin-top: 10px;">
                    <button onclick="clearCharacter()" style="margin-right: 10px;">Clear</button>
                    <button onclick="revertCharacter()">Revert</button>
                </div>
                
                <!-- Pixel Shift Controls -->
                <div style="margin-top: 20px; padding: 15px; border: 1px solid #555; border-radius: 5px; background: #333;">
                    <h4 style="color: #fff; margin-top: 0;">Move Pixels</h4>
                    
                    <div style="margin-bottom: 15px;">
                        <div style="color: #ccc; font-size: 12px; margin-bottom: 8px;">All Characters:</div>
                        <button onclick="shiftAllCharacters('up')" style="margin-right: 5px;" title="Move all characters up 1 pixel (with wrap-around)">↑ All Up</button>
                        <button onclick="shiftAllCharacters('down')" title="Move all characters down 1 pixel (with wrap-around)">↓ All Down</button>
                    </div>
                    
                    <div>
                        <div style="color: #ccc; font-size: 12px; margin-bottom: 8px;">Current Character:</div>
                        <div style="text-align: center;">
                            <div><button onclick="shiftCurrentCharacter('up')" style="width: 30px;" title="Move current character up 1 pixel">↑</button></div>
                            <div style="margin: 5px 0;">
                                <button onclick="shiftCurrentCharacter('left')" style="width: 30px; margin-right: 5px;" title="Move current character left 1 pixel">←</button>
                                <button onclick="shiftCurrentCharacter('right')" style="width: 30px;" title="Move current character right 1 pixel">→</button>
                            </div>
                            <div><button onclick="shiftCurrentCharacter('down')" style="width: 30px;" title="Move current character down 1 pixel">↓</button></div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Live Data Output -->
            <div style="flex: 1;">
                <h3 style="color: #fff;">Live Font Data</h3>
                <textarea id="fontDataOutput" readonly style="width: 100%; height: 400px; font-family: monospace; font-size: 12px; background: #1a1a1a; color: #0f0; border: 1px solid #666;"></textarea>
                <div style="margin-top: 10px;">
                    <button onclick="copyFontData()">Copy to Clipboard</button>
                    <button onclick="exportModifiedFont()" style="margin-left: 10px;">Export Modified Font</button>
                </div>
            </div>
        </div>
    </div>

    <script>

        // Display properties
        const DISPLAY_WIDTH = 64;
        const DISPLAY_HEIGHT = 32;
        let display = [];

                 // Global font variables
         let currentFont = null;
         let currentFontName = 'ArialMT_Plain_10';
         let fontWidth, fontHeight, firstChar, numChars;
         
         // Font registry
         let availableFonts;
         
         // Font editing variables
         let originalFont = null; // Keep original for revert
         let fontData = null; // Unpacked font structure
         let currentEditChar = 65; // Currently editing character
         let editGrid = []; // 2D array for character editor

                 // Select and set font properties
         function selectFont(font, fontName = 'Unknown') {
             currentFont = new Uint8Array(font); // Make a copy
             originalFont = new Uint8Array(font); // Keep original
             fontWidth = font[0];
             fontHeight = font[1];
             firstChar = font[2];
             numChars = font[3];
             currentFontName = fontName;
             
             // Update font info display
             updateFontInfo();
             
             // Unpack font into more convenient structure
             unpackFont();
         }
         
         // Change font based on selector
         function changeFont() {
             const fontSelector = document.getElementById('fontSelect');
             const selectedFontName = fontSelector.value;
             
             if (availableFonts[selectedFontName]) {
                 selectFont(availableFonts[selectedFontName], selectedFontName);
                 
                 // Re-initialize font editor with new font
                 initFontEditor();
                 
                 // Re-render display
                 renderText();
             }
         }
         
         // Update font info display
         function updateFontInfo() {
             const fontInfoElement = document.getElementById('fontInfo');
             fontInfoElement.textContent = `Font: ${currentFontName} (Width: ${fontWidth}, Height: ${fontHeight})`;
         }
         
         // Unpack font data into convenient structure
         function unpackFont() {
             fontData = {
                 header: {
                     width: fontWidth,
                     height: fontHeight,
                     firstChar: firstChar,
                     numChars: numChars
                 },
                 characters: {}
             };
             
             const JUMPTABLE_START = 4;
             const JUMPTABLE_BYTES = 4;
             const sizeOfJumpTable = numChars * JUMPTABLE_BYTES;
             const bitmapDataStart = JUMPTABLE_START + sizeOfJumpTable;
             
             // Calculate actual bitmap offsets by sequential parsing
             let currentBitmapOffset = bitmapDataStart;
             
             // Parse each character
             for (let i = 0; i < numChars; i++) {
                 const charCode = firstChar + i;
                 const entryOffset = JUMPTABLE_START + (i * JUMPTABLE_BYTES);
                 
                 const msbJumpToChar = currentFont[entryOffset];
                 const lsbJumpToChar = currentFont[entryOffset + 1];
                 const charByteSize = currentFont[entryOffset + 2];
                 const charWidth = currentFont[entryOffset + 3];
                 
                 const isDrawable = !(msbJumpToChar === 255 && lsbJumpToChar === 255);
                 let bitmapData = [];
                 
                 if (isDrawable && charByteSize > 0) {
                     // Extract bitmap data from current position
                     for (let j = 0; j < charByteSize; j++) {
                         if (currentBitmapOffset + j < currentFont.length) {
                             bitmapData.push(currentFont[currentBitmapOffset + j]);
                         }
                     }
                     // Move to next character's bitmap data
                     currentBitmapOffset += charByteSize;
                 }
                 
                 fontData.characters[charCode] = {
                     width: charWidth,
                     byteSize: charByteSize,
                     bitmapOffset: isDrawable ? currentBitmapOffset - charByteSize : 0,
                     bitmapData: bitmapData,
                     isDrawable: isDrawable,
                     // Convert bitmap to 2D pixel array for editing
                     pixels: bitmapToPixels(bitmapData, charWidth, fontHeight)
                 };
                 
                 // Debug problematic characters
                 if (charCode === 34 || charCode === 33 || charCode === 35) { // '"', '!', '#' characters
                     console.log(`Unpacking char ${charCode}: width=${charWidth}, byteSize=${charByteSize}, calculatedOffset=${fontData.characters[charCode].bitmapOffset}, isDrawable=${isDrawable}`);
                     console.log(`Jump table entry: [${currentFont[entryOffset]}, ${currentFont[entryOffset+1]}, ${currentFont[entryOffset+2]}, ${currentFont[entryOffset+3]}]`);
                     console.log(`BitmapData:`, bitmapData);
                     console.log(`Font array length:`, currentFont.length);
                 }
             }
         }
         
         // Convert bitmap bytes to 2D pixel array
         function bitmapToPixels(bitmapData, width, height) {
             const pixels = [];
             for (let y = 0; y < height; y++) {
                 pixels[y] = [];
                 for (let x = 0; x < width; x++) {
                     pixels[y][x] = false;
                 }
             }
             
             if (!bitmapData || bitmapData.length === 0) return pixels;
             
             const rasterHeight = Math.ceil(height / 8);
             let byteIndex = 0;
             
             for (let col = 0; col < width && byteIndex < bitmapData.length; col++) {
                 for (let byteRow = 0; byteRow < rasterHeight && byteIndex < bitmapData.length; byteRow++) {
                     const currentByte = bitmapData[byteIndex];
                     byteIndex++;
                     
                     for (let bit = 0; bit < 8; bit++) {
                         const y = (byteRow * 8) + bit;
                         if (y >= height) break;
                         
                         if ((currentByte & (1 << bit)) !== 0) {
                             pixels[y][col] = true;
                         }
                     }
                 }
             }
             
             return pixels;
         }
         
         // Convert 2D pixel array back to bitmap bytes
         function pixelsToBitmap(pixels, width, height) {
             const rasterHeight = Math.ceil(height / 8);
             const bitmapData = [];
             
             for (let col = 0; col < width; col++) {
                 for (let byteRow = 0; byteRow < rasterHeight; byteRow++) {
                     let currentByte = 0;
                     
                     for (let bit = 0; bit < 8; bit++) {
                         const y = (byteRow * 8) + bit;
                         if (y >= height) break;
                         
                         if (pixels[y] && pixels[y][col]) {
                             currentByte |= (1 << bit);
                         }
                     }
                     
                     bitmapData.push(currentByte);
                 }
             }
             
             return bitmapData;
         }
        
        // Debug function to analyze font structure
        // Initialize display
        function initDisplay() {
            display = [];
            for (let y = 0; y < DISPLAY_HEIGHT; y++) {
                display[y] = [];
                for (let x = 0; x < DISPLAY_WIDTH; x++) {
                    display[y][x] = false;
                }
            }
        }

                 // Get character info from jump table (following actual OLEDDisplay logic)
         function getCharInfo(charCode) {
             if (charCode < firstChar || charCode >= firstChar + numChars) {
                 return null;
             }
             
             // If we have fontData structure (after unpacking), use it directly
             if (fontData && fontData.characters && fontData.characters[charCode]) {
                 const char = fontData.characters[charCode];
                 return {
                     width: char.width,
                     byteSize: char.byteSize,
                     bitmapOffset: char.bitmapOffset
                 };
             }
             
             // Fallback to parsing currentFont directly
             const JUMPTABLE_START = 4; // After header
             const JUMPTABLE_BYTES = 4; // 4 bytes per character entry
             const JUMPTABLE_LSB = 1;   // LSB offset within entry
             const JUMPTABLE_SIZE = 2;  // Size offset within entry  
             const JUMPTABLE_WIDTH = 3; // Width offset within entry
             
             const charIndex = charCode - firstChar;
             const entryOffset = JUMPTABLE_START + (charIndex * JUMPTABLE_BYTES);
             
             const msbJumpToChar = currentFont[entryOffset];
             const lsbJumpToChar = currentFont[entryOffset + JUMPTABLE_LSB];
             const charByteSize = currentFont[entryOffset + JUMPTABLE_SIZE];
             const currentCharWidth = currentFont[entryOffset + JUMPTABLE_WIDTH];
             
             // Test if the char is drawable (following actual code logic)
             if (msbJumpToChar === 255 && lsbJumpToChar === 255) {
                 return { width: currentCharWidth, byteSize: 0, bitmapOffset: 0 };
             }
             
             // Get the position of the char data (following actual code)
             const sizeOfJumpTable = numChars * JUMPTABLE_BYTES;
             const charDataPosition = JUMPTABLE_START + sizeOfJumpTable + ((msbJumpToChar << 8) + lsbJumpToChar);
             
             return {
                 width: currentCharWidth,
                 byteSize: charByteSize,
                 bitmapOffset: charDataPosition
             };
         }

                 // Draw character at position (simplified but correct approach)
         function drawChar(charCode, xMove, yMove) {
             const charInfo = getCharInfo(charCode);
             if (!charInfo || charInfo.byteSize === 0) {
                 return charInfo ? charInfo.width : 0;
             }
             
             // Debug info for troubleshooting
             if (charCode === 84) { // 'T'
                 console.log(`Drawing T: charInfo=`, charInfo, `currentFont.length=${currentFont.length}`);
             }
             
             // Simple approach: the font bitmap is stored as vertical columns
             // Each byte represents 8 vertical pixels in a column
             // We need to figure out how many columns and how they're arranged
             
             const width = charInfo.width;
             const height = fontHeight;
             const data = currentFont;
             const offset = charInfo.bitmapOffset;
             const bytesInData = charInfo.byteSize;
             
             // Calculate how many byte-rows we need for the font height
             const rasterHeight = Math.ceil(height / 8);
             
             // The bitmap data is arranged as vertical strips
             // For a character of width W and height H, we have:
             // - W columns
             // - Each column has rasterHeight bytes (to cover H pixels)
             
             let byteIndex = 0;
             for (let col = 0; col < width && byteIndex < bytesInData; col++) {
                 const x = xMove + col;
                 if (x >= DISPLAY_WIDTH) break;
                 
                 // For each column, process the vertical bytes
                 for (let byteRow = 0; byteRow < rasterHeight && byteIndex < bytesInData; byteRow++) {
                     const currentByte = data[offset + byteIndex];
                     byteIndex++;
                     
                     // Extract 8 pixels from this byte
                     for (let bit = 0; bit < 8; bit++) {
                         const y = yMove + (byteRow * 8) + bit;
                         if (y >= DISPLAY_HEIGHT || y < 0) continue;
                         if (y >= yMove + height) break; // Don't go beyond character height
                         
                         if ((currentByte & (1 << bit)) !== 0) {
                             display[y][x] = true;
                         }
                     }
                 }
             }
             
             return charInfo.width;
         }

        // Render display to HTML
        function renderDisplay() {
            renderDisplayToElement('displayLarge', 'large');
            renderDisplayToElement('displaySmall', 'small');
        }
        
        function renderDisplayToElement(elementId, sizeClass) {
            const displayElement = document.getElementById(elementId);
            displayElement.innerHTML = '';
            
            for (let y = 0; y < DISPLAY_HEIGHT; y++) {
                const row = document.createElement('div');
                row.className = `row ${sizeClass}`;
                
                for (let x = 0; x < DISPLAY_WIDTH; x++) {
                    const pixel = document.createElement('span');
                    const isOn = display[y][x];
                    pixel.className = isOn ? `pixel ${sizeClass} on` : `pixel ${sizeClass}`;
                    row.appendChild(pixel);
                }
                
                displayElement.appendChild(row);
            }
        }

        // Render text to display
        function renderText() {
            const text = document.getElementById('textInput').value;
            initDisplay();
            
            let x = 0;
            const y = 10; // Center vertically (32 - 13) / 2 + baseline
            
            for (let i = 0; i < text.length; i++) {
                if (x >= DISPLAY_WIDTH) break;
                
                const charCode = text.charCodeAt(i);
                const charWidth = drawChar(charCode, x, y);
                
                x += charWidth; // No extra spacing - character width includes spacing
            }
            
            renderDisplay();
            updatePositionInfo(x, y);
        }

        // Clear display
        function clearDisplay() {
            initDisplay();
            renderDisplay();
            updatePositionInfo(0, 0);
        }

        // Update position info
        function updatePositionInfo(x, y) {
            document.getElementById('positionInfo').textContent = `Position: (${x}, ${y})`;
        }

         // Font Editor Functions
         function initFontEditor() {
             // Populate character selector
             const charSelect = document.getElementById('charSelect');
             charSelect.innerHTML = '';
             
             for (let i = firstChar; i < firstChar + numChars; i++) {
                 const option = document.createElement('option');
                 option.value = i;
                 option.textContent = `${i} (${String.fromCharCode(i)})`;
                 charSelect.appendChild(option);
             }
             
             charSelect.value = currentEditChar;
             selectCharacterForEdit();
         }
         
         function selectCharacterForEdit() {
             currentEditChar = parseInt(document.getElementById('charSelect').value);
             let char = fontData.characters[currentEditChar];
             
             // If character doesn't exist or isn't drawable, create a new empty character
             if (!char || !char.isDrawable) {
                 createEmptyCharacter(currentEditChar);
                 char = fontData.characters[currentEditChar];
             }
             
             // Update dimension inputs
             document.getElementById('charWidth').value = char.width;
             document.getElementById('charHeight').value = fontHeight;
             
             // Create editing grid
             createEditGrid();
             updateFontDataOutput();
         }
         
         function createEditGrid() {
             let char = fontData.characters[currentEditChar];
             
             // If character doesn't exist or isn't drawable, create it first
             if (!char || !char.isDrawable) {
                 createEmptyCharacter(currentEditChar);
                 char = fontData.characters[currentEditChar];
             }
             
             const editorDiv = document.getElementById('charEditor');
             editorDiv.innerHTML = '';
             
             // Copy pixels to edit grid
             editGrid = [];
             for (let y = 0; y < fontHeight; y++) {
                 editGrid[y] = [];
                 for (let x = 0; x < char.width; x++) {
                     editGrid[y][x] = char.pixels[y] ? char.pixels[y][x] : false;
                 }
             }
             
             // Create grid
             for (let y = 0; y < fontHeight; y++) {
                 const row = document.createElement('div');
                 row.style.display = 'flex';
                 row.style.height = '20px';
                 
                 for (let x = 0; x < char.width; x++) {
                     const cell = document.createElement('div');
                     cell.style.width = '20px';
                     cell.style.height = '20px';
                     cell.style.border = '1px solid #444';
                     cell.style.cursor = 'pointer';
                     cell.style.backgroundColor = editGrid[y][x] ? '#96ceff' : '#000';
                     
                     cell.onclick = () => togglePixel(x, y);
                     row.appendChild(cell);
                 }
                 editorDiv.appendChild(row);
             }
         }
         
         function togglePixel(x, y) {
             // If character doesn't exist or isn't drawable, create it first
             let char = fontData.characters[currentEditChar];
             if (!char || !char.isDrawable) {
                 createEmptyCharacter(currentEditChar);
                 char = fontData.characters[currentEditChar];
                 // Recreate the edit grid with the new character
                 createEditGrid();
             }
             
             editGrid[y][x] = !editGrid[y][x];
             
             // Update visual
             const editorDiv = document.getElementById('charEditor');
             const cell = editorDiv.children[y].children[x];
             cell.style.backgroundColor = editGrid[y][x] ? '#96ceff' : '#000';
             
             // Update font data
             updateCharacterFromGrid();
         }
         
         function updateCharacterFromGrid() {
             const char = fontData.characters[currentEditChar];
             
             // Update pixels
             char.pixels = [];
             for (let y = 0; y < fontHeight; y++) {
                 char.pixels[y] = [];
                 for (let x = 0; x < char.width; x++) {
                     char.pixels[y][x] = editGrid[y][x];
                 }
             }
             
             // Convert to bitmap
             char.bitmapData = pixelsToBitmap(char.pixels, char.width, fontHeight);
             char.byteSize = char.bitmapData.length;
             char.isDrawable = char.bitmapData.some(b => b !== 0);
             
             // Rebuild font array
             rebuildFontArray();
             updateFontDataOutput();
             
             // Update display
             renderText();
         }
         
         function updateCharDimensions() {
             const newWidth = parseInt(document.getElementById('charWidth').value);
             const char = fontData.characters[currentEditChar];
             
             if (newWidth !== char.width) {
                 // Resize character
                 const newPixels = [];
                 for (let y = 0; y < fontHeight; y++) {
                     newPixels[y] = [];
                     for (let x = 0; x < newWidth; x++) {
                         newPixels[y][x] = (x < char.width && char.pixels[y]) ? char.pixels[y][x] : false;
                     }
                 }
                 
                 char.width = newWidth;
                 char.pixels = newPixels;
                 char.bitmapData = pixelsToBitmap(char.pixels, char.width, fontHeight);
                 char.byteSize = char.bitmapData.length;
                 
                 rebuildFontArray();
                 createEditGrid();
                 updateFontDataOutput();
                 renderText();
             }
         }
         
         function createEmptyCharacter(charCode) {
             // Create a new empty character with default width
             const defaultWidth = 8; // Default character width
             const emptyPixels = [];
             
             // Initialize empty pixel array
             for (let y = 0; y < fontHeight; y++) {
                 emptyPixels[y] = [];
                 for (let x = 0; x < defaultWidth; x++) {
                     emptyPixels[y][x] = false;
                 }
             }
             
             // Create the character object
             fontData.characters[charCode] = {
                 width: defaultWidth,
                 byteSize: 0, // Will be calculated when pixels are added
                 bitmapOffset: 0,
                 bitmapData: [],
                 isDrawable: true, // Mark as drawable so it can be edited
                 pixels: emptyPixels
             };
             
             console.log(`Created new empty character ${charCode} (${String.fromCharCode(charCode)}) with width ${defaultWidth}`);
         }
         
         function clearCharacter() {
             const char = fontData.characters[currentEditChar];
             for (let y = 0; y < fontHeight; y++) {
                 for (let x = 0; x < char.width; x++) {
                     editGrid[y][x] = false;
                 }
             }
             updateCharacterFromGrid();
             createEditGrid();
         }
         
         function revertCharacter() {
             // Revert to original
             const originalCharInfo = getCharInfo(currentEditChar);
             if (originalCharInfo && originalCharInfo.byteSize > 0) {
                 const char = fontData.characters[currentEditChar];
                 char.bitmapData = [];
                 for (let i = 0; i < originalCharInfo.byteSize; i++) {
                     char.bitmapData.push(originalFont[originalCharInfo.bitmapOffset + i]);
                 }
                 char.pixels = bitmapToPixels(char.bitmapData, char.width, fontHeight);
                 rebuildFontArray();
                 createEditGrid();
                 updateFontDataOutput();
                 renderText();
             }
         }
         
         function rebuildFontArray() {
             // Rebuild the entire font array with correct offsets
             const JUMPTABLE_START = 4;
             const JUMPTABLE_BYTES = 4;
             const headerSize = 4;
             const jumpTableSize = numChars * JUMPTABLE_BYTES;
             
             // Calculate total size needed
             let totalBitmapSize = 0;
             const charEntries = [];
             
             // First pass: calculate bitmap sizes and prepare entries
             for (let i = 0; i < numChars; i++) {
                 const charCode = firstChar + i;
                 const char = fontData.characters[charCode];
                 
                 charEntries.push({
                     charCode: charCode,
                     width: char.width,
                     bitmapData: char.bitmapData,
                     byteSize: char.bitmapData.length,
                     isDrawable: char.isDrawable,
                     bitmapOffset: totalBitmapSize // Relative offset in bitmap section
                 });
                 
                 if (char.isDrawable) {
                     totalBitmapSize += char.bitmapData.length;
                 }
             }
             
             // Create new font array
             const newFontSize = headerSize + jumpTableSize + totalBitmapSize;
             const newFont = new Uint8Array(newFontSize);
             
             // Write header
             newFont[0] = fontWidth;
             newFont[1] = fontHeight;
             newFont[2] = firstChar;
             newFont[3] = numChars;
             
             // Write jump table
             for (let i = 0; i < numChars; i++) {
                 const entry = charEntries[i];
                 const jumpTableOffset = JUMPTABLE_START + (i * JUMPTABLE_BYTES);
                 
                 if (entry.isDrawable && entry.byteSize > 0) {
                     // Calculate bitmap offset (relative to start of bitmap data)
                     const bitmapOffset = entry.bitmapOffset;
                     
                     // Write jump table entry in little-endian format: [offsetLow, offsetHigh, byteSize, width]
                     newFont[jumpTableOffset] = (bitmapOffset >> 8) & 0xFF;  // MSB of offset (big-endian)
                     newFont[jumpTableOffset + 1] = bitmapOffset & 0xFF;     // LSB of offset (big-endian)
                     newFont[jumpTableOffset + 2] = entry.byteSize;          // Size in bytes
                     newFont[jumpTableOffset + 3] = entry.width;             // Character width
                 } else {
                     // Non-drawable character (like space)
                     newFont[jumpTableOffset] = 0xFF;     // LSB = 255 (little-endian)
                     newFont[jumpTableOffset + 1] = 0xFF; // MSB = 255 (little-endian)
                     newFont[jumpTableOffset + 2] = 0;    // Size = 0
                     newFont[jumpTableOffset + 3] = entry.width; // Width
                 }
             }
             
             // Write bitmap data
             const bitmapDataStartOffset = headerSize + jumpTableSize;
             let currentBitmapOffset = 0;
             
             for (let i = 0; i < numChars; i++) {
                 const entry = charEntries[i];
                 if (entry.isDrawable && entry.bitmapData.length > 0) {
                     // Copy bitmap data
                     for (let j = 0; j < entry.bitmapData.length; j++) {
                         newFont[bitmapDataStartOffset + currentBitmapOffset + j] = entry.bitmapData[j];
                     }
                     currentBitmapOffset += entry.bitmapData.length;
                 }
             }
             
             // Update the current font
             currentFont = newFont;
             
             // Update fontData structure with new offsets
             for (let i = 0; i < numChars; i++) {
                 const entry = charEntries[i];
                 const char = fontData.characters[entry.charCode];
                 
                 if (entry.isDrawable && entry.byteSize > 0) {
                     // Update the absolute bitmap offset in the new font array
                     char.bitmapOffset = bitmapDataStartOffset + entry.bitmapOffset;
                 } else {
                     char.bitmapOffset = 0;
                 }
             }
             
             console.log(`Font rebuilt: ${newFontSize} bytes (header: ${headerSize}, jump table: ${jumpTableSize}, bitmap: ${totalBitmapSize})`);
             
             // Verify a few characters after rebuild
             console.log('Verifying rebuilt font:');
             for (let testChar of [65, 84, 33]) { // A, T, !
                 const info = getCharInfo(testChar);
                 console.log(`  Char ${testChar} ('${String.fromCharCode(testChar)}'): width=${info?.width}, byteSize=${info?.byteSize}, offset=${info?.bitmapOffset}`);
             }
         }
         
         function getCharacterDisplayName(charCode) {
             // Special control characters and common names
             const specialChars = {
                 0: '(NUL)', 1: '(SOH)', 2: '(STX)', 3: '(ETX)', 4: '(EOT)', 5: '(ENQ)', 6: '(ACK)', 7: '(BEL)',
                 8: '(BS)', 9: '(TAB)', 10: '(LF)', 11: '(VT)', 12: '(FF)', 13: '(CR)', 14: '(SO)', 15: '(SI)',
                 16: '(DLE)', 17: '(DC1)', 18: '(DC2)', 19: '(DC3)', 20: '(DC4)', 21: '(NAK)', 22: '(SYN)', 23: '(ETB)',
                 24: '(CAN)', 25: '(EM)', 26: '(SUB)', 27: '(ESC)', 28: '(FS)', 29: '(GS)', 30: '(RS)', 31: '(US)',
                 32: '(SPACE)', 127: '(DEL)',
                 160: '(NBSP)', 173: '(SHY)', 255: '(NBHY)'
             };
             
             // Check for special characters first
             if (specialChars[charCode]) {
                 return specialChars[charCode];
             }
             
             // For printable ASCII (33-126), show the character in quotes
             if (charCode >= 33 && charCode <= 126) {
                 return `('${String.fromCharCode(charCode)}')`;
             }
             
             // For extended ASCII (128-255), try to show the character if it's displayable
             if (charCode >= 128 && charCode <= 255) {
                 try {
                     const char = String.fromCharCode(charCode);
                     // Check if it's a reasonable character (not a control character)
                     if (char && char.trim() !== '' && charCode !== 173) { // 173 is soft hyphen
                         return `('${char}' U+${charCode.toString(16).padStart(4, '0').toUpperCase()})`;
                     }
                 } catch (e) {
                     // Fall through to hex display
                 }
             }
             
             // For everything else, show hex code
             return `(0x${charCode.toString(16).padStart(2, '0').toUpperCase()})`;
         }

         function updateFontDataOutput() {
             // Generate formatted font data with proper structure
             let output = `// Modified font data\nconst ModifiedFont = new Uint8Array([\n`;
             output += `    // Header: width=${fontWidth}, height=${fontHeight}, firstChar=${firstChar}, numChars=${numChars}\n`;
             output += `    ${fontWidth}, ${fontHeight}, ${firstChar}, ${numChars},\n\n`;
             
             // Calculate offsets for jump table
             let bitmapOffset = 0;
             const jumpTableEntries = [];
             
             for (let i = 0; i < numChars; i++) {
                 const charCode = firstChar + i;
                 const char = fontData.characters[charCode];
                 
                 if (char.isDrawable && char.bitmapData.length > 0) {
                     jumpTableEntries.push({
                         offsetHigh: (bitmapOffset >> 8) & 0xFF,
                         offsetLow: bitmapOffset & 0xFF,
                         byteSize: char.bitmapData.length,
                         width: char.width,
                         charCode: charCode
                     });
                     bitmapOffset += char.bitmapData.length;
                 } else {
                     // Non-drawable character
                     jumpTableEntries.push({
                         offsetLow: 0xFF,
                         offsetHigh: 0xFF,
                         byteSize: 0,
                         width: char.width,
                         charCode: charCode
                     });
                 }
             }
             
             // Output jump table
             output += `    // Jump table (${numChars} entries of 4 bytes each: offsetLow, offsetHigh, byteSize, width)\n`;
             for (let i = 0; i < jumpTableEntries.length; i++) {
                 const entry = jumpTableEntries[i];
                 const charDisplay = getCharacterDisplayName(entry.charCode);
                 
                 output += `    0x${entry.offsetHigh.toString(16).padStart(2, '0')}, 0x${entry.offsetLow.toString(16).padStart(2, '0')}, `;
                 output += `0x${entry.byteSize.toString(16).padStart(2, '0')}, 0x${entry.width.toString(16).padStart(2, '0')}, `;
                 output += `// ${entry.charCode} ${charDisplay}\n`;
                 
                 // Add spacing every 8 entries for readability
                 if ((i + 1) % 8 === 0 && i < jumpTableEntries.length - 1) {
                     output += `\n`;
                 }
             }
             
             output += `\n    // Character bitmap data\n`;
             
             // Output bitmap data
             for (let charCode = firstChar; charCode < firstChar + numChars; charCode++) {
                 const char = fontData.characters[charCode];
                 if (char && char.isDrawable && char.bitmapData && char.bitmapData.length > 0) {
                     const charDisplay = getCharacterDisplayName(charCode);
                     output += `    // Char ${charCode} ${charDisplay} - ${char.width}x${fontHeight} pixels, ${char.bitmapData.length} bytes\n`;
                     
                     // Format bitmap data in rows of 8 bytes for readability
                     for (let i = 0; i < char.bitmapData.length; i += 8) {
                         const chunk = char.bitmapData.slice(i, i + 8);
                         // Add null check for each byte in the chunk
                         const validChunk = chunk.filter(b => b !== undefined && b !== null);
                         if (validChunk.length > 0) {
                             output += `    ${validChunk.map(b => '0x' + b.toString(16).padStart(2, '0')).join(', ')}`;
                             if (i + 8 < char.bitmapData.length) {
                                 output += `,\n`;
                             } else {
                                 output += `,\n`;
                             }
                         }
                     }
                     output += `\n`;
                 }
             }
             
             output += `]);\n\n`;
             output += `// Font info:\n`;
             output += `// Total size: ${currentFont.length} bytes\n`;
             output += `// Header: 4 bytes\n`;
             output += `// Jump table: ${numChars * 4} bytes\n`;
             output += `// Bitmap data: ${currentFont.length - 4 - (numChars * 4)} bytes\n`;
             
             document.getElementById('fontDataOutput').value = output;
         }
         
         function copyFontData() {
             const textarea = document.getElementById('fontDataOutput');
             textarea.select();
             document.execCommand('copy');
             alert('Font data copied to clipboard!');
         }
         
         function exportModifiedFont() {
             // Create downloadable file
             const fontData = document.getElementById('fontDataOutput').value;
             const blob = new Blob([fontData], { type: 'text/plain' });
             const url = URL.createObjectURL(blob);
             
             const a = document.createElement('a');
             a.href = url;
             a.download = 'modified_font.js';
             document.body.appendChild(a);
             a.click();
             document.body.removeChild(a);
             URL.revokeObjectURL(url);
         }
         
         // Shift all characters in the font
         function shiftAllCharacters(direction) {
             for (let charCode = firstChar; charCode < firstChar + numChars; charCode++) {
                 if (fontData.characters[charCode] && fontData.characters[charCode].isDrawable) {
                     shiftCharacterPixels(charCode, direction);
                 }
             }
             
             // If we're currently editing a character, update its editGrid
             if (currentEditChar && fontData.characters[currentEditChar]) {
                 const char = fontData.characters[currentEditChar];
                 for (let y = 0; y < fontHeight; y++) {
                     for (let x = 0; x < char.width; x++) {
                         editGrid[y][x] = char.pixels[y][x];
                     }
                 }
             }
             
             // Update everything
             rebuildFontArray(); // Rebuild the font with all shifted characters
             updateFontDataOutput();
             renderText();
             if (currentEditChar) {
                 createEditGrid(); // Refresh the character editor grid
             }
         }
         
         // Shift current character being edited
         function shiftCurrentCharacter(direction) {
             if (currentEditChar && fontData.characters[currentEditChar]) {
                 shiftCharacterPixels(currentEditChar, direction);
                 
                 // Update editGrid to match the shifted pixels
                 const char = fontData.characters[currentEditChar];
                 for (let y = 0; y < fontHeight; y++) {
                     for (let x = 0; x < char.width; x++) {
                         editGrid[y][x] = char.pixels[y][x];
                     }
                 }
                 
                 // Update everything
                 updateCharacterFromGrid(); // This rebuilds font data and renders
                 createEditGrid(); // Refresh the visual editor grid
             }
         }
         
         // Core function to shift pixels in a character
         function shiftCharacterPixels(charCode, direction) {
             const char = fontData.characters[charCode];
             if (!char || !char.isDrawable || !char.pixels) return;
             
             const width = char.width;
             const height = fontHeight;
             const pixels = char.pixels;
             
             let newPixels = [];
             for (let y = 0; y < height; y++) {
                 newPixels[y] = [];
                 for (let x = 0; x < width; x++) {
                     newPixels[y][x] = false;
                 }
             }
             
             // Shift pixels based on direction
             for (let y = 0; y < height; y++) {
                 for (let x = 0; x < width; x++) {
                     if (pixels[y] && pixels[y][x]) {
                         let newX = x, newY = y;
                         
                         switch (direction) {
                             case 'up':
                                 newY = y === 0 ? height - 1 : y - 1; // Wrap around
                                 break;
                             case 'down':
                                 newY = y === height - 1 ? 0 : y + 1; // Wrap around
                                 break;
                             case 'left':
                                 newX = x === 0 ? width - 1 : x - 1; // Wrap around
                                 break;
                             case 'right':
                                 newX = x === width - 1 ? 0 : x + 1; // Wrap around
                                 break;
                         }
                         
                         if (newY >= 0 && newY < height && newX >= 0 && newX < width) {
                             newPixels[newY][newX] = true;
                         }
                     }
                 }
             }
             
             // Update character data
             char.pixels = newPixels;
             char.bitmapData = pixelsToBitmap(newPixels, width, height);
         }

         // Initialize on page load
         window.onload = function() {
             selectFont(ArialMT_Plain_10, 'ArialMT_Plain_10');
             initDisplay();
             renderDisplay();
                          
             // Set default text and render
             document.getElementById('textInput').value = 'ABC abc 123 $€°. The quick brown fox jumps over the lazy dog.';
             renderText();
             
             // Initialize font editor
             initFontEditor();
         };

        // Font data is stored in squix 3.0.0+ format
        const ArialMT_Plain_10 = new Uint8Array([
  0x0A, // Width: 10
  0x0D, // Height: 13
  0x20, // First Char: 32
  0xE0, // Numbers of Chars: 224

  // Jump Table:
  0xFF, 0xFF, 0x00, 0x03,  // 32:65535
  0x00, 0x00, 0x04, 0x03,  // 33:0
  0x00, 0x04, 0x05, 0x04,  // 34:4
  0x00, 0x09, 0x09, 0x06,  // 35:9
  0x00, 0x12, 0x0A, 0x06,  // 36:18
  0x00, 0x1C, 0x10, 0x09,  // 37:28
  0x00, 0x2C, 0x0E, 0x07,  // 38:44
  0x00, 0x3A, 0x01, 0x02,  // 39:58
  0x00, 0x3B, 0x06, 0x03,  // 40:59
  0x00, 0x41, 0x06, 0x03,  // 41:65
  0x00, 0x47, 0x05, 0x04,  // 42:71
  0x00, 0x4C, 0x09, 0x06,  // 43:76
  0x00, 0x55, 0x04, 0x03,  // 44:85
  0x00, 0x59, 0x03, 0x03,  // 45:89
  0x00, 0x5C, 0x04, 0x03,  // 46:92
  0x00, 0x60, 0x05, 0x03,  // 47:96
  0x00, 0x65, 0x0A, 0x06,  // 48:101
  0x00, 0x6F, 0x08, 0x06,  // 49:111
  0x00, 0x77, 0x0A, 0x06,  // 50:119
  0x00, 0x81, 0x0A, 0x06,  // 51:129
  0x00, 0x8B, 0x0B, 0x06,  // 52:139
  0x00, 0x96, 0x0A, 0x06,  // 53:150
  0x00, 0xA0, 0x0A, 0x06,  // 54:160
  0x00, 0xAA, 0x09, 0x06,  // 55:170
  0x00, 0xB3, 0x0A, 0x06,  // 56:179
  0x00, 0xBD, 0x0A, 0x06,  // 57:189
  0x00, 0xC7, 0x04, 0x03,  // 58:199
  0x00, 0xCB, 0x04, 0x03,  // 59:203
  0x00, 0xCF, 0x0A, 0x06,  // 60:207
  0x00, 0xD9, 0x09, 0x06,  // 61:217
  0x00, 0xE2, 0x09, 0x06,  // 62:226
  0x00, 0xEB, 0x0B, 0x06,  // 63:235
  0x00, 0xF6, 0x14, 0x0A,  // 64:246
  0x01, 0x0A, 0x0E, 0x07,  // 65:266
  0x01, 0x18, 0x0C, 0x07,  // 66:280
  0x01, 0x24, 0x0C, 0x07,  // 67:292
  0x01, 0x30, 0x0B, 0x07,  // 68:304
  0x01, 0x3B, 0x0C, 0x07,  // 69:315
  0x01, 0x47, 0x09, 0x06,  // 70:327
  0x01, 0x50, 0x0D, 0x08,  // 71:336
  0x01, 0x5D, 0x0C, 0x07,  // 72:349
  0x01, 0x69, 0x04, 0x03,  // 73:361
  0x01, 0x6D, 0x08, 0x05,  // 74:365
  0x01, 0x75, 0x0E, 0x07,  // 75:373
  0x01, 0x83, 0x0C, 0x06,  // 76:387
  0x01, 0x8F, 0x10, 0x08,  // 77:399
  0x01, 0x9F, 0x0C, 0x07,  // 78:415
  0x01, 0xAB, 0x0E, 0x08,  // 79:427
  0x01, 0xB9, 0x0B, 0x07,  // 80:441
  0x01, 0xC4, 0x0E, 0x08,  // 81:452
  0x01, 0xD2, 0x0C, 0x07,  // 82:466
  0x01, 0xDE, 0x0C, 0x07,  // 83:478
  0x01, 0xEA, 0x0B, 0x06,  // 84:490
  0x01, 0xF5, 0x0C, 0x07,  // 85:501
  0x02, 0x01, 0x0D, 0x07,  // 86:513
  0x02, 0x0E, 0x11, 0x09,  // 87:526
  0x02, 0x1F, 0x0E, 0x07,  // 88:543
  0x02, 0x2D, 0x0D, 0x07,  // 89:557
  0x02, 0x3A, 0x0C, 0x06,  // 90:570
  0x02, 0x46, 0x06, 0x03,  // 91:582
  0x02, 0x4C, 0x06, 0x03,  // 92:588
  0x02, 0x52, 0x04, 0x03,  // 93:594
  0x02, 0x56, 0x09, 0x05,  // 94:598
  0x02, 0x5F, 0x0C, 0x06,  // 95:607
  0x02, 0x6B, 0x03, 0x03,  // 96:619
  0x02, 0x6E, 0x0A, 0x06,  // 97:622
  0x02, 0x78, 0x0A, 0x06,  // 98:632
  0x02, 0x82, 0x0A, 0x05,  // 99:642
  0x02, 0x8C, 0x0A, 0x06,  // 100:652
  0x02, 0x96, 0x0A, 0x06,  // 101:662
  0x02, 0xA0, 0x05, 0x03,  // 102:672
  0x02, 0xA5, 0x0A, 0x06,  // 103:677
  0x02, 0xAF, 0x0A, 0x06,  // 104:687
  0x02, 0xB9, 0x04, 0x02,  // 105:697
  0x02, 0xBD, 0x04, 0x02,  // 106:701
  0x02, 0xC1, 0x08, 0x05,  // 107:705
  0x02, 0xC9, 0x04, 0x02,  // 108:713
  0x02, 0xCD, 0x10, 0x08,  // 109:717
  0x02, 0xDD, 0x0A, 0x06,  // 110:733
  0x02, 0xE7, 0x0A, 0x06,  // 111:743
  0x02, 0xF1, 0x0A, 0x06,  // 112:753
  0x02, 0xFB, 0x0A, 0x06,  // 113:763
  0x03, 0x05, 0x05, 0x03,  // 114:773
  0x03, 0x0A, 0x08, 0x05,  // 115:778
  0x03, 0x12, 0x06, 0x03,  // 116:786
  0x03, 0x18, 0x0A, 0x06,  // 117:792
  0x03, 0x22, 0x09, 0x05,  // 118:802
  0x03, 0x2B, 0x0E, 0x07,  // 119:811
  0x03, 0x39, 0x0A, 0x05,  // 120:825
  0x03, 0x43, 0x09, 0x05,  // 121:835
  0x03, 0x4C, 0x0A, 0x05,  // 122:844
  0x03, 0x56, 0x06, 0x03,  // 123:854
  0x03, 0x5C, 0x04, 0x03,  // 124:860
  0x03, 0x60, 0x05, 0x03,  // 125:864
  0x03, 0x65, 0x09, 0x06,  // 126:869
  0xFF, 0xFF, 0x00, 0x00,  // 127:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 128:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 129:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 130:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 131:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 132:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 133:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 134:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 135:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 136:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 137:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 138:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 139:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 140:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 141:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 142:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 143:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 144:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 145:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 146:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 147:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 148:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 149:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 150:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 151:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 152:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 153:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 154:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 155:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 156:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 157:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 158:65535
  0xFF, 0xFF, 0x00, 0x0A,  // 159:65535
  0xFF, 0xFF, 0x00, 0x03,  // 160:65535
  0x03, 0x6E, 0x04, 0x03,  // 161:878
  0x03, 0x72, 0x0A, 0x06,  // 162:882
  0x03, 0x7C, 0x0C, 0x06,  // 163:892
  0x03, 0x88, 0x0A, 0x06,  // 164:904
  0x03, 0x92, 0x0A, 0x06,  // 165:914
  0x03, 0x9C, 0x04, 0x03,  // 166:924
  0x03, 0xA0, 0x0A, 0x06,  // 167:928
  0x03, 0xAA, 0x05, 0x03,  // 168:938
  0x03, 0xAF, 0x0D, 0x07,  // 169:943
  0x03, 0xBC, 0x07, 0x04,  // 170:956
  0x03, 0xC3, 0x0A, 0x06,  // 171:963
  0x03, 0xCD, 0x09, 0x06,  // 172:973
  0x03, 0xD6, 0x03, 0x03,  // 173:982
  0x03, 0xD9, 0x0D, 0x07,  // 174:985
  0x03, 0xE6, 0x0B, 0x06,  // 175:998
  0x03, 0xF1, 0x07, 0x04,  // 176:1009
  0x03, 0xF8, 0x0A, 0x05,  // 177:1016
  0x04, 0x02, 0x05, 0x03,  // 178:1026
  0x04, 0x07, 0x05, 0x03,  // 179:1031
  0x04, 0x0C, 0x05, 0x03,  // 180:1036
  0x04, 0x11, 0x0A, 0x06,  // 181:1041
  0x04, 0x1B, 0x09, 0x05,  // 182:1051
  0x04, 0x24, 0x03, 0x03,  // 183:1060
  0x04, 0x27, 0x06, 0x03,  // 184:1063
  0x04, 0x2D, 0x05, 0x03,  // 185:1069
  0x04, 0x32, 0x07, 0x04,  // 186:1074
  0x04, 0x39, 0x0A, 0x06,  // 187:1081
  0x04, 0x43, 0x10, 0x08,  // 188:1091
  0x04, 0x53, 0x10, 0x08,  // 189:1107
  0x04, 0x63, 0x10, 0x08,  // 190:1123
  0x04, 0x73, 0x0A, 0x06,  // 191:1139
  0x04, 0x7D, 0x0E, 0x07,  // 192:1149
  0x04, 0x8B, 0x0E, 0x07,  // 193:1163
  0x04, 0x99, 0x0E, 0x07,  // 194:1177
  0x04, 0xA7, 0x0E, 0x07,  // 195:1191
  0x04, 0xB5, 0x0E, 0x07,  // 196:1205
  0x04, 0xC3, 0x0E, 0x07,  // 197:1219
  0x04, 0xD1, 0x12, 0x0A,  // 198:1233
  0x04, 0xE3, 0x0C, 0x07,  // 199:1251
  0x04, 0xEF, 0x0C, 0x07,  // 200:1263
  0x04, 0xFB, 0x0C, 0x07,  // 201:1275
  0x05, 0x07, 0x0C, 0x07,  // 202:1287
  0x05, 0x13, 0x0C, 0x07,  // 203:1299
  0x05, 0x1F, 0x05, 0x03,  // 204:1311
  0x05, 0x24, 0x04, 0x03,  // 205:1316
  0x05, 0x28, 0x04, 0x03,  // 206:1320
  0x05, 0x2C, 0x05, 0x03,  // 207:1324
  0x05, 0x31, 0x0B, 0x07,  // 208:1329
  0x05, 0x3C, 0x0C, 0x07,  // 209:1340
  0x05, 0x48, 0x0E, 0x08,  // 210:1352
  0x05, 0x56, 0x0E, 0x08,  // 211:1366
  0x05, 0x64, 0x0E, 0x08,  // 212:1380
  0x05, 0x72, 0x0E, 0x08,  // 213:1394
  0x05, 0x80, 0x0E, 0x08,  // 214:1408
  0x05, 0x8E, 0x0A, 0x06,  // 215:1422
  0x05, 0x98, 0x0D, 0x08,  // 216:1432
  0x05, 0xA5, 0x0C, 0x07,  // 217:1445
  0x05, 0xB1, 0x0C, 0x07,  // 218:1457
  0x05, 0xBD, 0x0C, 0x07,  // 219:1469
  0x05, 0xC9, 0x0C, 0x07,  // 220:1481
  0x05, 0xD5, 0x0D, 0x07,  // 221:1493
  0x05, 0xE2, 0x0B, 0x07,  // 222:1506
  0x05, 0xED, 0x0C, 0x06,  // 223:1517
  0x05, 0xF9, 0x0A, 0x06,  // 224:1529
  0x06, 0x03, 0x0A, 0x06,  // 225:1539
  0x06, 0x0D, 0x0A, 0x06,  // 226:1549
  0x06, 0x17, 0x0A, 0x06,  // 227:1559
  0x06, 0x21, 0x0A, 0x06,  // 228:1569
  0x06, 0x2B, 0x0A, 0x06,  // 229:1579
  0x06, 0x35, 0x10, 0x09,  // 230:1589
  0x06, 0x45, 0x0A, 0x05,  // 231:1605
  0x06, 0x4F, 0x0A, 0x06,  // 232:1615
  0x06, 0x59, 0x0A, 0x06,  // 233:1625
  0x06, 0x63, 0x0A, 0x06,  // 234:1635
  0x06, 0x6D, 0x0A, 0x06,  // 235:1645
  0x06, 0x77, 0x05, 0x03,  // 236:1655
  0x06, 0x7C, 0x04, 0x03,  // 237:1660
  0x06, 0x80, 0x05, 0x03,  // 238:1664
  0x06, 0x85, 0x05, 0x03,  // 239:1669
  0x06, 0x8A, 0x0A, 0x06,  // 240:1674
  0x06, 0x94, 0x0A, 0x06,  // 241:1684
  0x06, 0x9E, 0x0A, 0x06,  // 242:1694
  0x06, 0xA8, 0x0A, 0x06,  // 243:1704
  0x06, 0xB2, 0x0A, 0x06,  // 244:1714
  0x06, 0xBC, 0x0A, 0x06,  // 245:1724
  0x06, 0xC6, 0x0A, 0x06,  // 246:1734
  0x06, 0xD0, 0x09, 0x05,  // 247:1744
  0x06, 0xD9, 0x0A, 0x06,  // 248:1753
  0x06, 0xE3, 0x0A, 0x06,  // 249:1763
  0x06, 0xED, 0x0A, 0x06,  // 250:1773
  0x06, 0xF7, 0x0A, 0x06,  // 251:1783
  0x07, 0x01, 0x0A, 0x06,  // 252:1793
  0x07, 0x0B, 0x09, 0x05,  // 253:1803
  0x07, 0x14, 0x0A, 0x06,  // 254:1812
  0x07, 0x1E, 0x09, 0x05,  // 255:1822

  // Font Data:
  0x00,0x00,0xF8,0x02,  // 33
  0x38,0x00,0x00,0x00,0x38, // 34
  0xA0,0x03,0xE0,0x00,0xB8,0x03,0xE0,0x00,0xB8, // 35
  0x30,0x01,0x28,0x02,0xF8,0x07,0x48,0x02,0x90,0x01,  // 36
  0x00,0x00,0x30,0x00,0x48,0x00,0x30,0x03,0xC0,0x00,0xB0,0x01,0x48,0x02,0x80,0x01,  // 37
  0x80,0x01,0x50,0x02,0x68,0x02,0xA8,0x02,0x18,0x01,0x80,0x03,0x80,0x02,  // 38
  0x38, // 39
  0xE0,0x03,0x10,0x04,0x08,0x08,  // 40
  0x08,0x08,0x10,0x04,0xE0,0x03,  // 41
  0x28,0x00,0x18,0x00,0x28, // 42
  0x40,0x00,0x40,0x00,0xF0,0x01,0x40,0x00,0x40, // 43
  0x00,0x00,0x00,0x06,  // 44
  0x80,0x00,0x80, // 45
  0x00,0x00,0x00,0x02,  // 46
  0x00,0x03,0xE0,0x00,0x18, // 47
  0xF0,0x01,0x08,0x02,0x08,0x02,0x08,0x02,0xF0,0x01,  // 48
  0x00,0x00,0x20,0x00,0x10,0x00,0xF8,0x03,  // 49
  0x10,0x02,0x08,0x03,0x88,0x02,0x48,0x02,0x30,0x02,  // 50
  0x10,0x01,0x08,0x02,0x48,0x02,0x48,0x02,0xB0,0x01,  // 51
  0xC0,0x00,0xA0,0x00,0x90,0x00,0x88,0x00,0xF8,0x03,0x80, // 52
  0x60,0x01,0x38,0x02,0x28,0x02,0x28,0x02,0xC8,0x01,  // 53
  0xF0,0x01,0x28,0x02,0x28,0x02,0x28,0x02,0xD0,0x01,  // 54
  0x08,0x00,0x08,0x03,0xC8,0x00,0x38,0x00,0x08, // 55
  0xB0,0x01,0x48,0x02,0x48,0x02,0x48,0x02,0xB0,0x01,  // 56
  0x70,0x01,0x88,0x02,0x88,0x02,0x88,0x02,0xF0,0x01,  // 57
  0x00,0x00,0x20,0x02,  // 58
  0x00,0x00,0x20,0x06,  // 59
  0x00,0x00,0x40,0x00,0xA0,0x00,0xA0,0x00,0x10,0x01,  // 60
  0xA0,0x00,0xA0,0x00,0xA0,0x00,0xA0,0x00,0xA0, // 61
  0x00,0x00,0x10,0x01,0xA0,0x00,0xA0,0x00,0x40, // 62
  0x10,0x00,0x08,0x00,0x08,0x00,0xC8,0x02,0x48,0x00,0x30, // 63
  0x00,0x00,0xC0,0x03,0x30,0x04,0xD0,0x09,0x28,0x0A,0x28,0x0A,0xC8,0x0B,0x68,0x0A,0x10,0x05,0xE0,0x04,  // 64
  0x00,0x02,0xC0,0x01,0xB0,0x00,0x88,0x00,0xB0,0x00,0xC0,0x01,0x00,0x02,  // 65
  0x00,0x00,0xF8,0x03,0x48,0x02,0x48,0x02,0x48,0x02,0xF0,0x01,  // 66
  0x00,0x00,0xF0,0x01,0x08,0x02,0x08,0x02,0x08,0x02,0x10,0x01,  // 67
  0x00,0x00,0xF8,0x03,0x08,0x02,0x08,0x02,0x10,0x01,0xE0, // 68
  0x00,0x00,0xF8,0x03,0x48,0x02,0x48,0x02,0x48,0x02,0x48,0x02,  // 69
  0x00,0x00,0xF8,0x03,0x48,0x00,0x48,0x00,0x08, // 70
  0x00,0x00,0xE0,0x00,0x10,0x01,0x08,0x02,0x48,0x02,0x50,0x01,0xC0, // 71
  0x00,0x00,0xF8,0x03,0x40,0x00,0x40,0x00,0x40,0x00,0xF8,0x03,  // 72
  0x00,0x00,0xF8,0x03,  // 73
  0x00,0x03,0x00,0x02,0x00,0x02,0xF8,0x01,  // 74
  0x00,0x00,0xF8,0x03,0x80,0x00,0x60,0x00,0x90,0x00,0x08,0x01,0x00,0x02,  // 75
  0x00,0x00,0xF8,0x03,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,  // 76
  0x00,0x00,0xF8,0x03,0x30,0x00,0xC0,0x01,0x00,0x02,0xC0,0x01,0x30,0x00,0xF8,0x03,  // 77
  0x00,0x00,0xF8,0x03,0x30,0x00,0x40,0x00,0x80,0x01,0xF8,0x03,  // 78
  0x00,0x00,0xF0,0x01,0x08,0x02,0x08,0x02,0x08,0x02,0x08,0x02,0xF0,0x01,  // 79
  0x00,0x00,0xF8,0x03,0x48,0x00,0x48,0x00,0x48,0x00,0x30, // 80
  0x00,0x00,0xF0,0x01,0x08,0x02,0x08,0x02,0x08,0x03,0x08,0x03,0xF0,0x02,  // 81
  0x00,0x00,0xF8,0x03,0x48,0x00,0x48,0x00,0xC8,0x00,0x30,0x03,  // 82
  0x00,0x00,0x30,0x01,0x48,0x02,0x48,0x02,0x48,0x02,0x90,0x01,  // 83
  0x00,0x00,0x08,0x00,0x08,0x00,0xF8,0x03,0x08,0x00,0x08, // 84
  0x00,0x00,0xF8,0x01,0x00,0x02,0x00,0x02,0x00,0x02,0xF8,0x01,  // 85
  0x08,0x00,0x70,0x00,0x80,0x01,0x00,0x02,0x80,0x01,0x70,0x00,0x08, // 86
  0x18,0x00,0xE0,0x01,0x00,0x02,0xF0,0x01,0x08,0x00,0xF0,0x01,0x00,0x02,0xE0,0x01,0x18, // 87
  0x00,0x02,0x08,0x01,0x90,0x00,0x60,0x00,0x90,0x00,0x08,0x01,0x00,0x02,  // 88
  0x08,0x00,0x10,0x00,0x20,0x00,0xC0,0x03,0x20,0x00,0x10,0x00,0x08, // 89
  0x08,0x03,0x88,0x02,0xC8,0x02,0x68,0x02,0x38,0x02,0x18,0x02,  // 90
  0x00,0x00,0xF8,0x0F,0x08,0x08,  // 91
  0x18,0x00,0xE0,0x00,0x00,0x03,  // 92
  0x08,0x08,0xF8,0x0F,  // 93
  0x40,0x00,0x30,0x00,0x08,0x00,0x30,0x00,0x40, // 94
  0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,  // 95
  0x08,0x00,0x10, // 96
  0x00,0x00,0x00,0x03,0xA0,0x02,0xA0,0x02,0xE0,0x03,  // 97
  0x00,0x00,0xF8,0x03,0x20,0x02,0x20,0x02,0xC0,0x01,  // 98
  0x00,0x00,0xC0,0x01,0x20,0x02,0x20,0x02,0x40,0x01,  // 99
  0x00,0x00,0xC0,0x01,0x20,0x02,0x20,0x02,0xF8,0x03,  // 100
  0x00,0x00,0xC0,0x01,0xA0,0x02,0xA0,0x02,0xC0,0x02,  // 101
  0x20,0x00,0xF0,0x03,0x28, // 102
  0x00,0x00,0xC0,0x05,0x20,0x0A,0x20,0x0A,0xE0,0x07,  // 103
  0x00,0x00,0xF8,0x03,0x20,0x00,0x20,0x00,0xC0,0x03,  // 104
  0x00,0x00,0xE8,0x03,  // 105
  0x00,0x08,0xE8,0x07,  // 106
  0xF8,0x03,0x80,0x00,0xC0,0x01,0x20,0x02,  // 107
  0x00,0x00,0xF8,0x03,  // 108
  0x00,0x00,0xE0,0x03,0x20,0x00,0x20,0x00,0xE0,0x03,0x20,0x00,0x20,0x00,0xC0,0x03,  // 109
  0x00,0x00,0xE0,0x03,0x20,0x00,0x20,0x00,0xC0,0x03,  // 110
  0x00,0x00,0xC0,0x01,0x20,0x02,0x20,0x02,0xC0,0x01,  // 111
  0x00,0x00,0xE0,0x0F,0x20,0x02,0x20,0x02,0xC0,0x01,  // 112
  0x00,0x00,0xC0,0x01,0x20,0x02,0x20,0x02,0xE0,0x0F,  // 113
  0x00,0x00,0xE0,0x03,0x20, // 114
  0x40,0x02,0xA0,0x02,0xA0,0x02,0x20,0x01,  // 115
  0x20,0x00,0xF8,0x03,0x20,0x02,  // 116
  0x00,0x00,0xE0,0x01,0x00,0x02,0x00,0x02,0xE0,0x03,  // 117
  0x20,0x00,0xC0,0x01,0x00,0x02,0xC0,0x01,0x20, // 118
  0xE0,0x01,0x00,0x02,0xC0,0x01,0x20,0x00,0xC0,0x01,0x00,0x02,0xE0,0x01,  // 119
  0x20,0x02,0x40,0x01,0x80,0x00,0x40,0x01,0x20,0x02,  // 120
  0x20,0x00,0xC0,0x09,0x00,0x06,0xC0,0x01,0x20, // 121
  0x20,0x02,0x20,0x03,0xA0,0x02,0x60,0x02,0x20,0x02,  // 122
  0x80,0x00,0x78,0x0F,0x08,0x08,  // 123
  0x00,0x00,0xF8,0x0F,  // 124
  0x08,0x08,0x78,0x0F,0x80, // 125
  0xC0,0x00,0x40,0x00,0xC0,0x00,0x80,0x00,0xC0, // 126
  0x00,0x00,0xA0,0x0F,  // 161
  0x00,0x00,0xC0,0x01,0xA0,0x0F,0x78,0x02,0x40,0x01,  // 162
  0x40,0x02,0x70,0x03,0xC8,0x02,0x48,0x02,0x08,0x02,0x10,0x02,  // 163
  0x00,0x00,0xE0,0x01,0x20,0x01,0x20,0x01,0xE0,0x01,  // 164
  0x48,0x01,0x70,0x01,0xC0,0x03,0x70,0x01,0x48,0x01,  // 165
  0x00,0x00,0x38,0x0F,  // 166
  0xD0,0x04,0x28,0x09,0x48,0x09,0x48,0x0A,0x90,0x05,  // 167
  0x08,0x00,0x00,0x00,0x08, // 168
  0xE0,0x00,0x10,0x01,0x48,0x02,0xA8,0x02,0xA8,0x02,0x10,0x01,0xE0, // 169
  0x68,0x00,0x68,0x00,0x68,0x00,0x78, // 170
  0x00,0x00,0x80,0x01,0x40,0x02,0x80,0x01,0x40,0x02,  // 171
  0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0xE0, // 172
  0x80,0x00,0x80, // 173
  0xE0,0x00,0x10,0x01,0xE8,0x02,0x68,0x02,0xC8,0x02,0x10,0x01,0xE0, // 174
  0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02, // 175
  0x00,0x00,0x38,0x00,0x28,0x00,0x38, // 176
  0x40,0x02,0x40,0x02,0xF0,0x03,0x40,0x02,0x40,0x02,  // 177
  0x48,0x00,0x68,0x00,0x58, // 178
  0x48,0x00,0x58,0x00,0x68, // 179
  0x00,0x00,0x10,0x00,0x08, // 180
  0x00,0x00,0xE0,0x0F,0x00,0x02,0x00,0x02,0xE0,0x03,  // 181
  0x70,0x00,0xF8,0x0F,0x08,0x00,0xF8,0x0F,0x08, // 182
  0x00,0x00,0x40, // 183
  0x00,0x00,0x00,0x14,0x00,0x18,  // 184
  0x00,0x00,0x10,0x00,0x78, // 185
  0x30,0x00,0x48,0x00,0x48,0x00,0x30, // 186
  0x00,0x00,0x40,0x02,0x80,0x01,0x40,0x02,0x80,0x01,  // 187
  0x00,0x00,0x10,0x02,0x78,0x01,0xC0,0x00,0x20,0x01,0x90,0x01,0xC8,0x03,0x00,0x01,  // 188
  0x00,0x00,0x10,0x02,0x78,0x01,0x80,0x00,0x60,0x00,0x50,0x02,0x48,0x03,0xC0,0x02,  // 189
  0x48,0x00,0x58,0x00,0x68,0x03,0x80,0x00,0x60,0x01,0x90,0x01,0xC8,0x03,0x00,0x01,  // 190
  0x00,0x00,0x00,0x06,0x00,0x09,0xA0,0x09,0x00,0x04,  // 191
  0x00,0x02,0xC0,0x01,0xB0,0x00,0x89,0x00,0xB2,0x00,0xC0,0x01,0x00,0x02,  // 192
  0x00,0x02,0xC0,0x01,0xB0,0x00,0x8A,0x00,0xB1,0x00,0xC0,0x01,0x00,0x02,  // 193
  0x00,0x02,0xC0,0x01,0xB2,0x00,0x89,0x00,0xB2,0x00,0xC0,0x01,0x00,0x02,  // 194
  0x00,0x02,0xC2,0x01,0xB1,0x00,0x8A,0x00,0xB1,0x00,0xC0,0x01,0x00,0x02,  // 195
  0x00,0x02,0xC0,0x01,0xB2,0x00,0x88,0x00,0xB2,0x00,0xC0,0x01,0x00,0x02,  // 196
  0x00,0x02,0xC0,0x01,0xBE,0x00,0x8A,0x00,0xBE,0x00,0xC0,0x01,0x00,0x02,  // 197
  0x00,0x03,0xC0,0x00,0xE0,0x00,0x98,0x00,0x88,0x00,0xF8,0x03,0x48,0x02,0x48,0x02,0x48,0x02,  // 198
  0x00,0x00,0xF0,0x01,0x08,0x02,0x08,0x16,0x08,0x1A,0x10,0x01,  // 199
  0x00,0x00,0xF8,0x03,0x49,0x02,0x4A,0x02,0x48,0x02,0x48,0x02,  // 200
  0x00,0x00,0xF8,0x03,0x48,0x02,0x4A,0x02,0x49,0x02,0x48,0x02,  // 201
  0x00,0x00,0xFA,0x03,0x49,0x02,0x4A,0x02,0x48,0x02,0x48,0x02,  // 202
  0x00,0x00,0xF8,0x03,0x4A,0x02,0x48,0x02,0x4A,0x02,0x48,0x02,  // 203
  0x00,0x00,0xF9,0x03,0x02, // 204
  0x02,0x00,0xF9,0x03,  // 205
  0x01,0x00,0xFA,0x03,  // 206
  0x02,0x00,0xF8,0x03,0x02, // 207
  0x40,0x00,0xF8,0x03,0x48,0x02,0x48,0x02,0x10,0x01,0xE0, // 208
  0x00,0x00,0xFA,0x03,0x31,0x00,0x42,0x00,0x81,0x01,0xF8,0x03,  // 209
  0x00,0x00,0xF0,0x01,0x08,0x02,0x09,0x02,0x0A,0x02,0x08,0x02,0xF0,0x01,  // 210
  0x00,0x00,0xF0,0x01,0x08,0x02,0x0A,0x02,0x09,0x02,0x08,0x02,0xF0,0x01,  // 211
  0x00,0x00,0xF0,0x01,0x08,0x02,0x0A,0x02,0x09,0x02,0x0A,0x02,0xF0,0x01,  // 212
  0x00,0x00,0xF0,0x01,0x0A,0x02,0x09,0x02,0x0A,0x02,0x09,0x02,0xF0,0x01,  // 213
  0x00,0x00,0xF0,0x01,0x0A,0x02,0x08,0x02,0x0A,0x02,0x08,0x02,0xF0,0x01,  // 214
  0x10,0x01,0xA0,0x00,0xE0,0x00,0xA0,0x00,0x10,0x01,  // 215
  0x00,0x00,0xF0,0x02,0x08,0x03,0xC8,0x02,0x28,0x02,0x18,0x03,0xE8, // 216
  0x00,0x00,0xF8,0x01,0x01,0x02,0x02,0x02,0x00,0x02,0xF8,0x01,  // 217
  0x00,0x00,0xF8,0x01,0x02,0x02,0x01,0x02,0x00,0x02,0xF8,0x01,  // 218
  0x00,0x00,0xF8,0x01,0x02,0x02,0x01,0x02,0x02,0x02,0xF8,0x01,  // 219
  0x00,0x00,0xF8,0x01,0x02,0x02,0x00,0x02,0x02,0x02,0xF8,0x01,  // 220
  0x08,0x00,0x10,0x00,0x20,0x00,0xC2,0x03,0x21,0x00,0x10,0x00,0x08, // 221
  0x00,0x00,0xF8,0x03,0x10,0x01,0x10,0x01,0x10,0x01,0xE0, // 222
  0x00,0x00,0xF0,0x03,0x08,0x01,0x48,0x02,0xB0,0x02,0x80,0x01,  // 223
  0x00,0x00,0x00,0x03,0xA4,0x02,0xA8,0x02,0xE0,0x03,  // 224
  0x00,0x00,0x00,0x03,0xA8,0x02,0xA4,0x02,0xE0,0x03,  // 225
  0x00,0x00,0x00,0x03,0xA8,0x02,0xA4,0x02,0xE8,0x03,  // 226
  0x00,0x00,0x08,0x03,0xA4,0x02,0xA8,0x02,0xE4,0x03,  // 227
  0x00,0x00,0x00,0x03,0xA8,0x02,0xA0,0x02,0xE8,0x03,  // 228
  0x00,0x00,0x00,0x03,0xAE,0x02,0xAA,0x02,0xEE,0x03,  // 229
  0x00,0x00,0x40,0x03,0xA0,0x02,0xA0,0x02,0xC0,0x01,0xA0,0x02,0xA0,0x02,0xC0,0x02,  // 230
  0x00,0x00,0xC0,0x01,0x20,0x16,0x20,0x1A,0x40,0x01,  // 231
  0x00,0x00,0xC0,0x01,0xA4,0x02,0xA8,0x02,0xC0,0x02,  // 232
  0x00,0x00,0xC0,0x01,0xA8,0x02,0xA4,0x02,0xC0,0x02,  // 233
  0x00,0x00,0xC0,0x01,0xA8,0x02,0xA4,0x02,0xC8,0x02,  // 234
  0x00,0x00,0xC0,0x01,0xA8,0x02,0xA0,0x02,0xC8,0x02,  // 235
  0x00,0x00,0xE4,0x03,0x08, // 236
  0x08,0x00,0xE4,0x03,  // 237
  0x08,0x00,0xE4,0x03,0x08, // 238
  0x08,0x00,0xE0,0x03,0x08, // 239
  0x00,0x00,0xC0,0x01,0x28,0x02,0x38,0x02,0xE0,0x01,  // 240
  0x00,0x00,0xE8,0x03,0x24,0x00,0x28,0x00,0xC4,0x03,  // 241
  0x00,0x00,0xC0,0x01,0x24,0x02,0x28,0x02,0xC0,0x01,  // 242
  0x00,0x00,0xC0,0x01,0x28,0x02,0x24,0x02,0xC0,0x01,  // 243
  0x00,0x00,0xC0,0x01,0x28,0x02,0x24,0x02,0xC8,0x01,  // 244
  0x00,0x00,0xC8,0x01,0x24,0x02,0x28,0x02,0xC4,0x01,  // 245
  0x00,0x00,0xC0,0x01,0x28,0x02,0x20,0x02,0xC8,0x01,  // 246
  0x40,0x00,0x40,0x00,0x50,0x01,0x40,0x00,0x40, // 247
  0x00,0x00,0xC0,0x02,0xA0,0x03,0x60,0x02,0xA0,0x01,  // 248
  0x00,0x00,0xE0,0x01,0x04,0x02,0x08,0x02,0xE0,0x03,  // 249
  0x00,0x00,0xE0,0x01,0x08,0x02,0x04,0x02,0xE0,0x03,  // 250
  0x00,0x00,0xE8,0x01,0x04,0x02,0x08,0x02,0xE0,0x03,  // 251
  0x00,0x00,0xE0,0x01,0x08,0x02,0x00,0x02,0xE8,0x03,  // 252
  0x20,0x00,0xC0,0x09,0x08,0x06,0xC4,0x01,0x20, // 253
  0x00,0x00,0xF8,0x0F,0x20,0x02,0x20,0x02,0xC0,0x01,  // 254
  0x20,0x00,0xC8,0x09,0x00,0x06,0xC8,0x01,0x20  // 255            
        ]);
        const Custom_font_10 = new Uint8Array([
    // Header: width=7, height=13, firstChar=32, numChars=224
    7, 13, 32, 224,

    // Jump table (224 entries of 4 bytes each: offsetLow, offsetHigh, byteSize, width)
    0xff, 0xff, 0x00, 0x01, // 32 (' ')
    0x00, 0x00, 0x06, 0x03, // 33 ('!')
    0x00, 0x06, 0x08, 0x04, // 34 ('"')
    0x00, 0x0e, 0x0c, 0x06, // 35 ('#')
    0x00, 0x1a, 0x0c, 0x06, // 36 ('$')
    0x00, 0x26, 0x0e, 0x07, // 37 ('%')
    0x00, 0x34, 0x0a, 0x05, // 38 ('&')
    0x00, 0x3e, 0x04, 0x02, // 39 (''')

    0x00, 0x42, 0x08, 0x04, // 40 ('(')
    0x00, 0x4a, 0x08, 0x04, // 41 (')')
    0x00, 0x52, 0x08, 0x04, // 42 ('*')
    0x00, 0x5a, 0x06, 0x03, // 43 ('+')
    0x00, 0x60, 0x06, 0x03, // 44 (',')
    0x00, 0x66, 0x08, 0x04, // 45 ('-')
    0x00, 0x6e, 0x04, 0x02, // 46 ('.')
    0x00, 0x72, 0x0a, 0x05, // 47 ('/')

    0x00, 0x7c, 0x0c, 0x06, // 48 ('0')
    0x00, 0x88, 0x08, 0x04, // 49 ('1')
    0x00, 0x90, 0x0a, 0x05, // 50 ('2')
    0x00, 0x9a, 0x0a, 0x05, // 51 ('3')
    0x00, 0xa4, 0x0c, 0x06, // 52 ('4')
    0x00, 0xb0, 0x0a, 0x05, // 53 ('5')
    0x00, 0xba, 0x0a, 0x05, // 54 ('6')
    0x00, 0xc4, 0x0a, 0x05, // 55 ('7')

    0x00, 0xce, 0x0a, 0x05, // 56 ('8')
    0x00, 0xd8, 0x0a, 0x05, // 57 ('9')
    0x00, 0xe2, 0x02, 0x01, // 58 (':')
    0x00, 0xe4, 0x04, 0x02, // 59 (';')
    0x00, 0xe8, 0x08, 0x04, // 60 ('<')
    0x00, 0xf0, 0x0a, 0x05, // 61 ('=')
    0x00, 0xfa, 0x08, 0x04, // 62 ('>')
    0x01, 0x02, 0x0a, 0x05, // 63 ('?')

    0x01, 0x0c, 0x0c, 0x06, // 64 ('@')
    0x01, 0x18, 0x0a, 0x05, // 65 ('A')
    0x01, 0x22, 0x0a, 0x05, // 66 ('B')
    0x01, 0x2c, 0x0a, 0x05, // 67 ('C')
    0x01, 0x36, 0x0a, 0x05, // 68 ('D')
    0x01, 0x40, 0x0a, 0x05, // 69 ('E')
    0x01, 0x4a, 0x08, 0x04, // 70 ('F')
    0x01, 0x52, 0x0c, 0x06, // 71 ('G')

    0x01, 0x5e, 0x0a, 0x05, // 72 ('H')
    0x01, 0x68, 0x06, 0x03, // 73 ('I')
    0x01, 0x6e, 0x08, 0x04, // 74 ('J')
    0x01, 0x76, 0x0a, 0x05, // 75 ('K')
    0x01, 0x80, 0x08, 0x04, // 76 ('L')
    0x01, 0x88, 0x0e, 0x07, // 77 ('M')
    0x01, 0x96, 0x0c, 0x06, // 78 ('N')
    0x01, 0xa2, 0x0a, 0x05, // 79 ('O')

    0x01, 0xac, 0x08, 0x04, // 80 ('P')
    0x01, 0xb4, 0x0a, 0x05, // 81 ('Q')
    0x01, 0xbe, 0x0a, 0x05, // 82 ('R')
    0x01, 0xc8, 0x08, 0x04, // 83 ('S')
    0x01, 0xd0, 0x08, 0x04, // 84 ('T')
    0x01, 0xd8, 0x0a, 0x05, // 85 ('U')
    0x01, 0xe2, 0x0a, 0x05, // 86 ('V')
    0x01, 0xec, 0x0e, 0x07, // 87 ('W')

    0x01, 0xfa, 0x0c, 0x06, // 88 ('X')
    0x02, 0x06, 0x0a, 0x05, // 89 ('Y')
    0x02, 0x10, 0x08, 0x04, // 90 ('Z')
    0x02, 0x18, 0x08, 0x04, // 91 ('[')
    0x02, 0x20, 0x0a, 0x05, // 92 ('\')
    0x02, 0x2a, 0x08, 0x04, // 93 (']')
    0x02, 0x32, 0x0c, 0x06, // 94 ('^')
    0x02, 0x3e, 0x08, 0x04, // 95 ('_')

    0x02, 0x46, 0x08, 0x04, // 96 ('`')
    0x02, 0x4e, 0x0c, 0x06, // 97 ('a')
    0x02, 0x5a, 0x0a, 0x05, // 98 ('b')
    0x02, 0x64, 0x08, 0x04, // 99 ('c')
    0x02, 0x6c, 0x0a, 0x05, // 100 ('d')
    0x02, 0x76, 0x0a, 0x05, // 101 ('e')
    0x02, 0x80, 0x0a, 0x05, // 102 ('f')
    0x02, 0x8a, 0x0a, 0x05, // 103 ('g')

    0x02, 0x94, 0x0a, 0x05, // 104 ('h')
    0x02, 0x9e, 0x06, 0x03, // 105 ('i')
    0x02, 0xa4, 0x06, 0x03, // 106 ('j')
    0x02, 0xaa, 0x0a, 0x05, // 107 ('k')
    0x02, 0xb4, 0x06, 0x03, // 108 ('l')
    0x02, 0xba, 0x10, 0x08, // 109 ('m')
    0x02, 0xca, 0x0c, 0x06, // 110 ('n')
    0x02, 0xd6, 0x0a, 0x05, // 111 ('o')

    0x02, 0xe0, 0x0a, 0x05, // 112 ('p')
    0x02, 0xea, 0x0a, 0x05, // 113 ('q')
    0x02, 0xf4, 0x08, 0x04, // 114 ('r')
    0x02, 0xfc, 0x08, 0x04, // 115 ('s')
    0x03, 0x04, 0x0a, 0x05, // 116 ('t')
    0x03, 0x0e, 0x0a, 0x05, // 117 ('u')
    0x03, 0x18, 0x0a, 0x05, // 118 ('v')
    0x03, 0x22, 0x0e, 0x07, // 119 ('w')

    0x03, 0x30, 0x0a, 0x05, // 120 ('x')
    0x03, 0x3a, 0x0a, 0x05, // 121 ('y')
    0x03, 0x44, 0x0a, 0x05, // 122 ('z')
    0x03, 0x4e, 0x08, 0x04, // 123 ('{')
    0x03, 0x56, 0x0a, 0x05, // 124 ('|')
    0x03, 0x60, 0x08, 0x04, // 125 ('}')
    0x03, 0x68, 0x08, 0x04, // 126 ('~')
    0x03, 0x70, 0x08, 0x05, // 127 ('?')

    0x03, 0x78, 0x08, 0x05, // 128 ('?')
    0x03, 0x80, 0x08, 0x05, // 129 ('?')
    0x03, 0x88, 0x08, 0x05, // 130 ('?')
    0x03, 0x90, 0x08, 0x05, // 131 ('?')
    0x03, 0x98, 0x08, 0x05, // 132 ('?')
    0x03, 0xa0, 0x08, 0x05, // 133 ('?')
    0x03, 0xa8, 0x08, 0x05, // 134 ('?')
    0x03, 0xb0, 0x08, 0x05, // 135 ('?')

    0x03, 0xb8, 0x08, 0x05, // 136 ('?')
    0x03, 0xc0, 0x08, 0x05, // 137 ('?')
    0x03, 0xc8, 0x08, 0x05, // 138 ('?')
    0x03, 0xd0, 0x08, 0x05, // 139 ('?')
    0x03, 0xd8, 0x08, 0x05, // 140 ('?')
    0x03, 0xe0, 0x08, 0x05, // 141 ('?')
    0x03, 0xe8, 0x08, 0x05, // 142 ('?')
    0x03, 0xf0, 0x08, 0x05, // 143 ('?')

    0x03, 0xf8, 0x08, 0x05, // 144 ('?')
    0x04, 0x00, 0x08, 0x05, // 145 ('?')
    0x04, 0x08, 0x08, 0x05, // 146 ('?')
    0x04, 0x10, 0x08, 0x05, // 147 ('?')
    0x04, 0x18, 0x08, 0x05, // 148 ('?')
    0x04, 0x20, 0x08, 0x05, // 149 ('?')
    0x04, 0x28, 0x08, 0x05, // 150 ('?')
    0x04, 0x30, 0x08, 0x05, // 151 ('?')

    0x04, 0x38, 0x08, 0x05, // 152 ('?')
    0x04, 0x40, 0x08, 0x05, // 153 ('?')
    0x04, 0x48, 0x08, 0x05, // 154 ('?')
    0x04, 0x50, 0x08, 0x05, // 155 ('?')
    0x04, 0x58, 0x08, 0x05, // 156 ('?')
    0x04, 0x60, 0x08, 0x05, // 157 ('?')
    0x04, 0x68, 0x08, 0x05, // 158 ('?')
    0x04, 0x70, 0x08, 0x05, // 159 ('?')

    0xff, 0xff, 0x00, 0x02, // 160 ('?')
    0x04, 0x78, 0x04, 0x02, // 161 ('?')
    0x04, 0x7c, 0x06, 0x04, // 162 ('?')
    0x04, 0x82, 0x08, 0x04, // 163 ('?')
    0x04, 0x8a, 0x0a, 0x05, // 164 ('?')
    0x04, 0x94, 0x08, 0x04, // 165 ('?')
    0x04, 0x9c, 0x06, 0x05, // 166 ('?')
    0x04, 0xa2, 0x08, 0x04, // 167 ('?')

    0x04, 0xaa, 0x07, 0x05, // 168 ('?')
    0x04, 0xb1, 0x0d, 0x07, // 169 ('?')
    0x04, 0xbe, 0x05, 0x03, // 170 ('?')
    0x04, 0xc3, 0x0a, 0x05, // 171 ('?')
    0x04, 0xcd, 0x08, 0x04, // 172 ('?')
    0x04, 0xd5, 0x05, 0x03, // 173 ('?')
    0x04, 0xda, 0x0d, 0x07, // 174 ('?')
    0x04, 0xe7, 0x09, 0x05, // 175 ('?')

    0x04, 0xf0, 0x07, 0x04, // 176 ('?')
    0x04, 0xf7, 0x08, 0x04, // 177 ('?')
    0x04, 0xff, 0x05, 0x03, // 178 ('?')
    0x05, 0x04, 0x05, 0x03, // 179 ('?')
    0x05, 0x09, 0x05, 0x05, // 180 ('?')
    0x05, 0x0e, 0x08, 0x05, // 181 ('?')
    0x05, 0x16, 0x08, 0x05, // 182 ('?')
    0x05, 0x1e, 0x03, 0x02, // 183 ('?')

    0x05, 0x21, 0x04, 0x02, // 184 ('?')
    0x05, 0x25, 0x03, 0x03, // 185 ('?')
    0x05, 0x28, 0x05, 0x03, // 186 ('?')
    0x05, 0x2d, 0x08, 0x05, // 187 ('?')
    0x05, 0x35, 0x0e, 0x07, // 188 ('?')
    0x05, 0x43, 0x0e, 0x07, // 189 ('?')
    0x05, 0x51, 0x0e, 0x07, // 190 ('?')
    0x05, 0x5f, 0x06, 0x03, // 191 ('?')

    0x05, 0x65, 0x0a, 0x05, // 192 ('?')
    0x05, 0x6f, 0x0a, 0x05, // 193 ('?')
    0x05, 0x79, 0x0a, 0x05, // 194 ('?')
    0x05, 0x83, 0x0a, 0x05, // 195 ('?')
    0x05, 0x8d, 0x0a, 0x05, // 196 ('?')
    0x05, 0x97, 0x0a, 0x05, // 197 ('?')
    0x05, 0xa1, 0x0c, 0x06, // 198 ('?')
    0x05, 0xad, 0x08, 0x04, // 199 ('?')

    0x05, 0xb5, 0x08, 0x04, // 200 ('?')
    0x05, 0xbd, 0x08, 0x04, // 201 ('?')
    0x05, 0xc5, 0x08, 0x04, // 202 ('?')
    0x05, 0xcd, 0x08, 0x04, // 203 ('?')
    0x05, 0xd5, 0x04, 0x03, // 204 ('?')
    0x05, 0xd9, 0x04, 0x03, // 205 ('?')
    0x05, 0xdd, 0x05, 0x03, // 206 ('?')
    0x05, 0xe2, 0x05, 0x03, // 207 ('?')

    0x05, 0xe7, 0x09, 0x05, // 208 ('?')
    0x05, 0xf0, 0x0a, 0x06, // 209 ('?')
    0x05, 0xfa, 0x09, 0x05, // 210 ('?')
    0x06, 0x03, 0x09, 0x05, // 211 ('?')
    0x06, 0x0c, 0x09, 0x05, // 212 ('?')
    0x06, 0x15, 0x09, 0x05, // 213 ('?')
    0x06, 0x1e, 0x09, 0x05, // 214 ('?')
    0x06, 0x27, 0x08, 0x04, // 215 ('?')

    0x06, 0x2f, 0x09, 0x05, // 216 ('?')
    0x06, 0x38, 0x08, 0x05, // 217 ('?')
    0x06, 0x40, 0x08, 0x05, // 218 ('?')
    0x06, 0x48, 0x08, 0x05, // 219 ('?')
    0x06, 0x50, 0x08, 0x05, // 220 ('?')
    0x06, 0x58, 0x07, 0x04, // 221 ('?')
    0x06, 0x5f, 0x07, 0x04, // 222 ('?')
    0x06, 0x66, 0x0a, 0x05, // 223 ('?')

    0x06, 0x70, 0x08, 0x04, // 224 ('?')
    0x06, 0x78, 0x08, 0x04, // 225 ('?')
    0x06, 0x80, 0x08, 0x04, // 226 ('?')
    0x06, 0x88, 0x08, 0x04, // 227 ('?')
    0x06, 0x90, 0x08, 0x04, // 228 ('?')
    0x06, 0x98, 0x08, 0x04, // 229 ('?')
    0x06, 0xa0, 0x0c, 0x06, // 230 ('?')
    0x06, 0xac, 0x06, 0x03, // 231 ('?')

    0x06, 0xb2, 0x08, 0x04, // 232 ('?')
    0x06, 0xba, 0x08, 0x04, // 233 ('?')
    0x06, 0xc2, 0x08, 0x04, // 234 ('?')
    0x06, 0xca, 0x08, 0x04, // 235 ('?')
    0x06, 0xd2, 0x04, 0x02, // 236 ('?')
    0x06, 0xd6, 0x04, 0x02, // 237 ('?')
    0x06, 0xda, 0x04, 0x02, // 238 ('?')
    0x06, 0xde, 0x04, 0x02, // 239 ('?')

    0x06, 0xe2, 0x08, 0x04, // 240 ('?')
    0x06, 0xea, 0x0a, 0x05, // 241 ('?')
    0x06, 0xf4, 0x08, 0x04, // 242 ('?')
    0x06, 0xfc, 0x08, 0x04, // 243 ('?')
    0x07, 0x04, 0x08, 0x04, // 244 ('?')
    0x07, 0x0c, 0x08, 0x04, // 245 ('?')
    0x07, 0x14, 0x08, 0x04, // 246 ('?')
    0x07, 0x1c, 0x07, 0x04, // 247 ('?')

    0x07, 0x23, 0x08, 0x04, // 248 ('?')
    0x07, 0x2b, 0x08, 0x05, // 249 ('?')
    0x07, 0x33, 0x08, 0x05, // 250 ('?')
    0x07, 0x3b, 0x08, 0x05, // 251 ('?')
    0x07, 0x43, 0x08, 0x05, // 252 ('?')
    0x07, 0x4b, 0x07, 0x04, // 253 ('?')
    0x07, 0x52, 0x08, 0x04, // 254 ('?')
    0x07, 0x5a, 0x07, 0x04, // 255 ('?')

    // Character bitmap data
    // Char 33 ('!') - 3x13 pixels, 6 bytes
    0xf8, 0x02, 0xf8, 0x02, 0x00, 0x00,

    // Char 34 ('"') - 4x13 pixels, 8 bytes
    0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,

    // Char 35 ('#') - 6x13 pixels, 12 bytes
    0xa0, 0x00, 0xf8, 0x03, 0xa0, 0x00, 0xf8, 0x03,
    0xa0, 0x00, 0x00, 0x00,

    // Char 36 ('$') - 6x13 pixels, 12 bytes
    0x20, 0x01, 0x50, 0x02, 0xf8, 0x07, 0x50, 0x02,
    0x80, 0x01, 0x00, 0x00,

    // Char 37 ('%') - 7x13 pixels, 14 bytes
    0x10, 0x00, 0x28, 0x02, 0x90, 0x01, 0x40, 0x00,
    0x30, 0x01, 0x88, 0x02, 0x00, 0x01,

    // Char 38 ('&') - 5x13 pixels, 10 bytes
    0xb0, 0x01, 0xf8, 0x03, 0x4c, 0x06, 0x08, 0x02,
    0x00, 0x00,

    // Char 39 (''') - 2x13 pixels, 4 bytes
    0x20, 0x00, 0x18, 0x00,

    // Char 40 ('(') - 4x13 pixels, 8 bytes
    0xf0, 0x03, 0xf8, 0x07, 0x08, 0x04, 0x00, 0x00,

    // Char 41 (')') - 4x13 pixels, 8 bytes
    0x08, 0x04, 0xf8, 0x07, 0xf0, 0x03, 0x00, 0x00,

    // Char 42 ('*') - 4x13 pixels, 8 bytes
    0x28, 0x00, 0x10, 0x00, 0x28, 0x00, 0x00, 0x00,

    // Char 43 ('+') - 3x13 pixels, 6 bytes
    0x40, 0x00, 0xe0, 0x00, 0x40, 0x00,

    // Char 44 (',') - 3x13 pixels, 6 bytes
    0x00, 0x08, 0x00, 0x06, 0x00, 0x00,

    // Char 45 ('-') - 4x13 pixels, 8 bytes
    0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00,

    // Char 46 ('.') - 2x13 pixels, 4 bytes
    0x00, 0x02, 0x00, 0x00,

    // Char 47 ('/') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xc0, 0x00, 0x30, 0x00, 0x0c, 0x00,
    0x00, 0x00,

    // Char 48 ('0') - 6x13 pixels, 12 bytes
    0xf0, 0x01, 0xf8, 0x03, 0xc8, 0x02, 0x68, 0x02,
    0xf0, 0x01, 0x00, 0x00,

    // Char 49 ('1') - 4x13 pixels, 8 bytes
    0x10, 0x00, 0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

    // Char 50 ('2') - 5x13 pixels, 10 bytes
    0x10, 0x03, 0x88, 0x03, 0xf8, 0x02, 0x70, 0x02,
    0x00, 0x00,

    // Char 51 ('3') - 5x13 pixels, 10 bytes
    0x08, 0x02, 0x48, 0x02, 0xf8, 0x03, 0xb0, 0x01,
    0x00, 0x00,

    // Char 52 ('4') - 6x13 pixels, 12 bytes
    0xe0, 0x00, 0xf0, 0x00, 0x98, 0x00, 0xf8, 0x03,
    0x80, 0x00, 0x00, 0x00,

    // Char 53 ('5') - 5x13 pixels, 10 bytes
    0x78, 0x02, 0x78, 0x02, 0xc8, 0x03, 0x88, 0x01,
    0x00, 0x00,

    // Char 54 ('6') - 5x13 pixels, 10 bytes
    0xf0, 0x01, 0xf8, 0x03, 0x48, 0x02, 0x90, 0x01,
    0x00, 0x00,

    // Char 55 ('7') - 5x13 pixels, 10 bytes
    0x08, 0x00, 0x88, 0x03, 0xf8, 0x03, 0x78, 0x00,
    0x00, 0x00,

    // Char 56 ('8') - 5x13 pixels, 10 bytes
    0xb0, 0x01, 0xf8, 0x03, 0x48, 0x02, 0xb0, 0x01,
    0x00, 0x00,

    // Char 57 ('9') - 5x13 pixels, 10 bytes
    0x30, 0x00, 0x78, 0x02, 0x48, 0x02, 0xf0, 0x01,
    0x00, 0x00,

    // Char 58 (':') - 1x13 pixels, 2 bytes
    0x20, 0x02,

    // Char 59 (';') - 2x13 pixels, 4 bytes
    0x00, 0x02, 0xa0, 0x01,

    // Char 60 ('<') - 4x13 pixels, 8 bytes
    0xc0, 0x00, 0x20, 0x01, 0x10, 0x02, 0x00, 0x00,

    // Char 61 ('=') - 5x13 pixels, 10 bytes
    0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
    0x00, 0x00,

    // Char 62 ('>') - 4x13 pixels, 8 bytes
    0x10, 0x02, 0x20, 0x01, 0xc0, 0x00, 0x00, 0x00,

    // Char 63 ('?') - 5x13 pixels, 10 bytes
    0x10, 0x00, 0xc8, 0x02, 0x78, 0x00, 0x30, 0x00,
    0x00, 0x00,

    // Char 64 ('@') - 6x13 pixels, 12 bytes
    0xe0, 0x01, 0x10, 0x02, 0xe8, 0x05, 0x28, 0x05,
    0xf0, 0x02, 0x00, 0x00,

    // Char 65 ('A') - 5x13 pixels, 10 bytes
    0xf0, 0x03, 0xf8, 0x03, 0x88, 0x00, 0xf0, 0x03,
    0x00, 0x00,

    // Char 66 ('B') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x48, 0x02, 0xb0, 0x01,
    0x00, 0x00,

    // Char 67 ('C') - 5x13 pixels, 10 bytes
    0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0x08, 0x02,
    0x00, 0x00,

    // Char 68 ('D') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x08, 0x02, 0xf0, 0x01,
    0x00, 0x00,

    // Char 69 ('E') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x48, 0x02, 0x08, 0x02,
    0x00, 0x00,

    // Char 70 ('F') - 4x13 pixels, 8 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x48, 0x00, 0x08, 0x00,

    // Char 71 ('G') - 6x13 pixels, 12 bytes
    0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0x48, 0x02,
    0xd0, 0x01, 0x00, 0x00,

    // Char 72 ('H') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x40, 0x00, 0xf8, 0x03,
    0x00, 0x00,

    // Char 73 ('I') - 3x13 pixels, 6 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

    // Char 74 ('J') - 4x13 pixels, 8 bytes
    0x08, 0x08, 0xf8, 0x07, 0xf8, 0x03, 0x00, 0x00,

    // Char 75 ('K') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x60, 0x00, 0xb8, 0x03,
    0x00, 0x00,

    // Char 76 ('L') - 4x13 pixels, 8 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x00, 0x02, 0x00, 0x02,

    // Char 77 ('M') - 7x13 pixels, 14 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x30, 0x00, 0xe0, 0x00,
    0x30, 0x00, 0xf8, 0x03, 0x00, 0x00,

    // Char 78 ('N') - 6x13 pixels, 12 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x70, 0x00, 0xc0, 0x01,
    0xf8, 0x03, 0x00, 0x00,

    // Char 79 ('O') - 5x13 pixels, 10 bytes
    0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0xf0, 0x01,
    0x00, 0x00,

    // Char 80 ('P') - 4x13 pixels, 8 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x88, 0x00, 0x70, 0x00,

    // Char 81 ('Q') - 5x13 pixels, 10 bytes
    0xf0, 0x01, 0xf8, 0x03, 0x08, 0x06, 0xf0, 0x05,
    0x00, 0x00,

    // Char 82 ('R') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x48, 0x00, 0xb0, 0x03,
    0x00, 0x00,

    // Char 83 ('S') - 4x13 pixels, 8 bytes
    0x30, 0x01, 0x78, 0x02, 0xc8, 0x02, 0x90, 0x01,

    // Char 84 ('T') - 4x13 pixels, 8 bytes
    0x08, 0x00, 0xf8, 0x03, 0xf8, 0x03, 0x08, 0x00,

    // Char 85 ('U') - 5x13 pixels, 10 bytes
    0xf8, 0x01, 0xf8, 0x03, 0x00, 0x02, 0xf8, 0x01,
    0x00, 0x00,

    // Char 86 ('V') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x01, 0x80, 0x00, 0x78, 0x00,
    0x00, 0x00,

    // Char 87 ('W') - 7x13 pixels, 14 bytes
    0xf8, 0x01, 0xf8, 0x03, 0x00, 0x02, 0xf8, 0x01,
    0x00, 0x02, 0xf8, 0x01, 0x00, 0x00,

    // Char 88 ('X') - 6x13 pixels, 12 bytes
    0x18, 0x03, 0xb8, 0x03, 0xe0, 0x00, 0xb8, 0x03,
    0x18, 0x03, 0x00, 0x00,

    // Char 89 ('Y') - 5x13 pixels, 10 bytes
    0x78, 0x00, 0xf8, 0x03, 0xc0, 0x03, 0x78, 0x00,
    0x00, 0x00,

    // Char 90 ('Z') - 4x13 pixels, 8 bytes
    0x08, 0x03, 0xc8, 0x03, 0x78, 0x02, 0x18, 0x02,

    // Char 91 ('[') - 4x13 pixels, 8 bytes
    0xf8, 0x07, 0xf8, 0x07, 0x08, 0x04, 0x00, 0x00,

    // Char 92 ('\') - 5x13 pixels, 10 bytes
    0x18, 0x00, 0x60, 0x00, 0x80, 0x01, 0x00, 0x06,
    0x00, 0x00,

    // Char 93 (']') - 4x13 pixels, 8 bytes
    0x08, 0x04, 0xf8, 0x07, 0xf8, 0x07, 0x00, 0x00,

    // Char 94 ('^') - 6x13 pixels, 12 bytes
    0x40, 0x00, 0x30, 0x00, 0x08, 0x00, 0x30, 0x00,
    0x40, 0x00, 0x00, 0x00,

    // Char 95 ('_') - 4x13 pixels, 8 bytes
    0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04,

    // Char 96 ('`') - 4x13 pixels, 8 bytes
    0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x00, 0x00,

    // Char 97 ('a') - 6x13 pixels, 12 bytes
    0x00, 0x01, 0xa0, 0x03, 0xa0, 0x02, 0xe0, 0x03,
    0xc0, 0x03, 0x00, 0x00,

    // Char 98 ('b') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x20, 0x02, 0xc0, 0x01,
    0x00, 0x00,

    // Char 99 ('c') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0xe0, 0x03, 0x20, 0x02, 0x00, 0x00,

    // Char 100 ('d') - 5x13 pixels, 10 bytes
    0xc0, 0x01, 0x20, 0x02, 0xf8, 0x03, 0xf8, 0x03,
    0x00, 0x00,

    // Char 101 ('e') - 5x13 pixels, 10 bytes
    0xc0, 0x01, 0xe0, 0x03, 0xa0, 0x02, 0xc0, 0x02,
    0x00, 0x00,

    // Char 102 ('f') - 5x13 pixels, 10 bytes
    0x20, 0x00, 0xf0, 0x03, 0xf8, 0x03, 0x28, 0x00,
    0x00, 0x00,

    // Char 103 ('g') - 5x13 pixels, 10 bytes
    0xc0, 0x04, 0x20, 0x09, 0xe0, 0x0f, 0xc0, 0x07,
    0x00, 0x00,

    // Char 104 ('h') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x20, 0x00, 0xc0, 0x03,
    0x00, 0x00,

    // Char 105 ('i') - 3x13 pixels, 6 bytes
    0xe8, 0x03, 0xe8, 0x03, 0x00, 0x00,

    // Char 106 ('j') - 3x13 pixels, 6 bytes
    0xe8, 0x0b, 0xe8, 0x07, 0x00, 0x00,

    // Char 107 ('k') - 5x13 pixels, 10 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x40, 0x01, 0x20, 0x02,
    0x00, 0x00,

    // Char 108 ('l') - 3x13 pixels, 6 bytes
    0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

    // Char 109 ('m') - 8x13 pixels, 16 bytes
    0xc0, 0x03, 0xe0, 0x03, 0x60, 0x00, 0xc0, 0x03,
    0x60, 0x00, 0xe0, 0x03, 0xc0, 0x03, 0x00, 0x00,

    // Char 110 ('n') - 6x13 pixels, 12 bytes
    0xe0, 0x03, 0xe0, 0x03, 0x20, 0x00, 0xe0, 0x03,
    0xc0, 0x03, 0x00, 0x00,

    // Char 111 ('o') - 5x13 pixels, 10 bytes
    0xc0, 0x01, 0xe0, 0x03, 0x60, 0x03, 0xc0, 0x01,
    0x00, 0x00,

    // Char 112 ('p') - 5x13 pixels, 10 bytes
    0xe0, 0x0f, 0xe0, 0x0f, 0x20, 0x02, 0xc0, 0x01,
    0x00, 0x00,

    // Char 113 ('q') - 5x13 pixels, 10 bytes
    0xc0, 0x01, 0x20, 0x02, 0xe0, 0x0f, 0xe0, 0x0f,
    0x00, 0x00,

    // Char 114 ('r') - 4x13 pixels, 8 bytes
    0xc0, 0x03, 0xe0, 0x03, 0x60, 0x00, 0x00, 0x00,

    // Char 115 ('s') - 4x13 pixels, 8 bytes
    0xc0, 0x02, 0xe0, 0x03, 0xa0, 0x01, 0x00, 0x00,

    // Char 116 ('t') - 5x13 pixels, 10 bytes
    0x20, 0x00, 0xf0, 0x01, 0xf0, 0x03, 0x20, 0x02,
    0x00, 0x00,

    // Char 117 ('u') - 5x13 pixels, 10 bytes
    0xe0, 0x01, 0xe0, 0x03, 0x00, 0x02, 0xe0, 0x01,
    0x00, 0x00,

    // Char 118 ('v') - 5x13 pixels, 10 bytes
    0xe0, 0x00, 0xe0, 0x01, 0x00, 0x03, 0xe0, 0x01,
    0x00, 0x00,

    // Char 119 ('w') - 7x13 pixels, 14 bytes
    0xe0, 0x01, 0xe0, 0x03, 0x00, 0x03, 0xe0, 0x01,
    0x00, 0x03, 0xe0, 0x01, 0x00, 0x00,

    // Char 120 ('x') - 5x13 pixels, 10 bytes
    0x60, 0x03, 0xe0, 0x03, 0x80, 0x00, 0x60, 0x03,
    0x00, 0x00,

    // Char 121 ('y') - 5x13 pixels, 10 bytes
    0xe0, 0x01, 0xe0, 0x0b, 0x00, 0x0a, 0xe0, 0x07,
    0x00, 0x00,

    // Char 122 ('z') - 5x13 pixels, 10 bytes
    0x60, 0x03, 0xa0, 0x03, 0xe0, 0x02, 0x60, 0x03,
    0x00, 0x00,

    // Char 123 ('{') - 4x13 pixels, 8 bytes
    0xf0, 0x03, 0x38, 0x07, 0x08, 0x04, 0x00, 0x00,

    // Char 124 ('|') - 5x13 pixels, 10 bytes
    0x00, 0x00, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00,
    0x00, 0x00,

    // Char 125 ('}') - 4x13 pixels, 8 bytes
    0x08, 0x04, 0x38, 0x07, 0xf0, 0x03, 0x00, 0x00,

    // Char 126 ('~') - 4x13 pixels, 8 bytes
    0xc0, 0x00, 0x40, 0x00, 0x80, 0x00, 0xc0, 0x00,

    // Char 127 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 128 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 129 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 130 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 131 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 132 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 133 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 134 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 135 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 136 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 137 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 138 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 139 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 140 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 141 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 142 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 143 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 144 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 145 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 146 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 147 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 148 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 149 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 150 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 151 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 152 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 153 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 154 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 155 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 156 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 157 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 158 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 159 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf0, 0x03, 0x10, 0x02, 0xf0, 0x03,

    // Char 161 ('?') - 2x13 pixels, 4 bytes
    0x20, 0x0c, 0xa0, 0x0f,

    // Char 162 ('?') - 4x13 pixels, 6 bytes
    0x00, 0x00, 0xf0, 0x01, 0x18, 0x03,

    // Char 163 ('?') - 4x13 pixels, 8 bytes
    0x40, 0x02, 0xf8, 0x03, 0x48, 0x02, 0x08, 0x02,

    // Char 164 ('?') - 5x13 pixels, 10 bytes
    0x20, 0x01, 0xe0, 0x01, 0x20, 0x01, 0xe0, 0x01,
    0x20, 0x01,

    // Char 165 ('?') - 4x13 pixels, 8 bytes
    0x48, 0x01, 0xf0, 0x03, 0xf0, 0x03, 0x48, 0x01,

    // Char 166 ('?') - 5x13 pixels, 6 bytes
    0x00, 0x00, 0x00, 0x00, 0x78, 0x0f,

    // Char 167 ('?') - 4x13 pixels, 8 bytes
    0x50, 0x02, 0xa8, 0x02, 0xa8, 0x03, 0x40, 0x01,

    // Char 168 ('?') - 5x13 pixels, 7 bytes
    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08,

    // Char 169 ('?') - 7x13 pixels, 13 bytes
    0xe0, 0x00, 0x10, 0x01, 0xe8, 0x02, 0xa8, 0x02,
    0xa8, 0x02, 0x10, 0x01, 0xe0,

    // Char 170 ('?') - 3x13 pixels, 5 bytes
    0x38, 0x00, 0x38, 0x00, 0x30,

    // Char 171 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x00, 0xc0, 0x03, 0x40, 0x02, 0xc0, 0x03,
    0x40, 0x02,

    // Char 172 ('?') - 4x13 pixels, 8 bytes
    0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xc0, 0x01,

    // Char 173 ('?') - 3x13 pixels, 5 bytes
    0x80, 0x00, 0x80, 0x00, 0x80,

    // Char 174 ('?') - 7x13 pixels, 13 bytes
    0xe0, 0x00, 0x10, 0x01, 0xe8, 0x02, 0x68, 0x02,
    0xa8, 0x02, 0x10, 0x01, 0xe0,

    // Char 175 ('?') - 5x13 pixels, 9 bytes
    0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00,
    0x04,

    // Char 176 ('?') - 4x13 pixels, 7 bytes
    0x10, 0x00, 0x28, 0x00, 0x28, 0x00, 0x10,

    // Char 177 ('?') - 4x13 pixels, 8 bytes
    0x40, 0x02, 0xe0, 0x02, 0x40, 0x02, 0x40, 0x02,

    // Char 178 ('?') - 3x13 pixels, 5 bytes
    0x48, 0x00, 0x68, 0x00, 0x50,

    // Char 179 ('?') - 3x13 pixels, 5 bytes
    0x48, 0x00, 0x58, 0x00, 0x20,

    // Char 180 ('?') - 5x13 pixels, 5 bytes
    0x00, 0x00, 0x00, 0x00, 0x18,

    // Char 181 ('?') - 5x13 pixels, 8 bytes
    0xe0, 0x0f, 0xe0, 0x0f, 0x00, 0x02, 0xe0, 0x03,

    // Char 182 ('?') - 5x13 pixels, 8 bytes
    0x30, 0x00, 0x78, 0x00, 0xf8, 0x07, 0xf8, 0x07,

    // Char 183 ('?') - 2x13 pixels, 3 bytes
    0x40, 0x00, 0x40,

    // Char 184 ('?') - 2x13 pixels, 4 bytes
    0x00, 0x08, 0x00, 0x0c,

    // Char 185 ('?') - 3x13 pixels, 3 bytes
    0x00, 0x00, 0x78,

    // Char 186 ('?') - 3x13 pixels, 5 bytes
    0x10, 0x00, 0x28, 0x00, 0x10,

    // Char 187 ('?') - 5x13 pixels, 8 bytes
    0x40, 0x02, 0xc0, 0x03, 0x40, 0x02, 0xc0, 0x03,

    // Char 188 ('?') - 7x13 pixels, 14 bytes
    0x00, 0x00, 0x78, 0x00, 0x00, 0x03, 0xe0, 0x00,
    0x18, 0x01, 0xc0, 0x01, 0x00, 0x03,

    // Char 189 ('?') - 7x13 pixels, 14 bytes
    0x00, 0x00, 0x78, 0x00, 0x00, 0x03, 0xe0, 0x00,
    0x58, 0x02, 0x40, 0x03, 0x80, 0x02,

    // Char 190 ('?') - 7x13 pixels, 14 bytes
    0x48, 0x00, 0x58, 0x00, 0x20, 0x03, 0xe0, 0x00,
    0x18, 0x01, 0xc0, 0x01, 0x00, 0x03,

    // Char 191 ('?') - 3x13 pixels, 6 bytes
    0x00, 0x06, 0xa0, 0x09, 0x00, 0x08,

    // Char 192 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf3, 0x01, 0x88, 0x00, 0xf0, 0x01,
    0x00, 0x03,

    // Char 193 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf0, 0x01, 0x8b, 0x00, 0xf0, 0x01,
    0x00, 0x03,

    // Char 194 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf2, 0x01, 0x89, 0x00, 0xf2, 0x01,
    0x00, 0x03,

    // Char 195 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf3, 0x01, 0x8b, 0x00, 0xf3, 0x01,
    0x00, 0x03,

    // Char 196 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf2, 0x01, 0x88, 0x00, 0xf2, 0x01,
    0x00, 0x03,

    // Char 197 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x03, 0xf4, 0x01, 0x8c, 0x00, 0xf4, 0x01,
    0x00, 0x03,

    // Char 198 ('?') - 6x13 pixels, 12 bytes
    0x00, 0x03, 0xe0, 0x01, 0x98, 0x00, 0xf8, 0x03,
    0x48, 0x02, 0x48, 0x02,

    // Char 199 ('?') - 4x13 pixels, 8 bytes
    0xe0, 0x00, 0xf8, 0x03, 0x08, 0x0a, 0x08, 0x0e,

    // Char 200 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x00, 0xfb, 0x03, 0x48, 0x02, 0x08, 0x02,

    // Char 201 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x00, 0xf8, 0x03, 0x4b, 0x02, 0x08, 0x02,

    // Char 202 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x00, 0xfa, 0x03, 0x49, 0x02, 0x0a, 0x02,

    // Char 203 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x00, 0xfa, 0x03, 0x48, 0x02, 0x0a, 0x02,

    // Char 204 ('?') - 3x13 pixels, 4 bytes
    0x03, 0x00, 0xf8, 0x03,

    // Char 205 ('?') - 3x13 pixels, 4 bytes
    0x00, 0x00, 0xfb, 0x03,

    // Char 206 ('?') - 3x13 pixels, 5 bytes
    0x02, 0x00, 0xf9, 0x03, 0x02,

    // Char 207 ('?') - 3x13 pixels, 5 bytes
    0x02, 0x00, 0xf8, 0x03, 0x02,

    // Char 208 ('?') - 5x13 pixels, 9 bytes
    0x40, 0x00, 0xf8, 0x03, 0x48, 0x02, 0xf8, 0x03,
    0xe0,

    // Char 209 ('?') - 6x13 pixels, 10 bytes
    0x00, 0x00, 0xfb, 0x03, 0x73, 0x00, 0xc3, 0x01,
    0xf8, 0x03,

    // Char 210 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xf8, 0x03, 0x0b, 0x02, 0xf8, 0x03,
    0xe0,

    // Char 211 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xf8, 0x03, 0x08, 0x02, 0xfb, 0x03,
    0xe0,

    // Char 212 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xfa, 0x03, 0x09, 0x02, 0xfa, 0x03,
    0xe0,

    // Char 213 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xfb, 0x03, 0x0b, 0x02, 0xfb, 0x03,
    0xe0,

    // Char 214 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xfa, 0x03, 0x08, 0x02, 0xfa, 0x03,
    0xe0,

    // Char 215 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x01, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x01,

    // Char 216 ('?') - 5x13 pixels, 9 bytes
    0xe0, 0x00, 0xf8, 0x03, 0xc8, 0x02, 0xf8, 0x03,
    0xe0,

    // Char 217 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf8, 0x03, 0x03, 0x02, 0xf8, 0x03,

    // Char 218 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xf8, 0x03, 0x00, 0x02, 0xfb, 0x03,

    // Char 219 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xfa, 0x03, 0x01, 0x02, 0xfa, 0x03,

    // Char 220 ('?') - 5x13 pixels, 8 bytes
    0x00, 0x00, 0xfa, 0x03, 0x00, 0x02, 0xfa, 0x03,

    // Char 221 ('?') - 4x13 pixels, 7 bytes
    0x18, 0x00, 0xf0, 0x03, 0xf3, 0x03, 0x18,

    // Char 222 ('?') - 4x13 pixels, 7 bytes
    0x00, 0x00, 0xf8, 0x03, 0xb0, 0x01, 0xe0,

    // Char 223 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x00, 0xf8, 0x03, 0x48, 0x02, 0xb8, 0x02,
    0x80, 0x01,

    // Char 224 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xac, 0x02, 0xe0, 0x01, 0xc0, 0x03,

    // Char 225 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xa0, 0x02, 0xec, 0x01, 0xc0, 0x03,

    // Char 226 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xa8, 0x02, 0xe4, 0x01, 0xc8, 0x03,

    // Char 227 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xac, 0x02, 0xec, 0x01, 0xcc, 0x03,

    // Char 228 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xa8, 0x02, 0xe0, 0x01, 0xc8, 0x03,

    // Char 229 ('?') - 4x13 pixels, 8 bytes
    0x00, 0x03, 0xa0, 0x02, 0xec, 0x01, 0xc0, 0x03,

    // Char 230 ('?') - 6x13 pixels, 12 bytes
    0x00, 0x03, 0xa0, 0x02, 0xe0, 0x03, 0xe0, 0x03,
    0xa0, 0x02, 0xc0, 0x02,

    // Char 231 ('?') - 3x13 pixels, 6 bytes
    0xc0, 0x01, 0x60, 0x0b, 0x20, 0x0e,

    // Char 232 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0xec, 0x03, 0xa0, 0x02, 0xc0, 0x02,

    // Char 233 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0xe0, 0x03, 0xac, 0x02, 0xc0, 0x02,

    // Char 234 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0xe8, 0x03, 0xa4, 0x02, 0xc8, 0x02,

    // Char 235 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0xe8, 0x03, 0xa0, 0x02, 0xc8, 0x02,

    // Char 236 ('?') - 2x13 pixels, 4 bytes
    0xec, 0x03, 0xe0, 0x03,

    // Char 237 ('?') - 2x13 pixels, 4 bytes
    0xe0, 0x03, 0xec, 0x03,

    // Char 238 ('?') - 2x13 pixels, 4 bytes
    0xe8, 0x03, 0xe4, 0x03,

    // Char 239 ('?') - 2x13 pixels, 4 bytes
    0xe8, 0x03, 0xe0, 0x03,

    // Char 240 ('?') - 4x13 pixels, 8 bytes
    0x80, 0x01, 0xd8, 0x03, 0xb8, 0x03, 0xc0, 0x01,

    // Char 241 ('?') - 5x13 pixels, 10 bytes
    0x00, 0x00, 0xec, 0x03, 0x2c, 0x00, 0xec, 0x03,
    0xc0, 0x03,

    // Char 242 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x6c, 0x03, 0xe0, 0x03, 0xc0, 0x01,

    // Char 243 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x60, 0x03, 0xec, 0x03, 0xc0, 0x01,

    // Char 244 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x68, 0x03, 0xe4, 0x03, 0xc8, 0x01,

    // Char 245 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x6c, 0x03, 0xec, 0x03, 0xcc, 0x01,

    // Char 246 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x68, 0x03, 0xe0, 0x03, 0xc8, 0x01,

    // Char 247 ('?') - 4x13 pixels, 7 bytes
    0x40, 0x00, 0x50, 0x01, 0x50, 0x01, 0x40,

    // Char 248 ('?') - 4x13 pixels, 8 bytes
    0xc0, 0x01, 0x60, 0x03, 0xe0, 0x03, 0xc0, 0x01,

    // Char 249 ('?') - 5x13 pixels, 8 bytes
    0xe0, 0x01, 0xec, 0x03, 0x00, 0x02, 0xe0, 0x03,

    // Char 250 ('?') - 5x13 pixels, 8 bytes
    0xe0, 0x01, 0xe0, 0x03, 0x0c, 0x02, 0xe0, 0x03,

    // Char 251 ('?') - 5x13 pixels, 8 bytes
    0xe0, 0x01, 0xe8, 0x03, 0x04, 0x02, 0xe8, 0x03,

    // Char 252 ('?') - 5x13 pixels, 8 bytes
    0xe0, 0x01, 0xe8, 0x03, 0x00, 0x02, 0xe8, 0x03,

    // Char 253 ('?') - 4x13 pixels, 7 bytes
    0x60, 0x08, 0xc0, 0x0f, 0xcc, 0x07, 0x60,

    // Char 254 ('?') - 4x13 pixels, 8 bytes
    0xf8, 0x0f, 0xf8, 0x0f, 0xe0, 0x03, 0xc0, 0x01,

    // Char 255 ('?') - 4x13 pixels, 7 bytes
    0x60, 0x08, 0xc8, 0x0f, 0xc0, 0x07, 0x68,

 ]);
        const ArialMT_Bold_10 = new Uint8Array([
            // Header: width=10, height=13, firstChar=32, numChars=224
            10, 13, 32, 224,

            // Jump table (224 entries of 4 bytes each: offsetLow, offsetHigh, byteSize, width)
            0xff, 0xff, 0x00, 0x03, // 32 (' ')
            0x00, 0x00, 0x04, 0x03, // 33 ('!')
            0x00, 0x04, 0x05, 0x04, // 34 ('"')
            0x00, 0x09, 0x0c, 0x06, // 35 ('#')
            0x00, 0x15, 0x0c, 0x06, // 36 ('$')
            0x00, 0x21, 0x12, 0x09, // 37 ('%')
            0x00, 0x33, 0x0e, 0x07, // 38 ('&')
            0x00, 0x41, 0x01, 0x02, // 39 (''')

            0x00, 0x42, 0x06, 0x03, // 40 ('(')
            0x00, 0x48, 0x06, 0x03, // 41 (')')
            0x00, 0x4e, 0x05, 0x04, // 42 ('*')
            0x00, 0x53, 0x09, 0x06, // 43 ('+')
            0x00, 0x5c, 0x04, 0x03, // 44 (',')
            0x00, 0x60, 0x03, 0x03, // 45 ('-')
            0x00, 0x63, 0x04, 0x03, // 46 ('.')
            0x00, 0x67, 0x05, 0x03, // 47 ('/')

            0x00, 0x6c, 0x0c, 0x06, // 48 ('0')
            0x00, 0x78, 0x08, 0x04, // 49 ('1')
            0x00, 0x80, 0x0c, 0x06, // 50 ('2')
            0x00, 0x8c, 0x0c, 0x06, // 51 ('3')
            0x00, 0x98, 0x0e, 0x07, // 52 ('4')
            0x00, 0xa6, 0x0c, 0x06, // 53 ('5')
            0x00, 0xb2, 0x0c, 0x06, // 54 ('6')
            0x00, 0xbe, 0x0c, 0x06, // 55 ('7')

            0x00, 0xca, 0x0c, 0x06, // 56 ('8')
            0x00, 0xd6, 0x0c, 0x06, // 57 ('9')
            0x00, 0xe2, 0x04, 0x03, // 58 (':')
            0x00, 0xe6, 0x04, 0x03, // 59 (';')
            0x00, 0xea, 0x0c, 0x06, // 60 ('<')
            0x00, 0xf6, 0x09, 0x06, // 61 ('=')
            0x00, 0xff, 0x0c, 0x06, // 62 ('>')
            0x01, 0x0b, 0x0b, 0x06, // 63 ('?')

            0x01, 0x16, 0x16, 0x0b, // 64 ('@')
            0x01, 0x2c, 0x10, 0x08, // 65 ('A')
            0x01, 0x3c, 0x0e, 0x07, // 66 ('B')
            0x01, 0x4a, 0x0e, 0x07, // 67 ('C')
            0x01, 0x58, 0x0e, 0x07, // 68 ('D')
            0x01, 0x66, 0x0e, 0x07, // 69 ('E')
            0x01, 0x74, 0x0c, 0x06, // 70 ('F')
            0x01, 0x80, 0x10, 0x08, // 71 ('G')

            0x01, 0x90, 0x0e, 0x07, // 72 ('H')
            0x01, 0x9e, 0x06, 0x03, // 73 ('I')
            0x01, 0xa4, 0x0a, 0x05, // 74 ('J')
            0x01, 0xae, 0x10, 0x08, // 75 ('K')
            0x01, 0xbe, 0x0c, 0x06, // 76 ('L')
            0x01, 0xca, 0x10, 0x08, // 77 ('M')
            0x01, 0xda, 0x0e, 0x07, // 78 ('N')
            0x01, 0xe8, 0x10, 0x08, // 79 ('O')

            0x01, 0xf8, 0x0e, 0x07, // 80 ('P')
            0x02, 0x06, 0x10, 0x08, // 81 ('Q')
            0x02, 0x16, 0x0e, 0x07, // 82 ('R')
            0x02, 0x24, 0x0e, 0x07, // 83 ('S')
            0x02, 0x32, 0x0e, 0x07, // 84 ('T')
            0x02, 0x40, 0x0e, 0x07, // 85 ('U')
            0x02, 0x4e, 0x10, 0x08, // 86 ('V')
            0x02, 0x5e, 0x10, 0x08, // 87 ('W')

            0x02, 0x6e, 0x10, 0x08, // 88 ('X')
            0x02, 0x7e, 0x0e, 0x07, // 89 ('Y')
            0x02, 0x8c, 0x0e, 0x07, // 90 ('Z')
            0x02, 0x9a, 0x06, 0x03, // 91 ('[')
            0x02, 0xa0, 0x06, 0x03, // 92 ('\')
            0x02, 0xa6, 0x04, 0x03, // 93 (']')
            0x02, 0xaa, 0x09, 0x05, // 94 ('^')
            0x02, 0xb3, 0x0c, 0x06, // 95 ('_')

            0x02, 0xbf, 0x03, 0x03, // 96 ('`')
            0x02, 0xc2, 0x0a, 0x06, // 97 ('a')
            0x02, 0xcc, 0x0a, 0x06, // 98 ('b')
            0x02, 0xd6, 0x0a, 0x05, // 99 ('c')
            0x02, 0xe0, 0x0a, 0x06, // 100 ('d')
            0x02, 0xea, 0x0a, 0x06, // 101 ('e')
            0x02, 0xf4, 0x05, 0x03, // 102 ('f')
            0x02, 0xf9, 0x0a, 0x06, // 103 ('g')

            0x03, 0x03, 0x0a, 0x06, // 104 ('h')
            0x03, 0x0d, 0x04, 0x02, // 105 ('i')
            0x03, 0x11, 0x04, 0x02, // 106 ('j')
            0x03, 0x15, 0x08, 0x05, // 107 ('k')
            0x03, 0x1d, 0x04, 0x02, // 108 ('l')
            0x03, 0x21, 0x10, 0x08, // 109 ('m')
            0x03, 0x31, 0x0a, 0x06, // 110 ('n')
            0x03, 0x3b, 0x0a, 0x06, // 111 ('o')

            0x03, 0x45, 0x0a, 0x06, // 112 ('p')
            0x03, 0x4f, 0x0a, 0x06, // 113 ('q')
            0x03, 0x59, 0x05, 0x03, // 114 ('r')
            0x03, 0x5e, 0x08, 0x05, // 115 ('s')
            0x03, 0x66, 0x06, 0x03, // 116 ('t')
            0x03, 0x6c, 0x0a, 0x06, // 117 ('u')
            0x03, 0x76, 0x09, 0x05, // 118 ('v')
            0x03, 0x7f, 0x0e, 0x07, // 119 ('w')

            0x03, 0x8d, 0x0a, 0x05, // 120 ('x')
            0x03, 0x97, 0x09, 0x05, // 121 ('y')
            0x03, 0xa0, 0x0a, 0x05, // 122 ('z')
            0x03, 0xaa, 0x06, 0x03, // 123 ('{')
            0x03, 0xb0, 0x04, 0x03, // 124 ('|')
            0x03, 0xb4, 0x05, 0x03, // 125 ('}')
            0x03, 0xb9, 0x09, 0x06, // 126 ('~')
            0xff, 0xff, 0x00, 0x00, // 127 ('?')

            0xff, 0xff, 0x00, 0x0a, // 128 ('?')
            0xff, 0xff, 0x00, 0x0a, // 129 ('?')
            0xff, 0xff, 0x00, 0x0a, // 130 ('?')
            0xff, 0xff, 0x00, 0x0a, // 131 ('?')
            0xff, 0xff, 0x00, 0x0a, // 132 ('?')
            0xff, 0xff, 0x00, 0x0a, // 133 ('?')
            0xff, 0xff, 0x00, 0x0a, // 134 ('?')
            0xff, 0xff, 0x00, 0x0a, // 135 ('?')

            0xff, 0xff, 0x00, 0x0a, // 136 ('?')
            0xff, 0xff, 0x00, 0x0a, // 137 ('?')
            0xff, 0xff, 0x00, 0x0a, // 138 ('?')
            0xff, 0xff, 0x00, 0x0a, // 139 ('?')
            0xff, 0xff, 0x00, 0x0a, // 140 ('?')
            0xff, 0xff, 0x00, 0x0a, // 141 ('?')
            0xff, 0xff, 0x00, 0x0a, // 142 ('?')
            0xff, 0xff, 0x00, 0x0a, // 143 ('?')

            0xff, 0xff, 0x00, 0x0a, // 144 ('?')
            0xff, 0xff, 0x00, 0x0a, // 145 ('?')
            0xff, 0xff, 0x00, 0x0a, // 146 ('?')
            0xff, 0xff, 0x00, 0x0a, // 147 ('?')
            0xff, 0xff, 0x00, 0x0a, // 148 ('?')
            0xff, 0xff, 0x00, 0x0a, // 149 ('?')
            0xff, 0xff, 0x00, 0x0a, // 150 ('?')
            0xff, 0xff, 0x00, 0x0a, // 151 ('?')

            0xff, 0xff, 0x00, 0x0a, // 152 ('?')
            0xff, 0xff, 0x00, 0x0a, // 153 ('?')
            0xff, 0xff, 0x00, 0x0a, // 154 ('?')
            0xff, 0xff, 0x00, 0x0a, // 155 ('?')
            0xff, 0xff, 0x00, 0x0a, // 156 ('?')
            0xff, 0xff, 0x00, 0x0a, // 157 ('?')
            0xff, 0xff, 0x00, 0x0a, // 158 ('?')
            0xff, 0xff, 0x00, 0x0a, // 159 ('?')

            0xff, 0xff, 0x00, 0x03, // 160 ('?')
            0x03, 0xc2, 0x04, 0x03, // 161 ('?')
            0x03, 0xc6, 0x0a, 0x06, // 162 ('?')
            0x03, 0xd0, 0x0c, 0x06, // 163 ('?')
            0x03, 0xdc, 0x0a, 0x06, // 164 ('?')
            0x03, 0xe6, 0x0a, 0x06, // 165 ('?')
            0x03, 0xf0, 0x04, 0x03, // 166 ('?')
            0x03, 0xf4, 0x0a, 0x06, // 167 ('?')

            0x03, 0xfe, 0x05, 0x03, // 168 ('?')
            0x04, 0x03, 0x0d, 0x07, // 169 ('?')
            0x04, 0x10, 0x07, 0x04, // 170 ('?')
            0x04, 0x17, 0x0a, 0x06, // 171 ('?')
            0x04, 0x21, 0x09, 0x06, // 172 ('?')
            0x04, 0x2a, 0x03, 0x03, // 173 ('?')
            0x04, 0x2d, 0x0d, 0x07, // 174 ('?')
            0x04, 0x3a, 0x0b, 0x06, // 175 ('?')

            0x04, 0x45, 0x07, 0x04, // 176 ('?')
            0x04, 0x4c, 0x0a, 0x05, // 177 ('?')
            0x04, 0x56, 0x05, 0x03, // 178 ('?')
            0x04, 0x5b, 0x05, 0x03, // 179 ('?')
            0x04, 0x60, 0x05, 0x03, // 180 ('?')
            0x04, 0x65, 0x0a, 0x06, // 181 ('?')
            0x04, 0x6f, 0x09, 0x05, // 182 ('?')
            0x04, 0x78, 0x03, 0x03, // 183 ('?')

            0x04, 0x7b, 0x06, 0x03, // 184 ('?')
            0x04, 0x81, 0x05, 0x03, // 185 ('?')
            0x04, 0x86, 0x07, 0x04, // 186 ('?')
            0x04, 0x8d, 0x0a, 0x06, // 187 ('?')
            0x04, 0x97, 0x10, 0x08, // 188 ('?')
            0x04, 0xa7, 0x10, 0x08, // 189 ('?')
            0x04, 0xb7, 0x10, 0x08, // 190 ('?')
            0x04, 0xc7, 0x0a, 0x06, // 191 ('?')

            0x04, 0xd1, 0x0e, 0x07, // 192 ('?')
            0x04, 0xdf, 0x0e, 0x07, // 193 ('?')
            0x04, 0xed, 0x0e, 0x07, // 194 ('?')
            0x04, 0xfb, 0x0e, 0x07, // 195 ('?')
            0x05, 0x09, 0x0e, 0x07, // 196 ('?')
            0x05, 0x17, 0x0e, 0x07, // 197 ('?')
            0x05, 0x25, 0x12, 0x0a, // 198 ('?')
            0x05, 0x37, 0x0c, 0x07, // 199 ('?')

            0x05, 0x43, 0x0c, 0x07, // 200 ('?')
            0x05, 0x4f, 0x0c, 0x07, // 201 ('?')
            0x05, 0x5b, 0x0c, 0x07, // 202 ('?')
            0x05, 0x67, 0x0c, 0x07, // 203 ('?')
            0x05, 0x73, 0x05, 0x03, // 204 ('?')
            0x05, 0x78, 0x04, 0x03, // 205 ('?')
            0x05, 0x7c, 0x04, 0x03, // 206 ('?')
            0x05, 0x80, 0x05, 0x03, // 207 ('?')

            0x05, 0x85, 0x0b, 0x07, // 208 ('?')
            0x05, 0x90, 0x0c, 0x07, // 209 ('?')
            0x05, 0x9c, 0x0e, 0x08, // 210 ('?')
            0x05, 0xaa, 0x0e, 0x08, // 211 ('?')
            0x05, 0xb8, 0x0e, 0x08, // 212 ('?')
            0x05, 0xc6, 0x0e, 0x08, // 213 ('?')
            0x05, 0xd4, 0x0e, 0x08, // 214 ('?')
            0x05, 0xe2, 0x0a, 0x06, // 215 ('?')

            0x05, 0xec, 0x0d, 0x08, // 216 ('?')
            0x05, 0xf9, 0x0c, 0x07, // 217 ('?')
            0x06, 0x05, 0x0c, 0x07, // 218 ('?')
            0x06, 0x11, 0x0c, 0x07, // 219 ('?')
            0x06, 0x1d, 0x0c, 0x07, // 220 ('?')
            0x06, 0x29, 0x0d, 0x07, // 221 ('?')
            0x06, 0x36, 0x0b, 0x07, // 222 ('?')
            0x06, 0x41, 0x0c, 0x06, // 223 ('?')

            0x06, 0x4d, 0x0a, 0x06, // 224 ('?')
            0x06, 0x57, 0x0a, 0x06, // 225 ('?')
            0x06, 0x61, 0x0a, 0x06, // 226 ('?')
            0x06, 0x6b, 0x0a, 0x06, // 227 ('?')
            0x06, 0x75, 0x0a, 0x06, // 228 ('?')
            0x06, 0x7f, 0x0a, 0x06, // 229 ('?')
            0x06, 0x89, 0x10, 0x09, // 230 ('?')
            0x06, 0x99, 0x0a, 0x05, // 231 ('?')

            0x06, 0xa3, 0x0a, 0x06, // 232 ('?')
            0x06, 0xad, 0x0a, 0x06, // 233 ('?')
            0x06, 0xb7, 0x0a, 0x06, // 234 ('?')
            0x06, 0xc1, 0x0a, 0x06, // 235 ('?')
            0x06, 0xcb, 0x05, 0x03, // 236 ('?')
            0x06, 0xd0, 0x04, 0x03, // 237 ('?')
            0x06, 0xd4, 0x05, 0x03, // 238 ('?')
            0x06, 0xd9, 0x05, 0x03, // 239 ('?')

            0x06, 0xde, 0x0a, 0x06, // 240 ('?')
            0x06, 0xe8, 0x0a, 0x06, // 241 ('?')
            0x06, 0xf2, 0x0a, 0x06, // 242 ('?')
            0x06, 0xfc, 0x0a, 0x06, // 243 ('?')
            0x07, 0x06, 0x0a, 0x06, // 244 ('?')
            0x07, 0x10, 0x0a, 0x06, // 245 ('?')
            0x07, 0x1a, 0x0a, 0x06, // 246 ('?')
            0x07, 0x24, 0x09, 0x05, // 247 ('?')

            0x07, 0x2d, 0x0a, 0x06, // 248 ('?')
            0x07, 0x37, 0x0a, 0x06, // 249 ('?')
            0x07, 0x41, 0x0a, 0x06, // 250 ('?')
            0x07, 0x4b, 0x0a, 0x06, // 251 ('?')
            0x07, 0x55, 0x0a, 0x06, // 252 ('?')
            0x07, 0x5f, 0x09, 0x05, // 253 ('?')
            0x07, 0x68, 0x0a, 0x06, // 254 ('?')
            0x07, 0x72, 0x09, 0x05, // 255 ('?')

            // Character bitmap data
            // Char 33 ('!') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0xf8, 0x02,

            // Char 34 ('"') - 4x13 pixels, 5 bytes
            0x38, 0x00, 0x00, 0x00, 0x38,

            // Char 35 ('#') - 6x13 pixels, 12 bytes
            0xa0, 0x00, 0xf8, 0x03, 0xa0, 0x00, 0xf8, 0x03,
            0xa0, 0x00, 0x00, 0x00,

            // Char 36 ('$') - 6x13 pixels, 12 bytes
            0x30, 0x01, 0x48, 0x02, 0xfc, 0x07, 0x48, 0x02,
            0x90, 0x01, 0x00, 0x00,

            // Char 37 ('%') - 9x13 pixels, 18 bytes
            0x08, 0x00, 0x94, 0x00, 0x48, 0x00, 0x20, 0x00,
            0x90, 0x00, 0x48, 0x01, 0x80, 0x00, 0x00, 0x00,
            0x00, 0x00,

            // Char 38 ('&') - 7x13 pixels, 14 bytes
            0x80, 0x01, 0x50, 0x02, 0x68, 0x02, 0xa8, 0x02,
            0x18, 0x01, 0x80, 0x03, 0x80, 0x02,

            // Char 39 (''') - 2x13 pixels, 1 bytes
            0x38,

            // Char 40 ('(') - 3x13 pixels, 6 bytes
            0xe0, 0x03, 0x10, 0x04, 0x08, 0x08,

            // Char 41 (')') - 3x13 pixels, 6 bytes
            0x08, 0x08, 0x10, 0x04, 0xe0, 0x03,

            // Char 42 ('*') - 4x13 pixels, 5 bytes
            0x28, 0x00, 0x18, 0x00, 0x28,

            // Char 43 ('+') - 6x13 pixels, 9 bytes
            0x40, 0x00, 0x40, 0x00, 0xf0, 0x01, 0x40, 0x00,
            0x40,

            // Char 44 (',') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0x00, 0x06,

            // Char 45 ('-') - 3x13 pixels, 3 bytes
            0x80, 0x00, 0x80,

            // Char 46 ('.') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0x00, 0x02,

            // Char 47 ('/') - 3x13 pixels, 5 bytes
            0x00, 0x03, 0xe0, 0x00, 0x18,

            // Char 48 ('0') - 6x13 pixels, 12 bytes
            0xf0, 0x01, 0x88, 0x02, 0x48, 0x02, 0x28, 0x02,
            0xf0, 0x01, 0x00, 0x00,

            // Char 49 ('1') - 4x13 pixels, 8 bytes
            0x10, 0x00, 0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

            // Char 50 ('2') - 6x13 pixels, 12 bytes
            0x10, 0x03, 0x98, 0x03, 0xc8, 0x02, 0x78, 0x02,
            0x30, 0x02, 0x00, 0x00,

            // Char 51 ('3') - 6x13 pixels, 12 bytes
            0x10, 0x01, 0x18, 0x03, 0x48, 0x02, 0xf8, 0x03,
            0xb0, 0x01, 0x00, 0x00,

            // Char 52 ('4') - 7x13 pixels, 14 bytes
            0xc0, 0x00, 0xe0, 0x00, 0x90, 0x00, 0xf8, 0x03,
            0xf8, 0x03, 0x80, 0x00, 0x00, 0x00,

            // Char 53 ('5') - 6x13 pixels, 12 bytes
            0x38, 0x01, 0x38, 0x03, 0x28, 0x02, 0xe8, 0x03,
            0xc8, 0x01, 0x00, 0x00,

            // Char 54 ('6') - 6x13 pixels, 12 bytes
            0xf0, 0x01, 0xf8, 0x03, 0x48, 0x02, 0xc8, 0x03,
            0x80, 0x01, 0x00, 0x00,

            // Char 55 ('7') - 6x13 pixels, 12 bytes
            0x08, 0x00, 0x08, 0x03, 0xc8, 0x03, 0xf8, 0x00,
            0x38, 0x00, 0x00, 0x00,

            // Char 56 ('8') - 6x13 pixels, 12 bytes
            0xb0, 0x01, 0xf8, 0x03, 0x48, 0x02, 0xf8, 0x03,
            0xb0, 0x01, 0x00, 0x00,

            // Char 57 ('9') - 6x13 pixels, 12 bytes
            0x30, 0x01, 0x78, 0x03, 0x48, 0x02, 0xf8, 0x03,
            0xf0, 0x01, 0x00, 0x00,

            // Char 58 (':') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0x20, 0x02,

            // Char 59 (';') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0x20, 0x06,

            // Char 60 ('<') - 6x13 pixels, 12 bytes
            0x00, 0x00, 0x80, 0x00, 0x40, 0x01, 0x40, 0x01,
            0x20, 0x02, 0x00, 0x00,

            // Char 61 ('=') - 6x13 pixels, 9 bytes
            0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00,
            0xa0,

            // Char 62 ('>') - 6x13 pixels, 12 bytes
            0x00, 0x00, 0x20, 0x02, 0x40, 0x01, 0x40, 0x01,
            0x80, 0x00, 0x00, 0x00,

            // Char 63 ('?') - 6x13 pixels, 11 bytes
            0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0xc8, 0x02,
            0x48, 0x00, 0x30,

            // Char 64 ('@') - 11x13 pixels, 22 bytes
            0x00, 0x00, 0xc0, 0x03, 0x30, 0x04, 0xd0, 0x09,
            0x28, 0x0a, 0x28, 0x0a, 0xc8, 0x0b, 0x68, 0x0a,
            0x10, 0x05, 0xe0, 0x04, 0x00, 0x00,

            // Char 65 ('A') - 8x13 pixels, 16 bytes
            0xe0, 0x03, 0xf0, 0x03, 0x98, 0x00, 0x88, 0x00,
            0x98, 0x00, 0xf0, 0x03, 0xe0, 0x03, 0x00, 0x00,

            // Char 66 ('B') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x48, 0x02, 0x48, 0x02,
            0xf8, 0x03, 0xb0, 0x01, 0x00, 0x00,

            // Char 67 ('C') - 7x13 pixels, 14 bytes
            0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0x08, 0x02,
            0x18, 0x03, 0x10, 0x01, 0x00, 0x00,

            // Char 68 ('D') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x08, 0x02, 0x18, 0x03,
            0xf0, 0x01, 0xe0, 0x00, 0x00, 0x00,

            // Char 69 ('E') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x48, 0x02, 0x48, 0x02,
            0x48, 0x02, 0x08, 0x02, 0x00, 0x00,

            // Char 70 ('F') - 6x13 pixels, 12 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x48, 0x00, 0x48, 0x00,
            0x08, 0x00, 0x00, 0x00,

            // Char 71 ('G') - 8x13 pixels, 16 bytes
            0xe0, 0x00, 0xf0, 0x01, 0x18, 0x03, 0x08, 0x02,
            0x58, 0x03, 0xd0, 0x01, 0xc0, 0x00, 0x00, 0x00,

            // Char 72 ('H') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x40, 0x00, 0x40, 0x00,
            0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

            // Char 73 ('I') - 3x13 pixels, 6 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

            // Char 74 ('J') - 5x13 pixels, 10 bytes
            0x00, 0x01, 0x00, 0x02, 0xf8, 0x03, 0xf8, 0x01,
            0x00, 0x00,

            // Char 75 ('K') - 8x13 pixels, 16 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x40, 0x00, 0xe0, 0x00,
            0xb0, 0x01, 0x18, 0x03, 0x08, 0x02, 0x00, 0x00,

            // Char 76 ('L') - 6x13 pixels, 12 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x00, 0x02, 0x00, 0x02,
            0x00, 0x02, 0x00, 0x02,

            // Char 77 ('M') - 8x13 pixels, 16 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x30, 0x00, 0xe0, 0x00,
            0x30, 0x00, 0xf8, 0x03, 0xf8, 0x03, 0x00, 0x00,

            // Char 78 ('N') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x30, 0x00, 0x40, 0x00,
            0x80, 0x01, 0xf8, 0x03, 0x00, 0x00,

            // Char 79 ('O') - 8x13 pixels, 16 bytes
            0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0x08, 0x02,
            0x08, 0x02, 0xf8, 0x03, 0xf0, 0x01, 0x00, 0x00,

            // Char 80 ('P') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x48, 0x00, 0x48, 0x00,
            0x78, 0x00, 0x30, 0x00, 0x00, 0x00,

            // Char 81 ('Q') - 8x13 pixels, 16 bytes
            0xf0, 0x01, 0xf8, 0x03, 0x08, 0x02, 0x08, 0x02,
            0x08, 0x03, 0xf8, 0x01, 0xf0, 0x02, 0x00, 0x00,

            // Char 82 ('R') - 7x13 pixels, 14 bytes
            0xf8, 0x03, 0xf8, 0x03, 0x48, 0x00, 0x48, 0x00,
            0xf8, 0x03, 0xb0, 0x03, 0x00, 0x00,

            // Char 83 ('S') - 7x13 pixels, 14 bytes
            0x30, 0x01, 0x78, 0x03, 0x48, 0x02, 0x48, 0x02,
            0xd8, 0x03, 0x90, 0x01, 0x00, 0x00,

            // Char 84 ('T') - 7x13 pixels, 14 bytes
            0x08, 0x00, 0x08, 0x00, 0xf8, 0x03, 0xf8, 0x03,
            0x08, 0x00, 0x08, 0x00, 0x00, 0x00,

            // Char 85 ('U') - 7x13 pixels, 14 bytes
            0xf8, 0x01, 0xf8, 0x03, 0x00, 0x02, 0x00, 0x02,
            0xf8, 0x03, 0xf8, 0x01, 0x00, 0x00,

            // Char 86 ('V') - 8x13 pixels, 16 bytes
            0x78, 0x00, 0xf8, 0x01, 0x80, 0x03, 0x00, 0x02,
            0x80, 0x03, 0xf8, 0x01, 0x78, 0x00, 0x00, 0x00,

            // Char 87 ('W') - 8x13 pixels, 16 bytes
            0xf8, 0x01, 0xf8, 0x03, 0x00, 0x02, 0xe0, 0x01,
            0x00, 0x02, 0xf8, 0x03, 0xf8, 0x01, 0x00, 0x00,

            // Char 88 ('X') - 8x13 pixels, 16 bytes
            0x08, 0x02, 0x18, 0x03, 0xb0, 0x01, 0xe0, 0x00,
            0xb0, 0x01, 0x18, 0x03, 0x08, 0x02, 0x00, 0x00,

            // Char 89 ('Y') - 7x13 pixels, 14 bytes
            0x38, 0x00, 0x78, 0x00, 0xe0, 0x03, 0xe0, 0x03,
            0x78, 0x00, 0x38, 0x00, 0x00, 0x00,

            // Char 90 ('Z') - 7x13 pixels, 14 bytes
            0x08, 0x03, 0x88, 0x03, 0xc8, 0x02, 0x68, 0x02,
            0x38, 0x02, 0x18, 0x02, 0x00, 0x00,

            // Char 91 ('[') - 3x13 pixels, 6 bytes
            0x00, 0x00, 0xf8, 0x0f, 0x08, 0x08,

            // Char 92 ('\') - 3x13 pixels, 6 bytes
            0x18, 0x00, 0xe0, 0x00, 0x00, 0x03,

            // Char 93 (']') - 3x13 pixels, 4 bytes
            0x08, 0x08, 0xf8, 0x0f,

            // Char 94 ('^') - 5x13 pixels, 9 bytes
            0x40, 0x00, 0x30, 0x00, 0x08, 0x00, 0x30, 0x00,
            0x40,

            // Char 95 ('_') - 6x13 pixels, 12 bytes
            0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
            0x00, 0x08, 0x00, 0x08,

            // Char 96 ('`') - 3x13 pixels, 3 bytes
            0x08, 0x00, 0x10,

            // Char 97 ('a') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xa0, 0x02, 0xa0, 0x02,
            0xe0, 0x03,

            // Char 98 ('b') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xf8, 0x03, 0x20, 0x02, 0x20, 0x02,
            0xc0, 0x01,

            // Char 99 ('c') - 5x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x20, 0x02, 0x20, 0x02,
            0x40, 0x01,

            // Char 100 ('d') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x20, 0x02, 0x20, 0x02,
            0xf8, 0x03,

            // Char 101 ('e') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa0, 0x02, 0xa0, 0x02,
            0xc0, 0x02,

            // Char 102 ('f') - 3x13 pixels, 5 bytes
            0x20, 0x00, 0xf0, 0x03, 0x28,

            // Char 103 ('g') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x05, 0x20, 0x0a, 0x20, 0x0a,
            0xe0, 0x07,

            // Char 104 ('h') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xf8, 0x03, 0x20, 0x00, 0x20, 0x00,
            0xc0, 0x03,

            // Char 105 ('i') - 2x13 pixels, 4 bytes
            0x00, 0x00, 0xe8, 0x03,

            // Char 106 ('j') - 2x13 pixels, 4 bytes
            0x00, 0x08, 0xe8, 0x07,

            // Char 107 ('k') - 5x13 pixels, 8 bytes
            0xf8, 0x03, 0x80, 0x00, 0xc0, 0x01, 0x20, 0x02,

            // Char 108 ('l') - 2x13 pixels, 4 bytes
            0x00, 0x00, 0xf8, 0x03,

            // Char 109 ('m') - 8x13 pixels, 16 bytes
            0x00, 0x00, 0xe0, 0x03, 0x20, 0x00, 0x20, 0x00,
            0xe0, 0x03, 0x20, 0x00, 0x20, 0x00, 0xc0, 0x03,

            // Char 110 ('n') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x03, 0x20, 0x00, 0x20, 0x00,
            0xc0, 0x03,

            // Char 111 ('o') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x20, 0x02, 0x20, 0x02,
            0xc0, 0x01,

            // Char 112 ('p') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x0f, 0x20, 0x02, 0x20, 0x02,
            0xc0, 0x01,

            // Char 113 ('q') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x20, 0x02, 0x20, 0x02,
            0xe0, 0x0f,

            // Char 114 ('r') - 3x13 pixels, 5 bytes
            0x00, 0x00, 0xe0, 0x03, 0x20,

            // Char 115 ('s') - 5x13 pixels, 8 bytes
            0x40, 0x02, 0xa0, 0x02, 0xa0, 0x02, 0x20, 0x01,

            // Char 116 ('t') - 3x13 pixels, 6 bytes
            0x20, 0x00, 0xf8, 0x03, 0x20, 0x02,

            // Char 117 ('u') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x01, 0x00, 0x02, 0x00, 0x02,
            0xe0, 0x03,

            // Char 118 ('v') - 5x13 pixels, 9 bytes
            0x20, 0x00, 0xc0, 0x01, 0x00, 0x02, 0xc0, 0x01,
            0x20,

            // Char 119 ('w') - 7x13 pixels, 14 bytes
            0xe0, 0x01, 0x00, 0x02, 0xc0, 0x01, 0x20, 0x00,
            0xc0, 0x01, 0x00, 0x02, 0xe0, 0x01,

            // Char 120 ('x') - 5x13 pixels, 10 bytes
            0x20, 0x02, 0x40, 0x01, 0x80, 0x00, 0x40, 0x01,
            0x20, 0x02,

            // Char 121 ('y') - 5x13 pixels, 9 bytes
            0x20, 0x00, 0xc0, 0x09, 0x00, 0x06, 0xc0, 0x01,
            0x20,

            // Char 122 ('z') - 5x13 pixels, 10 bytes
            0x20, 0x02, 0x20, 0x03, 0xa0, 0x02, 0x60, 0x02,
            0x20, 0x02,

            // Char 123 ('{') - 3x13 pixels, 6 bytes
            0x80, 0x00, 0x78, 0x0f, 0x08, 0x08,

            // Char 124 ('|') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0xf8, 0x0f,

            // Char 125 ('}') - 3x13 pixels, 5 bytes
            0x08, 0x08, 0x78, 0x0f, 0x80,

            // Char 126 ('~') - 6x13 pixels, 9 bytes
            0xc0, 0x00, 0x40, 0x00, 0xc0, 0x00, 0x80, 0x00,
            0xc0,

            // Char 161 ('?') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0xa0, 0x0f,

            // Char 162 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa0, 0x0f, 0x78, 0x02,
            0x40, 0x01,

            // Char 163 ('?') - 6x13 pixels, 12 bytes
            0x40, 0x02, 0x70, 0x03, 0xc8, 0x02, 0x48, 0x02,
            0x08, 0x02, 0x10, 0x02,

            // Char 164 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x01, 0x20, 0x01, 0x20, 0x01,
            0xe0, 0x01,

            // Char 165 ('?') - 6x13 pixels, 10 bytes
            0x48, 0x01, 0x70, 0x01, 0xc0, 0x03, 0x70, 0x01,
            0x48, 0x01,

            // Char 166 ('?') - 3x13 pixels, 4 bytes
            0x00, 0x00, 0x38, 0x0f,

            // Char 167 ('?') - 6x13 pixels, 10 bytes
            0xd0, 0x04, 0x28, 0x09, 0x48, 0x09, 0x48, 0x0a,
            0x90, 0x05,

            // Char 168 ('?') - 3x13 pixels, 5 bytes
            0x08, 0x00, 0x00, 0x00, 0x08,

            // Char 169 ('?') - 7x13 pixels, 13 bytes
            0xe0, 0x00, 0x10, 0x01, 0x48, 0x02, 0xa8, 0x02,
            0xa8, 0x02, 0x10, 0x01, 0xe0,

            // Char 170 ('?') - 4x13 pixels, 7 bytes
            0x68, 0x00, 0x68, 0x00, 0x68, 0x00, 0x78,

            // Char 171 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x80, 0x01, 0x40, 0x02, 0x80, 0x01,
            0x40, 0x02,

            // Char 172 ('?') - 6x13 pixels, 9 bytes
            0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00,
            0xe0,

            // Char 173 ('?') - 3x13 pixels, 3 bytes
            0x80, 0x00, 0x80,

            // Char 174 ('?') - 7x13 pixels, 13 bytes
            0xe0, 0x00, 0x10, 0x01, 0xe8, 0x02, 0x68, 0x02,
            0xc8, 0x02, 0x10, 0x01, 0xe0,

            // Char 175 ('?') - 6x13 pixels, 11 bytes
            0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00,
            0x02, 0x00, 0x02,

            // Char 176 ('?') - 4x13 pixels, 7 bytes
            0x00, 0x00, 0x38, 0x00, 0x28, 0x00, 0x38,

            // Char 177 ('?') - 5x13 pixels, 10 bytes
            0x40, 0x02, 0x40, 0x02, 0xf0, 0x03, 0x40, 0x02,
            0x40, 0x02,

            // Char 178 ('?') - 3x13 pixels, 5 bytes
            0x48, 0x00, 0x68, 0x00, 0x58,

            // Char 179 ('?') - 3x13 pixels, 5 bytes
            0x48, 0x00, 0x58, 0x00, 0x68,

            // Char 180 ('?') - 3x13 pixels, 5 bytes
            0x00, 0x00, 0x10, 0x00, 0x08,

            // Char 181 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x0f, 0x00, 0x02, 0x00, 0x02,
            0xe0, 0x03,

            // Char 182 ('?') - 5x13 pixels, 9 bytes
            0x70, 0x00, 0xf8, 0x0f, 0x08, 0x00, 0xf8, 0x0f,
            0x08,

            // Char 183 ('?') - 3x13 pixels, 3 bytes
            0x00, 0x00, 0x40,

            // Char 184 ('?') - 3x13 pixels, 6 bytes
            0x00, 0x00, 0x00, 0x14, 0x00, 0x18,

            // Char 185 ('?') - 3x13 pixels, 5 bytes
            0x00, 0x00, 0x10, 0x00, 0x78,

            // Char 186 ('?') - 4x13 pixels, 7 bytes
            0x30, 0x00, 0x48, 0x00, 0x48, 0x00, 0x30,

            // Char 187 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x40, 0x02, 0x80, 0x01, 0x40, 0x02,
            0x80, 0x01,

            // Char 188 ('?') - 8x13 pixels, 16 bytes
            0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0xc0, 0x00,
            0x20, 0x01, 0x90, 0x01, 0xc8, 0x03, 0x00, 0x01,

            // Char 189 ('?') - 8x13 pixels, 16 bytes
            0x00, 0x00, 0x10, 0x02, 0x78, 0x01, 0x80, 0x00,
            0x60, 0x00, 0x50, 0x02, 0x48, 0x03, 0xc0, 0x02,

            // Char 190 ('?') - 8x13 pixels, 16 bytes
            0x48, 0x00, 0x58, 0x00, 0x68, 0x03, 0x80, 0x00,
            0x60, 0x01, 0x90, 0x01, 0xc8, 0x03, 0x00, 0x01,

            // Char 191 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x06, 0x00, 0x09, 0xa0, 0x09,
            0x00, 0x04,

            // Char 192 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc0, 0x01, 0xb0, 0x00, 0x89, 0x00,
            0xb2, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 193 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc0, 0x01, 0xb0, 0x00, 0x8a, 0x00,
            0xb1, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 194 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc0, 0x01, 0xb2, 0x00, 0x89, 0x00,
            0xb2, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 195 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc2, 0x01, 0xb1, 0x00, 0x8a, 0x00,
            0xb1, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 196 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc0, 0x01, 0xb2, 0x00, 0x88, 0x00,
            0xb2, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 197 ('?') - 7x13 pixels, 14 bytes
            0x00, 0x02, 0xc0, 0x01, 0xbe, 0x00, 0x8a, 0x00,
            0xbe, 0x00, 0xc0, 0x01, 0x00, 0x02,

            // Char 198 ('?') - 10x13 pixels, 18 bytes
            0x00, 0x03, 0xc0, 0x00, 0xe0, 0x00, 0x98, 0x00,
            0x88, 0x00, 0xf8, 0x03, 0x48, 0x02, 0x48, 0x02,
            0x48, 0x02,

            // Char 199 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf0, 0x01, 0x08, 0x02, 0x08, 0x16,
            0x08, 0x1a, 0x10, 0x01,

            // Char 200 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x03, 0x49, 0x02, 0x4a, 0x02,
            0x48, 0x02, 0x48, 0x02,

            // Char 201 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x03, 0x48, 0x02, 0x4a, 0x02,
            0x49, 0x02, 0x48, 0x02,

            // Char 202 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xfa, 0x03, 0x49, 0x02, 0x4a, 0x02,
            0x48, 0x02, 0x48, 0x02,

            // Char 203 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x03, 0x4a, 0x02, 0x48, 0x02,
            0x4a, 0x02, 0x48, 0x02,

            // Char 204 ('?') - 3x13 pixels, 5 bytes
            0x00, 0x00, 0xf9, 0x03, 0x02,

            // Char 205 ('?') - 3x13 pixels, 4 bytes
            0x02, 0x00, 0xf9, 0x03,

            // Char 206 ('?') - 3x13 pixels, 4 bytes
            0x01, 0x00, 0xfa, 0x03,

            // Char 207 ('?') - 3x13 pixels, 5 bytes
            0x02, 0x00, 0xf8, 0x03, 0x02,

            // Char 208 ('?') - 7x13 pixels, 11 bytes
            0x40, 0x00, 0xf8, 0x03, 0x48, 0x02, 0x48, 0x02,
            0x10, 0x01, 0xe0,

            // Char 209 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xfa, 0x03, 0x31, 0x00, 0x42, 0x00,
            0x81, 0x01, 0xf8, 0x03,

            // Char 210 ('?') - 8x13 pixels, 14 bytes
            0x00, 0x00, 0xf0, 0x01, 0x08, 0x02, 0x09, 0x02,
            0x0a, 0x02, 0x08, 0x02, 0xf0, 0x01,

            // Char 211 ('?') - 8x13 pixels, 14 bytes
            0x00, 0x00, 0xf0, 0x01, 0x08, 0x02, 0x0a, 0x02,
            0x09, 0x02, 0x08, 0x02, 0xf0, 0x01,

            // Char 212 ('?') - 8x13 pixels, 14 bytes
            0x00, 0x00, 0xf0, 0x01, 0x08, 0x02, 0x0a, 0x02,
            0x09, 0x02, 0x0a, 0x02, 0xf0, 0x01,

            // Char 213 ('?') - 8x13 pixels, 14 bytes
            0x00, 0x00, 0xf0, 0x01, 0x0a, 0x02, 0x09, 0x02,
            0x0a, 0x02, 0x09, 0x02, 0xf0, 0x01,

            // Char 214 ('?') - 8x13 pixels, 14 bytes
            0x00, 0x00, 0xf0, 0x01, 0x0a, 0x02, 0x08, 0x02,
            0x0a, 0x02, 0x08, 0x02, 0xf0, 0x01,

            // Char 215 ('?') - 6x13 pixels, 10 bytes
            0x10, 0x01, 0xa0, 0x00, 0xe0, 0x00, 0xa0, 0x00,
            0x10, 0x01,

            // Char 216 ('?') - 8x13 pixels, 13 bytes
            0x00, 0x00, 0xf0, 0x02, 0x08, 0x03, 0xc8, 0x02,
            0x28, 0x02, 0x18, 0x03, 0xe8,

            // Char 217 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x01, 0x01, 0x02, 0x02, 0x02,
            0x00, 0x02, 0xf8, 0x01,

            // Char 218 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x01, 0x02, 0x02, 0x01, 0x02,
            0x00, 0x02, 0xf8, 0x01,

            // Char 219 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x01, 0x02, 0x02, 0x01, 0x02,
            0x02, 0x02, 0xf8, 0x01,

            // Char 220 ('?') - 7x13 pixels, 12 bytes
            0x00, 0x00, 0xf8, 0x01, 0x02, 0x02, 0x00, 0x02,
            0x02, 0x02, 0xf8, 0x01,

            // Char 221 ('?') - 7x13 pixels, 13 bytes
            0x08, 0x00, 0x10, 0x00, 0x20, 0x00, 0xc2, 0x03,
            0x21, 0x00, 0x10, 0x00, 0x08,

            // Char 222 ('?') - 7x13 pixels, 11 bytes
            0x00, 0x00, 0xf8, 0x03, 0x10, 0x01, 0x10, 0x01,
            0x10, 0x01, 0xe0,

            // Char 223 ('?') - 6x13 pixels, 12 bytes
            0x00, 0x00, 0xf0, 0x03, 0x08, 0x01, 0x48, 0x02,
            0xb0, 0x02, 0x80, 0x01,

            // Char 224 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xa4, 0x02, 0xa8, 0x02,
            0xe0, 0x03,

            // Char 225 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xa8, 0x02, 0xa4, 0x02,
            0xe0, 0x03,

            // Char 226 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xa8, 0x02, 0xa4, 0x02,
            0xe8, 0x03,

            // Char 227 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x08, 0x03, 0xa4, 0x02, 0xa8, 0x02,
            0xe4, 0x03,

            // Char 228 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xa8, 0x02, 0xa0, 0x02,
            0xe8, 0x03,

            // Char 229 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0x00, 0x03, 0xae, 0x02, 0xaa, 0x02,
            0xee, 0x03,

            // Char 230 ('?') - 9x13 pixels, 16 bytes
            0x00, 0x00, 0x40, 0x03, 0xa0, 0x02, 0xa0, 0x02,
            0xc0, 0x01, 0xa0, 0x02, 0xa0, 0x02, 0xc0, 0x02,

            // Char 231 ('?') - 5x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x20, 0x16, 0x20, 0x1a,
            0x40, 0x01,

            // Char 232 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa4, 0x02, 0xa8, 0x02,
            0xc0, 0x02,

            // Char 233 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa8, 0x02, 0xa4, 0x02,
            0xc0, 0x02,

            // Char 234 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa8, 0x02, 0xa4, 0x02,
            0xc8, 0x02,

            // Char 235 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0xa8, 0x02, 0xa0, 0x02,
            0xc8, 0x02,

            // Char 236 ('?') - 3x13 pixels, 5 bytes
            0x00, 0x00, 0xe4, 0x03, 0x08,

            // Char 237 ('?') - 3x13 pixels, 4 bytes
            0x08, 0x00, 0xe4, 0x03,

            // Char 238 ('?') - 3x13 pixels, 5 bytes
            0x08, 0x00, 0xe4, 0x03, 0x08,

            // Char 239 ('?') - 3x13 pixels, 5 bytes
            0x08, 0x00, 0xe0, 0x03, 0x08,

            // Char 240 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x28, 0x02, 0x38, 0x02,
            0xe0, 0x01,

            // Char 241 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe8, 0x03, 0x24, 0x00, 0x28, 0x00,
            0xc4, 0x03,

            // Char 242 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x24, 0x02, 0x28, 0x02,
            0xc0, 0x01,

            // Char 243 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x28, 0x02, 0x24, 0x02,
            0xc0, 0x01,

            // Char 244 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x28, 0x02, 0x24, 0x02,
            0xc8, 0x01,

            // Char 245 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc8, 0x01, 0x24, 0x02, 0x28, 0x02,
            0xc4, 0x01,

            // Char 246 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x01, 0x28, 0x02, 0x20, 0x02,
            0xc8, 0x01,

            // Char 247 ('?') - 5x13 pixels, 9 bytes
            0x40, 0x00, 0x40, 0x00, 0x50, 0x01, 0x40, 0x00,
            0x40,

            // Char 248 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xc0, 0x02, 0xa0, 0x03, 0x60, 0x02,
            0xa0, 0x01,

            // Char 249 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x01, 0x04, 0x02, 0x08, 0x02,
            0xe0, 0x03,

            // Char 250 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x01, 0x08, 0x02, 0x04, 0x02,
            0xe0, 0x03,

            // Char 251 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe8, 0x01, 0x04, 0x02, 0x08, 0x02,
            0xe0, 0x03,

            // Char 252 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xe0, 0x01, 0x08, 0x02, 0x00, 0x02,
            0xe8, 0x03,

            // Char 253 ('?') - 5x13 pixels, 9 bytes
            0x20, 0x00, 0xc0, 0x09, 0x08, 0x06, 0xc4, 0x01,
            0x20,

            // Char 254 ('?') - 6x13 pixels, 10 bytes
            0x00, 0x00, 0xf8, 0x0f, 0x20, 0x02, 0x20, 0x02,
            0xc0, 0x01,

            // Char 255 ('?') - 5x13 pixels, 9 bytes
            0x20, 0x00, 0xc8, 0x09, 0x00, 0x06, 0xc8, 0x01,
            0x20,

        ]);
        const URW_Gothic_L_Book_10 = new Uint8Array([
    // Header: width=13, height=15, firstChar=32, numChars=224
    13, 15, 32, 224,

    // Jump table (224 entries of 4 bytes each: offsetLow, offsetHigh, byteSize, width)
    0xff, 0xff, 0x00, 0x03, // 32 (SPACE)
    0x00, 0x00, 0x06, 0x03, // 33 ('!')
    0x00, 0x06, 0x0a, 0x05, // 34 ('"')
    0x00, 0x10, 0x0c, 0x06, // 35 ('#')
    0x00, 0x1c, 0x0c, 0x06, // 36 ('$')
    0x00, 0x28, 0x14, 0x0a, // 37 ('%')
    0x00, 0x3c, 0x10, 0x08, // 38 ('&')
    0x00, 0x4c, 0x06, 0x03, // 39 (''')

    0x00, 0x52, 0x08, 0x04, // 40 ('(')
    0x00, 0x5a, 0x08, 0x04, // 41 (')')
    0x00, 0x62, 0x0c, 0x06, // 42 ('*')
    0x00, 0x6e, 0x0e, 0x07, // 43 ('+')
    0x00, 0x7c, 0x06, 0x03, // 44 (',')
    0x00, 0x82, 0x0a, 0x05, // 45 ('-')
    0x00, 0x8c, 0x06, 0x03, // 46 ('.')
    0x00, 0x92, 0x0c, 0x06, // 47 ('/')

    0x00, 0x9e, 0x0c, 0x06, // 48 ('0')
    0x00, 0xaa, 0x06, 0x03, // 49 ('1')
    0x00, 0xb0, 0x0c, 0x06, // 50 ('2')
    0x00, 0xbc, 0x0c, 0x06, // 51 ('3')
    0x00, 0xc8, 0x0c, 0x06, // 52 ('4')
    0x00, 0xd4, 0x0c, 0x06, // 53 ('5')
    0x00, 0xe0, 0x0c, 0x06, // 54 ('6')
    0x00, 0xec, 0x0a, 0x05, // 55 ('7')

    0x00, 0xf6, 0x0c, 0x06, // 56 ('8')
    0x01, 0x02, 0x0c, 0x06, // 57 ('9')
    0x01, 0x0e, 0x06, 0x03, // 58 (':')
    0x01, 0x14, 0x06, 0x03, // 59 (';')
    0x01, 0x1a, 0x0a, 0x05, // 60 ('<')
    0x01, 0x24, 0x0e, 0x07, // 61 ('=')
    0x01, 0x32, 0x0a, 0x05, // 62 ('>')
    0x01, 0x3c, 0x0e, 0x07, // 63 ('?')

    0x01, 0x4a, 0x12, 0x09, // 64 ('@')
    0x01, 0x5c, 0x10, 0x08, // 65 ('A')
    0x01, 0x6c, 0x0c, 0x06, // 66 ('B')
    0x01, 0x78, 0x0e, 0x07, // 67 ('C')
    0x01, 0x86, 0x0e, 0x07, // 68 ('D')
    0x01, 0x94, 0x0c, 0x06, // 69 ('E')
    0x01, 0xa0, 0x0c, 0x06, // 70 ('F')
    0x01, 0xac, 0x0e, 0x07, // 71 ('G')

    0x01, 0xba, 0x0e, 0x07, // 72 ('H')
    0x01, 0xc8, 0x04, 0x02, // 73 ('I')
    0x01, 0xcc, 0x0a, 0x05, // 74 ('J')
    0x01, 0xd6, 0x0c, 0x06, // 75 ('K')
    0x01, 0xe2, 0x0a, 0x05, // 76 ('L')
    0x01, 0xec, 0x10, 0x08, // 77 ('M')
    0x01, 0xfc, 0x0e, 0x07, // 78 ('N')
    0x02, 0x0a, 0x10, 0x08, // 79 ('O')

    0x02, 0x1a, 0x0c, 0x06, // 80 ('P')
    0x02, 0x26, 0x10, 0x08, // 81 ('Q')
    0x02, 0x36, 0x0c, 0x06, // 82 ('R')
    0x02, 0x42, 0x0c, 0x06, // 83 ('S')
    0x02, 0x4e, 0x0c, 0x06, // 84 ('T')
    0x02, 0x5a, 0x0c, 0x06, // 85 ('U')
    0x02, 0x66, 0x10, 0x08, // 86 ('V')
    0x02, 0x76, 0x14, 0x0a, // 87 ('W')

    0x02, 0x8a, 0x10, 0x08, // 88 ('X')
    0x02, 0x9a, 0x0c, 0x06, // 89 ('Y')
    0x02, 0xa6, 0x0c, 0x06, // 90 ('Z')
    0x02, 0xb2, 0x06, 0x03, // 91 ('[')
    0x02, 0xb8, 0x0c, 0x06, // 92 ('\')
    0x02, 0xc4, 0x06, 0x03, // 93 (']')
    0x02, 0xca, 0x0c, 0x06, // 94 ('^')
    0x02, 0xd6, 0x0a, 0x05, // 95 ('_')

    0x02, 0xe0, 0x08, 0x04, // 96 ('`')
    0x02, 0xe8, 0x0e, 0x07, // 97 ('a')
    0x02, 0xf6, 0x0e, 0x07, // 98 ('b')
    0x03, 0x04, 0x0e, 0x07, // 99 ('c')
    0x03, 0x12, 0x0e, 0x07, // 100 ('d')
    0x03, 0x20, 0x0c, 0x06, // 101 ('e')
    0x03, 0x2c, 0x08, 0x04, // 102 ('f')
    0x03, 0x34, 0x0e, 0x07, // 103 ('g')

    0x03, 0x42, 0x0c, 0x06, // 104 ('h')
    0x03, 0x4e, 0x04, 0x02, // 105 ('i')
    0x03, 0x52, 0x04, 0x02, // 106 ('j')
    0x03, 0x56, 0x0a, 0x05, // 107 ('k')
    0x03, 0x60, 0x04, 0x02, // 108 ('l')
    0x03, 0x64, 0x10, 0x08, // 109 ('m')
    0x03, 0x74, 0x0c, 0x06, // 110 ('n')
    0x03, 0x80, 0x0e, 0x07, // 111 ('o')

    0x03, 0x8e, 0x0e, 0x07, // 112 ('p')
    0x03, 0x9c, 0x0e, 0x07, // 113 ('q')
    0x03, 0xaa, 0x0a, 0x05, // 114 ('r')
    0x03, 0xb4, 0x0a, 0x05, // 115 ('s')
    0x03, 0xbe, 0x08, 0x04, // 116 ('t')
    0x03, 0xc6, 0x0c, 0x06, // 117 ('u')
    0x03, 0xd2, 0x0c, 0x06, // 118 ('v')
    0x03, 0xde, 0x10, 0x08, // 119 ('w')

    0x03, 0xee, 0x0c, 0x06, // 120 ('x')
    0x03, 0xfa, 0x0a, 0x05, // 121 ('y')
    0x04, 0x04, 0x0c, 0x06, // 122 ('z')
    0x04, 0x10, 0x08, 0x04, // 123 ('{')
    0x04, 0x18, 0x04, 0x02, // 124 ('|')
    0x04, 0x1c, 0x08, 0x04, // 125 ('}')
    0x04, 0x24, 0x0c, 0x06, // 126 ('~')
    0xff, 0xff, 0x00, 0x08, // 127 (DEL)

    0xff, 0xff, 0x00, 0x08, // 128 ('' U+0080)
    0xff, 0xff, 0x00, 0x08, // 129 ('' U+0081)
    0xff, 0xff, 0x00, 0x03, // 130 ('' U+0082)
    0xff, 0xff, 0x00, 0x03, // 131 ('' U+0083)
    0xff, 0xff, 0x00, 0x03, // 132 ('' U+0084)
    0xff, 0xff, 0x00, 0x03, // 133 ('' U+0085)
    0xff, 0xff, 0x00, 0x03, // 134 ('' U+0086)
    0xff, 0xff, 0x00, 0x03, // 135 ('' U+0087)

    0xff, 0xff, 0x00, 0x03, // 136 ('' U+0088)
    0xff, 0xff, 0x00, 0x03, // 137 ('' U+0089)
    0xff, 0xff, 0x00, 0x03, // 138 ('' U+008A)
    0xff, 0xff, 0x00, 0x03, // 139 ('' U+008B)
    0xff, 0xff, 0x00, 0x03, // 140 ('' U+008C)
    0xff, 0xff, 0x00, 0x03, // 141 ('' U+008D)
    0xff, 0xff, 0x00, 0x03, // 142 ('' U+008E)
    0xff, 0xff, 0x00, 0x03, // 143 ('' U+008F)

    0xff, 0xff, 0x00, 0x03, // 144 ('' U+0090)
    0xff, 0xff, 0x00, 0x03, // 145 ('' U+0091)
    0xff, 0xff, 0x00, 0x03, // 146 ('' U+0092)
    0xff, 0xff, 0x00, 0x03, // 147 ('' U+0093)
    0xff, 0xff, 0x00, 0x03, // 148 ('' U+0094)
    0xff, 0xff, 0x00, 0x03, // 149 ('' U+0095)
    0xff, 0xff, 0x00, 0x03, // 150 ('' U+0096)
    0xff, 0xff, 0x00, 0x03, // 151 ('' U+0097)

    0xff, 0xff, 0x00, 0x03, // 152 ('' U+0098)
    0xff, 0xff, 0x00, 0x03, // 153 ('' U+0099)
    0xff, 0xff, 0x00, 0x03, // 154 ('' U+009A)
    0xff, 0xff, 0x00, 0x03, // 155 ('' U+009B)
    0xff, 0xff, 0x00, 0x03, // 156 ('' U+009C)
    0xff, 0xff, 0x00, 0x03, // 157 ('' U+009D)
    0xff, 0xff, 0x00, 0x03, // 158 ('' U+009E)
    0xff, 0xff, 0x00, 0x03, // 159 ('' U+009F)

    0xff, 0xff, 0x00, 0x03, // 160 (NBSP)
    0x04, 0x30, 0x06, 0x03, // 161 ('¡' U+00A1)
    0x04, 0x36, 0x0c, 0x06, // 162 ('¢' U+00A2)
    0x04, 0x42, 0x0c, 0x06, // 163 ('£' U+00A3)
    0x04, 0x4e, 0x0e, 0x07, // 164 ('¤' U+00A4)
    0x04, 0x5c, 0x0c, 0x06, // 165 ('¥' U+00A5)
    0x04, 0x68, 0x06, 0x03, // 166 ('¦' U+00A6)
    0x04, 0x6e, 0x0e, 0x07, // 167 ('§' U+00A7)

    0x04, 0x7c, 0x08, 0x04, // 168 ('¨' U+00A8)
    0x04, 0x84, 0x10, 0x08, // 169 ('©' U+00A9)
    0x04, 0x94, 0x06, 0x03, // 170 ('ª' U+00AA)
    0x04, 0x9a, 0x08, 0x04, // 171 ('«' U+00AB)
    0x04, 0xa2, 0x0e, 0x07, // 172 ('¬' U+00AC)
    0xff, 0xff, 0x00, 0x03, // 173 (SHY)
    0x04, 0xb0, 0x10, 0x08, // 174 ('®' U+00AE)
    0x04, 0xc0, 0x0a, 0x05, // 175 ('¯' U+00AF)

    0x04, 0xca, 0x08, 0x04, // 176 ('°' U+00B0)
    0x04, 0xd2, 0x0e, 0x07, // 177 ('±' U+00B1)
    0x04, 0xe0, 0x08, 0x04, // 178 ('²' U+00B2)
    0x04, 0xe8, 0x0a, 0x05, // 179 ('³' U+00B3)
    0x04, 0xf2, 0x08, 0x04, // 180 ('´' U+00B4)
    0x04, 0xfa, 0x0e, 0x07, // 181 ('µ' U+00B5)
    0x05, 0x08, 0x0e, 0x07, // 182 ('¶' U+00B6)
    0x05, 0x16, 0x06, 0x03, // 183 ('·' U+00B7)

    0x05, 0x1c, 0x06, 0x03, // 184 ('¸' U+00B8)
    0x05, 0x22, 0x08, 0x04, // 185 ('¹' U+00B9)
    0x05, 0x2a, 0x08, 0x04, // 186 ('º' U+00BA)
    0x05, 0x32, 0x08, 0x04, // 187 ('»' U+00BB)
    0x05, 0x3a, 0x12, 0x09, // 188 ('¼' U+00BC)
    0x05, 0x4c, 0x14, 0x0a, // 189 ('½' U+00BD)
    0x05, 0x60, 0x12, 0x09, // 190 ('¾' U+00BE)
    0x05, 0x72, 0x0c, 0x06, // 191 ('¿' U+00BF)

    0x05, 0x7e, 0x0e, 0x07, // 192 ('À' U+00C0)
    0x05, 0x8c, 0x0e, 0x07, // 193 ('Á' U+00C1)
    0x05, 0x9a, 0x0e, 0x07, // 194 ('Â' U+00C2)
    0x05, 0xa8, 0x0e, 0x07, // 195 ('Ã' U+00C3)
    0x05, 0xb6, 0x10, 0x08, // 196 ('Ä' U+00C4)
    0x05, 0xc6, 0x0e, 0x07, // 197 ('Å' U+00C5)
    0x05, 0xd4, 0x14, 0x0a, // 198 ('Æ' U+00C6)
    0x05, 0xe8, 0x10, 0x08, // 199 ('Ç' U+00C7)

    0x05, 0xf8, 0x0c, 0x06, // 200 ('È' U+00C8)
    0x06, 0x04, 0x0c, 0x06, // 201 ('É' U+00C9)
    0x06, 0x10, 0x0c, 0x06, // 202 ('Ê' U+00CA)
    0x06, 0x1c, 0x0a, 0x05, // 203 ('Ë' U+00CB)
    0x06, 0x26, 0x06, 0x03, // 204 ('Ì' U+00CC)
    0x06, 0x2c, 0x06, 0x03, // 205 ('Í' U+00CD)
    0x06, 0x32, 0x06, 0x03, // 206 ('Î' U+00CE)
    0x06, 0x38, 0x08, 0x04, // 207 ('Ï' U+00CF)

    0x06, 0x40, 0x10, 0x08, // 208 ('Ð' U+00D0)
    0x06, 0x50, 0x10, 0x08, // 209 ('Ñ' U+00D1)
    0x06, 0x60, 0x14, 0x0a, // 210 ('Ò' U+00D2)
    0x06, 0x74, 0x14, 0x0a, // 211 ('Ó' U+00D3)
    0x06, 0x88, 0x14, 0x0a, // 212 ('Ô' U+00D4)
    0x06, 0x9c, 0x14, 0x0a, // 213 ('Õ' U+00D5)
    0x06, 0xb0, 0x14, 0x0a, // 214 ('Ö' U+00D6)
    0x06, 0xc4, 0x0c, 0x06, // 215 ('×' U+00D7)

    0x06, 0xd0, 0x14, 0x0a, // 216 ('Ø' U+00D8)
    0x06, 0xe4, 0x0e, 0x07, // 217 ('Ù' U+00D9)
    0x06, 0xf2, 0x0e, 0x07, // 218 ('Ú' U+00DA)
    0x07, 0x00, 0x0e, 0x07, // 219 ('Û' U+00DB)
    0x07, 0x0e, 0x0e, 0x07, // 220 ('Ü' U+00DC)
    0x07, 0x1c, 0x0e, 0x07, // 221 ('Ý' U+00DD)
    0x07, 0x2a, 0x0e, 0x07, // 222 ('Þ' U+00DE)
    0x07, 0x38, 0x0e, 0x07, // 223 ('ß' U+00DF)

    0x07, 0x46, 0x10, 0x08, // 224 ('à' U+00E0)
    0x07, 0x56, 0x10, 0x08, // 225 ('á' U+00E1)
    0x07, 0x66, 0x10, 0x08, // 226 ('â' U+00E2)
    0x07, 0x76, 0x10, 0x08, // 227 ('ã' U+00E3)
    0x07, 0x86, 0x10, 0x08, // 228 ('ä' U+00E4)
    0x07, 0x96, 0x10, 0x08, // 229 ('å' U+00E5)
    0x07, 0xa6, 0x1a, 0x0d, // 230 ('æ' U+00E6)
    0x07, 0xc0, 0x0e, 0x07, // 231 ('ç' U+00E7)

    0x07, 0xce, 0x0e, 0x07, // 232 ('è' U+00E8)
    0x07, 0xdc, 0x0e, 0x07, // 233 ('é' U+00E9)
    0x07, 0xea, 0x0e, 0x07, // 234 ('ê' U+00EA)
    0x07, 0xf8, 0x0e, 0x07, // 235 ('ë' U+00EB)
    0x08, 0x06, 0x06, 0x03, // 236 ('ì' U+00EC)
    0x08, 0x0c, 0x06, 0x03, // 237 ('í' U+00ED)
    0x08, 0x12, 0x06, 0x03, // 238 ('î' U+00EE)
    0x08, 0x18, 0x04, 0x02, // 239 ('ï' U+00EF)

    0x08, 0x1c, 0x10, 0x08, // 240 ('ð' U+00F0)
    0x08, 0x2c, 0x0e, 0x07, // 241 ('ñ' U+00F1)
    0x08, 0x3a, 0x10, 0x08, // 242 ('ò' U+00F2)
    0x08, 0x4a, 0x10, 0x08, // 243 ('ó' U+00F3)
    0x08, 0x5a, 0x10, 0x08, // 244 ('ô' U+00F4)
    0x08, 0x6a, 0x10, 0x08, // 245 ('õ' U+00F5)
    0x08, 0x7a, 0x10, 0x08, // 246 ('ö' U+00F6)
    0x08, 0x8a, 0x0c, 0x06, // 247 ('÷' U+00F7)

    0x08, 0x96, 0x10, 0x08, // 248 ('ø' U+00F8)
    0x08, 0xa6, 0x0e, 0x07, // 249 ('ù' U+00F9)
    0x08, 0xb4, 0x0e, 0x07, // 250 ('ú' U+00FA)
    0x08, 0xc2, 0x0e, 0x07, // 251 ('û' U+00FB)
    0x08, 0xd0, 0x0e, 0x07, // 252 ('ü' U+00FC)
    0x08, 0xde, 0x0a, 0x05, // 253 ('ý' U+00FD)
    0x08, 0xe8, 0x10, 0x08, // 254 ('þ' U+00FE)
    0x08, 0xf8, 0x0c, 0x06, // 255 (NBHY)

    // Character bitmap data
    // Char 33 ('!') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x7e, 0x01, 0x00, 0x00,

    // Char 34 ('"') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
    0x00, 0x00,

    // Char 35 ('#') - 6x15 pixels, 12 bytes
    0x48, 0x00, 0xfe, 0x01, 0x48, 0x00, 0xfe, 0x01,
    0x48, 0x00, 0x00, 0x00,

    // Char 36 ('$') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xcc, 0x00, 0x12, 0x01, 0xff, 0x03,
    0x12, 0x01, 0xe4, 0x00,

    // Char 37 ('%') - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x0c, 0x00, 0x12, 0x00, 0x8c, 0x01,
    0x60, 0x00, 0x18, 0x00, 0xc6, 0x00, 0x20, 0x01,
    0xc0, 0x00, 0x00, 0x00,

    // Char 38 ('&') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xdc, 0x00, 0x32, 0x01, 0x22, 0x01,
    0x52, 0x01, 0x8c, 0x00, 0x40, 0x01, 0x00, 0x00,

    // Char 39 (''') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x06, 0x00, 0x00, 0x00,

    // Char 40 ('(') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0xf8, 0x00, 0x04, 0x01, 0x02, 0x02,

    // Char 41 (')') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x02, 0x02, 0x04, 0x01, 0xf8, 0x00,

    // Char 42 ('*') - 6x15 pixels, 12 bytes
    0x08, 0x00, 0x2a, 0x00, 0x1c, 0x00, 0x1c, 0x00,
    0x2a, 0x00, 0x08, 0x00,

    // Char 43 ('+') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xf8, 0x00,
    0x20, 0x00, 0x20, 0x00, 0x00, 0x00,

    // Char 44 (',') - 3x15 pixels, 6 bytes
    0x00, 0x04, 0x00, 0x03, 0x00, 0x00,

    // Char 45 ('-') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00,
    0x20, 0x00,

    // Char 46 ('.') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x00, 0x01, 0x00, 0x00,

    // Char 47 ('/') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x80, 0x01, 0x60, 0x00, 0x18, 0x00,
    0x06, 0x00, 0x00, 0x00,

    // Char 48 ('0') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfc, 0x00, 0x02, 0x01, 0x32, 0x01,
    0x02, 0x01, 0xfc, 0x00,

    // Char 49 ('1') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x02, 0x00, 0xfe, 0x01,

    // Char 50 ('2') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x0c, 0x01, 0x82, 0x01, 0x42, 0x01,
    0x22, 0x01, 0x1c, 0x01,

    // Char 51 ('3') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x84, 0x00, 0x02, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xec, 0x00,

    // Char 52 ('4') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x60, 0x00, 0x58, 0x00, 0x44, 0x00,
    0xfe, 0x01, 0x40, 0x00,

    // Char 53 ('5') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x9e, 0x00, 0x12, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xe2, 0x00,

    // Char 54 ('6') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xf8, 0x00, 0x14, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xe0, 0x00,

    // Char 55 ('7') - 5x15 pixels, 10 bytes
    0x02, 0x00, 0x82, 0x01, 0x62, 0x00, 0x12, 0x00,
    0x0e, 0x00,

    // Char 56 ('8') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xec, 0x00, 0x12, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xec, 0x00,

    // Char 57 ('9') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x1c, 0x00, 0x22, 0x01, 0x22, 0x01,
    0xa2, 0x00, 0x7c, 0x00,

    // Char 58 (':') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x10, 0x01, 0x00, 0x00,

    // Char 59 (';') - 3x15 pixels, 6 bytes
    0x00, 0x04, 0x10, 0x03, 0x00, 0x00,

    // Char 60 ('<') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x20, 0x00, 0x50, 0x00, 0x88, 0x00,
    0x04, 0x01,

    // Char 61 ('=') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00,
    0x50, 0x00, 0x50, 0x00, 0x00, 0x00,

    // Char 62 ('>') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x04, 0x01, 0x88, 0x00, 0x50, 0x00,
    0x20, 0x00,

    // Char 63 ('?') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x0c, 0x00, 0x02, 0x00, 0x42, 0x01,
    0x22, 0x00, 0x1c, 0x00, 0x00, 0x00,

    // Char 64 ('@') - 9x15 pixels, 18 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x32, 0x01,
    0x4a, 0x01, 0x32, 0x01, 0x44, 0x00, 0x38, 0x00,
    0x00, 0x00,

    // Char 65 ('A') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x80, 0x01, 0x70, 0x00, 0x2c, 0x00,
    0x22, 0x00, 0x2c, 0x00, 0x70, 0x00, 0x80, 0x01,

    // Char 66 ('B') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xec, 0x00,

    // Char 67 ('C') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x01, 0x02, 0x01, 0x84, 0x00,

    // Char 68 ('D') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x01, 0x02, 0x01, 0x02, 0x01,
    0x02, 0x01, 0x84, 0x00, 0x78, 0x00,

    // Char 69 ('E') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x01, 0x12, 0x01,
    0x12, 0x01, 0x02, 0x01,

    // Char 70 ('F') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x00, 0x12, 0x00,
    0x12, 0x00, 0x02, 0x00,

    // Char 71 ('G') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x22, 0x01, 0x22, 0x01, 0xe4, 0x00,

    // Char 72 ('H') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x01, 0x10, 0x00, 0x10, 0x00,
    0x10, 0x00, 0x10, 0x00, 0xfe, 0x01,

    // Char 73 ('I') - 2x15 pixels, 4 bytes
    0x00, 0x00, 0xfe, 0x01,

    // Char 74 ('J') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x01,
    0xfe, 0x00,

    // Char 75 ('K') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x10, 0x00, 0x28, 0x00,
    0x44, 0x00, 0x82, 0x01,

    // Char 76 ('L') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0xfe, 0x01, 0x00, 0x01, 0x00, 0x01,
    0x00, 0x01,

    // Char 77 ('M') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xfe, 0x01, 0x06, 0x00, 0x78, 0x00,
    0xc0, 0x01, 0x78, 0x00, 0x06, 0x00, 0xfe, 0x01,

    // Char 78 ('N') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x01, 0x04, 0x00, 0x18, 0x00,
    0x60, 0x00, 0x80, 0x00, 0xfe, 0x01,

    // Char 79 ('O') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x01, 0x02, 0x01, 0x84, 0x00, 0x78, 0x00,

    // Char 80 ('P') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x22, 0x00, 0x22, 0x00,
    0x22, 0x00, 0x1c, 0x00,

    // Char 81 ('Q') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x42, 0x01, 0x42, 0x01, 0x84, 0x00, 0x78, 0x01,

    // Char 82 ('R') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x22, 0x00, 0x62, 0x00,
    0xa2, 0x00, 0x1c, 0x01,

    // Char 83 ('S') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x8c, 0x00, 0x12, 0x01, 0x12, 0x01,
    0x22, 0x01, 0xc4, 0x00,

    // Char 84 ('T') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0xfe, 0x01,
    0x02, 0x00, 0x02, 0x00,

    // Char 85 ('U') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x00, 0x00, 0x01, 0x00, 0x01,
    0x00, 0x01, 0xfe, 0x00,

    // Char 86 ('V') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x06, 0x00, 0x18, 0x00, 0x60, 0x00,
    0x80, 0x01, 0x60, 0x00, 0x18, 0x00, 0x06, 0x00,

    // Char 87 ('W') - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x0e, 0x00, 0x70, 0x00, 0x80, 0x01,
    0x70, 0x00, 0x0c, 0x00, 0x70, 0x00, 0x80, 0x01,
    0x70, 0x00, 0x0e, 0x00,

    // Char 88 ('X') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x02, 0x01, 0x84, 0x00, 0x48, 0x00,
    0x30, 0x00, 0x48, 0x00, 0x84, 0x00, 0x02, 0x01,

    // Char 89 ('Y') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x0e, 0x00, 0x10, 0x00, 0xe0, 0x01,
    0x10, 0x00, 0x0e, 0x00,

    // Char 90 ('Z') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x82, 0x01, 0x62, 0x01, 0x12, 0x01,
    0x0a, 0x01, 0x06, 0x01,

    // Char 91 ('[') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xfe, 0x03, 0x02, 0x02,

    // Char 92 ('\') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x06, 0x00, 0x18, 0x00, 0x60, 0x00,
    0x80, 0x01, 0x00, 0x00,

    // Char 93 (']') - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x02, 0x02, 0xfe, 0x03,

    // Char 94 ('^') - 6x15 pixels, 12 bytes
    0x20, 0x00, 0x18, 0x00, 0x06, 0x00, 0x18, 0x00,
    0x20, 0x00, 0x00, 0x00,

    // Char 95 ('_') - 5x15 pixels, 10 bytes
    0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04,
    0x00, 0x04,

    // Char 96 ('`') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,

    // Char 97 ('a') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x90, 0x00, 0xf8, 0x01,

    // Char 98 ('b') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x01, 0x90, 0x00, 0x08, 0x01,
    0x08, 0x01, 0x98, 0x01, 0xf0, 0x00,

    // Char 99 ('c') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x08, 0x01, 0x90, 0x00,

    // Char 100 ('d') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x90, 0x00, 0xfe, 0x01,

    // Char 101 ('e') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xf0, 0x00, 0x28, 0x01, 0x28, 0x01,
    0x28, 0x01, 0xb0, 0x00,

    // Char 102 ('f') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x08, 0x00, 0xfe, 0x01, 0x09, 0x00,

    // Char 103 ('g') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x60, 0x04, 0x90, 0x08, 0x08, 0x09,
    0x08, 0x09, 0x90, 0x04, 0xf8, 0x03,

    // Char 104 ('h') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x08, 0x00, 0x08, 0x00,
    0x08, 0x00, 0xf0, 0x01,

    // Char 105 ('i') - 2x15 pixels, 4 bytes
    0x00, 0x00, 0xfa, 0x01,

    // Char 106 ('j') - 2x15 pixels, 4 bytes
    0x00, 0x04, 0xfa, 0x03,

    // Char 107 ('k') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0xfe, 0x01, 0x20, 0x00, 0x50, 0x00,
    0x88, 0x01,

    // Char 108 ('l') - 2x15 pixels, 4 bytes
    0x00, 0x00, 0xfe, 0x01,

    // Char 109 ('m') - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf8, 0x01, 0x08, 0x00, 0x08, 0x00,
    0x70, 0x00, 0x08, 0x00, 0x08, 0x00, 0xf0, 0x01,

    // Char 110 ('n') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xf8, 0x01, 0x08, 0x00, 0x08, 0x00,
    0x08, 0x00, 0xf0, 0x01,

    // Char 111 ('o') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x98, 0x01, 0xf0, 0x00,

    // Char 112 ('p') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x07, 0x90, 0x00, 0x08, 0x01,
    0x08, 0x01, 0x98, 0x01, 0xf0, 0x00,

    // Char 113 ('q') - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x90, 0x00, 0xf8, 0x0f,

    // Char 114 ('r') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0xf0, 0x01, 0x08, 0x00, 0x08, 0x00,
    0x10, 0x00,

    // Char 115 ('s') - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x90, 0x00, 0x28, 0x01, 0x28, 0x01,
    0xc8, 0x00,

    // Char 116 ('t') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x08, 0x00, 0xfe, 0x00, 0x08, 0x01,

    // Char 117 ('u') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xf8, 0x00, 0x00, 0x01, 0x00, 0x01,
    0x00, 0x01, 0xf8, 0x01,

    // Char 118 ('v') - 6x15 pixels, 12 bytes
    0x18, 0x00, 0x60, 0x00, 0x80, 0x01, 0x60, 0x00,
    0x18, 0x00, 0x00, 0x00,

    // Char 119 ('w') - 8x15 pixels, 16 bytes
    0x18, 0x00, 0x60, 0x00, 0x80, 0x01, 0x60, 0x00,
    0x80, 0x01, 0x60, 0x00, 0x18, 0x00, 0x00, 0x00,

    // Char 120 ('x') - 6x15 pixels, 12 bytes
    0x08, 0x01, 0x90, 0x00, 0x60, 0x00, 0x90, 0x00,
    0x08, 0x01, 0x00, 0x00,

    // Char 121 ('y') - 5x15 pixels, 10 bytes
    0x18, 0x00, 0x60, 0x04, 0x80, 0x03, 0x60, 0x00,
    0x18, 0x00,

    // Char 122 ('z') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x88, 0x01, 0x48, 0x01, 0x28, 0x01,
    0x18, 0x01, 0x00, 0x00,

    // Char 123 ('{') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x20, 0x00, 0xdc, 0x01, 0x02, 0x02,

    // Char 124 ('|') - 2x15 pixels, 4 bytes
    0x00, 0x00, 0xfe, 0x03,

    // Char 125 ('}') - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x02, 0x02, 0xdc, 0x01, 0x20, 0x00,

    // Char 126 ('~') - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x03, 0x00,
    0x02, 0x00, 0x01, 0x00,

    // Char 161 ('¡' U+00A1) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xe8, 0x07, 0x00, 0x00,

    // Char 162 ('¢' U+00A2) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x38, 0x00, 0x44, 0x00, 0xfe, 0x00,
    0x44, 0x00, 0x00, 0x00,

    // Char 163 ('£' U+00A3) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x10, 0x01, 0xfc, 0x01, 0x12, 0x01,
    0x12, 0x01, 0xc4, 0x00,

    // Char 164 ('¤' U+00A4) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x68, 0x01, 0x90, 0x00, 0x08, 0x01,
    0x90, 0x00, 0x68, 0x01, 0x00, 0x00,

    // Char 165 ('¥' U+00A5) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x56, 0x00, 0x78, 0x00, 0xc0, 0x01,
    0x78, 0x00, 0x56, 0x00,

    // Char 166 ('¦' U+00A6) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xce, 0x01, 0x00, 0x00,

    // Char 167 ('§' U+00A7) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x7c, 0x02, 0x52, 0x04, 0x92, 0x04,
    0xa4, 0x03, 0x60, 0x00, 0x00, 0x00,

    // Char 168 ('¨' U+00A8) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,

    // Char 169 ('©' U+00A9) - 8x15 pixels, 16 bytes
    0xf8, 0x00, 0x04, 0x01, 0x72, 0x02, 0x8a, 0x02,
    0x8a, 0x02, 0x52, 0x02, 0x04, 0x01, 0xf8, 0x00,

    // Char 170 ('ª' U+00AA) - 3x15 pixels, 6 bytes
    0x28, 0x00, 0x34, 0x00, 0x3c, 0x00,

    // Char 171 ('«' U+00AB) - 4x15 pixels, 8 bytes
    0x60, 0x00, 0x90, 0x00, 0x60, 0x00, 0x90, 0x00,

    // Char 172 ('¬' U+00AC) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x00,
    0x10, 0x00, 0xf0, 0x00, 0x00, 0x00,

    // Char 174 ('®' U+00AE) - 8x15 pixels, 16 bytes
    0xf8, 0x00, 0x04, 0x01, 0xfa, 0x02, 0x2a, 0x02,
    0x2a, 0x02, 0xd2, 0x02, 0x04, 0x01, 0xf8, 0x00,

    // Char 175 ('¯' U+00AF) - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00,
    0x00, 0x00,

    // Char 176 ('°' U+00B0) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x04, 0x00, 0x0a, 0x00, 0x04, 0x00,

    // Char 177 ('±' U+00B1) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x20, 0x01, 0x20, 0x01, 0xf8, 0x01,
    0x20, 0x01, 0x20, 0x01, 0x00, 0x00,

    // Char 178 ('²' U+00B2) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x19, 0x00, 0x15, 0x00, 0x12, 0x00,

    // Char 179 ('³' U+00B3) - 5x15 pixels, 10 bytes
    0x00, 0x00, 0x11, 0x00, 0x15, 0x00, 0x0a, 0x00,
    0x00, 0x00,

    // Char 180 ('´' U+00B4) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,

    // Char 181 ('µ' U+00B5) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x07, 0x00, 0x01, 0x00, 0x01,
    0x00, 0x01, 0xf8, 0x00, 0x00, 0x00,

    // Char 182 ('¶' U+00B6) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x1c, 0x00, 0x3e, 0x00, 0xfe, 0x07,
    0x02, 0x00, 0xfe, 0x07, 0x00, 0x00,

    // Char 183 ('·' U+00B7) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x20, 0x00, 0x00, 0x00,

    // Char 184 ('¸' U+00B8) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0x00, 0x08, 0x00, 0x08,

    // Char 185 ('¹' U+00B9) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x04, 0x00, 0x3c, 0x00, 0x00, 0x00,

    // Char 186 ('º' U+00BA) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x5c, 0x00, 0x54, 0x00, 0x48, 0x00,

    // Char 187 ('»' U+00BB) - 4x15 pixels, 8 bytes
    0x90, 0x00, 0x60, 0x00, 0x90, 0x00, 0x60, 0x00,

    // Char 188 ('¼' U+00BC) - 9x15 pixels, 18 bytes
    0x00, 0x00, 0x02, 0x00, 0x1e, 0x01, 0xc0, 0x00,
    0x30, 0x00, 0xcc, 0x00, 0xa2, 0x00, 0xf0, 0x01,
    0x00, 0x00,

    // Char 189 ('½' U+00BD) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0xc0, 0x01,
    0x30, 0x00, 0x0e, 0x00, 0x90, 0x01, 0x50, 0x01,
    0x30, 0x01, 0x00, 0x00,

    // Char 190 ('¾' U+00BE) - 9x15 pixels, 18 bytes
    0x00, 0x00, 0x26, 0x00, 0x2a, 0x00, 0xf4, 0x01,
    0x30, 0x00, 0xcc, 0x00, 0xa0, 0x00, 0xf0, 0x01,
    0x00, 0x00,

    // Char 191 ('¿' U+00BF) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x80, 0x03, 0x40, 0x04, 0x28, 0x04,
    0x00, 0x02, 0x00, 0x00,

    // Char 192 ('À' U+00C0) - 7x15 pixels, 14 bytes
    0x80, 0x01, 0x70, 0x00, 0x2c, 0x00, 0x22, 0x40,
    0x2c, 0x00, 0x70, 0x00, 0x80, 0x01,

    // Char 193 ('Á' U+00C1) - 7x15 pixels, 14 bytes
    0x80, 0x01, 0x70, 0x00, 0x2c, 0x00, 0x22, 0x40,
    0x2c, 0x40, 0x70, 0x00, 0x80, 0x01,

    // Char 194 ('Â' U+00C2) - 7x15 pixels, 14 bytes
    0x80, 0x01, 0x70, 0x00, 0x2d, 0x00, 0x22, 0x40,
    0x2c, 0x40, 0x70, 0x00, 0x80, 0x01,

    // Char 195 ('Ã' U+00C3) - 7x15 pixels, 14 bytes
    0x80, 0x01, 0x70, 0x00, 0x2c, 0x40, 0x22, 0x40,
    0x2c, 0x40, 0x70, 0x00, 0x80, 0x01,

    // Char 196 ('Ä' U+00C4) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xc0, 0x01, 0x38, 0x00, 0x26, 0x40,
    0x2c, 0x40, 0x70, 0x00, 0x80, 0x01, 0x00, 0x00,

    // Char 197 ('Å' U+00C5) - 7x15 pixels, 14 bytes
    0x00, 0x01, 0xc0, 0x00, 0x38, 0x40, 0x27, 0x20,
    0x2f, 0x60, 0x30, 0x00, 0xc0, 0x01,

    // Char 198 ('Æ' U+00C6) - 10x15 pixels, 20 bytes
    0x80, 0x01, 0x40, 0x00, 0x30, 0x00, 0x28, 0x00,
    0x26, 0x00, 0xfe, 0x01, 0x12, 0x01, 0x12, 0x01,
    0x12, 0x01, 0x00, 0x00,

    // Char 199 ('Ç' U+00C7) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x0b, 0x02, 0x05, 0x86, 0x01, 0x84, 0x00,

    // Char 200 ('È' U+00C8) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x41, 0x12, 0x41,
    0x12, 0x01, 0x00, 0x00,

    // Char 201 ('É' U+00C9) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x01, 0x12, 0x41,
    0x12, 0x01, 0x00, 0x00,

    // Char 202 ('Ê' U+00CA) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0xff, 0x01, 0x12, 0x41, 0x12, 0x41,
    0x13, 0x01, 0x00, 0x00,

    // Char 203 ('Ë' U+00CB) - 5x15 pixels, 10 bytes
    0x00, 0x00, 0xfe, 0x01, 0x12, 0x41, 0x12, 0x41,
    0x12, 0x01,

    // Char 204 ('Ì' U+00CC) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xfe, 0x41, 0x00, 0x00,

    // Char 205 ('Í' U+00CD) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xfe, 0x41, 0x00, 0x00,

    // Char 206 ('Î' U+00CE) - 3x15 pixels, 6 bytes
    0x01, 0x00, 0xfe, 0x41, 0x01, 0x00,

    // Char 207 ('Ï' U+00CF) - 4x15 pixels, 8 bytes
    0x00, 0x00, 0x00, 0x40, 0xfe, 0x41, 0x00, 0x00,

    // Char 208 ('Ð' U+00D0) - 8x15 pixels, 16 bytes
    0x10, 0x00, 0xfe, 0x01, 0x12, 0x01, 0x12, 0x01,
    0x02, 0x01, 0x84, 0x00, 0x78, 0x00, 0x00, 0x00,

    // Char 209 ('Ñ' U+00D1) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xfe, 0x01, 0x06, 0x00, 0x18, 0x40,
    0x60, 0x40, 0x80, 0x00, 0xfe, 0x01, 0x00, 0x00,

    // Char 210 ('Ò' U+00D2) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x41, 0x03, 0x01, 0x02, 0x01, 0x84, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 211 ('Ó' U+00D3) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x01, 0x02, 0x41, 0x02, 0x01, 0x84, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 212 ('Ô' U+00D4) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x41, 0x02, 0x41, 0x02, 0x01, 0x84, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 213 ('Õ' U+00D5) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x41, 0x02, 0x41, 0x02, 0x01, 0x84, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 214 ('Ö' U+00D6) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x00, 0x02, 0x01,
    0x02, 0x41, 0x02, 0x41, 0x02, 0x01, 0x84, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 215 ('×' U+00D7) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x90, 0x00, 0x60, 0x00, 0x60, 0x00,
    0x90, 0x00, 0x00, 0x00,

    // Char 216 ('Ø' U+00D8) - 10x15 pixels, 20 bytes
    0x00, 0x00, 0x78, 0x00, 0x84, 0x01, 0xc2, 0x01,
    0x22, 0x01, 0x1a, 0x01, 0x06, 0x01, 0x86, 0x00,
    0x78, 0x00, 0x00, 0x00,

    // Char 217 ('Ù' U+00D9) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x00, 0x00, 0x01, 0x00, 0x41,
    0x00, 0x01, 0xfe, 0x00, 0x00, 0x00,

    // Char 218 ('Ú' U+00DA) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x00, 0x00, 0x01, 0x00, 0x41,
    0x00, 0x01, 0xfe, 0x00, 0x00, 0x00,

    // Char 219 ('Û' U+00DB) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x00, 0x00, 0x41, 0x00, 0x41,
    0x00, 0x01, 0xfe, 0x00, 0x00, 0x00,

    // Char 220 ('Ü' U+00DC) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x00, 0x00, 0x41, 0x00, 0x01,
    0x00, 0x41, 0xfe, 0x00, 0x00, 0x00,

    // Char 221 ('Ý' U+00DD) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0x06, 0x00, 0x18, 0x00, 0xe0, 0x41,
    0x18, 0x40, 0x06, 0x00, 0x00, 0x00,

    // Char 222 ('Þ' U+00DE) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfe, 0x01, 0x44, 0x00, 0x44, 0x00,
    0x44, 0x00, 0x38, 0x00, 0x00, 0x00,

    // Char 223 ('ß' U+00DF) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xfc, 0x01, 0x82, 0x00, 0x12, 0x01,
    0x1c, 0x01, 0xe0, 0x00, 0x00, 0x00,

    // Char 224 ('à' U+00E0) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x08, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 225 ('á' U+00E1) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x0a, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 226 ('â' U+00E2) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 227 ('ã' U+00E3) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x92, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 228 ('ä' U+00E4) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 229 ('å' U+00E5) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0f, 0x01, 0x90, 0x00, 0xf8, 0x01, 0x00, 0x00,

    // Char 230 ('æ' U+00E6) - 13x15 pixels, 26 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x01, 0x90, 0x00, 0xf8, 0x01, 0xb0, 0x00,
    0x28, 0x01, 0x28, 0x01, 0x28, 0x01, 0xb0, 0x00,
    0x00, 0x00,

    // Char 231 ('ç' U+00E7) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x08, 0x0f, 0x98, 0x01, 0x80, 0x00,

    // Char 232 ('è' U+00E8) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0xa8, 0x01, 0x2a, 0x01,
    0x28, 0x01, 0xa8, 0x01, 0x30, 0x00,

    // Char 233 ('é' U+00E9) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0xa8, 0x01, 0x28, 0x01,
    0x2a, 0x01, 0xa8, 0x01, 0x30, 0x00,

    // Char 234 ('ê' U+00EA) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0xa8, 0x01, 0x2a, 0x01,
    0x2a, 0x01, 0xa8, 0x01, 0x30, 0x00,

    // Char 235 ('ë' U+00EB) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf0, 0x00, 0xa8, 0x01, 0x2a, 0x01,
    0x2a, 0x01, 0xb8, 0x00, 0x20, 0x00,

    // Char 236 ('ì' U+00EC) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xfa, 0x01, 0x00, 0x00,

    // Char 237 ('í' U+00ED) - 3x15 pixels, 6 bytes
    0x00, 0x00, 0xfa, 0x01, 0x00, 0x00,

    // Char 238 ('î' U+00EE) - 3x15 pixels, 6 bytes
    0x02, 0x00, 0xfa, 0x01, 0x02, 0x00,

    // Char 239 ('ï' U+00EF) - 2x15 pixels, 4 bytes
    0x02, 0x00, 0xfa, 0x01,

    // Char 240 ('ð' U+00F0) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0e, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 241 ('ñ' U+00F1) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x01, 0x12, 0x00, 0x0a, 0x00,
    0x0a, 0x00, 0xf0, 0x01, 0x00, 0x00,

    // Char 242 ('ò' U+00F2) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x08, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 243 ('ó' U+00F3) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x08, 0x01,
    0x0a, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 244 ('ô' U+00F4) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 245 ('õ' U+00F5) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 246 ('ö' U+00F6) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x0a, 0x01,
    0x0a, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 247 ('÷' U+00F7) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x20, 0x00, 0xb0, 0x00, 0x20, 0x00,
    0x20, 0x00, 0x20, 0x00,

    // Char 248 ('ø' U+00F8) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xf0, 0x00, 0x98, 0x01, 0x48, 0x01,
    0x38, 0x01, 0x98, 0x01, 0xe0, 0x00, 0x00, 0x00,

    // Char 249 ('ù' U+00F9) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x00, 0x02, 0x01, 0x02, 0x01,
    0x00, 0x01, 0xf8, 0x01, 0x00, 0x00,

    // Char 250 ('ú' U+00FA) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x00, 0x00, 0x01, 0x02, 0x01,
    0x01, 0x01, 0xf8, 0x01, 0x00, 0x00,

    // Char 251 ('û' U+00FB) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x00, 0x04, 0x01, 0x02, 0x01,
    0x04, 0x01, 0xf8, 0x01, 0x00, 0x00,

    // Char 252 ('ü' U+00FC) - 7x15 pixels, 14 bytes
    0x00, 0x00, 0xf8, 0x00, 0x02, 0x01, 0x00, 0x01,
    0x02, 0x01, 0xf8, 0x01, 0x00, 0x00,

    // Char 253 ('ý' U+00FD) - 5x15 pixels, 10 bytes
    0x18, 0x00, 0x60, 0x04, 0x82, 0x03, 0x62, 0x00,
    0x18, 0x00,

    // Char 254 ('þ' U+00FE) - 8x15 pixels, 16 bytes
    0x00, 0x00, 0xfe, 0x07, 0x90, 0x00, 0x08, 0x01,
    0x08, 0x01, 0x98, 0x01, 0xf0, 0x00, 0x00, 0x00,

    // Char 255 (NBHY) - 6x15 pixels, 12 bytes
    0x00, 0x00, 0x38, 0x00, 0xc2, 0x06, 0xc2, 0x01,
    0x38, 0x00, 0x00, 0x00,
 ]);

        availableFonts = {
             'ArialMT_Plain_10': ArialMT_Plain_10,
             'ArialMT_Bold_10': ArialMT_Bold_10,
             'URW_Gothic_L_Book_10': URW_Gothic_L_Book_10,
             'Custom_font_10': Custom_font_10
         }
 </script>
 </body>
 </html>