From 5cfa22c650b08bc68758327d7969f6c2f5a74477 Mon Sep 17 00:00:00 2001 From: Max Regan Date: Wed, 26 Jun 2019 09:02:34 -0700 Subject: [PATCH] Add a C file generator for TrueType fonts In order to be able to optimize the output better, add my own TTF generator. Fortunately, freetype-py handles all of the hard work. The generator is not yet integrated. --- .gitignore | 3 +- gen/__init__.py | 18 + gen/fixedfont-to-c.py | 150 +++ gen/font.py | 230 ++++ gen/output.c | 2438 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 2838 insertions(+), 1 deletion(-) create mode 100644 gen/__init__.py create mode 100755 gen/fixedfont-to-c.py create mode 100755 gen/font.py create mode 100644 gen/output.c diff --git a/.gitignore b/.gitignore index 068274f..74e2463 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,5 @@ *.o *.bin *.elf -build \ No newline at end of file +build +*.pyc \ No newline at end of file diff --git a/gen/__init__.py b/gen/__init__.py new file mode 100644 index 0000000..c7f4d5d --- /dev/null +++ b/gen/__init__.py @@ -0,0 +1,18 @@ +# Copyright (C) 2019 Max Regan + +# 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. diff --git a/gen/fixedfont-to-c.py b/gen/fixedfont-to-c.py new file mode 100755 index 0000000..d156ad9 --- /dev/null +++ b/gen/fixedfont-to-c.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 + +# Copyright (C) 2019 Max Regan + +# 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. + +import font +import argparse +import string + +def emit_license(output): + output.write( +"""/* + * Copyright (C) 2019 Max Regan + * + * 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. + */ + +""") + +def emit_include(output, header_dir): + if header_dir: + if header_dir[-1] == '/': + header_dir = header_dir[:-1] + header = header_dir + "/font.h" + else: + header = "font.h" + + output.write(f"#include \"{header}\"\n\n") + +def ceildiv(num, den): + return (num + (den - 1)) // den + +def to_c_name(name): + return name.replace("-","_") + +def emit_bmp(output, font_name, char, bmp): + + width_bytes = ceildiv(bmp.width, 8) + height_bytes = ceildiv(bmp.height, 8) + + output.write(f"// Bitmap for '{char}'\n") + + name = to_c_name(f"{font_name}_{ord(char)}") + output.write(f"static uint8_t {name}_bitmap[] {{\n") + byte = 0 + for y in range(bmp.height): + output.write(" ") + for x in range(bmp.width): + bit_idx = 7 - (x % 8) + bit = bmp.pixels[y * bmp.width + x] + byte |= bit << bit_idx + if bit_idx == 0 or x == bmp.width - 1: + output.write('0x{:02x}, '.format(byte)) + byte = 0 + + output.write("\n") + + output.write("};\n\n") + + output.write(f"// Glyph data for '{char}'\n") + + output.write(f"static struct glyph {name}_glyph {{\n") + output.write(f" .width = {bmp.width},\n") + output.write(f" .width_bytes = {width_bytes},\n") + output.write(f" .height = {bmp.height},\n") + output.write(f" .height_bytes = {height_bytes},\n") + output.write(f" .bitmap = {name}_bitmap,\n") + output.write("};\n\n") + + +def emit_font(output, ff, font_name, chars): + c_font_name = to_c_name(font_name) + output.write(f"static struct font {c_font_name} {{\n") + output.write(f" .name = \"{font_name}\",\n") + output.write(f" .glypyhs = [\n") + for i in range(127): + if i in + output.write("};\n\n") + + +def gen_c_font_file(ttf, output, charset, width=None, size=None, header_dir=None): + + ff = font.FixedFont(ttf, size) + font_name = ff.face.postscript_name.decode('ASCII') + emit_license(output) + emit_include(output, header_dir) + width = None + for char in charset: + bmp = ff.render_character(char) + emit_bmp(output, font_name, char, bmp) + if width is None: + width = ceildiv(bmp.width, 8) + emit_font(output, ff, font_name) + +def gen_h_font_file(ttf, output, charset, width=None, size=None): + emit_license(output) + + +def main(): + parser = argparse.ArgumentParser(description="Fixed-width TrueType C code generator") + parser.add_argument(dest="ttf", help="TrueType font file", action="store", type=str) + parser.add_argument(dest="output", help="Output C file", action="store", type=argparse.FileType('w')) + parser.add_argument("--chars", "-c", help="Character set. Defaults to all printable ASCII", action="store", type=str, + default="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-=_+{}[]:\";'<>,.?/~!@#$%^&*()|\\") + parser.add_argument("--header-dir", help="Directory of the font.h header", action="store", type=str) + + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument("--size", "-s", help="Font pitch", action="store", type=int) + group.add_argument("--width", "-w", help="Font width", action="store", type=int) + + args = parser.parse_args() + args.chars = list(set(args.chars)) + args.chars.sort() + + gen_c_font_file(args.ttf, args.output, args.chars, width=args.width, size=args.size, header_dir=args.header_dir) + + +if __name__ == "__main__": + main() diff --git a/gen/font.py b/gen/font.py new file mode 100755 index 0000000..eeaf3bd --- /dev/null +++ b/gen/font.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# Needs freetype-py>=1.0 + +# For more info see: +# http://dbader.org/blog/monochrome-font-rendering-with-freetype-and-python + +# The MIT License (MIT) +# +# Copyright (c) 2013 Daniel Bader (http://dbader.org) +# Copyright (c) 2019 Max Regan (http://git.maxregan.me) +# +# 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. + +import freetype + + +class Bitmap(object): + """ + A 2D bitmap image represented as a list of byte values. Each byte indicates the state + of a single pixel in the bitmap. A value of 0 indicates that the pixel is `off` + and any other value indicates that it is `on`. + """ + def __init__(self, width, height, pixels=None): + self.width = width + self.height = height + self.pixels = pixels or bytearray(width * height) + + def __repr__(self): + """Return a string representation of the bitmap's pixels.""" + rows = '' + for y in range(self.height): + for x in range(self.width): + rows += '#' if self.pixels[y * self.width + x] else ' ' + rows += '\n' + return rows + + def bitblt(self, src, x, y): + """Copy all pixels from `src` into this bitmap""" + srcpixel = 0 + dstpixel = y * self.width + x + row_offset = self.width - src.width + + for sy in range(src.height): + for sx in range(src.width): + # Perform an OR operation on the destination pixel and the source pixel + # because glyph bitmaps may overlap if character kerning is applied, e.g. + # in the string "AVA", the "A" and "V" glyphs must be rendered with + # overlapping bounding boxes. + self.pixels[dstpixel] = self.pixels[dstpixel] or src.pixels[srcpixel] + srcpixel += 1 + dstpixel += 1 + dstpixel += row_offset + + +class Glyph(object): + def __init__(self, pixels, width, height, top, advance_width): + self.bitmap = Bitmap(width, height, pixels) + + # The glyph bitmap's top-side bearing, i.e. the vertical distance from the + # baseline to the bitmap's top-most scanline. + self.top = top + + # Ascent and descent determine how many pixels the glyph extends + # above or below the baseline. + self.descent = max(0, self.height - self.top) + self.ascent = max(0, max(self.top, self.height) - self.descent) + + # The advance width determines where to place the next character horizontally, + # that is, how many pixels we move to the right to draw the next glyph. + self.advance_width = advance_width + + @property + def width(self): + return self.bitmap.width + + @property + def height(self): + return self.bitmap.height + + @staticmethod + def from_glyphslot(slot): + """Construct and return a Glyph object from a FreeType GlyphSlot.""" + pixels = Glyph.unpack_mono_bitmap(slot.bitmap) + width, height = slot.bitmap.width, slot.bitmap.rows + top = slot.bitmap_top + + # The advance width is given in FreeType's 26.6 fixed point format, + # which means that the pixel values are multiples of 64. + assert slot.advance.x % 64 == 0 + advance_width = slot.advance.x // 64 + + return Glyph(pixels, width, height, top, advance_width) + + @staticmethod + def unpack_mono_bitmap(bitmap): + """ + Unpack a freetype FT_LOAD_TARGET_MONO glyph bitmap into a bytearray where each + pixel is represented by a single byte. + """ + # Allocate a bytearray of sufficient size to hold the glyph bitmap. + data = bytearray(bitmap.rows * bitmap.width) + + # Iterate over every byte in the glyph bitmap. Note that we're not + # iterating over every pixel in the resulting unpacked bitmap -- + # we're iterating over the packed bytes in the input bitmap. + for y in range(bitmap.rows): + for byte_index in range(bitmap.pitch): + + # Read the byte that contains the packed pixel data. + byte_value = bitmap.buffer[y * bitmap.pitch + byte_index] + + # We've processed this many bits (=pixels) so far. This determines + # where we'll read the next batch of pixels from. + num_bits_done = byte_index * 8 + + # Pre-compute where to write the pixels that we're going + # to unpack from the current byte in the glyph bitmap. + rowstart = y * bitmap.width + byte_index * 8 + + # Iterate over every bit (=pixel) that's still a part of the + # output bitmap. Sometimes we're only unpacking a fraction of a byte + # because glyphs may not always fit on a byte boundary. So we make sure + # to stop if we unpack past the current row of pixels. + for bit_index in range(min(8, bitmap.width - num_bits_done)): + + # Unpack the next pixel from the current glyph byte. + bit = byte_value & (1 << (7 - bit_index)) + + # Write the pixel to the output bytearray. We ensure that `off` + # pixels have a value of 0 and `on` pixels have a value of 1. + data[rowstart + bit_index] = 1 if bit else 0 + + return data + + +class FixedFont(object): + def __init__(self, filename, size): + self.face = freetype.Face(filename) + self.face.set_pixel_sizes(0, size) + + if not self.face.is_fixed_width: + raise ValueError("Font is not fixed width") + + self.face.load_char('A', freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO) + self.advance = self.face.glyph.advance.x // 64 + + def glyph_for_character(self, char): + # Let FreeType load the glyph for the given character and tell it to render + # a monochromatic bitmap representation. + self.face.load_char(char, freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO) + return Glyph.from_glyphslot(self.face.glyph) + + def render_character(self, char): + glyph = self.glyph_for_character(char) + return glyph.bitmap + + def text_dimensions(self, text): + """Return (width, height, baseline) of `text` rendered in the current font.""" + width = 0 + max_ascent = 0 + max_descent = 0 + previous_char = None + + # For each character in the text string we get the glyph + # and update the overall dimensions of the resulting bitmap. + for char in text: + glyph = self.glyph_for_character(char) + max_ascent = max(max_ascent, glyph.ascent) + max_descent = max(max_descent, glyph.descent) + + # With kerning, the advance width may be less than the width of the glyph's bitmap. + # Make sure we compute the total width so that all of the glyph's pixels + # fit into the returned dimensions. + width += self.advance + + previous_char = char + + height = max_ascent + max_descent + return (width, height, max_descent) + + def render_text(self, text, width=None, height=None, baseline=None): + """ + Render the given `text` into a Bitmap and return it. + + If `width`, `height`, and `baseline` are not specified they are computed using + the `text_dimensions' method. + """ + if None in (width, height, baseline): + width, height, baseline = self.text_dimensions(text) + + x = 0 + previous_char = None + outbuffer = Bitmap(width, height) + + for char in text: + glyph = self.glyph_for_character(char) + + # The vertical drawing position should place the glyph + # on the baseline as intended. + y = height - glyph.ascent - baseline + + outbuffer.bitblt(glyph.bitmap, x, y) + + x += glyph.advance_width + previous_char = char + + return outbuffer + +if __name__ == '__main__': + # Be sure to place 'helvetica.ttf' (or any other ttf / otf font file) in the working directory. + fnt = FixedFont('/usr/share/fonts/truetype/ubuntu/UbuntuMono-R.ttf', 24) + + print(repr(fnt.render_text('AV Wa'))) diff --git a/gen/output.c b/gen/output.c new file mode 100644 index 0000000..f681fa5 --- /dev/null +++ b/gen/output.c @@ -0,0 +1,2438 @@ +/* + * Copyright (C) 2019 Max Regan + * + * 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. + */ + +#include "lib/font/include/font.h" + +// Bitmap for '!' +static uint8_t UbuntuMono_Regular_33_bitmap[] { + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x00, + 0x00, + 0xe0, + 0xe0, + 0xe0, +}; + +// Glyph data for '!' +static struct glyph UbuntuMono_Regular_33_glyph { + .width = 3, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_33_bitmap, +}; + +// Bitmap for '"' +static uint8_t UbuntuMono_Regular_34_bitmap[] { + 0xcc, + 0xcc, + 0xcc, + 0xcc, + 0xcc, +}; + +// Glyph data for '"' +static struct glyph UbuntuMono_Regular_34_glyph { + .width = 6, + .width_bytes = 1, + .height = 5, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_34_bitmap, +}; + +// Bitmap for '#' +static uint8_t UbuntuMono_Regular_35_bitmap[] { + 0x33, 0x00, + 0x33, 0x00, + 0x33, 0x00, + 0x33, 0x00, + 0xff, 0x80, + 0xff, 0x80, + 0x33, 0x00, + 0x66, 0x00, + 0x66, 0x00, + 0xff, 0x80, + 0xff, 0x80, + 0x66, 0x00, + 0x66, 0x00, + 0x66, 0x00, +}; + +// Glyph data for '#' +static struct glyph UbuntuMono_Regular_35_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_35_bitmap, +}; + +// Bitmap for '$' +static uint8_t UbuntuMono_Regular_36_bitmap[] { + 0x0c, 0x00, + 0x0c, 0x00, + 0x3f, 0x00, + 0x7f, 0x00, + 0xc1, 0x00, + 0xc0, 0x00, + 0xe0, 0x00, + 0x78, 0x00, + 0x3e, 0x00, + 0x0f, 0x00, + 0x01, 0x80, + 0x01, 0x80, + 0xc1, 0x80, + 0xff, 0x00, + 0x7e, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, +}; + +// Glyph data for '$' +static struct glyph UbuntuMono_Regular_36_glyph { + .width = 9, + .width_bytes = 2, + .height = 17, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_36_bitmap, +}; + +// Bitmap for '%' +static uint8_t UbuntuMono_Regular_37_bitmap[] { + 0x60, 0x40, + 0x90, 0x80, + 0x91, 0x00, + 0x91, 0x00, + 0x92, 0x00, + 0x94, 0x00, + 0x64, 0x00, + 0x09, 0x80, + 0x0a, 0x40, + 0x12, 0x40, + 0x22, 0x40, + 0x22, 0x40, + 0x42, 0x40, + 0x81, 0x80, +}; + +// Glyph data for '%' +static struct glyph UbuntuMono_Regular_37_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_37_bitmap, +}; + +// Bitmap for '&' +static uint8_t UbuntuMono_Regular_38_bitmap[] { + 0x3c, 0x00, + 0x7e, 0x00, + 0x66, 0x00, + 0x66, 0x00, + 0x64, 0x00, + 0x3c, 0x00, + 0x39, 0x80, + 0x6d, 0x80, + 0xc7, 0x80, + 0xc7, 0x00, + 0xc3, 0x00, + 0xe7, 0x80, + 0x7f, 0x80, + 0x3c, 0xc0, +}; + +// Glyph data for '&' +static struct glyph UbuntuMono_Regular_38_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_38_bitmap, +}; + +// Bitmap for ''' +static uint8_t UbuntuMono_Regular_39_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for ''' +static struct glyph UbuntuMono_Regular_39_glyph { + .width = 2, + .width_bytes = 1, + .height = 6, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_39_bitmap, +}; + +// Bitmap for '(' +static uint8_t UbuntuMono_Regular_40_bitmap[] { + 0x08, + 0x1c, + 0x38, + 0x30, + 0x60, + 0x60, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0x60, + 0x60, + 0x30, + 0x38, + 0x1c, + 0x08, +}; + +// Glyph data for '(' +static struct glyph UbuntuMono_Regular_40_glyph { + .width = 6, + .width_bytes = 1, + .height = 18, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_40_bitmap, +}; + +// Bitmap for ')' +static uint8_t UbuntuMono_Regular_41_bitmap[] { + 0x40, + 0xe0, + 0x70, + 0x30, + 0x18, + 0x18, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x18, + 0x18, + 0x30, + 0x70, + 0xe0, + 0x40, +}; + +// Glyph data for ')' +static struct glyph UbuntuMono_Regular_41_glyph { + .width = 6, + .width_bytes = 1, + .height = 18, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_41_bitmap, +}; + +// Bitmap for '*' +static uint8_t UbuntuMono_Regular_42_bitmap[] { + 0x18, + 0x18, + 0xdb, + 0xff, + 0x1c, + 0x3c, + 0x66, + 0x24, +}; + +// Glyph data for '*' +static struct glyph UbuntuMono_Regular_42_glyph { + .width = 8, + .width_bytes = 1, + .height = 8, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_42_bitmap, +}; + +// Bitmap for '+' +static uint8_t UbuntuMono_Regular_43_bitmap[] { + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0xff, 0xc0, + 0xff, 0xc0, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, +}; + +// Glyph data for '+' +static struct glyph UbuntuMono_Regular_43_glyph { + .width = 10, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_43_bitmap, +}; + +// Bitmap for ',' +static uint8_t UbuntuMono_Regular_44_bitmap[] { + 0x70, + 0x70, + 0x70, + 0x30, + 0x60, + 0xc0, +}; + +// Glyph data for ',' +static struct glyph UbuntuMono_Regular_44_glyph { + .width = 4, + .width_bytes = 1, + .height = 6, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_44_bitmap, +}; + +// Bitmap for '-' +static uint8_t UbuntuMono_Regular_45_bitmap[] { + 0xf8, + 0xf8, +}; + +// Glyph data for '-' +static struct glyph UbuntuMono_Regular_45_glyph { + .width = 5, + .width_bytes = 1, + .height = 2, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_45_bitmap, +}; + +// Bitmap for '.' +static uint8_t UbuntuMono_Regular_46_bitmap[] { + 0xe0, + 0xe0, + 0xe0, +}; + +// Glyph data for '.' +static struct glyph UbuntuMono_Regular_46_glyph { + .width = 3, + .width_bytes = 1, + .height = 3, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_46_bitmap, +}; + +// Bitmap for '/' +static uint8_t UbuntuMono_Regular_47_bitmap[] { + 0x02, + 0x02, + 0x04, + 0x04, + 0x04, + 0x08, + 0x08, + 0x08, + 0x10, + 0x10, + 0x10, + 0x20, + 0x20, + 0x20, + 0x40, + 0x40, + 0x40, + 0x80, + 0x80, +}; + +// Glyph data for '/' +static struct glyph UbuntuMono_Regular_47_glyph { + .width = 7, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_47_bitmap, +}; + +// Bitmap for '0' +static uint8_t UbuntuMono_Regular_48_bitmap[] { + 0x1c, 0x00, + 0x7f, 0x00, + 0x63, 0x00, + 0xe3, 0x80, + 0xc1, 0x80, + 0xdd, 0x80, + 0xdd, 0x80, + 0xdd, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x80, + 0x63, 0x00, + 0x7f, 0x00, + 0x1c, 0x00, +}; + +// Glyph data for '0' +static struct glyph UbuntuMono_Regular_48_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_48_bitmap, +}; + +// Bitmap for '1' +static uint8_t UbuntuMono_Regular_49_bitmap[] { + 0x0c, 0x00, + 0x1c, 0x00, + 0x7c, 0x00, + 0xcc, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x7f, 0x80, + 0x7f, 0x80, +}; + +// Glyph data for '1' +static struct glyph UbuntuMono_Regular_49_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_49_bitmap, +}; + +// Bitmap for '2' +static uint8_t UbuntuMono_Regular_50_bitmap[] { + 0x7c, + 0xfe, + 0x8e, + 0x06, + 0x06, + 0x06, + 0x0c, + 0x18, + 0x30, + 0x20, + 0x60, + 0xc0, + 0xff, + 0xff, +}; + +// Glyph data for '2' +static struct glyph UbuntuMono_Regular_50_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_50_bitmap, +}; + +// Bitmap for '3' +static uint8_t UbuntuMono_Regular_51_bitmap[] { + 0x7c, 0x00, + 0xfe, 0x00, + 0x47, 0x00, + 0x03, 0x00, + 0x03, 0x00, + 0x06, 0x00, + 0x3c, 0x00, + 0x3f, 0x00, + 0x03, 0x80, + 0x01, 0x80, + 0x01, 0x80, + 0x83, 0x80, + 0xff, 0x00, + 0x7e, 0x00, +}; + +// Glyph data for '3' +static struct glyph UbuntuMono_Regular_51_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_51_bitmap, +}; + +// Bitmap for '4' +static uint8_t UbuntuMono_Regular_52_bitmap[] { + 0x06, 0x00, + 0x0e, 0x00, + 0x0e, 0x00, + 0x1e, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x66, 0x00, + 0x66, 0x00, + 0xc6, 0x00, + 0xff, 0x80, + 0xff, 0x80, + 0x06, 0x00, + 0x06, 0x00, + 0x06, 0x00, +}; + +// Glyph data for '4' +static struct glyph UbuntuMono_Regular_52_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_52_bitmap, +}; + +// Bitmap for '5' +static uint8_t UbuntuMono_Regular_53_bitmap[] { + 0x7f, 0x80, + 0x7f, 0x80, + 0x60, 0x00, + 0x60, 0x00, + 0x60, 0x00, + 0x7c, 0x00, + 0x7f, 0x00, + 0x07, 0x00, + 0x01, 0x80, + 0x01, 0x80, + 0x01, 0x80, + 0x83, 0x80, + 0xff, 0x00, + 0x7e, 0x00, +}; + +// Glyph data for '5' +static struct glyph UbuntuMono_Regular_53_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_53_bitmap, +}; + +// Bitmap for '6' +static uint8_t UbuntuMono_Regular_54_bitmap[] { + 0x07, 0x00, + 0x1f, 0x00, + 0x38, 0x00, + 0x60, 0x00, + 0x60, 0x00, + 0xfe, 0x00, + 0xff, 0x00, + 0xc3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0x63, 0x80, + 0x7f, 0x00, + 0x3e, 0x00, +}; + +// Glyph data for '6' +static struct glyph UbuntuMono_Regular_54_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_54_bitmap, +}; + +// Bitmap for '7' +static uint8_t UbuntuMono_Regular_55_bitmap[] { + 0xff, 0x80, + 0xff, 0x80, + 0x01, 0x80, + 0x03, 0x00, + 0x06, 0x00, + 0x06, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, +}; + +// Glyph data for '7' +static struct glyph UbuntuMono_Regular_55_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_55_bitmap, +}; + +// Bitmap for '8' +static uint8_t UbuntuMono_Regular_56_bitmap[] { + 0x3e, 0x00, + 0x7f, 0x00, + 0xe3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x00, + 0x7e, 0x00, + 0x7f, 0x00, + 0x63, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x80, + 0x7f, 0x00, + 0x3e, 0x00, +}; + +// Glyph data for '8' +static struct glyph UbuntuMono_Regular_56_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_56_bitmap, +}; + +// Bitmap for '9' +static uint8_t UbuntuMono_Regular_57_bitmap[] { + 0x3e, 0x00, + 0x7f, 0x00, + 0xe3, 0x00, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe1, 0x80, + 0x7f, 0x80, + 0x3f, 0x80, + 0x03, 0x00, + 0x03, 0x00, + 0x0e, 0x00, + 0x7c, 0x00, + 0x70, 0x00, +}; + +// Glyph data for '9' +static struct glyph UbuntuMono_Regular_57_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_57_bitmap, +}; + +// Bitmap for ':' +static uint8_t UbuntuMono_Regular_58_bitmap[] { + 0xe0, + 0xe0, + 0xe0, + 0x00, + 0x00, + 0x00, + 0x00, + 0xe0, + 0xe0, + 0xe0, +}; + +// Glyph data for ':' +static struct glyph UbuntuMono_Regular_58_glyph { + .width = 3, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_58_bitmap, +}; + +// Bitmap for ';' +static uint8_t UbuntuMono_Regular_59_bitmap[] { + 0x38, + 0x38, + 0x38, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x70, + 0x30, + 0x10, + 0x30, + 0x40, +}; + +// Glyph data for ';' +static struct glyph UbuntuMono_Regular_59_glyph { + .width = 5, + .width_bytes = 1, + .height = 13, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_59_bitmap, +}; + +// Bitmap for '<' +static uint8_t UbuntuMono_Regular_60_bitmap[] { + 0x01, 0x80, + 0x07, 0x80, + 0x1f, 0x00, + 0x78, 0x00, + 0xc0, 0x00, + 0xf8, 0x00, + 0x1f, 0x00, + 0x07, 0x80, + 0x01, 0x80, +}; + +// Glyph data for '<' +static struct glyph UbuntuMono_Regular_60_glyph { + .width = 9, + .width_bytes = 2, + .height = 9, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_60_bitmap, +}; + +// Bitmap for '=' +static uint8_t UbuntuMono_Regular_61_bitmap[] { + 0xff, 0x80, + 0xff, 0x80, + 0x00, 0x00, + 0x00, 0x00, + 0x00, 0x00, + 0xff, 0x80, + 0xff, 0x80, +}; + +// Glyph data for '=' +static struct glyph UbuntuMono_Regular_61_glyph { + .width = 9, + .width_bytes = 2, + .height = 7, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_61_bitmap, +}; + +// Bitmap for '>' +static uint8_t UbuntuMono_Regular_62_bitmap[] { + 0xc0, 0x00, + 0xf0, 0x00, + 0x7c, 0x00, + 0x0f, 0x00, + 0x01, 0x80, + 0x0f, 0x80, + 0x7c, 0x00, + 0xf0, 0x00, + 0xc0, 0x00, +}; + +// Glyph data for '>' +static struct glyph UbuntuMono_Regular_62_glyph { + .width = 9, + .width_bytes = 2, + .height = 9, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_62_bitmap, +}; + +// Bitmap for '?' +static uint8_t UbuntuMono_Regular_63_bitmap[] { + 0x7c, + 0xfe, + 0x86, + 0x06, + 0x06, + 0x0c, + 0x18, + 0x30, + 0x30, + 0x00, + 0x00, + 0x70, + 0x70, + 0x70, +}; + +// Glyph data for '?' +static struct glyph UbuntuMono_Regular_63_glyph { + .width = 7, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_63_bitmap, +}; + +// Bitmap for '@' +static uint8_t UbuntuMono_Regular_64_bitmap[] { + 0x1e, 0x00, + 0x3f, 0x00, + 0x73, 0x80, + 0x61, 0x80, + 0xc1, 0x80, + 0xc7, 0x80, + 0xcf, 0x80, + 0xd9, 0x80, + 0xd9, 0x80, + 0xd9, 0x80, + 0xd9, 0x80, + 0xcf, 0x80, + 0x67, 0x80, + 0x60, 0x00, + 0x30, 0x00, + 0x3f, 0x00, + 0x0f, 0x00, +}; + +// Glyph data for '@' +static struct glyph UbuntuMono_Regular_64_glyph { + .width = 9, + .width_bytes = 2, + .height = 17, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_64_bitmap, +}; + +// Bitmap for 'A' +static uint8_t UbuntuMono_Regular_65_bitmap[] { + 0x1e, 0x00, + 0x1e, 0x00, + 0x1e, 0x00, + 0x3b, 0x00, + 0x33, 0x00, + 0x33, 0x00, + 0x33, 0x00, + 0x73, 0x80, + 0x61, 0x80, + 0x7f, 0x80, + 0x7f, 0x80, + 0x61, 0x80, + 0xc0, 0xc0, + 0xc0, 0xc0, +}; + +// Glyph data for 'A' +static struct glyph UbuntuMono_Regular_65_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_65_bitmap, +}; + +// Bitmap for 'B' +static uint8_t UbuntuMono_Regular_66_bitmap[] { + 0xfc, 0x00, + 0xfe, 0x00, + 0xc7, 0x00, + 0xc3, 0x00, + 0xc3, 0x00, + 0xc6, 0x00, + 0xfc, 0x00, + 0xff, 0x00, + 0xc3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc3, 0x80, + 0xff, 0x00, + 0xfe, 0x00, +}; + +// Glyph data for 'B' +static struct glyph UbuntuMono_Regular_66_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_66_bitmap, +}; + +// Bitmap for 'C' +static uint8_t UbuntuMono_Regular_67_bitmap[] { + 0x1f, 0x00, + 0x3f, 0x80, + 0x70, 0x80, + 0x60, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0x60, 0x00, + 0x70, 0x80, + 0x3f, 0x80, + 0x1f, 0x00, +}; + +// Glyph data for 'C' +static struct glyph UbuntuMono_Regular_67_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_67_bitmap, +}; + +// Bitmap for 'D' +static uint8_t UbuntuMono_Regular_68_bitmap[] { + 0xfc, 0x00, + 0xfe, 0x00, + 0xc7, 0x00, + 0xc3, 0x00, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc3, 0x00, + 0xc7, 0x00, + 0xfe, 0x00, + 0xfc, 0x00, +}; + +// Glyph data for 'D' +static struct glyph UbuntuMono_Regular_68_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_68_bitmap, +}; + +// Bitmap for 'E' +static uint8_t UbuntuMono_Regular_69_bitmap[] { + 0xff, + 0xff, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xfe, + 0xfe, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xff, + 0xff, +}; + +// Glyph data for 'E' +static struct glyph UbuntuMono_Regular_69_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_69_bitmap, +}; + +// Bitmap for 'F' +static uint8_t UbuntuMono_Regular_70_bitmap[] { + 0xff, + 0xff, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xfe, + 0xfe, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for 'F' +static struct glyph UbuntuMono_Regular_70_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_70_bitmap, +}; + +// Bitmap for 'G' +static uint8_t UbuntuMono_Regular_71_bitmap[] { + 0x1f, 0x00, + 0x3f, 0x80, + 0x70, 0x80, + 0x60, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0x61, 0x80, + 0x71, 0x80, + 0x3f, 0x80, + 0x1f, 0x80, +}; + +// Glyph data for 'G' +static struct glyph UbuntuMono_Regular_71_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_71_bitmap, +}; + +// Bitmap for 'H' +static uint8_t UbuntuMono_Regular_72_bitmap[] { + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xff, 0x80, + 0xff, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'H' +static struct glyph UbuntuMono_Regular_72_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_72_bitmap, +}; + +// Bitmap for 'I' +static uint8_t UbuntuMono_Regular_73_bitmap[] { + 0xff, + 0xff, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0xff, + 0xff, +}; + +// Glyph data for 'I' +static struct glyph UbuntuMono_Regular_73_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_73_bitmap, +}; + +// Bitmap for 'J' +static uint8_t UbuntuMono_Regular_74_bitmap[] { + 0x3f, + 0x3f, + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x87, + 0xfe, + 0x7c, +}; + +// Glyph data for 'J' +static struct glyph UbuntuMono_Regular_74_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_74_bitmap, +}; + +// Bitmap for 'K' +static uint8_t UbuntuMono_Regular_75_bitmap[] { + 0xc1, 0x80, + 0xc3, 0x00, + 0xc6, 0x00, + 0xcc, 0x00, + 0xcc, 0x00, + 0xd8, 0x00, + 0xf0, 0x00, + 0xf0, 0x00, + 0xd8, 0x00, + 0xcc, 0x00, + 0xc6, 0x00, + 0xc3, 0x00, + 0xc3, 0x00, + 0xc1, 0x80, +}; + +// Glyph data for 'K' +static struct glyph UbuntuMono_Regular_75_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_75_bitmap, +}; + +// Bitmap for 'L' +static uint8_t UbuntuMono_Regular_76_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xff, + 0xff, +}; + +// Glyph data for 'L' +static struct glyph UbuntuMono_Regular_76_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_76_bitmap, +}; + +// Bitmap for 'M' +static uint8_t UbuntuMono_Regular_77_bitmap[] { + 0x63, 0x00, + 0x63, 0x00, + 0x63, 0x00, + 0x55, 0x00, + 0x55, 0x80, + 0xd5, 0x80, + 0xd5, 0x80, + 0xdd, 0x80, + 0xc9, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'M' +static struct glyph UbuntuMono_Regular_77_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_77_bitmap, +}; + +// Bitmap for 'N' +static uint8_t UbuntuMono_Regular_78_bitmap[] { + 0xc1, 0x80, + 0xe1, 0x80, + 0xe1, 0x80, + 0xf1, 0x80, + 0xd1, 0x80, + 0xd9, 0x80, + 0xc9, 0x80, + 0xcd, 0x80, + 0xc5, 0x80, + 0xc5, 0x80, + 0xc3, 0x80, + 0xc3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'N' +static struct glyph UbuntuMono_Regular_78_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_78_bitmap, +}; + +// Bitmap for 'O' +static uint8_t UbuntuMono_Regular_79_bitmap[] { + 0x1c, 0x00, + 0x7f, 0x00, + 0x63, 0x00, + 0xe3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x80, + 0x63, 0x00, + 0x7f, 0x00, + 0x3c, 0x00, +}; + +// Glyph data for 'O' +static struct glyph UbuntuMono_Regular_79_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_79_bitmap, +}; + +// Bitmap for 'P' +static uint8_t UbuntuMono_Regular_80_bitmap[] { + 0xfc, + 0xfe, + 0xc7, + 0xc3, + 0xc3, + 0xc3, + 0xc7, + 0xfe, + 0xfc, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for 'P' +static struct glyph UbuntuMono_Regular_80_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_80_bitmap, +}; + +// Bitmap for 'Q' +static uint8_t UbuntuMono_Regular_81_bitmap[] { + 0x1c, 0x00, + 0x7f, 0x00, + 0x63, 0x00, + 0xe3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x80, + 0x63, 0x00, + 0x7f, 0x00, + 0x3c, 0x00, + 0x1c, 0x00, + 0x0f, 0x00, + 0x03, 0x00, +}; + +// Glyph data for 'Q' +static struct glyph UbuntuMono_Regular_81_glyph { + .width = 9, + .width_bytes = 2, + .height = 17, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_81_bitmap, +}; + +// Bitmap for 'R' +static uint8_t UbuntuMono_Regular_82_bitmap[] { + 0xfc, 0x00, + 0xfe, 0x00, + 0xc7, 0x00, + 0xc3, 0x00, + 0xc3, 0x00, + 0xc3, 0x00, + 0xc7, 0x00, + 0xfe, 0x00, + 0xfc, 0x00, + 0xcc, 0x00, + 0xc6, 0x00, + 0xc3, 0x00, + 0xc3, 0x00, + 0xc1, 0x80, +}; + +// Glyph data for 'R' +static struct glyph UbuntuMono_Regular_82_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_82_bitmap, +}; + +// Bitmap for 'S' +static uint8_t UbuntuMono_Regular_83_bitmap[] { + 0x3c, + 0x7e, + 0xc2, + 0xc0, + 0xc0, + 0xf0, + 0x7c, + 0x1e, + 0x07, + 0x03, + 0x03, + 0x87, + 0xfe, + 0x7c, +}; + +// Glyph data for 'S' +static struct glyph UbuntuMono_Regular_83_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_83_bitmap, +}; + +// Bitmap for 'T' +static uint8_t UbuntuMono_Regular_84_bitmap[] { + 0xff, 0xc0, + 0xff, 0xc0, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, +}; + +// Glyph data for 'T' +static struct glyph UbuntuMono_Regular_84_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_84_bitmap, +}; + +// Bitmap for 'U' +static uint8_t UbuntuMono_Regular_85_bitmap[] { + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xe3, 0x80, + 0x7f, 0x00, + 0x3e, 0x00, +}; + +// Glyph data for 'U' +static struct glyph UbuntuMono_Regular_85_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_85_bitmap, +}; + +// Bitmap for 'V' +static uint8_t UbuntuMono_Regular_86_bitmap[] { + 0xc0, 0xc0, + 0xc0, 0xc0, + 0x61, 0x80, + 0x61, 0x80, + 0x61, 0x80, + 0x71, 0x80, + 0x31, 0x00, + 0x33, 0x00, + 0x3b, 0x00, + 0x1a, 0x00, + 0x1e, 0x00, + 0x1e, 0x00, + 0x1e, 0x00, + 0x0c, 0x00, +}; + +// Glyph data for 'V' +static struct glyph UbuntuMono_Regular_86_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_86_bitmap, +}; + +// Bitmap for 'W' +static uint8_t UbuntuMono_Regular_87_bitmap[] { + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc9, 0x80, + 0xdd, 0x80, + 0xd5, 0x80, + 0xd5, 0x80, + 0xf7, 0x80, + 0xe3, 0x80, + 0xe3, 0x80, + 0xe3, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'W' +static struct glyph UbuntuMono_Regular_87_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_87_bitmap, +}; + +// Bitmap for 'X' +static uint8_t UbuntuMono_Regular_88_bitmap[] { + 0xc1, 0x80, + 0x63, 0x00, + 0x63, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x1c, 0x00, + 0x1c, 0x00, + 0x1c, 0x00, + 0x1c, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x63, 0x00, + 0x63, 0x00, + 0xc1, 0x80, +}; + +// Glyph data for 'X' +static struct glyph UbuntuMono_Regular_88_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_88_bitmap, +}; + +// Bitmap for 'Y' +static uint8_t UbuntuMono_Regular_89_bitmap[] { + 0xc0, 0xc0, + 0x61, 0x80, + 0x61, 0x80, + 0x61, 0x80, + 0x33, 0x00, + 0x33, 0x00, + 0x1e, 0x00, + 0x1e, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, +}; + +// Glyph data for 'Y' +static struct glyph UbuntuMono_Regular_89_glyph { + .width = 10, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_89_bitmap, +}; + +// Bitmap for 'Z' +static uint8_t UbuntuMono_Regular_90_bitmap[] { + 0xff, 0x80, + 0xff, 0x80, + 0x03, 0x80, + 0x03, 0x00, + 0x06, 0x00, + 0x0c, 0x00, + 0x0c, 0x00, + 0x18, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x60, 0x00, + 0xe0, 0x00, + 0xff, 0x80, + 0xff, 0x80, +}; + +// Glyph data for 'Z' +static struct glyph UbuntuMono_Regular_90_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_90_bitmap, +}; + +// Bitmap for '[' +static uint8_t UbuntuMono_Regular_91_bitmap[] { + 0xfc, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xfc, +}; + +// Glyph data for '[' +static struct glyph UbuntuMono_Regular_91_glyph { + .width = 6, + .width_bytes = 1, + .height = 18, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_91_bitmap, +}; + +// Bitmap for '\' +static uint8_t UbuntuMono_Regular_92_bitmap[] { + 0x80, + 0x80, + 0x40, + 0x40, + 0x40, + 0x20, + 0x20, + 0x20, + 0x10, + 0x10, + 0x10, + 0x08, + 0x08, + 0x08, + 0x04, + 0x04, + 0x04, + 0x02, + 0x02, +}; + +// Glyph data for '\' +static struct glyph UbuntuMono_Regular_92_glyph { + .width = 7, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_92_bitmap, +}; + +// Bitmap for ']' +static uint8_t UbuntuMono_Regular_93_bitmap[] { + 0xfc, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0xfc, +}; + +// Glyph data for ']' +static struct glyph UbuntuMono_Regular_93_glyph { + .width = 6, + .width_bytes = 1, + .height = 18, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_93_bitmap, +}; + +// Bitmap for '^' +static uint8_t UbuntuMono_Regular_94_bitmap[] { + 0x1c, 0x00, + 0x1c, 0x00, + 0x36, 0x00, + 0x22, 0x00, + 0x63, 0x00, + 0xc1, 0x80, + 0x80, 0x80, +}; + +// Glyph data for '^' +static struct glyph UbuntuMono_Regular_94_glyph { + .width = 9, + .width_bytes = 2, + .height = 7, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_94_bitmap, +}; + +// Bitmap for '_' +static uint8_t UbuntuMono_Regular_95_bitmap[] { + 0xff, 0xe0, + 0xff, 0xe0, +}; + +// Glyph data for '_' +static struct glyph UbuntuMono_Regular_95_glyph { + .width = 11, + .width_bytes = 2, + .height = 2, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_95_bitmap, +}; + +// Bitmap for 'a' +static uint8_t UbuntuMono_Regular_97_bitmap[] { + 0x7c, + 0x7f, + 0x07, + 0x03, + 0x3f, + 0xc3, + 0xc3, + 0xc3, + 0xff, + 0x3f, +}; + +// Glyph data for 'a' +static struct glyph UbuntuMono_Regular_97_glyph { + .width = 8, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_97_bitmap, +}; + +// Bitmap for 'b' +static uint8_t UbuntuMono_Regular_98_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xfc, + 0xfe, + 0xc7, + 0xc3, + 0xc3, + 0xc3, + 0xc3, + 0xc7, + 0xfe, + 0xfc, +}; + +// Glyph data for 'b' +static struct glyph UbuntuMono_Regular_98_glyph { + .width = 8, + .width_bytes = 1, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_98_bitmap, +}; + +// Bitmap for 'c' +static uint8_t UbuntuMono_Regular_99_bitmap[] { + 0x1f, 0x80, + 0x7f, 0x80, + 0x70, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0xc0, 0x00, + 0x60, 0x00, + 0x7f, 0x80, + 0x1f, 0x80, +}; + +// Glyph data for 'c' +static struct glyph UbuntuMono_Regular_99_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_99_bitmap, +}; + +// Bitmap for 'd' +static uint8_t UbuntuMono_Regular_100_bitmap[] { + 0x03, + 0x03, + 0x03, + 0x03, + 0x03, + 0x3f, + 0x7f, + 0xe3, + 0xc3, + 0xc3, + 0xc3, + 0xc3, + 0xe3, + 0x7f, + 0x3f, +}; + +// Glyph data for 'd' +static struct glyph UbuntuMono_Regular_100_glyph { + .width = 8, + .width_bytes = 1, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_100_bitmap, +}; + +// Bitmap for 'e' +static uint8_t UbuntuMono_Regular_101_bitmap[] { + 0x1e, 0x00, + 0x7f, 0x00, + 0x63, 0x80, + 0xc1, 0x80, + 0xff, 0x80, + 0xc0, 0x00, + 0xc0, 0x00, + 0x60, 0x00, + 0x7f, 0x00, + 0x1f, 0x00, +}; + +// Glyph data for 'e' +static struct glyph UbuntuMono_Regular_101_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_101_bitmap, +}; + +// Bitmap for 'f' +static uint8_t UbuntuMono_Regular_102_bitmap[] { + 0x0f, 0x00, + 0x1f, 0x80, + 0x38, 0x80, + 0x30, 0x00, + 0x30, 0x00, + 0xff, 0x00, + 0xff, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, +}; + +// Glyph data for 'f' +static struct glyph UbuntuMono_Regular_102_glyph { + .width = 9, + .width_bytes = 2, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_102_bitmap, +}; + +// Bitmap for 'g' +static uint8_t UbuntuMono_Regular_103_bitmap[] { + 0x3f, + 0x7f, + 0x63, + 0xc3, + 0xc3, + 0xc3, + 0xc3, + 0xe3, + 0x7f, + 0x3f, + 0x03, + 0x47, + 0x7e, + 0x7c, +}; + +// Glyph data for 'g' +static struct glyph UbuntuMono_Regular_103_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_103_bitmap, +}; + +// Bitmap for 'h' +static uint8_t UbuntuMono_Regular_104_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xfc, + 0xfc, + 0xce, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, +}; + +// Glyph data for 'h' +static struct glyph UbuntuMono_Regular_104_glyph { + .width = 7, + .width_bytes = 1, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_104_bitmap, +}; + +// Bitmap for 'i' +static uint8_t UbuntuMono_Regular_105_bitmap[] { + 0x38, 0x00, + 0x38, 0x00, + 0x38, 0x00, + 0x00, 0x00, + 0x00, 0x00, + 0xf8, 0x00, + 0xf8, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x1f, 0x80, + 0x0f, 0x80, +}; + +// Glyph data for 'i' +static struct glyph UbuntuMono_Regular_105_glyph { + .width = 9, + .width_bytes = 2, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_105_bitmap, +}; + +// Bitmap for 'j' +static uint8_t UbuntuMono_Regular_106_bitmap[] { + 0x1c, + 0x1c, + 0x1c, + 0x00, + 0x00, + 0x7c, + 0x7c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x8c, + 0xf8, + 0x78, +}; + +// Glyph data for 'j' +static struct glyph UbuntuMono_Regular_106_glyph { + .width = 6, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_106_bitmap, +}; + +// Bitmap for 'k' +static uint8_t UbuntuMono_Regular_107_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc3, + 0xc6, + 0xcc, + 0xd8, + 0xf0, + 0xf0, + 0xd8, + 0xcc, + 0xc6, + 0xc3, +}; + +// Glyph data for 'k' +static struct glyph UbuntuMono_Regular_107_glyph { + .width = 8, + .width_bytes = 1, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_107_bitmap, +}; + +// Bitmap for 'l' +static uint8_t UbuntuMono_Regular_108_bitmap[] { + 0xf8, 0x00, + 0xf8, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x18, 0x00, + 0x1f, 0x80, + 0x0f, 0x80, +}; + +// Glyph data for 'l' +static struct glyph UbuntuMono_Regular_108_glyph { + .width = 9, + .width_bytes = 2, + .height = 15, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_108_bitmap, +}; + +// Bitmap for 'm' +static uint8_t UbuntuMono_Regular_109_bitmap[] { + 0xff, 0x00, + 0xff, 0x80, + 0xcd, 0x80, + 0xcd, 0x80, + 0xcd, 0x80, + 0xcd, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'm' +static struct glyph UbuntuMono_Regular_109_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_109_bitmap, +}; + +// Bitmap for 'n' +static uint8_t UbuntuMono_Regular_110_bitmap[] { + 0xfe, 0x00, + 0xff, 0x00, + 0xc3, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, +}; + +// Glyph data for 'n' +static struct glyph UbuntuMono_Regular_110_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_110_bitmap, +}; + +// Bitmap for 'o' +static uint8_t UbuntuMono_Regular_111_bitmap[] { + 0x3e, 0x00, + 0x7f, 0x00, + 0x63, 0x00, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0xc1, 0x80, + 0x63, 0x00, + 0x7f, 0x00, + 0x3e, 0x00, +}; + +// Glyph data for 'o' +static struct glyph UbuntuMono_Regular_111_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_111_bitmap, +}; + +// Bitmap for 'p' +static uint8_t UbuntuMono_Regular_112_bitmap[] { + 0xfc, + 0xfe, + 0xc6, + 0xc3, + 0xc3, + 0xc3, + 0xc3, + 0xc7, + 0xfe, + 0xfc, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for 'p' +static struct glyph UbuntuMono_Regular_112_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_112_bitmap, +}; + +// Bitmap for 'q' +static uint8_t UbuntuMono_Regular_113_bitmap[] { + 0x3f, + 0x7f, + 0x63, + 0xc3, + 0xc3, + 0xc3, + 0xc3, + 0xe3, + 0x7f, + 0x3f, + 0x03, + 0x03, + 0x03, + 0x03, +}; + +// Glyph data for 'q' +static struct glyph UbuntuMono_Regular_113_glyph { + .width = 8, + .width_bytes = 1, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_113_bitmap, +}; + +// Bitmap for 'r' +static uint8_t UbuntuMono_Regular_114_bitmap[] { + 0x7f, + 0xff, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for 'r' +static struct glyph UbuntuMono_Regular_114_glyph { + .width = 8, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_114_bitmap, +}; + +// Bitmap for 's' +static uint8_t UbuntuMono_Regular_115_bitmap[] { + 0x3f, + 0xff, + 0xc1, + 0xe0, + 0x7c, + 0x3e, + 0x07, + 0x83, + 0xff, + 0x7e, +}; + +// Glyph data for 's' +static struct glyph UbuntuMono_Regular_115_glyph { + .width = 8, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_115_bitmap, +}; + +// Bitmap for 't' +static uint8_t UbuntuMono_Regular_116_bitmap[] { + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0xff, 0x80, + 0xff, 0x80, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x30, 0x00, + 0x3f, 0x80, + 0x1f, 0x80, +}; + +// Glyph data for 't' +static struct glyph UbuntuMono_Regular_116_glyph { + .width = 9, + .width_bytes = 2, + .height = 13, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_116_bitmap, +}; + +// Bitmap for 'u' +static uint8_t UbuntuMono_Regular_117_bitmap[] { + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xc6, + 0xe6, + 0x7e, + 0x3e, +}; + +// Glyph data for 'u' +static struct glyph UbuntuMono_Regular_117_glyph { + .width = 7, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_117_bitmap, +}; + +// Bitmap for 'v' +static uint8_t UbuntuMono_Regular_118_bitmap[] { + 0xc1, 0x80, + 0xc1, 0x80, + 0x63, 0x00, + 0x63, 0x00, + 0x63, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x1c, 0x00, + 0x1c, 0x00, +}; + +// Glyph data for 'v' +static struct glyph UbuntuMono_Regular_118_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_118_bitmap, +}; + +// Bitmap for 'w' +static uint8_t UbuntuMono_Regular_119_bitmap[] { + 0xc0, 0x60, + 0xc0, 0x60, + 0xc4, 0x60, + 0xc4, 0x60, + 0x44, 0x40, + 0x6a, 0xc0, + 0x6a, 0xc0, + 0x71, 0xc0, + 0x71, 0xc0, + 0x20, 0x80, +}; + +// Glyph data for 'w' +static struct glyph UbuntuMono_Regular_119_glyph { + .width = 11, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_119_bitmap, +}; + +// Bitmap for 'x' +static uint8_t UbuntuMono_Regular_120_bitmap[] { + 0xc1, 0x80, + 0x63, 0x00, + 0x36, 0x00, + 0x36, 0x00, + 0x1c, 0x00, + 0x1c, 0x00, + 0x36, 0x00, + 0x32, 0x00, + 0x63, 0x00, + 0xc1, 0x80, +}; + +// Glyph data for 'x' +static struct glyph UbuntuMono_Regular_120_glyph { + .width = 9, + .width_bytes = 2, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_120_bitmap, +}; + +// Bitmap for 'y' +static uint8_t UbuntuMono_Regular_121_bitmap[] { + 0xc1, 0x80, + 0xc1, 0x80, + 0x63, 0x80, + 0x63, 0x00, + 0x63, 0x00, + 0x33, 0x00, + 0x33, 0x00, + 0x3e, 0x00, + 0x1e, 0x00, + 0x1e, 0x00, + 0x0e, 0x00, + 0x1c, 0x00, + 0xf8, 0x00, + 0xf0, 0x00, +}; + +// Glyph data for 'y' +static struct glyph UbuntuMono_Regular_121_glyph { + .width = 9, + .width_bytes = 2, + .height = 14, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_121_bitmap, +}; + +// Bitmap for 'z' +static uint8_t UbuntuMono_Regular_122_bitmap[] { + 0xfe, + 0xfe, + 0x0c, + 0x0c, + 0x18, + 0x30, + 0x60, + 0x60, + 0xfe, + 0xfe, +}; + +// Glyph data for 'z' +static struct glyph UbuntuMono_Regular_122_glyph { + .width = 7, + .width_bytes = 1, + .height = 10, + .height_bytes = 2, + .bitmap = UbuntuMono_Regular_122_bitmap, +}; + +// Bitmap for '{' +static uint8_t UbuntuMono_Regular_123_bitmap[] { + 0x1f, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x20, + 0xc0, + 0x20, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x1f, +}; + +// Glyph data for '{' +static struct glyph UbuntuMono_Regular_123_glyph { + .width = 8, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_123_bitmap, +}; + +// Bitmap for '|' +static uint8_t UbuntuMono_Regular_124_bitmap[] { + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, + 0xc0, +}; + +// Glyph data for '|' +static struct glyph UbuntuMono_Regular_124_glyph { + .width = 2, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_124_bitmap, +}; + +// Bitmap for '}' +static uint8_t UbuntuMono_Regular_125_bitmap[] { + 0xf8, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x04, + 0x03, + 0x04, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0x0c, + 0xf8, +}; + +// Glyph data for '}' +static struct glyph UbuntuMono_Regular_125_glyph { + .width = 8, + .width_bytes = 1, + .height = 19, + .height_bytes = 3, + .bitmap = UbuntuMono_Regular_125_bitmap, +}; + +// Bitmap for '~' +static uint8_t UbuntuMono_Regular_126_bitmap[] { + 0x70, 0x80, + 0x79, 0x80, + 0xcf, 0x00, + 0x87, 0x00, +}; + +// Glyph data for '~' +static struct glyph UbuntuMono_Regular_126_glyph { + .width = 9, + .width_bytes = 2, + .height = 4, + .height_bytes = 1, + .bitmap = UbuntuMono_Regular_126_bitmap, +}; + +static struct font UbuntuMono_Regular { + .name = "UbuntuMono-Regular", +}; +