layer0/os_gl.cpp

#include"os_predef.h"
#include"os_gl.h"

#include<stdio.h>

void PyMOLReadPixels(GLint x,
                     GLint y,
                     GLsizei width,
                     GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
{

  /* special "safe" version of glReadPixels for buggy OpenGL implementations */

  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;

  /* Save current pixel store state. */
  glGetIntegerv(GL_PACK_SWAP_BYTES, &swapbytes);
  glGetIntegerv(GL_PACK_LSB_FIRST, &lsbfirst);
  glGetIntegerv(GL_PACK_ROW_LENGTH, &rowlength);
  glGetIntegerv(GL_PACK_SKIP_ROWS, &skiprows);
  glGetIntegerv(GL_PACK_SKIP_PIXELS, &skippixels);
  glGetIntegerv(GL_PACK_ALIGNMENT, &alignment);

  /* Set desired pixel store state. */
  glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
  glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
  glPixelStorei(GL_PACK_ROW_LENGTH, 0);
  glPixelStorei(GL_PACK_SKIP_ROWS, 0);
  glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);

  /* call glFlush & glFinish first to avoid full system crash on buggy
   * ATI Radeon drivers, such as Radeon 7000 & 9000 series.  (calling
   * both is probably redundant and ultra-paranoid, but so what?) */
  glFlush();
  glFinish();

  /* now get the pixels */
  glReadPixels(x, y, width, height, format, type, pixels);

  /* now flush once again just to be extra sure that we don't encounter
   * the dreaded ATI driver bug system freeze-up */
  glFlush();
  glFinish();

  /* and then estore current pixel store state. */
  glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes);
  glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst);
  glPixelStorei(GL_PACK_ROW_LENGTH, rowlength);
  glPixelStorei(GL_PACK_SKIP_ROWS, skiprows);
  glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels);
  glPixelStorei(GL_PACK_ALIGNMENT, alignment);

}

void PyMOLDrawPixels(GLsizei width,
                     GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
{

  /* special "safe" version of glDrawPixels for buggy OpenGL implementations */

  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;

  /* Save current pixel store state. */
  glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
  glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
  glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
  glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
  glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
  glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);

  /* Set desired pixel store state. */
  glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
  glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
  glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

  glDrawPixels(width, height, format, type, pixels);

  /* Restore current pixel store state. */
  glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
  glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
  glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
  glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
  glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
  glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);

}

int PyMOLCheckOpenGLErr(const char *pos)
{
  int flag = 0;
  GLenum glerr = glGetError();
  while(glerr != GL_NO_ERROR) {
    printf("OpenGL-Error: Where? %s: glerr=%d\n", pos, glerr);
    glerr = glGetError();
    flag = 1;
  }
  return flag;
}

#ifdef _PYMOL_NO_GLUT
#ifndef _MACPYMOL_XCODE
int p_glutGet(GLenum type)
{
  return 0;
}
#endif
#endif

#ifndef _PYMOL_NO_GLUT

#ifdef _PYMOL_PRETEND_GLUT_FONT
void plutBitmapCharacter(int c);
#endif

#ifdef _PYMOL_MIN_GLUT


/* NULL GLUT: Bare Minimum GLUT implementation for getting PyMOL up in 
   preparation for porting PYMOL to a non-GLUT environment (such as ActiveX)... */

#include<GL/glut.h>

static void (*idleFunc) (void) = NULL;
static int WinX = 640, WinY = 480;

int p_glutCreateWindow(const char *title)
{

  char **myArgv, *myArgvv[2], myArgvvv[1024] = "pymol";
  int myArgc;

  myArgc = 1;
  myArgvv[0] = myArgvvv;
  myArgvv[1] = (void *) 0;
  myArgv = myArgvv;

  glutInit(&myArgc, myArgv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
  glutInitWindowPosition(0, 175);
  glutInitWindowSize(WinX, WinY);

  return glutCreateWindow(title);
}

void p_glutMainLoop(void)
{
  while(1) {
    if(idleFunc)
      idleFunc();
  }

}

void p_glutGameModeString(char *str)
{
}

void p_glutEnterGameMode(void)
{
}

void p_glutLeaveGameMode(void)
{
}

void p_glutBitmapCharacter(void *font, int character)
{
}

void p_glutSwapBuffers(void)
{
}

void p_glutPopWindow(void)
{
}

void p_glutShowWindow(void)
{
}

void p_glutHideWindow(void)
{
}

void p_glutDestroyWindow(int theWindow)
{
}

void p_glutReshapeWindow(int width, int height)
{
  WinX = width;
  WinY = height;
}

void p_glutFullScreen(void)
{
}

void p_glutPostRedisplay(void)
{
}

void p_glutInit(int *argcp, char **argv)
{
}

void p_glutInitDisplayMode(unsigned int mode)
{
}

void p_glutInitDisplayString(const char *string)
{
}

void p_glutInitWindowPosition(int x, int y)
{
}

void p_glutInitWindowSize(int width, int height)
{
  WinX = width;
  WinY = height;
}

int p_glutGet(GLenum type)
{
  return 0;
}

int p_glutGetModifiers(void)
{
  return 0;
}

void p_glutDisplayFunc(void (*func) (void))
{
}

void p_glutReshapeFunc(void (*func) (int width, int height))
{
}

void p_glutKeyboardFunc(void (*func) (unsigned char key, int x, int y))
{
}

void p_glutMouseFunc(void (*func) (int button, int state, int x, int y))
{
}

void p_glutMotionFunc(void (*func) (int x, int y))
{
}

void p_glutPassiveMotionFunc(void (*func) (int x, int y))
{
}

void p_glutSpecialFunc(void (*func) (int key, int x, int y))
{
}

void p_glutIdleFunc(void (*func) (void))
{
  idleFunc = func;
}

void p_glutPositionWindow(int x, int y)
{
};

#endif

#ifdef _PYMOL_WX_GLUT

#include"P.h"
#include"main.h"


/* wxWindow-based GLUT emulation layer */

static void (*idleFunc) (void) = NULL;
static void (*displayFunc) (void) = NULL;
static void (*reshapeFunc) (int width, int height) = NULL;
static void (*mouseFunc) (int button, int state, int x, int y) = NULL;
static void (*keyboardFunc) (unsigned char key, int x, int y) = NULL;
static void (*specialFunc) (int key, int x, int y) = NULL;
static void (*motionFunc) (int x, int y) = NULL;
static void (*passiveMotionFunc) (int x, int y) = NULL;
static int WinX = 640, WinY = 480;

static int redisplay = true;
static int modifiers = 0;

int p_glutGetRedisplay(void)
{
  int tmp = redisplay;
  redisplay = false;
  return (tmp);
}

void p_glutGameModeString(char *str)
{
}

void p_glutEnterGameMode(void)
{
}

void p_glutLeaveGameMode(void)
{
}

void p_glutHandleEvent(p_glut_event * ev)
{
  /* NOTE: this function should be called with an unblocked interpreter,
     just as if it were an asychronous thread */

  modifiers = ev->mod;
  switch (ev->event_code) {
  case P_GLUT_IDLE_EVENT:
    if(idleFunc)
      idleFunc();
    break;
  case P_GLUT_DISPLAY_EVENT:
    if(displayFunc)
      displayFunc();
    break;
  case P_GLUT_RESHAPE_EVENT:
    if(reshapeFunc)
      reshapeFunc(ev->x, ev->y);
    break;
  case P_GLUT_MOUSE_EVENT:
    if(mouseFunc)
      mouseFunc(ev->input, ev->state, ev->x, ev->y);
    break;
  case P_GLUT_MOTION_EVENT:
    if(motionFunc)
      motionFunc(ev->x, ev->y);
    break;
  case P_GLUT_PASSIVE_MOTION_EVENT:
    if(passiveMotionFunc)
      passiveMotionFunc(ev->x, ev->y);
    break;
  case P_GLUT_CHAR_EVENT:
    if(keyboardFunc)
      keyboardFunc((unsigned char) ev->input, ev->x, ev->y);
    break;
  case P_GLUT_SPECIAL_EVENT:
    if(specialFunc)
      specialFunc(ev->input, ev->x, ev->y);
    break;
  }
}

int p_glutCreateWindow(const char *title)
{
  return 0;
}

void p_glutMainLoop(void)
{
  /* TRICK: for "pretend GLUT", this routine must return, so that the
     host windowing system can keep control of the main thread... */
}

void p_glutBitmapCharacter(void *font, int character)
{
#ifdef _PYMOL_PRETEND_GLUT_FONT
  plutBitmapCharacter(character);
#endif
}

void p_glutSwapBuffers(void)
{
  PBlockLegacy();
  PyRun_SimpleString("if hasattr(pymol,'_swap_buffers'): pymol._swap_buffers()");
  PUnblockLegacy();
}

void p_glutPopWindow(void)
{
}

void p_glutShowWindow(void)
{
}

void p_glutHideWindow(void)
{
}

void p_glutDestroyWindow(int theWindow)
{
}

void p_glutReshapeWindow(int width, int height)
{
  WinX = width;
  WinY = height;
}

void p_glutFullScreen(void)
{
}

void p_glutPostRedisplay(void)
{
  redisplay = true;
}

void p_glutInit(int *argcp, char **argv)
{
}

void p_glutInitDisplayMode(unsigned int mode)
{
}

void p_glutInitDisplayString(const char *string)
{
}

void p_glutInitWindowPosition(int x, int y)
{
}

void p_glutInitWindowSize(int width, int height)
{
  WinX = width;
  WinY = height;
}

int p_glutGet(GLenum type)
{
  return 0;
}

int p_glutGetModifiers(void)
{
  return modifiers;
}

void p_glutDisplayFunc(void (*func) (void))
{
  displayFunc = func;
}

void p_glutReshapeFunc(void (*func) (int width, int height))
{
  reshapeFunc = func;
}

void p_glutKeyboardFunc(void (*func) (unsigned char key, int x, int y))
{
  keyboardFunc = func;
}

void p_glutMouseFunc(void (*func) (int button, int state, int x, int y))
{
  mouseFunc = func;
}

void p_glutMotionFunc(void (*func) (int x, int y))
{
  motionFunc = func;
}

void p_glutPassiveMotionFunc(void (*func) (int x, int y))
{
  passiveMotionFunc = func;
}

void p_glutSpecialFunc(void (*func) (int key, int x, int y))
{
  specialFunc = func;
}

void p_glutIdleFunc(void (*func) (void))
{
  idleFunc = func;
}

void p_glutPositionWindow(int x, int y)
{
};

#endif

#ifdef _PYMOL_PRETEND_GLUT_FONT


/* BEGIN GLUT EXCERPT.  THE FOLLOWING CODE IS:

 * Copyright (c) Mark J. Kilgard, 1994. 
 
 * This program is freely distributable without licensing fees 
 * and is provided without guarantee or warrantee expressed or 
 * implied. This program is -not- in the public domain. 

 * Modifications by Warren L. DeLano, 2002.  

*/

typedef struct {
  const GLsizei width;
  const GLsizei height;
  const GLfloat xorig;
  const GLfloat yorig;
  const GLfloat advance;
  const GLubyte *bitmap;
} BitmapCharRec, *BitmapCharPtr;

typedef struct {
  const char *name;
  const int num_chars;
  const int first;
  const BitmapCharRec *const *ch;
} BitmapFontRec, *BitmapFontPtr;

typedef void *PLUTbitmapFont;


/* GENERATED FILE -- DO NOT MODIFY */

#ifdef _WIN32


/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
   a height or width of zero does not advance the raster position
   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
static const GLubyte ch0data[] = { 0x0 };
static const BitmapCharRec ch0 = { 1, 1, 0, 0, 8, ch0data };
#else
static const BitmapCharRec ch0 = { 0, 0, 0, 0, 8, 0 };
#endif

#ifdef _WIN32


/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
   a height or width of zero does not advance the raster position
   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
static const GLubyte ch32data[] = { 0x0 };
static const BitmapCharRec ch32 = { 1, 1, 0, 0, 8, ch32data };
#else
static const BitmapCharRec ch32 = { 0, 0, 0, 0, 8, 0 };
#endif

#ifdef _WIN32


/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
   a height or width of zero does not advance the raster position
   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
static const GLubyte ch127data[] = { 0x0 };
static const BitmapCharRec ch127 = { 1, 1, 0, 0, 8, ch127data };
#else
static const BitmapCharRec ch127 = { 0, 0, 0, 0, 8, 0 };
#endif

#ifdef _WIN32


/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with
   a height or width of zero does not advance the raster position
   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */
static const GLubyte ch160data[] = { 0x0 };
static const BitmapCharRec ch160 = { 1, 1, 0, 0, 8, ch160data };
#else
static const BitmapCharRec ch160 = { 0, 0, 0, 0, 8, 0 };
#endif


/* char: 0xff */

static const GLubyte ch255data[] = {
  0x78, 0x84, 0x4, 0x74, 0x8c, 0x84, 0x84, 0x84, 0x0, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch255 = { 6, 12, -1, 2, 8, ch255data };


/* char: 0xfe */

static const GLubyte ch254data[] = {
  0x80, 0x80, 0xb8, 0xc4, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80,
};

static const BitmapCharRec ch254 = { 6, 10, -1, 2, 8, ch254data };


/* char: 0xfd */

static const GLubyte ch253data[] = {
  0x78, 0x84, 0x4, 0x74, 0x8c, 0x84, 0x84, 0x84, 0x0, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch253 = { 6, 12, -1, 2, 8, ch253data };


/* char: 0xfc */

static const GLubyte ch252data[] = {
  0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch252 = { 6, 10, -1, 0, 8, ch252data };


/* char: 0xfb */

static const GLubyte ch251data[] = {
  0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch251 = { 6, 10, -1, 0, 8, ch251data };


/* char: 0xfa */

static const GLubyte ch250data[] = {
  0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch250 = { 6, 10, -1, 0, 8, ch250data };


/* char: 0xf9 */

static const GLubyte ch249data[] = {
  0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x0, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch249 = { 6, 10, -1, 0, 8, ch249data };


/* char: 0xf8 */

static const GLubyte ch248data[] = {
  0x80, 0x78, 0xc4, 0xa4, 0x94, 0x8c, 0x78, 0x4,
};

static const BitmapCharRec ch248 = { 6, 8, -1, 1, 8, ch248data };


/* char: 0xf7 */

static const GLubyte ch247data[] = {
  0x20, 0x20, 0x0, 0xf8, 0x0, 0x20, 0x20,
};

static const BitmapCharRec ch247 = { 5, 7, -1, -1, 8, ch247data };


/* char: 0xf6 */

static const GLubyte ch246data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x0, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch246 = { 6, 10, -1, 0, 8, ch246data };


/* char: 0xf5 */

static const GLubyte ch245data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x0, 0x0, 0x50, 0x28,
};

static const BitmapCharRec ch245 = { 6, 10, -1, 0, 8, ch245data };


/* char: 0xf4 */

static const GLubyte ch244data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x0, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch244 = { 6, 10, -1, 0, 8, ch244data };


/* char: 0xf3 */

static const GLubyte ch243data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x0, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch243 = { 6, 10, -1, 0, 8, ch243data };


/* char: 0xf2 */

static const GLubyte ch242data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x0, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch242 = { 6, 10, -1, 0, 8, ch242data };


/* char: 0xf1 */

static const GLubyte ch241data[] = {
  0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8, 0x0, 0x0, 0x50, 0x28,
};

static const BitmapCharRec ch241 = { 6, 10, -1, 0, 8, ch241data };


/* char: 0xf0 */

static const GLubyte ch240data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x8, 0x50, 0x30, 0x48,
};

static const BitmapCharRec ch240 = { 6, 10, -1, 0, 8, ch240data };


/* char: 0xef */

static const GLubyte ch239data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x0, 0x0, 0x50, 0x50,
};

static const BitmapCharRec ch239 = { 5, 10, -1, 0, 8, ch239data };


/* char: 0xee */

static const GLubyte ch238data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x0, 0x0, 0x90, 0x60,
};

static const BitmapCharRec ch238 = { 5, 10, -1, 0, 8, ch238data };


/* char: 0xed */

static const GLubyte ch237data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x0, 0x0, 0x40, 0x20,
};

static const BitmapCharRec ch237 = { 5, 10, -1, 0, 8, ch237data };


/* char: 0xec */

static const GLubyte ch236data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x0, 0x0, 0x20, 0x40,
};

static const BitmapCharRec ch236 = { 5, 10, -1, 0, 8, ch236data };


/* char: 0xeb */

static const GLubyte ch235data[] = {
  0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x0, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch235 = { 6, 10, -1, 0, 8, ch235data };


/* char: 0xea */

static const GLubyte ch234data[] = {
  0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x0, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch234 = { 6, 10, -1, 0, 8, ch234data };


/* char: 0xe9 */

static const GLubyte ch233data[] = {
  0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x0, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch233 = { 6, 10, -1, 0, 8, ch233data };


/* char: 0xe8 */

static const GLubyte ch232data[] = {
  0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x0, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch232 = { 6, 10, -1, 0, 8, ch232data };


/* char: 0xe7 */

static const GLubyte ch231data[] = {
  0x20, 0x10, 0x78, 0x84, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch231 = { 6, 8, -1, 2, 8, ch231data };


/* char: 0xe6 */

static const GLubyte ch230data[] = {
  0x6c, 0x92, 0x90, 0x7c, 0x12, 0x6c,
};

static const BitmapCharRec ch230 = { 7, 6, 0, 0, 8, ch230data };


/* char: 0xe5 */

static const GLubyte ch229data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x30, 0x48, 0x30,
};

static const BitmapCharRec ch229 = { 6, 10, -1, 0, 8, ch229data };


/* char: 0xe4 */

static const GLubyte ch228data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch228 = { 6, 10, -1, 0, 8, ch228data };


/* char: 0xe3 */

static const GLubyte ch227data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x0, 0x50, 0x28,
};

static const BitmapCharRec ch227 = { 6, 10, -1, 0, 8, ch227data };


/* char: 0xe2 */

static const GLubyte ch226data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch226 = { 6, 10, -1, 0, 8, ch226data };


/* char: 0xe1 */

static const GLubyte ch225data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch225 = { 6, 10, -1, 0, 8, ch225data };


/* char: 0xe0 */

static const GLubyte ch224data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78, 0x0, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch224 = { 6, 10, -1, 0, 8, ch224data };


/* char: 0xdf */

static const GLubyte ch223data[] = {
  0x80, 0xb8, 0xc4, 0x84, 0x84, 0xf8, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch223 = { 6, 9, -1, 1, 8, ch223data };


/* char: 0xde */

static const GLubyte ch222data[] = {
  0x80, 0x80, 0x80, 0xf8, 0x84, 0x84, 0x84, 0xf8, 0x80,
};

static const BitmapCharRec ch222 = { 6, 9, -1, 0, 8, ch222data };


/* char: 0xdd */

static const GLubyte ch221data[] = {
  0x20, 0x20, 0x20, 0x20, 0x50, 0x88, 0x88, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch221 = { 5, 10, -1, 0, 8, ch221data };


/* char: 0xdc */

static const GLubyte ch220data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch220 = { 6, 10, -1, 0, 8, ch220data };


/* char: 0xdb */

static const GLubyte ch219data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch219 = { 6, 10, -1, 0, 8, ch219data };


/* char: 0xda */

static const GLubyte ch218data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch218 = { 6, 10, -1, 0, 8, ch218data };


/* char: 0xd9 */

static const GLubyte ch217data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch217 = { 6, 10, -1, 0, 8, ch217data };


/* char: 0xd8 */

static const GLubyte ch216data[] = {
  0x80, 0x78, 0xc4, 0xa4, 0xa4, 0xa4, 0x94, 0x94, 0x8c, 0x78, 0x4,
};

static const BitmapCharRec ch216 = { 6, 11, -1, 1, 8, ch216data };


/* char: 0xd7 */

static const GLubyte ch215data[] = {
  0x84, 0x48, 0x30, 0x30, 0x48, 0x84,
};

static const BitmapCharRec ch215 = { 6, 6, -1, -1, 8, ch215data };


/* char: 0xd6 */

static const GLubyte ch214data[] = {
  0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x0, 0x28, 0x28,
};

static const BitmapCharRec ch214 = { 7, 10, 0, 0, 8, ch214data };


/* char: 0xd5 */

static const GLubyte ch213data[] = {
  0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x0, 0x28, 0x14,
};

static const BitmapCharRec ch213 = { 7, 10, 0, 0, 8, ch213data };


/* char: 0xd4 */

static const GLubyte ch212data[] = {
  0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x0, 0x24, 0x18,
};

static const BitmapCharRec ch212 = { 7, 10, 0, 0, 8, ch212data };


/* char: 0xd3 */

static const GLubyte ch211data[] = {
  0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x0, 0x10, 0x8,
};

static const BitmapCharRec ch211 = { 7, 10, 0, 0, 8, ch211data };


/* char: 0xd2 */

static const GLubyte ch210data[] = {
  0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x0, 0x8, 0x10,
};

static const BitmapCharRec ch210 = { 7, 10, 0, 0, 8, ch210data };


/* char: 0xd1 */

static const GLubyte ch209data[] = {
  0x82, 0x86, 0x8a, 0x92, 0xa2, 0xc2, 0x82, 0x0, 0x28, 0x14,
};

static const BitmapCharRec ch209 = { 7, 10, 0, 0, 8, ch209data };


/* char: 0xd0 */

static const GLubyte ch208data[] = {
  0xfc, 0x42, 0x42, 0x42, 0xe2, 0x42, 0x42, 0x42, 0xfc,
};

static const BitmapCharRec ch208 = { 7, 9, 0, 0, 8, ch208data };


/* char: 0xcf */

static const GLubyte ch207data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x0, 0x50, 0x50,
};

static const BitmapCharRec ch207 = { 5, 10, -1, 0, 8, ch207data };


/* char: 0xce */

static const GLubyte ch206data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch206 = { 5, 10, -1, 0, 8, ch206data };


/* char: 0xcd */

static const GLubyte ch205data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch205 = { 5, 10, -1, 0, 8, ch205data };


/* char: 0xcc */

static const GLubyte ch204data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch204 = { 5, 10, -1, 0, 8, ch204data };


/* char: 0xcb */

static const GLubyte ch203data[] = {
  0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch203 = { 6, 10, -1, 0, 8, ch203data };


/* char: 0xca */

static const GLubyte ch202data[] = {
  0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch202 = { 6, 10, -1, 0, 8, ch202data };


/* char: 0xc9 */

static const GLubyte ch201data[] = {
  0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch201 = { 6, 10, -1, 0, 8, ch201data };


/* char: 0xc8 */

static const GLubyte ch200data[] = {
  0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch200 = { 6, 10, -1, 0, 8, ch200data };


/* char: 0xc7 */

static const GLubyte ch199data[] = {
  0x20, 0x10, 0x78, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch199 = { 6, 11, -1, 2, 8, ch199data };


/* char: 0xc6 */

static const GLubyte ch198data[] = {
  0x9e, 0x90, 0x90, 0xf0, 0x9c, 0x90, 0x90, 0x90, 0x6e,
};

static const BitmapCharRec ch198 = { 7, 9, 0, 0, 8, ch198data };


/* char: 0xc5 */

static const GLubyte ch197data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x30, 0x48, 0x30,
};

static const BitmapCharRec ch197 = { 6, 10, -1, 0, 8, ch197data };


/* char: 0xc4 */

static const GLubyte ch196data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x0, 0x48, 0x48,
};

static const BitmapCharRec ch196 = { 6, 10, -1, 0, 8, ch196data };


/* char: 0xc3 */

static const GLubyte ch195data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x0, 0x50, 0x28,
};

static const BitmapCharRec ch195 = { 6, 10, -1, 0, 8, ch195data };


/* char: 0xc2 */

static const GLubyte ch194data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x0, 0x48, 0x30,
};

static const BitmapCharRec ch194 = { 6, 10, -1, 0, 8, ch194data };


/* char: 0xc1 */

static const GLubyte ch193data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x0, 0x20, 0x10,
};

static const BitmapCharRec ch193 = { 6, 10, -1, 0, 8, ch193data };


/* char: 0xc0 */

static const GLubyte ch192data[] = {
  0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x0, 0x10, 0x20,
};

static const BitmapCharRec ch192 = { 6, 10, -1, 0, 8, ch192data };


/* char: 0xbf */

static const GLubyte ch191data[] = {
  0x78, 0x84, 0x84, 0x80, 0x40, 0x20, 0x20, 0x0, 0x20,
};

static const BitmapCharRec ch191 = { 6, 9, -1, 0, 8, ch191data };


/* char: 0xbe */

static const GLubyte ch190data[] = {
  0x6, 0x1a, 0x12, 0xa, 0x66, 0x92, 0x10, 0x20, 0x90, 0x60,
};

static const BitmapCharRec ch190 = { 7, 10, 0, 0, 8, ch190data };


/* char: 0xbd */

static const GLubyte ch189data[] = {
  0x1e, 0x10, 0xc, 0x2, 0xf2, 0x4c, 0x40, 0x40, 0xc0, 0x40,
};

static const BitmapCharRec ch189 = { 7, 10, 0, 0, 8, ch189data };


/* char: 0xbc */

static const GLubyte ch188data[] = {
  0x6, 0x1a, 0x12, 0xa, 0xe6, 0x42, 0x40, 0x40, 0xc0, 0x40,
};

static const BitmapCharRec ch188 = { 7, 10, 0, 0, 8, ch188data };


/* char: 0xbb */

static const GLubyte ch187data[] = {
  0x90, 0x48, 0x24, 0x12, 0x24, 0x48, 0x90,
};

static const BitmapCharRec ch187 = { 7, 7, 0, -1, 8, ch187data };


/* char: 0xba */

static const GLubyte ch186data[] = {
  0xf0, 0x0, 0x60, 0x90, 0x90, 0x60,
};

static const BitmapCharRec ch186 = { 4, 6, -1, -3, 8, ch186data };


/* char: 0xb9 */

static const GLubyte ch185data[] = {
  0xe0, 0x40, 0x40, 0x40, 0xc0, 0x40,
};

static const BitmapCharRec ch185 = { 3, 6, -1, -4, 8, ch185data };


/* char: 0xb8 */

static const GLubyte ch184data[] = {
  0xc0, 0x40,
};

static const BitmapCharRec ch184 = { 2, 2, -3, 2, 8, ch184data };


/* char: 0xb7 */

static const GLubyte ch183data[] = {
  0xc0,
};

static const BitmapCharRec ch183 = { 2, 1, -3, -4, 8, ch183data };


/* char: 0xb6 */

static const GLubyte ch182data[] = {
  0x28, 0x28, 0x28, 0x28, 0x68, 0xe8, 0xe8, 0xe8, 0x7c,
};

static const BitmapCharRec ch182 = { 6, 9, -1, 0, 8, ch182data };


/* char: 0xb5 */

static const GLubyte ch181data[] = {
  0x80, 0xb4, 0xcc, 0x84, 0x84, 0x84, 0x84,
};

static const BitmapCharRec ch181 = { 6, 7, -1, 1, 8, ch181data };


/* char: 0xb4 */

static const GLubyte ch180data[] = {
  0x80, 0x40,
};

static const BitmapCharRec ch180 = { 2, 2, -3, -8, 8, ch180data };


/* char: 0xb3 */

static const GLubyte ch179data[] = {
  0x60, 0x90, 0x10, 0x20, 0x90, 0x60,
};

static const BitmapCharRec ch179 = { 4, 6, -1, -4, 8, ch179data };


/* char: 0xb2 */

static const GLubyte ch178data[] = {
  0xf0, 0x80, 0x60, 0x10, 0x90, 0x60,
};

static const BitmapCharRec ch178 = { 4, 6, -1, -4, 8, ch178data };


/* char: 0xb1 */

static const GLubyte ch177data[] = {
  0xf8, 0x0, 0x20, 0x20, 0xf8, 0x20, 0x20,
};

static const BitmapCharRec ch177 = { 5, 7, -1, -1, 8, ch177data };


/* char: 0xb0 */

static const GLubyte ch176data[] = {
  0x60, 0x90, 0x90, 0x60,
};

static const BitmapCharRec ch176 = { 4, 4, -2, -5, 8, ch176data };


/* char: 0xaf */

static const GLubyte ch175data[] = {
  0xfc,
};

static const BitmapCharRec ch175 = { 6, 1, -1, -8, 8, ch175data };


/* char: 0xae */

static const GLubyte ch174data[] = {
  0x38, 0x44, 0xaa, 0xb2, 0xaa, 0xaa, 0x92, 0x44, 0x38,
};

static const BitmapCharRec ch174 = { 7, 9, 0, -1, 8, ch174data };


/* char: 0xad */

static const GLubyte ch173data[] = {
  0xfc,
};

static const BitmapCharRec ch173 = { 6, 1, -1, -4, 8, ch173data };


/* char: 0xac */

static const GLubyte ch172data[] = {
  0x4, 0x4, 0x4, 0xfc,
};

static const BitmapCharRec ch172 = { 6, 4, -1, -1, 8, ch172data };


/* char: 0xab */

static const GLubyte ch171data[] = {
  0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12,
};

static const BitmapCharRec ch171 = { 7, 7, 0, -1, 8, ch171data };


/* char: 0xaa */

static const GLubyte ch170data[] = {
  0xf8, 0x0, 0x78, 0x88, 0x78, 0x8, 0x70,
};

static const BitmapCharRec ch170 = { 5, 7, -1, -2, 8, ch170data };


/* char: 0xa9 */

static const GLubyte ch169data[] = {
  0x38, 0x44, 0x92, 0xaa, 0xa2, 0xaa, 0x92, 0x44, 0x38,
};

static const BitmapCharRec ch169 = { 7, 9, 0, -1, 8, ch169data };


/* char: 0xa8 */

static const GLubyte ch168data[] = {
  0xd8,
};

static const BitmapCharRec ch168 = { 5, 1, -1, -8, 8, ch168data };


/* char: 0xa7 */

static const GLubyte ch167data[] = {
  0x60, 0x90, 0x10, 0x60, 0x90, 0x90, 0x60, 0x80, 0x90, 0x60,
};

static const BitmapCharRec ch167 = { 4, 10, -2, 0, 8, ch167data };


/* char: 0xa6 */

static const GLubyte ch166data[] = {
  0x80, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch166 = { 1, 9, -3, 0, 8, ch166data };


/* char: 0xa5 */

static const GLubyte ch165data[] = {
  0x10, 0x10, 0x7c, 0x10, 0x7c, 0x28, 0x44, 0x82, 0x82,
};

static const BitmapCharRec ch165 = { 7, 9, 0, 0, 8, ch165data };


/* char: 0xa4 */

static const GLubyte ch164data[] = {
  0x84, 0x78, 0x48, 0x48, 0x78, 0x84,
};

static const BitmapCharRec ch164 = { 6, 6, -1, -1, 8, ch164data };


/* char: 0xa3 */

static const GLubyte ch163data[] = {
  0xdc, 0x62, 0x20, 0x20, 0x20, 0x70, 0x20, 0x22, 0x1c,
};

static const BitmapCharRec ch163 = { 7, 9, 0, 0, 8, ch163data };


/* char: 0xa2 */

static const GLubyte ch162data[] = {
  0x20, 0x70, 0xa8, 0xa0, 0xa0, 0xa8, 0x70, 0x20,
};

static const BitmapCharRec ch162 = { 5, 8, -1, -1, 8, ch162data };


/* char: 0xa1 */

static const GLubyte ch161data[] = {
  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x0, 0x80,
};

static const BitmapCharRec ch161 = { 1, 9, -3, 0, 8, ch161data };


/* char: 0x7e '~' */

static const GLubyte ch126data[] = {
  0x90, 0xa8, 0x48,
};

static const BitmapCharRec ch126 = { 5, 3, -1, -6, 8, ch126data };


/* char: 0x7d '}' */

static const GLubyte ch125data[] = {
  0xe0, 0x10, 0x10, 0x20, 0x18, 0x20, 0x10, 0x10, 0xe0,
};

static const BitmapCharRec ch125 = { 5, 9, -1, 0, 8, ch125data };


/* char: 0x7c '|' */

static const GLubyte ch124data[] = {
  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch124 = { 1, 9, -3, 0, 8, ch124data };


/* char: 0x7b '{' */

static const GLubyte ch123data[] = {
  0x38, 0x40, 0x40, 0x20, 0xc0, 0x20, 0x40, 0x40, 0x38,
};

static const BitmapCharRec ch123 = { 5, 9, -2, 0, 8, ch123data };


/* char: 0x7a 'z' */

static const GLubyte ch122data[] = {
  0xfc, 0x40, 0x20, 0x10, 0x8, 0xfc,
};

static const BitmapCharRec ch122 = { 6, 6, -1, 0, 8, ch122data };


/* char: 0x79 'y' */

static const GLubyte ch121data[] = {
  0x78, 0x84, 0x4, 0x74, 0x8c, 0x84, 0x84, 0x84,
};

static const BitmapCharRec ch121 = { 6, 8, -1, 2, 8, ch121data };


/* char: 0x78 'x' */

static const GLubyte ch120data[] = {
  0x84, 0x48, 0x30, 0x30, 0x48, 0x84,
};

static const BitmapCharRec ch120 = { 6, 6, -1, 0, 8, ch120data };


/* char: 0x77 'w' */

static const GLubyte ch119data[] = {
  0x44, 0xaa, 0x92, 0x92, 0x82, 0x82,
};

static const BitmapCharRec ch119 = { 7, 6, 0, 0, 8, ch119data };


/* char: 0x76 'v' */

static const GLubyte ch118data[] = {
  0x20, 0x50, 0x50, 0x88, 0x88, 0x88,
};

static const BitmapCharRec ch118 = { 5, 6, -1, 0, 8, ch118data };


/* char: 0x75 'u' */

static const GLubyte ch117data[] = {
  0x74, 0x88, 0x88, 0x88, 0x88, 0x88,
};

static const BitmapCharRec ch117 = { 6, 6, -1, 0, 8, ch117data };


/* char: 0x74 't' */

static const GLubyte ch116data[] = {
  0x38, 0x44, 0x40, 0x40, 0x40, 0xf8, 0x40, 0x40,
};

static const BitmapCharRec ch116 = { 6, 8, -1, 0, 8, ch116data };


/* char: 0x73 's' */

static const GLubyte ch115data[] = {
  0x78, 0x84, 0x18, 0x60, 0x84, 0x78,
};

static const BitmapCharRec ch115 = { 6, 6, -1, 0, 8, ch115data };


/* char: 0x72 'r' */

static const GLubyte ch114data[] = {
  0x40, 0x40, 0x40, 0x40, 0x44, 0xb8,
};

static const BitmapCharRec ch114 = { 6, 6, -1, 0, 8, ch114data };


/* char: 0x71 'q' */

static const GLubyte ch113data[] = {
  0x4, 0x4, 0x4, 0x74, 0x8c, 0x84, 0x8c, 0x74,
};

static const BitmapCharRec ch113 = { 6, 8, -1, 2, 8, ch113data };


/* char: 0x70 'p' */

static const GLubyte ch112data[] = {
  0x80, 0x80, 0x80, 0xb8, 0xc4, 0x84, 0xc4, 0xb8,
};

static const BitmapCharRec ch112 = { 6, 8, -1, 2, 8, ch112data };


/* char: 0x6f 'o' */

static const GLubyte ch111data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch111 = { 6, 6, -1, 0, 8, ch111data };


/* char: 0x6e 'n' */

static const GLubyte ch110data[] = {
  0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8,
};

static const BitmapCharRec ch110 = { 6, 6, -1, 0, 8, ch110data };


/* char: 0x6d 'm' */

static const GLubyte ch109data[] = {
  0x82, 0x92, 0x92, 0x92, 0x92, 0xec,
};

static const BitmapCharRec ch109 = { 7, 6, 0, 0, 8, ch109data };


/* char: 0x6c 'l' */

static const GLubyte ch108data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x60,
};

static const BitmapCharRec ch108 = { 5, 9, -1, 0, 8, ch108data };


/* char: 0x6b 'k' */

static const GLubyte ch107data[] = {
  0x84, 0x88, 0x90, 0xe0, 0x90, 0x88, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch107 = { 6, 9, -1, 0, 8, ch107data };


/* char: 0x6a 'j' */

static const GLubyte ch106data[] = {
  0x70, 0x88, 0x88, 0x8, 0x8, 0x8, 0x8, 0x18, 0x0, 0x8,
};

static const BitmapCharRec ch106 = { 5, 10, -1, 2, 8, ch106data };


/* char: 0x69 'i' */

static const GLubyte ch105data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x0, 0x20,
};

static const BitmapCharRec ch105 = { 5, 8, -1, 0, 8, ch105data };


/* char: 0x68 'h' */

static const GLubyte ch104data[] = {
  0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch104 = { 6, 9, -1, 0, 8, ch104data };


/* char: 0x67 'g' */

static const GLubyte ch103data[] = {
  0x78, 0x84, 0x78, 0x80, 0x70, 0x88, 0x88, 0x74,
};

static const BitmapCharRec ch103 = { 6, 8, -1, 2, 8, ch103data };


/* char: 0x66 'f' */

static const GLubyte ch102data[] = {
  0x40, 0x40, 0x40, 0x40, 0xf8, 0x40, 0x40, 0x44, 0x38,
};

static const BitmapCharRec ch102 = { 6, 9, -1, 0, 8, ch102data };


/* char: 0x65 'e' */

static const GLubyte ch101data[] = {
  0x78, 0x84, 0x80, 0xfc, 0x84, 0x78,
};

static const BitmapCharRec ch101 = { 6, 6, -1, 0, 8, ch101data };


/* char: 0x64 'd' */

static const GLubyte ch100data[] = {
  0x74, 0x8c, 0x84, 0x84, 0x8c, 0x74, 0x4, 0x4, 0x4,
};

static const BitmapCharRec ch100 = { 6, 9, -1, 0, 8, ch100data };


/* char: 0x63 'c' */

static const GLubyte ch99data[] = {
  0x78, 0x84, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch99 = { 6, 6, -1, 0, 8, ch99data };


/* char: 0x62 'b' */

static const GLubyte ch98data[] = {
  0xb8, 0xc4, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch98 = { 6, 9, -1, 0, 8, ch98data };


/* char: 0x61 'a' */

static const GLubyte ch97data[] = {
  0x74, 0x8c, 0x84, 0x7c, 0x4, 0x78,
};

static const BitmapCharRec ch97 = { 6, 6, -1, 0, 8, ch97data };


/* char: 0x60 '`' */

static const GLubyte ch96data[] = {
  0x10, 0x60, 0xe0,
};

static const BitmapCharRec ch96 = { 4, 3, -2, -6, 8, ch96data };


/* char: 0x5f '_' */

static const GLubyte ch95data[] = {
  0xfe,
};

static const BitmapCharRec ch95 = { 7, 1, 0, 1, 8, ch95data };


/* char: 0x5e '^' */

static const GLubyte ch94data[] = {
  0x88, 0x50, 0x20,
};

static const BitmapCharRec ch94 = { 5, 3, -1, -6, 8, ch94data };


/* char: 0x5d ']' */

static const GLubyte ch93data[] = {
  0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0,
};

static const BitmapCharRec ch93 = { 4, 9, -1, 0, 8, ch93data };


/* char: 0x5c '\' */

static const GLubyte ch92data[] = {
  0x2, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x80,
};

static const BitmapCharRec ch92 = { 7, 9, 0, 0, 8, ch92data };


/* char: 0x5b '[' */

static const GLubyte ch91data[] = {
  0xf0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xf0,
};

static const BitmapCharRec ch91 = { 4, 9, -2, 0, 8, ch91data };


/* char: 0x5a 'Z' */

static const GLubyte ch90data[] = {
  0xfc, 0x80, 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0xfc,
};

static const BitmapCharRec ch90 = { 6, 9, -1, 0, 8, ch90data };


/* char: 0x59 'Y' */

static const GLubyte ch89data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0x28, 0x44, 0x82, 0x82,
};

static const BitmapCharRec ch89 = { 7, 9, 0, 0, 8, ch89data };


/* char: 0x58 'X' */

static const GLubyte ch88data[] = {
  0x82, 0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x82,
};

static const BitmapCharRec ch88 = { 7, 9, 0, 0, 8, ch88data };


/* char: 0x57 'W' */

static const GLubyte ch87data[] = {
  0x44, 0xaa, 0x92, 0x92, 0x92, 0x82, 0x82, 0x82, 0x82,
};

static const BitmapCharRec ch87 = { 7, 9, 0, 0, 8, ch87data };


/* char: 0x56 'V' */

static const GLubyte ch86data[] = {
  0x10, 0x28, 0x28, 0x28, 0x44, 0x44, 0x44, 0x82, 0x82,
};

static const BitmapCharRec ch86 = { 7, 9, 0, 0, 8, ch86data };


/* char: 0x55 'U' */

static const GLubyte ch85data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
};

static const BitmapCharRec ch85 = { 6, 9, -1, 0, 8, ch85data };


/* char: 0x54 'T' */

static const GLubyte ch84data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xfe,
};

static const BitmapCharRec ch84 = { 7, 9, 0, 0, 8, ch84data };


/* char: 0x53 'S' */

static const GLubyte ch83data[] = {
  0x78, 0x84, 0x4, 0x4, 0x78, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch83 = { 6, 9, -1, 0, 8, ch83data };


/* char: 0x52 'R' */

static const GLubyte ch82data[] = {
  0x84, 0x88, 0x90, 0xa0, 0xf8, 0x84, 0x84, 0x84, 0xf8,
};

static const BitmapCharRec ch82 = { 6, 9, -1, 0, 8, ch82data };


/* char: 0x51 'Q' */

static const GLubyte ch81data[] = {
  0x4, 0x78, 0x94, 0xa4, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch81 = { 6, 10, -1, 1, 8, ch81data };


/* char: 0x50 'P' */

static const GLubyte ch80data[] = {
  0x80, 0x80, 0x80, 0x80, 0xf8, 0x84, 0x84, 0x84, 0xf8,
};

static const BitmapCharRec ch80 = { 6, 9, -1, 0, 8, ch80data };


/* char: 0x4f 'O' */

static const GLubyte ch79data[] = {
  0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch79 = { 6, 9, -1, 0, 8, ch79data };


/* char: 0x4e 'N' */

static const GLubyte ch78data[] = {
  0x84, 0x84, 0x84, 0x8c, 0x94, 0xa4, 0xc4, 0x84, 0x84,
};

static const BitmapCharRec ch78 = { 6, 9, -1, 0, 8, ch78data };


/* char: 0x4d 'M' */

static const GLubyte ch77data[] = {
  0x82, 0x82, 0x82, 0x92, 0x92, 0xaa, 0xc6, 0x82, 0x82,
};

static const BitmapCharRec ch77 = { 7, 9, 0, 0, 8, ch77data };


/* char: 0x4c 'L' */

static const GLubyte ch76data[] = {
  0xfc, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch76 = { 6, 9, -1, 0, 8, ch76data };


/* char: 0x4b 'K' */

static const GLubyte ch75data[] = {
  0x84, 0x88, 0x90, 0xa0, 0xc0, 0xa0, 0x90, 0x88, 0x84,
};

static const BitmapCharRec ch75 = { 6, 9, -1, 0, 8, ch75data };


/* char: 0x4a 'J' */

static const GLubyte ch74data[] = {
  0x70, 0x88, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x3c,
};

static const BitmapCharRec ch74 = { 6, 9, -1, 0, 8, ch74data };


/* char: 0x49 'I' */

static const GLubyte ch73data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8,
};

static const BitmapCharRec ch73 = { 5, 9, -1, 0, 8, ch73data };


/* char: 0x48 'H' */

static const GLubyte ch72data[] = {
  0x84, 0x84, 0x84, 0x84, 0xfc, 0x84, 0x84, 0x84, 0x84,
};

static const BitmapCharRec ch72 = { 6, 9, -1, 0, 8, ch72data };


/* char: 0x47 'G' */

static const GLubyte ch71data[] = {
  0x74, 0x8c, 0x84, 0x9c, 0x80, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch71 = { 6, 9, -1, 0, 8, ch71data };


/* char: 0x46 'F' */

static const GLubyte ch70data[] = {
  0x80, 0x80, 0x80, 0x80, 0xf0, 0x80, 0x80, 0x80, 0xfc,
};

static const BitmapCharRec ch70 = { 6, 9, -1, 0, 8, ch70data };


/* char: 0x45 'E' */

static const GLubyte ch69data[] = {
  0xfc, 0x80, 0x80, 0x80, 0xf0, 0x80, 0x80, 0x80, 0xfc,
};

static const BitmapCharRec ch69 = { 6, 9, -1, 0, 8, ch69data };


/* char: 0x44 'D' */

static const GLubyte ch68data[] = {
  0xfc, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0xfc,
};

static const BitmapCharRec ch68 = { 7, 9, 0, 0, 8, ch68data };


/* char: 0x43 'C' */

static const GLubyte ch67data[] = {
  0x78, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80, 0x84, 0x78,
};

static const BitmapCharRec ch67 = { 6, 9, -1, 0, 8, ch67data };


/* char: 0x42 'B' */

static const GLubyte ch66data[] = {
  0xfc, 0x42, 0x42, 0x42, 0x7c, 0x42, 0x42, 0x42, 0xfc,
};

static const BitmapCharRec ch66 = { 7, 9, 0, 0, 8, ch66data };


/* char: 0x41 'A' */

static const GLubyte ch65data[] = {
  0x84, 0x84, 0x84, 0xfc, 0x84, 0x84, 0x84, 0x48, 0x30,
};

static const BitmapCharRec ch65 = { 6, 9, -1, 0, 8, ch65data };


/* char: 0x40 '@' */

static const GLubyte ch64data[] = {
  0x78, 0x80, 0x94, 0xac, 0xa4, 0x9c, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch64 = { 6, 9, -1, 0, 8, ch64data };


/* char: 0x3f '?' */

static const GLubyte ch63data[] = {
  0x10, 0x0, 0x10, 0x10, 0x8, 0x4, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch63 = { 6, 9, -1, 0, 8, ch63data };


/* char: 0x3e '>' */

static const GLubyte ch62data[] = {
  0x80, 0x40, 0x20, 0x10, 0x8, 0x10, 0x20, 0x40, 0x80,
};

static const BitmapCharRec ch62 = { 5, 9, -1, 0, 8, ch62data };


/* char: 0x3d '=' */

static const GLubyte ch61data[] = {
  0xfc, 0x0, 0x0, 0xfc,
};

static const BitmapCharRec ch61 = { 6, 4, -1, -2, 8, ch61data };


/* char: 0x3c '<' */

static const GLubyte ch60data[] = {
  0x8, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x8,
};

static const BitmapCharRec ch60 = { 5, 9, -2, 0, 8, ch60data };


/* char: 0x3b ';' */

static const GLubyte ch59data[] = {
  0x80, 0x60, 0x70, 0x0, 0x0, 0x20, 0x70, 0x20,
};

static const BitmapCharRec ch59 = { 4, 8, -1, 1, 8, ch59data };


/* char: 0x3a ':' */

static const GLubyte ch58data[] = {
  0x40, 0xe0, 0x40, 0x0, 0x0, 0x40, 0xe0, 0x40,
};

static const BitmapCharRec ch58 = { 3, 8, -2, 1, 8, ch58data };


/* char: 0x39 '9' */

static const GLubyte ch57data[] = {
  0x70, 0x8, 0x4, 0x4, 0x74, 0x8c, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch57 = { 6, 9, -1, 0, 8, ch57data };


/* char: 0x38 '8' */

static const GLubyte ch56data[] = {
  0x78, 0x84, 0x84, 0x84, 0x78, 0x84, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch56 = { 6, 9, -1, 0, 8, ch56data };


/* char: 0x37 '7' */

static const GLubyte ch55data[] = {
  0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x8, 0x4, 0xfc,
};

static const BitmapCharRec ch55 = { 6, 9, -1, 0, 8, ch55data };


/* char: 0x36 '6' */

static const GLubyte ch54data[] = {
  0x78, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x40, 0x38,
};

static const BitmapCharRec ch54 = { 6, 9, -1, 0, 8, ch54data };


/* char: 0x35 '5' */

static const GLubyte ch53data[] = {
  0x78, 0x84, 0x4, 0x4, 0xc4, 0xb8, 0x80, 0x80, 0xfc,
};

static const BitmapCharRec ch53 = { 6, 9, -1, 0, 8, ch53data };


/* char: 0x34 '4' */

static const GLubyte ch52data[] = {
  0x8, 0x8, 0xfc, 0x88, 0x88, 0x48, 0x28, 0x18, 0x8,
};

static const BitmapCharRec ch52 = { 6, 9, -1, 0, 8, ch52data };


/* char: 0x33 '3' */

static const GLubyte ch51data[] = {
  0x78, 0x84, 0x4, 0x4, 0x38, 0x10, 0x8, 0x4, 0xfc,
};

static const BitmapCharRec ch51 = { 6, 9, -1, 0, 8, ch51data };


/* char: 0x32 '2' */

static const GLubyte ch50data[] = {
  0xfc, 0x80, 0x40, 0x30, 0x8, 0x4, 0x84, 0x84, 0x78,
};

static const BitmapCharRec ch50 = { 6, 9, -1, 0, 8, ch50data };


/* char: 0x31 '1' */

static const GLubyte ch49data[] = {
  0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0, 0x60, 0x20,
};

static const BitmapCharRec ch49 = { 5, 9, -1, 0, 8, ch49data };


/* char: 0x30 '0' */

static const GLubyte ch48data[] = {
  0x30, 0x48, 0x84, 0x84, 0x84, 0x84, 0x84, 0x48, 0x30,
};

static const BitmapCharRec ch48 = { 6, 9, -1, 0, 8, ch48data };


/* char: 0x2f '/' */

static const GLubyte ch47data[] = {
  0x80, 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x2,
};

static const BitmapCharRec ch47 = { 7, 9, 0, 0, 8, ch47data };


/* char: 0x2e '.' */

static const GLubyte ch46data[] = {
  0x40, 0xe0, 0x40,
};

static const BitmapCharRec ch46 = { 3, 3, -2, 1, 8, ch46data };


/* char: 0x2d '-' */

static const GLubyte ch45data[] = {
  0xfc,
};

static const BitmapCharRec ch45 = { 6, 1, -1, -4, 8, ch45data };


/* char: 0x2c ',' */

static const GLubyte ch44data[] = {
  0x80, 0x60, 0x70,
};

static const BitmapCharRec ch44 = { 4, 3, -1, 1, 8, ch44data };


/* char: 0x2b '+' */

static const GLubyte ch43data[] = {
  0x20, 0x20, 0xf8, 0x20, 0x20,
};

static const BitmapCharRec ch43 = { 5, 5, -1, -2, 8, ch43data };


/* char: 0x2a '*' */

static const GLubyte ch42data[] = {
  0x48, 0x30, 0xfc, 0x30, 0x48,
};

static const BitmapCharRec ch42 = { 6, 5, -1, -2, 8, ch42data };


/* char: 0x29 ')' */

static const GLubyte ch41data[] = {
  0x80, 0x40, 0x40, 0x20, 0x20, 0x20, 0x40, 0x40, 0x80,
};

static const BitmapCharRec ch41 = { 3, 9, -2, 0, 8, ch41data };


/* char: 0x28 '(' */

static const GLubyte ch40data[] = {
  0x20, 0x40, 0x40, 0x80, 0x80, 0x80, 0x40, 0x40, 0x20,
};

static const BitmapCharRec ch40 = { 3, 9, -3, 0, 8, ch40data };


/* char: 0x27 ''' */

static const GLubyte ch39data[] = {
  0x80, 0x60, 0x70,
};

static const BitmapCharRec ch39 = { 4, 3, -1, -6, 8, ch39data };


/* char: 0x26 '&' */

static const GLubyte ch38data[] = {
  0x74, 0x88, 0x94, 0x60, 0x90, 0x90, 0x60,
};

static const BitmapCharRec ch38 = { 6, 7, -1, 0, 8, ch38data };


/* char: 0x25 '%' */

static const GLubyte ch37data[] = {
  0x88, 0x54, 0x48, 0x20, 0x10, 0x10, 0x48, 0xa4, 0x44,
};

static const BitmapCharRec ch37 = { 6, 9, -1, 0, 8, ch37data };


/* char: 0x24 '$' */

static const GLubyte ch36data[] = {
  0x20, 0xf0, 0x28, 0x70, 0xa0, 0x78, 0x20,
};

static const BitmapCharRec ch36 = { 5, 7, -1, -1, 8, ch36data };


/* char: 0x23 '#' */

static const GLubyte ch35data[] = {
  0x48, 0x48, 0xfc, 0x48, 0xfc, 0x48, 0x48,
};

static const BitmapCharRec ch35 = { 6, 7, -1, -1, 8, ch35data };


/* char: 0x22 '"' */

static const GLubyte ch34data[] = {
  0x90, 0x90, 0x90,
};

static const BitmapCharRec ch34 = { 4, 3, -2, -6, 8, ch34data };


/* char: 0x21 '!' */

static const GLubyte ch33data[] = {
  0x80, 0x0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch33 = { 1, 9, -3, 0, 8, ch33data };


/* char: 0x1f */

static const GLubyte ch31data[] = {
  0x80,
};

static const BitmapCharRec ch31 = { 1, 1, -3, -3, 8, ch31data };


/* char: 0x1e */

static const GLubyte ch30data[] = {
  0xdc, 0x62, 0x20, 0x20, 0x20, 0x70, 0x20, 0x22, 0x1c,
};

static const BitmapCharRec ch30 = { 7, 9, 0, 0, 8, ch30data };


/* char: 0x1d */

static const GLubyte ch29data[] = {
  0x80, 0x40, 0xfe, 0x10, 0xfe, 0x4, 0x2,
};

static const BitmapCharRec ch29 = { 7, 7, 0, 0, 8, ch29data };


/* char: 0x1c */

static const GLubyte ch28data[] = {
  0x88, 0x48, 0x48, 0x48, 0x48, 0xfc,
};

static const BitmapCharRec ch28 = { 6, 6, -1, 0, 8, ch28data };


/* char: 0x1b */

static const GLubyte ch27data[] = {
  0xfe, 0x80, 0x20, 0x8, 0x2, 0x8, 0x20, 0x80,
};

static const BitmapCharRec ch27 = { 7, 8, 0, 0, 8, ch27data };


/* char: 0x1a */

static const GLubyte ch26data[] = {
  0xfe, 0x2, 0x8, 0x20, 0x80, 0x20, 0x8, 0x2,
};

static const BitmapCharRec ch26 = { 7, 8, 0, 0, 8, ch26data };


/* char: 0x19 */

static const GLubyte ch25data[] = {
  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch25 = { 1, 13, -3, 2, 8, ch25data };


/* char: 0x18 */

static const GLubyte ch24data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0xff,
};

static const BitmapCharRec ch24 = { 8, 6, 0, 2, 8, ch24data };


/* char: 0x17 */

static const GLubyte ch23data[] = {
  0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
};

static const BitmapCharRec ch23 = { 8, 8, 0, -3, 8, ch23data };


/* char: 0x16 */

static const GLubyte ch22data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
};

static const BitmapCharRec ch22 = { 4, 13, 0, 2, 8, ch22data };


/* char: 0x15 */

static const GLubyte ch21data[] = {
  0x80, 0x80, 0x80, 0x80, 0x80, 0xf8, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch21 = { 5, 13, -3, 2, 8, ch21data };


/* char: 0x14 */

static const GLubyte ch20data[] = {
  0xff,
};

static const BitmapCharRec ch20 = { 8, 1, 0, 1, 8, ch20data };


/* char: 0x13 */

static const GLubyte ch19data[] = {
  0xff,
};

static const BitmapCharRec ch19 = { 8, 1, 0, -1, 8, ch19data };


/* char: 0x12 */

static const GLubyte ch18data[] = {
  0xff,
};

static const BitmapCharRec ch18 = { 8, 1, 0, -3, 8, ch18data };


/* char: 0x11 */

static const GLubyte ch17data[] = {
  0xff,
};

static const BitmapCharRec ch17 = { 8, 1, 0, -5, 8, ch17data };


/* char: 0x10 */

static const GLubyte ch16data[] = {
  0xff,
};

static const BitmapCharRec ch16 = { 8, 1, 0, -7, 8, ch16data };


/* char: 0xf */

static const GLubyte ch15data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
};

static const BitmapCharRec ch15 = { 8, 13, 0, 2, 8, ch15data };


/* char: 0xe */

static const GLubyte ch14data[] = {
  0xf8, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch14 = { 5, 8, -3, -3, 8, ch14data };


/* char: 0xd */

static const GLubyte ch13data[] = {
  0x80, 0x80, 0x80, 0x80, 0x80, 0xf8,
};

static const BitmapCharRec ch13 = { 5, 6, -3, 2, 8, ch13data };


/* char: 0xc */

static const GLubyte ch12data[] = {
  0x10, 0x10, 0x10, 0x10, 0x10, 0xf0,
};

static const BitmapCharRec ch12 = { 4, 6, 0, 2, 8, ch12data };


/* char: 0xb */

static const GLubyte ch11data[] = {
  0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
};

static const BitmapCharRec ch11 = { 4, 8, 0, -3, 8, ch11data };


/* char: 0xa */

static const GLubyte ch10data[] = {
  0x8, 0x8, 0x8, 0x8, 0x3e, 0x20, 0x50, 0x88, 0x88,
};

static const BitmapCharRec ch10 = { 7, 9, 0, 2, 8, ch10data };


/* char: 0x9 */

static const GLubyte ch9data[] = {
  0x3e, 0x20, 0x20, 0x20, 0x88, 0x98, 0xa8, 0xc8, 0x88,
};

static const BitmapCharRec ch9 = { 7, 9, 0, 2, 8, ch9data };


/* char: 0x8 */

static const GLubyte ch8data[] = {
  0xfe, 0x10, 0x10, 0xfe, 0x10, 0x10,
};

static const BitmapCharRec ch8 = { 7, 6, 0, 0, 8, ch8data };


/* char: 0x7 */

static const GLubyte ch7data[] = {
  0x70, 0x88, 0x88, 0x70,
};

static const BitmapCharRec ch7 = { 5, 4, -1, -5, 8, ch7data };


/* char: 0x6 */

static const GLubyte ch6data[] = {
  0x20, 0x20, 0x3c, 0x20, 0x3e, 0xf8, 0x80, 0x80, 0x80,
};

static const BitmapCharRec ch6 = { 7, 9, 0, 2, 8, ch6data };


/* char: 0x5 */

static const GLubyte ch5data[] = {
  0x22, 0x22, 0x3c, 0x22, 0x3c, 0x78, 0x80, 0x80, 0x78,
};

static const BitmapCharRec ch5 = { 7, 9, 0, 2, 8, ch5data };


/* char: 0x4 */

static const GLubyte ch4data[] = {
  0x10, 0x10, 0x1c, 0x10, 0x9e, 0x80, 0xe0, 0x80, 0xf0,
};

static const BitmapCharRec ch4 = { 7, 9, 0, 2, 8, ch4data };


/* char: 0x3 */

static const GLubyte ch3data[] = {
  0x8, 0x8, 0x8, 0x3e, 0x88, 0x88, 0xf8, 0x88, 0x88,
};

static const BitmapCharRec ch3 = { 7, 9, 0, 2, 8, ch3data };


/* char: 0x2 */

static const GLubyte ch2data[] = {
  0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa,
};

static const BitmapCharRec ch2 = { 8, 12, 0, 2, 8, ch2data };


/* char: 0x1 */

static const GLubyte ch1data[] = {
  0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10,
};

static const BitmapCharRec ch1 = { 7, 7, 0, -1, 8, ch1data };

static const BitmapCharRec *const chars[] = {
  &ch0,
  &ch1,
  &ch2,
  &ch3,
  &ch4,
  &ch5,
  &ch6,
  &ch7,
  &ch8,
  &ch9,
  &ch10,
  &ch11,
  &ch12,
  &ch13,
  &ch14,
  &ch15,
  &ch16,
  &ch17,
  &ch18,
  &ch19,
  &ch20,
  &ch21,
  &ch22,
  &ch23,
  &ch24,
  &ch25,
  &ch26,
  &ch27,
  &ch28,
  &ch29,
  &ch30,
  &ch31,
  &ch32,
  &ch33,
  &ch34,
  &ch35,
  &ch36,
  &ch37,
  &ch38,
  &ch39,
  &ch40,
  &ch41,
  &ch42,
  &ch43,
  &ch44,
  &ch45,
  &ch46,
  &ch47,
  &ch48,
  &ch49,
  &ch50,
  &ch51,
  &ch52,
  &ch53,
  &ch54,
  &ch55,
  &ch56,
  &ch57,
  &ch58,
  &ch59,
  &ch60,
  &ch61,
  &ch62,
  &ch63,
  &ch64,
  &ch65,
  &ch66,
  &ch67,
  &ch68,
  &ch69,
  &ch70,
  &ch71,
  &ch72,
  &ch73,
  &ch74,
  &ch75,
  &ch76,
  &ch77,
  &ch78,
  &ch79,
  &ch80,
  &ch81,
  &ch82,
  &ch83,
  &ch84,
  &ch85,
  &ch86,
  &ch87,
  &ch88,
  &ch89,
  &ch90,
  &ch91,
  &ch92,
  &ch93,
  &ch94,
  &ch95,
  &ch96,
  &ch97,
  &ch98,
  &ch99,
  &ch100,
  &ch101,
  &ch102,
  &ch103,
  &ch104,
  &ch105,
  &ch106,
  &ch107,
  &ch108,
  &ch109,
  &ch110,
  &ch111,
  &ch112,
  &ch113,
  &ch114,
  &ch115,
  &ch116,
  &ch117,
  &ch118,
  &ch119,
  &ch120,
  &ch121,
  &ch122,
  &ch123,
  &ch124,
  &ch125,
  &ch126,
  &ch127,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  &ch160,
  &ch161,
  &ch162,
  &ch163,
  &ch164,
  &ch165,
  &ch166,
  &ch167,
  &ch168,
  &ch169,
  &ch170,
  &ch171,
  &ch172,
  &ch173,
  &ch174,
  &ch175,
  &ch176,
  &ch177,
  &ch178,
  &ch179,
  &ch180,
  &ch181,
  &ch182,
  &ch183,
  &ch184,
  &ch185,
  &ch186,
  &ch187,
  &ch188,
  &ch189,
  &ch190,
  &ch191,
  &ch192,
  &ch193,
  &ch194,
  &ch195,
  &ch196,
  &ch197,
  &ch198,
  &ch199,
  &ch200,
  &ch201,
  &ch202,
  &ch203,
  &ch204,
  &ch205,
  &ch206,
  &ch207,
  &ch208,
  &ch209,
  &ch210,
  &ch211,
  &ch212,
  &ch213,
  &ch214,
  &ch215,
  &ch216,
  &ch217,
  &ch218,
  &ch219,
  &ch220,
  &ch221,
  &ch222,
  &ch223,
  &ch224,
  &ch225,
  &ch226,
  &ch227,
  &ch228,
  &ch229,
  &ch230,
  &ch231,
  &ch232,
  &ch233,
  &ch234,
  &ch235,
  &ch236,
  &ch237,
  &ch238,
  &ch239,
  &ch240,
  &ch241,
  &ch242,
  &ch243,
  &ch244,
  &ch245,
  &ch246,
  &ch247,
  &ch248,
  &ch249,
  &ch250,
  &ch251,
  &ch252,
  &ch253,
  &ch254,
  &ch255,
};

const BitmapFontRec plutBitmap8By13 = {
  "-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1",
  256,
  0,
  chars
};

void plutBitmapCharacter(int c)
{
  const BitmapCharRec *ch;
  BitmapFontPtr fontinfo;
  GLint swapbytes, lsbfirst, rowlength;
  GLint skiprows, skippixels, alignment;

  fontinfo = (BitmapFontPtr) & plutBitmap8By13;

  if(c < fontinfo->first || c >= fontinfo->first + fontinfo->num_chars)
    return;
  ch = fontinfo->ch[c - fontinfo->first];
  if(ch) {
    /* Save current modes. */
    glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
    glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
    glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
    glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
    glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
    glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
    /* Little endian machines (DEC Alpha for example) could
       benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE
       instead of GL_FALSE, but this would require changing the
       generated bitmaps too. */
    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glBitmap(ch->width, ch->height, ch->xorig, ch->yorig, ch->advance, 0, ch->bitmap);
    /* Restore saved modes. */
    glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
    glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
    glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
  }
}

#endif
#endif