Merge pull request #237 from fdlamotte/t114_monochrome

T114 monochrome

examples/companion_radio/UITask.cpp

@@ -106,6 +106,7 @@ void UITask::renderCurrScreen() {
     _display->setColor(DisplayDriver::ORANGE);
     sprintf(tmp, "%d", _msgcount);
     _display->print(tmp);
+    _display->setColor(DisplayDriver::YELLOW); // last color will be kept on T114
   } else {
     // render 'home' screen
     _display->setColor(DisplayDriver::BLUE);
@@ -120,6 +121,7 @@ void UITask::renderCurrScreen() {
     _display->print(_version_info);
 
     if (_connected) {
+      _display->setColor(DisplayDriver::BLUE);
       //_display->printf("freq : %03.2f sf %d\n", _prefs.freq, _prefs.sf);
       //_display->printf("bw   : %03.2f cr %d\n", _prefs.bw, _prefs.cr);
     } else if (_pin_code != 0) {
@@ -128,6 +130,9 @@ void UITask::renderCurrScreen() {
       _display->setCursor(0, 43);
       sprintf(tmp, "Pin:%d", _pin_code);
       _display->print(tmp);
+      _display->setColor(DisplayDriver::GREEN);
+    } else {
+      _display->setColor(DisplayDriver::LIGHT);
     }
   }
   _need_refresh = false;

src/helpers/ui/OLEDDisplay.cpp

@@ -0,0 +1,1176 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
+ * Copyright (c) 2019 by Helmut Tschemernjak - www.radioshuttle.de
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
+ */
+
+ /*
+  * TODO Helmut
+  * - test/finish dislplay.printf() on mbed-os
+  * - Finish _putc with drawLogBuffer when running display
+  */
+
+#include "OLEDDisplay.h"
+
+OLEDDisplay::OLEDDisplay() {
+
+	displayWidth = 128;
+	displayHeight = 64;
+	displayBufferSize = displayWidth * displayHeight / 8;
+	color = WHITE;
+	geometry = GEOMETRY_128_64;
+	textAlignment = TEXT_ALIGN_LEFT;
+	fontData = ArialMT_Plain_10;
+	fontTableLookupFunction = DefaultFontTableLookup;
+	buffer = NULL;
+#ifdef OLEDDISPLAY_DOUBLE_BUFFER
+	buffer_back = NULL;
+#endif
+}
+
+OLEDDisplay::~OLEDDisplay() {
+  end();
+}
+
+bool OLEDDisplay::allocateBuffer() {
+
+  logBufferSize = 0;
+  logBufferFilled = 0;
+  logBufferLine = 0;
+  logBufferMaxLines = 0;
+  logBuffer = NULL;
+
+  if (!connect()) {
+    DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Can't establish connection to display\n");
+    return false;
+  }
+
+  if(this->buffer==NULL) {
+    this->buffer = (uint8_t*) malloc((sizeof(uint8_t) * displayBufferSize) + BufferOffset);
+    this->buffer += BufferOffset;
+
+    if(!this->buffer) {
+      DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Not enough memory to create display\n");
+      return false;
+    }
+  }
+
+  #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+  if(this->buffer_back==NULL) {
+    this->buffer_back = (uint8_t*) malloc((sizeof(uint8_t) * displayBufferSize) + BufferOffset);
+    this->buffer_back += BufferOffset;
+
+    if(!this->buffer_back) {
+      DEBUG_OLEDDISPLAY("[OLEDDISPLAY][init] Not enough memory to create back buffer\n");
+      free(this->buffer - BufferOffset);
+      return false;
+    }
+  }
+  #endif
+
+  return true;
+}
+
+bool OLEDDisplay::init() {
+
+  BufferOffset = getBufferOffset();
+
+  if(!allocateBuffer()) {
+    return false;
+  }
+
+  sendInitCommands();
+  resetDisplay();
+
+  return true;
+}
+
+void OLEDDisplay::end() {
+  if (this->buffer) { free(this->buffer - BufferOffset); this->buffer = NULL; }
+  #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+  if (this->buffer_back) { free(this->buffer_back - BufferOffset); this->buffer_back = NULL; }
+  #endif
+  if (this->logBuffer != NULL) { free(this->logBuffer); this->logBuffer = NULL; }
+}
+
+void OLEDDisplay::resetDisplay(void) {
+  clear();
+  #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+  memset(buffer_back, 1, displayBufferSize);
+  #endif
+  display();
+}
+
+void OLEDDisplay::setColor(OLEDDISPLAY_COLOR color) {
+  this->color = color;
+}
+
+OLEDDISPLAY_COLOR OLEDDisplay::getColor() {
+  return this->color;
+}
+
+void OLEDDisplay::setPixel(int16_t x, int16_t y) {
+  if (x >= 0 && x < this->width() && y >= 0 && y < this->height()) {
+    switch (color) {
+      case WHITE:   buffer[x + (y / 8) * this->width()] |=  (1 << (y & 7)); break;
+      case BLACK:   buffer[x + (y / 8) * this->width()] &= ~(1 << (y & 7)); break;
+      case INVERSE: buffer[x + (y / 8) * this->width()] ^=  (1 << (y & 7)); break;
+    }
+  }
+}
+
+void OLEDDisplay::setPixelColor(int16_t x, int16_t y, OLEDDISPLAY_COLOR color) {
+  if (x >= 0 && x < this->width() && y >= 0 && y < this->height()) {
+    switch (color) {
+      case WHITE:   buffer[x + (y / 8) * this->width()] |=  (1 << (y & 7)); break;
+      case BLACK:   buffer[x + (y / 8) * this->width()] &= ~(1 << (y & 7)); break;
+      case INVERSE: buffer[x + (y / 8) * this->width()] ^=  (1 << (y & 7)); break;
+    }
+  }
+}
+
+void OLEDDisplay::clearPixel(int16_t x, int16_t y) {
+  if (x >= 0 && x < this->width() && y >= 0 && y < this->height()) {
+    switch (color) {
+      case BLACK:   buffer[x + (y >> 3) * this->width()] |=  (1 << (y & 7)); break;
+      case WHITE:   buffer[x + (y >> 3) * this->width()] &= ~(1 << (y & 7)); break;
+      case INVERSE: buffer[x + (y >> 3) * this->width()] ^=  (1 << (y & 7)); break;
+    }
+  }
+}
+
+
+// Bresenham's algorithm - thx wikipedia and Adafruit_GFX
+void OLEDDisplay::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1) {
+  int16_t steep = abs(y1 - y0) > abs(x1 - x0);
+  if (steep) {
+    _swap_int16_t(x0, y0);
+    _swap_int16_t(x1, y1);
+  }
+
+  if (x0 > x1) {
+    _swap_int16_t(x0, x1);
+    _swap_int16_t(y0, y1);
+  }
+
+  int16_t dx, dy;
+  dx = x1 - x0;
+  dy = abs(y1 - y0);
+
+  int16_t err = dx / 2;
+  int16_t ystep;
+
+  if (y0 < y1) {
+    ystep = 1;
+  } else {
+    ystep = -1;
+  }
+
+  for (; x0<=x1; x0++) {
+    if (steep) {
+      setPixel(y0, x0);
+    } else {
+      setPixel(x0, y0);
+    }
+    err -= dy;
+    if (err < 0) {
+      y0 += ystep;
+      err += dx;
+    }
+  }
+}
+
+void OLEDDisplay::drawRect(int16_t x, int16_t y, int16_t width, int16_t height) {
+  drawHorizontalLine(x, y, width);
+  drawVerticalLine(x, y, height);
+  drawVerticalLine(x + width - 1, y, height);
+  drawHorizontalLine(x, y + height - 1, width);
+}
+
+void OLEDDisplay::fillRect(int16_t xMove, int16_t yMove, int16_t width, int16_t height) {
+  for (int16_t x = xMove; x < xMove + width; x++) {
+    drawVerticalLine(x, yMove, height);
+  }
+}
+
+void OLEDDisplay::drawCircle(int16_t x0, int16_t y0, int16_t radius) {
+  int16_t x = 0, y = radius;
+	int16_t dp = 1 - radius;
+	do {
+		if (dp < 0)
+			dp = dp + (x++) * 2 + 3;
+		else
+			dp = dp + (x++) * 2 - (y--) * 2 + 5;
+
+		setPixel(x0 + x, y0 + y);     //For the 8 octants
+		setPixel(x0 - x, y0 + y);
+		setPixel(x0 + x, y0 - y);
+		setPixel(x0 - x, y0 - y);
+		setPixel(x0 + y, y0 + x);
+		setPixel(x0 - y, y0 + x);
+		setPixel(x0 + y, y0 - x);
+		setPixel(x0 - y, y0 - x);
+
+	} while (x < y);
+
+  setPixel(x0 + radius, y0);
+  setPixel(x0, y0 + radius);
+  setPixel(x0 - radius, y0);
+  setPixel(x0, y0 - radius);
+}
+
+void OLEDDisplay::drawCircleQuads(int16_t x0, int16_t y0, int16_t radius, uint8_t quads) {
+  int16_t x = 0, y = radius;
+  int16_t dp = 1 - radius;
+  while (x < y) {
+    if (dp < 0)
+      dp = dp + (x++) * 2 + 3;
+    else
+      dp = dp + (x++) * 2 - (y--) * 2 + 5;
+    if (quads & 0x1) {
+      setPixel(x0 + x, y0 - y);
+      setPixel(x0 + y, y0 - x);
+    }
+    if (quads & 0x2) {
+      setPixel(x0 - y, y0 - x);
+      setPixel(x0 - x, y0 - y);
+    }
+    if (quads & 0x4) {
+      setPixel(x0 - y, y0 + x);
+      setPixel(x0 - x, y0 + y);
+    }
+    if (quads & 0x8) {
+      setPixel(x0 + x, y0 + y);
+      setPixel(x0 + y, y0 + x);
+    }
+  }
+  if (quads & 0x1 && quads & 0x8) {
+    setPixel(x0 + radius, y0);
+  }
+  if (quads & 0x4 && quads & 0x8) {
+    setPixel(x0, y0 + radius);
+  }
+  if (quads & 0x2 && quads & 0x4) {
+    setPixel(x0 - radius, y0);
+  }
+  if (quads & 0x1 && quads & 0x2) {
+    setPixel(x0, y0 - radius);
+  }
+}
+
+
+void OLEDDisplay::fillCircle(int16_t x0, int16_t y0, int16_t radius) {
+  int16_t x = 0, y = radius;
+	int16_t dp = 1 - radius;
+	do {
+		if (dp < 0)
+      dp = dp + (x++) * 2 + 3;
+    else
+      dp = dp + (x++) * 2 - (y--) * 2 + 5;
+
+    drawHorizontalLine(x0 - x, y0 - y, 2*x);
+    drawHorizontalLine(x0 - x, y0 + y, 2*x);
+    drawHorizontalLine(x0 - y, y0 - x, 2*y);
+    drawHorizontalLine(x0 - y, y0 + x, 2*y);
+
+
+	} while (x < y);
+  drawHorizontalLine(x0 - radius, y0, 2 * radius);
+
+}
+
+void OLEDDisplay::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+                               int16_t x2, int16_t y2) {
+  drawLine(x0, y0, x1, y1);
+  drawLine(x1, y1, x2, y2);
+  drawLine(x2, y2, x0, y0);
+}
+
+void OLEDDisplay::fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
+                               int16_t x2, int16_t y2) {
+  int16_t a, b, y, last;
+
+  if (y0 > y1) {
+    _swap_int16_t(y0, y1);
+    _swap_int16_t(x0, x1);
+  }
+  if (y1 > y2) {
+    _swap_int16_t(y2, y1);
+    _swap_int16_t(x2, x1);
+  }
+  if (y0 > y1) {
+    _swap_int16_t(y0, y1);
+    _swap_int16_t(x0, x1);
+  }
+
+  if (y0 == y2) {
+    a = b = x0;
+    if (x1 < a) {
+      a = x1;
+    } else if (x1 > b) {
+      b = x1;
+    }
+    if (x2 < a) {
+      a = x2;
+    } else if (x2 > b) {
+      b = x2;
+    }
+    drawHorizontalLine(a, y0, b - a + 1);
+    return;
+  }
+
+  int16_t
+    dx01 = x1 - x0,
+    dy01 = y1 - y0,
+    dx02 = x2 - x0,
+    dy02 = y2 - y0,
+    dx12 = x2 - x1,
+    dy12 = y2 - y1;
+  int32_t
+    sa   = 0,
+    sb   = 0;
+
+  if (y1 == y2) {
+    last = y1; // Include y1 scanline
+  } else {
+    last = y1 - 1; // Skip it
+  }
+
+  for (y = y0; y <= last; y++) {
+    a = x0 + sa / dy01;
+    b = x0 + sb / dy02;
+    sa += dx01;
+    sb += dx02;
+
+    if (a > b) {
+      _swap_int16_t(a, b);
+    }
+    drawHorizontalLine(a, y, b - a + 1);
+  }
+
+  sa = dx12 * (y - y1);
+  sb = dx02 * (y - y0);
+  for (; y <= y2; y++) {
+    a = x1 + sa / dy12;
+    b = x0 + sb / dy02;
+    sa += dx12;
+    sb += dx02;
+
+    if (a > b) {
+      _swap_int16_t(a, b);
+    }
+    drawHorizontalLine(a, y, b - a + 1);
+  }
+}
+
+void OLEDDisplay::drawHorizontalLine(int16_t x, int16_t y, int16_t length) {
+  if (y < 0 || y >= this->height()) { return; }
+
+  if (x < 0) {
+    length += x;
+    x = 0;
+  }
+
+  if ( (x + length) > this->width()) {
+    length = (this->width() - x);
+  }
+
+  if (length <= 0) { return; }
+
+  uint8_t * bufferPtr = buffer;
+  bufferPtr += (y >> 3) * this->width();
+  bufferPtr += x;
+
+  uint8_t drawBit = 1 << (y & 7);
+
+  switch (color) {
+    case WHITE:   while (length--) {
+        *bufferPtr++ |= drawBit;
+      }; break;
+    case BLACK:   drawBit = ~drawBit;   while (length--) {
+        *bufferPtr++ &= drawBit;
+      }; break;
+    case INVERSE: while (length--) {
+        *bufferPtr++ ^= drawBit;
+      }; break;
+  }
+}
+
+void OLEDDisplay::drawVerticalLine(int16_t x, int16_t y, int16_t length) {
+  if (x < 0 || x >= this->width()) return;
+
+  if (y < 0) {
+    length += y;
+    y = 0;
+  }
+
+  if ( (y + length) > this->height()) {
+    length = (this->height() - y);
+  }
+
+  if (length <= 0) return;
+
+
+  uint8_t yOffset = y & 7;
+  uint8_t drawBit;
+  uint8_t *bufferPtr = buffer;
+
+  bufferPtr += (y >> 3) * this->width();
+  bufferPtr += x;
+
+  if (yOffset) {
+    yOffset = 8 - yOffset;
+    drawBit = ~(0xFF >> (yOffset));
+
+    if (length < yOffset) {
+      drawBit &= (0xFF >> (yOffset - length));
+    }
+
+    switch (color) {
+      case WHITE:   *bufferPtr |=  drawBit; break;
+      case BLACK:   *bufferPtr &= ~drawBit; break;
+      case INVERSE: *bufferPtr ^=  drawBit; break;
+    }
+
+    if (length < yOffset) return;
+
+    length -= yOffset;
+    bufferPtr += this->width();
+  }
+
+  if (length >= 8) {
+    switch (color) {
+      case WHITE:
+      case BLACK:
+        drawBit = (color == WHITE) ? 0xFF : 0x00;
+        do {
+          *bufferPtr = drawBit;
+          bufferPtr += this->width();
+          length -= 8;
+        } while (length >= 8);
+        break;
+      case INVERSE:
+        do {
+          *bufferPtr = ~(*bufferPtr);
+          bufferPtr += this->width();
+          length -= 8;
+        } while (length >= 8);
+        break;
+    }
+  }
+
+  if (length > 0) {
+    drawBit = (1 << (length & 7)) - 1;
+    switch (color) {
+      case WHITE:   *bufferPtr |=  drawBit; break;
+      case BLACK:   *bufferPtr &= ~drawBit; break;
+      case INVERSE: *bufferPtr ^=  drawBit; break;
+    }
+  }
+}
+
+void OLEDDisplay::drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t progress) {
+  uint16_t radius = height / 2;
+  uint16_t xRadius = x + radius;
+  uint16_t yRadius = y + radius;
+  uint16_t doubleRadius = 2 * radius;
+  uint16_t innerRadius = radius - 2;
+
+  setColor(WHITE);
+  drawCircleQuads(xRadius, yRadius, radius, 0b00000110);
+  drawHorizontalLine(xRadius, y, width - doubleRadius + 1);
+  drawHorizontalLine(xRadius, y + height, width - doubleRadius + 1);
+  drawCircleQuads(x + width - radius, yRadius, radius, 0b00001001);
+
+  uint16_t maxProgressWidth = (width - doubleRadius + 1) * progress / 100;
+
+  fillCircle(xRadius, yRadius, innerRadius);
+  fillRect(xRadius + 1, y + 2, maxProgressWidth, height - 3);
+  fillCircle(xRadius + maxProgressWidth, yRadius, innerRadius);
+}
+
+void OLEDDisplay::drawFastImage(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *image) {
+  drawInternal(xMove, yMove, width, height, image, 0, 0);
+}
+
+void OLEDDisplay::drawXbm(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *xbm) {
+  int16_t widthInXbm = (width + 7) / 8;
+  uint8_t data = 0;
+
+  for(int16_t y = 0; y < height; y++) {
+    for(int16_t x = 0; x < width; x++ ) {
+      if (x & 7) {
+        data >>= 1; // Move a bit
+      } else {  // Read new data every 8 bit
+        data = pgm_read_byte(xbm + (x / 8) + y * widthInXbm);
+      }
+      // if there is a bit draw it
+      if (data & 0x01) {
+        setPixel(xMove + x, yMove + y);
+      }
+    }
+  }
+}
+
+void OLEDDisplay::drawIco16x16(int16_t xMove, int16_t yMove, const uint8_t *ico, bool inverse) {
+  uint16_t data;
+
+  for(int16_t y = 0; y < 16; y++) {
+    data = pgm_read_byte(ico + (y << 1)) + (pgm_read_byte(ico + (y << 1) + 1) << 8);
+    for(int16_t x = 0; x < 16; x++ ) {
+      if ((data & 0x01) ^ inverse) {
+        setPixelColor(xMove + x, yMove + y, WHITE);
+      } else {
+        setPixelColor(xMove + x, yMove + y, BLACK);
+      }
+      data >>= 1; // Move a bit
+    }
+  }
+}
+
+uint16_t OLEDDisplay::drawStringInternal(int16_t xMove, int16_t yMove, const char* text, uint16_t textLength, uint16_t textWidth, bool utf8) {
+  uint8_t textHeight       = pgm_read_byte(fontData + HEIGHT_POS);
+  uint8_t firstChar        = pgm_read_byte(fontData + FIRST_CHAR_POS);
+  uint16_t sizeOfJumpTable = pgm_read_byte(fontData + CHAR_NUM_POS)  * JUMPTABLE_BYTES;
+
+  uint16_t cursorX         = 0;
+  uint16_t cursorY         = 0;
+  uint16_t charCount       = 0;
+
+  switch (textAlignment) {
+    case TEXT_ALIGN_CENTER_BOTH:
+      yMove -= textHeight >> 1;
+    // Fallthrough
+    case TEXT_ALIGN_CENTER:
+      xMove -= textWidth >> 1; // divide by 2
+      break;
+    case TEXT_ALIGN_RIGHT:
+      xMove -= textWidth;
+      break;
+    case TEXT_ALIGN_LEFT:
+      break;
+  }
+
+  // Don't draw anything if it is not on the screen.
+  if (xMove + textWidth  < 0 || xMove >= this->width() ) {return 0;}
+  if (yMove + textHeight < 0 || yMove >= this->height()) {return 0;}
+
+  for (uint16_t j = 0; j < textLength; j++) {
+    int16_t xPos = xMove + cursorX;
+    int16_t yPos = yMove + cursorY;
+    if (xPos > this->width())
+      break; // no need to continue
+    charCount++;
+
+    uint8_t code;
+    if (utf8) {
+      code = (this->fontTableLookupFunction)(text[j]);
+      if (code == 0)
+        continue;
+    } else
+      code = text[j];
+    if (code >= firstChar) {
+      uint8_t charCode = code - firstChar;
+
+      // 4 Bytes per char code
+      uint8_t msbJumpToChar    = pgm_read_byte( fontData + JUMPTABLE_START + charCode * JUMPTABLE_BYTES );                  // MSB  \ JumpAddress
+      uint8_t lsbJumpToChar    = pgm_read_byte( fontData + JUMPTABLE_START + charCode * JUMPTABLE_BYTES + JUMPTABLE_LSB);   // LSB /
+      uint8_t charByteSize     = pgm_read_byte( fontData + JUMPTABLE_START + charCode * JUMPTABLE_BYTES + JUMPTABLE_SIZE);  // Size
+      uint8_t currentCharWidth = pgm_read_byte( fontData + JUMPTABLE_START + charCode * JUMPTABLE_BYTES + JUMPTABLE_WIDTH); // Width
+
+      // Test if the char is drawable
+      if (!(msbJumpToChar == 255 && lsbJumpToChar == 255)) {
+        // Get the position of the char data
+        uint16_t charDataPosition = JUMPTABLE_START + sizeOfJumpTable + ((msbJumpToChar << 8) + lsbJumpToChar);
+        drawInternal(xPos, yPos, currentCharWidth, textHeight, fontData, charDataPosition, charByteSize);
+      }
+
+      cursorX += currentCharWidth;
+    }
+  }
+  return charCount;
+}
+
+
+uint16_t OLEDDisplay::drawString(int16_t xMove, int16_t yMove, const String &strUser) {
+  uint16_t lineHeight = pgm_read_byte(fontData + HEIGHT_POS);
+
+  // char* text must be freed!
+  char* text = strdup(strUser.c_str());
+  if (!text) {
+    DEBUG_OLEDDISPLAY("[OLEDDISPLAY][drawString] Can't allocate char array.\n");
+    return 0;
+  }
+
+  uint16_t yOffset = 0;
+  // If the string should be centered vertically too
+  // we need to now how heigh the string is.
+  if (textAlignment == TEXT_ALIGN_CENTER_BOTH) {
+    uint16_t lb = 0;
+    // Find number of linebreaks in text
+    for (uint16_t i=0;text[i] != 0; i++) {
+      lb += (text[i] == 10);
+    }
+    // Calculate center
+    yOffset = (lb * lineHeight) / 2;
+  }
+
+  uint16_t charDrawn = 0;
+  uint16_t line = 0;
+  char* textPart = strtok(text,"\n");
+  while (textPart != NULL) {
+    uint16_t length = strlen(textPart);
+    charDrawn += drawStringInternal(xMove, yMove - yOffset + (line++) * lineHeight, textPart, length, getStringWidth(textPart, length, true), true);
+    textPart = strtok(NULL, "\n");
+  }
+  free(text);
+  return charDrawn;
+}
+
+void OLEDDisplay::drawStringf( int16_t x, int16_t y, char* buffer, String format, ... )
+{
+  va_list myargs;
+  va_start(myargs, format);
+  vsprintf(buffer, format.c_str(), myargs);
+  va_end(myargs);
+  drawString( x, y, buffer );
+}
+
+uint16_t OLEDDisplay::drawStringMaxWidth(int16_t xMove, int16_t yMove, uint16_t maxLineWidth, const String &strUser) {
+  uint16_t firstChar  = pgm_read_byte(fontData + FIRST_CHAR_POS);
+  uint16_t lineHeight = pgm_read_byte(fontData + HEIGHT_POS);
+
+  const char* text = strUser.c_str();
+
+  uint16_t length = strlen(text);
+  uint16_t lastDrawnPos = 0;
+  uint16_t lineNumber = 0;
+  uint16_t strWidth = 0;
+
+  uint16_t preferredBreakpoint = 0;
+  uint16_t widthAtBreakpoint = 0;
+  uint16_t firstLineChars = 0;
+  uint16_t drawStringResult = 1; // later tested for 0 == error, so initialize to 1
+
+  for (uint16_t i = 0; i < length; i++) {
+    char c = (this->fontTableLookupFunction)(text[i]);
+    if (c == 0)
+      continue;
+    strWidth += pgm_read_byte(fontData + JUMPTABLE_START + (c - firstChar) * JUMPTABLE_BYTES + JUMPTABLE_WIDTH);
+
+    // Always break on newline
+    if (text[i] == '\n') {
+      drawStringResult = drawStringInternal(xMove, yMove + (lineNumber++) * lineHeight , &text[lastDrawnPos], i - lastDrawnPos, strWidth, true);
+      if (firstLineChars == 0)
+        firstLineChars = i;
+        
+      lastDrawnPos = i + 1;
+      strWidth = 0;
+      if (drawStringResult == 0) // we are past the display already?
+        break;
+    }
+
+    // Always try to break on a space, dash or slash
+    if (text[i] == ' ' || text[i]== '-' || text[i] == '/') {
+      preferredBreakpoint = i + 1;
+      widthAtBreakpoint = strWidth;
+    }
+
+    if (strWidth >= maxLineWidth) {
+      if (preferredBreakpoint == 0) {
+        preferredBreakpoint = i;
+        widthAtBreakpoint = strWidth;
+      }
+      drawStringResult = drawStringInternal(xMove, yMove + (lineNumber++) * lineHeight , &text[lastDrawnPos], preferredBreakpoint - lastDrawnPos, widthAtBreakpoint, true);
+      if (firstLineChars == 0)
+        firstLineChars = preferredBreakpoint;
+      lastDrawnPos = preferredBreakpoint;
+      // It is possible that we did not draw all letters to i so we need
+      // to account for the width of the chars from `i - preferredBreakpoint`
+      // by calculating the width we did not draw yet.
+      strWidth = strWidth - widthAtBreakpoint;
+      preferredBreakpoint = 0;
+      if (drawStringResult == 0) // we are past the display already?
+        break;
+    }
+  }
+
+  // Draw last part if needed
+  if (drawStringResult != 0 && lastDrawnPos < length) {
+    drawStringResult = drawStringInternal(xMove, yMove + (lineNumber++) * lineHeight , &text[lastDrawnPos], length - lastDrawnPos, getStringWidth(&text[lastDrawnPos], length - lastDrawnPos, true), true);
+  }
+
+  if (drawStringResult == 0 || (yMove + lineNumber * lineHeight) >= this->height()) // text did not fit on screen
+    return firstLineChars;
+  return 0; // everything was drawn
+}
+
+uint16_t OLEDDisplay::getStringWidth(const char* text, uint16_t length, bool utf8) {
+  uint16_t firstChar        = pgm_read_byte(fontData + FIRST_CHAR_POS);
+
+  uint16_t stringWidth = 0;
+  uint16_t maxWidth = 0;
+
+  for (uint16_t i = 0; i < length; i++) {
+    char c = text[i];
+    if (utf8) {
+      c = (this->fontTableLookupFunction)(c);
+      if (c == 0)
+        continue;
+    }
+    stringWidth += pgm_read_byte(fontData + JUMPTABLE_START + (c - firstChar) * JUMPTABLE_BYTES + JUMPTABLE_WIDTH);
+    if (c == 10) {
+      maxWidth = max(maxWidth, stringWidth);
+      stringWidth = 0;
+    }
+  }
+
+  return max(maxWidth, stringWidth);
+}
+
+uint16_t OLEDDisplay::getStringWidth(const String &strUser) {
+  uint16_t width = getStringWidth(strUser.c_str(), strUser.length());
+  return width;
+}
+
+void OLEDDisplay::setTextAlignment(OLEDDISPLAY_TEXT_ALIGNMENT textAlignment) {
+  this->textAlignment = textAlignment;
+}
+
+void OLEDDisplay::setFont(const uint8_t *fontData) {
+  this->fontData = fontData;
+}
+
+void OLEDDisplay::displayOn(void) {
+  sendCommand(DISPLAYON);
+}
+
+void OLEDDisplay::displayOff(void) {
+  sendCommand(DISPLAYOFF);
+}
+
+void OLEDDisplay::invertDisplay(void) {
+  sendCommand(INVERTDISPLAY);
+}
+
+void OLEDDisplay::normalDisplay(void) {
+  sendCommand(NORMALDISPLAY);
+}
+
+void OLEDDisplay::setContrast(uint8_t contrast, uint8_t precharge, uint8_t comdetect) {
+  sendCommand(SETPRECHARGE); //0xD9
+  sendCommand(precharge); //0xF1 default, to lower the contrast, put 1-1F
+  sendCommand(SETCONTRAST);
+  sendCommand(contrast); // 0-255
+  sendCommand(SETVCOMDETECT); //0xDB, (additionally needed to lower the contrast)
+  sendCommand(comdetect);	//0x40 default, to lower the contrast, put 0
+  sendCommand(DISPLAYALLON_RESUME);
+  sendCommand(NORMALDISPLAY);
+  sendCommand(DISPLAYON);
+}
+
+void OLEDDisplay::setBrightness(uint8_t brightness) {
+  uint8_t contrast = brightness;
+  if (brightness < 128) {
+    // Magic values to get a smooth/ step-free transition
+    contrast = brightness * 1.171;
+  } else {
+    contrast = brightness * 1.171 - 43;
+  }
+
+  uint8_t precharge = 241;
+  if (brightness == 0) {
+    precharge = 0;
+  }
+  uint8_t comdetect = brightness / 8;
+
+  setContrast(contrast, precharge, comdetect);
+}
+
+void OLEDDisplay::resetOrientation() {
+  sendCommand(SEGREMAP);
+  sendCommand(COMSCANINC);           //Reset screen rotation or mirroring
+}
+
+void OLEDDisplay::flipScreenVertically() {
+  sendCommand(SEGREMAP | 0x01);
+  sendCommand(COMSCANDEC);           //Rotate screen 180 Deg
+}
+
+void OLEDDisplay::mirrorScreen() {
+  sendCommand(SEGREMAP);
+  sendCommand(COMSCANDEC);           //Mirror screen
+}
+
+void OLEDDisplay::clear(void) {
+  memset(buffer, 0, displayBufferSize);
+}
+
+void OLEDDisplay::drawLogBuffer(uint16_t xMove, uint16_t yMove) {
+  uint16_t lineHeight = pgm_read_byte(fontData + HEIGHT_POS);
+  // Always align left
+  setTextAlignment(TEXT_ALIGN_LEFT);
+
+  // State values
+  uint16_t length   = 0;
+  uint16_t line     = 0;
+  uint16_t lastPos  = 0;
+
+  for (uint16_t i=0;i<this->logBufferFilled;i++){
+    // Everytime we have a \n print
+    if (this->logBuffer[i] == 10) {
+      length++;
+      // Draw string on line `line` from lastPos to length
+      // Passing 0 as the lenght because we are in TEXT_ALIGN_LEFT
+      drawStringInternal(xMove, yMove + (line++) * lineHeight, &this->logBuffer[lastPos], length, 0, false);
+      // Remember last pos
+      lastPos = i;
+      // Reset length
+      length = 0;
+    } else {
+      // Count chars until next linebreak
+      length++;
+    }
+  }
+  // Draw the remaining string
+  if (length > 0) {
+    drawStringInternal(xMove, yMove + line * lineHeight, &this->logBuffer[lastPos], length, 0, false);
+  }
+}
+
+uint16_t OLEDDisplay::getWidth(void) {
+  return displayWidth;
+}
+
+uint16_t OLEDDisplay::getHeight(void) {
+  return displayHeight;
+}
+
+bool OLEDDisplay::setLogBuffer(uint16_t lines, uint16_t chars){
+  if (logBuffer != NULL) free(logBuffer);
+  uint16_t size = lines * chars;
+  if (size > 0) {
+    this->logBufferLine     = 0;      // Lines printed
+    this->logBufferFilled   = 0;      // Nothing stored yet
+    this->logBufferMaxLines = lines;  // Lines max printable
+    this->logBufferSize     = size;   // Total number of characters the buffer can hold
+    this->logBuffer         = (char *) malloc(size * sizeof(uint8_t));
+    if(!this->logBuffer) {
+      DEBUG_OLEDDISPLAY("[OLEDDISPLAY][setLogBuffer] Not enough memory to create log buffer\n");
+      return false;
+    }
+  }
+  return true;
+}
+
+size_t OLEDDisplay::write(uint8_t c) {
+  if (this->logBufferSize > 0) {
+    // Don't waste space on \r\n line endings, dropping \r
+    if (c == 13) return 1;
+
+    // convert UTF-8 character to font table index
+    c = (this->fontTableLookupFunction)(c);
+    // drop unknown character
+    if (c == 0) return 1;
+
+    bool maxLineNotReached = this->logBufferLine < this->logBufferMaxLines;
+    bool bufferNotFull = this->logBufferFilled < this->logBufferSize;
+
+    // Can we write to the buffer?
+    if (bufferNotFull && maxLineNotReached) {
+      this->logBuffer[logBufferFilled] = c;
+      this->logBufferFilled++;
+      // Keep track of lines written
+      if (c == 10) this->logBufferLine++;
+    } else {
+      // Max line number is reached
+      if (!maxLineNotReached) this->logBufferLine--;
+
+      // Find the end of the first line
+      uint16_t firstLineEnd = 0;
+      for (uint16_t i=0;i<this->logBufferFilled;i++) {
+        if (this->logBuffer[i] == 10){
+          // Include last char too
+          firstLineEnd = i + 1;
+          break;
+        }
+      }
+      // If there was a line ending
+      if (firstLineEnd > 0) {
+        // Calculate the new logBufferFilled value
+        this->logBufferFilled = logBufferFilled - firstLineEnd;
+        // Now we move the lines infront of the buffer
+        memcpy(this->logBuffer, &this->logBuffer[firstLineEnd], logBufferFilled);
+      } else {
+        // Let's reuse the buffer if it was full
+        if (!bufferNotFull) {
+          this->logBufferFilled = 0;
+        }// else {
+        //  Nothing to do here
+        //}
+      }
+      write(c);
+    }
+  }
+  // We are always writing all uint8_t to the buffer
+  return 1;
+}
+
+size_t OLEDDisplay::write(const char* str) {
+  if (str == NULL) return 0;
+  size_t length = strlen(str);
+  for (size_t i = 0; i < length; i++) {
+    write(str[i]);
+  }
+  return length;
+}
+
+#ifdef __MBED__
+int OLEDDisplay::_putc(int c) {
+
+	if (!fontData)
+		return 1;
+	if (!logBufferSize) {
+		uint8_t textHeight = pgm_read_byte(fontData + HEIGHT_POS);
+		uint16_t lines =  this->displayHeight / textHeight;
+		uint16_t chars =   2 * (this->displayWidth / textHeight);
+
+		if (this->displayHeight % textHeight)
+			lines++;
+		if (this->displayWidth % textHeight)
+			chars++;
+		setLogBuffer(lines, chars);
+	}
+
+	return this->write((uint8_t)c);
+}
+#endif
+
+// Private functions
+void OLEDDisplay::setGeometry(OLEDDISPLAY_GEOMETRY g, uint16_t width, uint16_t height) {
+  this->geometry = g;
+
+  switch (g) {
+    case GEOMETRY_128_128:
+      this->displayWidth = 128;
+      this->displayHeight = 128;
+      break;
+    case GEOMETRY_128_64:
+      this->displayWidth = 128;
+      this->displayHeight = 64;
+      break;
+    case GEOMETRY_128_32:
+      this->displayWidth = 128;
+      this->displayHeight = 32;
+      break;
+    case GEOMETRY_64_48:
+      this->displayWidth = 64;
+      this->displayHeight = 48;
+      break;
+    case GEOMETRY_64_32:
+      this->displayWidth = 64;
+      this->displayHeight = 32;
+      break;
+    case GEOMETRY_RAWMODE:
+      this->displayWidth = width > 0 ? width : 128;
+      this->displayHeight = height > 0 ? height : 64;
+      break;
+  }
+  this->displayBufferSize = displayWidth * displayHeight / 8;
+}
+
+void OLEDDisplay::sendInitCommands(void) {
+  if (geometry == GEOMETRY_RAWMODE)
+  	return;
+  sendCommand(DISPLAYOFF);
+  sendCommand(SETDISPLAYCLOCKDIV);
+  sendCommand(0xF0); // Increase speed of the display max ~96Hz
+  sendCommand(SETMULTIPLEX);
+  sendCommand(this->height() - 1);
+  sendCommand(SETDISPLAYOFFSET);
+  sendCommand(0x00);
+  if(geometry == GEOMETRY_64_32)
+    sendCommand(0x00);
+  else
+    sendCommand(SETSTARTLINE);
+  sendCommand(CHARGEPUMP);
+  sendCommand(0x14);
+  sendCommand(MEMORYMODE);
+  sendCommand(0x00);
+  sendCommand(SEGREMAP);
+  sendCommand(COMSCANINC);
+  sendCommand(SETCOMPINS);
+
+  if (geometry == GEOMETRY_128_128 || geometry == GEOMETRY_128_64 || geometry == GEOMETRY_64_48 || geometry == GEOMETRY_64_32) {
+    sendCommand(0x12);
+  } else if (geometry == GEOMETRY_128_32) {
+    sendCommand(0x02);
+  }
+
+  sendCommand(SETCONTRAST);
+
+  if (geometry == GEOMETRY_128_128 || geometry == GEOMETRY_128_64 || geometry == GEOMETRY_64_48 || geometry == GEOMETRY_64_32) {
+    sendCommand(0xCF);
+  } else if (geometry == GEOMETRY_128_32) {
+    sendCommand(0x8F);
+  }
+
+  sendCommand(SETPRECHARGE);
+  sendCommand(0xF1);
+  sendCommand(SETVCOMDETECT); //0xDB, (additionally needed to lower the contrast)
+  sendCommand(0x40);	        //0x40 default, to lower the contrast, put 0
+  sendCommand(DISPLAYALLON_RESUME);
+  sendCommand(NORMALDISPLAY);
+  sendCommand(0x2e);            // stop scroll
+  sendCommand(DISPLAYON);
+}
+
+void inline OLEDDisplay::drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *data, uint16_t offset, uint16_t bytesInData) {
+  if (width < 0 || height < 0) return;
+  if (yMove + height < 0 || yMove > this->height())  return;
+  if (xMove + width  < 0 || xMove > this->width())   return;
+
+  uint8_t  rasterHeight = 1 + ((height - 1) >> 3); // fast ceil(height / 8.0)
+  int8_t   yOffset      = yMove & 7;
+
+  bytesInData = bytesInData == 0 ? width * rasterHeight : bytesInData;
+
+  int16_t initYMove   = yMove;
+  int8_t  initYOffset = yOffset;
+
+
+  for (uint16_t i = 0; i < bytesInData; i++) {
+
+    // Reset if next horizontal drawing phase is started.
+    if ( i % rasterHeight == 0) {
+      yMove   = initYMove;
+      yOffset = initYOffset;
+    }
+
+    uint8_t currentByte = pgm_read_byte(data + offset + i);
+
+    int16_t xPos = xMove + (i / rasterHeight);
+    int16_t yPos = ((yMove >> 3) + (i % rasterHeight)) * this->width();
+
+//    int16_t yScreenPos = yMove + yOffset;
+    int16_t dataPos    = xPos  + yPos;
+
+    if (dataPos >=  0  && dataPos < displayBufferSize &&
+        xPos    >=  0  && xPos    < this->width() ) {
+
+      if (yOffset >= 0) {
+        switch (this->color) {
+          case WHITE:   buffer[dataPos] |= currentByte << yOffset; break;
+          case BLACK:   buffer[dataPos] &= ~(currentByte << yOffset); break;
+          case INVERSE: buffer[dataPos] ^= currentByte << yOffset; break;
+        }
+
+        if (dataPos < (displayBufferSize - this->width())) {
+          switch (this->color) {
+            case WHITE:   buffer[dataPos + this->width()] |= currentByte >> (8 - yOffset); break;
+            case BLACK:   buffer[dataPos + this->width()] &= ~(currentByte >> (8 - yOffset)); break;
+            case INVERSE: buffer[dataPos + this->width()] ^= currentByte >> (8 - yOffset); break;
+          }
+        }
+      } else {
+        // Make new offset position
+        yOffset = -yOffset;
+
+        switch (this->color) {
+          case WHITE:   buffer[dataPos] |= currentByte >> yOffset; break;
+          case BLACK:   buffer[dataPos] &= ~(currentByte >> yOffset); break;
+          case INVERSE: buffer[dataPos] ^= currentByte >> yOffset; break;
+        }
+
+        // Prepare for next iteration by moving one block up
+        yMove -= 8;
+
+        // and setting the new yOffset
+        yOffset = 8 - yOffset;
+      }
+#ifndef __MBED__
+      yield();
+#endif
+    }
+  }
+}
+
+// You need to free the char!
+char* OLEDDisplay::utf8ascii(const String &str) {
+  uint16_t k = 0;
+  uint16_t length = str.length() + 1;
+
+  // Copy the string into a char array
+  char* s = (char*) malloc(length * sizeof(char));
+  if(!s) {
+    DEBUG_OLEDDISPLAY("[OLEDDISPLAY][utf8ascii] Can't allocate another char array. Drop support for UTF-8.\n");
+    return (char*) str.c_str();
+  }
+  str.toCharArray(s, length);
+
+  length--;
+
+  for (uint16_t i=0; i < length; i++) {
+    char c = (this->fontTableLookupFunction)(s[i]);
+    if (c!=0) {
+      s[k++]=c;
+    }
+  }
+
+  s[k]=0;
+
+  // This will leak 's' be sure to free it in the calling function.
+  return s;
+}
+
+void OLEDDisplay::setFontTableLookupFunction(FontTableLookupFunction function) {
+  this->fontTableLookupFunction = function;
+}
+
+
+char DefaultFontTableLookup(const uint8_t ch) {
+    // UTF-8 to font table index converter
+    // Code form http://playground.arduino.cc/Main/Utf8ascii
+	static uint8_t LASTCHAR;
+
+	if (ch < 128) { // Standard ASCII-set 0..0x7F handling
+		LASTCHAR = 0;
+		return ch;
+	}
+
+	uint8_t last = LASTCHAR;   // get last char
+	LASTCHAR = ch;
+
+	switch (last) {    // conversion depnding on first UTF8-character
+		case 0xC2: return (uint8_t) ch;
+		case 0xC3: return (uint8_t) (ch | 0xC0);
+		case 0x82: if (ch == 0xAC) return (uint8_t) 0x80;    // special case Euro-symbol
+	}
+
+	return (uint8_t) 0; // otherwise: return zero, if character has to be ignored
+}

src/helpers/ui/OLEDDisplay.h

@@ -0,0 +1,395 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
+ * Copyright (c) 2019 by Helmut Tschemernjak - www.radioshuttle.de
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
+ */
+
+#ifndef OLEDDISPLAY_h
+#define OLEDDISPLAY_h
+
+#include <cstdarg>
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#elif __MBED__
+#define pgm_read_byte(addr)   (*(const unsigned char *)(addr))
+
+#include <mbed.h>
+#define delay(x)	wait_ms(x)
+#define yield()		void()
+
+/*
+ * This is a little Arduino String emulation to keep the OLEDDisplay
+ * library code in common between Arduino and mbed-os
+ */
+class String {
+public:
+	String(const char *s) { _str = s; };
+	int length() { return strlen(_str); };
+	const char *c_str() { return _str; };
+    void toCharArray(char *buf, unsigned int bufsize, unsigned int index = 0) const {
+		memcpy(buf, _str + index,  std::min(bufsize, strlen(_str)));
+	};
+private:
+	const char *_str;
+};
+
+#else
+#error "Unkown operating system"
+#endif
+
+#include "OLEDDisplayFonts.h"
+
+//#define DEBUG_OLEDDISPLAY(...) Serial.printf( __VA_ARGS__ )
+//#define DEBUG_OLEDDISPLAY(...) dprintf("%s",  __VA_ARGS__ )
+
+#ifndef DEBUG_OLEDDISPLAY
+#define DEBUG_OLEDDISPLAY(...)
+#endif
+
+// Use DOUBLE BUFFERING by default
+#ifndef OLEDDISPLAY_REDUCE_MEMORY
+#define OLEDDISPLAY_DOUBLE_BUFFER
+#endif
+
+// Header Values
+#define JUMPTABLE_BYTES 4
+
+#define JUMPTABLE_LSB   1
+#define JUMPTABLE_SIZE  2
+#define JUMPTABLE_WIDTH 3
+#define JUMPTABLE_START 4
+
+#define WIDTH_POS 0
+#define HEIGHT_POS 1
+#define FIRST_CHAR_POS 2
+#define CHAR_NUM_POS 3
+
+
+// Display commands
+#define CHARGEPUMP 0x8D
+#define COLUMNADDR 0x21
+#define COMSCANDEC 0xC8
+#define COMSCANINC 0xC0
+#define DISPLAYALLON 0xA5
+#define DISPLAYALLON_RESUME 0xA4
+#define DISPLAYOFF 0xAE
+#define DISPLAYON 0xAF
+#define EXTERNALVCC 0x1
+#define INVERTDISPLAY 0xA7
+#define MEMORYMODE 0x20
+#define NORMALDISPLAY 0xA6
+#define PAGEADDR 0x22
+#define SEGREMAP 0xA0
+#define SETCOMPINS 0xDA
+#define SETCONTRAST 0x81
+#define SETDISPLAYCLOCKDIV 0xD5
+#define SETDISPLAYOFFSET 0xD3
+#define SETHIGHCOLUMN 0x10
+#define SETLOWCOLUMN 0x00
+#define SETMULTIPLEX 0xA8
+#define SETPRECHARGE 0xD9
+#define SETSEGMENTREMAP 0xA1
+#define SETSTARTLINE 0x40
+#define SETVCOMDETECT 0xDB
+#define SWITCHCAPVCC 0x2
+
+#ifndef _swap_int16_t
+#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
+#endif
+
+enum OLEDDISPLAY_COLOR {
+  BLACK = 0,
+  WHITE = 1,
+  INVERSE = 2
+};
+
+enum OLEDDISPLAY_TEXT_ALIGNMENT {
+  TEXT_ALIGN_LEFT = 0,
+  TEXT_ALIGN_RIGHT = 1,
+  TEXT_ALIGN_CENTER = 2,
+  TEXT_ALIGN_CENTER_BOTH = 3
+};
+
+
+enum OLEDDISPLAY_GEOMETRY {
+  GEOMETRY_128_64   = 0,
+  GEOMETRY_128_32   = 1,
+  GEOMETRY_64_48    = 2,
+  GEOMETRY_64_32    = 3,
+  GEOMETRY_RAWMODE  = 4,
+  GEOMETRY_128_128  = 5
+};
+
+enum HW_I2C {
+  I2C_ONE,
+  I2C_TWO
+};
+
+typedef char (*FontTableLookupFunction)(const uint8_t ch);
+char DefaultFontTableLookup(const uint8_t ch);
+
+
+#ifdef ARDUINO
+class OLEDDisplay : public Print  {
+#elif __MBED__
+class OLEDDisplay : public Stream {
+#else
+#error "Unkown operating system"
+#endif
+
+  public:
+	OLEDDisplay();
+    virtual ~OLEDDisplay();
+
+	uint16_t width(void) const { return displayWidth; };
+	uint16_t height(void) const { return displayHeight; };
+
+    // Use this to resume after a deep sleep without resetting the display (what init() would do).
+    // Returns true if connection to the display was established and the buffer allocated, false otherwise.
+    bool allocateBuffer();
+
+    // Allocates the buffer and initializes the driver & display. Resets the display!
+    // Returns false if buffer allocation failed, true otherwise.
+    bool init();
+
+    // Free the memory used by the display
+    void end();
+
+    // Cycle through the initialization
+    void resetDisplay(void);
+
+    /* Drawing functions */
+    // Sets the color of all pixel operations
+    void setColor(OLEDDISPLAY_COLOR color);
+
+    // Returns the current color.
+    OLEDDISPLAY_COLOR getColor();
+
+    // Draw a pixel at given position
+    void setPixel(int16_t x, int16_t y);
+
+    // Draw a pixel at given position and color
+    void setPixelColor(int16_t x, int16_t y, OLEDDISPLAY_COLOR color);
+
+    // Clear a pixel at given position FIXME: INVERSE is untested with this function
+    void clearPixel(int16_t x, int16_t y);
+
+    // Draw a line from position 0 to position 1
+    void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1);
+
+    // Draw the border of a rectangle at the given location
+    void drawRect(int16_t x, int16_t y, int16_t width, int16_t height);
+
+    // Fill the rectangle
+    void fillRect(int16_t x, int16_t y, int16_t width, int16_t height);
+
+    // Draw the border of a circle
+    void drawCircle(int16_t x, int16_t y, int16_t radius);
+
+    // Draw all Quadrants specified in the quads bit mask
+    void drawCircleQuads(int16_t x0, int16_t y0, int16_t radius, uint8_t quads);
+
+    // Fill circle
+    void fillCircle(int16_t x, int16_t y, int16_t radius);
+
+    // Draw an empty triangle i.e. only the outline
+    void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+
+    // Draw a solid triangle i.e. filled
+    void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+
+    // Draw a line horizontally
+    void drawHorizontalLine(int16_t x, int16_t y, int16_t length);
+
+    // Draw a line vertically
+    void drawVerticalLine(int16_t x, int16_t y, int16_t length);
+
+    // Draws a rounded progress bar with the outer dimensions given by width and height. Progress is
+    // a unsigned byte value between 0 and 100
+    void drawProgressBar(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t progress);
+
+    // Draw a bitmap in the internal image format
+    void drawFastImage(int16_t x, int16_t y, int16_t width, int16_t height, const uint8_t *image);
+
+    // Draw a XBM
+    void drawXbm(int16_t x, int16_t y, int16_t width, int16_t height, const uint8_t *xbm);
+
+    // Draw icon 16x16 xbm format
+    void drawIco16x16(int16_t x, int16_t y, const uint8_t *ico, bool inverse = false);
+
+    /* Text functions */
+
+    // Draws a string at the given location, returns how many chars have been written
+    uint16_t drawString(int16_t x, int16_t y, const String &text);
+
+    // Draws a formatted string (like printf) at the given location
+    void drawStringf(int16_t x, int16_t y, char* buffer, String format, ... );
+
+    // Draws a String with a maximum width at the given location.
+    // If the given String is wider than the specified width
+    // The text will be wrapped to the next line at a space or dash
+    // returns 0 if everything fits on the screen or the numbers of characters in the
+    // first line if not
+    uint16_t drawStringMaxWidth(int16_t x, int16_t y, uint16_t maxLineWidth, const String &text);
+
+    // Returns the width of the const char* with the current
+    // font settings
+    uint16_t getStringWidth(const char* text, uint16_t length, bool utf8 = false);
+
+    // Convencience method for the const char version
+    uint16_t getStringWidth(const String &text);
+
+    // Specifies relative to which anchor point
+    // the text is rendered. Available constants:
+    // TEXT_ALIGN_LEFT, TEXT_ALIGN_CENTER, TEXT_ALIGN_RIGHT, TEXT_ALIGN_CENTER_BOTH
+    void setTextAlignment(OLEDDISPLAY_TEXT_ALIGNMENT textAlignment);
+
+    // Sets the current font. Available default fonts
+    // ArialMT_Plain_10, ArialMT_Plain_16, ArialMT_Plain_24
+    void setFont(const uint8_t *fontData);
+
+    // Set the function that will convert utf-8 to font table index
+    void setFontTableLookupFunction(FontTableLookupFunction function);
+
+    /* Display functions */
+
+    // Turn the display on
+    void displayOn(void);
+
+    // Turn the display offs
+    void displayOff(void);
+
+    // Inverted display mode
+    void invertDisplay(void);
+
+    // Normal display mode
+    void normalDisplay(void);
+
+    // Set display contrast
+    // really low brightness & contrast: contrast = 10, precharge = 5, comdetect = 0
+    // normal brightness & contrast:  contrast = 100
+    void setContrast(uint8_t contrast, uint8_t precharge = 241, uint8_t comdetect = 64);
+
+    // Convenience method to access 
+    virtual void setBrightness(uint8_t);
+
+    // Reset display rotation or mirroring
+    void resetOrientation();
+
+    // Turn the display upside down
+    void flipScreenVertically();
+
+    // Mirror the display (to be used in a mirror or as a projector)
+    void mirrorScreen();
+
+    // Write the buffer to the display memory
+    virtual void display(void) = 0;
+
+    // Clear the local pixel buffer
+    void clear(void);
+
+    // Log buffer implementation
+
+    // This will define the lines and characters you can
+    // print to the screen. When you exeed the buffer size (lines * chars)
+    // the output may be truncated due to the size constraint.
+    bool setLogBuffer(uint16_t lines, uint16_t chars);
+
+    // Draw the log buffer at position (x, y)
+    void drawLogBuffer(uint16_t x, uint16_t y);
+
+    // Get screen geometry
+    uint16_t getWidth(void);
+    uint16_t getHeight(void);
+
+    // Implement needed function to be compatible with Print class
+    size_t write(uint8_t c);
+    size_t write(const char* s);
+
+    // Implement needed function to be compatible with Stream class
+#ifdef __MBED__
+	int _putc(int c);
+	int _getc() { return -1; };
+#endif
+
+
+    uint8_t            *buffer;
+
+    #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+    uint8_t            *buffer_back;
+    #endif
+
+    // Set the correct height, width and buffer for the geometry
+    void setGeometry(OLEDDISPLAY_GEOMETRY g, uint16_t width = 0, uint16_t height = 0);
+
+  protected:
+
+    OLEDDISPLAY_GEOMETRY geometry;
+
+    uint16_t  displayWidth;
+    uint16_t  displayHeight;
+    uint16_t  displayBufferSize;
+
+    OLEDDISPLAY_TEXT_ALIGNMENT   textAlignment;
+    OLEDDISPLAY_COLOR            color;
+
+    const uint8_t	 *fontData;
+
+    // State values for logBuffer
+    uint16_t   logBufferSize;
+    uint16_t   logBufferFilled;
+    uint16_t   logBufferLine;
+    uint16_t   logBufferMaxLines;
+    char      *logBuffer;
+
+
+	// the header size of the buffer used, e.g. for the SPI command header
+  int BufferOffset;
+	virtual int getBufferOffset(void) = 0;
+
+    // Send a command to the display (low level function)
+    virtual void sendCommand(uint8_t com) {(void)com;};
+
+    // Connect to the display
+    virtual bool connect() { return false; };
+
+    // Send all the init commands
+    virtual void sendInitCommands();
+
+    // converts utf8 characters to extended ascii
+    char* utf8ascii(const String &s);
+
+    void inline drawInternal(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *data, uint16_t offset, uint16_t bytesInData) __attribute__((always_inline));
+
+    uint16_t drawStringInternal(int16_t xMove, int16_t yMove, const char* text, uint16_t textLength, uint16_t textWidth, bool utf8);
+
+	FontTableLookupFunction fontTableLookupFunction;
+};
+
+#endif

src/helpers/ui/OLEDDisplayFonts.cpp

@@ -0,0 +1,1273 @@
+#include "OLEDDisplayFonts.h"
+
+const uint8_t ArialMT_Plain_10[] PROGMEM = {
+  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 uint8_t ArialMT_Plain_16[] PROGMEM = {
+  0x10, // Width: 16
+  0x13, // Height: 19
+  0x20, // First Char: 32
+  0xE0, // Numbers of Chars: 224
+
+  // Jump Table:
+  0xFF, 0xFF, 0x00, 0x04,  // 32:65535
+  0x00, 0x00, 0x08, 0x04,  // 33:0
+  0x00, 0x08, 0x0D, 0x06,  // 34:8
+  0x00, 0x15, 0x1A, 0x09,  // 35:21
+  0x00, 0x2F, 0x17, 0x09,  // 36:47
+  0x00, 0x46, 0x26, 0x0E,  // 37:70
+  0x00, 0x6C, 0x1D, 0x0B,  // 38:108
+  0x00, 0x89, 0x04, 0x03,  // 39:137
+  0x00, 0x8D, 0x0C, 0x05,  // 40:141
+  0x00, 0x99, 0x0B, 0x05,  // 41:153
+  0x00, 0xA4, 0x0D, 0x06,  // 42:164
+  0x00, 0xB1, 0x17, 0x09,  // 43:177
+  0x00, 0xC8, 0x09, 0x04,  // 44:200
+  0x00, 0xD1, 0x0B, 0x05,  // 45:209
+  0x00, 0xDC, 0x08, 0x04,  // 46:220
+  0x00, 0xE4, 0x0A, 0x04,  // 47:228
+  0x00, 0xEE, 0x17, 0x09,  // 48:238
+  0x01, 0x05, 0x11, 0x09,  // 49:261
+  0x01, 0x16, 0x17, 0x09,  // 50:278
+  0x01, 0x2D, 0x17, 0x09,  // 51:301
+  0x01, 0x44, 0x17, 0x09,  // 52:324
+  0x01, 0x5B, 0x17, 0x09,  // 53:347
+  0x01, 0x72, 0x17, 0x09,  // 54:370
+  0x01, 0x89, 0x16, 0x09,  // 55:393
+  0x01, 0x9F, 0x17, 0x09,  // 56:415
+  0x01, 0xB6, 0x17, 0x09,  // 57:438
+  0x01, 0xCD, 0x05, 0x04,  // 58:461
+  0x01, 0xD2, 0x06, 0x04,  // 59:466
+  0x01, 0xD8, 0x17, 0x09,  // 60:472
+  0x01, 0xEF, 0x17, 0x09,  // 61:495
+  0x02, 0x06, 0x17, 0x09,  // 62:518
+  0x02, 0x1D, 0x16, 0x09,  // 63:541
+  0x02, 0x33, 0x2F, 0x10,  // 64:563
+  0x02, 0x62, 0x1D, 0x0B,  // 65:610
+  0x02, 0x7F, 0x1D, 0x0B,  // 66:639
+  0x02, 0x9C, 0x20, 0x0C,  // 67:668
+  0x02, 0xBC, 0x20, 0x0C,  // 68:700
+  0x02, 0xDC, 0x1D, 0x0B,  // 69:732
+  0x02, 0xF9, 0x19, 0x0A,  // 70:761
+  0x03, 0x12, 0x20, 0x0C,  // 71:786
+  0x03, 0x32, 0x1D, 0x0C,  // 72:818
+  0x03, 0x4F, 0x05, 0x04,  // 73:847
+  0x03, 0x54, 0x14, 0x08,  // 74:852
+  0x03, 0x68, 0x1D, 0x0B,  // 75:872
+  0x03, 0x85, 0x17, 0x09,  // 76:901
+  0x03, 0x9C, 0x23, 0x0D,  // 77:924
+  0x03, 0xBF, 0x1D, 0x0C,  // 78:959
+  0x03, 0xDC, 0x20, 0x0C,  // 79:988
+  0x03, 0xFC, 0x1C, 0x0B,  // 80:1020
+  0x04, 0x18, 0x20, 0x0C,  // 81:1048
+  0x04, 0x38, 0x1D, 0x0C,  // 82:1080
+  0x04, 0x55, 0x1D, 0x0B,  // 83:1109
+  0x04, 0x72, 0x19, 0x0A,  // 84:1138
+  0x04, 0x8B, 0x1D, 0x0C,  // 85:1163
+  0x04, 0xA8, 0x1C, 0x0B,  // 86:1192
+  0x04, 0xC4, 0x2B, 0x0F,  // 87:1220
+  0x04, 0xEF, 0x20, 0x0B,  // 88:1263
+  0x05, 0x0F, 0x19, 0x0B,  // 89:1295
+  0x05, 0x28, 0x1A, 0x0A,  // 90:1320
+  0x05, 0x42, 0x0C, 0x04,  // 91:1346
+  0x05, 0x4E, 0x0B, 0x04,  // 92:1358
+  0x05, 0x59, 0x09, 0x04,  // 93:1369
+  0x05, 0x62, 0x14, 0x08,  // 94:1378
+  0x05, 0x76, 0x1B, 0x09,  // 95:1398
+  0x05, 0x91, 0x07, 0x05,  // 96:1425
+  0x05, 0x98, 0x17, 0x09,  // 97:1432
+  0x05, 0xAF, 0x17, 0x09,  // 98:1455
+  0x05, 0xC6, 0x14, 0x08,  // 99:1478
+  0x05, 0xDA, 0x17, 0x09,  // 100:1498
+  0x05, 0xF1, 0x17, 0x09,  // 101:1521
+  0x06, 0x08, 0x0A, 0x04,  // 102:1544
+  0x06, 0x12, 0x17, 0x09,  // 103:1554
+  0x06, 0x29, 0x14, 0x09,  // 104:1577
+  0x06, 0x3D, 0x05, 0x04,  // 105:1597
+  0x06, 0x42, 0x06, 0x04,  // 106:1602
+  0x06, 0x48, 0x17, 0x08,  // 107:1608
+  0x06, 0x5F, 0x05, 0x04,  // 108:1631
+  0x06, 0x64, 0x23, 0x0D,  // 109:1636
+  0x06, 0x87, 0x14, 0x09,  // 110:1671
+  0x06, 0x9B, 0x17, 0x09,  // 111:1691
+  0x06, 0xB2, 0x17, 0x09,  // 112:1714
+  0x06, 0xC9, 0x18, 0x09,  // 113:1737
+  0x06, 0xE1, 0x0D, 0x05,  // 114:1761
+  0x06, 0xEE, 0x14, 0x08,  // 115:1774
+  0x07, 0x02, 0x0B, 0x04,  // 116:1794
+  0x07, 0x0D, 0x14, 0x09,  // 117:1805
+  0x07, 0x21, 0x13, 0x08,  // 118:1825
+  0x07, 0x34, 0x1F, 0x0C,  // 119:1844
+  0x07, 0x53, 0x14, 0x08,  // 120:1875
+  0x07, 0x67, 0x13, 0x08,  // 121:1895
+  0x07, 0x7A, 0x14, 0x08,  // 122:1914
+  0x07, 0x8E, 0x0F, 0x05,  // 123:1934
+  0x07, 0x9D, 0x06, 0x04,  // 124:1949
+  0x07, 0xA3, 0x0E, 0x05,  // 125:1955
+  0x07, 0xB1, 0x17, 0x09,  // 126:1969
+  0xFF, 0xFF, 0x00, 0x00,  // 127:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 128:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 129:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 130:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 131:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 132:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 133:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 134:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 135:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 136:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 137:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 138:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 139:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 140:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 141:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 142:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 143:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 144:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 145:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 146:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 147:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 148:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 149:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 150:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 151:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 152:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 153:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 154:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 155:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 156:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 157:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 158:65535
+  0xFF, 0xFF, 0x00, 0x10,  // 159:65535
+  0xFF, 0xFF, 0x00, 0x04,  // 160:65535
+  0x07, 0xC8, 0x09, 0x05,  // 161:1992
+  0x07, 0xD1, 0x17, 0x09,  // 162:2001
+  0x07, 0xE8, 0x17, 0x09,  // 163:2024
+  0x07, 0xFF, 0x14, 0x09,  // 164:2047
+  0x08, 0x13, 0x1A, 0x09,  // 165:2067
+  0x08, 0x2D, 0x06, 0x04,  // 166:2093
+  0x08, 0x33, 0x17, 0x09,  // 167:2099
+  0x08, 0x4A, 0x07, 0x05,  // 168:2122
+  0x08, 0x51, 0x23, 0x0C,  // 169:2129
+  0x08, 0x74, 0x0E, 0x06,  // 170:2164
+  0x08, 0x82, 0x14, 0x09,  // 171:2178
+  0x08, 0x96, 0x17, 0x09,  // 172:2198
+  0x08, 0xAD, 0x0B, 0x05,  // 173:2221
+  0x08, 0xB8, 0x23, 0x0C,  // 174:2232
+  0x08, 0xDB, 0x19, 0x09,  // 175:2267
+  0x08, 0xF4, 0x0D, 0x06,  // 176:2292
+  0x09, 0x01, 0x17, 0x09,  // 177:2305
+  0x09, 0x18, 0x0E, 0x05,  // 178:2328
+  0x09, 0x26, 0x0D, 0x05,  // 179:2342
+  0x09, 0x33, 0x0A, 0x05,  // 180:2355
+  0x09, 0x3D, 0x17, 0x09,  // 181:2365
+  0x09, 0x54, 0x19, 0x09,  // 182:2388
+  0x09, 0x6D, 0x08, 0x05,  // 183:2413
+  0x09, 0x75, 0x0C, 0x05,  // 184:2421
+  0x09, 0x81, 0x0B, 0x05,  // 185:2433
+  0x09, 0x8C, 0x0D, 0x06,  // 186:2444
+  0x09, 0x99, 0x17, 0x09,  // 187:2457
+  0x09, 0xB0, 0x26, 0x0D,  // 188:2480
+  0x09, 0xD6, 0x26, 0x0D,  // 189:2518
+  0x09, 0xFC, 0x26, 0x0D,  // 190:2556
+  0x0A, 0x22, 0x1A, 0x0A,  // 191:2594
+  0x0A, 0x3C, 0x1D, 0x0B,  // 192:2620
+  0x0A, 0x59, 0x1D, 0x0B,  // 193:2649
+  0x0A, 0x76, 0x1D, 0x0B,  // 194:2678
+  0x0A, 0x93, 0x1D, 0x0B,  // 195:2707
+  0x0A, 0xB0, 0x1D, 0x0B,  // 196:2736
+  0x0A, 0xCD, 0x1D, 0x0B,  // 197:2765
+  0x0A, 0xEA, 0x2C, 0x10,  // 198:2794
+  0x0B, 0x16, 0x20, 0x0C,  // 199:2838
+  0x0B, 0x36, 0x1D, 0x0B,  // 200:2870
+  0x0B, 0x53, 0x1D, 0x0B,  // 201:2899
+  0x0B, 0x70, 0x1D, 0x0B,  // 202:2928
+  0x0B, 0x8D, 0x1D, 0x0B,  // 203:2957
+  0x0B, 0xAA, 0x05, 0x04,  // 204:2986
+  0x0B, 0xAF, 0x07, 0x04,  // 205:2991
+  0x0B, 0xB6, 0x0A, 0x04,  // 206:2998
+  0x0B, 0xC0, 0x07, 0x04,  // 207:3008
+  0x0B, 0xC7, 0x20, 0x0C,  // 208:3015
+  0x0B, 0xE7, 0x1D, 0x0C,  // 209:3047
+  0x0C, 0x04, 0x20, 0x0C,  // 210:3076
+  0x0C, 0x24, 0x20, 0x0C,  // 211:3108
+  0x0C, 0x44, 0x20, 0x0C,  // 212:3140
+  0x0C, 0x64, 0x20, 0x0C,  // 213:3172
+  0x0C, 0x84, 0x20, 0x0C,  // 214:3204
+  0x0C, 0xA4, 0x17, 0x09,  // 215:3236
+  0x0C, 0xBB, 0x20, 0x0C,  // 216:3259
+  0x0C, 0xDB, 0x1D, 0x0C,  // 217:3291
+  0x0C, 0xF8, 0x1D, 0x0C,  // 218:3320
+  0x0D, 0x15, 0x1D, 0x0C,  // 219:3349
+  0x0D, 0x32, 0x1D, 0x0C,  // 220:3378
+  0x0D, 0x4F, 0x19, 0x0B,  // 221:3407
+  0x0D, 0x68, 0x1D, 0x0B,  // 222:3432
+  0x0D, 0x85, 0x17, 0x0A,  // 223:3461
+  0x0D, 0x9C, 0x17, 0x09,  // 224:3484
+  0x0D, 0xB3, 0x17, 0x09,  // 225:3507
+  0x0D, 0xCA, 0x17, 0x09,  // 226:3530
+  0x0D, 0xE1, 0x17, 0x09,  // 227:3553
+  0x0D, 0xF8, 0x17, 0x09,  // 228:3576
+  0x0E, 0x0F, 0x17, 0x09,  // 229:3599
+  0x0E, 0x26, 0x29, 0x0E,  // 230:3622
+  0x0E, 0x4F, 0x14, 0x08,  // 231:3663
+  0x0E, 0x63, 0x17, 0x09,  // 232:3683
+  0x0E, 0x7A, 0x17, 0x09,  // 233:3706
+  0x0E, 0x91, 0x17, 0x09,  // 234:3729
+  0x0E, 0xA8, 0x17, 0x09,  // 235:3752
+  0x0E, 0xBF, 0x05, 0x04,  // 236:3775
+  0x0E, 0xC4, 0x07, 0x04,  // 237:3780
+  0x0E, 0xCB, 0x0A, 0x04,  // 238:3787
+  0x0E, 0xD5, 0x07, 0x04,  // 239:3797
+  0x0E, 0xDC, 0x17, 0x09,  // 240:3804
+  0x0E, 0xF3, 0x14, 0x09,  // 241:3827
+  0x0F, 0x07, 0x17, 0x09,  // 242:3847
+  0x0F, 0x1E, 0x17, 0x09,  // 243:3870
+  0x0F, 0x35, 0x17, 0x09,  // 244:3893
+  0x0F, 0x4C, 0x17, 0x09,  // 245:3916
+  0x0F, 0x63, 0x17, 0x09,  // 246:3939
+  0x0F, 0x7A, 0x17, 0x09,  // 247:3962
+  0x0F, 0x91, 0x17, 0x0A,  // 248:3985
+  0x0F, 0xA8, 0x14, 0x09,  // 249:4008
+  0x0F, 0xBC, 0x14, 0x09,  // 250:4028
+  0x0F, 0xD0, 0x14, 0x09,  // 251:4048
+  0x0F, 0xE4, 0x14, 0x09,  // 252:4068
+  0x0F, 0xF8, 0x13, 0x08,  // 253:4088
+  0x10, 0x0B, 0x17, 0x09,  // 254:4107
+  0x10, 0x22, 0x13, 0x08,  // 255:4130
+
+  // Font Data:
+  0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x5F,  // 33
+  0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78, // 34
+  0x80,0x08,0x00,0x80,0x78,0x00,0xC0,0x0F,0x00,0xB8,0x08,0x00,0x80,0x08,0x00,0x80,0x78,0x00,0xC0,0x0F,0x00,0xB8,0x08,0x00,0x80,0x08,  // 35
+  0x00,0x00,0x00,0xE0,0x10,0x00,0x10,0x21,0x00,0x08,0x41,0x00,0xFC,0xFF,0x00,0x08,0x42,0x00,0x10,0x22,0x00,0x20,0x1C, // 36
+  0x00,0x00,0x00,0xF0,0x00,0x00,0x08,0x01,0x00,0x08,0x01,0x00,0x08,0x61,0x00,0xF0,0x18,0x00,0x00,0x06,0x00,0xC0,0x01,0x00,0x30,0x3C,0x00,0x08,0x42,0x00,0x00,0x42,0x00,0x00,0x42,0x00,0x00,0x3C,  // 37
+  0x00,0x00,0x00,0x00,0x1C,0x00,0x70,0x22,0x00,0x88,0x41,0x00,0x08,0x43,0x00,0x88,0x44,0x00,0x70,0x28,0x00,0x00,0x10,0x00,0x00,0x28,0x00,0x00,0x44, // 38
+  0x00,0x00,0x00,0x78,  // 39
+  0x00,0x00,0x00,0x80,0x3F,0x00,0x70,0xC0,0x01,0x08,0x00,0x02,  // 40
+  0x00,0x00,0x00,0x08,0x00,0x02,0x70,0xC0,0x01,0x80,0x3F, // 41
+  0x10,0x00,0x00,0xD0,0x00,0x00,0x38,0x00,0x00,0xD0,0x00,0x00,0x10, // 42
+  0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0xC0,0x1F,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02, // 43
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x01, // 44
+  0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08, // 45
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,  // 46
+  0x00,0x60,0x00,0x00,0x1E,0x00,0xE0,0x01,0x00,0x18,  // 47
+  0x00,0x00,0x00,0xE0,0x1F,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0xE0,0x1F, // 48
+  0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0x00,0x10,0x00,0x00,0xF8,0x7F, // 49
+  0x00,0x00,0x00,0x20,0x40,0x00,0x10,0x60,0x00,0x08,0x50,0x00,0x08,0x48,0x00,0x08,0x44,0x00,0x10,0x43,0x00,0xE0,0x40, // 50
+  0x00,0x00,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x88,0x41,0x00,0xF0,0x22,0x00,0x00,0x1C, // 51
+  0x00,0x0C,0x00,0x00,0x0A,0x00,0x00,0x09,0x00,0xC0,0x08,0x00,0x20,0x08,0x00,0x10,0x08,0x00,0xF8,0x7F,0x00,0x00,0x08, // 52
+  0x00,0x00,0x00,0xC0,0x11,0x00,0xB8,0x20,0x00,0x88,0x40,0x00,0x88,0x40,0x00,0x88,0x40,0x00,0x08,0x21,0x00,0x08,0x1E, // 53
+  0x00,0x00,0x00,0xE0,0x1F,0x00,0x10,0x21,0x00,0x88,0x40,0x00,0x88,0x40,0x00,0x88,0x40,0x00,0x10,0x21,0x00,0x20,0x1E, // 54
+  0x00,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x78,0x00,0x08,0x07,0x00,0xC8,0x00,0x00,0x28,0x00,0x00,0x18,  // 55
+  0x00,0x00,0x00,0x60,0x1C,0x00,0x90,0x22,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x90,0x22,0x00,0x60,0x1C, // 56
+  0x00,0x00,0x00,0xE0,0x11,0x00,0x10,0x22,0x00,0x08,0x44,0x00,0x08,0x44,0x00,0x08,0x44,0x00,0x10,0x22,0x00,0xE0,0x1F, // 57
+  0x00,0x00,0x00,0x40,0x40, // 58
+  0x00,0x00,0x00,0x40,0xC0,0x01,  // 59
+  0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x05,0x00,0x00,0x05,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x40,0x10, // 60
+  0x00,0x00,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08, // 61
+  0x00,0x00,0x00,0x40,0x10,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x80,0x08,0x00,0x00,0x05,0x00,0x00,0x05,0x00,0x00,0x02, // 62
+  0x00,0x00,0x00,0x60,0x00,0x00,0x10,0x00,0x00,0x08,0x00,0x00,0x08,0x5C,0x00,0x08,0x02,0x00,0x10,0x01,0x00,0xE0,  // 63
+  0x00,0x00,0x00,0x00,0x3F,0x00,0xC0,0x40,0x00,0x20,0x80,0x00,0x10,0x1E,0x01,0x10,0x21,0x01,0x88,0x40,0x02,0x48,0x40,0x02,0x48,0x40,0x02,0x48,0x20,0x02,0x88,0x7C,0x02,0xC8,0x43,0x02,0x10,0x40,0x02,0x10,0x20,0x01,0x60,0x10,0x01,0x80,0x8F, // 64
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x70,0x04,0x00,0x08,0x04,0x00,0x70,0x04,0x00,0x80,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 65
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x90,0x22,0x00,0x60,0x1C, // 66
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,  // 67
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 68
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x40, // 69
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08, // 70
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x42,0x00,0x08,0x42,0x00,0x10,0x22,0x00,0x20,0x12,0x00,0x00,0x0E,  // 71
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0xF8,0x7F, // 72
+  0x00,0x00,0x00,0xF8,0x7F, // 73
+  0x00,0x00,0x00,0x00,0x38,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0xF8,0x3F,  // 74
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x00,0x04,0x00,0x00,0x02,0x00,0x00,0x01,0x00,0x80,0x03,0x00,0x40,0x04,0x00,0x20,0x18,0x00,0x10,0x20,0x00,0x08,0x40, // 75
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40, // 76
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x30,0x00,0x00,0xC0,0x00,0x00,0x00,0x03,0x00,0x00,0x1C,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x00,0x03,0x00,0xC0,0x00,0x00,0x30,0x00,0x00,0xF8,0x7F, // 77
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x10,0x00,0x00,0x60,0x00,0x00,0x80,0x00,0x00,0x00,0x03,0x00,0x00,0x04,0x00,0x00,0x18,0x00,0x00,0x20,0x00,0xF8,0x7F, // 78
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 79
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x10,0x01,0x00,0xE0,  // 80
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x08,0x50,0x00,0x08,0x50,0x00,0x10,0x20,0x00,0x20,0x70,0x00,0xC0,0x4F,  // 81
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x02,0x00,0x08,0x06,0x00,0x08,0x1A,0x00,0x10,0x21,0x00,0xE0,0x40, // 82
+  0x00,0x00,0x00,0x60,0x10,0x00,0x90,0x20,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x42,0x00,0x08,0x42,0x00,0x10,0x22,0x00,0x20,0x1C, // 83
+  0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0xF8,0x7F,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08, // 84
+  0x00,0x00,0x00,0xF8,0x1F,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xF8,0x1F, // 85
+  0x00,0x00,0x00,0x18,0x00,0x00,0xE0,0x00,0x00,0x00,0x07,0x00,0x00,0x18,0x00,0x00,0x60,0x00,0x00,0x18,0x00,0x00,0x07,0x00,0xE0,0x00,0x00,0x18,  // 86
+  0x18,0x00,0x00,0xE0,0x01,0x00,0x00,0x1E,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x03,0x00,0x70,0x00,0x00,0x08,0x00,0x00,0x70,0x00,0x00,0x80,0x03,0x00,0x00,0x1C,0x00,0x00,0x60,0x00,0x00,0x1E,0x00,0xE0,0x01,0x00,0x18, // 87
+  0x00,0x40,0x00,0x08,0x20,0x00,0x10,0x10,0x00,0x60,0x0C,0x00,0x80,0x02,0x00,0x00,0x01,0x00,0x80,0x02,0x00,0x60,0x0C,0x00,0x10,0x10,0x00,0x08,0x20,0x00,0x00,0x40,  // 88
+  0x08,0x00,0x00,0x30,0x00,0x00,0x40,0x00,0x00,0x80,0x01,0x00,0x00,0x7E,0x00,0x80,0x01,0x00,0x40,0x00,0x00,0x30,0x00,0x00,0x08, // 89
+  0x00,0x40,0x00,0x08,0x60,0x00,0x08,0x58,0x00,0x08,0x44,0x00,0x08,0x43,0x00,0x88,0x40,0x00,0x68,0x40,0x00,0x18,0x40,0x00,0x08,0x40,  // 90
+  0x00,0x00,0x00,0xF8,0xFF,0x03,0x08,0x00,0x02,0x08,0x00,0x02,  // 91
+  0x18,0x00,0x00,0xE0,0x01,0x00,0x00,0x1E,0x00,0x00,0x60, // 92
+  0x08,0x00,0x02,0x08,0x00,0x02,0xF8,0xFF,0x03, // 93
+  0x00,0x01,0x00,0xC0,0x00,0x00,0x30,0x00,0x00,0x08,0x00,0x00,0x30,0x00,0x00,0xC0,0x00,0x00,0x00,0x01,  // 94
+  0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02, // 95
+  0x00,0x00,0x00,0x08,0x00,0x00,0x10, // 96
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x42,0x00,0x40,0x22,0x00,0x80,0x7F, // 97
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 98
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,  // 99
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0xF8,0x7F, // 100
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x24,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x80,0x24,0x00,0x00,0x17, // 101
+  0x40,0x00,0x00,0xF0,0x7F,0x00,0x48,0x00,0x00,0x48,  // 102
+  0x00,0x00,0x00,0x00,0x1F,0x01,0x80,0x20,0x02,0x40,0x40,0x02,0x40,0x40,0x02,0x40,0x40,0x02,0x80,0x20,0x01,0xC0,0xFF, // 103
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x80,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x80,0x7F,  // 104
+  0x00,0x00,0x00,0xC8,0x7F, // 105
+  0x00,0x00,0x02,0xC8,0xFF,0x01,  // 106
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x00,0x08,0x00,0x00,0x04,0x00,0x00,0x06,0x00,0x00,0x19,0x00,0x80,0x20,0x00,0x40,0x40, // 107
+  0x00,0x00,0x00,0xF8,0x7F, // 108
+  0x00,0x00,0x00,0xC0,0x7F,0x00,0x80,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x80,0x7F,0x00,0x80,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x80,0x7F, // 109
+  0x00,0x00,0x00,0xC0,0x7F,0x00,0x80,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x80,0x7F,  // 110
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 111
+  0x00,0x00,0x00,0xC0,0xFF,0x03,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 112
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0xC0,0xFF,0x03,  // 113
+  0x00,0x00,0x00,0xC0,0x7F,0x00,0x80,0x00,0x00,0x40,0x00,0x00,0x40, // 114
+  0x00,0x00,0x00,0x80,0x23,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x80,0x38,  // 115
+  0x40,0x00,0x00,0xF0,0x7F,0x00,0x40,0x40,0x00,0x40,0x40, // 116
+  0x00,0x00,0x00,0xC0,0x3F,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xC0,0x7F,  // 117
+  0xC0,0x00,0x00,0x00,0x03,0x00,0x00,0x1C,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x00,0x03,0x00,0xC0, // 118
+  0xC0,0x00,0x00,0x00,0x1F,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x00,0x03,0x00,0xC0,0x00,0x00,0x00,0x03,0x00,0x00,0x1C,0x00,0x00,0x60,0x00,0x00,0x1F,0x00,0xC0, // 119
+  0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1B,0x00,0x00,0x04,0x00,0x00,0x1B,0x00,0x80,0x20,0x00,0x40,0x40,  // 120
+  0xC0,0x01,0x00,0x00,0x06,0x02,0x00,0x38,0x02,0x00,0xE0,0x01,0x00,0x38,0x00,0x00,0x07,0x00,0xC0, // 121
+  0x40,0x40,0x00,0x40,0x60,0x00,0x40,0x58,0x00,0x40,0x44,0x00,0x40,0x43,0x00,0xC0,0x40,0x00,0x40,0x40,  // 122
+  0x00,0x04,0x00,0x00,0x04,0x00,0xF0,0xFB,0x01,0x08,0x00,0x02,0x08,0x00,0x02, // 123
+  0x00,0x00,0x00,0xF8,0xFF,0x03,  // 124
+  0x08,0x00,0x02,0x08,0x00,0x02,0xF0,0xFB,0x01,0x00,0x04,0x00,0x00,0x04,  // 125
+  0x00,0x02,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x01,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x01, // 126
+  0x00,0x00,0x00,0x00,0x00,0x00,0x40,0xFF,0x03, // 161
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x03,0x40,0xF0,0x00,0x40,0x4E,0x00,0xC0,0x41,0x00,0xB8,0x20,0x00,0x00,0x11, // 162
+  0x00,0x41,0x00,0xE0,0x31,0x00,0x10,0x2F,0x00,0x08,0x21,0x00,0x08,0x21,0x00,0x08,0x40,0x00,0x10,0x40,0x00,0x20,0x20, // 163
+  0x00,0x00,0x00,0x40,0x0B,0x00,0x80,0x04,0x00,0x40,0x08,0x00,0x40,0x08,0x00,0x80,0x04,0x00,0x40,0x0B,  // 164
+  0x08,0x0A,0x00,0x10,0x0A,0x00,0x60,0x0A,0x00,0x80,0x0B,0x00,0x00,0x7E,0x00,0x80,0x0B,0x00,0x60,0x0A,0x00,0x10,0x0A,0x00,0x08,0x0A,  // 165
+  0x00,0x00,0x00,0xF8,0xF1,0x03,  // 166
+  0x00,0x86,0x00,0x70,0x09,0x01,0xC8,0x10,0x02,0x88,0x10,0x02,0x08,0x21,0x02,0x08,0x61,0x02,0x30,0xD2,0x01,0x00,0x0C, // 167
+  0x08,0x00,0x00,0x00,0x00,0x00,0x08, // 168
+  0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0xC8,0x47,0x00,0x28,0x48,0x00,0x28,0x48,0x00,0x28,0x48,0x00,0x28,0x48,0x00,0x48,0x44,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F, // 169
+  0xD0,0x00,0x00,0x48,0x01,0x00,0x28,0x01,0x00,0x28,0x01,0x00,0xF0,0x01,  // 170
+  0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x1B,0x00,0x80,0x20,0x00,0x00,0x04,0x00,0x00,0x1B,0x00,0x80,0x20,  // 171
+  0x00,0x00,0x00,0x80,0x00,0x00,0x80,0x00,0x00,0x80,0x00,0x00,0x80,0x00,0x00,0x80,0x00,0x00,0x80,0x00,0x00,0x80,0x0F, // 172
+  0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08,0x00,0x00,0x08, // 173
+  0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0xE8,0x4F,0x00,0x28,0x41,0x00,0x28,0x41,0x00,0x28,0x43,0x00,0x28,0x45,0x00,0xC8,0x48,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F, // 174
+  0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04,0x00,0x00,0x04, // 175
+  0x00,0x00,0x00,0x30,0x00,0x00,0x48,0x00,0x00,0x48,0x00,0x00,0x30, // 176
+  0x00,0x00,0x00,0x00,0x41,0x00,0x00,0x41,0x00,0x00,0x41,0x00,0xE0,0x4F,0x00,0x00,0x41,0x00,0x00,0x41,0x00,0x00,0x41, // 177
+  0x10,0x01,0x00,0x88,0x01,0x00,0x48,0x01,0x00,0x48,0x01,0x00,0x30,0x01,  // 178
+  0x90,0x00,0x00,0x08,0x01,0x00,0x08,0x01,0x00,0x28,0x01,0x00,0xD8, // 179
+  0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x08,  // 180
+  0x00,0x00,0x00,0xC0,0xFF,0x03,0x00,0x20,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xC0,0x7F, // 181
+  0xF0,0x00,0x00,0xF8,0x00,0x00,0xF8,0x01,0x00,0xF8,0x01,0x00,0xF8,0xFF,0x03,0x08,0x00,0x00,0x08,0x00,0x00,0xF8,0xFF,0x03,0x08, // 182
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,  // 183
+  0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x80,0x02,0x00,0x00,0x03,  // 184
+  0x00,0x00,0x00,0x10,0x00,0x00,0x08,0x00,0x00,0xF8,0x01, // 185
+  0xF0,0x00,0x00,0x08,0x01,0x00,0x08,0x01,0x00,0x08,0x01,0x00,0xF0, // 186
+  0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x20,0x00,0x00,0x1B,0x00,0x00,0x04,0x00,0x80,0x20,0x00,0x00,0x1B,0x00,0x00,0x04, // 187
+  0x00,0x00,0x00,0x10,0x00,0x00,0x08,0x40,0x00,0xF8,0x21,0x00,0x00,0x10,0x00,0x00,0x0C,0x00,0x00,0x02,0x00,0x80,0x01,0x00,0x40,0x30,0x00,0x30,0x28,0x00,0x08,0x24,0x00,0x00,0x7E,0x00,0x00,0x20,  // 188
+  0x00,0x00,0x00,0x10,0x00,0x00,0x08,0x40,0x00,0xF8,0x31,0x00,0x00,0x08,0x00,0x00,0x04,0x00,0x00,0x03,0x00,0x80,0x00,0x00,0x60,0x44,0x00,0x10,0x62,0x00,0x08,0x52,0x00,0x00,0x52,0x00,0x00,0x4C,  // 189
+  0x90,0x00,0x00,0x08,0x01,0x00,0x08,0x41,0x00,0x28,0x21,0x00,0xD8,0x18,0x00,0x00,0x04,0x00,0x00,0x03,0x00,0x80,0x00,0x00,0x40,0x30,0x00,0x30,0x28,0x00,0x08,0x24,0x00,0x00,0x7E,0x00,0x00,0x20,  // 190
+  0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0x10,0x01,0x00,0x08,0x02,0x40,0x07,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x01,0x00,0xC0,  // 191
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x71,0x04,0x00,0x0A,0x04,0x00,0x70,0x04,0x00,0x80,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 192
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x70,0x04,0x00,0x0A,0x04,0x00,0x71,0x04,0x00,0x80,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 193
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x72,0x04,0x00,0x09,0x04,0x00,0x71,0x04,0x00,0x82,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 194
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x72,0x04,0x00,0x09,0x04,0x00,0x72,0x04,0x00,0x81,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 195
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x72,0x04,0x00,0x08,0x04,0x00,0x72,0x04,0x00,0x80,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 196
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x1C,0x00,0x80,0x07,0x00,0x7E,0x04,0x00,0x0A,0x04,0x00,0x7E,0x04,0x00,0x80,0x07,0x00,0x00,0x1C,0x00,0x00,0x60, // 197
+  0x00,0x60,0x00,0x00,0x18,0x00,0x00,0x06,0x00,0x80,0x05,0x00,0x60,0x04,0x00,0x18,0x04,0x00,0x08,0x04,0x00,0x08,0x04,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,  // 198
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x08,0x40,0x02,0x08,0xC0,0x02,0x08,0x40,0x03,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,  // 199
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x09,0x41,0x00,0x0A,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x40, // 200
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x0A,0x41,0x00,0x09,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x40, // 201
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x0A,0x41,0x00,0x09,0x41,0x00,0x09,0x41,0x00,0x0A,0x41,0x00,0x08,0x41,0x00,0x08,0x40, // 202
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x0A,0x41,0x00,0x08,0x41,0x00,0x0A,0x41,0x00,0x08,0x41,0x00,0x08,0x41,0x00,0x08,0x40, // 203
+  0x01,0x00,0x00,0xFA,0x7F, // 204
+  0x00,0x00,0x00,0xFA,0x7F,0x00,0x01, // 205
+  0x02,0x00,0x00,0xF9,0x7F,0x00,0x01,0x00,0x00,0x02,  // 206
+  0x02,0x00,0x00,0xF8,0x7F,0x00,0x02, // 207
+  0x00,0x02,0x00,0xF8,0x7F,0x00,0x08,0x42,0x00,0x08,0x42,0x00,0x08,0x42,0x00,0x08,0x42,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 208
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x10,0x00,0x00,0x60,0x00,0x00,0x82,0x00,0x00,0x01,0x03,0x00,0x02,0x04,0x00,0x01,0x18,0x00,0x00,0x20,0x00,0xF8,0x7F, // 209
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x09,0x40,0x00,0x0A,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 210
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x0A,0x40,0x00,0x09,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 211
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x0A,0x40,0x00,0x09,0x40,0x00,0x09,0x40,0x00,0x0A,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 212
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x0A,0x40,0x00,0x09,0x40,0x00,0x0A,0x40,0x00,0x09,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 213
+  0x00,0x00,0x00,0xC0,0x0F,0x00,0x20,0x10,0x00,0x10,0x20,0x00,0x08,0x40,0x00,0x0A,0x40,0x00,0x08,0x40,0x00,0x0A,0x40,0x00,0x10,0x20,0x00,0x20,0x10,0x00,0xC0,0x0F,  // 214
+  0x00,0x00,0x00,0x40,0x10,0x00,0x80,0x08,0x00,0x00,0x05,0x00,0x00,0x07,0x00,0x00,0x05,0x00,0x80,0x08,0x00,0x40,0x10, // 215
+  0x00,0x00,0x00,0xC0,0x4F,0x00,0x20,0x30,0x00,0x10,0x30,0x00,0x08,0x4C,0x00,0x08,0x42,0x00,0x08,0x41,0x00,0xC8,0x40,0x00,0x30,0x20,0x00,0x30,0x10,0x00,0xC8,0x0F,  // 216
+  0x00,0x00,0x00,0xF8,0x1F,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0x01,0x40,0x00,0x02,0x40,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xF8,0x1F, // 217
+  0x00,0x00,0x00,0xF8,0x1F,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x02,0x40,0x00,0x01,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xF8,0x1F, // 218
+  0x00,0x00,0x00,0xF8,0x1F,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0x02,0x40,0x00,0x01,0x40,0x00,0x01,0x40,0x00,0x02,0x40,0x00,0x00,0x20,0x00,0xF8,0x1F, // 219
+  0x00,0x00,0x00,0xF8,0x1F,0x00,0x00,0x20,0x00,0x00,0x40,0x00,0x02,0x40,0x00,0x00,0x40,0x00,0x02,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xF8,0x1F, // 220
+  0x08,0x00,0x00,0x30,0x00,0x00,0x40,0x00,0x00,0x80,0x01,0x00,0x02,0x7E,0x00,0x81,0x01,0x00,0x40,0x00,0x00,0x30,0x00,0x00,0x08, // 221
+  0x00,0x00,0x00,0xF8,0x7F,0x00,0x20,0x10,0x00,0x20,0x10,0x00,0x20,0x10,0x00,0x20,0x10,0x00,0x20,0x10,0x00,0x20,0x10,0x00,0x40,0x08,0x00,0x80,0x07, // 222
+  0x00,0x00,0x00,0xE0,0x7F,0x00,0x10,0x00,0x00,0x08,0x20,0x00,0x88,0x43,0x00,0x70,0x42,0x00,0x00,0x44,0x00,0x00,0x38, // 223
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x40,0x44,0x00,0x48,0x44,0x00,0x50,0x42,0x00,0x40,0x22,0x00,0x80,0x7F, // 224
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x40,0x44,0x00,0x50,0x44,0x00,0x48,0x42,0x00,0x40,0x22,0x00,0x80,0x7F, // 225
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x50,0x44,0x00,0x48,0x44,0x00,0x48,0x42,0x00,0x50,0x22,0x00,0x80,0x7F, // 226
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x50,0x44,0x00,0x48,0x44,0x00,0x50,0x42,0x00,0x48,0x22,0x00,0x80,0x7F, // 227
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x50,0x44,0x00,0x40,0x44,0x00,0x50,0x42,0x00,0x40,0x22,0x00,0x80,0x7F, // 228
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x5C,0x44,0x00,0x54,0x44,0x00,0x5C,0x42,0x00,0x40,0x22,0x00,0x80,0x7F, // 229
+  0x00,0x00,0x00,0x00,0x39,0x00,0x80,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x42,0x00,0x40,0x22,0x00,0x80,0x3F,0x00,0x80,0x24,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x40,0x44,0x00,0x80,0x24,0x00,0x00,0x17, // 230
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x02,0x40,0xC0,0x02,0x40,0x40,0x03,0x80,0x20,  // 231
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x24,0x00,0x48,0x44,0x00,0x50,0x44,0x00,0x40,0x44,0x00,0x80,0x24,0x00,0x00,0x17, // 232
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x24,0x00,0x40,0x44,0x00,0x50,0x44,0x00,0x48,0x44,0x00,0x80,0x24,0x00,0x00,0x17, // 233
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x24,0x00,0x50,0x44,0x00,0x48,0x44,0x00,0x48,0x44,0x00,0x90,0x24,0x00,0x00,0x17, // 234
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x24,0x00,0x50,0x44,0x00,0x40,0x44,0x00,0x50,0x44,0x00,0x80,0x24,0x00,0x00,0x17, // 235
+  0x08,0x00,0x00,0xD0,0x7F, // 236
+  0x00,0x00,0x00,0xD0,0x7F,0x00,0x08, // 237
+  0x10,0x00,0x00,0xC8,0x7F,0x00,0x08,0x00,0x00,0x10,  // 238
+  0x10,0x00,0x00,0xC0,0x7F,0x00,0x10, // 239
+  0x00,0x00,0x00,0x00,0x1F,0x00,0xA0,0x20,0x00,0x68,0x40,0x00,0x58,0x40,0x00,0x70,0x40,0x00,0xE8,0x20,0x00,0x00,0x1F, // 240
+  0x00,0x00,0x00,0xC0,0x7F,0x00,0x90,0x00,0x00,0x48,0x00,0x00,0x50,0x00,0x00,0x48,0x00,0x00,0x80,0x7F,  // 241
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x48,0x40,0x00,0x50,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 242
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x40,0x40,0x00,0x50,0x40,0x00,0x48,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 243
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x50,0x40,0x00,0x48,0x40,0x00,0x48,0x40,0x00,0x90,0x20,0x00,0x00,0x1F, // 244
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x50,0x40,0x00,0x48,0x40,0x00,0x50,0x40,0x00,0x88,0x20,0x00,0x00,0x1F, // 245
+  0x00,0x00,0x00,0x00,0x1F,0x00,0x80,0x20,0x00,0x50,0x40,0x00,0x40,0x40,0x00,0x50,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 246
+  0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x80,0x0A,0x00,0x00,0x02,0x00,0x00,0x02,0x00,0x00,0x02, // 247
+  0x00,0x00,0x00,0x00,0x5F,0x00,0x80,0x30,0x00,0x40,0x48,0x00,0x40,0x44,0x00,0x40,0x42,0x00,0x80,0x21,0x00,0x40,0x1F, // 248
+  0x00,0x00,0x00,0xC0,0x3F,0x00,0x00,0x40,0x00,0x08,0x40,0x00,0x10,0x40,0x00,0x00,0x20,0x00,0xC0,0x7F,  // 249
+  0x00,0x00,0x00,0xC0,0x3F,0x00,0x00,0x40,0x00,0x00,0x40,0x00,0x10,0x40,0x00,0x08,0x20,0x00,0xC0,0x7F,  // 250
+  0x00,0x00,0x00,0xC0,0x3F,0x00,0x10,0x40,0x00,0x08,0x40,0x00,0x08,0x40,0x00,0x10,0x20,0x00,0xC0,0x7F,  // 251
+  0x00,0x00,0x00,0xD0,0x3F,0x00,0x00,0x40,0x00,0x10,0x40,0x00,0x00,0x40,0x00,0x00,0x20,0x00,0xC0,0x7F,  // 252
+  0xC0,0x01,0x00,0x00,0x06,0x02,0x00,0x38,0x02,0x10,0xE0,0x01,0x08,0x38,0x00,0x00,0x07,0x00,0xC0, // 253
+  0x00,0x00,0x00,0xF8,0xFF,0x03,0x80,0x20,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x40,0x40,0x00,0x80,0x20,0x00,0x00,0x1F, // 254
+  0xC0,0x01,0x00,0x00,0x06,0x02,0x10,0x38,0x02,0x00,0xE0,0x01,0x10,0x38,0x00,0x00,0x07,0x00,0xC0  // 255
+};
+
+const uint8_t ArialMT_Plain_24[] PROGMEM = {
+  0x18, // Width: 24
+  0x1C, // Height: 28
+  0x20, // First Char: 32
+  0xE0, // Numbers of Chars: 224
+
+  // Jump Table:
+  0xFF, 0xFF, 0x00, 0x07,  // 32:65535
+  0x00, 0x00, 0x13, 0x07,  // 33:0
+  0x00, 0x13, 0x1A, 0x09,  // 34:19
+  0x00, 0x2D, 0x33, 0x0D,  // 35:45
+  0x00, 0x60, 0x2F, 0x0D,  // 36:96
+  0x00, 0x8F, 0x4F, 0x15,  // 37:143
+  0x00, 0xDE, 0x3B, 0x10,  // 38:222
+  0x01, 0x19, 0x0A, 0x05,  // 39:281
+  0x01, 0x23, 0x1C, 0x08,  // 40:291
+  0x01, 0x3F, 0x1B, 0x08,  // 41:319
+  0x01, 0x5A, 0x21, 0x09,  // 42:346
+  0x01, 0x7B, 0x32, 0x0E,  // 43:379
+  0x01, 0xAD, 0x10, 0x07,  // 44:429
+  0x01, 0xBD, 0x1B, 0x08,  // 45:445
+  0x01, 0xD8, 0x0F, 0x07,  // 46:472
+  0x01, 0xE7, 0x19, 0x07,  // 47:487
+  0x02, 0x00, 0x2F, 0x0D,  // 48:512
+  0x02, 0x2F, 0x23, 0x0D,  // 49:559
+  0x02, 0x52, 0x2F, 0x0D,  // 50:594
+  0x02, 0x81, 0x2F, 0x0D,  // 51:641
+  0x02, 0xB0, 0x2F, 0x0D,  // 52:688
+  0x02, 0xDF, 0x2F, 0x0D,  // 53:735
+  0x03, 0x0E, 0x2F, 0x0D,  // 54:782
+  0x03, 0x3D, 0x2D, 0x0D,  // 55:829
+  0x03, 0x6A, 0x2F, 0x0D,  // 56:874
+  0x03, 0x99, 0x2F, 0x0D,  // 57:921
+  0x03, 0xC8, 0x0F, 0x07,  // 58:968
+  0x03, 0xD7, 0x10, 0x07,  // 59:983
+  0x03, 0xE7, 0x2F, 0x0E,  // 60:999
+  0x04, 0x16, 0x2F, 0x0E,  // 61:1046
+  0x04, 0x45, 0x2E, 0x0E,  // 62:1093
+  0x04, 0x73, 0x2E, 0x0D,  // 63:1139
+  0x04, 0xA1, 0x5B, 0x18,  // 64:1185
+  0x04, 0xFC, 0x3B, 0x10,  // 65:1276
+  0x05, 0x37, 0x3B, 0x10,  // 66:1335
+  0x05, 0x72, 0x3F, 0x11,  // 67:1394
+  0x05, 0xB1, 0x3F, 0x11,  // 68:1457
+  0x05, 0xF0, 0x3B, 0x10,  // 69:1520
+  0x06, 0x2B, 0x35, 0x0F,  // 70:1579
+  0x06, 0x60, 0x43, 0x13,  // 71:1632
+  0x06, 0xA3, 0x3B, 0x11,  // 72:1699
+  0x06, 0xDE, 0x0F, 0x07,  // 73:1758
+  0x06, 0xED, 0x27, 0x0C,  // 74:1773
+  0x07, 0x14, 0x3F, 0x10,  // 75:1812
+  0x07, 0x53, 0x2F, 0x0D,  // 76:1875
+  0x07, 0x82, 0x43, 0x14,  // 77:1922
+  0x07, 0xC5, 0x3B, 0x11,  // 78:1989
+  0x08, 0x00, 0x47, 0x13,  // 79:2048
+  0x08, 0x47, 0x3A, 0x10,  // 80:2119
+  0x08, 0x81, 0x47, 0x13,  // 81:2177
+  0x08, 0xC8, 0x3F, 0x11,  // 82:2248
+  0x09, 0x07, 0x3B, 0x10,  // 83:2311
+  0x09, 0x42, 0x35, 0x0F,  // 84:2370
+  0x09, 0x77, 0x3B, 0x11,  // 85:2423
+  0x09, 0xB2, 0x39, 0x10,  // 86:2482
+  0x09, 0xEB, 0x59, 0x17,  // 87:2539
+  0x0A, 0x44, 0x3B, 0x10,  // 88:2628
+  0x0A, 0x7F, 0x3D, 0x10,  // 89:2687
+  0x0A, 0xBC, 0x37, 0x0F,  // 90:2748
+  0x0A, 0xF3, 0x14, 0x07,  // 91:2803
+  0x0B, 0x07, 0x1B, 0x07,  // 92:2823
+  0x0B, 0x22, 0x18, 0x07,  // 93:2850
+  0x0B, 0x3A, 0x2A, 0x0B,  // 94:2874
+  0x0B, 0x64, 0x34, 0x0D,  // 95:2916
+  0x0B, 0x98, 0x11, 0x08,  // 96:2968
+  0x0B, 0xA9, 0x2F, 0x0D,  // 97:2985
+  0x0B, 0xD8, 0x33, 0x0D,  // 98:3032
+  0x0C, 0x0B, 0x2B, 0x0C,  // 99:3083
+  0x0C, 0x36, 0x2F, 0x0D,  // 100:3126
+  0x0C, 0x65, 0x2F, 0x0D,  // 101:3173
+  0x0C, 0x94, 0x1A, 0x07,  // 102:3220
+  0x0C, 0xAE, 0x2F, 0x0D,  // 103:3246
+  0x0C, 0xDD, 0x2F, 0x0D,  // 104:3293
+  0x0D, 0x0C, 0x0F, 0x05,  // 105:3340
+  0x0D, 0x1B, 0x10, 0x05,  // 106:3355
+  0x0D, 0x2B, 0x2F, 0x0C,  // 107:3371
+  0x0D, 0x5A, 0x0F, 0x05,  // 108:3418
+  0x0D, 0x69, 0x47, 0x14,  // 109:3433
+  0x0D, 0xB0, 0x2F, 0x0D,  // 110:3504
+  0x0D, 0xDF, 0x2F, 0x0D,  // 111:3551
+  0x0E, 0x0E, 0x33, 0x0D,  // 112:3598
+  0x0E, 0x41, 0x30, 0x0D,  // 113:3649
+  0x0E, 0x71, 0x1E, 0x08,  // 114:3697
+  0x0E, 0x8F, 0x2B, 0x0C,  // 115:3727
+  0x0E, 0xBA, 0x1B, 0x07,  // 116:3770
+  0x0E, 0xD5, 0x2F, 0x0D,  // 117:3797
+  0x0F, 0x04, 0x2A, 0x0C,  // 118:3844
+  0x0F, 0x2E, 0x42, 0x11,  // 119:3886
+  0x0F, 0x70, 0x2B, 0x0C,  // 120:3952
+  0x0F, 0x9B, 0x2A, 0x0C,  // 121:3995
+  0x0F, 0xC5, 0x2B, 0x0C,  // 122:4037
+  0x0F, 0xF0, 0x1C, 0x08,  // 123:4080
+  0x10, 0x0C, 0x10, 0x06,  // 124:4108
+  0x10, 0x1C, 0x1B, 0x08,  // 125:4124
+  0x10, 0x37, 0x32, 0x0E,  // 126:4151
+  0xFF, 0xFF, 0x00, 0x00,  // 127:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 128:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 129:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 130:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 131:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 132:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 133:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 134:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 135:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 136:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 137:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 138:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 139:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 140:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 141:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 142:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 143:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 144:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 145:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 146:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 147:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 148:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 149:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 150:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 151:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 152:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 153:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 154:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 155:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 156:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 157:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 158:65535
+  0xFF, 0xFF, 0x00, 0x18,  // 159:65535
+  0xFF, 0xFF, 0x00, 0x07,  // 160:65535
+  0x10, 0x69, 0x14, 0x08,  // 161:4201
+  0x10, 0x7D, 0x2B, 0x0D,  // 162:4221
+  0x10, 0xA8, 0x2F, 0x0D,  // 163:4264
+  0x10, 0xD7, 0x33, 0x0D,  // 164:4311
+  0x11, 0x0A, 0x31, 0x0D,  // 165:4362
+  0x11, 0x3B, 0x10, 0x06,  // 166:4411
+  0x11, 0x4B, 0x2F, 0x0D,  // 167:4427
+  0x11, 0x7A, 0x19, 0x08,  // 168:4474
+  0x11, 0x93, 0x46, 0x12,  // 169:4499
+  0x11, 0xD9, 0x1A, 0x09,  // 170:4569
+  0x11, 0xF3, 0x27, 0x0D,  // 171:4595
+  0x12, 0x1A, 0x2F, 0x0E,  // 172:4634
+  0x12, 0x49, 0x1B, 0x08,  // 173:4681
+  0x12, 0x64, 0x46, 0x12,  // 174:4708
+  0x12, 0xAA, 0x31, 0x0D,  // 175:4778
+  0x12, 0xDB, 0x1E, 0x0A,  // 176:4827
+  0x12, 0xF9, 0x33, 0x0D,  // 177:4857
+  0x13, 0x2C, 0x1A, 0x08,  // 178:4908
+  0x13, 0x46, 0x1A, 0x08,  // 179:4934
+  0x13, 0x60, 0x19, 0x08,  // 180:4960
+  0x13, 0x79, 0x2F, 0x0E,  // 181:4985
+  0x13, 0xA8, 0x31, 0x0D,  // 182:5032
+  0x13, 0xD9, 0x12, 0x08,  // 183:5081
+  0x13, 0xEB, 0x18, 0x08,  // 184:5099
+  0x14, 0x03, 0x16, 0x08,  // 185:5123
+  0x14, 0x19, 0x1E, 0x09,  // 186:5145
+  0x14, 0x37, 0x2E, 0x0D,  // 187:5175
+  0x14, 0x65, 0x4F, 0x14,  // 188:5221
+  0x14, 0xB4, 0x4B, 0x14,  // 189:5300
+  0x14, 0xFF, 0x4B, 0x14,  // 190:5375
+  0x15, 0x4A, 0x33, 0x0F,  // 191:5450
+  0x15, 0x7D, 0x3B, 0x10,  // 192:5501
+  0x15, 0xB8, 0x3B, 0x10,  // 193:5560
+  0x15, 0xF3, 0x3B, 0x10,  // 194:5619
+  0x16, 0x2E, 0x3B, 0x10,  // 195:5678
+  0x16, 0x69, 0x3B, 0x10,  // 196:5737
+  0x16, 0xA4, 0x3B, 0x10,  // 197:5796
+  0x16, 0xDF, 0x5B, 0x18,  // 198:5855
+  0x17, 0x3A, 0x3F, 0x11,  // 199:5946
+  0x17, 0x79, 0x3B, 0x10,  // 200:6009
+  0x17, 0xB4, 0x3B, 0x10,  // 201:6068
+  0x17, 0xEF, 0x3B, 0x10,  // 202:6127
+  0x18, 0x2A, 0x3B, 0x10,  // 203:6186
+  0x18, 0x65, 0x11, 0x07,  // 204:6245
+  0x18, 0x76, 0x11, 0x07,  // 205:6262
+  0x18, 0x87, 0x15, 0x07,  // 206:6279
+  0x18, 0x9C, 0x15, 0x07,  // 207:6300
+  0x18, 0xB1, 0x3F, 0x11,  // 208:6321
+  0x18, 0xF0, 0x3B, 0x11,  // 209:6384
+  0x19, 0x2B, 0x47, 0x13,  // 210:6443
+  0x19, 0x72, 0x47, 0x13,  // 211:6514
+  0x19, 0xB9, 0x47, 0x13,  // 212:6585
+  0x1A, 0x00, 0x47, 0x13,  // 213:6656
+  0x1A, 0x47, 0x47, 0x13,  // 214:6727
+  0x1A, 0x8E, 0x2B, 0x0E,  // 215:6798
+  0x1A, 0xB9, 0x47, 0x13,  // 216:6841
+  0x1B, 0x00, 0x3B, 0x11,  // 217:6912
+  0x1B, 0x3B, 0x3B, 0x11,  // 218:6971
+  0x1B, 0x76, 0x3B, 0x11,  // 219:7030
+  0x1B, 0xB1, 0x3B, 0x11,  // 220:7089
+  0x1B, 0xEC, 0x3D, 0x10,  // 221:7148
+  0x1C, 0x29, 0x3A, 0x10,  // 222:7209
+  0x1C, 0x63, 0x37, 0x0F,  // 223:7267
+  0x1C, 0x9A, 0x2F, 0x0D,  // 224:7322
+  0x1C, 0xC9, 0x2F, 0x0D,  // 225:7369
+  0x1C, 0xF8, 0x2F, 0x0D,  // 226:7416
+  0x1D, 0x27, 0x2F, 0x0D,  // 227:7463
+  0x1D, 0x56, 0x2F, 0x0D,  // 228:7510
+  0x1D, 0x85, 0x2F, 0x0D,  // 229:7557
+  0x1D, 0xB4, 0x53, 0x15,  // 230:7604
+  0x1E, 0x07, 0x2B, 0x0C,  // 231:7687
+  0x1E, 0x32, 0x2F, 0x0D,  // 232:7730
+  0x1E, 0x61, 0x2F, 0x0D,  // 233:7777
+  0x1E, 0x90, 0x2F, 0x0D,  // 234:7824
+  0x1E, 0xBF, 0x2F, 0x0D,  // 235:7871
+  0x1E, 0xEE, 0x11, 0x07,  // 236:7918
+  0x1E, 0xFF, 0x11, 0x07,  // 237:7935
+  0x1F, 0x10, 0x15, 0x07,  // 238:7952
+  0x1F, 0x25, 0x15, 0x07,  // 239:7973
+  0x1F, 0x3A, 0x2F, 0x0D,  // 240:7994
+  0x1F, 0x69, 0x2F, 0x0D,  // 241:8041
+  0x1F, 0x98, 0x2F, 0x0D,  // 242:8088
+  0x1F, 0xC7, 0x2F, 0x0D,  // 243:8135
+  0x1F, 0xF6, 0x2F, 0x0D,  // 244:8182
+  0x20, 0x25, 0x2F, 0x0D,  // 245:8229
+  0x20, 0x54, 0x2F, 0x0D,  // 246:8276
+  0x20, 0x83, 0x32, 0x0D,  // 247:8323
+  0x20, 0xB5, 0x33, 0x0F,  // 248:8373
+  0x20, 0xE8, 0x2F, 0x0D,  // 249:8424
+  0x21, 0x17, 0x2F, 0x0D,  // 250:8471
+  0x21, 0x46, 0x2F, 0x0D,  // 251:8518
+  0x21, 0x75, 0x2F, 0x0D,  // 252:8565
+  0x21, 0xA4, 0x2A, 0x0C,  // 253:8612
+  0x21, 0xCE, 0x2F, 0x0D,  // 254:8654
+  0x21, 0xFD, 0x2A, 0x0C,  // 255:8701
+
+  // Font Data:
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x33,0x00,0xE0,0xFF,0x33, // 33
+  0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xE0,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xE0,0x07,  // 34
+  0x00,0x0C,0x03,0x00,0x00,0x0C,0x33,0x00,0x00,0x0C,0x3F,0x00,0x00,0xFC,0x0F,0x00,0x80,0xFF,0x03,0x00,0xE0,0x0F,0x03,0x00,0x60,0x0C,0x33,0x00,0x00,0x0C,0x3F,0x00,0x00,0xFC,0x0F,0x00,0x80,0xFF,0x03,0x00,0xE0,0x0F,0x03,0x00,0x60,0x0C,0x03,0x00,0x00,0x0C,0x03, // 35
+  0x00,0x00,0x00,0x00,0x80,0x07,0x06,0x00,0xC0,0x0F,0x1E,0x00,0xC0,0x18,0x1C,0x00,0x60,0x18,0x38,0x00,0x60,0x30,0x30,0x00,0xF0,0xFF,0xFF,0x00,0x60,0x30,0x30,0x00,0x60,0x60,0x38,0x00,0xC0,0x60,0x18,0x00,0xC0,0xC1,0x1F,0x00,0x00,0x81,0x07, // 36
+  0x00,0x00,0x00,0x00,0x80,0x0F,0x00,0x00,0xC0,0x1F,0x00,0x00,0x60,0x30,0x00,0x00,0x20,0x20,0x00,0x00,0x20,0x20,0x20,0x00,0x60,0x30,0x38,0x00,0xC0,0x1F,0x1E,0x00,0x80,0x8F,0x0F,0x00,0x00,0xC0,0x03,0x00,0x00,0xF0,0x00,0x00,0x00,0x3C,0x00,0x00,0x00,0x8F,0x0F,0x00,0xC0,0xC3,0x1F,0x00,0xE0,0x60,0x30,0x00,0x20,0x20,0x20,0x00,0x00,0x20,0x20,0x00,0x00,0x60,0x30,0x00,0x00,0xC0,0x1F,0x00,0x00,0x80,0x0F, // 37
+  0x00,0x00,0x00,0x00,0x00,0x80,0x07,0x00,0x00,0xC0,0x0F,0x00,0x80,0xE3,0x1C,0x00,0xC0,0x77,0x38,0x00,0xE0,0x3C,0x30,0x00,0x60,0x38,0x30,0x00,0x60,0x78,0x30,0x00,0xE0,0xEC,0x38,0x00,0xC0,0x8F,0x1B,0x00,0x80,0x03,0x1F,0x00,0x00,0x00,0x0F,0x00,0x00,0xC0,0x1F,0x00,0x00,0xC0,0x38,0x00,0x00,0x00,0x10, // 38
+  0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xE0,0x07,  // 39
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x0F,0x00,0x00,0xFE,0x7F,0x00,0x80,0x0F,0xF0,0x01,0xC0,0x01,0x80,0x03,0x60,0x00,0x00,0x06,0x20,0x00,0x00,0x04,  // 40
+  0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x04,0x60,0x00,0x00,0x06,0xC0,0x01,0x80,0x03,0x80,0x0F,0xF0,0x01,0x00,0xFE,0x7F,0x00,0x00,0xF0,0x0F, // 41
+  0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80,0x04,0x00,0x00,0x80,0x0F,0x00,0x00,0xE0,0x03,0x00,0x00,0xE0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x80,0x04,0x00,0x00,0x80, // 42
+  0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xFF,0x0F,0x00,0x00,0xFF,0x0F,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,  // 43
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x03,0x00,0x00,0xF0,0x01,  // 44
+  0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01, // 45
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30, // 46
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0xE0,0x0F,0x00,0x00,0xFC,0x01,0x00,0x80,0x3F,0x00,0x00,0xE0,0x03,0x00,0x00,0x60, // 47
+  0x00,0x00,0x00,0x00,0x00,0xFE,0x03,0x00,0x80,0xFF,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xE0,0x00,0x38,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x38,0x00,0xC0,0x01,0x1C,0x00,0x80,0xFF,0x0F,0x00,0x00,0xFE,0x03, // 48
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x03,0x00,0x00,0x80,0x01,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 49
+  0x00,0x00,0x00,0x00,0x00,0x03,0x30,0x00,0xC0,0x03,0x38,0x00,0xC0,0x00,0x3C,0x00,0x60,0x00,0x36,0x00,0x60,0x00,0x33,0x00,0x60,0x80,0x31,0x00,0x60,0xC0,0x30,0x00,0x60,0x60,0x30,0x00,0xC0,0x30,0x30,0x00,0xC0,0x1F,0x30,0x00,0x00,0x0F,0x30, // 50
+  0x00,0x00,0x00,0x00,0x00,0x01,0x06,0x00,0xC0,0x01,0x0E,0x00,0xC0,0x00,0x1C,0x00,0x60,0x00,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0xC0,0x38,0x30,0x00,0xC0,0x6F,0x18,0x00,0x80,0xC7,0x0F,0x00,0x00,0x80,0x07, // 51
+  0x00,0x00,0x00,0x00,0x00,0x80,0x03,0x00,0x00,0xC0,0x03,0x00,0x00,0xF0,0x03,0x00,0x00,0x3C,0x03,0x00,0x00,0x0E,0x03,0x00,0x80,0x07,0x03,0x00,0xC0,0x01,0x03,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x03, // 52
+  0x00,0x00,0x00,0x00,0x00,0x30,0x06,0x00,0x80,0x3F,0x0E,0x00,0xE0,0x1F,0x18,0x00,0x60,0x08,0x30,0x00,0x60,0x0C,0x30,0x00,0x60,0x0C,0x30,0x00,0x60,0x0C,0x30,0x00,0x60,0x0C,0x30,0x00,0x60,0x18,0x1C,0x00,0x60,0xF0,0x0F,0x00,0x00,0xE0,0x03, // 53
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x03,0x00,0x80,0xFF,0x0F,0x00,0xC0,0x63,0x1C,0x00,0xC0,0x30,0x38,0x00,0x60,0x18,0x30,0x00,0x60,0x18,0x30,0x00,0x60,0x18,0x30,0x00,0x60,0x18,0x30,0x00,0xE0,0x30,0x18,0x00,0xC0,0xF1,0x0F,0x00,0x80,0xC1,0x07, // 54
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x3C,0x00,0x60,0x80,0x3F,0x00,0x60,0xE0,0x03,0x00,0x60,0x78,0x00,0x00,0x60,0x0E,0x00,0x00,0x60,0x03,0x00,0x00,0xE0,0x01,0x00,0x00,0x60, // 55
+  0x00,0x00,0x00,0x00,0x00,0x80,0x07,0x00,0x80,0xC7,0x1F,0x00,0xC0,0x6F,0x18,0x00,0xE0,0x38,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0xE0,0x38,0x30,0x00,0xC0,0x6F,0x18,0x00,0x80,0xC7,0x1F,0x00,0x00,0x80,0x07, // 56
+  0x00,0x00,0x00,0x00,0x00,0x1F,0x0C,0x00,0x80,0x7F,0x1C,0x00,0xC0,0x61,0x38,0x00,0x60,0xC0,0x30,0x00,0x60,0xC0,0x30,0x00,0x60,0xC0,0x30,0x00,0x60,0xC0,0x30,0x00,0x60,0x60,0x18,0x00,0xC0,0x31,0x1E,0x00,0x80,0xFF,0x0F,0x00,0x00,0xFE,0x01, // 57
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30, // 58
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x30,0x03,0x00,0x06,0xF0,0x01,  // 59
+  0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0xD8,0x00,0x00,0x00,0xD8,0x00,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x04,0x01,0x00,0x00,0x06,0x03,0x00,0x00,0x06,0x03,0x00,0x00,0x03,0x06, // 60
+  0x00,0x00,0x00,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01, // 61
+  0x00,0x00,0x00,0x00,0x00,0x03,0x06,0x00,0x00,0x06,0x03,0x00,0x00,0x06,0x03,0x00,0x00,0x04,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0x8C,0x01,0x00,0x00,0xD8,0x00,0x00,0x00,0xD8,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x20,  // 62
+  0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x80,0x03,0x00,0x00,0xC0,0x01,0x00,0x00,0xE0,0x00,0x00,0x00,0x60,0x80,0x33,0x00,0x60,0xC0,0x33,0x00,0x60,0xE0,0x00,0x00,0x60,0x30,0x00,0x00,0xC0,0x38,0x00,0x00,0xC0,0x1F,0x00,0x00,0x00,0x07,  // 63
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x0F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x1E,0xF0,0x00,0x00,0x07,0xC0,0x01,0x80,0xC3,0x87,0x01,0xC0,0xF1,0x9F,0x03,0xC0,0x38,0x18,0x03,0xC0,0x0C,0x30,0x03,0x60,0x0E,0x30,0x06,0x60,0x06,0x30,0x06,0x60,0x06,0x18,0x06,0x60,0x06,0x0C,0x06,0x60,0x0C,0x1E,0x06,0x60,0xF8,0x3F,0x06,0xE0,0xFE,0x31,0x06,0xC0,0x0E,0x30,0x06,0xC0,0x01,0x18,0x03,0x80,0x03,0x1C,0x03,0x00,0x07,0x8F,0x01,0x00,0xFE,0x87,0x01,0x00,0xF8,0xC1,0x00,0x00,0x00,0x40, // 64
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x80,0x8F,0x01,0x00,0xE0,0x83,0x01,0x00,0x60,0x80,0x01,0x00,0xE0,0x83,0x01,0x00,0x80,0x8F,0x01,0x00,0x00,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 65
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0xC0,0x78,0x30,0x00,0xC0,0xFF,0x18,0x00,0x80,0xC7,0x1F,0x00,0x00,0x80,0x07, // 66
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x03,0x0F,0x00,0x00,0x02,0x03, // 67
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x03,0x0E,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 68
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 69
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60, // 70
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x18,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x60,0x30,0x00,0x60,0x60,0x30,0x00,0xE0,0x60,0x38,0x00,0xC0,0x60,0x18,0x00,0xC0,0x61,0x18,0x00,0x80,0xE3,0x0F,0x00,0x00,0xE2,0x0F, // 71
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 72
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 73
+  0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x38,0x00,0xE0,0xFF,0x1F,0x00,0xE0,0xFF,0x0F, // 74
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0xE0,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0xE7,0x01,0x00,0x80,0x83,0x07,0x00,0xC0,0x01,0x0F,0x00,0xE0,0x00,0x1E,0x00,0x60,0x00,0x38,0x00,0x20,0x00,0x30,0x00,0x00,0x00,0x20, // 75
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30, // 76
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0x01,0x00,0x00,0xC0,0x0F,0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3F,0x00,0x00,0xE0,0x07,0x00,0x00,0xFE,0x00,0x00,0xC0,0x0F,0x00,0x00,0xE0,0x01,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 77
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0xC0,0x01,0x00,0x00,0x80,0x03,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x3C,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0xE0,0x01,0x00,0x00,0x80,0x03,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 78
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x38,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 79
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0x60,0x60,0x00,0x00,0xC0,0x30,0x00,0x00,0xC0,0x3F,0x00,0x00,0x00,0x0F,  // 80
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x0C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x18,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x36,0x00,0x60,0x00,0x36,0x00,0xE0,0x00,0x3C,0x00,0xC0,0x00,0x1C,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x3F,0x00,0x00,0xFF,0x77,0x00,0x00,0xFC,0x61, // 81
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x70,0x00,0x00,0x60,0xF0,0x00,0x00,0x60,0xF0,0x03,0x00,0x60,0xB0,0x07,0x00,0xE0,0x18,0x1F,0x00,0xC0,0x1F,0x3C,0x00,0x80,0x0F,0x30,0x00,0x00,0x00,0x20, // 82
+  0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x07,0x0F,0x00,0xC0,0x1F,0x1C,0x00,0xC0,0x18,0x18,0x00,0x60,0x38,0x38,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x70,0x30,0x00,0xC0,0x60,0x18,0x00,0xC0,0xE1,0x18,0x00,0x80,0xC3,0x0F,0x00,0x00,0x83,0x07, // 83
+  0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60, // 84
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x03,0x00,0xE0,0xFF,0x0F,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x0F,0x00,0xE0,0xFF,0x03, // 85
+  0x20,0x00,0x00,0x00,0xE0,0x01,0x00,0x00,0xC0,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0xF8,0x01,0x00,0x00,0xC0,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x3E,0x00,0x00,0xC0,0x0F,0x00,0x00,0xF8,0x01,0x00,0x00,0x3E,0x00,0x00,0xC0,0x0F,0x00,0x00,0xE0,0x01,0x00,0x00,0x20, // 86
+  0x60,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0x80,0xFF,0x00,0x00,0x00,0xF8,0x0F,0x00,0x00,0x80,0x3F,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3F,0x00,0x00,0xE0,0x0F,0x00,0x00,0xFC,0x01,0x00,0x80,0x1F,0x00,0x00,0xE0,0x03,0x00,0x00,0x60,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0x80,0x1F,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xE0,0x0F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x30,0x00,0x00,0x80,0x3F,0x00,0x00,0xF8,0x0F,0x00,0x80,0xFF,0x00,0x00,0xE0,0x07,0x00,0x00,0x60, // 87
+  0x00,0x00,0x20,0x00,0x20,0x00,0x30,0x00,0x60,0x00,0x3C,0x00,0xE0,0x01,0x1E,0x00,0xC0,0x83,0x07,0x00,0x00,0xCF,0x03,0x00,0x00,0xFE,0x01,0x00,0x00,0x38,0x00,0x00,0x00,0xFE,0x01,0x00,0x00,0xCF,0x03,0x00,0xC0,0x03,0x07,0x00,0xE0,0x01,0x1E,0x00,0x60,0x00,0x3C,0x00,0x20,0x00,0x30,0x00,0x00,0x00,0x20, // 88
+  0x20,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xC0,0x01,0x00,0x00,0x80,0x03,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x3C,0x00,0x00,0x00,0xF0,0x3F,0x00,0x00,0xF0,0x3F,0x00,0x00,0x3C,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x07,0x00,0x00,0xC0,0x03,0x00,0x00,0xE0,0x01,0x00,0x00,0x60,0x00,0x00,0x00,0x20, // 89
+  0x00,0x00,0x30,0x00,0x60,0x00,0x38,0x00,0x60,0x00,0x3C,0x00,0x60,0x00,0x37,0x00,0x60,0x80,0x33,0x00,0x60,0xC0,0x31,0x00,0x60,0xE0,0x30,0x00,0x60,0x38,0x30,0x00,0x60,0x1C,0x30,0x00,0x60,0x0E,0x30,0x00,0x60,0x07,0x30,0x00,0xE0,0x01,0x30,0x00,0xE0,0x00,0x30,0x00,0x60,0x00,0x30, // 90
+  0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,0x60,0x00,0x00,0x06,0x60,0x00,0x00,0x06,  // 91
+  0x60,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0x80,0x3F,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xE0,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 92
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x06,0x60,0x00,0x00,0x06,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,  // 93
+  0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1F,0x00,0x00,0xC0,0x07,0x00,0x00,0xE0,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0xC0,0x07,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x20,  // 94
+  0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,  // 95
+  0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x80, // 96
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0x00,0x8C,0x39,0x00,0x00,0x86,0x31,0x00,0x00,0x86,0x31,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x18,0x00,0x00,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 97
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x18,0x0C,0x00,0x00,0x0C,0x18,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xE0,0x03, // 98
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0x18,0x0C, // 99
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0C,0x18,0x00,0x00,0x18,0x0C,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 100
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0xDC,0x1C,0x00,0x00,0xCE,0x38,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xCE,0x38,0x00,0x00,0xDC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xF0,0x04, // 101
+  0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0xC0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x06,0x00,0x00,0x60,0x06,0x00,0x00,0x60,0x06,  // 102
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x83,0x01,0x00,0xF8,0x8F,0x03,0x00,0x1C,0x1C,0x07,0x00,0x0E,0x38,0x06,0x00,0x06,0x30,0x06,0x00,0x06,0x30,0x06,0x00,0x06,0x30,0x06,0x00,0x0C,0x18,0x07,0x00,0x18,0x8C,0x03,0x00,0xFE,0xFF,0x01,0x00,0xFE,0xFF, // 103
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x18,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0xFC,0x3F,0x00,0x00,0xF8,0x3F, // 104
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0xFE,0x3F,0x00,0x60,0xFE,0x3F, // 105
+  0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x60,0xFE,0xFF,0x07,0x60,0xFE,0xFF,0x03,  // 106
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0xC0,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0xF0,0x01,0x00,0x00,0x98,0x07,0x00,0x00,0x0C,0x0E,0x00,0x00,0x06,0x3C,0x00,0x00,0x02,0x30,0x00,0x00,0x00,0x20, // 107
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 108
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0xFC,0x3F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x0C,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0xFC,0x3F,0x00,0x00,0xF8,0x3F, // 109
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F,0x00,0x00,0x18,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0xFC,0x3F,0x00,0x00,0xF8,0x3F, // 110
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 111
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0xFF,0x07,0x00,0xFE,0xFF,0x07,0x00,0x18,0x0C,0x00,0x00,0x0C,0x18,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xE0,0x03, // 112
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0C,0x18,0x00,0x00,0x18,0x0C,0x00,0x00,0xFE,0xFF,0x07,0x00,0xFE,0xFF,0x07,  // 113
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F,0x00,0x00,0x0C,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x06,  // 114
+  0x00,0x00,0x00,0x00,0x00,0x38,0x0C,0x00,0x00,0x7C,0x1C,0x00,0x00,0xEE,0x38,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x31,0x00,0x00,0xC6,0x31,0x00,0x00,0x8E,0x39,0x00,0x00,0x9C,0x1F,0x00,0x00,0x18,0x0F, // 115
+  0x00,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0xC0,0xFF,0x1F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30, // 116
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0xFE,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x0C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 117
+  0x00,0x06,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0xC0,0x07,0x00,0x00,0x00,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1F,0x00,0x00,0xC0,0x07,0x00,0x00,0xF8,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x06,  // 118
+  0x00,0x0E,0x00,0x00,0x00,0x7E,0x00,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x80,0x1F,0x00,0x00,0xE0,0x03,0x00,0x00,0x7C,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0x80,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x80,0x1F,0x00,0x00,0xF0,0x03,0x00,0x00,0x7E,0x00,0x00,0x00,0x0E,  // 119
+  0x00,0x02,0x20,0x00,0x00,0x06,0x30,0x00,0x00,0x1E,0x3C,0x00,0x00,0x38,0x0E,0x00,0x00,0xF0,0x07,0x00,0x00,0xC0,0x01,0x00,0x00,0xE0,0x07,0x00,0x00,0x38,0x0E,0x00,0x00,0x1C,0x3C,0x00,0x00,0x0E,0x30,0x00,0x00,0x02,0x20, // 120
+  0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x7E,0x00,0x06,0x00,0xF0,0x01,0x06,0x00,0x80,0x0F,0x07,0x00,0x00,0xFE,0x03,0x00,0x00,0xFC,0x00,0x00,0xC0,0x1F,0x00,0x00,0xF8,0x03,0x00,0x00,0x3E,0x00,0x00,0x00,0x06,  // 121
+  0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x06,0x3C,0x00,0x00,0x06,0x3E,0x00,0x00,0x06,0x37,0x00,0x00,0xC6,0x33,0x00,0x00,0xE6,0x30,0x00,0x00,0x76,0x30,0x00,0x00,0x3E,0x30,0x00,0x00,0x1E,0x30,0x00,0x00,0x06,0x30, // 122
+  0x00,0x00,0x00,0x00,0x00,0x80,0x01,0x00,0x00,0xC0,0x03,0x00,0xC0,0x7F,0xFE,0x03,0xE0,0x3F,0xFC,0x07,0x60,0x00,0x00,0x06,0x60,0x00,0x00,0x06,  // 123
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x0F,0xE0,0xFF,0xFF,0x0F,  // 124
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x06,0x60,0x00,0x00,0x06,0xE0,0x3F,0xFC,0x07,0xC0,0x7F,0xFF,0x03,0x00,0xC0,0x03,0x00,0x00,0x80,0x01, // 125
+  0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x60,  // 126
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE6,0xFF,0x07,0x00,0xE6,0xFF,0x07,  // 161
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x9C,0x07,0x00,0x0E,0x78,0x00,0x00,0x06,0x3F,0x00,0x00,0xF6,0x30,0x00,0x00,0x0E,0x30,0x00,0xE0,0x0D,0x1C,0x00,0x00,0x1C,0x0E,0x00,0x00,0x10,0x06, // 162
+  0x00,0x60,0x10,0x00,0x00,0x60,0x38,0x00,0x00,0x7F,0x1C,0x00,0xC0,0xFF,0x1F,0x00,0xE0,0xE0,0x19,0x00,0x60,0x60,0x18,0x00,0x60,0x60,0x18,0x00,0x60,0x60,0x30,0x00,0xE0,0x00,0x30,0x00,0xC0,0x01,0x30,0x00,0x80,0x01,0x38,0x00,0x00,0x00,0x10, // 163
+  0x00,0x00,0x00,0x00,0x00,0x02,0x04,0x00,0x00,0xF7,0x0E,0x00,0x00,0xFE,0x07,0x00,0x00,0x0C,0x03,0x00,0x00,0x06,0x06,0x00,0x00,0x06,0x06,0x00,0x00,0x06,0x06,0x00,0x00,0x06,0x06,0x00,0x00,0x0C,0x03,0x00,0x00,0xFE,0x07,0x00,0x00,0xF7,0x0E,0x00,0x00,0x02,0x04, // 164
+  0xE0,0x60,0x06,0x00,0xC0,0x61,0x06,0x00,0x80,0x67,0x06,0x00,0x00,0x7E,0x06,0x00,0x00,0x7C,0x06,0x00,0x00,0xF0,0x3F,0x00,0x00,0xF0,0x3F,0x00,0x00,0x7C,0x06,0x00,0x00,0x7E,0x06,0x00,0x80,0x67,0x06,0x00,0xC0,0x61,0x06,0x00,0xE0,0x60,0x06,0x00,0x20, // 165
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x7F,0xF8,0x0F,0xE0,0x7F,0xF8,0x0F,  // 166
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0x80,0xF3,0xC1,0x00,0xC0,0x1F,0xC3,0x03,0xE0,0x0C,0x07,0x03,0x60,0x1C,0x06,0x06,0x60,0x18,0x0C,0x06,0x60,0x30,0x1C,0x06,0xE0,0x70,0x38,0x07,0xC0,0xE1,0xF4,0x03,0x80,0xC1,0xE7,0x01,0x00,0x80,0x03, // 167
+  0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60, // 168
+  0x00,0xF8,0x00,0x00,0x00,0xFE,0x03,0x00,0x00,0x07,0x07,0x00,0x80,0x01,0x0C,0x00,0xC0,0x79,0x1C,0x00,0xC0,0xFE,0x19,0x00,0x60,0x86,0x31,0x00,0x60,0x03,0x33,0x00,0x60,0x03,0x33,0x00,0x60,0x03,0x33,0x00,0x60,0x03,0x33,0x00,0x60,0x87,0x33,0x00,0xC0,0x86,0x19,0x00,0xC0,0x85,0x1C,0x00,0x80,0x01,0x0C,0x00,0x00,0x07,0x07,0x00,0x00,0xFE,0x03,0x00,0x00,0xF8,  // 169
+  0x00,0x00,0x00,0x00,0xC0,0x1C,0x00,0x00,0xE0,0x3E,0x00,0x00,0x60,0x32,0x00,0x00,0x60,0x32,0x00,0x00,0xE0,0x3F,0x00,0x00,0xC0,0x3F,  // 170
+  0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0xE0,0x03,0x00,0x00,0x78,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x84,0x10,0x00,0x00,0xE0,0x03,0x00,0x00,0x78,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x04,0x10, // 171
+  0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFC,0x01, // 172
+  0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01, // 173
+  0x00,0xF8,0x00,0x00,0x00,0xFE,0x03,0x00,0x00,0x07,0x07,0x00,0x80,0x01,0x0C,0x00,0xC0,0x01,0x1C,0x00,0xC0,0xFE,0x1B,0x00,0x60,0xFE,0x33,0x00,0x60,0x66,0x30,0x00,0x60,0x66,0x30,0x00,0x60,0xE6,0x30,0x00,0x60,0xFE,0x31,0x00,0x60,0x3C,0x33,0x00,0xC0,0x00,0x1A,0x00,0xC0,0x01,0x1C,0x00,0x80,0x01,0x0C,0x00,0x00,0x07,0x07,0x00,0x00,0xFE,0x03,0x00,0x00,0xF8,  // 174
+  0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x0C, // 175
+  0x00,0x00,0x00,0x00,0x80,0x03,0x00,0x00,0x40,0x04,0x00,0x00,0x20,0x08,0x00,0x00,0x20,0x08,0x00,0x00,0x20,0x08,0x00,0x00,0x40,0x04,0x00,0x00,0x80,0x03,  // 176
+  0x00,0x00,0x00,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0xFF,0x3F,0x00,0x00,0xFF,0x3F,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30,0x00,0x00,0x60,0x30, // 177
+  0x40,0x20,0x00,0x00,0x60,0x30,0x00,0x00,0x20,0x38,0x00,0x00,0x20,0x2C,0x00,0x00,0x20,0x26,0x00,0x00,0xE0,0x23,0x00,0x00,0xC0,0x21,  // 178
+  0x40,0x10,0x00,0x00,0x60,0x30,0x00,0x00,0x20,0x20,0x00,0x00,0x20,0x22,0x00,0x00,0x20,0x22,0x00,0x00,0xE0,0x3D,0x00,0x00,0xC0,0x1D,  // 179
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x20, // 180
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0xFF,0x07,0x00,0xFE,0xFF,0x07,0x00,0x00,0x1C,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x1C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 181
+  0x00,0x0F,0x00,0x00,0xC0,0x3F,0x00,0x00,0xC0,0x3F,0x00,0x00,0xE0,0x7F,0x00,0x00,0xE0,0x7F,0x00,0x00,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,0x60,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,0x60,0x00,0x00,0x00,0x60, // 182
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x60,  // 183
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0xC0,0x02,0x00,0x00,0x80,0x03,0x00,0x00,0x00,0x01,  // 184
+  0x00,0x00,0x00,0x00,0x80,0x01,0x00,0x00,0xC0,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0xE0,0x3F,0x00,0x00,0xE0,0x3F,  // 185
+  0x00,0x00,0x00,0x00,0x80,0x0F,0x00,0x00,0xC0,0x1F,0x00,0x00,0xE0,0x38,0x00,0x00,0x60,0x30,0x00,0x00,0xE0,0x38,0x00,0x00,0xC0,0x1F,0x00,0x00,0x80,0x0F,  // 186
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x10,0x00,0x00,0x1C,0x1C,0x00,0x00,0x78,0x0F,0x00,0x00,0xE0,0x03,0x00,0x00,0x84,0x10,0x00,0x00,0x1C,0x1C,0x00,0x00,0x78,0x0F,0x00,0x00,0xE0,0x03,0x00,0x00,0x80,  // 187
+  0x00,0x00,0x00,0x00,0x80,0x01,0x00,0x00,0xC0,0x00,0x00,0x00,0xC0,0x00,0x20,0x00,0xE0,0x3F,0x38,0x00,0xE0,0x3F,0x1C,0x00,0x00,0x00,0x0E,0x00,0x00,0x80,0x03,0x00,0x00,0xC0,0x01,0x00,0x00,0xE0,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x07,0x0C,0x00,0xC0,0x01,0x0E,0x00,0xE0,0x80,0x0B,0x00,0x60,0xC0,0x08,0x00,0x00,0xE0,0x3F,0x00,0x00,0xE0,0x3F,0x00,0x00,0x00,0x08, // 188
+  0x00,0x00,0x00,0x00,0x80,0x01,0x00,0x00,0xC0,0x00,0x00,0x00,0xC0,0x00,0x20,0x00,0xE0,0x3F,0x30,0x00,0xE0,0x3F,0x1C,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x07,0x00,0x00,0xC0,0x01,0x00,0x00,0xE0,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x4E,0x20,0x00,0x00,0x67,0x30,0x00,0xC0,0x21,0x38,0x00,0xE0,0x20,0x2C,0x00,0x60,0x20,0x26,0x00,0x00,0xE0,0x27,0x00,0x00,0xC0,0x21, // 189
+  0x40,0x10,0x00,0x00,0x60,0x30,0x00,0x00,0x20,0x20,0x00,0x00,0x20,0x22,0x20,0x00,0x20,0x22,0x30,0x00,0xE0,0x3D,0x38,0x00,0xC0,0x1D,0x0E,0x00,0x00,0x00,0x07,0x00,0x00,0x80,0x03,0x00,0x00,0xE0,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x0E,0x0C,0x00,0x00,0x07,0x0E,0x00,0x80,0x83,0x0B,0x00,0xE0,0xC0,0x08,0x00,0x60,0xE0,0x3F,0x00,0x20,0xE0,0x3F,0x00,0x00,0x00,0x08, // 190
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0xF8,0x03,0x00,0x00,0x1E,0x03,0x00,0x00,0x07,0x07,0x00,0xE6,0x03,0x06,0x00,0xE6,0x01,0x06,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x07,0x00,0x00,0x80,0x03,0x00,0x00,0xC0,0x01,0x00,0x00,0xC0, // 191
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x82,0x8F,0x01,0x00,0xE6,0x83,0x01,0x00,0x6E,0x80,0x01,0x00,0xE8,0x83,0x01,0x00,0x80,0x8F,0x01,0x00,0x00,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 192
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x80,0x8F,0x01,0x00,0xE8,0x83,0x01,0x00,0x6E,0x80,0x01,0x00,0xE6,0x83,0x01,0x00,0x82,0x8F,0x01,0x00,0x00,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 193
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x88,0x8F,0x01,0x00,0xEC,0x83,0x01,0x00,0x66,0x80,0x01,0x00,0xE6,0x83,0x01,0x00,0x8C,0x8F,0x01,0x00,0x08,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 194
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x0C,0xFE,0x01,0x00,0x8E,0x8F,0x01,0x00,0xE6,0x83,0x01,0x00,0x66,0x80,0x01,0x00,0xEC,0x83,0x01,0x00,0x8C,0x8F,0x01,0x00,0x0E,0xFE,0x01,0x00,0x06,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 195
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x8C,0x8F,0x01,0x00,0xEC,0x83,0x01,0x00,0x60,0x80,0x01,0x00,0xE0,0x83,0x01,0x00,0x8C,0x8F,0x01,0x00,0x0C,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 196
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3E,0x00,0x00,0x80,0x0F,0x00,0x00,0xF0,0x03,0x00,0x00,0xFE,0x01,0x00,0x9C,0x8F,0x01,0x00,0xE2,0x83,0x01,0x00,0x62,0x80,0x01,0x00,0xE2,0x83,0x01,0x00,0x9C,0x8F,0x01,0x00,0x00,0xFE,0x01,0x00,0x00,0xF0,0x03,0x00,0x00,0x80,0x0F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x30, // 197
+  0x00,0x00,0x30,0x00,0x00,0x00,0x3C,0x00,0x00,0x00,0x0F,0x00,0x00,0xC0,0x03,0x00,0x00,0xF0,0x01,0x00,0x00,0xBC,0x01,0x00,0x00,0x8F,0x01,0x00,0xC0,0x83,0x01,0x00,0xE0,0x80,0x01,0x00,0x60,0x80,0x01,0x00,0x60,0x80,0x01,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 198
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0x60,0x00,0x30,0x02,0x60,0x00,0x30,0x02,0x60,0x00,0xF0,0x02,0x60,0x00,0xB0,0x03,0x60,0x00,0x30,0x01,0x60,0x00,0x30,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x03,0x0F,0x00,0x00,0x02,0x03, // 199
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x62,0x30,0x30,0x00,0x66,0x30,0x30,0x00,0x6E,0x30,0x30,0x00,0x68,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 200
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x68,0x30,0x30,0x00,0x6E,0x30,0x30,0x00,0x66,0x30,0x30,0x00,0x62,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 201
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x68,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x66,0x30,0x30,0x00,0x66,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x68,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 202
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x6C,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30, // 203
+  0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0xE6,0xFF,0x3F,0x00,0xEE,0xFF,0x3F,0x00,0x08, // 204
+  0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0xEE,0xFF,0x3F,0x00,0xE6,0xFF,0x3F,0x00,0x02, // 205
+  0x08,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0xE6,0xFF,0x3F,0x00,0xE6,0xFF,0x3F,0x00,0x0C,0x00,0x00,0x00,0x08, // 206
+  0x0C,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x0C,0x00,0x00,0x00,0x0C, // 207
+  0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x30,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x03,0x0E,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 208
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0xC0,0x01,0x00,0x00,0x8C,0x03,0x00,0x00,0x0E,0x0E,0x00,0x00,0x06,0x3C,0x00,0x00,0x06,0x70,0x00,0x00,0x0C,0xE0,0x01,0x00,0x0C,0x80,0x03,0x00,0x0E,0x00,0x0F,0x00,0x06,0x00,0x1C,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F, // 209
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x38,0x00,0x62,0x00,0x30,0x00,0x66,0x00,0x30,0x00,0x6E,0x00,0x30,0x00,0x68,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 210
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x38,0x00,0x60,0x00,0x30,0x00,0x68,0x00,0x30,0x00,0x6E,0x00,0x30,0x00,0x66,0x00,0x30,0x00,0x62,0x00,0x30,0x00,0xE0,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 211
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x38,0x00,0x68,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0x66,0x00,0x30,0x00,0x66,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0xE8,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 212
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xCC,0x00,0x18,0x00,0xEE,0x00,0x38,0x00,0x66,0x00,0x30,0x00,0x66,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0x6E,0x00,0x30,0x00,0xE6,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 213
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x00,0x00,0xFF,0x07,0x00,0x80,0x07,0x0F,0x00,0xC0,0x01,0x1C,0x00,0xC0,0x00,0x18,0x00,0xE0,0x00,0x38,0x00,0x6C,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x6C,0x00,0x30,0x00,0xEC,0x00,0x38,0x00,0xC0,0x00,0x18,0x00,0xC0,0x01,0x1C,0x00,0x80,0x07,0x0F,0x00,0x00,0xFF,0x07,0x00,0x00,0xFC,0x01, // 214
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x03,0x00,0x00,0x8E,0x03,0x00,0x00,0xDC,0x01,0x00,0x00,0xF8,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0xDC,0x01,0x00,0x00,0x8E,0x03,0x00,0x00,0x06,0x03, // 215
+  0x00,0x00,0x00,0x00,0x00,0xFC,0x21,0x00,0x00,0xFF,0x77,0x00,0x80,0x07,0x3F,0x00,0xC0,0x01,0x1E,0x00,0xC0,0x00,0x1F,0x00,0xE0,0x80,0x3B,0x00,0x60,0xC0,0x31,0x00,0x60,0xE0,0x30,0x00,0x60,0x70,0x30,0x00,0x60,0x38,0x30,0x00,0x60,0x1C,0x30,0x00,0xE0,0x0E,0x38,0x00,0xC0,0x07,0x18,0x00,0xC0,0x03,0x1C,0x00,0xE0,0x07,0x0F,0x00,0x70,0xFF,0x07,0x00,0x20,0xFC,0x01, // 216
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x03,0x00,0xE0,0xFF,0x0F,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x38,0x00,0x02,0x00,0x30,0x00,0x06,0x00,0x30,0x00,0x0E,0x00,0x30,0x00,0x08,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x0F,0x00,0xE0,0xFF,0x03, // 217
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x03,0x00,0xE0,0xFF,0x0F,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x30,0x00,0x08,0x00,0x30,0x00,0x0E,0x00,0x30,0x00,0x06,0x00,0x30,0x00,0x02,0x00,0x30,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x0F,0x00,0xE0,0xFF,0x03, // 218
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x03,0x00,0xE0,0xFF,0x0F,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x38,0x00,0x08,0x00,0x30,0x00,0x0C,0x00,0x30,0x00,0x06,0x00,0x30,0x00,0x06,0x00,0x30,0x00,0x0C,0x00,0x30,0x00,0x08,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x0F,0x00,0xE0,0xFF,0x03, // 219
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x03,0x00,0xE0,0xFF,0x0F,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x38,0x00,0x0C,0x00,0x30,0x00,0x0C,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x0C,0x00,0x30,0x00,0x0C,0x00,0x38,0x00,0x00,0x00,0x1C,0x00,0xE0,0xFF,0x0F,0x00,0xE0,0xFF,0x03, // 220
+  0x20,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xC0,0x01,0x00,0x00,0x80,0x03,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x3C,0x00,0x00,0x08,0xF0,0x3F,0x00,0x0E,0xF0,0x3F,0x00,0x06,0x3C,0x00,0x00,0x02,0x1E,0x00,0x00,0x00,0x07,0x00,0x00,0xC0,0x03,0x00,0x00,0xE0,0x01,0x00,0x00,0x60,0x00,0x00,0x00,0x20, // 221
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0x3F,0x00,0xE0,0xFF,0x3F,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x06,0x00,0x00,0x03,0x07,0x00,0x00,0x86,0x03,0x00,0x00,0xFE,0x01,0x00,0x00,0xF8,  // 222
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x3F,0x00,0xC0,0xFF,0x3F,0x00,0xC0,0x00,0x00,0x00,0x60,0x00,0x08,0x00,0x60,0x00,0x1C,0x00,0x60,0x00,0x38,0x00,0xE0,0x78,0x30,0x00,0xC0,0x7F,0x30,0x00,0x80,0xC7,0x30,0x00,0x00,0x80,0x39,0x00,0x00,0x80,0x1F,0x00,0x00,0x00,0x0F, // 223
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0x00,0x8C,0x39,0x00,0x20,0x86,0x31,0x00,0x60,0x86,0x31,0x00,0xE0,0xC6,0x30,0x00,0x80,0xC6,0x18,0x00,0x00,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 224
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0x00,0x8C,0x39,0x00,0x00,0x86,0x31,0x00,0x80,0x86,0x31,0x00,0xE0,0xC6,0x30,0x00,0x60,0xC6,0x18,0x00,0x20,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 225
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0x80,0x8C,0x39,0x00,0xC0,0x86,0x31,0x00,0x60,0x86,0x31,0x00,0x60,0xC6,0x30,0x00,0xC0,0xC6,0x18,0x00,0x80,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 226
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0xC0,0x1C,0x1F,0x00,0xE0,0x8C,0x39,0x00,0x60,0x86,0x31,0x00,0x60,0x86,0x31,0x00,0xC0,0xC6,0x30,0x00,0xC0,0xC6,0x18,0x00,0xE0,0xCE,0x0C,0x00,0x60,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 227
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0xC0,0x8C,0x39,0x00,0xC0,0x86,0x31,0x00,0x00,0x86,0x31,0x00,0x00,0xC6,0x30,0x00,0xC0,0xC6,0x18,0x00,0xC0,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 228
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0E,0x00,0x00,0x1C,0x1F,0x00,0x00,0x8C,0x39,0x00,0x70,0x86,0x31,0x00,0x88,0x86,0x31,0x00,0x88,0xC6,0x30,0x00,0x88,0xC6,0x18,0x00,0x70,0xCE,0x0C,0x00,0x00,0xFC,0x1F,0x00,0x00,0xF8,0x3F,0x00,0x00,0x00,0x20, // 229
+  0x00,0x00,0x00,0x00,0x00,0x10,0x0F,0x00,0x00,0x9C,0x1F,0x00,0x00,0xCC,0x39,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0x66,0x18,0x00,0x00,0x6E,0x1C,0x00,0x00,0xFC,0x0F,0x00,0x00,0xFC,0x1F,0x00,0x00,0xCC,0x1C,0x00,0x00,0xCE,0x38,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xCC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xE0,0x04, // 230
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x02,0x00,0x06,0x30,0x02,0x00,0x06,0xF0,0x02,0x00,0x06,0xB0,0x03,0x00,0x0E,0x38,0x01,0x00,0x1C,0x1C,0x00,0x00,0x18,0x0C, // 231
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0xDC,0x1C,0x00,0x20,0xCE,0x38,0x00,0x60,0xC6,0x30,0x00,0xE0,0xC6,0x30,0x00,0x80,0xC6,0x30,0x00,0x00,0xCE,0x38,0x00,0x00,0xDC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xF0,0x04, // 232
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0xDC,0x1C,0x00,0x00,0xCE,0x38,0x00,0x80,0xC6,0x30,0x00,0xE0,0xC6,0x30,0x00,0x60,0xC6,0x30,0x00,0x20,0xCE,0x38,0x00,0x00,0xDC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xF0,0x04, // 233
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0xDC,0x1C,0x00,0x80,0xCE,0x38,0x00,0xC0,0xC6,0x30,0x00,0x60,0xC6,0x30,0x00,0x60,0xC6,0x30,0x00,0xC0,0xCE,0x38,0x00,0x80,0xDC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xF0,0x04, // 234
+  0x00,0x00,0x00,0x00,0x00,0xE0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0xDC,0x1C,0x00,0xC0,0xCE,0x38,0x00,0xC0,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0x00,0xC6,0x30,0x00,0xC0,0xCE,0x38,0x00,0xC0,0xDC,0x18,0x00,0x00,0xF8,0x0C,0x00,0x00,0xF0,0x04, // 235
+  0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x60,0xFE,0x3F,0x00,0xE0,0xFE,0x3F,0x00,0x80, // 236
+  0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0xE0,0xFE,0x3F,0x00,0x60,0xFE,0x3F,0x00,0x20, // 237
+  0x80,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x60,0xFE,0x3F,0x00,0x60,0xFE,0x3F,0x00,0xC0,0x00,0x00,0x00,0x80, // 238
+  0xC0,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F,0x00,0xC0,0x00,0x00,0x00,0xC0, // 239
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1D,0x1C,0x00,0xA0,0x0F,0x38,0x00,0xA0,0x06,0x30,0x00,0xE0,0x06,0x30,0x00,0xC0,0x06,0x30,0x00,0xC0,0x0F,0x38,0x00,0x20,0x1F,0x1C,0x00,0x00,0xFC,0x0F,0x00,0x00,0xE0,0x07, // 240
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0xC0,0xFE,0x3F,0x00,0xE0,0x18,0x00,0x00,0x60,0x0C,0x00,0x00,0x60,0x06,0x00,0x00,0xC0,0x06,0x00,0x00,0xC0,0x06,0x00,0x00,0xE0,0x0E,0x00,0x00,0x60,0xFC,0x3F,0x00,0x00,0xF8,0x3F, // 241
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x20,0x0E,0x38,0x00,0x60,0x06,0x30,0x00,0xE0,0x06,0x30,0x00,0x80,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 242
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x38,0x00,0x80,0x06,0x30,0x00,0xE0,0x06,0x30,0x00,0x60,0x06,0x30,0x00,0x20,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 243
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0x80,0x0E,0x38,0x00,0xC0,0x06,0x30,0x00,0x60,0x06,0x30,0x00,0x60,0x06,0x30,0x00,0xC0,0x0E,0x38,0x00,0x80,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 244
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0xC0,0x1C,0x1C,0x00,0xE0,0x0E,0x38,0x00,0x60,0x06,0x30,0x00,0x60,0x06,0x30,0x00,0xC0,0x06,0x30,0x00,0xC0,0x0E,0x38,0x00,0xE0,0x1C,0x1C,0x00,0x60,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 245
+  0x00,0x00,0x00,0x00,0x00,0xF0,0x07,0x00,0x00,0xF8,0x0F,0x00,0x00,0x1C,0x1C,0x00,0xC0,0x0E,0x38,0x00,0xC0,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0xC0,0x0E,0x38,0x00,0xC0,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x07, // 246
+  0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0xB6,0x01,0x00,0x00,0xB6,0x01,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,  // 247
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x67,0x00,0x00,0xF8,0x7F,0x00,0x00,0x1C,0x1C,0x00,0x00,0x0E,0x3F,0x00,0x00,0x86,0x33,0x00,0x00,0xE6,0x31,0x00,0x00,0x76,0x30,0x00,0x00,0x3E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xFF,0x0F,0x00,0x00,0xF3,0x07, // 248
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0xFE,0x1F,0x00,0x20,0x00,0x38,0x00,0x60,0x00,0x30,0x00,0xE0,0x00,0x30,0x00,0x80,0x00,0x30,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x0C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 249
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0xFE,0x1F,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x30,0x00,0x80,0x00,0x30,0x00,0xE0,0x00,0x30,0x00,0x60,0x00,0x18,0x00,0x20,0x00,0x0C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 250
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0xFE,0x1F,0x00,0x80,0x00,0x38,0x00,0xC0,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0x60,0x00,0x30,0x00,0xC0,0x00,0x18,0x00,0x80,0x00,0x0C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 251
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0xFE,0x1F,0x00,0xC0,0x00,0x38,0x00,0xC0,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x30,0x00,0xC0,0x00,0x18,0x00,0xC0,0x00,0x0C,0x00,0x00,0xFE,0x3F,0x00,0x00,0xFE,0x3F, // 252
+  0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x7E,0x00,0x06,0x00,0xF0,0x01,0x06,0x00,0x80,0x0F,0x07,0x80,0x00,0xFE,0x03,0xE0,0x00,0xFC,0x00,0x60,0xC0,0x1F,0x00,0x20,0xF8,0x03,0x00,0x00,0x3E,0x00,0x00,0x00,0x06,  // 253
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x07,0xE0,0xFF,0xFF,0x07,0x00,0x1C,0x18,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x06,0x30,0x00,0x00,0x0E,0x38,0x00,0x00,0x1C,0x1C,0x00,0x00,0xF8,0x0F,0x00,0x00,0xF0,0x03, // 254
+  0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x7E,0x00,0x06,0xC0,0xF0,0x01,0x06,0xC0,0x80,0x0F,0x07,0x00,0x00,0xFE,0x03,0x00,0x00,0xFC,0x00,0xC0,0xC0,0x1F,0x00,0xC0,0xF8,0x03,0x00,0x00,0x3E,0x00,0x00,0x00,0x06 // 255
+};

src/helpers/ui/OLEDDisplayFonts.h

@@ -0,0 +1,13 @@
+#ifndef OLEDDISPLAYFONTS_h
+#define OLEDDISPLAYFONTS_h
+
+#ifdef ARDUINO
+#include <Arduino.h>
+#elif __MBED__
+#define PROGMEM
+#endif
+
+extern const uint8_t ArialMT_Plain_10[] PROGMEM;
+extern const uint8_t ArialMT_Plain_16[] PROGMEM;
+extern const uint8_t ArialMT_Plain_24[] PROGMEM;
+#endif

src/helpers/ui/ST7789Display.cpp

@@ -2,14 +2,9 @@
 
 #include "ST7789Display.h"
 
-bool ST7789Display::i2c_probe(TwoWire& wire, uint8_t addr) {
-  return true;
-/*
-  wire.beginTransmission(addr);
-  uint8_t error = wire.endTransmission();
-  return (error == 0);
-*/
-}
+#ifndef X_OFFSET
+#define X_OFFSET 16
+#endif
 
 bool ST7789Display::begin() {
   if(!_isOn) {
@@ -19,14 +14,11 @@ bool ST7789Display::begin() {
     digitalWrite(PIN_TFT_LEDA_CTL, LOW);
     digitalWrite(PIN_TFT_RST, HIGH);
 
-    display.init(135, 240);
-    display.setRotation(2);
-    display.setSPISpeed(40000000);
-    display.fillScreen(ST77XX_BLACK);
-    display.setTextColor(ST77XX_WHITE);
-    display.setTextSize(2);
-    display.cp437(true);         // Use full 256 char 'Code Page 437' font
-  
+    display.init();
+    display.landscapeScreen();
+    display.displayOn();
+    setCursor(0,0);
+
     _isOn = true;
   }
   return true;
@@ -40,24 +32,28 @@ void ST7789Display::turnOff() {
   digitalWrite(PIN_TFT_VDD_CTL, HIGH);
   digitalWrite(PIN_TFT_LEDA_CTL, HIGH);
   digitalWrite(PIN_TFT_RST, LOW);
-  // digitalWrite(PIN_TFT_VDD_CTL, LOW);
-  // digitalWrite(PIN_TFT_LEDA_CTL, LOW);
   _isOn = false;
 }
 
 void ST7789Display::clear() {
-  display.fillScreen(ST77XX_BLACK);
+  display.clear();
 }
 
 void ST7789Display::startFrame(Color bkg) {
-  display.fillScreen(0x00);
-  display.setTextColor(ST77XX_WHITE);
-  display.setTextSize(2);
-  display.cp437(true);         // Use full 256 char 'Code Page 437' font
+  display.clear();
 }
 
 void ST7789Display::setTextSize(int sz) {
-  display.setTextSize(sz);
+  switch(sz) {
+    case 1 :
+      display.setFont(ArialMT_Plain_10);
+      break;
+    case 2 :
+      display.setFont(ArialMT_Plain_24);
+      break;
+    default:
+      display.setFont(ArialMT_Plain_10);
+  }
 }
 
 void ST7789Display::setColor(Color c) {
@@ -87,31 +83,32 @@ void ST7789Display::setColor(Color c) {
       _color = ST77XX_WHITE;
       break;
   }
-  display.setTextColor(_color);
+  display.setRGB(_color);
 }
 
 void ST7789Display::setCursor(int x, int y) {
-  display.setCursor(x, y);
+  _x = x + X_OFFSET;
+  _y = y;
 }
 
 void ST7789Display::print(const char* str) {
-  display.print(str);
+  display.drawString(_x, _y, str);
 }
 
 void ST7789Display::fillRect(int x, int y, int w, int h) {
-  display.fillRect(x, y, w, h, _color);
+  display.fillRect(x + X_OFFSET, y, w, h);
 }
 
 void ST7789Display::drawRect(int x, int y, int w, int h) {
-  display.drawRect(x, y, w, h, _color);
+  display.drawRect(x + X_OFFSET, y, w, h);
 }
 
 void ST7789Display::drawXbm(int x, int y, const uint8_t* bits, int w, int h) {
-  display.drawBitmap(x, y, bits, w, h, _color);
+  display.drawBitmap(x+X_OFFSET, y, w, h, bits);
 }
 
 void ST7789Display::endFrame() {
-  // display.display();
+  display.display();
 }
 
 #endif

src/helpers/ui/ST7789Display.h

@@ -4,16 +4,18 @@
 #include <Wire.h>
 #include <SPI.h>
 #include <Adafruit_GFX.h>
-#include <Adafruit_ST7789.h>
+#include <ST7789Spi.h>
 
 class ST7789Display : public DisplayDriver {
-  Adafruit_ST7789 display;
+  ST7789Spi display;
   bool _isOn;
   uint16_t _color;
+  int _x=0, _y=0;
 
   bool i2c_probe(TwoWire& wire, uint8_t addr);
 public:
-  ST7789Display() : DisplayDriver(135, 240), display(&SPI1, PIN_TFT_CS, PIN_TFT_DC, PIN_TFT_RST) { _isOn = false; }
+  ST7789Display() : DisplayDriver(135, 240), display(&SPI1, PIN_TFT_RST, PIN_TFT_DC, PIN_TFT_CS, GEOMETRY_RAWMODE, 240, 135) {_isOn = false;}
+
 //  ST7789Display() : DisplayDriver(135, 240), display(PIN_TFT_CS, PIN_TFT_DC, PIN_TFT_SDA, PIN_TFT_SCL, PIN_TFT_RST) { _isOn = false; }
   bool begin();
 

src/helpers/ui/ST7789Spi.h

@@ -0,0 +1,461 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 by ThingPulse, Daniel Eichhorn
+ * Copyright (c) 2018 by Fabrice Weinberg
+ * Copyright (c) 2024 by Heltec AutoMation
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ThingPulse invests considerable time and money to develop these open source libraries.
+ * Please support us by buying our products (and not the clones) from
+ * https://thingpulse.com
+ *
+ */
+
+#ifndef ST7789Spi_h
+#define ST7789Spi_h
+
+#include "OLEDDisplay.h"
+#include <SPI.h>
+
+
+#define ST_CMD_DELAY 0x80 // special signifier for command lists
+
+#define ST77XX_NOP 0x00
+#define ST77XX_SWRESET 0x01
+#define ST77XX_RDDID 0x04
+#define ST77XX_RDDST 0x09
+
+#define ST77XX_SLPIN 0x10
+#define ST77XX_SLPOUT 0x11
+#define ST77XX_PTLON 0x12
+#define ST77XX_NORON 0x13
+
+#define ST77XX_INVOFF 0x20
+#define ST77XX_INVON 0x21
+#define ST77XX_DISPOFF 0x28
+#define ST77XX_DISPON 0x29
+#define ST77XX_CASET 0x2A
+#define ST77XX_RASET 0x2B
+#define ST77XX_RAMWR 0x2C
+#define ST77XX_RAMRD 0x2E
+
+#define ST77XX_PTLAR 0x30
+#define ST77XX_TEOFF 0x34
+#define ST77XX_TEON 0x35
+#define ST77XX_MADCTL 0x36
+#define ST77XX_COLMOD 0x3A
+
+#define ST77XX_MADCTL_MY 0x80
+#define ST77XX_MADCTL_MX 0x40
+#define ST77XX_MADCTL_MV 0x20
+#define ST77XX_MADCTL_ML 0x10
+#define ST77XX_MADCTL_RGB 0x00
+
+#define ST77XX_RDID1 0xDA
+#define ST77XX_RDID2 0xDB
+#define ST77XX_RDID3 0xDC
+#define ST77XX_RDID4 0xDD
+
+// Some ready-made 16-bit ('565') color settings:
+#define ST77XX_BLACK 0x0000
+#define ST77XX_WHITE 0xFFFF
+#define ST77XX_RED 0xF800
+#define ST77XX_GREEN 0x07E0
+#define ST77XX_BLUE 0x001F
+#define ST77XX_CYAN 0x07FF
+#define ST77XX_MAGENTA 0xF81F
+#define ST77XX_YELLOW 0xFFE0
+#define ST77XX_ORANGE 0xFC00
+
+#define LED_A_ON LOW
+
+#ifdef ESP_PLATFORM
+#undef LED_A_ON
+#define LED_A_ON HIGH
+#define rtos_free free
+#define rtos_malloc malloc
+//SPIClass SPI1(HSPI);
+#endif
+class ST7789Spi : public OLEDDisplay {
+  private:
+      uint8_t             _rst;
+      uint8_t             _dc;
+      uint8_t             _cs;
+      uint8_t             _ledA;
+      int             _miso;
+      int             _mosi;
+      int             _clk;
+      SPIClass * _spi;
+      SPISettings 		    _spiSettings;
+      uint16_t            _RGB=0xFFFF;
+      uint8_t             _buffheight;
+  public:
+    /* pass _cs as -1 to indicate "do not use CS pin", for cases where it is hard wired low */
+    ST7789Spi(SPIClass *spiClass,uint8_t _rst, uint8_t _dc, uint8_t _cs, OLEDDISPLAY_GEOMETRY g = GEOMETRY_RAWMODE,uint16_t width=240,uint16_t height=135,int mosi=-1,int miso=-1,int clk=-1) {
+      this->_spi = spiClass;
+      this->_rst = _rst;
+      this->_dc  = _dc;
+      this->_cs  = _cs;
+      this->_mosi=mosi;
+      this->_miso=miso;
+      this->_clk=clk;
+      //this->_ledA  = _ledA;
+      _spiSettings = SPISettings(40000000, MSBFIRST, SPI_MODE0);
+      setGeometry(g,width,height);
+    }
+
+    bool connect(){
+      this->_buffheight=displayHeight / 8;
+      this->_buffheight+=displayHeight % 8 ? 1:0;
+      pinMode(_cs, OUTPUT);
+      pinMode(_dc, OUTPUT);
+      //pinMode(_ledA, OUTPUT);
+      if (_cs != (uint8_t) -1) {
+        pinMode(_cs, OUTPUT);
+      }  
+      pinMode(_rst, OUTPUT);
+
+#ifdef ESP_PLATFORM
+      _spi->begin(_clk,_miso,_mosi,-1);
+#else
+      _spi->begin();
+#endif
+      _spi->setClockDivider (SPI_CLOCK_DIV2);
+
+      // Pulse Reset low for 10ms
+      digitalWrite(_rst, HIGH);
+      delay(1);
+      digitalWrite(_rst, LOW);
+      delay(10);
+      digitalWrite(_rst, HIGH);
+      _spi->begin ();
+      //digitalWrite(_ledA, LED_A_ON);
+      return true;
+    }
+
+    void display(void) {
+    #ifdef OLEDDISPLAY_DOUBLE_BUFFER
+
+       uint16_t minBoundY = UINT16_MAX;
+       uint16_t maxBoundY = 0;
+
+       uint16_t minBoundX = UINT16_MAX;
+       uint16_t maxBoundX = 0;
+
+       uint16_t x, y;
+        
+       // Calculate the Y bounding box of changes
+       // and copy buffer[pos] to buffer_back[pos];
+       for (y = 0; y < _buffheight; y++) {
+         for (x = 0; x < displayWidth; x++) {
+          //Serial.printf("x  %d y %d\r\n",x,y);
+          uint16_t pos = x + y * displayWidth;
+          if (buffer[pos] != buffer_back[pos]) {
+            minBoundY = min(minBoundY, y);
+            maxBoundY = max(maxBoundY, y);
+            minBoundX = min(minBoundX, x);
+            maxBoundX = max(maxBoundX, x);
+          }
+          buffer_back[pos] = buffer[pos];
+        }
+        yield();
+       }
+
+       // If the minBoundY wasn't updated
+       // we can savely assume that buffer_back[pos] == buffer[pos]
+       // holdes true for all values of pos
+       if (minBoundY == UINT16_MAX) return;
+
+		  set_CS(LOW);
+		  _spi->beginTransaction(_spiSettings);
+
+          for (y = minBoundY; y <= maxBoundY; y++)
+          {
+            for(int temp = 0; temp<8;temp++)
+            {
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              //setAddrWindow(y*8+temp,minBoundX,1,maxBoundX-minBoundX+1);
+              uint32_t const pixbufcount = maxBoundX-minBoundX+1;
+              uint16_t *pixbuf = (uint16_t *)rtos_malloc(2 * pixbufcount);
+              for (x = minBoundX; x <= maxBoundX; x++)
+              {
+                pixbuf[x-minBoundX] = ((buffer[x + y * displayWidth]>>temp)&0x01)==1?_RGB:0;
+              }
+#ifdef ESP_PLATFORM
+              _spi->transferBytes((uint8_t *)pixbuf, NULL, 2 * pixbufcount);
+#else
+              _spi->transfer(pixbuf, NULL, 2 * pixbufcount);
+#endif
+              rtos_free(pixbuf);
+            }
+          }
+	  _spi->endTransaction();
+	  set_CS(HIGH);
+
+     #else
+		  set_CS(LOW);
+		  _spi->beginTransaction(_spiSettings);
+		uint8_t x, y;
+          for (y = 0; y < _buffheight; y++)
+          {
+            for(int temp = 0; temp<8;temp++)
+            {
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              //setAddrWindow(minBoundX,y*8+temp,maxBoundX-minBoundX+1,1);
+              setAddrWindow(y*8+temp,0,1,displayWidth);
+              uint32_t const pixbufcount = displayWidth;
+              uint16_t *pixbuf = (uint16_t *)rtos_malloc(2 * pixbufcount);
+              for (x = 0; x < displayWidth; x++)
+              {
+                pixbuf[x] = ((buffer[x + y * displayWidth]>>temp)&0x01)==1?_RGB:0;
+              }
+#ifdef ESP_PLATFORM
+              _spi->transferBytes((uint8_t *)pixbuf, NULL, 2 * pixbufcount);
+#else
+              _spi->transfer(pixbuf, NULL, 2 * pixbufcount);
+#endif
+              rtos_free(pixbuf);
+            }
+          }
+	  _spi->endTransaction();
+	  set_CS(HIGH);
+
+     #endif
+    }
+
+ virtual void resetOrientation() {
+	uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX;
+	sendCommand(ST77XX_MADCTL);
+	WriteData(madctl);
+	delay(10);
+  }
+  
+ virtual void flipScreenVertically() {
+	uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MY;
+	sendCommand(ST77XX_MADCTL);
+	WriteData(madctl);
+	delay(10);
+  }
+  
+ virtual void mirrorScreen() {
+	uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX|ST77XX_MADCTL_MY;
+	sendCommand(ST77XX_MADCTL);
+	WriteData(madctl);
+	delay(10);
+  }
+
+  virtual void landscapeScreen() {
+
+    
+    uint8_t madctl = ST77XX_MADCTL_RGB;
+    sendCommand(ST77XX_MADCTL);
+    WriteData(madctl);
+    delay(10);
+
+    }
+  
+
+  void setRGB(uint16_t c)
+  {
+
+    this->_RGB=0x00|c>>8|c<<8&0xFF00;
+  }
+  
+  void displayOn(void) {
+  //sendCommand(DISPLAYON);
+  }
+
+  void displayOff(void) {
+  //sendCommand(DISPLAYOFF);
+  }
+  
+  void drawBitmap(int16_t xMove, int16_t yMove, int16_t width, int16_t height, const uint8_t *xbm) {
+    int16_t widthInXbm = (width + 7) / 8;
+    uint8_t data = 0;
+  
+    for(int16_t y = 0; y < height; y++) {
+      for(int16_t x = 0; x < width; x++ ) {
+        if (x & 7) {
+          data <<= 1; // Move a bit
+        } else {  // Read new data every 8 bit
+            data = pgm_read_byte(xbm + (x / 8) + y * widthInXbm);
+        }
+        // if there is a bit draw it
+        if (data & 0x80) {
+          setPixel(xMove + x, yMove + y);
+        }
+      }
+    }
+  }
+  
+
+//#define ST77XX_MADCTL_MY 0x80
+//#define ST77XX_MADCTL_MX 0x40
+//#define ST77XX_MADCTL_MV 0x20
+//#define ST77XX_MADCTL_ML 0x10
+  protected:
+    // Send all the init commands
+    virtual void sendInitCommands()
+    {
+        sendCommand(ST77XX_SWRESET); //  1: Software reset, no args, w/delay
+        delay(150);
+
+        sendCommand(ST77XX_SLPOUT); //  2: Out of sleep mode, no args, w/delay
+        delay(10);
+
+        sendCommand(ST77XX_COLMOD); //  3: Set color mode, 16-bit color
+        WriteData(0x55); 
+        delay(10);
+        
+        sendCommand(ST77XX_MADCTL); //  4: Mem access ctrl (directions), Row/col addr, bottom-top refresh
+        WriteData(0x08); 
+        
+        sendCommand(ST77XX_CASET); //   5: Column addr set, 
+        WriteData(0x00); 
+        WriteData(0x00);         //    XSTART = 0
+        WriteData(0x00); 
+        WriteData(240);          //     XEND = 240
+        
+        sendCommand(ST77XX_RASET); //   6: Row addr set, 
+        WriteData(0x00); 
+        WriteData(0x00);         //    YSTART = 0
+        WriteData(320>>8); 
+        WriteData(320&0xFF);          //    YSTART = 320
+        
+        sendCommand(ST77XX_SLPOUT); //  7: hack
+        delay(10);
+        
+        sendCommand(ST77XX_NORON); //  8: Normal display on, no args, w/delay
+        delay(10);
+        
+        sendCommand(ST77XX_DISPON); //  9: Main screen turn on, no args, delay
+        delay(10);
+
+        sendCommand(ST77XX_INVON); //  10: invert
+        delay(10);
+
+        //uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MX;
+        uint8_t madctl = ST77XX_MADCTL_RGB|ST77XX_MADCTL_MV|ST77XX_MADCTL_MX;
+        sendCommand(ST77XX_MADCTL);
+        WriteData(madctl);
+        delay(10);
+        setRGB(ST77XX_GREEN);
+    }
+
+
+  private:
+
+   void setAddrWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
+    x += (320-displayWidth)/2;
+    y += (240-displayHeight)/2;
+    uint32_t xa = ((uint32_t)x << 16) | (x + w - 1);
+    uint32_t ya = ((uint32_t)y << 16) | (y + h - 1);
+
+    writeCommand(ST77XX_CASET); // Column addr set
+    SPI_WRITE32(xa);
+
+    writeCommand(ST77XX_RASET); // Row addr set
+    SPI_WRITE32(ya);
+
+    writeCommand(ST77XX_RAMWR); // write to RAM
+  }
+	int getBufferOffset(void) {
+		return 0;
+	}
+    inline void set_CS(bool level) {
+      if (_cs != (uint8_t) -1) {
+        digitalWrite(_cs, level);
+      }
+    };
+    inline void sendCommand(uint8_t com) __attribute__((always_inline)){
+      set_CS(HIGH);
+      digitalWrite(_dc, LOW);
+      set_CS(LOW);
+      _spi->beginTransaction(_spiSettings);
+      _spi->transfer(com);
+      _spi->endTransaction();
+      set_CS(HIGH);
+      digitalWrite(_dc, HIGH);
+    }
+    
+    inline void WriteData(uint8_t data) __attribute__((always_inline)){
+        digitalWrite(_cs, LOW);
+        _spi->beginTransaction(_spiSettings);
+        _spi->transfer(data);
+        _spi->endTransaction();
+        digitalWrite(_cs, HIGH);
+    }
+   void SPI_WRITE32(uint32_t l)
+   {
+      _spi->transfer(l >> 24);
+      _spi->transfer(l >> 16);
+      _spi->transfer(l >> 8);
+      _spi->transfer(l);
+   }
+  void writeCommand(uint8_t cmd) {
+    digitalWrite(_dc, LOW);
+    _spi->transfer(cmd);
+    digitalWrite(_dc, HIGH);
+  }
+
+// Private functions
+  void setGeometry(OLEDDISPLAY_GEOMETRY g, uint16_t width, uint16_t height) {
+    this->geometry = g;
+
+    switch (g) {
+      case GEOMETRY_128_128:
+        this->displayWidth = 128;
+        this->displayHeight = 128;
+        break;
+      case GEOMETRY_128_64:
+        this->displayWidth = 128;
+        this->displayHeight = 64;
+        break;
+      case GEOMETRY_128_32:
+        this->displayWidth = 128;
+        this->displayHeight = 32;
+        break;
+      case GEOMETRY_64_48:
+        this->displayWidth = 64;
+        this->displayHeight = 48;
+        break;
+      case GEOMETRY_64_32:
+        this->displayWidth = 64;
+        this->displayHeight = 32;
+        break;
+      case GEOMETRY_RAWMODE:
+        this->displayWidth = width > 0 ? width : 128;
+        this->displayHeight = height > 0 ? height : 64;
+        break;
+    }
+    uint8_t tmp=displayHeight % 8;
+    uint8_t _buffheight=displayHeight / 8;
+
+    if(tmp!=0)
+      _buffheight++;
+    this->displayBufferSize = displayWidth * _buffheight ;
+  }
+  
+
+
+};
+
+#endif

variants/t114/platformio.ini

@@ -60,6 +60,9 @@ build_flags =
 extends = Heltec_t114
 build_flags =
   ${Heltec_t114.build_flags}
+  -I src/helpers/ui
+  -D ST7789
+  -D DISPLAY_CLASS=ST7789Display
   -D MAX_CONTACTS=100
   -D MAX_GROUP_CHANNELS=8
   -D BLE_PIN_CODE=123456
@@ -69,24 +72,18 @@ build_flags =
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${Heltec_t114.build_src_filter}
-  +<helpers/nrf52/*.cpp>
+  +<helpers/nrf52/T114Board.cpp>
+  +<helpers/nrf52/SerialBLEInterface.cpp>
   +<../examples/companion_radio/main.cpp>
+  +<../examples/companion_radio/UITask.cpp>
+  +<helpers/ui/ST7789Display.cpp>
+  +<helpers/ui/OLEDDisplay.cpp>
+  +<helpers/ui/OLEDDisplayFonts.cpp>
 lib_deps =
+  adafruit/Adafruit GFX Library @ ^1.12.1
   ${Heltec_t114.lib_deps}
   densaugeo/base64 @ ~1.4.0
 
-[env:Heltec_t114_companion_radio_ble_screen]
-extends = env:Heltec_t114_companion_radio_ble
-build_flags = ${env:Heltec_t114_companion_radio_ble.build_flags}
-  -I src/helpers/ui
-  -D ST7789
-  -D DISPLAY_CLASS=ST7789Display
-build_src_filter = ${env:Heltec_t114_companion_radio_ble.build_src_filter}
-  +<../examples/companion_radio/UITask.cpp>
-  +<helpers/ui/ST7789Display.cpp>
-lib_deps = ${env:Heltec_t114_companion_radio_ble.lib_deps}
-  adafruit/Adafruit ST7735 and ST7789 Library @ ^1.11.0
-
 [env:Heltec_t114_companion_radio_usb]
 extends = Heltec_t114
 build_flags =

variants/t114/variant.cpp

@@ -11,4 +11,5 @@ const uint32_t g_ADigitalPinMap[] = {
 
 void initVariant()
 {
+  pinMode(PIN_USER_BTN, INPUT);
 }