Squashed commit of the following:

commit 1856230d9fa61710cce3e152b8d88b1269611a73
Author: José Fonseca <[email protected]>
Date:   Tue Jul 12 23:41:27 2011 +0100

    make: Use better var names on packaging.

commit d1ae72d0bd14e820ecfe9f8f27b316f9566ceb0c
Author: José Fonseca <[email protected]>
Date:   Tue Jul 12 23:38:21 2011 +0100

    make: Apply several of Dan Nicholson's suggestions.

commit f27cf8743ac9cbf4c0ad66aff0cd3f97efde97e4
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 14:18:20 2011 +0100

    make: Put back the tar.bz2 creation rule.

    Removed by accident.

commit 34983337f9d7db984e9f0117808274106d262110
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 11:59:29 2011 +0100

    make: Determine tarballs contents via git ls-files.

    The wildcards were a mess:
    - lots of files for non Linux platforms missing
    - several files listed and archived twice

    Using git-ls-files ensures things are not loss when making the tarballs.

commit 34a28ccbf459ed5710aafba5e7149e8291cb808c
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 11:07:14 2011 +0100

    glut: Remove GLUT source.

    Most distros ship freeglut, and most people don't care one vs the other,
    and it hasn't been really maintained.

    So it is better to have Mesa GLUT be revisioned and built separately
    from Mesa.

commit 5c26a2c3c0c7e95ef853e19d12d75c4f80137e7d
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 10:31:02 2011 +0100

    Ignore the tarballs.

commit 26edecac589819f0d0efe2165ab748dbc4e53394
Author: José Fonseca <[email protected]>
Date:   Sat Jul 9 10:30:24 2011 +0100

    make: Create the Mesa-xxx-devel symlink automatically.

    Also actually remote the intermediate uncompressed tarballs.

112 files changed, 0 insertions, 62099 deletions

diff --git a/src/SConscript b/src/SConscript
index 6d7bd6cd6ec..87e2444034c 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -25,7 +25,6 @@ if env['platform'] != 'embedded':
     SConscript('glx/SConscript')
     SConscript('egl/main/SConscript')
     SConscript('glu/sgi/SConscript')
-    SConscript('glut/glx/SConscript')
 
     if env['gles']:
         SConscript('mapi/shared-glapi/SConscript')
diff --git a/src/glut/beos/Makefile b/src/glut/beos/Makefile
deleted file mode 100644
index a9f8684c9bd..00000000000
--- a/src/glut/beos/Makefile
+++ /dev/null
@@ -1,99 +0,0 @@
-# Makefile for GLUT
-#
-# NOTICE:  The OpenGL Utility Toolkit (GLUT) distribution contains source
-# code published in a book titled "Programming OpenGL for the X Window
-# System" (ISBN: 0-201-48359-9) published by Addison-Wesley.  The
-# programs and associated files contained in the distribution were
-# developed by Mark J. Kilgard and are Copyright 1994, 1995, 1996 by Mark
-# J. Kilgard (unless otherwise noted).  The programs are not in the
-# public domain, but they are freely distributable without licensing
-# fees.  These programs are provided without guarantee or warrantee
-# expressed or implied.
-#
-# GLUT source included with Mesa with permission from Mark Kilgard.
-
-# src/glut/beos/Makefile
-
-TOP = ../../..
-include $(TOP)/configs/current
-
-GLUT_MAJOR = 3
-GLUT_MINOR = 7
-GLUT_TINY = 1
-
-CPP_SOURCES = \
-	glutBlocker.cpp \
-	glutInit.cpp \
-	glutWindow.cpp \
-	glutEvent.cpp \
-	glutCallback.cpp \
-	glutOverlay.cpp \
-	glutGet.cpp \
-	glutColor.cpp \
-	glutCursor.cpp \
-	glutMenu.cpp \
-	glutDstr.cpp \
-	beos_x11.cpp
-
-C_SOURCES = \
-	glut_8x13.c \
-	glut_9x15.c \
-	glut_bitmap.c \
-	glut_bwidth.c \
-	glut_hel10.c \
-	glut_hel12.c \
-	glut_hel18.c \
-	glut_tr10.c \
-	glut_tr24.c \
-	glut_mroman.c \
-	glut_roman.c \
-	glut_stroke.c \
-	glut_swidth.c \
-	glut_shapes.c \
-	glut_teapot.c \
-	glut_vidresize.c \
-	glut_util.c \
-	glut_ext.c
-
-OBJECTS = \
-	$(CPP_SOURCES:.cpp=.o) \
-	$(C_SOURCES:.c=.o)
-
-INCLUDES = \
-	-I. \
-	-I- \
-	-I$(TOP)/include
-
-# Rules
-
-.cpp.o:
-	$(CC) -c $< $(INCLUDES) $(CFLAGS) $(GLUT_CFLAGS) -o $@
-
-.c.o:
-	$(CC) -c $< $(INCLUDES) $(CFLAGS) $(GLUT_CFLAGS) -o $@
-
-
-# ---- TARGETS
-
-default: $(TOP)/$(LIB_DIR) $(TOP)/$(LIB_DIR)/$(GLUT_LIB_NAME)
-
-# Create the lib directory if missing
-$(TOP)/$(LIB_DIR):
-	mkdir $(TOP)/$(LIB_DIR)
-
-# Make the library
-$(TOP)/$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS)
-	@$(MKLIB) -o $(GLUT_LIB) -linker '$(CC)' -ldflags '$(LDFLAGS)' \
-		-major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \
-		-install $(TOP)/$(LIB_DIR) $(MKLIB_OPTIONS) \
-		$(GLUT_LIB_DEPS) $(OBJECTS)
-
-clean:
-	-rm -f *.o
-
-depend: $(SOURCES)
-	rm -f depend
-	touch depend
-	$(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(SOURCES) > /dev/null 
-
-include depend
diff --git a/src/glut/beos/beos_x11.cpp b/src/glut/beos/beos_x11.cpp
deleted file mode 100644
index 4f7ec48ac80..00000000000
--- a/src/glut/beos/beos_x11.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-#include <Screen.h>
-#include <stdio.h>
-#include "beos_x11.h"
-
-/* NOTE:  These functions require a BApplication to be instantiated first */
-int DisplayWidth() {
-	BScreen s;
-	return s.Frame().IntegerWidth() + 1;
-}
-
-int DisplayHeight() {
-	BScreen s;
-	return s.Frame().IntegerHeight() + 1;
-}
-
-/* the following function was stolen from the X sources as indicated. */
-
-/* Copyright 	Massachusetts Institute of Technology  1985, 1986, 1987 */
-
-/*
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation, and that the name of M.I.T. not be used in advertising or
-publicity pertaining to distribution of the software without specific,
-written prior permission.  M.I.T. makes no representations about the
-suitability of this software for any purpose.  It is provided "as is"
-without express or implied warranty.
-*/
-
-#if 0	// Not used currently...
-
-/* 
- *Returns pointer to first char ins search which is also in what, else NULL.
- */
-static char *strscan (char *search, char *what)
-{
-	int i, len = strlen (what);
-	char c;
-
-	while ((c = *(search++))) {
-		for (i = 0; i < len; i++)
-			if (c == what [i])
-				return (--search);
-	}
-	return (NULL);
-}
-
-#endif
-
-/*
- *    XParseGeometry parses strings of the form
- *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
- *   width, height, xoffset, and yoffset are unsigned integers.
- *   Example:  "=80x24+300-49"
- *   The equal sign is optional.
- *   It returns a bitmask that indicates which of the four values
- *   were actually found in the string.  For each value found,
- *   the corresponding argument is updated;  for each value
- *   not found, the corresponding argument is left unchanged. 
- */
-
-static int
-ReadInteger(char *string, char **NextString)
-{
-    register int Result = 0;
-    int Sign = 1;
-    
-    if (*string == '+')
-	string++;
-    else if (*string == '-')
-    {
-	string++;
-	Sign = -1;
-    }
-    for (; (*string >= '0') && (*string <= '9'); string++)
-    {
-	Result = (Result * 10) + (*string - '0');
-    }
-    *NextString = string;
-    if (Sign >= 0)
-	return (Result);
-    else
-	return (-Result);
-}
-
-int XParseGeometry (char *string, int *x, int *y, 
-					unsigned int *width, unsigned int *height)
-{
-	int mask = NoValue;
-	register char *strind;
-	unsigned int tempWidth=0, tempHeight=0;
-	int tempX=0, tempY=0;
-	char *nextCharacter;
-
-	if ( (string == NULL) || (*string == '\0')) return(mask);
-	if (*string == '=')
-		string++;  /* ignore possible '=' at beg of geometry spec */
-
-	strind = (char *)string;
-	if (*strind != '+' && *strind != '-' && *strind != 'x') {
-		tempWidth = ReadInteger(strind, &nextCharacter);
-		if (strind == nextCharacter) 
-		    return (0);
-		strind = nextCharacter;
-		mask |= WidthValue;
-	}
-
-	if (*strind == 'x' || *strind == 'X') {	
-		strind++;
-		tempHeight = ReadInteger(strind, &nextCharacter);
-		if (strind == nextCharacter)
-		    return (0);
-		strind = nextCharacter;
-		mask |= HeightValue;
-	}
-
-	if ((*strind == '+') || (*strind == '-')) {
-		if (*strind == '-') {
-  			strind++;
-			tempX = -ReadInteger(strind, &nextCharacter);
-			if (strind == nextCharacter)
-			    return (0);
-			strind = nextCharacter;
-			mask |= XNegative;
-
-		}
-		else
-		{	strind++;
-			tempX = ReadInteger(strind, &nextCharacter);
-			if (strind == nextCharacter)
-			    return(0);
-			strind = nextCharacter;
-		}
-		mask |= XValue;
-		if ((*strind == '+') || (*strind == '-')) {
-			if (*strind == '-') {
-				strind++;
-				tempY = -ReadInteger(strind, &nextCharacter);
-				if (strind == nextCharacter)
-			    	    return(0);
-				strind = nextCharacter;
-				mask |= YNegative;
-
-			}
-			else
-			{
-				strind++;
-				tempY = ReadInteger(strind, &nextCharacter);
-				if (strind == nextCharacter)
-			    	    return(0);
-				strind = nextCharacter;
-			}
-			mask |= YValue;
-		}
-	}
-	
-	/* If strind isn't at the end of the string the it's an invalid
-		geometry specification. */
-
-	if (*strind != '\0') return (0);
-
-	if (mask & XValue)
-	    *x = tempX;
- 	if (mask & YValue)
-	    *y = tempY;
-	if (mask & WidthValue)
-            *width = tempWidth;
-	if (mask & HeightValue)
-            *height = tempHeight;
-	return (mask);
-}
diff --git a/src/glut/beos/beos_x11.h b/src/glut/beos/beos_x11.h
deleted file mode 100644
index 966dddd5e02..00000000000
--- a/src/glut/beos/beos_x11.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef __beos_x11_h__
-#define __beos_x11_h__
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-/* 
- * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
- * value (x, y, width, height) was found in the parsed string.
-*/
-#define NoValue		0x0000
-#define XValue  	0x0001
-#define YValue		0x0002
-#define WidthValue  	0x0004
-#define HeightValue  	0x0008
-#define AllValues 	0x000F
-#define XNegative 	0x0010
-#define YNegative 	0x0020
-
-/* Function prototypes. */
-
-extern int DisplayWidth();
-extern int DisplayHeight();
-
-extern int XParseGeometry(
-  char* string,
-  int* x, int* y, 
-  unsigned int* width, unsigned int* height);
-
-#endif /* __beos_x11_h__ */
diff --git a/src/glut/beos/glutBlocker.cpp b/src/glut/beos/glutBlocker.cpp
deleted file mode 100644
index aa948522b9b..00000000000
--- a/src/glut/beos/glutBlocker.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/***********************************************************
- *	Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *  FILE:	glutBlocker.cpp
- *
- *	DESCRIPTION:	helper class for GLUT event loop.
- *		if a window receives an event, wake up the event loop.
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include "glutBlocker.h"
-
-/***********************************************************
- *	Global variable
- ***********************************************************/
-GlutBlocker gBlock;
-
-/***********************************************************
- *	Member functions
- ***********************************************************/
-GlutBlocker::GlutBlocker() {
-	gSem = create_sem(1, "gSem");
-	eSem = create_sem(0, "eSem");
-	events = false;
-	sleeping = false;
-}
-
-GlutBlocker::~GlutBlocker() {
-	delete_sem(eSem);
-	delete_sem(gSem);
-}
-
-void GlutBlocker::WaitEvent() {
-	acquire_sem(gSem);
-	if(!events) {			// wait for new event
-		sleeping = true;
-		release_sem(gSem);
-		acquire_sem(eSem);	// next event will release eSem
-	} else {
-		release_sem(gSem);
-	}
-}
-
-void GlutBlocker::WaitEvent(bigtime_t usecs) {
-	acquire_sem(gSem);
-	if(!events) {			// wait for new event
-		sleeping = true;
-		release_sem(gSem);
-		acquire_sem_etc(eSem, 1, B_TIMEOUT, usecs);	// wait for next event or timeout
-	} else {
-		release_sem(gSem);
-	}
-}
-
-void GlutBlocker::NewEvent() {
-	acquire_sem(gSem);
-	events = true;		// next call to WaitEvent returns immediately
-	if(sleeping) {
-		sleeping = false;
-		release_sem(eSem);	// if event loop is blocking, wake it up
-	}
-	release_sem(gSem);
-}
diff --git a/src/glut/beos/glutBlocker.h b/src/glut/beos/glutBlocker.h
deleted file mode 100644
index fc9e4cc309b..00000000000
--- a/src/glut/beos/glutBlocker.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *  FILE:	glutBlocker.h
- *
- *	DESCRIPTION:	helper class for GLUT event loop.
- *		if a window receives an event, wake up the event loop.
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <kernel/OS.h>
-
-/***********************************************************
- *	CLASS:	GlutBlocker
- *
- *	DESCRIPTION:  Fairly naive, but safe implementation.
- *		global semaphore controls access to state
- *		event semaphore blocks WaitEvent() call if necessary
- *		(this is basically a condition variable class)
- ***********************************************************/
-class GlutBlocker {
-public:
-	GlutBlocker();
-	~GlutBlocker();
-	void WaitEvent();		// wait for new event
-	void WaitEvent(bigtime_t usecs);	// wait with timeout
-	void NewEvent();		// new event from a window (may need to wakeup main thread)
-	void QuickNewEvent() { events = true; }	// new event from main thread
-	void ClearEvents() { events = false; }		// clear counter at beginning of event loop
-	bool PendingEvent() { return events; }		// XPending() equivalent
-private:
-	sem_id gSem;
-	sem_id eSem;
-	bool events;	// are there any new events?
-	bool sleeping;	// is someone sleeping on eSem?
-};
-
-/***********************************************************
- *	Global variable
- ***********************************************************/
-extern GlutBlocker gBlock;
diff --git a/src/glut/beos/glutCallback.cpp b/src/glut/beos/glutCallback.cpp
deleted file mode 100644
index cf3daaaf36f..00000000000
--- a/src/glut/beos/glutCallback.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutCallback.cpp
- *
- *	DESCRIPTION:	put all the callback setting routines in
- *		one place
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include "glutint.h"
-#include "glutState.h"
-
-/***********************************************************
- *	Window related callbacks
- ***********************************************************/
-void APIENTRY 
-glutDisplayFunc(GLUTdisplayCB displayFunc)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  if (!displayFunc)
-    __glutFatalError("NULL display callback not allowed in GLUT 3.0; update your code.");
-  gState.currentWindow->display = displayFunc;
-}
-
-void APIENTRY 
-glutKeyboardFunc(GLUTkeyboardCB keyboardFunc)
-{
-  gState.currentWindow->keyboard = keyboardFunc;
-}
-
-void APIENTRY 
-glutSpecialFunc(GLUTspecialCB specialFunc)
-{
-  gState.currentWindow->special = specialFunc;
-}
-
-void APIENTRY 
-glutMouseFunc(GLUTmouseCB mouseFunc)
-{
-  gState.currentWindow->mouse = mouseFunc;
-}
-
-void APIENTRY 
-glutMotionFunc(GLUTmotionCB motionFunc)
-{
-  gState.currentWindow->motion = motionFunc;
-}
-
-void APIENTRY 
-glutPassiveMotionFunc(GLUTpassiveCB passiveMotionFunc)
-{
-  gState.currentWindow->passive = passiveMotionFunc;
-}
-
-void APIENTRY 
-glutEntryFunc(GLUTentryCB entryFunc)
-{
-  gState.currentWindow->entry = entryFunc;
-  if (!entryFunc) {
-    gState.currentWindow->entryState = -1;
-  }
-}
-
-void APIENTRY
-glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc)
-{
-  gState.currentWindow->windowStatus = windowStatusFunc;
-}
-
-static void
-visibilityHelper(int status)
-{
-  if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED)
-    gState.currentWindow->visibility(GLUT_NOT_VISIBLE);
-  else
-    gState.currentWindow->visibility(GLUT_VISIBLE);
-}
-
-void APIENTRY 
-glutVisibilityFunc(GLUTvisibilityCB visibilityFunc)
-{
-  gState.currentWindow->visibility = visibilityFunc;
-  if (visibilityFunc)
-    glutWindowStatusFunc(visibilityHelper);
-  else
-    glutWindowStatusFunc(NULL);
-}
-
-void APIENTRY 
-glutReshapeFunc(GLUTreshapeCB reshapeFunc)
-{
-  if (reshapeFunc) {
-    gState.currentWindow->reshape = reshapeFunc;
-  } else {
-    gState.currentWindow->reshape = __glutDefaultReshape;
-  }
-}
-
-/***********************************************************
- *	General callbacks (timer callback in glutEvent.cpp)
- ***********************************************************/
-/* DEPRICATED, use glutMenuStatusFunc instead. */
-void APIENTRY
-glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
-{
-  gState.menuStatus = (GLUTmenuStatusCB) menuStateFunc;
-}
-
-void APIENTRY
-glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
-{
-  gState.menuStatus = menuStatusFunc;
-}
-
-void APIENTRY
-glutIdleFunc(GLUTidleCB idleFunc)
-{
-  gState.idle = idleFunc;
-}
-
-/***********************************************************
- *	Unsupported callbacks
- ***********************************************************/
-void APIENTRY
-glutOverlayDisplayFunc(GLUTdisplayCB displayFunc)
-{
-}
-
-void APIENTRY
-glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc)
-{
-}
-
-void APIENTRY
-glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc)
-{
-}
-
-void APIENTRY
-glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc)
-{
-}
-
-void APIENTRY
-glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc)
-{
-}
-
-void APIENTRY
-glutDialsFunc(GLUTdialsCB dialsFunc)
-{
-}
-
-void APIENTRY
-glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc)
-{
-}
-
-void APIENTRY
-glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc)
-{
-}
diff --git a/src/glut/beos/glutColor.cpp b/src/glut/beos/glutColor.cpp
deleted file mode 100644
index d9f7739ae5a..00000000000
--- a/src/glut/beos/glutColor.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutColor.cpp
- *
- *	DESCRIPTION:	we don't support indexed color, so this code is
- *		really simple
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include "glutint.h"
-
-void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue) {
-	__glutWarning("glutSetColor: current window is RGBA");
-}
-
-GLfloat glutGetColor(int cell, int component) {
-	__glutWarning("glutGetColor: current window is RGBA");
-	return -1.0;
-}
-
-void glutCopyColormap(int win) {
-	__glutWarning("glutCopyColormap: color index not supported in BeOS");
-}
diff --git a/src/glut/beos/glutCursor.cpp b/src/glut/beos/glutCursor.cpp
deleted file mode 100644
index 3081fff44b3..00000000000
--- a/src/glut/beos/glutCursor.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutCursor.cpp
- *
- *	DESCRIPTION:	code for handling custom mouse cursors
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include "glutint.h"
-#include "glutState.h"
-#include "glutCursors.h"
-
-static const unsigned char *cursorTable[] = {
-  XC_arrow,		  /* GLUT_CURSOR_RIGHT_ARROW */
-  XC_top_left_arrow,	  /* GLUT_CURSOR_LEFT_ARROW */
-  XC_hand1,		  /* GLUT_CURSOR_INFO */
-  XC_pirate,		  /* GLUT_CURSOR_DESTROY */
-  XC_question_arrow,	  /* GLUT_CURSOR_HELP */
-  XC_exchange,		  /* GLUT_CURSOR_CYCLE */
-  XC_spraycan,		  /* GLUT_CURSOR_SPRAY */
-  XC_watch,		  /* GLUT_CURSOR_WAIT */
-  XC_xterm,		  /* GLUT_CURSOR_TEXT */
-  XC_crosshair,		  /* GLUT_CURSOR_CROSSHAIR */
-  XC_sb_v_double_arrow,	  /* GLUT_CURSOR_UP_DOWN */
-  XC_sb_h_double_arrow,	  /* GLUT_CURSOR_LEFT_RIGHT */
-  XC_top_side,		  /* GLUT_CURSOR_TOP_SIDE */
-  XC_bottom_side,	  /* GLUT_CURSOR_BOTTOM_SIDE */
-  XC_left_side,		  /* GLUT_CURSOR_LEFT_SIDE */
-  XC_right_side,	  /* GLUT_CURSOR_RIGHT_SIDE */
-  XC_top_left_corner,	  /* GLUT_CURSOR_TOP_LEFT_CORNER */
-  XC_top_right_corner,	  /* GLUT_CURSOR_TOP_RIGHT_CORNER */
-  XC_bottom_right_corner, /* GLUT_CURSOR_BOTTOM_RIGHT_CORNER */
-  XC_bottom_left_corner,  /* GLUT_CURSOR_BOTTOM_LEFT_CORNER */
-};
-
-/***********************************************************
- *	FUNCTION:	glutSetCursor (4.13)
- *
- *	DESCRIPTION:  set a new mouse cursor for current window
- ***********************************************************/
-void glutSetCursor(int cursor) {
-	gState.currentWindow->Window()->Lock();
-	gState.currentWindow->cursor = cursor;
-	__glutSetCursor(cursor);
-	gState.currentWindow->Window()->Unlock();
-}
-
-/***********************************************************
- *	FUNCTION:	__glutSetCursor
- *
- *	DESCRIPTION:  the actual cursor changing routine
- ***********************************************************/
-void __glutSetCursor(int cursor) {
-	int realcursor = cursor;
-	if (cursor < 0 || cursor > GLUT_CURSOR_BOTTOM_LEFT_CORNER) {
-		switch(cursor) {
-		case GLUT_CURSOR_INHERIT:
-			return;		// don't change cursor
-		case GLUT_CURSOR_NONE:
-			// this hides the cursor until the user moves the mouse
-			// change it to HideCursor() AT YOUR OWN RISK!
-			be_app->ObscureCursor();
-			return;
-		case GLUT_CURSOR_FULL_CROSSHAIR:
-			realcursor = GLUT_CURSOR_CROSSHAIR;
-			break;
-		default:
-			__glutWarning("unknown cursor\n");
-			return;
-		}
-	}
-	be_app->SetCursor(cursorTable[realcursor]);
-}
-
-/***********************************************************
- *	FUNCTION:	glutWarpPointer (x.xx)
- *
- *	DESCRIPTION:  move the mouse pointer to a new location
- *		(note:  can't do this in BeOS!)
- ***********************************************************/
-void glutWarpPointer(int x, int y) { }
diff --git a/src/glut/beos/glutCursors.h b/src/glut/beos/glutCursors.h
deleted file mode 100644
index 59f6951e2df..00000000000
--- a/src/glut/beos/glutCursors.h
+++ /dev/null
@@ -1,3083 +0,0 @@
-/* cursors.h:  X Window standard cursor shapes */
-/* Generated by bdftobcursor */
-
-const unsigned char XC_X_cursor[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x70, 0xe,
-	0x78, 0x1e,
-	0x7c, 0x3e,
-	0x3e, 0x7c,
-	0x1f, 0xf8,
-	0xf, 0xf0,
-	0x7, 0xe0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x3e, 0x7c,
-	0x7c, 0x3e,
-	0x78, 0x1e,
-	0x70, 0xe,
-	0x0, 0x0,
-	/* mask */
-	0xf0, 0xf,
-	0xf8, 0x1f,
-	0xfc, 0x3f,
-	0xfe, 0x7f,
-	0x7f, 0xfe,
-	0x3f, 0xfc,
-	0x1f, 0xf8,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x7f, 0xfe,
-	0xfe, 0x7f,
-	0xfc, 0x3f,
-	0xf8, 0x1f,
-	0xf0, 0xf,
-};
-
-const unsigned char XC_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 2,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x60, 0x0,
-	0x78, 0x0,
-	0x3e, 0x0,
-	0x3f, 0x80,
-	0x1f, 0xe0,
-	0x1f, 0xf8,
-	0xf, 0x80,
-	0xf, 0xc0,
-	0x6, 0xe0,
-	0x6, 0x70,
-	0x2, 0x38,
-	0x2, 0x1c,
-	0x0, 0xe,
-	0x0, 0x4,
-	0x0, 0x0,
-	/* mask */
-	0xe0, 0x0,
-	0xf8, 0x0,
-	0xfe, 0x0,
-	0x7f, 0x80,
-	0x7f, 0xe0,
-	0x3f, 0xf8,
-	0x3f, 0xfc,
-	0x1f, 0xfc,
-	0x1f, 0xe0,
-	0xf, 0xf0,
-	0xf, 0xf8,
-	0x7, 0x7c,
-	0x7, 0x3e,
-	0x2, 0x1f,
-	0x0, 0xe,
-	0x0, 0x4,
-};
-
-const unsigned char XC_based_arrow_down[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0xf, 0xf0,
-	0x0, 0x0,
-	0xf, 0xf0,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x5, 0xa0,
-	0x3, 0xc0,
-	0x1, 0x80,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x7, 0xe0,
-	0x3, 0xc0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_based_arrow_up[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1, 0x80,
-	0x3, 0xc0,
-	0x5, 0xa0,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0xf, 0xf0,
-	0x0, 0x0,
-	0xf, 0xf0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1, 0x80,
-	0x3, 0xc0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_boat[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 2,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x80,
-	0x3, 0xe0,
-	0x6, 0x11,
-	0xff, 0xff,
-	0x18, 0x0,
-	0x4, 0x0,
-	0x2, 0x0,
-	0x3, 0xff,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0xe0,
-	0x3, 0xf0,
-	0x7, 0xf9,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x1f, 0xff,
-	0x7, 0xff,
-	0x3, 0xff,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_bogosity[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x38, 0x8e,
-	0x8, 0x88,
-	0x8, 0x88,
-	0x8, 0x88,
-	0x3f, 0xfe,
-	0x28, 0x8a,
-	0x28, 0x8a,
-	0x28, 0x8a,
-	0x28, 0x8a,
-	0x3f, 0xfe,
-	0x8, 0x88,
-	0x8, 0x88,
-	0x8, 0x88,
-	0x38, 0x8e,
-	0x0, 0x0,
-	/* mask */
-	0x7d, 0xdf,
-	0x7d, 0xdf,
-	0x7d, 0xdf,
-	0x1d, 0xdc,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7d, 0xdf,
-	0x7d, 0xdf,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x1d, 0xdc,
-	0x7d, 0xdf,
-	0x7d, 0xdf,
-	0x7d, 0xdf,
-};
-
-const unsigned char XC_bottom_left_corner[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	14, 15,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x10, 0x46,
-	0x8, 0x46,
-	0x4, 0x46,
-	0x2, 0x46,
-	0x1, 0x46,
-	0x0, 0xc6,
-	0x1f, 0xc6,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0xf,
-	0x0, 0xf,
-	0x30, 0xef,
-	0x38, 0xef,
-	0x1c, 0xef,
-	0xe, 0xef,
-	0x7, 0xef,
-	0x3, 0xef,
-	0x3f, 0xef,
-	0x3f, 0xef,
-	0x3f, 0xef,
-	0x0, 0xf,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-};
-
-const unsigned char XC_bottom_right_corner[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	14, 2,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x62, 0x8,
-	0x62, 0x10,
-	0x62, 0x20,
-	0x62, 0x40,
-	0x62, 0x80,
-	0x63, 0x0,
-	0x63, 0xf8,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x0,
-	/* mask */
-	0xf0, 0x0,
-	0xf0, 0x0,
-	0xf7, 0xc,
-	0xf7, 0x1c,
-	0xf7, 0x38,
-	0xf7, 0x70,
-	0xf7, 0xe0,
-	0xf7, 0xc0,
-	0xf7, 0xfc,
-	0xf7, 0xfc,
-	0xf7, 0xfc,
-	0xf0, 0x0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-};
-
-const unsigned char XC_bottom_side[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	14, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x8, 0x88,
-	0x4, 0x90,
-	0x2, 0xa0,
-	0x1, 0xc0,
-	0x0, 0x80,
-	0x0, 0x0,
-	0x3f, 0xfe,
-	0x3f, 0xfe,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x19, 0xcc,
-	0x1d, 0xdc,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-};
-
-const unsigned char XC_bottom_tee[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_box_spiral[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 7,	/* y,x of hotspot */
-	/* data */
-	0xff, 0xff,
-	0x0, 0x1,
-	0x7f, 0xfd,
-	0x40, 0x5,
-	0x5f, 0xf5,
-	0x50, 0x15,
-	0x57, 0xd5,
-	0x54, 0x55,
-	0x55, 0x55,
-	0x55, 0xd5,
-	0x54, 0x15,
-	0x57, 0xf5,
-	0x50, 0x5,
-	0x5f, 0xfd,
-	0x40, 0x1,
-	0x7f, 0xff,
-	/* mask */
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-};
-
-const unsigned char XC_center_ptr[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x81, 0x80,
-	0x1, 0x80,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x7, 0xe0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x19, 0x98,
-	0x11, 0x88,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x83, 0xc0,
-	0x3, 0xc0,
-	0x7, 0xe0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3b, 0xdc,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-};
-
-const unsigned char XC_circle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x3, 0xc0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x3c, 0x3c,
-	0x38, 0x1c,
-	0x70, 0xe,
-	0x70, 0xe,
-	0x70, 0xe,
-	0x70, 0xe,
-	0x38, 0x1c,
-	0x3c, 0x3c,
-	0x1f, 0xf8,
-	0xf, 0xf0,
-	0x3, 0xc0,
-	0x0, 0x0,
-	/* mask */
-	0x7, 0xe0,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0xfc, 0x3f,
-	0xf8, 0x1f,
-	0xf8, 0x1f,
-	0xf8, 0x1f,
-	0xf8, 0x1f,
-	0xfc, 0x3f,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x3f, 0xfc,
-	0x1f, 0xf8,
-	0x7, 0xe0,
-};
-
-const unsigned char XC_clock[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	3, 9,	/* y,x of hotspot */
-	/* data */
-	0x1f, 0xf8,
-	0x33, 0xcc,
-	0x66, 0x26,
-	0x49, 0x92,
-	0x48, 0xf2,
-	0x44, 0x22,
-	0x63, 0xc6,
-	0x3f, 0xfc,
-	0x29, 0x94,
-	0x29, 0x94,
-	0x29, 0x94,
-	0x2b, 0xd4,
-	0x69, 0x96,
-	0x78, 0x1e,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	/* mask */
-	0x1f, 0xfe,
-	0x39, 0xf7,
-	0x77, 0xdb,
-	0x6d, 0xed,
-	0x6f, 0xfd,
-	0x66, 0xf9,
-	0x73, 0xf3,
-	0x3f, 0xff,
-	0x35, 0xeb,
-	0x35, 0xeb,
-	0x35, 0xeb,
-	0x37, 0xfb,
-	0x75, 0xeb,
-	0x7c, 0xcf,
-	0x7f, 0xff,
-	0x7f, 0xff,
-};
-
-const unsigned char XC_coffee_mug[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	9, 8,	/* y,x of hotspot */
-	/* data */
-	0x8f, 0xf8,
-	0x10, 0x4,
-	0x60, 0x6,
-	0x58, 0xa,
-	0x47, 0xf2,
-	0x40, 0x3,
-	0x40, 0x3,
-	0x40, 0x2,
-	0x40, 0x2,
-	0x58, 0x9a,
-	0x55, 0x56,
-	0x55, 0xd7,
-	0x59, 0x5b,
-	0x40, 0x2,
-	0x40, 0x2,
-	0x3f, 0xfc,
-	/* mask */
-	0xf, 0xf8,
-	0x1f, 0xfc,
-	0xff, 0xfe,
-	0xff, 0xfe,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xfe,
-	0xff, 0xfe,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xfe,
-	0x3f, 0xfc,
-};
-
-const unsigned char XC_cross[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0xff, 0x7f,
-	0x0, 0x0,
-	0xff, 0x7f,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-};
-
-const unsigned char XC_cross_reverse[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x21, 0x42,
-	0x51, 0x45,
-	0x29, 0x4a,
-	0x15, 0x54,
-	0xb, 0x68,
-	0x5, 0x50,
-	0xfe, 0xbf,
-	0x1, 0x40,
-	0xfe, 0xbf,
-	0x5, 0x50,
-	0xb, 0x68,
-	0x15, 0x54,
-	0x29, 0x4a,
-	0x51, 0x45,
-	0x21, 0x42,
-	0x0, 0x0,
-	/* mask */
-	0x33, 0x66,
-	0xdb, 0x6d,
-	0x6f, 0x7b,
-	0x37, 0x76,
-	0x1b, 0x6c,
-	0xfd, 0x5f,
-	0xfe, 0x3f,
-	0x0, 0x80,
-	0xfe, 0x3f,
-	0xfd, 0x5f,
-	0x1b, 0x6c,
-	0x37, 0x76,
-	0x6f, 0x7b,
-	0xdb, 0x6d,
-	0x33, 0x66,
-	0x0, 0x0,
-};
-
-const unsigned char XC_crosshair[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0xff, 0x7f,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-};
-
-const unsigned char XC_diamond_cross[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x81, 0x40,
-	0x3, 0x60,
-	0x5, 0x50,
-	0x9, 0x48,
-	0x11, 0x44,
-	0x21, 0x42,
-	0x7f, 0x7f,
-	0x0, 0x0,
-	0x7f, 0x7f,
-	0x21, 0x42,
-	0x11, 0x44,
-	0x9, 0x48,
-	0x5, 0x50,
-	0x3, 0x60,
-	0x1, 0x40,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x1d, 0xdc,
-	0x39, 0xce,
-	0x71, 0xc7,
-	0xff, 0xff,
-	0xff, 0x7f,
-	0xff, 0xff,
-	0x71, 0xc7,
-	0x39, 0xce,
-	0x1d, 0xdc,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-};
-
-const unsigned char XC_dot[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x83, 0xc0,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0xf, 0xf0,
-	0xf, 0xf0,
-	0x3, 0xc0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x87, 0xe0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x7, 0xe0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_dotbox[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x7f, 0xfc,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x21, 0x84,
-	0x21, 0x84,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x20, 0x4,
-	0x3f, 0xfc,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x70, 0xe,
-	0x70, 0xe,
-	0x73, 0xce,
-	0x73, 0xce,
-	0x73, 0xce,
-	0x73, 0xce,
-	0x70, 0xe,
-	0x70, 0xe,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x0,
-};
-
-const unsigned char XC_double_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x81, 0x80,
-	0x3, 0xc0,
-	0x7, 0xe0,
-	0xd, 0xb0,
-	0x19, 0x98,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x19, 0x98,
-	0xd, 0xb0,
-	0x7, 0xe0,
-	0x3, 0xc0,
-	0x1, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x83, 0xc0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x1f, 0xf8,
-	0xf, 0xf0,
-	0x7, 0xe0,
-	0x3, 0xc0,
-};
-
-const unsigned char XC_draft_large[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 1,	/* y,x of hotspot */
-	/* data */
-	0xc0, 0x0,
-	0x30, 0x0,
-	0x3c, 0x0,
-	0x1f, 0x0,
-	0x1f, 0xc0,
-	0xf, 0xf0,
-	0xf, 0xfc,
-	0x7, 0x80,
-	0x7, 0x40,
-	0x3, 0x20,
-	0x3, 0x10,
-	0x1, 0x8,
-	0x1, 0x4,
-	0x0, 0x2,
-	0x0, 0x1,
-	0x0, 0x0,
-	/* mask */
-	0x60, 0x0,
-	0x78, 0x0,
-	0x7e, 0x0,
-	0x3f, 0x80,
-	0x1f, 0xe0,
-	0x1f, 0xf8,
-	0xf, 0xfe,
-	0xf, 0xfe,
-	0x7, 0xe0,
-	0x7, 0xf0,
-	0x3, 0xb8,
-	0x3, 0x9c,
-	0x1, 0x8e,
-	0x1, 0x87,
-	0x0, 0x3,
-	0x0, 0x1,
-};
-
-const unsigned char XC_draft_small[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 1,	/* y,x of hotspot */
-	/* data */
-	0x40, 0x0,
-	0x30, 0x0,
-	0x3c, 0x0,
-	0x1f, 0x0,
-	0x1f, 0xc0,
-	0xe, 0x0,
-	0xd, 0x0,
-	0x4, 0x80,
-	0x4, 0x40,
-	0x0, 0x20,
-	0x0, 0x10,
-	0x0, 0x8,
-	0x0, 0x4,
-	0x0, 0x2,
-	0x0, 0x1,
-	0x0, 0x0,
-	/* mask */
-	0x60, 0x0,
-	0x78, 0x0,
-	0x3e, 0x0,
-	0x3f, 0x80,
-	0x1f, 0xe0,
-	0x1f, 0xe0,
-	0xf, 0x80,
-	0xf, 0xc0,
-	0x6, 0xe0,
-	0x2, 0x70,
-	0x0, 0x38,
-	0x0, 0x1c,
-	0x0, 0xe,
-	0x0, 0x7,
-	0x0, 0x3,
-	0x0, 0x0,
-};
-
-const unsigned char XC_draped_box[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x7f, 0xfc,
-	0x22, 0x44,
-	0x26, 0x64,
-	0x2c, 0x34,
-	0x38, 0x1c,
-	0x21, 0x84,
-	0x21, 0x84,
-	0x38, 0x1c,
-	0x2c, 0x34,
-	0x26, 0x64,
-	0x22, 0x44,
-	0x3f, 0xfc,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x67, 0xe6,
-	0x6f, 0xf6,
-	0x7e, 0x7e,
-	0x7d, 0xbe,
-	0x7b, 0xde,
-	0x7b, 0xde,
-	0x7d, 0xbe,
-	0x7e, 0x7e,
-	0x6f, 0xf6,
-	0x67, 0xe6,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x0,
-};
-
-const unsigned char XC_exchange[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x7, 0xe2,
-	0xf, 0xf6,
-	0x18, 0x3e,
-	0x10, 0x12,
-	0x0, 0x32,
-	0x0, 0x7e,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x7e, 0x0,
-	0x4c, 0x0,
-	0x48, 0x8,
-	0x7c, 0x18,
-	0x6f, 0xf0,
-	0x47, 0xe0,
-	0x0, 0x0,
-	/* mask */
-	0x7, 0xe3,
-	0xf, 0xf7,
-	0x1f, 0xff,
-	0x3f, 0xff,
-	0x38, 0x3f,
-	0x30, 0xff,
-	0x0, 0xff,
-	0x0, 0xff,
-	0xff, 0x0,
-	0xff, 0x0,
-	0xfe, 0xc,
-	0xfc, 0x1c,
-	0xff, 0xfc,
-	0xff, 0xf8,
-	0xef, 0xf0,
-	0xc7, 0xe0,
-};
-
-const unsigned char XC_fleur[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x1, 0x80,
-	0x3, 0xc0,
-	0x7, 0xe0,
-	0x1, 0x80,
-	0x11, 0x88,
-	0x31, 0x8c,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x31, 0x8c,
-	0x11, 0x88,
-	0x1, 0x80,
-	0x7, 0xe0,
-	0x3, 0xc0,
-	0x1, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xc0,
-	0x7, 0xc0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0x17, 0xe8,
-	0x3b, 0xdc,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x3b, 0xdc,
-	0x17, 0xe8,
-	0xf, 0xf0,
-	0x7, 0xe0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-};
-
-const unsigned char XC_gobbler[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	2, 2,	/* y,x of hotspot */
-	/* data */
-	0x1e, 0x0,
-	0xe, 0x0,
-	0xcc, 0x1,
-	0xd, 0xf9,
-	0xf, 0xff,
-	0xc, 0x7f,
-	0xc, 0x3f,
-	0x1c, 0x6,
-	0xf, 0x0,
-	0x7, 0xf8,
-	0x0, 0x10,
-	0x0, 0x10,
-	0x0, 0x10,
-	0x0, 0x10,
-	0x0, 0x78,
-	0x0, 0x0,
-	/* mask */
-	0x3f, 0x0,
-	0x3f, 0x0,
-	0xff, 0x3,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x3f, 0xff,
-	0x3f, 0xff,
-	0x3f, 0xff,
-	0x3f, 0xff,
-	0x3f, 0xff,
-	0x1f, 0xfe,
-	0xf, 0xf8,
-	0x0, 0x38,
-	0x0, 0x38,
-	0x0, 0xfc,
-	0x0, 0xfc,
-};
-
-const unsigned char XC_gumby[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 14,	/* y,x of hotspot */
-	/* data */
-	0x0, 0xfc,
-	0x1, 0x8,
-	0x2, 0x13,
-	0x5, 0x57,
-	0x4, 0x13,
-	0x5, 0xd3,
-	0x3c, 0x1f,
-	0xfc, 0x1c,
-	0xe4, 0x10,
-	0xe4, 0x10,
-	0xf4, 0x90,
-	0xe4, 0x90,
-	0x4, 0x90,
-	0x8, 0x88,
-	0x10, 0x84,
-	0x1f, 0x7c,
-	/* mask */
-	0x0, 0xfc,
-	0x1, 0xfb,
-	0x3, 0xf7,
-	0x7, 0xff,
-	0x7, 0xf7,
-	0x3f, 0xf7,
-	0x7f, 0xff,
-	0xff, 0xff,
-	0xf7, 0xfc,
-	0xf7, 0xf0,
-	0xff, 0xf0,
-	0xf7, 0xf0,
-	0xe7, 0xf0,
-	0xf, 0xf8,
-	0x1f, 0xfc,
-	0x1f, 0x7c,
-};
-
-const unsigned char XC_hand1[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 2,	/* y,x of hotspot */
-	/* data */
-	0x30, 0x0,
-	0x3c, 0x0,
-	0xf, 0x0,
-	0x7, 0x80,
-	0x3, 0xc0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0x7, 0xf4,
-	0xf, 0xfe,
-	0xf, 0xfa,
-	0x7, 0xe0,
-	0x3, 0xe0,
-	0x0, 0x52,
-	0x0, 0x46,
-	0x0, 0x2c,
-	0x0, 0x18,
-	/* mask */
-	0xb8, 0x0,
-	0x3e, 0x0,
-	0x1f, 0x80,
-	0xf, 0xc0,
-	0x7, 0xe0,
-	0xf, 0xf0,
-	0x1f, 0xfc,
-	0x1f, 0xfe,
-	0x1f, 0xfe,
-	0x1f, 0xfe,
-	0xf, 0xfe,
-	0x7, 0xfe,
-	0x3, 0xfe,
-	0x0, 0xfe,
-	0x0, 0x7e,
-	0x0, 0x3c,
-};
-
-const unsigned char XC_hand2[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 15,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x1, 0xfe,
-	0x2, 0x1,
-	0x4, 0x7e,
-	0x8, 0x8,
-	0x8, 0x70,
-	0x8, 0x8,
-	0x14, 0x70,
-	0x22, 0x8,
-	0x41, 0x30,
-	0x20, 0xc0,
-	0x12, 0x40,
-	0x8, 0x80,
-	0x5, 0x0,
-	0x2, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xfe,
-	0x3, 0xff,
-	0x7, 0xff,
-	0xf, 0xff,
-	0x1f, 0xfe,
-	0x1f, 0xf8,
-	0x1f, 0xfc,
-	0x3f, 0xf8,
-	0x7f, 0xfc,
-	0xff, 0xf8,
-	0x7f, 0xf0,
-	0x3f, 0xe0,
-	0x1f, 0xc0,
-	0xf, 0x80,
-	0x7, 0x0,
-	0x2, 0x0,
-};
-
-const unsigned char XC_heart[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	9, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x1f, 0x7c,
-	0x31, 0xc6,
-	0x60, 0x83,
-	0x40, 0x1,
-	0x40, 0x1,
-	0x40, 0x1,
-	0x40, 0x1,
-	0x60, 0x3,
-	0x30, 0x6,
-	0x18, 0xc,
-	0xc, 0x18,
-	0x6, 0x30,
-	0x3, 0x60,
-	0x1, 0xc0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x9f, 0x7c,
-	0x3f, 0xfe,
-	0x71, 0xc7,
-	0x60, 0x83,
-	0x60, 0x3,
-	0x60, 0x3,
-	0x61, 0x43,
-	0x70, 0x87,
-	0x38, 0xe,
-	0x1c, 0x1c,
-	0xe, 0x38,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_icon[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0xff, 0xff,
-	0xaa, 0xab,
-	0xd5, 0x55,
-	0xaa, 0xab,
-	0xd0, 0x5,
-	0xa0, 0xb,
-	0xd0, 0x5,
-	0xa0, 0xb,
-	0xd0, 0x5,
-	0xa0, 0xb,
-	0xd0, 0x5,
-	0xa0, 0xb,
-	0xd5, 0x55,
-	0xaa, 0xab,
-	0xd5, 0x55,
-	0xff, 0xff,
-	/* mask */
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-};
-
-const unsigned char XC_iron_cross[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x3f, 0xfc,
-	0x1f, 0xf8,
-	0x4f, 0xf2,
-	0x67, 0xe6,
-	0x73, 0xce,
-	0x79, 0x9e,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x79, 0x9e,
-	0x73, 0xce,
-	0x67, 0xe6,
-	0x4f, 0xf2,
-	0x1f, 0xf8,
-	0x3f, 0xfc,
-	0x0, 0x0,
-	/* mask */
-	0x3f, 0xfc,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x7f, 0xfe,
-	0x7f, 0xfe,
-	0x3f, 0xfc,
-};
-
-const unsigned char XC_left_ptr[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 12,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x10,
-	0x0, 0x30,
-	0x0, 0x70,
-	0x0, 0xf0,
-	0x1, 0xf0,
-	0x3, 0xf0,
-	0x7, 0xf0,
-	0xf, 0xf0,
-	0x1, 0xf0,
-	0x1, 0xb0,
-	0x3, 0x10,
-	0x3, 0x0,
-	0x6, 0x0,
-	0x6, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x18,
-	0x0, 0x38,
-	0x0, 0x78,
-	0x0, 0xf8,
-	0x1, 0xf8,
-	0x3, 0xf8,
-	0x7, 0xf8,
-	0xf, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x3, 0xf8,
-	0x7, 0xb8,
-	0x7, 0x98,
-	0xf, 0x0,
-	0xf, 0x0,
-	0x6, 0x0,
-};
-
-const unsigned char XC_left_side[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 15,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x1, 0x6,
-	0x0, 0x86,
-	0x0, 0x46,
-	0x0, 0x26,
-	0x7f, 0xf6,
-	0x0, 0x26,
-	0x0, 0x46,
-	0x0, 0x86,
-	0x1, 0x6,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0xf,
-	0x0, 0xf,
-	0x3, 0xf,
-	0x3, 0x8f,
-	0x1, 0xcf,
-	0x0, 0xef,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x0, 0xef,
-	0x1, 0xcf,
-	0x3, 0x8f,
-	0x3, 0xf,
-	0x0, 0xf,
-	0x0, 0xf,
-	0x0, 0x0,
-};
-
-const unsigned char XC_left_tee[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 13,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x80, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-};
-
-const unsigned char XC_leftbutton[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0xc0, 0x1,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xa2, 0x22,
-	0xaa, 0xa2,
-	0xaa, 0xa2,
-	0xaa, 0xa2,
-	0xaa, 0xa2,
-	0xa2, 0x22,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xc0, 0x1,
-	/* mask */
-	0xbf, 0xfe,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x3f, 0xfe,
-};
-
-const unsigned char XC_ll_angle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 13,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x80, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_lr_angle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 4,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x98, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_man[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	5, 2,	/* y,x of hotspot */
-	/* data */
-	0x1, 0xc0,
-	0xf, 0x78,
-	0x1, 0x40,
-	0x0, 0x81,
-	0xe1, 0xc2,
-	0xd2, 0x24,
-	0xe, 0xb8,
-	0x2, 0xa0,
-	0x2, 0x20,
-	0x1, 0x40,
-	0x2, 0x20,
-	0x4, 0x90,
-	0x9, 0x48,
-	0xa, 0x28,
-	0x3c, 0x1e,
-	0xfc, 0x1f,
-	/* mask */
-	0x7, 0xf8,
-	0xf, 0xfc,
-	0x1f, 0xfc,
-	0x41, 0xc3,
-	0xe3, 0xe7,
-	0xff, 0xfe,
-	0xdf, 0xfc,
-	0xf, 0xf8,
-	0x7, 0xe0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x1f, 0xfc,
-	0x3f, 0x7e,
-	0xfe, 0x3f,
-	0xfe, 0x3f,
-};
-
-const unsigned char XC_middlebutton[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0xc0, 0x1,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xa2, 0x22,
-	0xaa, 0x2a,
-	0xaa, 0x2a,
-	0xaa, 0x2a,
-	0xaa, 0x2a,
-	0xa2, 0x22,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xc0, 0x1,
-	/* mask */
-	0xbf, 0xfe,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x3f, 0xfe,
-};
-
-const unsigned char XC_mouse[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	2, 11,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0xe0,
-	0x0, 0x30,
-	0x0, 0x60,
-	0x0, 0xc0,
-	0x1f, 0xfe,
-	0x20, 0x1,
-	0x6c, 0xcd,
-	0x6c, 0xcd,
-	0x6c, 0xcd,
-	0x60, 0x1,
-	0x60, 0x1,
-	0x38, 0x6,
-	0x6, 0x18,
-	0x1, 0xe0,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xf0,
-	0x0, 0x78,
-	0x0, 0xf0,
-	0x0, 0xe0,
-	0x1f, 0xfe,
-	0x3f, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xef, 0xfc,
-	0x7, 0xf8,
-	0x3, 0xf0,
-	0x1, 0xe0,
-};
-
-const unsigned char XC_pencil[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	15, 3,	/* y,x of hotspot */
-	/* data */
-	0x40, 0x38,
-	0x0, 0x44,
-	0x0, 0xc4,
-	0x1, 0x48,
-	0x1, 0x78,
-	0x2, 0x10,
-	0x2, 0x20,
-	0x4, 0x20,
-	0x4, 0x40,
-	0x8, 0xc0,
-	0x8, 0x80,
-	0x11, 0x0,
-	0x1e, 0x0,
-	0x1c, 0x0,
-	0x18, 0x0,
-	0x10, 0x0,
-	/* mask */
-	0x80, 0x7e,
-	0x0, 0xfe,
-	0x1, 0xfe,
-	0x1, 0xfc,
-	0x3, 0xf8,
-	0x3, 0xf8,
-	0x7, 0xf0,
-	0x7, 0xe0,
-	0xf, 0xe0,
-	0xf, 0xc0,
-	0x1f, 0xc0,
-	0x3f, 0x80,
-	0x3f, 0x0,
-	0x3e, 0x0,
-	0x3c, 0x0,
-	0x38, 0x0,
-};
-
-const unsigned char XC_pirate[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	12, 8,	/* y,x of hotspot */
-	/* data */
-	0x1, 0xe0,
-	0x3, 0xf0,
-	0x7, 0xf8,
-	0xc, 0xcc,
-	0xc, 0xcc,
-	0x7, 0xf8,
-	0x3, 0xf0,
-	0x1, 0xe0,
-	0x21, 0xe1,
-	0x61, 0xe1,
-	0x10, 0xc2,
-	0xe, 0x1c,
-	0x1, 0xe0,
-	0x47, 0xf8,
-	0x7c, 0xf,
-	0x20, 0x1,
-	/* mask */
-	0x3, 0xf0,
-	0x7, 0xf8,
-	0xf, 0xfc,
-	0x1f, 0xfe,
-	0x1f, 0xfe,
-	0xf, 0xfc,
-	0x7, 0xf8,
-	0x83, 0xf1,
-	0xe3, 0xf1,
-	0xf3, 0xf3,
-	0x39, 0xef,
-	0x1e, 0x1e,
-	0x1, 0xe0,
-	0xc7, 0xfe,
-	0xff, 0xff,
-	0x7c, 0xf,
-};
-
-const unsigned char XC_plus[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x81, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_question_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x83, 0xe0,
-	0x7, 0xf0,
-	0xe, 0x38,
-	0xc, 0x18,
-	0xc, 0x38,
-	0xe, 0x30,
-	0x7, 0x0,
-	0x3, 0xc0,
-	0x1, 0xc0,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x7, 0x70,
-	0x3, 0x60,
-	0x1, 0xc0,
-	0x0, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x1f, 0xfc,
-	0x1e, 0x3c,
-	0x1e, 0x7c,
-	0x1f, 0x78,
-	0xf, 0xf0,
-	0x7, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-};
-
-const unsigned char XC_right_ptr[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 5,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x8, 0x0,
-	0xc, 0x0,
-	0xe, 0x0,
-	0xf, 0x0,
-	0xf, 0x80,
-	0xf, 0xc0,
-	0xf, 0xe0,
-	0xf, 0xf0,
-	0xf, 0x80,
-	0xd, 0x80,
-	0x8, 0xc0,
-	0x0, 0xc0,
-	0x0, 0x60,
-	0x0, 0x60,
-	0x0, 0x0,
-	/* mask */
-	0x18, 0x0,
-	0x1c, 0x0,
-	0x1e, 0x0,
-	0x1f, 0x0,
-	0x1f, 0x80,
-	0x1f, 0xc0,
-	0x1f, 0xe0,
-	0x1f, 0xf0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x1f, 0xc0,
-	0x1d, 0xe0,
-	0x19, 0xe0,
-	0x0, 0xf0,
-	0x0, 0xf0,
-	0x0, 0x60,
-};
-
-const unsigned char XC_right_side[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 2,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x60, 0x80,
-	0x61, 0x0,
-	0x62, 0x0,
-	0x64, 0x0,
-	0x6f, 0xfe,
-	0x64, 0x0,
-	0x62, 0x0,
-	0x61, 0x0,
-	0x60, 0x80,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0xf0, 0x0,
-	0xf0, 0x0,
-	0xf0, 0xc0,
-	0xf1, 0xc0,
-	0xf3, 0x80,
-	0xf7, 0x0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xf7, 0x0,
-	0xf3, 0x80,
-	0xf1, 0xc0,
-	0xf0, 0xc0,
-	0xf0, 0x0,
-	0xf0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_right_tee[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 4,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x98, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-};
-
-const unsigned char XC_rightbutton[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0xc0, 0x1,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xa2, 0x22,
-	0xa2, 0xaa,
-	0xa2, 0xaa,
-	0xa2, 0xaa,
-	0xa2, 0xaa,
-	0xa2, 0x22,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xbf, 0xfe,
-	0xc0, 0x1,
-	/* mask */
-	0xbf, 0xfe,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x3f, 0xfe,
-};
-
-const unsigned char XC_rtl_logo[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 9,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x7f, 0xfe,
-	0x44, 0x2,
-	0x44, 0x2,
-	0x44, 0x2,
-	0x47, 0xfe,
-	0x44, 0x22,
-	0x44, 0x22,
-	0x44, 0x22,
-	0x44, 0x22,
-	0x7f, 0xe2,
-	0x40, 0x22,
-	0x40, 0x22,
-	0x40, 0x22,
-	0x7f, 0xfe,
-	0x0, 0x0,
-	/* mask */
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xee, 0x7,
-	0xef, 0xff,
-	0xef, 0xff,
-	0xef, 0xff,
-	0xee, 0x77,
-	0xee, 0x77,
-	0xff, 0xf7,
-	0xff, 0xf7,
-	0xff, 0xf7,
-	0xe0, 0x77,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-};
-
-const unsigned char XC_sailboat[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x42, 0x0,
-	0x2, 0x0,
-	0x6, 0x80,
-	0x6, 0x80,
-	0x6, 0xc0,
-	0xe, 0xc0,
-	0xe, 0xe0,
-	0xe, 0xe0,
-	0x1e, 0xf0,
-	0x1e, 0xf0,
-	0x1e, 0xf8,
-	0x3e, 0xf8,
-	0x1c, 0x7c,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0x0,
-	0x7, 0x0,
-	0x7, 0x80,
-	0xf, 0xc0,
-	0xf, 0xc0,
-	0xf, 0xe0,
-	0x1f, 0xe0,
-	0x1f, 0xf0,
-	0x1f, 0xf0,
-	0x3f, 0xf8,
-	0x3f, 0xf8,
-	0x3f, 0xfc,
-	0xff, 0xfc,
-	0xff, 0xfe,
-	0x1f, 0xff,
-	0x7, 0xfe,
-};
-
-const unsigned char XC_sb_down_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	15, 8,	/* y,x of hotspot */
-	/* data */
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x80,
-};
-
-const unsigned char XC_sb_h_double_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x8, 0x8,
-	0x18, 0xc,
-	0x3f, 0xfe,
-	0x78, 0xf,
-	0x3f, 0xfe,
-	0x18, 0xc,
-	0x8, 0x8,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x8c, 0x18,
-	0x1c, 0x1c,
-	0x3f, 0xfe,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x3f, 0xfe,
-	0x1c, 0x1c,
-	0xc, 0x18,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_sb_left_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 16,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x8,
-	0x0, 0xc,
-	0x7f, 0xfe,
-	0x0, 0xf,
-	0x7f, 0xfe,
-	0x0, 0xc,
-	0x0, 0x8,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x30,
-	0x0, 0x38,
-	0xff, 0xfc,
-	0xff, 0xfe,
-	0xff, 0xff,
-	0xff, 0xfe,
-	0xff, 0xfc,
-	0x0, 0x38,
-	0x0, 0x30,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_sb_right_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 0,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x8, 0x0,
-	0x18, 0x0,
-	0x3f, 0xff,
-	0x78, 0x0,
-	0x3f, 0xff,
-	0x18, 0x0,
-	0x8, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0xc, 0x0,
-	0x1c, 0x0,
-	0x3f, 0xff,
-	0x7f, 0xff,
-	0xff, 0xff,
-	0x7f, 0xff,
-	0x3f, 0xff,
-	0x1c, 0x0,
-	0xc, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_sb_up_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x80,
-	0x9, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x80,
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-};
-
-const unsigned char XC_sb_v_double_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x80,
-	0x9, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0x3, 0xe0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_shuttle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 5,	/* y,x of hotspot */
-	/* data */
-	0x84, 0x0,
-	0xe, 0x0,
-	0x1f, 0x0,
-	0x7b, 0x80,
-	0x7b, 0xa0,
-	0x7b, 0x90,
-	0x7b, 0x88,
-	0x7b, 0x88,
-	0x7b, 0x88,
-	0x7b, 0x88,
-	0x7b, 0x8c,
-	0x7b, 0x8e,
-	0x7b, 0xbf,
-	0x11, 0x18,
-	0x1e, 0x0,
-	0xc, 0x0,
-	/* mask */
-	0x1c, 0x0,
-	0x3e, 0x0,
-	0x7f, 0x0,
-	0xff, 0x0,
-	0xff, 0x60,
-	0xff, 0x70,
-	0xff, 0x78,
-	0xff, 0x78,
-	0xff, 0x78,
-	0xff, 0x78,
-	0xff, 0x7c,
-	0xff, 0x7e,
-	0xff, 0x7f,
-	0x7f, 0x7e,
-	0x7e, 0x30,
-	0x3c, 0x0,
-};
-
-const unsigned char XC_sizing[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x81, 0xfe,
-	0x0, 0x2,
-	0x0, 0x2,
-	0x0, 0x2,
-	0x7, 0xe2,
-	0x4, 0x22,
-	0x44, 0x22,
-	0x44, 0x22,
-	0x44, 0x20,
-	0x47, 0xe0,
-	0x48, 0x0,
-	0x50, 0x0,
-	0x60, 0x0,
-	0x7f, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x3, 0xff,
-	0x3, 0xff,
-	0x3, 0xff,
-	0x0, 0x7,
-	0xf, 0xf7,
-	0xf, 0xf7,
-	0xef, 0xf7,
-	0xee, 0x77,
-	0xee, 0x77,
-	0xef, 0xf7,
-	0xef, 0xf0,
-	0xff, 0xf0,
-	0xf8, 0x0,
-	0xff, 0xc0,
-	0xff, 0xc0,
-	0xff, 0xc0,
-};
-
-const unsigned char XC_spider[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 10,	/* y,x of hotspot */
-	/* data */
-	0x8, 0x4,
-	0x4, 0x8,
-	0x4, 0x8,
-	0x2, 0x10,
-	0x2, 0x10,
-	0xe1, 0xe1,
-	0x19, 0xe6,
-	0x7, 0xf8,
-	0x7, 0xf8,
-	0x19, 0xe6,
-	0xe1, 0xe1,
-	0x2, 0x10,
-	0x2, 0x10,
-	0x4, 0x8,
-	0x4, 0x8,
-	0x8, 0x4,
-	/* mask */
-	0x18, 0x6,
-	0xc, 0xc,
-	0x4, 0x8,
-	0x6, 0x18,
-	0x83, 0xf1,
-	0xf3, 0xf3,
-	0x3b, 0xf6,
-	0xf, 0xfc,
-	0x7, 0xfc,
-	0x1f, 0xf6,
-	0xf3, 0xf3,
-	0x83, 0xf1,
-	0x2, 0x18,
-	0x6, 0x18,
-	0xc, 0xc,
-	0x18, 0x6,
-};
-
-const unsigned char XC_spraycan[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	2, 4,	/* y,x of hotspot */
-	/* data */
-	0x98, 0x0,
-	0x2, 0x0,
-	0x18, 0xb0,
-	0x2, 0x78,
-	0x18, 0x58,
-	0x0, 0xfc,
-	0x0, 0x84,
-	0x0, 0x9c,
-	0x0, 0x94,
-	0x0, 0x9c,
-	0x0, 0x94,
-	0x0, 0x9c,
-	0x0, 0x9c,
-	0x0, 0x84,
-	0x0, 0x84,
-	0x0, 0xfc,
-	/* mask */
-	0x30, 0x0,
-	0x34, 0x60,
-	0x35, 0xf0,
-	0x35, 0xf0,
-	0x35, 0xf8,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-	0x3, 0xfc,
-};
-
-const unsigned char XC_star[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x80, 0x80,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x1, 0x40,
-	0x2, 0x20,
-	0x2, 0x20,
-	0x2, 0x20,
-	0x1c, 0x9c,
-	0x60, 0x3,
-	0x1c, 0x1c,
-	0x4, 0x90,
-	0x9, 0x48,
-	0x12, 0x24,
-	0x14, 0x14,
-	0x18, 0xc,
-	0x10, 0x4,
-	/* mask */
-	0x0, 0x80,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x3, 0x60,
-	0x3, 0x60,
-	0x6, 0x30,
-	0x1e, 0x38,
-	0x7c, 0x9f,
-	0xe0, 0x3,
-	0x7c, 0x1f,
-	0x1c, 0x9c,
-	0x19, 0xcc,
-	0x33, 0x66,
-	0x36, 0x36,
-	0x3c, 0x1e,
-	0x38, 0xe,
-};
-
-const unsigned char XC_target[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x81, 0xc0,
-	0x7, 0xf0,
-	0xe, 0x38,
-	0x18, 0xc,
-	0x30, 0x6,
-	0x60, 0x83,
-	0x61, 0x43,
-	0x60, 0x83,
-	0x30, 0x6,
-	0x18, 0xc,
-	0xe, 0x38,
-	0x7, 0xf0,
-	0x1, 0xc0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x1e, 0x3c,
-	0x38, 0xe,
-	0x70, 0x87,
-	0xe1, 0xc3,
-	0xe3, 0x63,
-	0xe1, 0xc3,
-	0x70, 0x87,
-	0x38, 0xe,
-	0x1e, 0x3c,
-	0xf, 0xf8,
-	0x3, 0xe0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_tcross[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	7, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0xc0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x3f, 0xfe,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_top_left_arrow[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 15,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x80, 0x6,
-	0x0, 0x1e,
-	0x0, 0x7c,
-	0x1, 0xfc,
-	0x7, 0xf8,
-	0x1f, 0xf8,
-	0x1, 0xf0,
-	0x1, 0xf0,
-	0x2, 0x60,
-	0x4, 0x60,
-	0x8, 0x40,
-	0x10, 0x40,
-	0x20, 0x0,
-	0x40, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x7,
-	0x0, 0x1f,
-	0x0, 0x7f,
-	0x1, 0xfe,
-	0x7, 0xfe,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xf8,
-	0x3, 0xf8,
-	0x7, 0xf0,
-	0xe, 0xf0,
-	0x1c, 0xe0,
-	0x38, 0xe0,
-	0x70, 0xe0,
-	0xe0, 0x0,
-	0xc0, 0x0,
-};
-
-const unsigned char XC_top_left_corner[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 15,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0xff, 0xfe,
-	0x7f, 0xfe,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x1f, 0xc6,
-	0x0, 0xc6,
-	0x1, 0x46,
-	0x2, 0x46,
-	0x4, 0x46,
-	0x8, 0x46,
-	0x10, 0x46,
-	0x0, 0x6,
-	0x0, 0x6,
-	0x0, 0x0,
-	/* mask */
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x0, 0xf,
-	0x3f, 0xef,
-	0x3f, 0xef,
-	0x3f, 0xef,
-	0x3, 0xef,
-	0x7, 0xef,
-	0xe, 0xef,
-	0x1c, 0xef,
-	0x38, 0xef,
-	0x30, 0xef,
-	0x0, 0xf,
-	0x0, 0xf,
-};
-
-const unsigned char XC_top_right_corner[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 2,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0xff, 0xfe,
-	0x7f, 0xfe,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x63, 0xf8,
-	0x63, 0x0,
-	0x62, 0x80,
-	0x62, 0x40,
-	0x62, 0x20,
-	0x62, 0x10,
-	0x62, 0x8,
-	0x60, 0x0,
-	0x60, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xf0, 0x0,
-	0xf7, 0xfc,
-	0xf7, 0xfc,
-	0xf7, 0xfc,
-	0xf7, 0xc0,
-	0xf7, 0xe0,
-	0xf7, 0x70,
-	0xf7, 0x38,
-	0xf7, 0x1c,
-	0xf7, 0xc,
-	0xf0, 0x0,
-	0xf0, 0x0,
-};
-
-const unsigned char XC_top_side[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	1, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0xff, 0xfe,
-	0x3f, 0xfe,
-	0x0, 0x0,
-	0x0, 0x80,
-	0x1, 0xc0,
-	0x2, 0xa0,
-	0x4, 0x90,
-	0x8, 0x88,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x0,
-	/* mask */
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x7f, 0xff,
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0x1d, 0xdc,
-	0x19, 0xcc,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-};
-
-const unsigned char XC_top_tee[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	3, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0xff, 0xfe,
-	0x7f, 0xfe,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x1, 0x80,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x3, 0xc0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_trek[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	0, 8,	/* y,x of hotspot */
-	/* data */
-	0x8, 0x80,
-	0x8, 0x0,
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0x7, 0x70,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x0, 0x80,
-	0x5, 0xd0,
-	0x6, 0xb0,
-	0x4, 0x90,
-	0x4, 0x10,
-	0x4, 0x10,
-	0x4, 0x10,
-	/* mask */
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0x7, 0xf0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x7, 0xf0,
-	0x3, 0xe0,
-	0x5, 0xd0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0xe, 0xb8,
-	0xe, 0xb8,
-	0xe, 0x38,
-};
-
-const unsigned char XC_ul_angle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	3, 13,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x18,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x3c,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_umbrella[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	3, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x89, 0x10,
-	0x14, 0x40,
-	0x65, 0x92,
-	0x13, 0xe4,
-	0xc, 0x98,
-	0x30, 0x86,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x2, 0x80,
-	0x2, 0x80,
-	0x1, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x76, 0xe8,
-	0xdf, 0xfb,
-	0x3f, 0xfd,
-	0xff, 0xfe,
-	0x3f, 0xff,
-	0xff, 0xff,
-	0x79, 0xcf,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x7, 0xc0,
-	0x7, 0xc0,
-	0x7, 0xc0,
-	0x7, 0xc0,
-	0x3, 0x80,
-};
-
-const unsigned char XC_ur_angle[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	3, 4,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x1f, 0xf8,
-	0x1f, 0xf8,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x18, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-	/* mask */
-	0x0, 0x0,
-	0x0, 0x0,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3f, 0xfc,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x3c, 0x0,
-	0x0, 0x0,
-	0x0, 0x0,
-};
-
-const unsigned char XC_watch[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	9, 1,	/* y,x of hotspot */
-	/* data */
-	0x7, 0xf8,
-	0x7, 0xf8,
-	0x7, 0xf8,
-	0xf, 0xfc,
-	0x18, 0x86,
-	0x30, 0x83,
-	0xe0, 0x81,
-	0xe1, 0xc1,
-	0xe1, 0xc1,
-	0xe0, 0x21,
-	0x30, 0x13,
-	0x18, 0x6,
-	0xf, 0xfc,
-	0x7, 0xf8,
-	0x7, 0xf8,
-	0x7, 0xf8,
-	/* mask */
-	0xf, 0xfc,
-	0xf, 0xfc,
-	0xf, 0xfc,
-	0x1f, 0xfe,
-	0x3f, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0xff, 0xff,
-	0x3f, 0xff,
-	0x1f, 0xfe,
-	0xf, 0xfc,
-	0xf, 0xfc,
-	0xf, 0xfc,
-};
-
-const unsigned char XC_xterm[] = {
-	16,	/* 16x16 size */
-	1,	/* 1 bit depth */
-	8, 8,	/* y,x of hotspot */
-	/* data */
-	0x0, 0x0,
-	0xf, 0x70,
-	0x9, 0xc0,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x0, 0x80,
-	0x1, 0xc0,
-	0x7, 0x70,
-	0x0, 0x0,
-	/* mask */
-	0xf, 0x78,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0x3, 0xe0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x1, 0xc0,
-	0x3, 0xe0,
-	0xf, 0xf8,
-	0xf, 0xf8,
-	0xf, 0x78,
-};
-
diff --git a/src/glut/beos/glutDstr.cpp b/src/glut/beos/glutDstr.cpp
deleted file mode 100644
index 281a0397017..00000000000
--- a/src/glut/beos/glutDstr.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutDstr.cpp
- *
- *	DESCRIPTION:	convert display string into a Be options variable
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <string.h>
-#include <stdlib.h>
-#include "glutint.h"
-#include "glutState.h"
-
-/***********************************************************
- *	FUNCTION:	glutInitDisplayString
- *
- *	DESCRIPTION:  sets the display string variable
- ***********************************************************/
-void APIENTRY 
-glutInitDisplayString(const char *string)
-{
-  if (gState.displayString) {
-    free(gState.displayString);
-  }
-  if (string) {
-    gState.displayString = strdup(string);
-    if (!gState.displayString)
-      __glutFatalError("out of memory.");
-  } else
-    gState.displayString = NULL;
-}
-
-/***********************************************************
- *	FUNCTION:	__glutConvertDisplayModeFromString
- *
- *	DESCRIPTION:  converts the current display mode into a BGLView
- *		display mode, printing warnings as appropriate.
- *
- *	PARAMETERS:	 if options is non-NULL, the current display mode is
- *		returned in it.
- *
- *	RETURNS:	1 if the current display mode is possible, else 0
- ***********************************************************/
-int __glutConvertDisplayModeFromString(unsigned long *options) {
-	ulong newoptions = 0;
-	
-	char *word = strtok(gState.displayString, " \t");
-	do {
-		char *cstr = strpbrk(word, "=><!~");
-		if(cstr)
-			*cstr = '\0';
-		// this is the most minimal possible parser.  scan for
-		// options that we support, and add them to newoptions
-		// this will certainly cause it to accept things that we
-		// don't actually support, but if we don't support it, the
-		// program's probably not going to work anyway.
-		if(!strcmp(word, "alpha")) {
-			newoptions |= BGL_ALPHA;
-		} else if((!strcmp(word, "acc")) || (!strcmp(word, "acca"))) {
-			newoptions |= BGL_ACCUM;
-		} else if(!strcmp(word, "depth")) {
-			newoptions |= BGL_DEPTH;
-		} else if(!strcmp(word, "double")) {
-			newoptions |= BGL_DOUBLE;
-		} else if(!strcmp(word, "stencil")) {
-			newoptions |= BGL_STENCIL;
-		}
-	} while((word = strtok(0, " \t")) != 0);
-
-	if (options)
-		*options = newoptions;
-
-	return 1;	// assume we support it
-}
diff --git a/src/glut/beos/glutEvent.cpp b/src/glut/beos/glutEvent.cpp
deleted file mode 100644
index cffbc1aa543..00000000000
--- a/src/glut/beos/glutEvent.cpp
+++ /dev/null
@@ -1,695 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutEvent.cpp
- *
- *	DESCRIPTION:	here it is, the BeOS GLUT event loop
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include "glutint.h"
-#include "glutState.h"
-#include "glutBlocker.h"
-
-/***********************************************************
- *	CLASS:	GLUTtimer
- *
- *	DESCRIPTION:	list of timer callbacks
- ***********************************************************/
-struct GLUTtimer {
-	GLUTtimer *next;	// list of timers
-	bigtime_t timeout;	// time to be called
-	GLUTtimerCB func;	// function to call
-	int value;			// value
-};
-
-/***********************************************************
- *	Private variables
- ***********************************************************/
-static GLUTtimer *__glutTimerList = 0;			// list of timer callbacks
-static GLUTtimer *freeTimerList = 0;
-
-/***********************************************************
- *	FUNCTION:	glutTimerFunc (7.19)
- *
- *	DESCRIPTION:  register a new timer callback
- ***********************************************************/
-void APIENTRY 
-glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)
-{
-  GLUTtimer *timer, *other;
-  GLUTtimer **prevptr;
-
-  if (!timerFunc)
-    return;
-
-  if (freeTimerList) {
-    timer = freeTimerList;
-    freeTimerList = timer->next;
-  } else {
-    timer = new GLUTtimer();
-    if (!timer)
-      __glutFatalError("out of memory.");
-  }
-
-  timer->func = timerFunc;
-  timer->value = value;
-  timer->next = NULL;
-  timer->timeout = system_time() + (interval*1000);	// 1000 ticks in a millisecond
-  prevptr = &__glutTimerList;
-  other = *prevptr;
-  while (other && (other->timeout < timer->timeout)) {
-    prevptr = &other->next;
-    other = *prevptr;
-  }
-  timer->next = other;
-  *prevptr = timer;
-}
-
-/***********************************************************
- *	FUNCTION:	handleTimeouts
- *
- *	DESCRIPTION:  private function to handle outstanding timeouts
- ***********************************************************/
-static void
-handleTimeouts(void)
-{
-  bigtime_t now;
-  GLUTtimer *timer;
-
-  /* Assumption is that __glutTimerList is already determined
-     to be non-NULL. */
-  now = system_time();
-  while (__glutTimerList->timeout <= now) {
-    timer = __glutTimerList;
-    if(gState.currentWindow)
-	    gState.currentWindow->LockGL();
-    timer->func(timer->value);
-    if(gState.currentWindow)
-	    gState.currentWindow->UnlockGL();
-    __glutTimerList = timer->next;
-    timer->next = freeTimerList;
-    freeTimerList = timer;
-    if (!__glutTimerList)
-      break;
-  }
-}
-
-
-/***********************************************************
- *	FUNCTION:	processEventsAndTimeouts
- *
- *	DESCRIPTION:  clear gBlock, then check all windows for events
- ***********************************************************/
-static void
-processEventsAndTimeouts(void)
-{
-	gBlock.WaitEvent();		// if there is already an event, returns
-							// immediately, otherwise wait forever
-	gBlock.ClearEvents();
-	
-	if(gState.quitAll)
-		exit(0);		// exit handler cleans up windows and quits nicely
-	
-	if (gState.currentWindow)
-		gState.currentWindow->LockGL();
-	for(int i=0; i<gState.windowListSize; i++) {
-		if (gState.windowList[i]) {
-			GlutWindow *win = gState.windowList[i];
-			// NOTE: we can use win as a shortcut for gState.windowList[i]
-			// in callbacks, EXCEPT we need to check the original variable
-			// after each callback to make sure the window hasn't been destroyed
-			if (win->anyevents) {
-				win->anyevents = false;
-				if (win->reshapeEvent) {
-					win->reshapeEvent = false;
-					__glutSetWindow(win);
-					win->reshape(win->m_width, win->m_height);
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->displayEvent) {
-					win->displayEvent = false;
-					__glutSetWindow(win);
-					win->display();
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->mouseEvent) {
-					win->mouseEvent = false;
-					__glutSetWindow(win);
-					if (win->mouse) {
-						gState.modifierKeys = win->modifierKeys;
-						win->mouse(win->button, win->mouseState, win->mouseX, win->mouseY);
-						gState.modifierKeys = ~0;
-					}
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->menuEvent) {
-					win->menuEvent = false;
-					__glutSetWindow(win);
-					GlutMenu *menu = __glutGetMenuByNum(win->menuNumber);
-					if (menu) {
-						gState.currentMenu = menu;
-						menu->select(win->menuValue);
-					}
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->statusEvent) {
-					win->statusEvent = false;
-					__glutSetWindow(win);
-					if (gState.menuStatus) {
-						gState.currentMenu = __glutGetMenuByNum(win->menuNumber);
-						gState.menuStatus(win->menuStatus, win->statusX, win->statusY);
-					}
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->motionEvent) {
-					win->motionEvent = false;
-					__glutSetWindow(win);
-					if (win->motion)
-						win->motion(win->motionX, win->motionY);
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->passiveEvent) {
-					win->passiveEvent = false;
-					__glutSetWindow(win);
-					if (win->passive)
-						win->passive(win->passiveX, win->passiveY);
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->keybEvent) {
-					win->keybEvent = false;
-					__glutSetWindow(win);
-					if (win->keyboard) {
-						gState.modifierKeys = win->modifierKeys;
-						win->keyboard(win->key, win->keyX, win->keyY);
-						gState.modifierKeys = ~0;
-					}
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->specialEvent) {
-					win->specialEvent = false;
-					__glutSetWindow(win);
-					if (win->special) {
-						gState.modifierKeys = win->modifierKeys;
-						win->special(win->specialKey, win->specialX, win->specialY);
-						gState.modifierKeys = ~0;
-					}
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->entryEvent) {
-					win->entryEvent = false;
-					__glutSetWindow(win);
-					if (win->entry)
-						win->entry(win->entryState);
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-
-				if (win->windowStatusEvent) {
-					win->windowStatusEvent = false;
-					__glutSetWindow(win);
-					if (win->windowStatus)
-						win->windowStatus(win->visState);
-				}
-				if (!gState.windowList[i])
-					continue;	// window was destroyed by callback!
-			}
-		}
-	}
-	if (gState.currentWindow)
-		gState.currentWindow->UnlockGL();
-
-	// This code isn't necessary since BGLView automatically traps errors
-#if 0
-	if(gState.debug) {
-		for(int i=0; i<gState.windowListSize; i++) {
-			if (gState.windowList[i]) {
-				gState.windowList[i]->LockGL();
-				glutReportErrors();
-				gState.windowList[i]->UnlockGL();
-			}
-		}
-	}
-#endif
-	if (__glutTimerList) {
-      handleTimeouts();
-    }
-}
-
-/***********************************************************
- *	FUNCTION:	waitForSomething
- *
- *	DESCRIPTION:  use gBlock to wait for a new event or timeout
- ***********************************************************/
-static void
-waitForSomething(void)
-{
-	bigtime_t timeout = __glutTimerList->timeout;
-	bigtime_t now = system_time();
-	
-	if (gBlock.PendingEvent())
-		goto immediatelyHandleEvent;
-	
-	if(timeout>now)
-		gBlock.WaitEvent(timeout-now);
-	if (gBlock.PendingEvent()) {
-	immediatelyHandleEvent:
-		processEventsAndTimeouts();
-	} else {
-		if (__glutTimerList)
-			handleTimeouts();
-	}
-}
-
-/***********************************************************
- *	FUNCTION:	idleWait
- *
- *	DESCRIPTION:  check for events, then call idle function
- ***********************************************************/
-static void
-idleWait(void)
-{
-  if (gBlock.PendingEvent()) {
-    processEventsAndTimeouts();
-  } else {
-    if (__glutTimerList)
-      handleTimeouts();
-  }
-  /* Make sure idle func still exists! */
-  if(gState.currentWindow)
-	  gState.currentWindow->LockGL();
-  if (gState.idle) {
-    gState.idle();
-  }
-  if(gState.currentWindow)
-	  gState.currentWindow->UnlockGL();
-}
-
-/***********************************************************
- *	FUNCTION:	glutMainLoop (3.1)
- *
- *	DESCRIPTION:  enter the event processing loop
- ***********************************************************/
-void glutMainLoop()
-{
-  if (!gState.windowListSize)
-    __glutFatalUsage("main loop entered with no windows created.");
-
-  if(gState.currentWindow)
-	  gState.currentWindow->UnlockGL();
-
-  for (;;) {
-    if (gState.idle) {
-      idleWait();
-    } else {
-      if (__glutTimerList) {
-        waitForSomething();
-      } else {
-        processEventsAndTimeouts();
-      }
-    }
-  }
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	KeyDown
- *
- *	DESCRIPTION:  handles keyboard and special events
- ***********************************************************/
-void GlutWindow::KeyDown(const char *s, int32 slen)
-{
-  ulong aChar = s[0];
-  BGLView::KeyDown(s,slen);
-  
-  BPoint p;
-	
-	switch (aChar) {
-		case B_FUNCTION_KEY:
-		switch(Window()->CurrentMessage()->FindInt32("key")) {
-			case B_F1_KEY:
-				aChar = GLUT_KEY_F1;
-				goto specialLabel;
-			case B_F2_KEY:
-				aChar = GLUT_KEY_F2;
-				goto specialLabel;
-			case B_F3_KEY:
-				aChar = GLUT_KEY_F3;
-				goto specialLabel;
-			case B_F4_KEY:
-				aChar = GLUT_KEY_F4;
-				goto specialLabel;
-			case B_F5_KEY:
-				aChar = GLUT_KEY_F5;
-				goto specialLabel;
-			case B_F6_KEY:
-				aChar = GLUT_KEY_F6;
-				goto specialLabel;
-			case B_F7_KEY:
-				aChar = GLUT_KEY_F7;
-				goto specialLabel;
-			case B_F8_KEY:
-				aChar = GLUT_KEY_F8;
-				goto specialLabel;
-			case B_F9_KEY:
-				aChar = GLUT_KEY_F9;
-				goto specialLabel;
-			case B_F10_KEY:
-				aChar = GLUT_KEY_F10;
-				goto specialLabel;
-			case B_F11_KEY:
-				aChar = GLUT_KEY_F11;
-				goto specialLabel;
-			case B_F12_KEY:
-				aChar = GLUT_KEY_F12;
-				goto specialLabel;
-			default:
-				return;
-		}
-		case B_LEFT_ARROW:
-			aChar = GLUT_KEY_LEFT;
-			goto specialLabel;
-		case B_UP_ARROW:
-			aChar = GLUT_KEY_UP;
-			goto specialLabel;
-		case B_RIGHT_ARROW:
-			aChar = GLUT_KEY_RIGHT;
-			goto specialLabel;
-		case B_DOWN_ARROW:
-			aChar = GLUT_KEY_DOWN;
-			goto specialLabel;
-		case B_PAGE_UP:
-			aChar = GLUT_KEY_PAGE_UP;
-			goto specialLabel;
-		case B_PAGE_DOWN:
-			aChar = GLUT_KEY_PAGE_DOWN;
-			goto specialLabel;
-		case B_HOME:
-			aChar = GLUT_KEY_HOME;
-			goto specialLabel;
-		case B_END:
-			aChar = GLUT_KEY_END;
-			goto specialLabel;
-		case B_INSERT:
-            aChar = GLUT_KEY_INSERT;
-specialLabel:	
-			if (special) {
-				anyevents = specialEvent = true;
-				GetMouse(&p,&m_buttons);
-				specialKey = aChar;
-				specialX = (int)p.x;
-				specialY = (int)p.y;
-				goto setModifiers;	// set the modifier variable
-			}
-			return;
-
-		default:
-			break;
-	}
-		
-	if (keyboard) {
-		anyevents = keybEvent = true;
-		GetMouse(&p,&m_buttons);
-		key = aChar;
-		keyX = (int)p.x;
-		keyY = (int)p.y;
-setModifiers:
-		modifierKeys = 0;
-		uint32 beMod = Window()->CurrentMessage()->FindInt32("modifiers");
-		if(beMod & B_SHIFT_KEY)
-			modifierKeys |= GLUT_ACTIVE_SHIFT;
-		if(beMod & B_CONTROL_KEY)
-			modifierKeys |= GLUT_ACTIVE_CTRL;
-		if(beMod & B_OPTION_KEY) {
-			// since the window traps B_COMMAND_KEY, we'll have to settle
-			// for the option key.. but we need to get the raw character,
-			// not the Unicode-enhanced version
-			key = Window()->CurrentMessage()->FindInt32("raw_char");
-			modifierKeys |= GLUT_ACTIVE_ALT;
-		}
-		gBlock.NewEvent();
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	MouseDown
- *
- *	DESCRIPTION:  handles mouse and menustatus events
- ***********************************************************/
-void GlutWindow::MouseDown(BPoint point)
-{
-	BGLView::MouseDown(point);
-	MouseCheck();
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	MouseCheck
- *
- *	DESCRIPTION:  checks for button state changes
- ***********************************************************/
-void GlutWindow::MouseCheck()
-{
-	if (mouseEvent)
-		return;		// we already have an outstanding mouse event
-
-	BPoint point;
-	uint32 newButtons;
-	GetMouse(&point, &newButtons);
-	if (m_buttons != newButtons) {
-		if (newButtons&B_PRIMARY_MOUSE_BUTTON && !(m_buttons&B_PRIMARY_MOUSE_BUTTON)) {
-			button = GLUT_LEFT_BUTTON;
-			mouseState = GLUT_DOWN;
-		} else if (m_buttons&B_PRIMARY_MOUSE_BUTTON && !(newButtons&B_PRIMARY_MOUSE_BUTTON)) {
-			button = GLUT_LEFT_BUTTON;
-			mouseState = GLUT_UP;
-		} else if (newButtons&B_SECONDARY_MOUSE_BUTTON && !(m_buttons&B_SECONDARY_MOUSE_BUTTON)) {
-			button = GLUT_RIGHT_BUTTON;
-			mouseState = GLUT_DOWN;
-		} else if (m_buttons&B_SECONDARY_MOUSE_BUTTON && !(newButtons&B_SECONDARY_MOUSE_BUTTON)) {
-			button = GLUT_RIGHT_BUTTON;
-			mouseState = GLUT_UP;
-		} else if (newButtons&B_TERTIARY_MOUSE_BUTTON && !(m_buttons&B_TERTIARY_MOUSE_BUTTON)) {
-			button = GLUT_MIDDLE_BUTTON;
-			mouseState = GLUT_DOWN;
-		} else if (m_buttons&B_TERTIARY_MOUSE_BUTTON && !(newButtons&B_TERTIARY_MOUSE_BUTTON)) {
-			button = GLUT_MIDDLE_BUTTON;
-			mouseState = GLUT_UP;
-		}
-	} else {
-		return;		// no change, return
-	}
-	m_buttons = newButtons;
-
-	if (mouseState == GLUT_DOWN) {
-		BWindow *w = Window();
-		GlutMenu *m = __glutGetMenuByNum(menu[button]);
-		if (m) {
-			if (gState.menuStatus) {
-				anyevents = statusEvent = true;
-				menuNumber = menu[button];
-				menuStatus = GLUT_MENU_IN_USE;
-				statusX = (int)point.x;
-				statusY = (int)point.y;
-				gBlock.NewEvent();
-			}		
-			BRect bounds = w->Frame();
-			point.x += bounds.left;
-			point.y += bounds.top;
-			GlutPopUp *bmenu = static_cast<GlutPopUp*>(m->CreateBMenu());	// start menu
-			bmenu->point = point;
-			bmenu->win = this;
-			thread_id menu_thread = spawn_thread(MenuThread, "menu thread", B_NORMAL_PRIORITY, bmenu);
-			resume_thread(menu_thread);
-			return;
-		}
-	}
-
-	if (mouse) {
-		anyevents = mouseEvent = true;
-		mouseX = (int)point.x;
-		mouseY = (int)point.y;
-		modifierKeys = 0;
-		uint32 beMod = modifiers();
-		if(beMod & B_SHIFT_KEY)
-			modifierKeys |= GLUT_ACTIVE_SHIFT;
-		if(beMod & B_CONTROL_KEY)
-			modifierKeys |= GLUT_ACTIVE_CTRL;
-		if(beMod & B_OPTION_KEY) {
-			modifierKeys |= GLUT_ACTIVE_ALT;
-		}
-		gBlock.NewEvent();
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	MouseMoved
- *
- *	DESCRIPTION:  handles entry, motion, and passive events
- ***********************************************************/
-void GlutWindow::MouseMoved(BPoint point,
-						ulong transit, const BMessage *msg)
-{
-	BGLView::MouseMoved(point,transit,msg);
-	
-	if(transit != B_INSIDE_VIEW) {
-		if (entry) {
-			anyevents = entryEvent = true;
-			gBlock.NewEvent();
-		}
-		if (transit == B_ENTERED_VIEW) {
-			entryState = GLUT_ENTERED;
-			MakeFocus();	// make me the current focus
-			__glutSetCursor(cursor);
-		} else
-			entryState = GLUT_LEFT;
-	}
-	
-	MouseCheck();
-	if(m_buttons) {
-		if(motion) {
-			anyevents = motionEvent = true;
-			motionX = (int)point.x;
-			motionY = (int)point.y;
-			gBlock.NewEvent();
-		}
-	} else {
-		if(passive) {
-			anyevents = passiveEvent = true;
-			passiveX = (int)point.x;
-			passiveY = (int)point.y;
-			gBlock.NewEvent();
-		}
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	FrameResized
- *
- *	DESCRIPTION:  handles reshape event
- ***********************************************************/
-void GlutWindow::FrameResized(float width, float height)
-{
-	BGLView::FrameResized(width, height);
-	if (visible) {
-		anyevents = reshapeEvent = true;
-		m_width = (int)(width)+1;
-		m_height = (int)(height)+1;
-		gBlock.NewEvent();
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	Draw
- *
- *	DESCRIPTION:  handles reshape and display events
- ***********************************************************/
-void GlutWindow::Draw(BRect updateRect)
-{
-	BGLView::Draw(updateRect);
-	BRect frame = Frame();
-	if (m_width != (frame.Width()+1) || m_height != (frame.Height()+1)) {
-		FrameResized(frame.Width(), frame.Height());
-	}
-	Window()->Lock();
-	if (visible) {
-		anyevents = displayEvent = true;
-		gBlock.NewEvent();
-	}
-	Window()->Unlock();
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	Pulse
- *
- *	DESCRIPTION:  handles mouse up event (MouseUp is broken)
- ***********************************************************/
-void GlutWindow::Pulse()
-{
-	BGLView::Pulse();
-	if (m_buttons) {	// if there are buttons pressed
-		MouseCheck();
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	ErrorCallback
- *
- *	DESCRIPTION:  handles GL error messages
- ***********************************************************/
-void GlutWindow::ErrorCallback(GLenum errorCode) {
-	__glutWarning("GL error: %s", gluErrorString(errorCode));
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	MenuThread
- *
- *	DESCRIPTION:  a new thread to launch popup menu, wait
- *			wait for response, then clean up afterwards and
- *			send appropriate messages
- ***********************************************************/
-long GlutWindow::MenuThread(void *m) {
-	GlutPopUp *bmenu = static_cast<GlutPopUp*>(m);
-	GlutWindow *win = bmenu->win;	// my window
-	GlutBMenuItem *result = (GlutBMenuItem*)bmenu->Go(bmenu->point);
-	win->Window()->Lock();
-	win->anyevents = win->statusEvent = true;
-	win->menuStatus = GLUT_MENU_NOT_IN_USE;
-	win->menuNumber = bmenu->menu;
-	BPoint cursor;
-	uint32 buttons;
-	win->GetMouse(&cursor, &buttons);
-	win->statusX = (int)cursor.x;
-	win->statusY = (int)cursor.y;
-	if(result && result->menu) {
-		win->menuEvent = true;
-		win->menuNumber = result->menu;  // in case it was a submenu
-		win->menuValue = result->value;
-	}
-	win->Window()->Unlock();
-	gBlock.NewEvent();
-	delete bmenu;
-	return 0;
-}
diff --git a/src/glut/beos/glutGet.cpp b/src/glut/beos/glutGet.cpp
deleted file mode 100644
index 04a8479b985..00000000000
--- a/src/glut/beos/glutGet.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutGet.cpp
- *
- *	DESCRIPTION:	get state information from GL
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <string.h>
-#include <Autolock.h>
-#include <Screen.h>
-
-#include "glutint.h"
-#include "glutState.h"
-
-/***********************************************************
- *	Global variables
- ***********************************************************/
-// rough guess, since we don't know how big the monitor really is
-const float dots_per_mm = (72/25.4);	// dots per millimeter
-
-/***********************************************************
- *	FUNCTION:	glutGet (9.1)
- *
- *	DESCRIPTION:  retrieve window and GL state
- ***********************************************************/
-int glutGet(GLenum state) {
-	switch(state) {
-	case GLUT_WINDOW_X:
-		{BAutolock winlock(gState.currentWindow->Window());	// need to lock the window
-		if (gState.currentWindow->parent)
-			return (int)gState.currentWindow->Frame().left;
-		else
-			return (int)gState.currentWindow->Window()->Frame().left;
-		}
-	case GLUT_WINDOW_Y:
-		{BAutolock winlock(gState.currentWindow->Window());
-		if (gState.currentWindow->parent)
-			return (int)gState.currentWindow->Frame().top;
-		else
-			return (int)gState.currentWindow->Window()->Frame().top;
-		}
-	case GLUT_WINDOW_WIDTH:
-		{BAutolock winlock(gState.currentWindow->Window());
-		return gState.currentWindow->m_width;
-		}
-	case GLUT_WINDOW_HEIGHT:
-		{BAutolock winlock(gState.currentWindow->Window());
-		return gState.currentWindow->m_height;
-		}
-	case GLUT_WINDOW_PARENT:
-		{BAutolock winlock(gState.currentWindow->Window());
-		if(gState.currentWindow->parent)
-			return gState.currentWindow->parent->num + 1;
-		else
-			return 0;
-		}
-	case GLUT_WINDOW_NUM_CHILDREN:
-		{BAutolock winlock(gState.currentWindow->Window());
-		int num = 0;
-		GlutWindow *children = gState.currentWindow->children;
-		while (children) {
-			num++;
-			children = children->siblings;
-		}
-		return num; 
-		}
-  case GLUT_WINDOW_BUFFER_SIZE:	// best guesses
-  case GLUT_WINDOW_DEPTH_SIZE:
-        return 32;
-
-  case GLUT_WINDOW_STENCIL_SIZE:
-  case GLUT_WINDOW_RED_SIZE:		// always 24-bit color
-  case GLUT_WINDOW_GREEN_SIZE:
-  case GLUT_WINDOW_BLUE_SIZE:
-  case GLUT_WINDOW_ALPHA_SIZE:
-  case GLUT_WINDOW_ACCUM_RED_SIZE:
-  case GLUT_WINDOW_ACCUM_GREEN_SIZE:
-  case GLUT_WINDOW_ACCUM_BLUE_SIZE:
-  case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
-        return 8;
-
-  case GLUT_WINDOW_DOUBLEBUFFER:	// always double-buffered RGBA
-  case GLUT_WINDOW_RGBA:
-        return 1;
-
-  case GLUT_WINDOW_COLORMAP_SIZE:	// don't support these
-  case GLUT_WINDOW_NUM_SAMPLES:
-  case GLUT_WINDOW_STEREO:
-        return 0;
- 
- 	case GLUT_WINDOW_CURSOR:
- 		return gState.currentWindow->cursor;	// don't need to lock window since it won't change
-
-	case GLUT_SCREEN_WIDTH:
-		return (int)(BScreen().Frame().Width()) + 1;
-	case GLUT_SCREEN_HEIGHT:
-		return (int)(BScreen().Frame().Height()) + 1;
-	case GLUT_SCREEN_WIDTH_MM:
-		return (int)((BScreen().Frame().Width() + 1) / dots_per_mm);
-	case GLUT_SCREEN_HEIGHT_MM:
-		return (int)((BScreen().Frame().Height() + 1) / dots_per_mm);
-	case GLUT_MENU_NUM_ITEMS:
-		return gState.currentMenu->num;
-	case GLUT_DISPLAY_MODE_POSSIBLE:
-		return __glutConvertDisplayMode(0);	// returns 1 if possible
-	case GLUT_INIT_DISPLAY_MODE:
-		return gState.displayMode;
-	case GLUT_INIT_WINDOW_X:
-		return gState.initX;
-	case GLUT_INIT_WINDOW_Y:
-		return gState.initY;
-	case GLUT_INIT_WINDOW_WIDTH:
-		return gState.initWidth;
-	case GLUT_INIT_WINDOW_HEIGHT:
-		return gState.initHeight;
-	case GLUT_ELAPSED_TIME:
-		bigtime_t elapsed, beginning, now;
-		__glutInitTime(&beginning);
-		now = system_time();
-		elapsed = now - beginning;
-		return (int) (elapsed / 1000);	// 1000 ticks in a millisecond
-	default:
-		__glutWarning("invalid glutGet parameter: %d", state);
-		return -1;
-	}
-}
-
-/***********************************************************
- *	FUNCTION:	glutLayerGet (9.2)
- *
- *	DESCRIPTION:  since we don't support layers, this is easy
- ***********************************************************/
-int glutLayerGet(GLenum info) {
-	switch(info) {
-	case GLUT_OVERLAY_POSSIBLE:
-	case GLUT_HAS_OVERLAY:
-		return 0;
-	case GLUT_LAYER_IN_USE:
-		return GLUT_NORMAL;
-	case GLUT_TRANSPARENT_INDEX:
-		return -1;
-	case GLUT_NORMAL_DAMAGED:
-		return gState.currentWindow->displayEvent;
-	case GLUT_OVERLAY_DAMAGED:
-		return -1;
-	default:
-		__glutWarning("invalid glutLayerGet param: %d", info);
-		return -1;
-	}
-}
-
-/***********************************************************
- *	FUNCTION:	glutDeviceGet (9.3)
- *
- *	DESCRIPTION:  get info about I/O devices we support
- *		easy, since BeOS only supports a keyboard and mouse now
- ***********************************************************/
-int glutDeviceGet(GLenum info) {
-	switch(info) {
-	case GLUT_HAS_KEYBOARD:
-	case GLUT_HAS_MOUSE:
-		return 1;
-
-	case GLUT_HAS_SPACEBALL:
-	case GLUT_HAS_DIAL_AND_BUTTON_BOX:
-	case GLUT_HAS_TABLET:
-	case GLUT_NUM_SPACEBALL_BUTTONS:
-	case GLUT_NUM_BUTTON_BOX_BUTTONS:
-	case GLUT_NUM_DIALS:
-	case GLUT_NUM_TABLET_BUTTONS:
-		return 0;
-	
-	case GLUT_NUM_MOUSE_BUTTONS:
-	    {
-		int32 mouseButtons = 3;		// good guess
-		if(get_mouse_type(&mouseButtons) != B_OK) {
-			__glutWarning("error getting number of mouse buttons");
-		}
-		return mouseButtons;
-	    }
-
-	default:
-		__glutWarning("invalid glutDeviceGet parameter: %d", info);
-		return -1;
-	}
-}
-
-/***********************************************************
- *	FUNCTION:	glutGetModifiers (9.4)
- *
- *	DESCRIPTION:  get the modifier key state for the current window
- ***********************************************************/
-int glutGetModifiers() {
-	if(gState.modifierKeys == (int) ~0) {
-	  __glutWarning(
-		"glutCurrentModifiers: do not call outside core input callback.");
-    return 0;
-	}
-	return gState.modifierKeys;
-}
-
diff --git a/src/glut/beos/glutInit.cpp b/src/glut/beos/glutInit.cpp
deleted file mode 100644
index 401081328f8..00000000000
--- a/src/glut/beos/glutInit.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutInit.cpp
- *
- *	DESCRIPTION:	initialize GLUT state
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <string.h>
-#include <stdlib.h>
-#include <signal.h>
-#include "glutint.h"
-#include "glutState.h"
-#include "glutBlocker.h"
-#include "beos_x11.h"
-
-/***********************************************************
- *	Global variables
- ***********************************************************/
-GlutState gState;
-char *__glutProgramName = NULL;
-
-/***********************************************************
- *	Private variables
- ***********************************************************/
-static int __glutArgc;
-static char **__glutArgv;
-
-/***********************************************************
- *	FUNCTION:	__glutInitTime
- *
- *	DESCRIPTION:  set up start time variable
- ***********************************************************/
-void __glutInitTime(bigtime_t *beginning)
-{
-  static int beenhere = 0;
-  static bigtime_t genesis;
-
-  if (!beenhere) {
-    genesis = system_time();
-    beenhere = 1;
-  }
-  *beginning = genesis;
-}
-
-/***********************************************************
- *	FUNCTION:	removeArgs
- *
- *	DESCRIPTION:  helper function for glutInit to remove args
- *		from argv variable passed in
- ***********************************************************/
-static void
-removeArgs(int *argcp, char **argv, int numToRemove)
-{
-  int i, j;
-
-  for (i = 0, j = numToRemove; argv[j]; i++, j++) {
-    argv[i] = argv[j];
-  }
-  argv[i] = NULL;
-  *argcp -= numToRemove;
-}
-
-/***********************************************************
- *	FUNCTION:	bAppThread
- *
- *	DESCRIPTION:  starts the BApplication message loop running
- ***********************************************************/
-static int32 bAppThread(void *arg) {
-	be_app->Lock();
-	return be_app->Run();
-}
-
-/***********************************************************
- *	FUNCTION:	sigHandler
- *
- *	DESCRIPTION:  shuts down the app on CTRL-C
- ***********************************************************/
-static void sigHandler(int) {
-  gState.quitAll = true;
-  gBlock.NewEvent();
-}
-
-/***********************************************************
- *	FUNCTION:	glutInit (2.1)
- *
- *	DESCRIPTION:  create BApplication, parse cmd-line arguments,
- *		and set up gState structure.
- ***********************************************************/
-void glutInit(int *argcp, char **argv) {
-  char *str, *geometry = NULL;
-  int i;
-
-  if (gState.display) {
-    __glutWarning("glutInit being called a second time.");
-    return;
-  }
-  /* Determine temporary program name. */
-  str = strrchr(argv[0], '/');
-  if (str == NULL) {
-    __glutProgramName = argv[0];
-  } else {
-    __glutProgramName = str + 1;
-  }
-
-  /* Make private copy of command line arguments. */
-  __glutArgc = *argcp;
-  __glutArgv = (char **) malloc(__glutArgc * sizeof(char *));
-  if (!__glutArgv)
-    __glutFatalError("out of memory.");
-  for (i = 0; i < __glutArgc; i++) {
-    __glutArgv[i] = strdup(argv[i]);
-    if (!__glutArgv[i])
-      __glutFatalError("out of memory.");
-  }
-
-  /* determine permanent program name */
-  str = strrchr(__glutArgv[0], '/');
-  if (str == NULL) {
-    __glutProgramName = __glutArgv[0];
-  } else {
-    __glutProgramName = str + 1;
-  }
-
-  /* parse arguments for standard options */
-  for (i = 1; i < __glutArgc; i++) {
-    if (!strcmp(__glutArgv[i], "-display")) {
-      __glutWarning("-display option only valid for X glut.");
-      if (++i >= __glutArgc) {
-        __glutFatalError(
-          "follow -display option with X display name.");
-      }
-      removeArgs(argcp, &argv[1], 2);
-    } else if (!strcmp(__glutArgv[i], "-geometry")) {
-      if (++i >= __glutArgc) {
-        __glutFatalError(
-          "follow -geometry option with geometry parameter.");
-      }
-      geometry = __glutArgv[i];
-      removeArgs(argcp, &argv[1], 2);
-    } else if (!strcmp(__glutArgv[i], "-direct")) {
-      __glutWarning("-direct option only valid for X glut.");
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-indirect")) {
-      __glutWarning("-indirect option only valid for X glut.");
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-iconic")) {
-      __glutWarning("-iconic option doesn't make sense in BeOS.");
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-gldebug")) {
-      gState.debug = true;
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-sync")) {
-      __glutWarning("-sync option only valid for X glut.");
-      removeArgs(argcp, &argv[1], 1);
-    } else {
-      /* Once unknown option encountered, stop command line
-         processing. */
-      break;
-    }
-  }
-  
-  __glutInit();  /* Create BApplication first so DisplayWidth() works */
-  if (geometry) {
-    int flags, x, y, width, height;
-
-    /* Fix bogus "{width|height} may be used before set"
-       warning */
-    width = 0;
-    height = 0;
-
-    flags = XParseGeometry(geometry, &x, &y,
-      (unsigned int *) &width, (unsigned int *) &height);
-    if (WidthValue & flags) {
-      /* Careful because X does not allow zero or negative
-         width windows */
-      if (width > 0)
-        gState.initWidth = width;
-    }
-    if (HeightValue & flags) {
-      /* Careful because X does not allow zero or negative
-         height windows */
-      if (height > 0)
-        gState.initHeight = height;
-    }
-    if (XValue & flags) {
-      if (XNegative & flags)
-        x = DisplayWidth() + x - gState.initWidth;
-      /* Play safe: reject negative X locations */
-      if (x >= 0)
-        gState.initX = x;
-    }
-    if (YValue & flags) {
-      if (YNegative & flags)
-        y = DisplayHeight() + y - gState.initHeight;
-      /* Play safe: reject negative Y locations */
-      if (y >= 0)
-        gState.initY = y;
-    }
-  }
-}
-
-/***********************************************************
- *	FUNCTION:	__glutInit
- *
- *	DESCRIPTION:  create BApplication, parse cmd-line arguments,
- *		and set up gState structure.
- ***********************************************************/
-void __glutInit() {
-  // open BApplication
-  gState.display = new BApplication("application/x-glut-demo");
-  be_app->Unlock();
-  gState.appthread = spawn_thread(bAppThread, "BApplication", B_NORMAL_PRIORITY, 0);
-  resume_thread(gState.appthread);
-
-  bigtime_t unused;
-  __glutInitTime(&unused);
-
-  /* set atexit() function to destroy all windows before exiting */
-  if(atexit(__glutDestroyAllWindows))
-  	__glutFatalError("can't set exit handler");
-  
-  /* similarly, destroy all windows on CTRL-C */
-  signal(SIGINT, sigHandler);
-}
-
-/***********************************************************
- *	FUNCTION:	glutInitWindowPosition (2.2)
- *
- *	DESCRIPTION:  set initial window position
- ***********************************************************/
-void glutInitWindowPosition(int x, int y) {
-	gState.initX = x;
-	gState.initY = y;
-}
-
-/***********************************************************
- *	FUNCTION:	glutInitWindowSize (2.2)
- *
- *	DESCRIPTION:  set initial window size
- ***********************************************************/
-void glutInitWindowSize(int width, int height) {
-	gState.initWidth = width;
-	gState.initHeight = height;
-}
-
-/***********************************************************
- *	FUNCTION:	glutInitDisplayMode (2.3)
- *
- *	DESCRIPTION:  set initial display mode
- ***********************************************************/
-void glutInitDisplayMode(unsigned int mode) {
-	gState.displayMode = mode;
-}
diff --git a/src/glut/beos/glutMenu.cpp b/src/glut/beos/glutMenu.cpp
deleted file mode 100644
index 2f9e6a2c67c..00000000000
--- a/src/glut/beos/glutMenu.cpp
+++ /dev/null
@@ -1,326 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *  FILE:	glutMenu.cpp
- *
- *	DESCRIPTION:	code for popup menu handling
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <stdlib.h>
-#include <string.h>
-#include "glutint.h"
-#include "glutState.h"
-
-/***********************************************************
- *	Private variables
- ***********************************************************/
-static GlutMenu **menuList = 0;
-static int menuListSize = 0;
-
-/***********************************************************
- *	FUNCTION:	getUnusedMenuSlot
- *
- *	DESCRIPTION:  helper function to get a new menu slot
- ***********************************************************/
-GlutMenu *__glutGetMenuByNum(int menunum)
-{
-  if (menunum < 1 || menunum > menuListSize) {
-    return NULL;
-  }
-  return menuList[menunum - 1];
-}
-
-/***********************************************************
- *	FUNCTION:	getUnusedMenuSlot
- *
- *	DESCRIPTION:  helper function to get a new menu slot
- ***********************************************************/
-static int
-getUnusedMenuSlot(void)
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < menuListSize; i++) {
-    if (!menuList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  menuListSize++;
-  menuList = (GlutMenu **)
-      realloc(menuList, menuListSize * sizeof(GlutMenu *));
-  if (!menuList)
-    __glutFatalError("out of memory.");
-  menuList[menuListSize - 1] = NULL;
-  return menuListSize - 1;
-}
-
-/***********************************************************
- *	FUNCTION:	glutCreateMenu (6.1)
- *
- *	DESCRIPTION:  create a new menu
- ***********************************************************/
-int APIENTRY 
-glutCreateMenu(GLUTselectCB selectFunc)
-{
-  GlutMenu *menu;
-  int menuid;
-
-  menuid = getUnusedMenuSlot();
-  menu = new GlutMenu(menuid, selectFunc);	// constructor sets up members
-  menuList[menuid] = menu;
-  gState.currentMenu = menu;
-  return menuid + 1;
-}
-
-/***********************************************************
- *	FUNCTION:	glutSetMenu (6.2)
- *				glutGetMenu
- *
- *	DESCRIPTION:  set and get the current menu
- ***********************************************************/
-int APIENTRY 
-glutGetMenu(void)
-{
-  if (gState.currentMenu) {
-    return gState.currentMenu->id + 1;
-  } else {
-    return 0;
-  }
-}
-
-void APIENTRY 
-glutSetMenu(int menuid)
-{
-  GlutMenu *menu;
-
-  if (menuid < 1 || menuid > menuListSize) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  menu = menuList[menuid - 1];
-  if (!menu) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  gState.currentMenu = menu;
-}
-
-/***********************************************************
- *	FUNCTION:	glutDestroyMenu (6.3)
- *
- *	DESCRIPTION:  destroy the specified menu
- ***********************************************************/
-void APIENTRY 
-glutDestroyMenu(int menunum)
-{
-  GlutMenu *menu = __glutGetMenuByNum(menunum);
-  menuList[menunum - 1] = 0;
-  if (gState.currentMenu == menu) {
-    gState.currentMenu = 0;
-  }
-  delete menu;
-}
-
-/***********************************************************
- *	FUNCTION:	glutAddMenuEntry (6.4)
- *
- *	DESCRIPTION:  add a new menu item
- ***********************************************************/
-void
-glutAddMenuEntry(const char *label, int value)
-{
-	new GlutMenuItem(gState.currentMenu, false, value, label);
-}
-
-/***********************************************************
- *	FUNCTION:	glutAddSubMenu (6.5)
- *
- *	DESCRIPTION:  add a new submenu
- ***********************************************************/
-void
-glutAddSubMenu(const char *label, int menu)
-{
-	new GlutMenuItem(gState.currentMenu, true, menu-1, label);
-}
-
-/***********************************************************
- *	FUNCTION:	glutChangeToMenuEntry (6.6)
- *
- *	DESCRIPTION:  change menuitem into a menu entry
- ***********************************************************/
-void
-glutChangeToMenuEntry(int num, const char *label, int value)
-{
-  GlutMenuItem *item;
-  int i;
-
-  i = gState.currentMenu->num;
-  item = gState.currentMenu->list;
-  while (item) {
-    if (i == num) {
-      free(item->label);
-      item->label = strdup(label);
-      item->isTrigger = false;
-      item->value = value;
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-/***********************************************************
- *	FUNCTION:	glutChangeToSubMenu (6.7)
- *
- *	DESCRIPTION:  change menuitem into a submenu
- ***********************************************************/
-void
-glutChangeToSubMenu(int num, const char *label, int menu)
-{
-  GlutMenuItem *item;
-  int i;
-
-  i = gState.currentMenu->num;
-  item = gState.currentMenu->list;
-  while (item) {
-    if (i == num) {
-      free(item->label);
-      item->label = strdup(label);
-      item->isTrigger = true;
-      item->value = menu-1;
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-/***********************************************************
- *	FUNCTION:	glutRemoveMenuItem (6.8)
- *
- *	DESCRIPTION:  remove a menu item
- ***********************************************************/
-void
-glutRemoveMenuItem(int num)
-{
-  GlutMenuItem *item, **prev;
-  int i;
-
-  i = gState.currentMenu->num;
-  prev = &gState.currentMenu->list;
-  item = gState.currentMenu->list;
-
-  while (item) {
-    if (i == num) {
-      gState.currentMenu->num--;
-
-      /* Patch up menu's item list. */
-      *prev = item->next;
-
-      free(item->label);
-      delete item;
-      return;
-    }
-    i--;
-    prev = &item->next;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-/***********************************************************
- *	FUNCTION:	glutAttachMenu (6.9)
- *				glutDetachMenu
- *
- *	DESCRIPTION:  attach and detach menu from view
- ***********************************************************/
-void
-glutAttachMenu(int button)
-{
-	gState.currentWindow->menu[button] = gState.currentMenu->id + 1;
-}
-
-void
-glutDetachMenu(int button)
-{
-	gState.currentWindow->menu[button] = 0;
-}
-
-/***********************************************************
- *	CLASS:		GlutMenu
- *
- *	FUNCTION:	CreateBMenu
- *
- *	DESCRIPTION:  construct a BPopupMenu for this menu
- ***********************************************************/
-BMenu *GlutMenu::CreateBMenu(bool toplevel) {
-	BMenu *bpopup;
-	if(toplevel) {
-		bpopup = new GlutPopUp(id+1);
-	} else {
-		bpopup = new BMenu("");
-	}
-	GlutMenuItem *item = list;
-	while (item) {
-		GlutBMenuItem *bitem;
-		if(item->isTrigger) {
-			// recursively call CreateBMenu
-			bitem = new GlutBMenuItem(menuList[item->value]->CreateBMenu(false));
-			bitem->SetLabel(item->label);
-			bitem->menu = 0;	// real menu items start at 1
-			bitem->value = 0;
-		} else {
-			bitem = new GlutBMenuItem(item->label);
-			bitem->menu = id + 1;
-			bitem->value = item->value;
-		}
-		bpopup->AddItem(bitem, 0);
-		item = item->next;
-	}
-	return bpopup;
-}
-
-/***********************************************************
- *	CLASS:		GlutMenu
- *
- *	FUNCTION:	(destructor)
- *
- *	DESCRIPTION:  destroy the menu and its items (but not submenus!)
- ***********************************************************/
-GlutMenu::~GlutMenu() {
-	while (list) {
-		GlutMenuItem *next = list->next;
-		delete list;
-		list = next;
-	}
-}
-
-/***********************************************************
- *	CLASS:		GlutMenuItem
- *
- *	FUNCTION:	(constructor)
- *
- *	DESCRIPTION:  construct the new menu item and add to parent
- ***********************************************************/
-GlutMenuItem::GlutMenuItem(GlutMenu *n_menu, bool n_trig, int n_value, const char *n_label)
-{
-	menu = n_menu;
-	isTrigger = n_trig;
-	value = n_value;
-	label = strdup(n_label);
-	next = menu->list;
-	menu->list = this;
-	menu->num++;
-}
diff --git a/src/glut/beos/glutMenu.h b/src/glut/beos/glutMenu.h
deleted file mode 100644
index 1ee170694b8..00000000000
--- a/src/glut/beos/glutMenu.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *  FILE:	glutMenu.h
- *
- *	DESCRIPTION:	the GlutMenu class is a simple popup menu
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <Menu.h>
-#include <MenuItem.h>
-#include <PopUpMenu.h>
-
-/***********************************************************
- *	Definitions
- ***********************************************************/
-const int32 MENU_ITEM = 'menu';
-
-/***********************************************************
- *	CLASS:	GlutMenu
- ***********************************************************/
-class GlutMenuItem;
-class GlutPopUp;
-class GlutMenu {
-public:
-	GlutMenu(int n_id, GLUTselectCB n_select) {
-		id = n_id;
-		select = n_select;
-		list = 0;
-		num = 0;
-	}
-	~GlutMenu();
-	BMenu *CreateBMenu(bool toplevel=true);	// construct BPopUpMenu
-
-	// public data
-	int id;
-	GLUTselectCB select;	// callback function
-	GlutMenuItem *list;		// list of menu items
-	int num;				// number of items
-};
-
-/***********************************************************
- *	CLASS:	GlutMenuItem
- ***********************************************************/
-class GlutMenuItem {
-public:
-	GlutMenuItem(GlutMenu *n_menu, bool n_trig, int n_value, const char *n_label);
-
-	// public data
-	GlutMenu *menu;		// parent menu
-	bool isTrigger;		// are we a submenu?
-	int value;			// value to send, or submenu id if isTrigger
-	char *label;		// strdup'ed label string
-	GlutMenuItem *next; // next menu entry on list
-};
-
-/***********************************************************
- *	CLASS:	GlutPopUp
- ***********************************************************/
-class GlutPopUp : public BPopUpMenu {
-public:
-	GlutPopUp(int m) : BPopUpMenu(0, false, false) { menu = m;}
-	
-	BPoint point;	// point to start menu
-	GlutWindow *win;	// pointer to my window
-	int menu;		// my menu number
-};
-
-/***********************************************************
- *	CLASS:	GlutBMenuItem
- ***********************************************************/
-class GlutBMenuItem : public BMenuItem {
-public:
-	GlutBMenuItem(const char *name) : BMenuItem(name, 0) {}
-	GlutBMenuItem(BMenu* menu) : BMenuItem(menu) {}
-	int menu, value;
-};
diff --git a/src/glut/beos/glutOverlay.cpp b/src/glut/beos/glutOverlay.cpp
deleted file mode 100644
index fed757fe954..00000000000
--- a/src/glut/beos/glutOverlay.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutOverlay.cpp
- *
- *	DESCRIPTION:	we don't support overlays, so this code is
- *		really simple
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include "glutint.h"
-
-void glutEstablishOverlay() {
-	__glutFatalError("BeOS lacks overlay support.");
-}
-
-void glutUseLayer(GLenum layer) {
-	// ignore
-}
-
-void glutRemoveOverlay() {
-	// ignore
-}
-
-void glutPostOverlayRedisplay() {
-	// ignore
-}
-
-void glutShowOverlay() {
-	// ignore
-}
-
-void glutHideOverlay() {
-	// ignore
-}
-
-void glutPostWindowOverlayRedisplay(int win) {
-	// ignore
-}
diff --git a/src/glut/beos/glutState.h b/src/glut/beos/glutState.h
deleted file mode 100644
index 9c44eb6b53a..00000000000
--- a/src/glut/beos/glutState.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutState.h
- *
- *	DESCRIPTION:	the global state for GLUT
- *		(takes the place of glutint.h in the C version)
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <Application.h>
-#include "glutWindow.h"
-#include "glutMenu.h"
-
-/***********************************************************
- *	CLASS:	GlutState
- *
- *	DESCRIPTION:	all the global state variables
- ***********************************************************/
-struct GlutState {
-	BApplication *display;
-	thread_id appthread;
-	
-	int initX, initY;			// initial window position
-	int initWidth, initHeight;	// initial window size
-	unsigned int displayMode;	// initial display mode
-	char *displayString;		// verbose display mode
-
-	GlutWindow *currentWindow;	// current window
-	GlutMenu *currentMenu;		// current menu
-	
-	GlutWindow **windowList;	// array of pointers to windows
-	int windowListSize;			// size of window list
-	
-	GLUTidleCB idle;				// idle callback
-	GLUTmenuStatusCB menuStatus;	// menu status callback
-	int modifierKeys;				// only valid during keyboard callback
-	
-	bool debug;					// call glGetError
-	bool quitAll;				// quit 
-	
-	GlutState() {
-		display = 0;
-		appthread = 0;
-		initX = initY = -1;
-		initWidth = initHeight = 300;
-		displayMode = GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH;
-		displayString = 0;
-		currentWindow = 0;
-		currentMenu = 0;
-		windowList = 0;
-		windowListSize = 0;
-		idle = 0;
-		menuStatus = 0;
-		modifierKeys = ~0;
-		debug = quitAll = false;
-	}
-};
-
-/***********************************************************
- *	Global variable (declared in glutInit.cpp)
- ***********************************************************/
-extern GlutState gState;
diff --git a/src/glut/beos/glutWindow.cpp b/src/glut/beos/glutWindow.cpp
deleted file mode 100644
index 66ea2a00a83..00000000000
--- a/src/glut/beos/glutWindow.cpp
+++ /dev/null
@@ -1,633 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutWindow.cpp
- *
- *	DESCRIPTION:	all the routines for dealing with GlutWindows
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <stdlib.h>
-#include "glutint.h"
-#include "glutState.h"
-#include "glutBlocker.h"
-
-/***********************************************************
- *	FUNCTION:	getUnusedWindowSlot
- *
- *	DESCRIPTION:  helper function to get a new window slot
- ***********************************************************/
-static int
-getUnusedWindowSlot()
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < gState.windowListSize; i++) {
-    if (!gState.windowList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  gState.windowListSize++;
-  gState.windowList = (GlutWindow **)
-    realloc(gState.windowList,
-      gState.windowListSize * sizeof(GlutWindow *));
-
-  if (!gState.windowList)
-    __glutFatalError("out of memory.");
-  gState.windowList[gState.windowListSize - 1] = NULL;
-  return gState.windowListSize - 1;
-}
-
-/***********************************************************
- *	FUNCTION:	__glutDefaultDisplay
- *				__glutDefaultReshape
- *
- *	DESCRIPTION:  default display and reshape functions
- ***********************************************************/
-static void
-__glutDefaultDisplay(void)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
-  __glutFatalError(
-    "redisplay needed for window %d, but no display callback.",
-    gState.currentWindow->num + 1);
-}
-
-void
-__glutDefaultReshape(int width, int height)
-{
-  /* Adjust the viewport of the window */
-  glViewport(0, 0, (GLsizei) width, (GLsizei) height);
-}
-
-/***********************************************************
- *	CLASS:		GlutWindow
- *
- *	FUNCTION:	(constructor)
- *
- *	DESCRIPTION:  creates a new GLUT window
- *		note:  subwindows don't resize, but top-level windows
- *		follow all sides
- ***********************************************************/
-GlutWindow::GlutWindow(GlutWindow *nparent, char *name,
-		int x, int y, int width, int height, ulong options) :
-		BGLView(
-		(nparent ? BRect(x,y,x+width-1,y+height-1) :
-			BRect(0,0,width-1,height-1)), name,
-		(nparent ? B_FOLLOW_NONE : B_FOLLOW_ALL_SIDES), 
-		B_WILL_DRAW|B_FRAME_EVENTS|B_FULL_UPDATE_ON_RESIZE|B_PULSE_NEEDED,
-		options)
-{
-	// add myself to window list
-	num = getUnusedWindowSlot();
-	gState.windowList[num] = this;
-
-	// set up parent/children relationships
-	parent = nparent;
-	if (parent) {
-		siblings = parent->children;
-		parent->children = this;
-	} else {
-		siblings = 0;
-	}
-	children = 0;
-		
-	// initialize variables
-	cursor = GLUT_CURSOR_INHERIT;	// default cursor
-	for (int i = 0; i < GLUT_MAX_MENUS; i++) {
-		menu[i] = 0;
-	}
-	m_width = width;
-	m_height = height;
-	m_buttons = 0;
-	
-	// clear callbacks
-	display = __glutDefaultDisplay;
-	reshape = __glutDefaultReshape;
-	mouse = 0;
-	motion = 0;
-	passive = 0;
-	entry = 0;
-	keyboard = 0;
-	visibility = 0;
-	special = 0;
-	windowStatus = 0;
-		
-	// clear event counters
-	anyevents = 1;
-	displayEvent = 1;	// get a reshape and a display event right away
-	reshapeEvent = 1;
-	mouseEvent = 0;
-	motionEvent = 0;
-	passiveEvent = 0;
-	entryEvent = 0;
-	keybEvent = 0;
-	windowStatusEvent = 0; // DirectConnected() will report change in 
-	visState = -1;         // visibility
-	specialEvent = 0;
-	statusEvent = 0;
-	menuEvent = 0;
-	visible = true;
-	gBlock.QuickNewEvent();
-	
-	// if i'm a subwindow, add me to my parent view
-	if (parent) {
-		parent->Window()->Lock();
-		parent->AddChild(this);
-		parent->Window()->Unlock();
-	} else {
-		// if I'm a top-level window, create my BWindow
-		GlutBWindow *mybwindow = new GlutBWindow(
-			BRect(x,y,x+width-1,y+height-1), name);
-		mybwindow->AddChild(this);
-		mybwindow->bgl = this;
-		mybwindow->Show();
-	}
-	
-	// give me the keyboard focus (focus follows mouse, X style, as
-	// implemented in GlutWindow::MouseMoved())
-	Window()->Lock();
-	MakeFocus();
-	Window()->Unlock();
-	
-	// make myself the default window
-	__glutSetWindow(this);
-}
-
-/***********************************************************
- *	FUNCTION:	glutCreateWindow (4.1)
- *
- *	DESCRIPTION:  creates a new GLUT window
- ***********************************************************/
-int glutCreateWindow(const char *name) {
-	if (!be_app)
-		__glutInit();
-
-	ulong options;
-	if (!__glutConvertDisplayMode(&options)) {
-		__glutWarning("visual with necessary capabilities not found.");
-	}
-	
-	// if X or Y is negative, then start at a reasonable position
-	bool defaultxy = (gState.initX < 0) || (gState.initY < 0);
-	
-	GlutWindow *window = new GlutWindow(0, const_cast<char*>(name), 
-		(defaultxy ? 50 : gState.initX), (defaultxy ? 50 : gState.initY), 
-		gState.initWidth, gState.initHeight, options);
-		
-	return window->num + 1;
-}
-
-/***********************************************************
- *	FUNCTION:	glutCreateSubWindow (4.2)
- *
- *	DESCRIPTION:  creates a new GLUT subwindow
- *		Note: a subwindow is a GlutWindow (which is actually
- *		a BGLView) without its own BWindow
- ***********************************************************/
-int glutCreateSubWindow(int win, int x, int y, int width, int height) {
-	ulong options;
-	if (!__glutConvertDisplayMode(&options)) {
-		__glutFatalError("visual with necessary capabilities not found.");
-	}
-	
-	GlutWindow *window = new GlutWindow(gState.windowList[win-1], "child",
-		x, y, width, height, options);
-	
-	return window->num + 1;
-}
-
-/***********************************************************
- *	FUNCTION:	__glutSetWindow
- *
- *	DESCRIPTION:  set the current window (utility function)
- ***********************************************************/
-void
-__glutSetWindow(GlutWindow * window)
-{
-  if (gState.currentWindow)
-	  gState.currentWindow->UnlockGL();
-  gState.currentWindow = window;
-  gState.currentWindow->LockGL();
-}
-
-/***********************************************************
- *	FUNCTION:	glutSetWindow (4.3)
- *				glutGetWindow
- *
- *	DESCRIPTION:  set and get the current window
- ***********************************************************/
-void glutSetWindow(int win) {
-  GlutWindow *window;
-
-  if (win < 1 || win > gState.windowListSize) {
-    __glutWarning("glutSetWindow attempted on bogus window.");
-    return;
-  }
-  window = gState.windowList[win - 1];
-  if (!window) {
-    __glutWarning("glutSetWindow attempted on bogus window.");
-    return;
-  }
-  __glutSetWindow(window);
-}
-
-int glutGetWindow() {
-  if (gState.currentWindow) {
-    return gState.currentWindow->num + 1;
-  } else {
-    return 0;
-  }
-}
-
-/***********************************************************
- *	FUNCTION:	__glutDestroyWindow
- *
- *	DESCRIPTION:  recursively set entries to 0
- ***********************************************************/
-static void
-__glutDestroyWindow(GlutWindow *window, GlutWindow *initialWindow) {
-	// first, find all children recursively and set their entries to 0
-	GlutWindow *cur = window->children;
-	while (cur) {
-		GlutWindow *siblings = cur->siblings;
-		__glutDestroyWindow(cur, initialWindow);
-		cur = siblings;
-	}
-	
-  /* Remove from parent's children list (only necessary for
-     non-initial windows and subwindows!). */
-  GlutWindow *parent = window->parent;
-  if (parent && parent == initialWindow->parent) {
-    GlutWindow **prev = &parent->children;
-    cur = parent->children;
-    while (cur) {
-      if (cur == window) {
-        *prev = cur->siblings;
-        break;
-      }
-      prev = &(cur->siblings);
-      cur = cur->siblings;
-    }
-  }
-  
-  // finally, check if we are the current window, and set to 0
-  if (gState.currentWindow == window) {
-  	gState.currentWindow = 0;
-  }
-  gState.windowList[window->num] = 0;
-}
-
-/***********************************************************
- *	FUNCTION:	glutDestroyWindow (4.4)
- *
- *	DESCRIPTION:  destroy window and all its children
- ***********************************************************/
-void glutDestroyWindow(int win) {
-	// can't destroy a window if another window has the GL context
-	if (gState.currentWindow)
-		gState.currentWindow->UnlockGL();
-
-	// lock the window
-	GlutWindow *window = gState.windowList[win-1];
-	BWindow *bwindow = window->Window();
-	bwindow->Lock();
-
-	// if win is the current window, set current window to 0
-	if (gState.currentWindow == window) {
-		gState.currentWindow = 0;
-	}
-
-	// recursively set child entries to 0
-	__glutDestroyWindow(window, window);
-
-	// try flushing OpenGL
-	window->LockGL();
-	glFlush();
-	window->UnlockGL();
-
-	// now, if the window was top-level, delete its BWindow
-	if(!window->parent) {
-		bwindow->Quit();
-	} else {
-		// else, detach it from the BWindow and delete it
-		window->RemoveSelf();
-		delete window;
-		bwindow->Unlock();
-	}
-	// relock GL if the current window is still valid
-	if(gState.currentWindow)
-		gState.currentWindow->LockGL();
-}
-
-/***********************************************************
- *	FUNCTION:	__glutDestroyAllWindows
- *
- *	DESCRIPTION:  destroy all windows when exit() is called
- *                this seems to be necessary to avoid delays
- *                and crashes when using BDirectWindow
- ***********************************************************/
-void __glutDestroyAllWindows() {
-	for(int i=0; i<gState.windowListSize; i++) {
-		if (gState.windowList[i]) {
-			glutDestroyWindow(i + 1);
-		}
-	}
-	gState.display->Lock();
-	gState.display->Quit();
-	status_t ignored;
-	wait_for_thread(gState.appthread, &ignored);
-}
-
-/***********************************************************
- *	FUNCTION:	glutPostRedisplay (4.5)
- *
- *	DESCRIPTION:  mark window as needing redisplay
- ***********************************************************/
-void glutPostRedisplay() {
-	gState.currentWindow->Window()->Lock();
-	gState.currentWindow->anyevents = true;
-	gState.currentWindow->displayEvent = true;
-	gState.currentWindow->Window()->Unlock();
-	gBlock.QuickNewEvent();
-}
-
-/***********************************************************
- *	FUNCTION:	glutPostWindowRedisplay
- *
- *	DESCRIPTION:  mark window as needing redisplay
- ***********************************************************/
-void glutPostWindowRedisplay(int win) {
-	GlutWindow *gwin = gState.windowList[win - 1];
-	gwin->Window()->Lock();
-	gwin->anyevents = true;
-	gwin->displayEvent = true;
-	gwin->Window()->Unlock();
-	gBlock.QuickNewEvent();
-}
-
-/***********************************************************
- *	FUNCTION:	glutSwapBuffers (4.6)
- *
- *	DESCRIPTION:  swap buffers
- ***********************************************************/
-void glutSwapBuffers() {
-	gState.currentWindow->SwapBuffers();
-}
-
-/***********************************************************
- *	FUNCTION:	glutPositionWindow (4.7)
- *
- *	DESCRIPTION:  move window
- ***********************************************************/
-void glutPositionWindow(int x, int y) {
-	BDirectWindow *win = dynamic_cast<BDirectWindow*>(gState.currentWindow->Window());
-	win->Lock();
-	if (gState.currentWindow->parent)
-		gState.currentWindow->MoveTo(x, y);	// move the child view
-	else {
-		if(win->IsFullScreen()) {
-			win->SetFullScreen(false);
-		}
-		win->MoveTo(x, y);  // move the window
-	}
-	win->Unlock();
-}
-
-/***********************************************************
- *	FUNCTION:	glutReshapeWindow (4.8)
- *
- *	DESCRIPTION:  reshape window (we'll catch the callback
- *				when the view gets a Draw() message
- ***********************************************************/
-void glutReshapeWindow(int width, int height) {
-	BDirectWindow *win = dynamic_cast<BDirectWindow*>(gState.currentWindow->Window());
-	win->Lock();
-	if (gState.currentWindow->parent)
-		gState.currentWindow->ResizeTo(width-1, height-1);		// resize the child
-	else {
-		if(win->IsFullScreen()) {
-			win->SetFullScreen(false);
-		}
-		win->ResizeTo(width-1, height-1);  // resize the parent
-	}
-	win->Unlock();
-}
-
-/***********************************************************
- *	FUNCTION:	glutFullScreen (4.9)
- *
- *	DESCRIPTION:  makes the window full screen
- ***********************************************************/
-void glutFullScreen() {
-	BDirectWindow *win = dynamic_cast<BDirectWindow*>(gState.currentWindow->Window());
-	win->Lock();
-	win->SetFullScreen(true);
-	win->Unlock();
-}
-
-/***********************************************************
- *	FUNCTION:	glutPopWindow (4.10)
- *				glutPushWindow
- *
- *	DESCRIPTION:  change the stacking order of the current window
- *		NOTE:	I can't figure out how to do this for windows,
- *				and there is no concept of "stacking order" for
- *				subwindows, so these are currently no-ops.
- ***********************************************************/
-void glutPopWindow() { }
-void glutPushWindow() { }
-
-/***********************************************************
- *	FUNCTION:	glutShowWindow (4.11)
- *				glutHideWindow
- *				glutIconifyWindow
- *
- *	DESCRIPTION:  change display status of current window
- ***********************************************************/
-void glutShowWindow() {
-	gState.currentWindow->Window()->Lock();
-	if (gState.currentWindow->parent)	// subwindow
-		gState.currentWindow->Show();
-	else {
-		if(gState.currentWindow->Window()->IsHidden())
-			gState.currentWindow->Window()->Show();	// show the actual BWindow
-		gState.currentWindow->Window()->Minimize(false);
-	}
-	gState.currentWindow->Window()->Unlock();
-}
-
-void glutHideWindow() {
-	gState.currentWindow->Window()->Lock();
-	if (gState.currentWindow->parent)	// subwindow
-		gState.currentWindow->Hide();
-	else
-		gState.currentWindow->Window()->Hide();	// show the actual BWindow
-	gState.currentWindow->Window()->Unlock();
-}
-
-void glutIconifyWindow() {
-	if(gState.currentWindow->parent)
-		__glutFatalError("can't iconify a subwindow");
-		
-	gState.currentWindow->Window()->Lock();
-	gState.currentWindow->Window()->Minimize(true);
-	gState.currentWindow->Window()->Unlock();
-}
-
-/***********************************************************
- *	FUNCTION:	glutSetWindowTitle (4.12)
- *				glutSetIconTitle
- *
- *	DESCRIPTION:  set the window title (icon title is same)
- ***********************************************************/
-void glutSetWindowTitle(const char *name) {
-	if (gState.currentWindow->parent)
-		__glutFatalError("glutSetWindowTitle: isn't a top-level window");
-	
-	gState.currentWindow->Window()->Lock();
-	gState.currentWindow->Window()->SetTitle(name);
-	gState.currentWindow->Window()->Unlock();
-}
-
-void glutSetIconTitle(const char *name) {
-	glutSetWindowTitle(name);
-}
-
-/***********************************************************
- *	FUNCTION:	__glutConvertDisplayMode
- *
- *	DESCRIPTION:  converts the current display mode into a BGLView
- *		display mode, printing warnings as appropriate.
- *
- *	PARAMETERS:	 if options is non-NULL, the current display mode is
- *		returned in it.
- *
- *	RETURNS:	1 if the current display mode is possible, else 0
- ***********************************************************/
-int __glutConvertDisplayMode(unsigned long *options) {
-	if (gState.displayString) {
-		/* __glutDisplayString should be NULL except if
-       glutInitDisplayString has been called to register a
-       different display string.  Calling glutInitDisplayString
-       means using a string instead of an integer mask determine
-       the visual to use.  This big ugly code is in glutDstr.cpp */
-       return __glutConvertDisplayModeFromString(options);
-    }
-
-	if(options) {
-		ulong newoptions = 0;
-		if(gState.displayMode & GLUT_ACCUM)
-			newoptions |= BGL_ACCUM;
-		if(gState.displayMode & GLUT_ALPHA)
-			newoptions |= BGL_ALPHA;
-		if(gState.displayMode & GLUT_DEPTH)
-			newoptions |= BGL_DEPTH;
-		if(gState.displayMode & GLUT_DOUBLE)
-			newoptions |= BGL_DOUBLE;
-		if(gState.displayMode & GLUT_STENCIL)
-			newoptions |= BGL_STENCIL;
-		*options = newoptions;
-	}
-	
-	if(gState.displayMode & GLUT_INDEX) {
-		__glutWarning("BeOS doesn't support indexed color");
-		return 0;
-	}
-	if(gState.displayMode & GLUT_MULTISAMPLE) {
-		return 1;	// try to go without multisampling
-	}
-	if(gState.displayMode & GLUT_STEREO) {
-		__glutWarning("BeOS doesn't support stereo windows");
-		return 0;
-	}
-	if(gState.displayMode & GLUT_LUMINANCE) {
-		__glutWarning("BeOS doesn't support luminance color model");
-		return 0;
-	}
-	return 1;	// visual supported
-}
-
-/***********************************************************
- *	CLASS:		GlutBWindow
- *
- *	DESCRIPTION:  very thin wrapper around BWindow
- ***********************************************************/
-GlutBWindow::GlutBWindow(BRect frame, char *name) :
-			BDirectWindow(frame, name, B_TITLED_WINDOW, 0) {
-	fConnectionDisabled = false;
-	bgl = 0;
-	SetPulseRate(100000);
-	
-	if (!SupportsWindowMode()) {
-		__glutFatalError("video card doesn't support windowed operation");
-	}
-}
-
-void GlutBWindow::DirectConnected( direct_buffer_info *info ) {
-	bgl->DirectConnected(info);
-	if(bgl && !fConnectionDisabled) {
-		bgl->EnableDirectMode(true);
-	}
-	int newVisState;
-	if((info->buffer_state & B_DIRECT_MODE_MASK) == B_DIRECT_START) {
-		bgl->visible = true;
-	}
-	if(!bgl->visible || info->buffer_state == B_DIRECT_STOP)
-		newVisState = GLUT_HIDDEN;
-	else {
-		if (info->clip_list_count == 0)
-			newVisState = GLUT_FULLY_COVERED;
-		else if (info->clip_list_count == 1)
-			newVisState = GLUT_FULLY_RETAINED;
-		else
-			newVisState = GLUT_PARTIALLY_RETAINED;
-	}
-	if(newVisState != bgl->visState) {
-		bgl->visState = newVisState;
-		bgl->anyevents = bgl->windowStatusEvent = true;
-		gBlock.NewEvent();
-	}
-}
-
-GlutBWindow::~GlutBWindow() {
-	fConnectionDisabled = true;
-	if(bgl) {
-		bgl->EnableDirectMode(false);
-	}
-	if(!IsHidden())
-		Hide();
-	Sync();
-}	
-
-bool GlutBWindow::QuitRequested() {
-	gState.quitAll = true;
-	gBlock.NewEvent();
-	return false;	// don't quit now, wait for main thread to do it
-}
-
-void GlutBWindow::Minimize(bool minimize) {
-	bgl->visible = !minimize;
-	BWindow::Minimize(minimize);
-}
-
-void GlutBWindow::Hide() {
-	BWindow::Hide();
-	bgl->visible = false;
-}
-
-void GlutBWindow::Show() {
-	BWindow::Show();
-	bgl->visible = true;
-}
diff --git a/src/glut/beos/glutWindow.h b/src/glut/beos/glutWindow.h
deleted file mode 100644
index d3ac1862695..00000000000
--- a/src/glut/beos/glutWindow.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/***********************************************************
- *      Copyright (C) 1997, Be Inc.  Copyright (C) 1999, Jake Hamby.
- *
- * 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.
- *
- *
- *  FILE:	glutWindow.h
- *
- *	DESCRIPTION:	the GlutWindow class saves all events for
- *		handling by main thread
- ***********************************************************/
-
-/***********************************************************
- *	Headers
- ***********************************************************/
-#include <GL/glut.h>
-#include <Window.h>
-#include <GLView.h>
-
-/***********************************************************
- *	CLASS:	GlutWindow
- *
- *  INHERITS FROM:  BGLView (NOT BWindow!)
- *
- *  DESCRIPTION:	all information needed for windows and
- *			subwindows (handled as similarly as possible)
- ***********************************************************/
-class GlutWindow : public BGLView {
-public:
-	GlutWindow(GlutWindow *nparent, char *name, int x, int y, int width,
-				int height, ulong options);
-	
-	void KeyDown(const char *bytes, int32 numBytes);
-	void MouseDown(BPoint point);
-	void MouseMoved(BPoint point, uint32 transit, const BMessage *message);
-	void FrameResized(float width, float height);
-	void Draw(BRect updateRect);
-	void Pulse();		// needed since MouseUp() is broken
-	void MouseCheck();	// check for button state changes
-	void ErrorCallback(GLenum errorCode);
-
-	static long MenuThread(void *menu);
-	
-	int num;			// window number returned to user
-	int cursor;			// my cursor
-#define GLUT_MAX_MENUS              3
-	int menu[GLUT_MAX_MENUS];	// my popup menus
-	int m_width, m_height;		// the last width and height reported to GLUT
-	uint32 m_buttons;			// the last mouse button state
-
-	/* Window relationship state. */
-  GlutWindow *parent;   /* parent window */
-  GlutWindow *children; /* first child window */
-  GlutWindow *siblings; /* next sibling */
-
-	// leave out buttons and dials callbacks that we don't support
-  GLUTdisplayCB display;  /* redraw  */
-  GLUTreshapeCB reshape;  /* resize  (width,height) */
-  GLUTmouseCB mouse;    /* mouse  (button,state,x,y) */
-  GLUTmotionCB motion;  /* motion  (x,y) */
-  GLUTpassiveCB passive;  /* passive motion  (x,y) */
-  GLUTentryCB entry;    /* window entry/exit  (state) */
-  GLUTkeyboardCB keyboard;  /* keyboard  (ASCII,x,y) */
-  GLUTvisibilityCB visibility;  /* visibility  */
-  GLUTspecialCB special;  /* special key  */
-  GLUTwindowStatusCB windowStatus;  /* window status */
-
-	bool anyevents;		// were any events received?
-	bool displayEvent;		// call display
-	bool reshapeEvent;		// call reshape
-	bool mouseEvent;		// call mouse
-	bool motionEvent;		// call motion
-	bool passiveEvent;		// call passive
-	bool entryEvent;		// call entry
-	bool keybEvent;			// call keyboard
-	bool windowStatusEvent;		// call visibility
-	bool specialEvent;		// call special
-	bool statusEvent;		// menu status changed
-	bool menuEvent;			// menu selected
-	
-	int button, mouseState; // for mouse callback
-	int mouseX, mouseY; // for mouse callback
-	int motionX, motionY; // for motion callback
-	int passiveX, passiveY; // for passive callback
-	int entryState;  // for entry callback
-	unsigned char key;  // for keyboard callback
-	int keyX, keyY;  // for keyboard callback
-	int visState;  // for visibility callback
-	int specialKey; // for special key callback
-	int specialX, specialY; // for special callback
-	int modifierKeys;	// modifier key state
-	int menuStatus;		// for status callback
-	int statusX, statusY;	// for status callback
-	int menuNumber;		// for menu and status callbacks
-	int menuValue;		// for menu callback
-	bool visible;		// for visibility callback
-};
-
-/***********************************************************
- *	CLASS:	GlutBWindow
- *
- *  INHERITS FROM:	BDirectWindow
- *
- *	DESCRIPTION:  basically a BWindow that won't quit
- ***********************************************************/
-class GlutBWindow : public BDirectWindow {
-public:
-	GlutBWindow(BRect frame, char *name);
-	~GlutBWindow();
-	void DirectConnected(direct_buffer_info *info);
-	bool QuitRequested();	// exits app
-	void Minimize(bool minimized);  // minimized windows are not visible
-	void Hide();
-	void Show();
-	GlutWindow *bgl;
-	bool fConnectionDisabled;
-};
diff --git a/src/glut/beos/glut_8x13.c b/src/glut/beos/glut_8x13.c
deleted file mode 100644
index 843c63d35ae..00000000000
--- a/src/glut/beos/glut_8x13.c
+++ /dev/null
@@ -1,2073 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmap8By13 XXX
-#include "glutbitmap.h"
-#undef glutBitmap8By13
-
-#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 glutBitmap8By13 = {
-"-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1",
-256,
-0,
-chars
-};
-
diff --git a/src/glut/beos/glut_9x15.c b/src/glut/beos/glut_9x15.c
deleted file mode 100644
index 2d5c004e47a..00000000000
--- a/src/glut/beos/glut_9x15.c
+++ /dev/null
@@ -1,2075 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmap9By15 XXX
-#include "glutbitmap.h"
-#undef glutBitmap9By15
-
-#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,9,ch0data};
-#else
-static const BitmapCharRec ch0 = {0,0,0,0,9,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,9,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,9,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,9,ch127data};
-#else
-static const BitmapCharRec ch127 = {0,0,0,0,9,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,9,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,9,0};
-#endif
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch255 = {6,14,-1,3,9,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {7,12,-1,3,9,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch253 = {6,14,-1,3,9,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch252 = {7,11,-1,0,9,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch251 = {7,11,-1,0,9,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch250 = {7,11,-1,0,9,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch249 = {7,11,-1,0,9,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x80,0x7c,0xa2,0xa2,0x92,0x8a,0x8a,0x7c,0x2,
-};
-
-static const BitmapCharRec ch248 = {7,9,-1,1,9,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x10,0x38,0x10,0x0,0xfe,0x0,0x10,0x38,0x10,
-};
-
-static const BitmapCharRec ch247 = {7,9,-1,0,9,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch246 = {7,11,-1,0,9,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {7,11,-1,0,9,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch244 = {7,11,-1,0,9,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch243 = {7,11,-1,0,9,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch242 = {7,11,-1,0,9,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch241 = {7,11,-1,0,9,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x8,0x50,0x30,0x48,
-};
-
-static const BitmapCharRec ch240 = {7,11,-1,0,9,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x50,0x50,
-};
-
-static const BitmapCharRec ch239 = {5,11,-2,0,9,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x90,0x60,
-};
-
-static const BitmapCharRec ch238 = {5,11,-2,0,9,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,0x10,
-};
-
-static const BitmapCharRec ch237 = {5,11,-2,0,9,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x30,0x40,
-};
-
-static const BitmapCharRec ch236 = {5,11,-2,0,9,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch235 = {7,11,-1,0,9,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch234 = {7,11,-1,0,9,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch233 = {7,11,-1,0,9,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch232 = {7,11,-1,0,9,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch231 = {7,10,-1,3,9,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x6e,0x92,0x90,0x7c,0x12,0x92,0x6c,
-};
-
-static const BitmapCharRec ch230 = {7,7,-1,0,9,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x18,0x24,0x18,
-};
-
-static const BitmapCharRec ch229 = {7,11,-1,0,9,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch228 = {7,11,-1,0,9,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch227 = {7,11,-1,0,9,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch226 = {7,11,-1,0,9,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch225 = {7,11,-1,0,9,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch224 = {7,11,-1,0,9,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0x80,0xbc,0xc2,0x82,0x82,0xfc,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch223 = {7,9,-1,1,9,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {7,10,-1,0,9,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,11,-1,0,9,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch220 = {7,11,-1,0,9,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch219 = {7,11,-1,0,9,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch218 = {7,11,-1,0,9,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch217 = {7,11,-1,0,9,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x7c,0xc2,0xa2,0xa2,0x92,0x92,0x8a,0x8a,0x86,0x7c,0x2,
-};
-
-static const BitmapCharRec ch216 = {7,12,-1,1,9,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x82,0x44,0x28,0x10,0x28,0x44,0x82,
-};
-
-static const BitmapCharRec ch215 = {7,7,-1,-1,9,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch214 = {7,11,-1,0,9,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {7,11,-1,0,9,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch212 = {7,11,-1,0,9,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch211 = {7,11,-1,0,9,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch210 = {7,11,-1,0,9,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x82,0x86,0x8a,0x92,0x92,0xa2,0xc2,0x82,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {7,11,-1,0,9,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0xfc,0x42,0x42,0x42,0x42,0xf2,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch208 = {7,10,-1,0,9,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x50,0x50,
-};
-
-static const BitmapCharRec ch207 = {5,11,-2,0,9,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x88,0x70,
-};
-
-static const BitmapCharRec ch206 = {5,11,-2,0,9,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x60,0x10,
-};
-
-static const BitmapCharRec ch205 = {5,11,-2,0,9,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x30,0x40,
-};
-
-static const BitmapCharRec ch204 = {5,11,-2,0,9,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch203 = {7,11,-1,0,9,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch202 = {7,11,-1,0,9,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch201 = {7,11,-1,0,9,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch200 = {7,11,-1,0,9,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch199 = {7,13,-1,3,9,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x9e,0x90,0x90,0x90,0xfc,0x90,0x90,0x90,0x90,0x6e,
-};
-
-static const BitmapCharRec ch198 = {7,10,-1,0,9,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,11,-1,0,9,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch195 = {7,11,-1,0,9,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch194 = {7,11,-1,0,9,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,11,-1,0,9,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,11,-1,0,9,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x7c,0x82,0x82,0x80,0x40,0x20,0x10,0x10,0x0,0x10,
-};
-
-static const BitmapCharRec ch191 = {7,10,-1,0,9,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x6,0x1a,0x12,0xa,0x66,0x92,0x10,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch190 = {7,10,-1,0,9,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x1e,0x10,0xc,0x2,0xf2,0x4c,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch189 = {7,10,-1,0,9,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x6,0x1a,0x12,0xa,0xe6,0x42,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch188 = {7,10,-1,0,9,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x90,0x48,0x24,0x12,0x12,0x24,0x48,0x90,
-};
-
-static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xf8,0x0,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch186 = {5,6,-1,-5,9,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {3,6,-1,-4,9,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0x60,0x90,0x30,
-};
-
-static const BitmapCharRec ch184 = {4,3,-2,3,9,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-4,-4,9,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0xa,0xa,0xa,0xa,0xa,0x7a,0x8a,0x8a,0x8a,0x7e,
-};
-
-static const BitmapCharRec ch182 = {7,10,-1,0,9,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xba,0xc6,0x82,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch181 = {7,9,-1,2,9,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0xc0,0x20,
-};
-
-static const BitmapCharRec ch180 = {3,2,-3,-9,9,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x60,0x90,0x10,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch179 = {4,6,-1,-4,9,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf0,0x80,0x60,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch178 = {4,6,-1,-4,9,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xfe,0x0,0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch177 = {7,9,-1,-1,9,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,-3,-6,9,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch175 = {6,1,-1,-9,9,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x3c,0x42,0xa5,0xa9,0xbd,0xa5,0xb9,0x42,0x3c,
-};
-
-static const BitmapCharRec ch174 = {8,9,0,-1,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch173 = {6,1,-1,-4,9,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x4,0x4,0x4,0xfc,
-};
-
-static const BitmapCharRec ch172 = {6,4,-1,-2,9,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x12,0x24,0x48,0x90,0x90,0x48,0x24,0x12,
-};
-
-static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xf8,0x0,0x78,0x90,0x70,0x90,0x60,
-};
-
-static const BitmapCharRec ch170 = {5,7,-3,-3,9,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x3c,0x42,0x99,0xa5,0xa1,0xa5,0x99,0x42,0x3c,
-};
-
-static const BitmapCharRec ch169 = {8,9,0,-1,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,2,-3,-9,9,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x8,0x70,0x88,0x88,0x88,0x70,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,11,-2,1,9,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,11,-4,1,9,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x10,0x10,0x10,0x7c,0x10,0x7c,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch165 = {7,10,-1,0,9,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x82,0x7c,0x44,0x44,0x7c,0x82,
-};
-
-static const BitmapCharRec ch164 = {7,6,-1,-3,9,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
-};
-
-static const BitmapCharRec ch163 = {7,10,-1,0,9,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x78,0xa4,0xa0,0x90,0x94,0x78,0x8,
-};
-
-static const BitmapCharRec ch162 = {6,8,-1,0,9,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,11,-4,0,9,ch161data};
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x8c,0x92,0x62,
-};
-
-static const BitmapCharRec ch126 = {7,3,-1,-7,9,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xe0,0x10,0x10,0x10,0x20,0x18,0x18,0x20,0x10,0x10,0x10,0xe0,
-};
-
-static const BitmapCharRec ch125 = {5,12,-1,1,9,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,12,-4,1,9,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x38,0x40,0x40,0x40,0x20,0xc0,0xc0,0x20,0x40,0x40,0x40,0x38,
-};
-
-static const BitmapCharRec ch123 = {5,12,-3,1,9,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xfe,0x40,0x20,0x10,0x8,0x4,0xfe,
-};
-
-static const BitmapCharRec ch122 = {7,7,-1,0,9,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch121 = {6,10,-1,3,9,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x82,0x44,0x28,0x10,0x28,0x44,0x82,
-};
-
-static const BitmapCharRec ch120 = {7,7,-1,0,9,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x44,0xaa,0x92,0x92,0x92,0x82,0x82,
-};
-
-static const BitmapCharRec ch119 = {7,7,-1,0,9,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x10,0x28,0x28,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch118 = {7,7,-1,0,9,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch117 = {7,7,-1,0,9,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x1c,0x22,0x20,0x20,0x20,0x20,0xfc,0x20,0x20,
-};
-
-static const BitmapCharRec ch116 = {7,9,-1,0,9,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x7c,0x82,0x2,0x7c,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch115 = {7,7,-1,0,9,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x40,0x40,0x40,0x40,0x42,0x62,0x9c,
-};
-
-static const BitmapCharRec ch114 = {7,7,-1,0,9,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x2,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,
-};
-
-static const BitmapCharRec ch113 = {7,10,-1,3,9,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,
-};
-
-static const BitmapCharRec ch112 = {7,10,-1,3,9,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch111 = {7,7,-1,0,9,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,
-};
-
-static const BitmapCharRec ch110 = {7,7,-1,0,9,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x82,0x92,0x92,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,
-};
-
-static const BitmapCharRec ch108 = {5,10,-2,0,9,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x82,0x8c,0xb0,0xc0,0xb0,0x8c,0x82,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {7,10,-1,0,9,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x78,0x84,0x84,0x84,0x4,0x4,0x4,0x4,0x4,0x1c,0x0,0x0,0xc,
-};
-
-static const BitmapCharRec ch106 = {6,13,-1,3,9,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,
-};
-
-static const BitmapCharRec ch105 = {5,10,-2,0,9,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {7,10,-1,0,9,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x7c,0x82,0x82,0x7c,0x80,0x78,0x84,0x84,0x84,0x7a,
-};
-
-static const BitmapCharRec ch103 = {7,10,-1,3,9,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x20,0x20,0x20,0x20,0xf8,0x20,0x20,0x22,0x22,0x1c,
-};
-
-static const BitmapCharRec ch102 = {7,10,-1,0,9,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch101 = {7,7,-1,0,9,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,0x2,0x2,0x2,
-};
-
-static const BitmapCharRec ch100 = {7,10,-1,0,9,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch99 = {7,7,-1,0,9,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {7,10,-1,0,9,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,
-};
-
-static const BitmapCharRec ch97 = {7,7,-1,0,9,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x10,0x20,0x40,0xc0,
-};
-
-static const BitmapCharRec ch96 = {4,4,-3,-6,9,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,
-};
-
-static const BitmapCharRec ch95 = {8,1,0,1,9,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x82,0x44,0x28,0x10,
-};
-
-static const BitmapCharRec ch94 = {7,4,-1,-6,9,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xf0,
-};
-
-static const BitmapCharRec ch93 = {4,12,-2,1,9,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x2,0x4,0x4,0x8,0x10,0x10,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch92 = {7,10,-1,0,9,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xf0,
-};
-
-static const BitmapCharRec ch91 = {4,12,-3,1,9,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xfe,0x80,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch90 = {7,10,-1,0,9,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,10,-1,0,9,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x82,0x82,0x44,0x28,0x10,0x10,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch88 = {7,10,-1,0,9,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x44,0xaa,0x92,0x92,0x92,0x92,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch87 = {7,10,-1,0,9,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x28,0x28,0x28,0x44,0x44,0x44,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,10,-1,0,9,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch85 = {7,10,-1,0,9,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,
-};
-
-static const BitmapCharRec ch84 = {7,10,-1,0,9,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x7c,0x82,0x82,0x2,0xc,0x70,0x80,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch83 = {7,10,-1,0,9,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x82,0x82,0x84,0x88,0x90,0xfc,0x82,0x82,0x82,0xfc,
-};
-
-static const BitmapCharRec ch82 = {7,10,-1,0,9,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x6,0x8,0x7c,0x92,0xa2,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch81 = {7,12,-1,2,9,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0x80,0x80,0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,
-};
-
-static const BitmapCharRec ch80 = {7,10,-1,0,9,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch79 = {7,10,-1,0,9,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x82,0x82,0x82,0x86,0x8a,0x92,0xa2,0xc2,0x82,0x82,
-};
-
-static const BitmapCharRec ch78 = {7,10,-1,0,9,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x82,0x82,0x82,0x92,0x92,0xaa,0xaa,0xc6,0x82,0x82,
-};
-
-static const BitmapCharRec ch77 = {7,10,-1,0,9,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xfe,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {7,10,-1,0,9,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x82,0x84,0x88,0x90,0xa0,0xe0,0x90,0x88,0x84,0x82,
-};
-
-static const BitmapCharRec ch75 = {7,10,-1,0,9,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x78,0x84,0x4,0x4,0x4,0x4,0x4,0x4,0x4,0x1e,
-};
-
-static const BitmapCharRec ch74 = {7,10,-1,0,9,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
-};
-
-static const BitmapCharRec ch73 = {5,10,-2,0,9,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x82,0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch72 = {7,10,-1,0,9,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x7c,0x82,0x82,0x82,0x8e,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch71 = {7,10,-1,0,9,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x40,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
-};
-
-static const BitmapCharRec ch70 = {7,10,-1,0,9,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xfe,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
-};
-
-static const BitmapCharRec ch69 = {7,10,-1,0,9,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xfc,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch68 = {7,10,-1,0,9,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch67 = {7,10,-1,0,9,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xfc,0x42,0x42,0x42,0x42,0x7c,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch66 = {7,10,-1,0,9,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x44,0x28,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,10,-1,0,9,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x7c,0x80,0x80,0x9a,0xa6,0xa2,0x9e,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch64 = {7,10,-1,0,9,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x10,0x0,0x10,0x10,0x8,0x4,0x2,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch63 = {7,10,-1,0,9,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {5,10,-2,0,9,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xfe,0x0,0x0,0xfe,
-};
-
-static const BitmapCharRec ch61 = {7,4,-1,-2,9,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x8,0x10,0x20,0x40,0x80,0x80,0x40,0x20,0x10,0x8,
-};
-
-static const BitmapCharRec ch60 = {5,10,-2,0,9,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {2,10,-4,3,9,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,7,-4,0,9,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x78,0x4,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch57 = {7,10,-1,0,9,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x38,0x44,0x82,0x82,0x44,0x38,0x44,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch56 = {7,10,-1,0,9,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x10,0x8,0x4,0x2,0x2,0xfe,
-};
-
-static const BitmapCharRec ch55 = {7,10,-1,0,9,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x7c,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x40,0x3c,
-};
-
-static const BitmapCharRec ch54 = {7,10,-1,0,9,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7c,0x82,0x2,0x2,0x2,0xc2,0xbc,0x80,0x80,0xfe,
-};
-
-static const BitmapCharRec ch53 = {7,10,-1,0,9,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x4,0x4,0x4,0xfe,0x84,0x44,0x24,0x14,0xc,0x4,
-};
-
-static const BitmapCharRec ch52 = {7,10,-1,0,9,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x7c,0x82,0x2,0x2,0x2,0x1c,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch51 = {7,10,-1,0,9,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xfe,0x80,0x40,0x30,0x8,0x4,0x2,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch50 = {7,10,-1,0,9,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xfe,0x10,0x10,0x10,0x10,0x10,0x90,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch49 = {7,10,-1,0,9,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x38,0x44,0x82,0x82,0x82,0x82,0x82,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch48 = {7,10,-1,0,9,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x40,0x40,0x20,0x10,0x10,0x8,0x4,0x4,0x2,
-};
-
-static const BitmapCharRec ch47 = {7,10,-1,0,9,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-4,0,9,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xfe,
-};
-
-static const BitmapCharRec ch45 = {7,1,-1,-4,9,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {2,5,-4,3,9,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch43 = {7,7,-1,-1,9,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x10,0x92,0x54,0x38,0x54,0x92,0x10,
-};
-
-static const BitmapCharRec ch42 = {7,7,-1,-1,9,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,12,-3,1,9,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,12,-3,1,9,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x20,0x30,
-};
-
-static const BitmapCharRec ch39 = {4,4,-3,-6,9,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x62,0x94,0x88,0x94,0x62,0x60,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch38 = {7,10,-1,0,9,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x84,0x4a,0x4a,0x24,0x10,0x10,0x48,0xa4,0xa4,0x42,
-};
-
-static const BitmapCharRec ch37 = {7,10,-1,0,9,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x10,0x7c,0x92,0x12,0x12,0x14,0x38,0x50,0x90,0x92,0x7c,0x10,
-};
-
-static const BitmapCharRec ch36 = {7,12,-1,1,9,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x48,0x48,0xfc,0x48,0x48,0xfc,0x48,0x48,
-};
-
-static const BitmapCharRec ch35 = {6,8,-1,-1,9,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch34 = {4,3,-3,-7,9,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,11,-4,0,9,ch33data};
-
-/* char: 0x1f */
-
-static const GLubyte ch31data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch31 = {2,2,-4,-2,9,ch31data};
-
-/* char: 0x1e */
-
-static const GLubyte ch30data[] = {
-0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
-};
-
-static const BitmapCharRec ch30 = {7,10,-1,0,9,ch30data};
-
-/* char: 0x1d */
-
-static const GLubyte ch29data[] = {
-0x80,0x40,0xfe,0x10,0xfe,0x4,0x2,
-};
-
-static const BitmapCharRec ch29 = {7,7,-1,0,9,ch29data};
-
-/* char: 0x1c */
-
-static const GLubyte ch28data[] = {
-0x44,0x24,0x24,0x24,0x24,0x24,0xfe,
-};
-
-static const BitmapCharRec ch28 = {7,7,-1,0,9,ch28data};
-
-/* char: 0x1b */
-
-static const GLubyte ch27data[] = {
-0xfe,0x0,0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch27 = {7,12,-1,2,9,ch27data};
-
-/* char: 0x1a */
-
-static const GLubyte ch26data[] = {
-0xfc,0x0,0x4,0x8,0x10,0x20,0x40,0x40,0x20,0x10,0x8,0x4,
-};
-
-static const BitmapCharRec ch26 = {6,12,-2,2,9,ch26data};
-
-/* char: 0x19 */
-
-static const GLubyte ch25data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch25 = {1,15,-4,3,9,ch25data};
-
-/* char: 0x18 */
-
-static const GLubyte ch24data[] = {
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,
-};
-
-static const BitmapCharRec ch24 = {9,7,0,3,9,ch24data};
-
-/* char: 0x17 */
-
-static const GLubyte ch23data[] = {
-0xff,0x80,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch23 = {9,9,0,-3,9,ch23data};
-
-/* char: 0x16 */
-
-static const GLubyte ch22data[] = {
-0x8,0x8,0x8,0x8,0x8,0x8,0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch22 = {5,15,0,3,9,ch22data};
-
-/* char: 0x15 */
-
-static const GLubyte ch21data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch21 = {5,15,-4,3,9,ch21data};
-
-/* char: 0x14 */
-
-static const GLubyte ch20data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch20 = {9,1,0,1,9,ch20data};
-
-/* char: 0x13 */
-
-static const GLubyte ch19data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch19 = {9,1,0,-1,9,ch19data};
-
-/* char: 0x12 */
-
-static const GLubyte ch18data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch18 = {9,1,0,-3,9,ch18data};
-
-/* char: 0x11 */
-
-static const GLubyte ch17data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch17 = {9,1,0,-5,9,ch17data};
-
-/* char: 0x10 */
-
-static const GLubyte ch16data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch16 = {9,1,0,-7,9,ch16data};
-
-/* char: 0xf */
-
-static const GLubyte ch15data[] = {
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,0x8,0x0,
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
-};
-
-static const BitmapCharRec ch15 = {9,15,0,3,9,ch15data};
-
-/* char: 0xe */
-
-static const GLubyte ch14data[] = {
-0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch14 = {5,9,-4,-3,9,ch14data};
-
-/* char: 0xd */
-
-static const GLubyte ch13data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch13 = {5,7,-4,3,9,ch13data};
-
-/* char: 0xc */
-
-static const GLubyte ch12data[] = {
-0x8,0x8,0x8,0x8,0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch12 = {5,7,0,3,9,ch12data};
-
-/* char: 0xb */
-
-static const GLubyte ch11data[] = {
-0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch11 = {5,9,0,-3,9,ch11data};
-
-/* char: 0xa */
-
-static const GLubyte ch10data[] = {
-0x8,0x8,0x8,0x8,0x3e,0x0,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch10 = {7,10,-1,2,9,ch10data};
-
-/* char: 0x9 */
-
-static const GLubyte ch9data[] = {
-0x3e,0x20,0x20,0x20,0x20,0x88,0x98,0xa8,0xc8,0x88,
-};
-
-static const BitmapCharRec ch9 = {7,10,-1,2,9,ch9data};
-
-/* char: 0x8 */
-
-static const GLubyte ch8data[] = {
-0xfe,0x10,0x10,0xfe,0x10,0x10,
-};
-
-static const BitmapCharRec ch8 = {7,6,-1,0,9,ch8data};
-
-/* char: 0x7 */
-
-static const GLubyte ch7data[] = {
-0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch7 = {5,4,-2,-6,9,ch7data};
-
-/* char: 0x6 */
-
-static const GLubyte ch6data[] = {
-0x20,0x20,0x3c,0x20,0x3e,0x0,0xf8,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch6 = {7,10,-1,2,9,ch6data};
-
-/* char: 0x5 */
-
-static const GLubyte ch5data[] = {
-0x22,0x22,0x3c,0x22,0x3c,0x0,0x78,0x80,0x80,0x78,
-};
-
-static const BitmapCharRec ch5 = {7,10,-1,2,9,ch5data};
-
-/* char: 0x4 */
-
-static const GLubyte ch4data[] = {
-0x10,0x10,0x1c,0x10,0x1e,0x80,0x80,0xe0,0x80,0xf0,
-};
-
-static const BitmapCharRec ch4 = {7,10,-1,2,9,ch4data};
-
-/* char: 0x3 */
-
-static const GLubyte ch3data[] = {
-0x8,0x8,0x8,0x3e,0x0,0x88,0x88,0xf8,0x88,0x88,
-};
-
-static const BitmapCharRec ch3 = {7,10,-1,2,9,ch3data};
-
-/* char: 0x2 */
-
-static const GLubyte ch2data[] = {
-0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,
-};
-
-static const BitmapCharRec ch2 = {8,14,0,3,9,ch2data};
-
-/* char: 0x1 */
-
-static const GLubyte ch1data[] = {
-0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,
-};
-
-static const BitmapCharRec ch1 = {7,7,-1,0,9,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 glutBitmap9By15 = {
-"-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1",
-256,
-0,
-chars
-};
-
diff --git a/src/glut/beos/glut_bitmap.c b/src/glut/beos/glut_bitmap.c
deleted file mode 100644
index f1afdd7a046..00000000000
--- a/src/glut/beos/glut_bitmap.c
+++ /dev/null
@@ -1,57 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutbitmap.h"
-
-void APIENTRY 
-glutBitmapCharacter(GLUTbitmapFont font, int c)
-{
-  const BitmapCharRec *ch;
-  BitmapFontPtr fontinfo;
-  GLint swapbytes, lsbfirst, rowlength;
-  GLint skiprows, skippixels, alignment;
-
-#if defined(_WIN32)
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  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);
-  }
-}
diff --git a/src/glut/beos/glut_bwidth.c b/src/glut/beos/glut_bwidth.c
deleted file mode 100644
index bee5e8827ea..00000000000
--- a/src/glut/beos/glut_bwidth.c
+++ /dev/null
@@ -1,58 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutbitmap.h"
-
-/* CENTRY */
-int APIENTRY 
-glutBitmapWidth(GLUTbitmapFont font, int c)
-{
-  BitmapFontPtr fontinfo;
-  const BitmapCharRec *ch;
-
-#ifdef _WIN32
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  if (c < fontinfo->first || c >= fontinfo->first + fontinfo->num_chars)
-    return 0;
-  ch = fontinfo->ch[c - fontinfo->first];
-  if (ch)
-    return ch->advance;
-  else
-    return 0;
-}
-
-int APIENTRY 
-glutBitmapLength(GLUTbitmapFont font, const unsigned char *string)
-{
-  int c, length;
-  BitmapFontPtr fontinfo;
-  const BitmapCharRec *ch;
-
-#ifdef _WIN32
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  length = 0;
-  for (; *string != '\0'; string++) {
-    c = *string;
-    if (c >= fontinfo->first && c < fontinfo->first + fontinfo->num_chars) {
-      ch = fontinfo->ch[c - fontinfo->first];
-      if (ch)
-        length += ch->advance;
-    }
-  }
-  return length;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glut_ext.c b/src/glut/beos/glut_ext.c
deleted file mode 100644
index 334f31f1a36..00000000000
--- a/src/glut/beos/glut_ext.c
+++ /dev/null
@@ -1,201 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutExtensionSupported(const char *extension)
-{
-  static const GLubyte *extensions = NULL;
-  const GLubyte *start;
-  GLubyte *where, *terminator;
-
-  /* Extension names should not have spaces. */
-  where = (GLubyte *) strchr(extension, ' ');
-  if (where || *extension == '\0')
-    return 0;
-
-  if (!extensions) {
-    extensions = glGetString(GL_EXTENSIONS);
-  }
-  /* It takes a bit of care to be fool-proof about parsing the
-     OpenGL extensions string.  Don't be fooled by sub-strings,
-     etc. */
-  start = extensions;
-  for (;;) {
-    /* If your application crashes in the strstr routine below,
-       you are probably calling glutExtensionSupported without
-       having a current window.  Calling glGetString without
-       a current OpenGL context has unpredictable results.
-       Please fix your program. */
-    where = (GLubyte *) strstr((const char *) start, extension);
-    if (!where)
-      break;
-    terminator = where + strlen(extension);
-    if (where == start || *(where - 1) == ' ') {
-      if (*terminator == ' ' || *terminator == '\0') {
-        return 1;
-      }
-    }
-    start = terminator;
-  }
-  return 0;
-}
-
-
-struct name_address_pair {
-   const char *name;
-   const GLUTproc address;
-};
-
-static struct name_address_pair glut_functions[] = {
-   { "glutInit", (const GLUTproc) glutInit },
-   { "glutInitDisplayMode", (const GLUTproc) glutInitDisplayMode },
-   { "glutInitDisplayString", (const GLUTproc) glutInitDisplayString },
-   { "glutInitWindowPosition", (const GLUTproc) glutInitWindowPosition },
-   { "glutInitWindowSize", (const GLUTproc) glutInitWindowSize },
-   { "glutMainLoop", (const GLUTproc) glutMainLoop },
-   { "glutCreateWindow", (const GLUTproc) glutCreateWindow },
-   { "glutCreateSubWindow", (const GLUTproc) glutCreateSubWindow },
-   { "glutDestroyWindow", (const GLUTproc) glutDestroyWindow },
-   { "glutPostRedisplay", (const GLUTproc) glutPostRedisplay },
-   { "glutPostWindowRedisplay", (const GLUTproc) glutPostWindowRedisplay },
-   { "glutSwapBuffers", (const GLUTproc) glutSwapBuffers },
-   { "glutGetWindow", (const GLUTproc) glutGetWindow },
-   { "glutSetWindow", (const GLUTproc) glutSetWindow },
-   { "glutSetWindowTitle", (const GLUTproc) glutSetWindowTitle },
-   { "glutSetIconTitle", (const GLUTproc) glutSetIconTitle },
-   { "glutPositionWindow", (const GLUTproc) glutPositionWindow },
-   { "glutReshapeWindow", (const GLUTproc) glutReshapeWindow },
-   { "glutPopWindow", (const GLUTproc) glutPopWindow },
-   { "glutPushWindow", (const GLUTproc) glutPushWindow },
-   { "glutIconifyWindow", (const GLUTproc) glutIconifyWindow },
-   { "glutShowWindow", (const GLUTproc) glutShowWindow },
-   { "glutHideWindow", (const GLUTproc) glutHideWindow },
-   { "glutFullScreen", (const GLUTproc) glutFullScreen },
-   { "glutSetCursor", (const GLUTproc) glutSetCursor },
-   { "glutWarpPointer", (const GLUTproc) glutWarpPointer },
-   { "glutEstablishOverlay", (const GLUTproc) glutEstablishOverlay },
-   { "glutRemoveOverlay", (const GLUTproc) glutRemoveOverlay },
-   { "glutUseLayer", (const GLUTproc) glutUseLayer },
-   { "glutPostOverlayRedisplay", (const GLUTproc) glutPostOverlayRedisplay },
-   { "glutPostWindowOverlayRedisplay", (const GLUTproc) glutPostWindowOverlayRedisplay },
-   { "glutShowOverlay", (const GLUTproc) glutShowOverlay },
-   { "glutHideOverlay", (const GLUTproc) glutHideOverlay },
-   { "glutCreateMenu", (const GLUTproc) glutCreateMenu },
-   { "glutDestroyMenu", (const GLUTproc) glutDestroyMenu },
-   { "glutGetMenu", (const GLUTproc) glutGetMenu },
-   { "glutSetMenu", (const GLUTproc) glutSetMenu },
-   { "glutAddMenuEntry", (const GLUTproc) glutAddMenuEntry },
-   { "glutAddSubMenu", (const GLUTproc) glutAddSubMenu },
-   { "glutChangeToMenuEntry", (const GLUTproc) glutChangeToMenuEntry },
-   { "glutChangeToSubMenu", (const GLUTproc) glutChangeToSubMenu },
-   { "glutRemoveMenuItem", (const GLUTproc) glutRemoveMenuItem },
-   { "glutAttachMenu", (const GLUTproc) glutAttachMenu },
-   { "glutDetachMenu", (const GLUTproc) glutDetachMenu },
-   { "glutDisplayFunc", (const GLUTproc) glutDisplayFunc },
-   { "glutReshapeFunc", (const GLUTproc) glutReshapeFunc },
-   { "glutKeyboardFunc", (const GLUTproc) glutKeyboardFunc },
-   { "glutMouseFunc", (const GLUTproc) glutMouseFunc },
-   { "glutMotionFunc", (const GLUTproc) glutMotionFunc },
-   { "glutPassiveMotionFunc", (const GLUTproc) glutPassiveMotionFunc },
-   { "glutEntryFunc", (const GLUTproc) glutEntryFunc },
-   { "glutVisibilityFunc", (const GLUTproc) glutVisibilityFunc },
-   { "glutIdleFunc", (const GLUTproc) glutIdleFunc },
-   { "glutTimerFunc", (const GLUTproc) glutTimerFunc },
-   { "glutMenuStateFunc", (const GLUTproc) glutMenuStateFunc },
-   { "glutSpecialFunc", (const GLUTproc) glutSpecialFunc },
-   { "glutSpaceballMotionFunc", (const GLUTproc) glutSpaceballMotionFunc },
-   { "glutSpaceballRotateFunc", (const GLUTproc) glutSpaceballRotateFunc },
-   { "glutSpaceballButtonFunc", (const GLUTproc) glutSpaceballButtonFunc },
-   { "glutButtonBoxFunc", (const GLUTproc) glutButtonBoxFunc },
-   { "glutDialsFunc", (const GLUTproc) glutDialsFunc },
-   { "glutTabletMotionFunc", (const GLUTproc) glutTabletMotionFunc },
-   { "glutTabletButtonFunc", (const GLUTproc) glutTabletButtonFunc },
-   { "glutMenuStatusFunc", (const GLUTproc) glutMenuStatusFunc },
-   { "glutOverlayDisplayFunc", (const GLUTproc) glutOverlayDisplayFunc },
-   { "glutWindowStatusFunc", (const GLUTproc) glutWindowStatusFunc },
-//   { "glutKeyboardUpFunc", (const GLUTproc) glutKeyboardUpFunc },
-//   { "glutSpecialUpFunc", (const GLUTproc) glutSpecialUpFunc },
-//   { "glutJoystickFunc", (const GLUTproc) glutJoystickFunc },
-   { "glutSetColor", (const GLUTproc) glutSetColor },
-   { "glutGetColor", (const GLUTproc) glutGetColor },
-   { "glutCopyColormap", (const GLUTproc) glutCopyColormap },
-   { "glutGet", (const GLUTproc) glutGet },
-   { "glutDeviceGet", (const GLUTproc) glutDeviceGet },
-   { "glutExtensionSupported", (const GLUTproc) glutExtensionSupported },
-   { "glutGetModifiers", (const GLUTproc) glutGetModifiers },
-   { "glutLayerGet", (const GLUTproc) glutLayerGet },
-   { "glutGetProcAddress", (const GLUTproc) glutGetProcAddress },
-   { "glutBitmapCharacter", (const GLUTproc) glutBitmapCharacter },
-   { "glutBitmapWidth", (const GLUTproc) glutBitmapWidth },
-   { "glutStrokeCharacter", (const GLUTproc) glutStrokeCharacter },
-   { "glutStrokeWidth", (const GLUTproc) glutStrokeWidth },
-   { "glutBitmapLength", (const GLUTproc) glutBitmapLength },
-   { "glutStrokeLength", (const GLUTproc) glutStrokeLength },
-   { "glutWireSphere", (const GLUTproc) glutWireSphere },
-   { "glutSolidSphere", (const GLUTproc) glutSolidSphere },
-   { "glutWireCone", (const GLUTproc) glutWireCone },
-   { "glutSolidCone", (const GLUTproc) glutSolidCone },
-   { "glutWireCube", (const GLUTproc) glutWireCube },
-   { "glutSolidCube", (const GLUTproc) glutSolidCube },
-   { "glutWireTorus", (const GLUTproc) glutWireTorus },
-   { "glutSolidTorus", (const GLUTproc) glutSolidTorus },
-   { "glutWireDodecahedron", (const GLUTproc) glutWireDodecahedron },
-   { "glutSolidDodecahedron", (const GLUTproc) glutSolidDodecahedron },
-   { "glutWireTeapot", (const GLUTproc) glutWireTeapot },
-   { "glutSolidTeapot", (const GLUTproc) glutSolidTeapot },
-   { "glutWireOctahedron", (const GLUTproc) glutWireOctahedron },
-   { "glutSolidOctahedron", (const GLUTproc) glutSolidOctahedron },
-   { "glutWireTetrahedron", (const GLUTproc) glutWireTetrahedron },
-   { "glutSolidTetrahedron", (const GLUTproc) glutSolidTetrahedron },
-   { "glutWireIcosahedron", (const GLUTproc) glutWireIcosahedron },
-   { "glutSolidIcosahedron", (const GLUTproc) glutSolidIcosahedron },
-   { "glutVideoResizeGet", (const GLUTproc) glutVideoResizeGet },
-   { "glutSetupVideoResizing", (const GLUTproc) glutSetupVideoResizing },
-   { "glutStopVideoResizing", (const GLUTproc) glutStopVideoResizing },
-   { "glutVideoResize", (const GLUTproc) glutVideoResize },
-   { "glutVideoPan", (const GLUTproc) glutVideoPan },
-   { "glutReportErrors", (const GLUTproc) glutReportErrors },
-//   { "glutIgnoreKeyRepeat", (const GLUTproc) glutIgnoreKeyRepeat },
-//   { "glutSetKeyRepeat", (const GLUTproc) glutSetKeyRepeat },
-//   { "glutForceJoystickFunc", (const GLUTproc) glutForceJoystickFunc },
-//   { "glutGameModeString", (const GLUTproc) glutGameModeString },
-//   { "glutEnterGameMode", (const GLUTproc) glutEnterGameMode },
-//   { "glutLeaveGameMode", (const GLUTproc) glutLeaveGameMode },
-//   { "glutGameModeGet", (const GLUTproc) glutGameModeGet },
-   { NULL, NULL }
-};   
-
-
-/* XXX This isn't an official GLUT function, yet */
-GLUTproc GLUTAPIENTRY 
-glutGetProcAddress(const char *procName)
-{
-   /* Try GLUT functions first */
-   int i;
-   for (i = 0; glut_functions[i].name; i++) {
-      if (strcmp(glut_functions[i].name, procName) == 0)
-         return glut_functions[i].address;
-   }
-
-   /* Try core GL functions */
-#if defined(_WIN32)
-  return (GLUTProc) wglGetProcAddress((LPCSTR) procName);
-#elif defined(GLX_ARB_get_proc_address)
-  return (GLUTProc) glXGetProcAddressARB((const GLubyte *) procName);
-#else
-  return NULL;
-#endif
-}
-
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glut_hel10.c b/src/glut/beos/glut_hel10.c
deleted file mode 100644
index 703cef38f26..00000000000
--- a/src/glut/beos/glut_hel10.c
+++ /dev/null
@@ -1,1778 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica10 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica10
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch255 = {4,10,0,2,5,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {5,10,0,2,6,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {4,11,0,2,5,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {4,8,0,0,5,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {4,9,0,0,5,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch250 = {4,9,0,0,5,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {4,9,0,0,5,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x70,0x88,0xc8,0xa8,0x98,0x74,
-};
-
-static const BitmapCharRec ch248 = {6,6,0,0,6,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,0,-1,6,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch246 = {5,8,0,0,6,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {5,9,0,0,6,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch244 = {5,9,0,0,6,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch243 = {5,9,0,0,6,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {5,9,0,0,6,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x90,0x90,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch241 = {4,9,0,0,5,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x70,0x88,0x88,0x88,0x88,0x78,0x90,0x60,0x50,
-};
-
-static const BitmapCharRec ch240 = {5,9,0,0,6,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,8,0,0,2,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,9,1,0,2,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch237 = {2,9,0,0,2,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {2,9,1,0,2,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,
-};
-
-static const BitmapCharRec ch235 = {4,8,0,0,5,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch234 = {4,9,0,0,5,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch233 = {4,9,0,0,5,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch232 = {4,9,0,0,5,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x60,0x20,0x60,0x90,0x80,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch231 = {4,8,0,2,5,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x6c,0x92,0x90,0x7e,0x12,0xec,
-};
-
-static const BitmapCharRec ch230 = {7,6,0,0,8,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x20,0x50,0x20,
-};
-
-static const BitmapCharRec ch229 = {5,9,0,0,5,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,
-};
-
-static const BitmapCharRec ch228 = {5,8,0,0,5,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch227 = {5,9,0,0,5,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch226 = {5,9,0,0,5,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch225 = {5,9,0,0,5,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch224 = {5,9,0,0,5,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xa0,0x90,0x90,0x90,0xa0,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch223 = {4,8,0,0,5,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0xf0,0x88,0x88,0xf0,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {5,8,-1,0,7,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,11,0,0,7,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
-};
-
-static const BitmapCharRec ch220 = {6,10,-1,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {6,11,-1,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch218 = {6,11,-1,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {6,11,-1,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x78,0xc4,0xa4,0xa4,0x94,0x94,0x8c,0x78,0x4,
-};
-
-static const BitmapCharRec ch216 = {6,10,-1,1,8,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,0,-1,6,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x48,
-};
-
-static const BitmapCharRec ch214 = {6,10,-1,0,8,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {6,11,-1,0,8,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch212 = {6,11,-1,0,8,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch211 = {6,11,-1,0,8,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch210 = {6,11,-1,0,8,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {6,11,-1,0,8,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x78,0x44,0x42,0x42,0xf2,0x42,0x44,0x78,
-};
-
-static const BitmapCharRec ch208 = {7,8,0,0,8,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,10,0,0,3,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,11,0,0,3,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch205 = {2,11,-1,0,3,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {2,11,0,0,3,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x50,
-};
-
-static const BitmapCharRec ch203 = {5,10,-1,0,7,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xf8,0x80,0x80,0xf8,0x80,0x80,0x80,0xf8,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch202 = {5,11,-1,0,7,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch201 = {5,11,-1,0,7,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch200 = {5,11,-1,0,7,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x10,0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch199 = {6,10,-1,2,8,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x8f,0x80,0x88,0x0,0x78,0x0,0x48,0x0,0x2f,0x80,0x28,0x0,0x18,0x0,0x1f,0x80,
-};
-
-static const BitmapCharRec ch198 = {9,8,0,0,10,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,11,0,0,7,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,10,0,0,7,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,11,0,0,7,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,11,0,0,7,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,11,0,0,7,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,11,0,0,7,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x60,0x90,0x80,0x40,0x20,0x20,0x0,0x20,
-};
-
-static const BitmapCharRec ch191 = {4,8,-1,2,6,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0xc8,0x0,0x24,0x0,0x44,0x0,0xe2,0x0,
-};
-
-static const BitmapCharRec ch190 = {9,8,0,0,9,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x27,0x12,0x15,0xb,0x48,0x44,0xc4,0x42,
-};
-
-static const BitmapCharRec ch189 = {8,8,0,0,9,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0x48,0x0,0x44,0x0,0xc4,0x0,0x42,0x0,
-};
-
-static const BitmapCharRec ch188 = {9,8,0,0,9,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x28,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {5,5,0,0,6,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0xe0,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch186 = {3,5,0,-3,4,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {2,4,0,-3,3,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x40,
-};
-
-static const BitmapCharRec ch184 = {2,2,0,2,3,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,1,0,-3,3,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
-};
-
-static const BitmapCharRec ch182 = {6,10,0,2,6,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xf0,0x90,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch181 = {4,8,0,2,5,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-6,3,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xe0,0x40,0xa0,0x60,
-};
-
-static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch175 = {3,1,0,-7,3,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
-};
-
-static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch173 = {3,1,0,-3,4,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch172 = {5,3,-1,-2,7,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x28,0x50,0xa0,0x50,0x28,
-};
-
-static const BitmapCharRec ch171 = {5,5,0,0,6,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xe0,
-};
-
-static const BitmapCharRec ch170 = {3,5,0,-3,4,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
-};
-
-static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,0,-7,3,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x18,0x70,0xc8,0x98,0x70,0xc0,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,10,0,2,6,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,10,-1,2,3,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x20,0xf8,0x20,0xf8,0x50,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,8,0,0,6,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x90,0x60,0x90,0x90,0x60,0x90,
-};
-
-static const BitmapCharRec ch164 = {4,6,0,-1,5,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xb0,0x48,0x40,0x40,0xe0,0x40,0x48,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,8,0,0,6,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x70,0xa8,0xa0,0xa0,0xa8,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {5,8,0,1,6,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,8,-1,2,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,3,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,3,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0x80,0x40,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch125 = {3,10,0,2,3,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,10,-1,2,3,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x20,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch123 = {3,10,0,2,3,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x80,0x40,0x20,0x10,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,6,0,0,5,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,
-};
-
-static const BitmapCharRec ch121 = {4,8,0,2,5,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x88,0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch120 = {5,6,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x28,0x28,0x54,0x54,0x92,0x92,
-};
-
-static const BitmapCharRec ch119 = {7,6,0,0,8,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x20,0x50,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch118 = {5,6,0,0,6,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch117 = {4,6,0,0,5,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x60,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
-};
-
-static const BitmapCharRec ch116 = {3,8,0,0,4,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x60,0x90,0x10,0x60,0x90,0x60,
-};
-
-static const BitmapCharRec ch115 = {4,6,0,0,5,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x80,0x80,0x80,0x80,0xc0,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,6,0,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x8,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch113 = {5,8,0,2,6,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch112 = {5,8,0,2,6,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch111 = {5,6,0,0,6,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x88,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch110 = {5,6,0,0,6,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x92,0x92,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {7,6,0,0,8,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch108 = {1,8,0,0,2,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x90,0x90,0xa0,0xc0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {4,8,0,0,5,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch106 = {1,9,0,1,2,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch105 = {1,8,0,0,2,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,8,0,0,6,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x70,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch103 = {5,8,0,2,6,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,8,0,0,4,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,
-};
-
-static const BitmapCharRec ch101 = {4,6,0,0,5,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x98,0x88,0x88,0x98,0x68,0x8,0x8,
-};
-
-static const BitmapCharRec ch100 = {5,8,0,0,6,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x60,0x90,0x80,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch99 = {4,6,0,0,5,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {5,8,0,0,6,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,
-};
-
-static const BitmapCharRec ch97 = {5,6,0,0,5,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x80,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,3,0,-5,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch95 = {6,1,0,2,6,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x88,0x50,0x50,0x20,0x20,
-};
-
-static const BitmapCharRec ch94 = {5,5,0,-3,6,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,10,0,2,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x20,0x20,0x40,0x40,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {3,8,0,0,3,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,10,-1,2,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xf8,0x80,0x40,0x20,0x20,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch90 = {5,8,-1,0,7,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,8,0,0,7,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x88,0x88,0x50,0x50,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch88 = {5,8,-1,0,7,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-};
-
-static const BitmapCharRec ch87 = {9,8,0,0,9,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,8,0,0,7,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch85 = {6,8,-1,0,8,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
-};
-
-static const BitmapCharRec ch84 = {5,8,0,0,5,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x70,0x88,0x88,0x8,0x70,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch83 = {5,8,-1,0,7,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x88,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch82 = {5,8,-1,0,7,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x2,0x7c,0x8c,0x94,0x84,0x84,0x84,0x84,0x78,
-};
-
-static const BitmapCharRec ch81 = {7,9,-1,1,8,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0x80,0x80,0x80,0x80,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch80 = {5,8,-1,0,7,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,
-};
-
-static const BitmapCharRec ch79 = {6,8,-1,0,8,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,
-};
-
-static const BitmapCharRec ch78 = {6,8,-1,0,8,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x92,0x92,0x92,0xaa,0xaa,0xc6,0xc6,0x82,
-};
-
-static const BitmapCharRec ch77 = {7,8,-1,0,9,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {4,8,-1,0,6,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x88,0x88,0x90,0x90,0xe0,0xa0,0x90,0x88,
-};
-
-static const BitmapCharRec ch75 = {5,8,-1,0,7,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x60,0x90,0x10,0x10,0x10,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch74 = {4,8,0,0,5,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch73 = {1,8,-1,0,3,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x84,0x84,0x84,0x84,0xfc,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch72 = {6,8,-1,0,8,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x74,0x8c,0x84,0x8c,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch71 = {6,8,-1,0,8,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x80,0x80,0x80,0x80,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch70 = {5,8,-1,0,6,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch69 = {5,8,-1,0,7,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf0,0x88,0x84,0x84,0x84,0x84,0x88,0xf0,
-};
-
-static const BitmapCharRec ch68 = {6,8,-1,0,8,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch67 = {6,8,-1,0,8,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf0,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch66 = {5,8,-1,0,7,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,8,0,0,7,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x0,0x40,0x0,0x9b,0x0,0xa4,0x80,0xa4,0x80,0xa2,0x40,0x92,0x40,0x4d,0x40,
-0x20,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch64 = {10,10,0,2,11,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x40,0x0,0x40,0x40,0x20,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch63 = {4,8,-1,0,6,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {3,5,-1,-1,6,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf0,0x0,0xf0,
-};
-
-static const BitmapCharRec ch61 = {4,3,0,-2,5,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x20,0x40,0x80,0x40,0x20,
-};
-
-static const BitmapCharRec ch60 = {3,5,-1,-1,6,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
-};
-
-static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch57 = {5,8,0,0,6,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x70,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch56 = {5,8,0,0,6,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x10,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch55 = {5,8,0,0,6,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x70,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch54 = {5,8,0,0,6,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x70,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch53 = {5,8,0,0,6,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x10,0x10,0xf8,0x90,0x50,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch52 = {5,8,0,0,6,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x70,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch51 = {5,8,0,0,6,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf8,0x80,0x40,0x30,0x8,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch50 = {5,8,0,0,6,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch49 = {2,8,-1,0,6,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch48 = {5,8,0,0,6,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x40,0x20,0x20,
-};
-
-static const BitmapCharRec ch47 = {3,8,0,0,3,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch45 = {5,1,-1,-3,7,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch44 = {2,3,0,2,3,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,0,-1,6,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,0,-5,4,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,10,-1,2,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,10,0,2,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch39 = {2,3,-1,-5,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x64,0x98,0x98,0xa4,0x60,0x50,0x50,0x20,
-};
-
-static const BitmapCharRec ch38 = {6,8,-1,0,8,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x26,0x29,0x16,0x10,0x8,0x68,0x94,0x64,
-};
-
-static const BitmapCharRec ch37 = {8,8,0,0,9,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0x70,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {5,9,0,1,6,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0xf8,0x28,0x7c,0x28,0x28,
-};
-
-static const BitmapCharRec ch35 = {6,7,0,0,6,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,2,-1,-6,4,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,8,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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 = {0,0,0,0,3,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,3,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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 glutBitmapHelvetica10 = {
-"-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/beos/glut_hel12.c b/src/glut/beos/glut_hel12.c
deleted file mode 100644
index 68aed8a2bd6..00000000000
--- a/src/glut/beos/glut_hel12.c
+++ /dev/null
@@ -1,1788 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica12 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica12
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0xc0,0x20,0x20,0x20,0x30,0x50,0x50,0x48,0x88,0x88,0x0,0x50,
-};
-
-static const BitmapCharRec ch255 = {5,12,-1,3,7,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {5,12,-1,3,7,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {5,13,-1,3,7,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {5,9,-1,0,7,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {5,10,-1,0,7,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch250 = {5,10,-1,0,7,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {5,10,-1,0,7,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xb8,0x44,0x64,0x54,0x4c,0x44,0x3a,
-};
-
-static const BitmapCharRec ch248 = {7,7,0,0,7,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,-1,-1,7,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch246 = {5,9,-1,0,7,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {5,10,-1,0,7,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch244 = {5,10,-1,0,7,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch243 = {5,10,-1,0,7,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {5,10,-1,0,7,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch241 = {5,10,-1,0,7,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x70,0x88,0x88,0x88,0x88,0x78,0x8,0x50,0x30,0x68,
-};
-
-static const BitmapCharRec ch240 = {5,10,-1,0,7,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,9,0,0,3,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,10,0,0,3,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch237 = {2,10,-1,0,3,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {2,10,0,0,3,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch235 = {5,9,-1,0,7,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch234 = {5,10,-1,0,7,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch233 = {5,10,-1,0,7,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch232 = {5,10,-1,0,7,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x60,0x10,0x20,0x70,0x88,0x80,0x80,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch231 = {5,10,-1,3,7,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x77,0x0,0x88,0x80,0x88,0x0,0x7f,0x80,0x8,0x80,0x88,0x80,0x77,0x0,
-};
-
-static const BitmapCharRec ch230 = {9,7,-1,0,11,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x30,0x48,0x30,
-};
-
-static const BitmapCharRec ch229 = {6,10,-1,0,7,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch228 = {6,9,-1,0,7,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch227 = {6,10,-1,0,7,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch226 = {6,10,-1,0,7,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch225 = {6,10,-1,0,7,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch224 = {6,10,-1,0,7,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xb0,0x88,0x88,0x88,0xb0,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch223 = {5,9,-1,0,7,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {6,9,-1,0,8,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,12,-1,0,9,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
-};
-
-static const BitmapCharRec ch220 = {6,11,-1,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {6,12,-1,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch218 = {6,12,-1,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {6,12,-1,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x0,0x5e,0x0,0x21,0x0,0x50,0x80,0x48,0x80,0x44,0x80,0x44,0x80,0x42,0x80,
-0x21,0x0,0x1e,0x80,0x0,0x40,
-};
-
-static const BitmapCharRec ch216 = {10,11,0,1,10,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,-1,-1,7,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x24,
-};
-
-static const BitmapCharRec ch214 = {8,11,-1,0,10,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch213 = {8,12,-1,0,10,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x14,0x8,
-};
-
-static const BitmapCharRec ch212 = {8,12,-1,0,10,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x4,
-};
-
-static const BitmapCharRec ch211 = {8,12,-1,0,10,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x10,
-};
-
-static const BitmapCharRec ch210 = {8,12,-1,0,10,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch209 = {7,12,-1,0,9,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7c,0x42,0x41,0x41,0xf1,0x41,0x41,0x42,0x7c,
-};
-
-static const BitmapCharRec ch208 = {8,9,0,0,9,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,11,0,0,3,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,12,0,0,3,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch205 = {2,12,-1,0,3,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {2,12,0,0,3,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,
-};
-
-static const BitmapCharRec ch203 = {6,11,-1,0,8,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch202 = {6,12,-1,0,8,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch201 = {6,12,-1,0,8,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch200 = {6,12,-1,0,8,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x8,0x8,0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch199 = {7,12,-1,3,9,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x8f,0x80,0x88,0x0,0x88,0x0,0x78,0x0,0x4f,0x80,0x48,0x0,0x28,0x0,0x28,0x0,
-0x1f,0x80,
-};
-
-static const BitmapCharRec ch198 = {9,9,-1,0,11,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,12,-1,0,9,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,12,-1,0,9,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,12,-1,0,9,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,12,-1,0,9,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,12,-1,0,9,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x70,0x88,0x88,0x40,0x40,0x20,0x20,0x0,0x20,
-};
-
-static const BitmapCharRec ch191 = {5,9,-1,3,7,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x21,0x0,0x17,0x80,0x15,0x0,0xb,0x0,0xc9,0x0,0x24,0x0,0x44,0x0,0x22,0x0,
-0xe1,0x0,
-};
-
-static const BitmapCharRec ch190 = {9,9,0,0,10,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x47,0x80,0x22,0x0,0x11,0x0,0x14,0x80,0x4b,0x0,0x48,0x0,0x44,0x0,0xc2,0x0,
-0x41,0x0,
-};
-
-static const BitmapCharRec ch189 = {9,9,0,0,10,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x41,0x0,0x27,0x80,0x15,0x0,0x13,0x0,0x49,0x0,0x44,0x0,0x44,0x0,0xc2,0x0,
-0x41,0x0,
-};
-
-static const BitmapCharRec ch188 = {9,9,0,0,10,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x28,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {5,5,-1,-1,7,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0xe0,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch186 = {3,5,-1,-4,5,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {2,5,-1,-3,4,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x20,0x20,0x40,
-};
-
-static const BitmapCharRec ch184 = {3,4,0,3,3,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch183 = {1,1,-1,-3,3,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x68,0x3c,
-};
-
-static const BitmapCharRec ch182 = {6,12,0,3,7,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0x80,0xe8,0x98,0x88,0x88,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch181 = {5,10,-1,3,7,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-8,2,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0x20,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,5,0,-3,4,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf0,0x40,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch178 = {4,5,0,-3,4,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,-1,0,7,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-4,5,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch175 = {4,1,0,-8,4,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x3e,0x0,0x41,0x0,0x94,0x80,0x94,0x80,0x98,0x80,0x94,0x80,0x9c,0x80,0x41,0x0,
-0x3e,0x0,
-};
-
-static const BitmapCharRec ch174 = {9,9,-1,0,11,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch173 = {4,1,0,-3,5,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x4,0x4,0x4,0xfc,
-};
-
-static const BitmapCharRec ch172 = {6,4,-1,-2,8,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x28,0x50,0xa0,0x50,0x28,
-};
-
-static const BitmapCharRec ch171 = {5,5,-1,-1,7,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xe0,
-};
-
-static const BitmapCharRec ch170 = {3,5,-1,-4,5,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x3e,0x0,0x41,0x0,0x9c,0x80,0xa2,0x80,0xa0,0x80,0xa2,0x80,0x9c,0x80,0x41,0x0,
-0x3e,0x0,
-};
-
-static const BitmapCharRec ch169 = {9,9,-1,0,11,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,0,-8,3,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x8,0x30,0x48,0x88,0x88,0x90,0x60,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,12,0,3,6,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,11,-1,2,3,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x20,0x20,0xf8,0x20,0xf8,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,9,-1,0,7,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x84,0x78,0x48,0x48,0x78,0x84,
-};
-
-static const BitmapCharRec ch164 = {6,6,0,-1,7,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xb0,0x48,0x20,0x20,0xf0,0x40,0x40,0x48,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,9,-1,0,7,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x70,0xc8,0xa0,0xa0,0xa0,0xa8,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {5,9,-1,1,7,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,10,-1,3,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,4,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,4,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xc0,0x20,0x20,0x20,0x20,0x20,0x10,0x20,0x20,0x20,0x20,0xc0,
-};
-
-static const BitmapCharRec ch125 = {4,12,0,3,4,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,12,-1,3,3,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x30,0x40,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x40,0x30,
-};
-
-static const BitmapCharRec ch123 = {4,12,0,3,4,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x80,0x40,0x40,0x20,0x10,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,7,-1,0,6,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch121 = {5,10,-1,3,7,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x84,0x84,0x48,0x30,0x30,0x48,0x84,
-};
-
-static const BitmapCharRec ch120 = {6,7,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-};
-
-static const BitmapCharRec ch119 = {9,7,0,0,9,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x20,0x50,0x50,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch118 = {5,7,-1,0,7,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch117 = {5,7,-1,0,7,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x60,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
-};
-
-static const BitmapCharRec ch116 = {3,9,0,0,3,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x60,0x90,0x10,0x60,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch115 = {4,7,-1,0,6,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x80,0x80,0x80,0x80,0x80,0xc0,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,7,-1,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x8,0x8,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch113 = {5,10,-1,3,7,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch112 = {5,10,-1,3,7,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch111 = {5,7,-1,0,7,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch110 = {5,7,-1,0,7,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x92,0x92,0x92,0x92,0x92,0xda,0xa4,
-};
-
-static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch108 = {1,9,-1,0,3,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x88,0x90,0xa0,0xc0,0xc0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {5,9,-1,0,6,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,
-};
-
-static const BitmapCharRec ch106 = {2,12,0,3,3,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch105 = {1,9,-1,0,3,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,9,-1,0,7,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch103 = {5,10,-1,3,7,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,9,0,0,3,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch101 = {5,7,-1,0,7,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x98,0x88,0x88,0x88,0x98,0x68,0x8,0x8,
-};
-
-static const BitmapCharRec ch100 = {5,9,-1,0,7,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x70,0x88,0x80,0x80,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch99 = {5,7,-1,0,7,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {5,9,-1,0,7,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch97 = {6,7,-1,0,7,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,3,0,-6,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xfe,
-};
-
-static const BitmapCharRec ch95 = {7,1,0,2,7,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x88,0x50,0x20,
-};
-
-static const BitmapCharRec ch94 = {5,3,0,-5,6,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,12,0,3,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x10,0x10,0x20,0x20,0x20,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {4,9,0,0,4,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,12,-1,3,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xfe,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch90 = {7,9,-1,0,9,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,9,-1,0,9,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x82,0x44,0x44,0x28,0x10,0x28,0x44,0x44,0x82,
-};
-
-static const BitmapCharRec ch88 = {7,9,-1,0,9,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-0x88,0x80,
-};
-
-static const BitmapCharRec ch87 = {9,9,-1,0,11,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,9,-1,0,9,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,7,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x78,0x84,0x84,0x4,0x18,0x60,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch83 = {6,9,-1,0,8,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x84,0x84,0x84,0x88,0xf8,0x84,0x84,0x84,0xf8,
-};
-
-static const BitmapCharRec ch82 = {6,9,-1,0,8,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x3d,0x42,0x85,0x89,0x81,0x81,0x81,0x42,0x3c,
-};
-
-static const BitmapCharRec ch81 = {8,9,-1,0,10,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[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,
-};
-
-static const BitmapCharRec ch79 = {8,9,-1,0,10,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,
-};
-
-static const BitmapCharRec ch78 = {7,9,-1,0,9,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x88,0x80,0x88,0x80,0x94,0x80,0x94,0x80,0xa2,0x80,0xa2,0x80,0xc1,0x80,0xc1,0x80,
-0x80,0x80,
-};
-
-static const BitmapCharRec ch77 = {9,9,-1,0,11,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {5,9,-1,0,7,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x82,0x84,0x88,0x90,0xe0,0xa0,0x90,0x88,0x84,
-};
-
-static const BitmapCharRec ch75 = {7,9,-1,0,8,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x70,0x88,0x88,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch74 = {5,9,-1,0,7,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch73 = {1,9,-1,0,3,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch72 = {7,9,-1,0,9,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x3a,0x46,0x82,0x82,0x8e,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch71 = {7,9,-1,0,9,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x80,0x80,0x80,0x80,0xf8,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,0xfc,0x80,0x80,0x80,0xfc,
-};
-
-static const BitmapCharRec ch69 = {6,9,-1,0,8,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf8,0x84,0x82,0x82,0x82,0x82,0x82,0x84,0xf8,
-};
-
-static const BitmapCharRec ch68 = {7,9,-1,0,9,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch67 = {7,9,-1,0,9,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf8,0x84,0x84,0x84,0xf8,0x84,0x84,0x84,0xf8,
-};
-
-static const BitmapCharRec ch66 = {6,9,-1,0,8,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x28,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,9,-1,0,9,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x0,0x40,0x0,0x9b,0x0,0xa6,0x80,0xa2,0x40,0xa2,0x40,0x92,0x40,0x4d,0x40,
-0x60,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch64 = {10,10,-1,1,12,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x20,0x0,0x20,0x20,0x10,0x10,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch63 = {5,9,-1,0,7,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0x30,0xc,0x30,0xc0,
-};
-
-static const BitmapCharRec ch62 = {6,5,-1,-1,7,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf8,0x0,0xf8,
-};
-
-static const BitmapCharRec ch61 = {5,3,-1,-2,7,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0xc,0x30,0xc0,0x30,0xc,
-};
-
-static const BitmapCharRec ch60 = {6,5,0,-1,7,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
-};
-
-static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x70,0x88,0x8,0x8,0x78,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch57 = {5,9,-1,0,7,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch56 = {5,9,-1,0,7,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x20,0x10,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch55 = {5,9,-1,0,7,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x70,0x88,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch54 = {5,9,-1,0,7,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x70,0x88,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch53 = {5,9,-1,0,7,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x8,0x8,0xfc,0x88,0x48,0x28,0x28,0x18,0x8,
-};
-
-static const BitmapCharRec ch52 = {6,9,0,0,7,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x70,0x88,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch51 = {5,9,-1,0,7,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf8,0x80,0x80,0x40,0x20,0x10,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch50 = {5,9,-1,0,7,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,0x20,
-};
-
-static const BitmapCharRec ch49 = {3,9,-1,0,7,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch48 = {5,9,-1,0,7,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x20,0x20,0x10,0x10,
-};
-
-static const BitmapCharRec ch47 = {4,9,0,0,4,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch45 = {5,1,-1,-3,8,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch44 = {2,3,-1,2,4,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,-1,-1,7,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,-1,-6,5,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,12,0,3,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,12,-1,3,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,3,-1,-6,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x72,0x8c,0x84,0x8a,0x50,0x30,0x48,0x48,0x30,
-};
-
-static const BitmapCharRec ch38 = {7,9,-1,0,9,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x23,0x0,0x14,0x80,0x14,0x80,0x13,0x0,0x8,0x0,0x68,0x0,0x94,0x0,0x94,0x0,
-0x62,0x0,
-};
-
-static const BitmapCharRec ch37 = {9,9,-1,0,11,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0x70,0xa8,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {5,10,-1,1,7,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0x50,0xfc,0x28,0xfc,0x28,0x28,
-};
-
-static const BitmapCharRec ch35 = {6,8,0,0,7,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,3,-1,-6,5,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,9,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,4,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,4,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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 glutBitmapHelvetica12 = {
-"-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/beos/glut_hel18.c b/src/glut/beos/glut_hel18.c
deleted file mode 100644
index f0800843e8e..00000000000
--- a/src/glut/beos/glut_hel18.c
+++ /dev/null
@@ -1,1897 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica18 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica18
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x66,
-0x66,
-};
-
-static const BitmapCharRec ch255 = {8,17,-1,4,10,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch254 = {9,18,-1,4,11,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x18,
-0xc,0x6,
-};
-
-static const BitmapCharRec ch253 = {8,18,-1,4,10,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x66,
-};
-
-static const BitmapCharRec ch252 = {8,13,-1,0,10,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch251 = {8,14,-1,0,10,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x18,0xc,0x6,
-};
-
-static const BitmapCharRec ch250 = {8,14,-1,0,10,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0xc,0x18,0x30,
-};
-
-static const BitmapCharRec ch249 = {8,14,-1,0,10,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xce,0x0,0x7f,0x80,0x31,0x80,0x78,0xc0,0x6c,0xc0,0x66,0xc0,0x63,0xc0,0x31,0x80,
-0x3f,0xc0,0xe,0x60,
-};
-
-static const BitmapCharRec ch248 = {11,10,0,0,11,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x18,0x18,0x0,0xff,0xff,0x0,0x18,0x18,
-};
-
-static const BitmapCharRec ch247 = {8,8,-1,-1,10,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x36,0x0,0x36,0x0,
-};
-
-static const BitmapCharRec ch246 = {9,13,-1,0,11,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x26,0x0,0x2d,0x0,0x19,0x0,
-};
-
-static const BitmapCharRec ch245 = {9,14,-1,0,11,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x33,0x0,0x1e,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch244 = {9,14,-1,0,11,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x18,0x0,0xc,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch243 = {9,14,-1,0,11,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x18,0x0,0x30,0x0,
-};
-
-static const BitmapCharRec ch242 = {9,14,-1,0,11,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0x0,0x4c,0x5a,0x32,
-};
-
-static const BitmapCharRec ch241 = {8,14,-1,0,10,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x4c,0x0,0x38,0x0,0x36,0x0,0x60,0x0,
-};
-
-static const BitmapCharRec ch240 = {9,14,-1,0,11,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch239 = {5,13,0,0,4,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,0x78,0x30,
-};
-
-static const BitmapCharRec ch238 = {6,14,1,0,4,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xc0,0x60,0x30,
-};
-
-static const BitmapCharRec ch237 = {4,14,0,0,4,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0x30,0x60,0xc0,
-};
-
-static const BitmapCharRec ch236 = {4,14,0,0,4,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x36,0x36,
-};
-
-static const BitmapCharRec ch235 = {8,13,-1,0,10,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch234 = {8,14,-1,0,10,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0xc,0x6,
-};
-
-static const BitmapCharRec ch233 = {8,14,-1,0,10,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0x30,0x60,
-};
-
-static const BitmapCharRec ch232 = {8,14,-1,0,10,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x78,0x6c,0xc,0x38,0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
-};
-
-static const BitmapCharRec ch231 = {8,14,-1,4,10,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x75,0xe0,0xef,0xf8,0xc7,0x18,0xc6,0x0,0xe6,0x0,0x7f,0xf8,0xe,0x18,0xc6,0x18,
-0xef,0xf0,0x7d,0xe0,
-};
-
-static const BitmapCharRec ch230 = {13,10,-1,0,15,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x38,0x6c,0x6c,0x38,
-};
-
-static const BitmapCharRec ch229 = {7,14,-1,0,9,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x6c,0x6c,
-};
-
-static const BitmapCharRec ch228 = {7,13,-1,0,9,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x4c,0x5a,0x32,
-};
-
-static const BitmapCharRec ch227 = {7,14,-1,0,9,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch226 = {7,14,-1,0,9,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x30,0x18,0xc,
-};
-
-static const BitmapCharRec ch225 = {7,14,-1,0,9,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x18,0x30,0x60,
-};
-
-static const BitmapCharRec ch224 = {7,14,-1,0,9,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xdc,0xde,0xc6,0xc6,0xc6,0xc6,0xdc,0xdc,0xc6,0xc6,0xc6,0xc6,0x7c,0x38,
-};
-
-static const BitmapCharRec ch223 = {7,14,-1,0,9,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc1,0xc0,0xff,0x80,0xff,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch222 = {10,14,-1,0,12,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,0x0,0x0,0x6,0x0,
-0x3,0x0,0x1,0x80,
-};
-
-static const BitmapCharRec ch221 = {12,18,-1,0,14,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
-0x19,0x80,
-};
-
-static const BitmapCharRec ch220 = {11,17,-1,0,13,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
-0xf,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch219 = {11,18,-1,0,13,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch218 = {11,18,-1,0,13,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x6,0x0,
-0xc,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch217 = {11,18,-1,0,13,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0xc7,0xc0,0xff,0xf0,0x78,0x38,0x38,0x18,0x6c,0x1c,0x6e,0xc,0x67,0xc,0x63,0x8c,
-0x61,0xcc,0x70,0xdc,0x30,0x78,0x38,0x38,0x1f,0xfc,0x7,0xcc,
-};
-
-static const BitmapCharRec ch216 = {14,14,0,0,15,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch215 = {10,9,0,0,10,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xd,0x80,
-0xd,0x80,
-};
-
-static const BitmapCharRec ch214 = {13,17,-1,0,15,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x9,0x80,
-0xb,0x40,0x6,0x40,
-};
-
-static const BitmapCharRec ch213 = {13,18,-1,0,15,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xc,0xc0,
-0x7,0x80,0x3,0x0,
-};
-
-static const BitmapCharRec ch212 = {13,18,-1,0,15,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
-0x1,0x80,0x0,0xc0,
-};
-
-static const BitmapCharRec ch211 = {13,18,-1,0,15,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
-0x6,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch210 = {13,18,-1,0,15,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
-0xcc,0x60,0xd8,0x60,0xd8,0x60,0xf0,0x60,0xe0,0x60,0xe0,0x60,0x0,0x0,0x13,0x0,
-0x16,0x80,0xc,0x80,
-};
-
-static const BitmapCharRec ch209 = {11,18,-1,0,13,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7f,0x80,0x7f,0xc0,0x60,0xe0,0x60,0x60,0x60,0x30,0x60,0x30,0xfc,0x30,0xfc,0x30,
-0x60,0x30,0x60,0x30,0x60,0x60,0x60,0xe0,0x7f,0xc0,0x7f,0x80,
-};
-
-static const BitmapCharRec ch208 = {12,14,0,0,13,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
-0xcc,
-};
-
-static const BitmapCharRec ch207 = {6,17,0,0,6,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
-0x78,0x30,
-};
-
-static const BitmapCharRec ch206 = {6,18,0,0,6,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0xc0,
-0x60,0x30,
-};
-
-static const BitmapCharRec ch205 = {4,18,-2,0,6,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x30,
-0x60,0xc0,
-};
-
-static const BitmapCharRec ch204 = {4,18,0,0,6,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
-0x33,0x0,
-};
-
-static const BitmapCharRec ch203 = {9,17,-1,0,11,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
-0x1e,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch202 = {9,18,-1,0,11,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch201 = {9,18,-1,0,11,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
-0x18,0x0,0x30,0x0,
-};
-
-static const BitmapCharRec ch200 = {9,18,-1,0,11,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x1e,0x0,0x1b,0x0,0x3,0x0,0xe,0x0,0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,
-0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,
-0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch199 = {12,18,-1,4,14,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xc1,0xff,0xc1,0xff,0x61,0x80,0x61,0x80,0x7f,0x80,0x3f,0x80,0x31,0xfe,0x31,0xfe,
-0x19,0x80,0x19,0x80,0xd,0x80,0xd,0x80,0x7,0xff,0x7,0xff,
-};
-
-static const BitmapCharRec ch198 = {16,14,-1,0,18,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x19,0x80,0xf,0x0,
-};
-
-static const BitmapCharRec ch197 = {12,18,0,0,12,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
-0x19,0x80,
-};
-
-static const BitmapCharRec ch196 = {12,17,0,0,12,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x13,0x0,
-0x16,0x80,0xc,0x80,
-};
-
-static const BitmapCharRec ch195 = {12,18,0,0,12,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
-0xf,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch194 = {12,18,0,0,12,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
-0x3,0x0,0x1,0x80,
-};
-
-static const BitmapCharRec ch193 = {12,18,0,0,12,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
-0xc,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch192 = {12,18,0,0,12,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x7c,0xfe,0xc6,0xc6,0xe0,0x70,0x38,0x18,0x18,0x18,0x0,0x0,0x18,0x18,
-};
-
-static const BitmapCharRec ch191 = {7,14,-1,4,10,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x18,0x18,0x18,0x18,0xc,0xfc,0x6,0xd8,0x6,0x78,0x73,0x38,0xf9,0x18,0x99,0x88,
-0x30,0xc0,0x30,0xc0,0x98,0x60,0xf8,0x30,0x70,0x30,
-};
-
-static const BitmapCharRec ch190 = {14,13,0,0,15,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x30,0xf8,0x30,0xf8,0x18,0x60,0xc,0x30,0xc,0x18,0x66,0x98,0x62,0xf8,0x63,0x70,
-0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
-};
-
-static const BitmapCharRec ch189 = {13,13,-1,0,15,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x30,0x30,0x30,0x30,0x19,0xf8,0xd,0xb0,0xc,0xf0,0x66,0x70,0x62,0x30,0x63,0x10,
-0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
-};
-
-static const BitmapCharRec ch188 = {13,13,-1,0,15,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x90,0xd8,0x6c,0x36,0x36,0x6c,0xd8,0x90,
-};
-
-static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xf8,0x0,0x70,0xd8,0x88,0x88,0xd8,0x70,
-};
-
-static const BitmapCharRec ch186 = {5,8,-1,-6,7,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x60,0x60,0x60,0x60,0x60,0xe0,0xe0,0x60,
-};
-
-static const BitmapCharRec ch185 = {3,8,-1,-5,6,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xf0,0xd8,0x18,0x70,0x60,
-};
-
-static const BitmapCharRec ch184 = {5,5,0,4,5,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-1,-4,4,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x32,0x72,0xf2,0xf2,0xf2,0xf2,
-0x72,0x3f,
-};
-
-static const BitmapCharRec ch182 = {8,18,-1,4,10,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0xc0,0xc0,0xc0,0xc0,0xdb,0xff,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch181 = {8,14,-1,4,10,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0xc0,0x60,0x30,
-};
-
-static const BitmapCharRec ch180 = {4,3,0,-11,4,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x70,0xf8,0x98,0x30,0x30,0x98,0xf8,0x70,
-};
-
-static const BitmapCharRec ch179 = {5,8,0,-5,6,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf8,0xf8,0x60,0x30,0x18,0x98,0xf8,0x70,
-};
-
-static const BitmapCharRec ch178 = {5,8,0,-5,6,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xff,0xff,0x0,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,
-};
-
-static const BitmapCharRec ch177 = {8,11,-1,0,10,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x70,0xd8,0x88,0xd8,0x70,
-};
-
-static const BitmapCharRec ch176 = {5,5,-1,-8,7,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch175 = {5,1,0,-12,5,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0xf,0x80,0x30,0x60,0x40,0x10,0x48,0x50,0x88,0x88,0x89,0x8,0x8f,0x88,0x88,0x48,
-0x88,0x48,0x4f,0x90,0x40,0x10,0x30,0x60,0xf,0x80,
-};
-
-static const BitmapCharRec ch174 = {13,13,-1,0,14,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xf8,0xf8,
-};
-
-static const BitmapCharRec ch173 = {5,2,-1,-4,7,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x1,0x80,0x1,0x80,0x1,0x80,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch172 = {9,5,-1,-3,11,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x12,0x36,0x6c,0xd8,0xd8,0x6c,0x36,0x12,
-};
-
-static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xf8,0x0,0x68,0xd8,0x48,0x38,0xc8,0x70,
-};
-
-static const BitmapCharRec ch170 = {5,8,-1,-6,7,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0xf,0x80,0x30,0x60,0x40,0x10,0x47,0x10,0x88,0x88,0x90,0x8,0x90,0x8,0x90,0x8,
-0x88,0x88,0x47,0x10,0x40,0x10,0x30,0x60,0xf,0x80,
-};
-
-static const BitmapCharRec ch169 = {13,13,-1,0,15,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xd8,0xd8,
-};
-
-static const BitmapCharRec ch168 = {5,2,0,-11,6,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x3c,0x7e,0xc3,0xc3,0x7,0xe,0x3e,0x73,0xe3,0xc3,0xc7,0x6e,0x7c,0xf0,0xc3,0xc3,
-0x7e,0x3c,
-};
-
-static const BitmapCharRec ch167 = {8,18,-1,4,10,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch166 = {2,17,-1,3,4,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x18,0x18,0x18,0x18,0xff,0x18,0xff,0x3c,0x66,0x66,0x66,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch165 = {8,13,-1,0,10,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0xc3,0xff,0x66,0x66,0x66,0xff,0xc3,
-};
-
-static const BitmapCharRec ch164 = {8,7,-1,-3,10,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xdf,0x0,0xff,0x80,0x60,0x80,0x30,0x0,0x18,0x0,0x18,0x0,0x7e,0x0,0x30,0x0,
-0x60,0x0,0x61,0x80,0x61,0x80,0x3f,0x0,0x1e,0x0,
-};
-
-static const BitmapCharRec ch163 = {9,13,0,0,10,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x10,0x10,0x3e,0x7f,0x6b,0xc8,0xc8,0xc8,0xc8,0x6b,0x7f,0x3e,0x4,0x4,
-};
-
-static const BitmapCharRec ch162 = {8,14,-1,2,10,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x40,0x40,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch161 = {2,14,-2,4,6,ch161data};
-
-/* char: 0xa0 */
-
-#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,5,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,5,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0xcc,0x7e,0x33,
-};
-
-static const BitmapCharRec ch126 = {8,3,-1,-4,10,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xc0,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x18,0xc,0x18,0x30,0x30,0x30,0x30,0x30,
-0x60,0xc0,
-};
-
-static const BitmapCharRec ch125 = {6,18,0,4,6,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch124 = {2,18,-1,4,4,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0xc,0x18,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0xc0,0x60,0x30,0x30,0x30,0x30,0x30,
-0x18,0xc,
-};
-
-static const BitmapCharRec ch123 = {6,18,0,4,6,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xfe,0xfe,0xc0,0x60,0x30,0x18,0xc,0x6,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch122 = {7,10,-1,0,9,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch121 = {8,14,-1,4,10,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xc3,0xe7,0x66,0x3c,0x18,0x18,0x3c,0x66,0xe7,0xc3,
-};
-
-static const BitmapCharRec ch120 = {8,10,-1,0,10,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x19,0x80,0x19,0x80,0x39,0xc0,0x29,0x40,0x69,0x60,0x66,0x60,0x66,0x60,0xc6,0x30,
-0xc6,0x30,0xc6,0x30,
-};
-
-static const BitmapCharRec ch119 = {12,10,-1,0,14,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch118 = {8,10,-1,0,10,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch117 = {8,10,-1,0,10,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x18,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x30,
-};
-
-static const BitmapCharRec ch116 = {6,13,0,0,6,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x78,0xfc,0xc6,0x6,0x3e,0xfc,0xc0,0xc6,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch115 = {7,10,-1,0,9,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xe0,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch114 = {5,10,-1,0,6,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,0x7f,0x80,0x3d,0x80,
-};
-
-static const BitmapCharRec ch113 = {9,14,-1,4,11,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,
-};
-
-static const BitmapCharRec ch112 = {9,14,-1,4,11,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,
-};
-
-static const BitmapCharRec ch111 = {9,10,-1,0,11,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,
-};
-
-static const BitmapCharRec ch110 = {8,10,-1,0,10,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xe7,0x30,
-0xde,0xf0,0xcc,0x60,
-};
-
-static const BitmapCharRec ch109 = {12,10,-1,0,14,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch108 = {2,14,-1,0,4,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0xc7,0xc6,0xce,0xcc,0xd8,0xf8,0xf0,0xd8,0xcc,0xc6,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch107 = {8,14,-1,0,9,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0xe0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x0,
-0x30,0x30,
-};
-
-static const BitmapCharRec ch106 = {4,18,1,4,4,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch105 = {2,14,-1,0,4,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch104 = {8,14,-1,0,10,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x1c,0x0,0x7f,0x0,0x63,0x0,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x7f,0x80,0x3d,0x80,
-};
-
-static const BitmapCharRec ch103 = {9,14,-1,4,11,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x3c,0x1c,
-};
-
-static const BitmapCharRec ch102 = {6,14,0,0,6,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch101 = {8,10,-1,0,10,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,
-0x7f,0x80,0x3d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
-};
-
-static const BitmapCharRec ch100 = {9,14,-1,0,11,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
-};
-
-static const BitmapCharRec ch99 = {8,10,-1,0,10,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,
-0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch98 = {9,14,-1,0,11,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,
-};
-
-static const BitmapCharRec ch97 = {7,10,-1,0,9,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0xc0,0x80,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,5,-1,-9,4,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch95 = {10,2,0,4,10,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x82,0xc6,0x6c,0x38,0x10,
-};
-
-static const BitmapCharRec ch94 = {7,5,-1,-8,9,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xf0,0xf0,
-};
-
-static const BitmapCharRec ch93 = {4,18,0,4,5,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x18,0x18,0x10,0x10,0x30,0x30,0x20,0x20,0x60,0x60,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch92 = {5,14,0,0,5,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf0,0xf0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xf0,0xf0,
-};
-
-static const BitmapCharRec ch91 = {4,18,-1,4,5,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xff,0xc0,0xff,0xc0,0xc0,0x0,0x60,0x0,0x30,0x0,0x18,0x0,0x1c,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,0x1,0x80,0x0,0xc0,0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch90 = {10,14,-1,0,12,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
-};
-
-static const BitmapCharRec ch89 = {12,14,-1,0,14,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xc0,0x60,0xe0,0xe0,0x60,0xc0,0x71,0xc0,0x31,0x80,0x1b,0x0,0xe,0x0,0xe,0x0,
-0x1b,0x0,0x31,0x80,0x71,0xc0,0x60,0xc0,0xe0,0xe0,0xc0,0x60,
-};
-
-static const BitmapCharRec ch88 = {11,14,-1,0,13,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x18,0x18,0x18,0x18,0x1c,0x38,0x34,0x2c,0x36,0x6c,0x36,0x6c,0x66,0x66,0x66,0x66,
-0x62,0x46,0x63,0xc6,0xc3,0xc3,0xc1,0x83,0xc1,0x83,0xc1,0x83,
-};
-
-static const BitmapCharRec ch87 = {16,14,-1,0,18,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x6,0x0,0xf,0x0,0xf,0x0,0x19,0x80,0x19,0x80,0x19,0x80,0x30,0xc0,0x30,0xc0,
-0x30,0xc0,0x60,0x60,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
-};
-
-static const BitmapCharRec ch86 = {12,14,-1,0,14,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch85 = {11,14,-1,0,13,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,
-0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch84 = {10,14,-1,0,12,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x3f,0x0,0x7f,0xc0,0xe0,0xe0,0xc0,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,0x1f,0x0,
-0x7c,0x0,0xe0,0x0,0xc0,0x60,0xe0,0xe0,0x7f,0xc0,0x1f,0x0,
-};
-
-static const BitmapCharRec ch83 = {11,14,-1,0,13,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0x80,0xc1,0x80,0xff,0x0,0xff,0x80,
-0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch82 = {10,14,-1,0,12,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x0,0x30,0xf,0xb0,0x3f,0xe0,0x70,0xf0,0x61,0xb0,0xe1,0xb8,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch81 = {13,15,-1,1,15,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,
-0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch80 = {10,14,-1,0,12,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch79 = {13,14,-1,0,15,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
-0xcc,0x60,0xd8,0x60,0xf0,0x60,0xf0,0x60,0xe0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch78 = {11,14,-1,0,13,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xc3,0xc,0xc3,0xc,0xc7,0x8c,0xc4,0x8c,0xcc,0xcc,0xcc,0xcc,0xd8,0x6c,0xd8,0x6c,
-0xf0,0x3c,0xf0,0x3c,0xe0,0x1c,0xe0,0x1c,0xc0,0xc,0xc0,0xc,
-};
-
-static const BitmapCharRec ch77 = {14,14,-1,0,16,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xff,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch76 = {8,14,-1,0,10,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xc0,0x70,0xc0,0xe0,0xc1,0xc0,0xc3,0x80,0xc7,0x0,0xce,0x0,0xfc,0x0,0xf8,0x0,
-0xdc,0x0,0xce,0x0,0xc7,0x0,0xc3,0x80,0xc1,0xc0,0xc0,0xe0,
-};
-
-static const BitmapCharRec ch75 = {12,14,-1,0,13,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x3c,0x7e,0xe7,0xc3,0xc3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,
-};
-
-static const BitmapCharRec ch74 = {8,14,-1,0,10,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch73 = {2,14,-2,0,6,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xff,0xe0,0xff,0xe0,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch72 = {11,14,-1,0,13,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0xf,0xb0,0x3f,0xf0,0x70,0x70,0x60,0x30,0xe0,0x30,0xc1,0xf0,0xc1,0xf0,0xc0,0x0,
-0xc0,0x0,0xe0,0x30,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch71 = {12,14,-1,0,14,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch70 = {9,14,-1,0,11,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch69 = {9,14,-1,0,11,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch68 = {11,14,-1,0,13,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch67 = {12,14,-1,0,14,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xff,0x80,0xff,0xc0,0xc0,0xe0,0xc0,0x60,0xc0,0x60,0xc0,0xe0,0xff,0xc0,0xff,0x80,
-0xc1,0x80,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch66 = {11,14,-1,0,13,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch65 = {12,14,0,0,12,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x7,0xe0,0x1f,0xf0,0x38,0x0,0x70,0x0,0x67,0x70,0xcf,0xf8,0xcc,0xcc,0xcc,0x66,
-0xcc,0x66,0xcc,0x63,0xc6,0x33,0x67,0x73,0x63,0xb3,0x30,0x6,0x1c,0xe,0xf,0xfc,
-0x3,0xf0,
-};
-
-static const BitmapCharRec ch64 = {16,17,-1,3,18,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x30,0x30,0x0,0x0,0x30,0x30,0x30,0x38,0x1c,0xe,0xc6,0xc6,0xfe,0x7c,
-};
-
-static const BitmapCharRec ch63 = {7,14,-1,0,10,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0xf0,0x3c,0xe,0x3,0xe,0x3c,0xf0,0xc0,
-};
-
-static const BitmapCharRec ch62 = {8,9,-1,0,10,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xfe,0xfe,0x0,0x0,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch61 = {7,6,-2,-2,11,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x3,0xf,0x3c,0x70,0xc0,0x70,0x3c,0xf,0x3,
-};
-
-static const BitmapCharRec ch60 = {8,9,-1,0,10,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {2,13,-1,3,5,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,10,-1,0,5,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x7c,0xfe,0xc6,0x3,0x3,0x3b,0x7f,0xc3,0xc3,0xc3,0xc7,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch57 = {8,13,-1,0,10,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x3c,0x7e,0xe7,0xc3,0xc3,0x66,0x7e,0x66,0xc3,0xc3,0xe7,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch56 = {8,13,-1,0,10,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x60,0x60,0x30,0x30,0x30,0x18,0x18,0xc,0xc,0x6,0x3,0xff,0xff,
-};
-
-static const BitmapCharRec ch55 = {8,13,-1,0,10,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x3c,0x7e,0xe3,0xc3,0xc3,0xc3,0xfe,0xdc,0xc0,0xc0,0x63,0x7f,0x3c,
-};
-
-static const BitmapCharRec ch54 = {8,13,-1,0,10,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7c,0xfe,0xc7,0xc3,0x3,0x3,0xc7,0xfe,0xfc,0xc0,0xc0,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch53 = {8,13,-1,0,10,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x3,0x0,0x3,0x0,0x3,0x0,0xff,0x80,0xff,0x80,0xc3,0x0,0x63,0x0,0x33,0x0,
-0x33,0x0,0x1b,0x0,0xf,0x0,0x7,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch52 = {9,13,-1,0,10,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x3c,0x7e,0xc7,0xc3,0x3,0x7,0x1e,0x1c,0x6,0xc3,0xc3,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch51 = {8,13,-1,0,10,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xff,0xff,0xc0,0xe0,0x70,0x38,0x1c,0xe,0x7,0x3,0xc3,0xfe,0x3c,
-};
-
-static const BitmapCharRec ch50 = {8,13,-1,0,10,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0xf8,0x18,
-};
-
-static const BitmapCharRec ch49 = {5,13,-2,0,10,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x3c,0x7e,0x66,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x66,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch48 = {8,13,-1,0,10,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0xc0,0xc0,0x40,0x40,0x60,0x60,0x20,0x20,0x30,0x30,0x10,0x10,0x18,0x18,
-};
-
-static const BitmapCharRec ch47 = {5,14,0,0,5,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-1,0,5,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xff,0xff,
-};
-
-static const BitmapCharRec ch45 = {8,2,-1,-4,11,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {2,5,-1,3,5,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x18,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,0x18,
-};
-
-static const BitmapCharRec ch43 = {8,10,-1,0,10,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x88,0x70,0x70,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch42 = {5,6,-1,-8,7,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0xc0,0x60,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0x60,
-0xc0,0x80,
-};
-
-static const BitmapCharRec ch41 = {4,18,-1,4,6,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x10,0x30,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,0x60,
-0x30,0x10,
-};
-
-static const BitmapCharRec ch40 = {4,18,-1,4,6,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,5,-1,-9,4,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x3c,0x70,0x7e,0xe0,0xe7,0xc0,0xc3,0x80,0xc3,0xc0,0xc6,0xc0,0xee,0xc0,0x7c,0x0,
-0x3c,0x0,0x66,0x0,0x66,0x0,0x7e,0x0,0x3c,0x0,
-};
-
-static const BitmapCharRec ch38 = {12,13,-1,0,13,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x18,0x78,0x18,0xfc,0xc,0xcc,0xc,0xcc,0x6,0xfc,0x6,0x78,0x3,0x0,0x7b,0x0,
-0xfd,0x80,0xcd,0x80,0xcc,0xc0,0xfc,0xc0,0x78,0x60,
-};
-
-static const BitmapCharRec ch37 = {14,13,-1,0,16,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x8,0x0,0x8,0x0,0x3e,0x0,0x7f,0x0,0xeb,0x80,0xc9,0x80,0x9,0x80,0xf,0x0,
-0x3e,0x0,0x78,0x0,0xe8,0x0,0xc8,0x0,0xcb,0x0,0x7f,0x0,0x3e,0x0,0x8,0x0,
-};
-
-static const BitmapCharRec ch36 = {9,16,-1,2,10,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x24,0x0,0x24,0x0,0x24,0x0,0xff,0x80,0xff,0x80,0x12,0x0,0x12,0x0,0x12,0x0,
-0x7f,0xc0,0x7f,0xc0,0x9,0x0,0x9,0x0,0x9,0x0,
-};
-
-static const BitmapCharRec ch35 = {10,13,0,0,10,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x90,0x90,0xd8,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch34 = {5,5,0,-9,5,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0xc0,0xc0,0x0,0x0,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch33 = {2,14,-2,0,6,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,5,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,5,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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 glutBitmapHelvetica18 = {
-"-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/beos/glut_mroman.c b/src/glut/beos/glut_mroman.c
deleted file mode 100644
index a29f043b4a8..00000000000
--- a/src/glut/beos/glut_mroman.c
+++ /dev/null
@@ -1,2451 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#include "glutstroke.h"
-
-/* char: 33 '!' */
-
-static const CoordRec char33_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 33.3333 },
-};
-
-static const CoordRec char33_stroke1[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char33[] = {
-   { 2, char33_stroke0 },
-   { 5, char33_stroke1 },
-};
-
-/* char: 34 '"' */
-
-static const CoordRec char34_stroke0[] = {
-    { 33.3334, 100 },
-    { 33.3334, 66.6667 },
-};
-
-static const CoordRec char34_stroke1[] = {
-    { 71.4286, 100 },
-    { 71.4286, 66.6667 },
-};
-
-static const StrokeRec char34[] = {
-   { 2, char34_stroke0 },
-   { 2, char34_stroke1 },
-};
-
-/* char: 35 '#' */
-
-static const CoordRec char35_stroke0[] = {
-    { 54.7619, 119.048 },
-    { 21.4286, -33.3333 },
-};
-
-static const CoordRec char35_stroke1[] = {
-    { 83.3334, 119.048 },
-    { 50, -33.3333 },
-};
-
-static const CoordRec char35_stroke2[] = {
-    { 21.4286, 57.1429 },
-    { 88.0952, 57.1429 },
-};
-
-static const CoordRec char35_stroke3[] = {
-    { 16.6667, 28.5714 },
-    { 83.3334, 28.5714 },
-};
-
-static const StrokeRec char35[] = {
-   { 2, char35_stroke0 },
-   { 2, char35_stroke1 },
-   { 2, char35_stroke2 },
-   { 2, char35_stroke3 },
-};
-
-/* char: 36 '$' */
-
-static const CoordRec char36_stroke0[] = {
-    { 42.8571, 119.048 },
-    { 42.8571, -19.0476 },
-};
-
-static const CoordRec char36_stroke1[] = {
-    { 61.9047, 119.048 },
-    { 61.9047, -19.0476 },
-};
-
-static const CoordRec char36_stroke2[] = {
-    { 85.7143, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 19.0476, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 23.8095, 66.6667 },
-    { 28.5714, 61.9048 },
-    { 38.0952, 57.1429 },
-    { 66.6666, 47.619 },
-    { 76.1905, 42.8571 },
-    { 80.9524, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 19.0476, 14.2857 },
-};
-
-static const StrokeRec char36[] = {
-   { 2, char36_stroke0 },
-   { 2, char36_stroke1 },
-   { 20, char36_stroke2 },
-};
-
-/* char: 37 '%' */
-
-static const CoordRec char37_stroke0[] = {
-    { 95.2381, 100 },
-    { 9.5238, 0 },
-};
-
-static const CoordRec char37_stroke1[] = {
-    { 33.3333, 100 },
-    { 42.8571, 90.4762 },
-    { 42.8571, 80.9524 },
-    { 38.0952, 71.4286 },
-    { 28.5714, 66.6667 },
-    { 19.0476, 66.6667 },
-    { 9.5238, 76.1905 },
-    { 9.5238, 85.7143 },
-    { 14.2857, 95.2381 },
-    { 23.8095, 100 },
-    { 33.3333, 100 },
-    { 42.8571, 95.2381 },
-    { 57.1428, 90.4762 },
-    { 71.4286, 90.4762 },
-    { 85.7143, 95.2381 },
-    { 95.2381, 100 },
-};
-
-static const CoordRec char37_stroke2[] = {
-    { 76.1905, 33.3333 },
-    { 66.6667, 28.5714 },
-    { 61.9048, 19.0476 },
-    { 61.9048, 9.5238 },
-    { 71.4286, 0 },
-    { 80.9524, 0 },
-    { 90.4762, 4.7619 },
-    { 95.2381, 14.2857 },
-    { 95.2381, 23.8095 },
-    { 85.7143, 33.3333 },
-    { 76.1905, 33.3333 },
-};
-
-static const StrokeRec char37[] = {
-   { 2, char37_stroke0 },
-   { 16, char37_stroke1 },
-   { 11, char37_stroke2 },
-};
-
-/* char: 38 '&' */
-
-static const CoordRec char38_stroke0[] = {
-    { 100, 57.1429 },
-    { 100, 61.9048 },
-    { 95.2381, 66.6667 },
-    { 90.4762, 66.6667 },
-    { 85.7143, 61.9048 },
-    { 80.9524, 52.381 },
-    { 71.4286, 28.5714 },
-    { 61.9048, 14.2857 },
-    { 52.3809, 4.7619 },
-    { 42.8571, 0 },
-    { 23.8095, 0 },
-    { 14.2857, 4.7619 },
-    { 9.5238, 9.5238 },
-    { 4.7619, 19.0476 },
-    { 4.7619, 28.5714 },
-    { 9.5238, 38.0952 },
-    { 14.2857, 42.8571 },
-    { 47.619, 61.9048 },
-    { 52.3809, 66.6667 },
-    { 57.1429, 76.1905 },
-    { 57.1429, 85.7143 },
-    { 52.3809, 95.2381 },
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 28.5714, 85.7143 },
-    { 28.5714, 76.1905 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 47.619 },
-    { 66.6667, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 85.7143, 0 },
-    { 95.2381, 0 },
-    { 100, 4.7619 },
-    { 100, 9.5238 },
-};
-
-static const StrokeRec char38[] = {
-   { 34, char38_stroke0 },
-};
-
-/* char: 39 ''' */
-
-static const CoordRec char39_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 66.6667 },
-};
-
-static const StrokeRec char39[] = {
-   { 2, char39_stroke0 },
-};
-
-/* char: 40 '(' */
-
-static const CoordRec char40_stroke0[] = {
-    { 69.0476, 119.048 },
-    { 59.5238, 109.524 },
-    { 50, 95.2381 },
-    { 40.4762, 76.1905 },
-    { 35.7143, 52.381 },
-    { 35.7143, 33.3333 },
-    { 40.4762, 9.5238 },
-    { 50, -9.5238 },
-    { 59.5238, -23.8095 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char40[] = {
-   { 10, char40_stroke0 },
-};
-
-/* char: 41 ')' */
-
-static const CoordRec char41_stroke0[] = {
-    { 35.7143, 119.048 },
-    { 45.2381, 109.524 },
-    { 54.7619, 95.2381 },
-    { 64.2857, 76.1905 },
-    { 69.0476, 52.381 },
-    { 69.0476, 33.3333 },
-    { 64.2857, 9.5238 },
-    { 54.7619, -9.5238 },
-    { 45.2381, -23.8095 },
-    { 35.7143, -33.3333 },
-};
-
-static const StrokeRec char41[] = {
-   { 10, char41_stroke0 },
-};
-
-/* char: 42 '*' */
-
-static const CoordRec char42_stroke0[] = {
-    { 52.381, 71.4286 },
-    { 52.381, 14.2857 },
-};
-
-static const CoordRec char42_stroke1[] = {
-    { 28.5715, 57.1429 },
-    { 76.1905, 28.5714 },
-};
-
-static const CoordRec char42_stroke2[] = {
-    { 76.1905, 57.1429 },
-    { 28.5715, 28.5714 },
-};
-
-static const StrokeRec char42[] = {
-   { 2, char42_stroke0 },
-   { 2, char42_stroke1 },
-   { 2, char42_stroke2 },
-};
-
-/* char: 43 '+' */
-
-static const CoordRec char43_stroke0[] = {
-    { 52.3809, 85.7143 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char43_stroke1[] = {
-    { 9.5238, 42.8571 },
-    { 95.2381, 42.8571 },
-};
-
-static const StrokeRec char43[] = {
-   { 2, char43_stroke0 },
-   { 2, char43_stroke1 },
-};
-
-/* char: 44 ',' */
-
-static const CoordRec char44_stroke0[] = {
-    { 57.1429, 4.7619 },
-    { 52.381, 0 },
-    { 47.6191, 4.7619 },
-    { 52.381, 9.5238 },
-    { 57.1429, 4.7619 },
-    { 57.1429, -4.7619 },
-    { 52.381, -14.2857 },
-    { 47.6191, -19.0476 },
-};
-
-static const StrokeRec char44[] = {
-   { 8, char44_stroke0 },
-};
-
-/* char: 45 '-' */
-
-static const CoordRec char45_stroke0[] = {
-    { 9.5238, 42.8571 },
-    { 95.2381, 42.8571 },
-};
-
-static const StrokeRec char45[] = {
-   { 2, char45_stroke0 },
-};
-
-/* char: 46 '.' */
-
-static const CoordRec char46_stroke0[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char46[] = {
-   { 5, char46_stroke0 },
-};
-
-/* char: 47 '/' */
-
-static const CoordRec char47_stroke0[] = {
-    { 19.0476, -14.2857 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char47[] = {
-   { 2, char47_stroke0 },
-};
-
-/* char: 48 '0' */
-
-static const CoordRec char48_stroke0[] = {
-    { 47.619, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 80.9524 },
-    { 19.0476, 57.1429 },
-    { 19.0476, 42.8571 },
-    { 23.8095, 19.0476 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 19.0476 },
-    { 85.7143, 42.8571 },
-    { 85.7143, 57.1429 },
-    { 80.9524, 80.9524 },
-    { 71.4286, 95.2381 },
-    { 57.1428, 100 },
-    { 47.619, 100 },
-};
-
-static const StrokeRec char48[] = {
-   { 17, char48_stroke0 },
-};
-
-/* char: 49 '1' */
-
-static const CoordRec char49_stroke0[] = {
-    { 40.4762, 80.9524 },
-    { 50, 85.7143 },
-    { 64.2857, 100 },
-    { 64.2857, 0 },
-};
-
-static const StrokeRec char49[] = {
-   { 4, char49_stroke0 },
-};
-
-/* char: 50 '2' */
-
-static const CoordRec char50_stroke0[] = {
-    { 23.8095, 76.1905 },
-    { 23.8095, 80.9524 },
-    { 28.5714, 90.4762 },
-    { 33.3333, 95.2381 },
-    { 42.8571, 100 },
-    { 61.9047, 100 },
-    { 71.4286, 95.2381 },
-    { 76.1905, 90.4762 },
-    { 80.9524, 80.9524 },
-    { 80.9524, 71.4286 },
-    { 76.1905, 61.9048 },
-    { 66.6666, 47.619 },
-    { 19.0476, 0 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char50[] = {
-   { 14, char50_stroke0 },
-};
-
-/* char: 51 '3' */
-
-static const CoordRec char51_stroke0[] = {
-    { 28.5714, 100 },
-    { 80.9524, 100 },
-    { 52.3809, 61.9048 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 80.9524, 52.381 },
-    { 85.7143, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 80.9524, 14.2857 },
-    { 71.4286, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-};
-
-static const StrokeRec char51[] = {
-   { 15, char51_stroke0 },
-};
-
-/* char: 52 '4' */
-
-static const CoordRec char52_stroke0[] = {
-    { 64.2857, 100 },
-    { 16.6667, 33.3333 },
-    { 88.0952, 33.3333 },
-};
-
-static const CoordRec char52_stroke1[] = {
-    { 64.2857, 100 },
-    { 64.2857, 0 },
-};
-
-static const StrokeRec char52[] = {
-   { 3, char52_stroke0 },
-   { 2, char52_stroke1 },
-};
-
-/* char: 53 '5' */
-
-static const CoordRec char53_stroke0[] = {
-    { 76.1905, 100 },
-    { 28.5714, 100 },
-    { 23.8095, 57.1429 },
-    { 28.5714, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 71.4286, 61.9048 },
-    { 80.9524, 52.381 },
-    { 85.7143, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 80.9524, 14.2857 },
-    { 71.4286, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-};
-
-static const StrokeRec char53[] = {
-   { 17, char53_stroke0 },
-};
-
-/* char: 54 '6' */
-
-static const CoordRec char54_stroke0[] = {
-    { 78.5714, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 59.5238, 100 },
-    { 50, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 80.9524 },
-    { 21.4286, 57.1429 },
-    { 21.4286, 33.3333 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 50, 0 },
-    { 54.7619, 0 },
-    { 69.0476, 4.7619 },
-    { 78.5714, 14.2857 },
-    { 83.3334, 28.5714 },
-    { 83.3334, 33.3333 },
-    { 78.5714, 47.619 },
-    { 69.0476, 57.1429 },
-    { 54.7619, 61.9048 },
-    { 50, 61.9048 },
-    { 35.7143, 57.1429 },
-    { 26.1905, 47.619 },
-    { 21.4286, 33.3333 },
-};
-
-static const StrokeRec char54[] = {
-   { 23, char54_stroke0 },
-};
-
-/* char: 55 '7' */
-
-static const CoordRec char55_stroke0[] = {
-    { 85.7143, 100 },
-    { 38.0952, 0 },
-};
-
-static const CoordRec char55_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char55[] = {
-   { 2, char55_stroke0 },
-   { 2, char55_stroke1 },
-};
-
-/* char: 56 '8' */
-
-static const CoordRec char56_stroke0[] = {
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 23.8095, 76.1905 },
-    { 28.5714, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 57.1428, 57.1429 },
-    { 71.4286, 52.381 },
-    { 80.9524, 42.8571 },
-    { 85.7143, 33.3333 },
-    { 85.7143, 19.0476 },
-    { 80.9524, 9.5238 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-    { 19.0476, 33.3333 },
-    { 23.8095, 42.8571 },
-    { 33.3333, 52.381 },
-    { 47.619, 57.1429 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 66.6667 },
-    { 80.9524, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const StrokeRec char56[] = {
-   { 29, char56_stroke0 },
-};
-
-/* char: 57 '9' */
-
-static const CoordRec char57_stroke0[] = {
-    { 83.3334, 66.6667 },
-    { 78.5714, 52.381 },
-    { 69.0476, 42.8571 },
-    { 54.7619, 38.0952 },
-    { 50, 38.0952 },
-    { 35.7143, 42.8571 },
-    { 26.1905, 52.381 },
-    { 21.4286, 66.6667 },
-    { 21.4286, 71.4286 },
-    { 26.1905, 85.7143 },
-    { 35.7143, 95.2381 },
-    { 50, 100 },
-    { 54.7619, 100 },
-    { 69.0476, 95.2381 },
-    { 78.5714, 85.7143 },
-    { 83.3334, 66.6667 },
-    { 83.3334, 42.8571 },
-    { 78.5714, 19.0476 },
-    { 69.0476, 4.7619 },
-    { 54.7619, 0 },
-    { 45.2381, 0 },
-    { 30.9524, 4.7619 },
-    { 26.1905, 14.2857 },
-};
-
-static const StrokeRec char57[] = {
-   { 23, char57_stroke0 },
-};
-
-/* char: 58 ':' */
-
-static const CoordRec char58_stroke0[] = {
-    { 52.381, 66.6667 },
-    { 47.6191, 61.9048 },
-    { 52.381, 57.1429 },
-    { 57.1429, 61.9048 },
-    { 52.381, 66.6667 },
-};
-
-static const CoordRec char58_stroke1[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char58[] = {
-   { 5, char58_stroke0 },
-   { 5, char58_stroke1 },
-};
-
-/* char: 59 ';' */
-
-static const CoordRec char59_stroke0[] = {
-    { 52.381, 66.6667 },
-    { 47.6191, 61.9048 },
-    { 52.381, 57.1429 },
-    { 57.1429, 61.9048 },
-    { 52.381, 66.6667 },
-};
-
-static const CoordRec char59_stroke1[] = {
-    { 57.1429, 4.7619 },
-    { 52.381, 0 },
-    { 47.6191, 4.7619 },
-    { 52.381, 9.5238 },
-    { 57.1429, 4.7619 },
-    { 57.1429, -4.7619 },
-    { 52.381, -14.2857 },
-    { 47.6191, -19.0476 },
-};
-
-static const StrokeRec char59[] = {
-   { 5, char59_stroke0 },
-   { 8, char59_stroke1 },
-};
-
-/* char: 60 '<' */
-
-static const CoordRec char60_stroke0[] = {
-    { 90.4762, 85.7143 },
-    { 14.2857, 42.8571 },
-    { 90.4762, 0 },
-};
-
-static const StrokeRec char60[] = {
-   { 3, char60_stroke0 },
-};
-
-/* char: 61 '=' */
-
-static const CoordRec char61_stroke0[] = {
-    { 9.5238, 57.1429 },
-    { 95.2381, 57.1429 },
-};
-
-static const CoordRec char61_stroke1[] = {
-    { 9.5238, 28.5714 },
-    { 95.2381, 28.5714 },
-};
-
-static const StrokeRec char61[] = {
-   { 2, char61_stroke0 },
-   { 2, char61_stroke1 },
-};
-
-/* char: 62 '>' */
-
-static const CoordRec char62_stroke0[] = {
-    { 14.2857, 85.7143 },
-    { 90.4762, 42.8571 },
-    { 14.2857, 0 },
-};
-
-static const StrokeRec char62[] = {
-   { 3, char62_stroke0 },
-};
-
-/* char: 63 '?' */
-
-static const CoordRec char63_stroke0[] = {
-    { 23.8095, 76.1905 },
-    { 23.8095, 80.9524 },
-    { 28.5714, 90.4762 },
-    { 33.3333, 95.2381 },
-    { 42.8571, 100 },
-    { 61.9047, 100 },
-    { 71.4285, 95.2381 },
-    { 76.1905, 90.4762 },
-    { 80.9524, 80.9524 },
-    { 80.9524, 71.4286 },
-    { 76.1905, 61.9048 },
-    { 71.4285, 57.1429 },
-    { 52.3809, 47.619 },
-    { 52.3809, 33.3333 },
-};
-
-static const CoordRec char63_stroke1[] = {
-    { 52.3809, 9.5238 },
-    { 47.619, 4.7619 },
-    { 52.3809, 0 },
-    { 57.1428, 4.7619 },
-    { 52.3809, 9.5238 },
-};
-
-static const StrokeRec char63[] = {
-   { 14, char63_stroke0 },
-   { 5, char63_stroke1 },
-};
-
-/* char: 64 '@' */
-
-static const CoordRec char64_stroke0[] = {
-    { 64.2857, 52.381 },
-    { 54.7619, 57.1429 },
-    { 45.2381, 57.1429 },
-    { 40.4762, 47.619 },
-    { 40.4762, 42.8571 },
-    { 45.2381, 33.3333 },
-    { 54.7619, 33.3333 },
-    { 64.2857, 38.0952 },
-};
-
-static const CoordRec char64_stroke1[] = {
-    { 64.2857, 57.1429 },
-    { 64.2857, 38.0952 },
-    { 69.0476, 33.3333 },
-    { 78.5714, 33.3333 },
-    { 83.3334, 42.8571 },
-    { 83.3334, 47.619 },
-    { 78.5714, 61.9048 },
-    { 69.0476, 71.4286 },
-    { 54.7619, 76.1905 },
-    { 50, 76.1905 },
-    { 35.7143, 71.4286 },
-    { 26.1905, 61.9048 },
-    { 21.4286, 47.619 },
-    { 21.4286, 42.8571 },
-    { 26.1905, 28.5714 },
-    { 35.7143, 19.0476 },
-    { 50, 14.2857 },
-    { 54.7619, 14.2857 },
-    { 69.0476, 19.0476 },
-};
-
-static const StrokeRec char64[] = {
-   { 8, char64_stroke0 },
-   { 19, char64_stroke1 },
-};
-
-/* char: 65 'A' */
-
-static const CoordRec char65_stroke0[] = {
-    { 52.3809, 100 },
-    { 14.2857, 0 },
-};
-
-static const CoordRec char65_stroke1[] = {
-    { 52.3809, 100 },
-    { 90.4762, 0 },
-};
-
-static const CoordRec char65_stroke2[] = {
-    { 28.5714, 33.3333 },
-    { 76.1905, 33.3333 },
-};
-
-static const StrokeRec char65[] = {
-   { 2, char65_stroke0 },
-   { 2, char65_stroke1 },
-   { 2, char65_stroke2 },
-};
-
-/* char: 66 'B' */
-
-static const CoordRec char66_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char66_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 71.4286 },
-    { 80.9524, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 61.9047, 52.381 },
-};
-
-static const CoordRec char66_stroke2[] = {
-    { 19.0476, 52.381 },
-    { 61.9047, 52.381 },
-    { 76.1905, 47.619 },
-    { 80.9524, 42.8571 },
-    { 85.7143, 33.3333 },
-    { 85.7143, 19.0476 },
-    { 80.9524, 9.5238 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char66[] = {
-   { 2, char66_stroke0 },
-   { 9, char66_stroke1 },
-   { 10, char66_stroke2 },
-};
-
-/* char: 67 'C' */
-
-static const CoordRec char67_stroke0[] = {
-    { 88.0952, 76.1905 },
-    { 83.3334, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 64.2857, 100 },
-    { 45.2381, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 85.7143 },
-    { 21.4286, 76.1905 },
-    { 16.6667, 61.9048 },
-    { 16.6667, 38.0952 },
-    { 21.4286, 23.8095 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 64.2857, 0 },
-    { 73.8096, 4.7619 },
-    { 83.3334, 14.2857 },
-    { 88.0952, 23.8095 },
-};
-
-static const StrokeRec char67[] = {
-   { 18, char67_stroke0 },
-};
-
-/* char: 68 'D' */
-
-static const CoordRec char68_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char68_stroke1[] = {
-    { 19.0476, 100 },
-    { 52.3809, 100 },
-    { 66.6666, 95.2381 },
-    { 76.1905, 85.7143 },
-    { 80.9524, 76.1905 },
-    { 85.7143, 61.9048 },
-    { 85.7143, 38.0952 },
-    { 80.9524, 23.8095 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 52.3809, 0 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char68[] = {
-   { 2, char68_stroke0 },
-   { 12, char68_stroke1 },
-};
-
-/* char: 69 'E' */
-
-static const CoordRec char69_stroke0[] = {
-    { 21.4286, 100 },
-    { 21.4286, 0 },
-};
-
-static const CoordRec char69_stroke1[] = {
-    { 21.4286, 100 },
-    { 83.3334, 100 },
-};
-
-static const CoordRec char69_stroke2[] = {
-    { 21.4286, 52.381 },
-    { 59.5238, 52.381 },
-};
-
-static const CoordRec char69_stroke3[] = {
-    { 21.4286, 0 },
-    { 83.3334, 0 },
-};
-
-static const StrokeRec char69[] = {
-   { 2, char69_stroke0 },
-   { 2, char69_stroke1 },
-   { 2, char69_stroke2 },
-   { 2, char69_stroke3 },
-};
-
-/* char: 70 'F' */
-
-static const CoordRec char70_stroke0[] = {
-    { 21.4286, 100 },
-    { 21.4286, 0 },
-};
-
-static const CoordRec char70_stroke1[] = {
-    { 21.4286, 100 },
-    { 83.3334, 100 },
-};
-
-static const CoordRec char70_stroke2[] = {
-    { 21.4286, 52.381 },
-    { 59.5238, 52.381 },
-};
-
-static const StrokeRec char70[] = {
-   { 2, char70_stroke0 },
-   { 2, char70_stroke1 },
-   { 2, char70_stroke2 },
-};
-
-/* char: 71 'G' */
-
-static const CoordRec char71_stroke0[] = {
-    { 88.0952, 76.1905 },
-    { 83.3334, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 64.2857, 100 },
-    { 45.2381, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 85.7143 },
-    { 21.4286, 76.1905 },
-    { 16.6667, 61.9048 },
-    { 16.6667, 38.0952 },
-    { 21.4286, 23.8095 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 64.2857, 0 },
-    { 73.8096, 4.7619 },
-    { 83.3334, 14.2857 },
-    { 88.0952, 23.8095 },
-    { 88.0952, 38.0952 },
-};
-
-static const CoordRec char71_stroke1[] = {
-    { 64.2857, 38.0952 },
-    { 88.0952, 38.0952 },
-};
-
-static const StrokeRec char71[] = {
-   { 19, char71_stroke0 },
-   { 2, char71_stroke1 },
-};
-
-/* char: 72 'H' */
-
-static const CoordRec char72_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char72_stroke1[] = {
-    { 85.7143, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char72_stroke2[] = {
-    { 19.0476, 52.381 },
-    { 85.7143, 52.381 },
-};
-
-static const StrokeRec char72[] = {
-   { 2, char72_stroke0 },
-   { 2, char72_stroke1 },
-   { 2, char72_stroke2 },
-};
-
-/* char: 73 'I' */
-
-static const CoordRec char73_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char73[] = {
-   { 2, char73_stroke0 },
-};
-
-/* char: 74 'J' */
-
-static const CoordRec char74_stroke0[] = {
-    { 76.1905, 100 },
-    { 76.1905, 23.8095 },
-    { 71.4286, 9.5238 },
-    { 66.6667, 4.7619 },
-    { 57.1429, 0 },
-    { 47.6191, 0 },
-    { 38.0953, 4.7619 },
-    { 33.3334, 9.5238 },
-    { 28.5715, 23.8095 },
-    { 28.5715, 33.3333 },
-};
-
-static const StrokeRec char74[] = {
-   { 10, char74_stroke0 },
-};
-
-/* char: 75 'K' */
-
-static const CoordRec char75_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char75_stroke1[] = {
-    { 85.7143, 100 },
-    { 19.0476, 33.3333 },
-};
-
-static const CoordRec char75_stroke2[] = {
-    { 42.8571, 57.1429 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char75[] = {
-   { 2, char75_stroke0 },
-   { 2, char75_stroke1 },
-   { 2, char75_stroke2 },
-};
-
-/* char: 76 'L' */
-
-static const CoordRec char76_stroke0[] = {
-    { 23.8095, 100 },
-    { 23.8095, 0 },
-};
-
-static const CoordRec char76_stroke1[] = {
-    { 23.8095, 0 },
-    { 80.9524, 0 },
-};
-
-static const StrokeRec char76[] = {
-   { 2, char76_stroke0 },
-   { 2, char76_stroke1 },
-};
-
-/* char: 77 'M' */
-
-static const CoordRec char77_stroke0[] = {
-    { 14.2857, 100 },
-    { 14.2857, 0 },
-};
-
-static const CoordRec char77_stroke1[] = {
-    { 14.2857, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char77_stroke2[] = {
-    { 90.4762, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char77_stroke3[] = {
-    { 90.4762, 100 },
-    { 90.4762, 0 },
-};
-
-static const StrokeRec char77[] = {
-   { 2, char77_stroke0 },
-   { 2, char77_stroke1 },
-   { 2, char77_stroke2 },
-   { 2, char77_stroke3 },
-};
-
-/* char: 78 'N' */
-
-static const CoordRec char78_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char78_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char78_stroke2[] = {
-    { 85.7143, 100 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char78[] = {
-   { 2, char78_stroke0 },
-   { 2, char78_stroke1 },
-   { 2, char78_stroke2 },
-};
-
-/* char: 79 'O' */
-
-static const CoordRec char79_stroke0[] = {
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 14.2857, 61.9048 },
-    { 14.2857, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 42.8571, 0 },
-    { 61.9047, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 23.8095 },
-    { 90.4762, 38.0952 },
-    { 90.4762, 61.9048 },
-    { 85.7143, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 71.4286, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const StrokeRec char79[] = {
-   { 21, char79_stroke0 },
-};
-
-/* char: 80 'P' */
-
-static const CoordRec char80_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char80_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 66.6667 },
-    { 80.9524, 57.1429 },
-    { 76.1905, 52.381 },
-    { 61.9047, 47.619 },
-    { 19.0476, 47.619 },
-};
-
-static const StrokeRec char80[] = {
-   { 2, char80_stroke0 },
-   { 10, char80_stroke1 },
-};
-
-/* char: 81 'Q' */
-
-static const CoordRec char81_stroke0[] = {
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 14.2857, 61.9048 },
-    { 14.2857, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 42.8571, 0 },
-    { 61.9047, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 23.8095 },
-    { 90.4762, 38.0952 },
-    { 90.4762, 61.9048 },
-    { 85.7143, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 71.4286, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const CoordRec char81_stroke1[] = {
-    { 57.1428, 19.0476 },
-    { 85.7143, -9.5238 },
-};
-
-static const StrokeRec char81[] = {
-   { 21, char81_stroke0 },
-   { 2, char81_stroke1 },
-};
-
-/* char: 82 'R' */
-
-static const CoordRec char82_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char82_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 71.4286 },
-    { 80.9524, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 61.9047, 52.381 },
-    { 19.0476, 52.381 },
-};
-
-static const CoordRec char82_stroke2[] = {
-    { 52.3809, 52.381 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char82[] = {
-   { 2, char82_stroke0 },
-   { 10, char82_stroke1 },
-   { 2, char82_stroke2 },
-};
-
-/* char: 83 'S' */
-
-static const CoordRec char83_stroke0[] = {
-    { 85.7143, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 19.0476, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 23.8095, 66.6667 },
-    { 28.5714, 61.9048 },
-    { 38.0952, 57.1429 },
-    { 66.6666, 47.619 },
-    { 76.1905, 42.8571 },
-    { 80.9524, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 19.0476, 14.2857 },
-};
-
-static const StrokeRec char83[] = {
-   { 20, char83_stroke0 },
-};
-
-/* char: 84 'T' */
-
-static const CoordRec char84_stroke0[] = {
-    { 52.3809, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char84_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char84[] = {
-   { 2, char84_stroke0 },
-   { 2, char84_stroke1 },
-};
-
-/* char: 85 'U' */
-
-static const CoordRec char85_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 28.5714 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char85[] = {
-   { 10, char85_stroke0 },
-};
-
-/* char: 86 'V' */
-
-static const CoordRec char86_stroke0[] = {
-    { 14.2857, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char86_stroke1[] = {
-    { 90.4762, 100 },
-    { 52.3809, 0 },
-};
-
-static const StrokeRec char86[] = {
-   { 2, char86_stroke0 },
-   { 2, char86_stroke1 },
-};
-
-/* char: 87 'W' */
-
-static const CoordRec char87_stroke0[] = {
-    { 4.7619, 100 },
-    { 28.5714, 0 },
-};
-
-static const CoordRec char87_stroke1[] = {
-    { 52.3809, 100 },
-    { 28.5714, 0 },
-};
-
-static const CoordRec char87_stroke2[] = {
-    { 52.3809, 100 },
-    { 76.1905, 0 },
-};
-
-static const CoordRec char87_stroke3[] = {
-    { 100, 100 },
-    { 76.1905, 0 },
-};
-
-static const StrokeRec char87[] = {
-   { 2, char87_stroke0 },
-   { 2, char87_stroke1 },
-   { 2, char87_stroke2 },
-   { 2, char87_stroke3 },
-};
-
-/* char: 88 'X' */
-
-static const CoordRec char88_stroke0[] = {
-    { 19.0476, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char88_stroke1[] = {
-    { 85.7143, 100 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char88[] = {
-   { 2, char88_stroke0 },
-   { 2, char88_stroke1 },
-};
-
-/* char: 89 'Y' */
-
-static const CoordRec char89_stroke0[] = {
-    { 14.2857, 100 },
-    { 52.3809, 52.381 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char89_stroke1[] = {
-    { 90.4762, 100 },
-    { 52.3809, 52.381 },
-};
-
-static const StrokeRec char89[] = {
-   { 3, char89_stroke0 },
-   { 2, char89_stroke1 },
-};
-
-/* char: 90 'Z' */
-
-static const CoordRec char90_stroke0[] = {
-    { 85.7143, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char90_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const CoordRec char90_stroke2[] = {
-    { 19.0476, 0 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char90[] = {
-   { 2, char90_stroke0 },
-   { 2, char90_stroke1 },
-   { 2, char90_stroke2 },
-};
-
-/* char: 91 '[' */
-
-static const CoordRec char91_stroke0[] = {
-    { 35.7143, 119.048 },
-    { 35.7143, -33.3333 },
-};
-
-static const CoordRec char91_stroke1[] = {
-    { 40.4762, 119.048 },
-    { 40.4762, -33.3333 },
-};
-
-static const CoordRec char91_stroke2[] = {
-    { 35.7143, 119.048 },
-    { 69.0476, 119.048 },
-};
-
-static const CoordRec char91_stroke3[] = {
-    { 35.7143, -33.3333 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char91[] = {
-   { 2, char91_stroke0 },
-   { 2, char91_stroke1 },
-   { 2, char91_stroke2 },
-   { 2, char91_stroke3 },
-};
-
-/* char: 92 '\' */
-
-static const CoordRec char92_stroke0[] = {
-    { 19.0476, 100 },
-    { 85.7143, -14.2857 },
-};
-
-static const StrokeRec char92[] = {
-   { 2, char92_stroke0 },
-};
-
-/* char: 93 ']' */
-
-static const CoordRec char93_stroke0[] = {
-    { 64.2857, 119.048 },
-    { 64.2857, -33.3333 },
-};
-
-static const CoordRec char93_stroke1[] = {
-    { 69.0476, 119.048 },
-    { 69.0476, -33.3333 },
-};
-
-static const CoordRec char93_stroke2[] = {
-    { 35.7143, 119.048 },
-    { 69.0476, 119.048 },
-};
-
-static const CoordRec char93_stroke3[] = {
-    { 35.7143, -33.3333 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char93[] = {
-   { 2, char93_stroke0 },
-   { 2, char93_stroke1 },
-   { 2, char93_stroke2 },
-   { 2, char93_stroke3 },
-};
-
-/* char: 94 '^' */
-
-static const CoordRec char94_stroke0[] = {
-    { 52.3809, 109.524 },
-    { 14.2857, 42.8571 },
-};
-
-static const CoordRec char94_stroke1[] = {
-    { 52.3809, 109.524 },
-    { 90.4762, 42.8571 },
-};
-
-static const StrokeRec char94[] = {
-   { 2, char94_stroke0 },
-   { 2, char94_stroke1 },
-};
-
-/* char: 95 '_' */
-
-static const CoordRec char95_stroke0[] = {
-    { 0, -33.3333 },
-    { 104.762, -33.3333 },
-    { 104.762, -28.5714 },
-    { 0, -28.5714 },
-    { 0, -33.3333 },
-};
-
-static const StrokeRec char95[] = {
-   { 5, char95_stroke0 },
-};
-
-/* char: 96 '`' */
-
-static const CoordRec char96_stroke0[] = {
-    { 42.8572, 100 },
-    { 66.6667, 71.4286 },
-};
-
-static const CoordRec char96_stroke1[] = {
-    { 42.8572, 100 },
-    { 38.0953, 95.2381 },
-    { 66.6667, 71.4286 },
-};
-
-static const StrokeRec char96[] = {
-   { 2, char96_stroke0 },
-   { 3, char96_stroke1 },
-};
-
-/* char: 97 'a' */
-
-static const CoordRec char97_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, 0 },
-};
-
-static const CoordRec char97_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char97[] = {
-   { 2, char97_stroke0 },
-   { 14, char97_stroke1 },
-};
-
-/* char: 98 'b' */
-
-static const CoordRec char98_stroke0[] = {
-    { 23.8095, 100 },
-    { 23.8095, 0 },
-};
-
-static const CoordRec char98_stroke1[] = {
-    { 23.8095, 52.381 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 52.381 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 28.5714 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 33.3333, 4.7619 },
-    { 23.8095, 14.2857 },
-};
-
-static const StrokeRec char98[] = {
-   { 2, char98_stroke0 },
-   { 14, char98_stroke1 },
-};
-
-/* char: 99 'c' */
-
-static const CoordRec char99_stroke0[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char99[] = {
-   { 14, char99_stroke0 },
-};
-
-/* char: 100 'd' */
-
-static const CoordRec char100_stroke0[] = {
-    { 80.9524, 100 },
-    { 80.9524, 0 },
-};
-
-static const CoordRec char100_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char100[] = {
-   { 2, char100_stroke0 },
-   { 14, char100_stroke1 },
-};
-
-/* char: 101 'e' */
-
-static const CoordRec char101_stroke0[] = {
-    { 23.8095, 38.0952 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 47.619 },
-    { 76.1905, 57.1429 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char101[] = {
-   { 17, char101_stroke0 },
-};
-
-/* char: 102 'f' */
-
-static const CoordRec char102_stroke0[] = {
-    { 71.4286, 100 },
-    { 61.9048, 100 },
-    { 52.381, 95.2381 },
-    { 47.6191, 80.9524 },
-    { 47.6191, 0 },
-};
-
-static const CoordRec char102_stroke1[] = {
-    { 33.3334, 66.6667 },
-    { 66.6667, 66.6667 },
-};
-
-static const StrokeRec char102[] = {
-   { 5, char102_stroke0 },
-   { 2, char102_stroke1 },
-};
-
-/* char: 103 'g' */
-
-static const CoordRec char103_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, -9.5238 },
-    { 76.1905, -23.8095 },
-    { 71.4285, -28.5714 },
-    { 61.9047, -33.3333 },
-    { 47.619, -33.3333 },
-    { 38.0952, -28.5714 },
-};
-
-static const CoordRec char103_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char103[] = {
-   { 7, char103_stroke0 },
-   { 14, char103_stroke1 },
-};
-
-/* char: 104 'h' */
-
-static const CoordRec char104_stroke0[] = {
-    { 26.1905, 100 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char104_stroke1[] = {
-    { 26.1905, 47.619 },
-    { 40.4762, 61.9048 },
-    { 50, 66.6667 },
-    { 64.2857, 66.6667 },
-    { 73.8095, 61.9048 },
-    { 78.5715, 47.619 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char104[] = {
-   { 2, char104_stroke0 },
-   { 7, char104_stroke1 },
-};
-
-/* char: 105 'i' */
-
-static const CoordRec char105_stroke0[] = {
-    { 47.6191, 100 },
-    { 52.381, 95.2381 },
-    { 57.1429, 100 },
-    { 52.381, 104.762 },
-    { 47.6191, 100 },
-};
-
-static const CoordRec char105_stroke1[] = {
-    { 52.381, 66.6667 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char105[] = {
-   { 5, char105_stroke0 },
-   { 2, char105_stroke1 },
-};
-
-/* char: 106 'j' */
-
-static const CoordRec char106_stroke0[] = {
-    { 57.1429, 100 },
-    { 61.9048, 95.2381 },
-    { 66.6667, 100 },
-    { 61.9048, 104.762 },
-    { 57.1429, 100 },
-};
-
-static const CoordRec char106_stroke1[] = {
-    { 61.9048, 66.6667 },
-    { 61.9048, -14.2857 },
-    { 57.1429, -28.5714 },
-    { 47.6191, -33.3333 },
-    { 38.0953, -33.3333 },
-};
-
-static const StrokeRec char106[] = {
-   { 5, char106_stroke0 },
-   { 5, char106_stroke1 },
-};
-
-/* char: 107 'k' */
-
-static const CoordRec char107_stroke0[] = {
-    { 26.1905, 100 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char107_stroke1[] = {
-    { 73.8095, 66.6667 },
-    { 26.1905, 19.0476 },
-};
-
-static const CoordRec char107_stroke2[] = {
-    { 45.2381, 38.0952 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char107[] = {
-   { 2, char107_stroke0 },
-   { 2, char107_stroke1 },
-   { 2, char107_stroke2 },
-};
-
-/* char: 108 'l' */
-
-static const CoordRec char108_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char108[] = {
-   { 2, char108_stroke0 },
-};
-
-/* char: 109 'm' */
-
-static const CoordRec char109_stroke0[] = {
-    { 0, 66.6667 },
-    { 0, 0 },
-};
-
-static const CoordRec char109_stroke1[] = {
-    { 0, 47.619 },
-    { 14.2857, 61.9048 },
-    { 23.8095, 66.6667 },
-    { 38.0952, 66.6667 },
-    { 47.619, 61.9048 },
-    { 52.381, 47.619 },
-    { 52.381, 0 },
-};
-
-static const CoordRec char109_stroke2[] = {
-    { 52.381, 47.619 },
-    { 66.6667, 61.9048 },
-    { 76.1905, 66.6667 },
-    { 90.4762, 66.6667 },
-    { 100, 61.9048 },
-    { 104.762, 47.619 },
-    { 104.762, 0 },
-};
-
-static const StrokeRec char109[] = {
-   { 2, char109_stroke0 },
-   { 7, char109_stroke1 },
-   { 7, char109_stroke2 },
-};
-
-/* char: 110 'n' */
-
-static const CoordRec char110_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char110_stroke1[] = {
-    { 26.1905, 47.619 },
-    { 40.4762, 61.9048 },
-    { 50, 66.6667 },
-    { 64.2857, 66.6667 },
-    { 73.8095, 61.9048 },
-    { 78.5715, 47.619 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char110[] = {
-   { 2, char110_stroke0 },
-   { 7, char110_stroke1 },
-};
-
-/* char: 111 'o' */
-
-static const CoordRec char111_stroke0[] = {
-    { 45.2381, 66.6667 },
-    { 35.7143, 61.9048 },
-    { 26.1905, 52.381 },
-    { 21.4286, 38.0952 },
-    { 21.4286, 28.5714 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 59.5238, 0 },
-    { 69.0476, 4.7619 },
-    { 78.5714, 14.2857 },
-    { 83.3334, 28.5714 },
-    { 83.3334, 38.0952 },
-    { 78.5714, 52.381 },
-    { 69.0476, 61.9048 },
-    { 59.5238, 66.6667 },
-    { 45.2381, 66.6667 },
-};
-
-static const StrokeRec char111[] = {
-   { 17, char111_stroke0 },
-};
-
-/* char: 112 'p' */
-
-static const CoordRec char112_stroke0[] = {
-    { 23.8095, 66.6667 },
-    { 23.8095, -33.3333 },
-};
-
-static const CoordRec char112_stroke1[] = {
-    { 23.8095, 52.381 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 52.381 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 28.5714 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 33.3333, 4.7619 },
-    { 23.8095, 14.2857 },
-};
-
-static const StrokeRec char112[] = {
-   { 2, char112_stroke0 },
-   { 14, char112_stroke1 },
-};
-
-/* char: 113 'q' */
-
-static const CoordRec char113_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, -33.3333 },
-};
-
-static const CoordRec char113_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char113[] = {
-   { 2, char113_stroke0 },
-   { 14, char113_stroke1 },
-};
-
-/* char: 114 'r' */
-
-static const CoordRec char114_stroke0[] = {
-    { 33.3334, 66.6667 },
-    { 33.3334, 0 },
-};
-
-static const CoordRec char114_stroke1[] = {
-    { 33.3334, 38.0952 },
-    { 38.0953, 52.381 },
-    { 47.6191, 61.9048 },
-    { 57.1429, 66.6667 },
-    { 71.4286, 66.6667 },
-};
-
-static const StrokeRec char114[] = {
-   { 2, char114_stroke0 },
-   { 5, char114_stroke1 },
-};
-
-/* char: 115 's' */
-
-static const CoordRec char115_stroke0[] = {
-    { 78.5715, 52.381 },
-    { 73.8095, 61.9048 },
-    { 59.5238, 66.6667 },
-    { 45.2381, 66.6667 },
-    { 30.9524, 61.9048 },
-    { 26.1905, 52.381 },
-    { 30.9524, 42.8571 },
-    { 40.4762, 38.0952 },
-    { 64.2857, 33.3333 },
-    { 73.8095, 28.5714 },
-    { 78.5715, 19.0476 },
-    { 78.5715, 14.2857 },
-    { 73.8095, 4.7619 },
-    { 59.5238, 0 },
-    { 45.2381, 0 },
-    { 30.9524, 4.7619 },
-    { 26.1905, 14.2857 },
-};
-
-static const StrokeRec char115[] = {
-   { 17, char115_stroke0 },
-};
-
-/* char: 116 't' */
-
-static const CoordRec char116_stroke0[] = {
-    { 47.6191, 100 },
-    { 47.6191, 19.0476 },
-    { 52.381, 4.7619 },
-    { 61.9048, 0 },
-    { 71.4286, 0 },
-};
-
-static const CoordRec char116_stroke1[] = {
-    { 33.3334, 66.6667 },
-    { 66.6667, 66.6667 },
-};
-
-static const StrokeRec char116[] = {
-   { 5, char116_stroke0 },
-   { 2, char116_stroke1 },
-};
-
-/* char: 117 'u' */
-
-static const CoordRec char117_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 26.1905, 19.0476 },
-    { 30.9524, 4.7619 },
-    { 40.4762, 0 },
-    { 54.7619, 0 },
-    { 64.2857, 4.7619 },
-    { 78.5715, 19.0476 },
-};
-
-static const CoordRec char117_stroke1[] = {
-    { 78.5715, 66.6667 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char117[] = {
-   { 7, char117_stroke0 },
-   { 2, char117_stroke1 },
-};
-
-/* char: 118 'v' */
-
-static const CoordRec char118_stroke0[] = {
-    { 23.8095, 66.6667 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char118_stroke1[] = {
-    { 80.9524, 66.6667 },
-    { 52.3809, 0 },
-};
-
-static const StrokeRec char118[] = {
-   { 2, char118_stroke0 },
-   { 2, char118_stroke1 },
-};
-
-/* char: 119 'w' */
-
-static const CoordRec char119_stroke0[] = {
-    { 14.2857, 66.6667 },
-    { 33.3333, 0 },
-};
-
-static const CoordRec char119_stroke1[] = {
-    { 52.3809, 66.6667 },
-    { 33.3333, 0 },
-};
-
-static const CoordRec char119_stroke2[] = {
-    { 52.3809, 66.6667 },
-    { 71.4286, 0 },
-};
-
-static const CoordRec char119_stroke3[] = {
-    { 90.4762, 66.6667 },
-    { 71.4286, 0 },
-};
-
-static const StrokeRec char119[] = {
-   { 2, char119_stroke0 },
-   { 2, char119_stroke1 },
-   { 2, char119_stroke2 },
-   { 2, char119_stroke3 },
-};
-
-/* char: 120 'x' */
-
-static const CoordRec char120_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 78.5715, 0 },
-};
-
-static const CoordRec char120_stroke1[] = {
-    { 78.5715, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const StrokeRec char120[] = {
-   { 2, char120_stroke0 },
-   { 2, char120_stroke1 },
-};
-
-/* char: 121 'y' */
-
-static const CoordRec char121_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 54.7619, 0 },
-};
-
-static const CoordRec char121_stroke1[] = {
-    { 83.3334, 66.6667 },
-    { 54.7619, 0 },
-    { 45.2381, -19.0476 },
-    { 35.7143, -28.5714 },
-    { 26.1905, -33.3333 },
-    { 21.4286, -33.3333 },
-};
-
-static const StrokeRec char121[] = {
-   { 2, char121_stroke0 },
-   { 6, char121_stroke1 },
-};
-
-/* char: 122 'z' */
-
-static const CoordRec char122_stroke0[] = {
-    { 78.5715, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char122_stroke1[] = {
-    { 26.1905, 66.6667 },
-    { 78.5715, 66.6667 },
-};
-
-static const CoordRec char122_stroke2[] = {
-    { 26.1905, 0 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char122[] = {
-   { 2, char122_stroke0 },
-   { 2, char122_stroke1 },
-   { 2, char122_stroke2 },
-};
-
-/* char: 123 '{' */
-
-static const CoordRec char123_stroke0[] = {
-    { 64.2857, 119.048 },
-    { 54.7619, 114.286 },
-    { 50, 109.524 },
-    { 45.2381, 100 },
-    { 45.2381, 90.4762 },
-    { 50, 80.9524 },
-    { 54.7619, 76.1905 },
-    { 59.5238, 66.6667 },
-    { 59.5238, 57.1429 },
-    { 50, 47.619 },
-};
-
-static const CoordRec char123_stroke1[] = {
-    { 54.7619, 114.286 },
-    { 50, 104.762 },
-    { 50, 95.2381 },
-    { 54.7619, 85.7143 },
-    { 59.5238, 80.9524 },
-    { 64.2857, 71.4286 },
-    { 64.2857, 61.9048 },
-    { 59.5238, 52.381 },
-    { 40.4762, 42.8571 },
-    { 59.5238, 33.3333 },
-    { 64.2857, 23.8095 },
-    { 64.2857, 14.2857 },
-    { 59.5238, 4.7619 },
-    { 54.7619, 0 },
-    { 50, -9.5238 },
-    { 50, -19.0476 },
-    { 54.7619, -28.5714 },
-};
-
-static const CoordRec char123_stroke2[] = {
-    { 50, 38.0952 },
-    { 59.5238, 28.5714 },
-    { 59.5238, 19.0476 },
-    { 54.7619, 9.5238 },
-    { 50, 4.7619 },
-    { 45.2381, -4.7619 },
-    { 45.2381, -14.2857 },
-    { 50, -23.8095 },
-    { 54.7619, -28.5714 },
-    { 64.2857, -33.3333 },
-};
-
-static const StrokeRec char123[] = {
-   { 10, char123_stroke0 },
-   { 17, char123_stroke1 },
-   { 10, char123_stroke2 },
-};
-
-/* char: 124 '|' */
-
-static const CoordRec char124_stroke0[] = {
-    { 52.381, 119.048 },
-    { 52.381, -33.3333 },
-};
-
-static const StrokeRec char124[] = {
-   { 2, char124_stroke0 },
-};
-
-/* char: 125 '}' */
-
-static const CoordRec char125_stroke0[] = {
-    { 40.4762, 119.048 },
-    { 50, 114.286 },
-    { 54.7619, 109.524 },
-    { 59.5238, 100 },
-    { 59.5238, 90.4762 },
-    { 54.7619, 80.9524 },
-    { 50, 76.1905 },
-    { 45.2381, 66.6667 },
-    { 45.2381, 57.1429 },
-    { 54.7619, 47.619 },
-};
-
-static const CoordRec char125_stroke1[] = {
-    { 50, 114.286 },
-    { 54.7619, 104.762 },
-    { 54.7619, 95.2381 },
-    { 50, 85.7143 },
-    { 45.2381, 80.9524 },
-    { 40.4762, 71.4286 },
-    { 40.4762, 61.9048 },
-    { 45.2381, 52.381 },
-    { 64.2857, 42.8571 },
-    { 45.2381, 33.3333 },
-    { 40.4762, 23.8095 },
-    { 40.4762, 14.2857 },
-    { 45.2381, 4.7619 },
-    { 50, 0 },
-    { 54.7619, -9.5238 },
-    { 54.7619, -19.0476 },
-    { 50, -28.5714 },
-};
-
-static const CoordRec char125_stroke2[] = {
-    { 54.7619, 38.0952 },
-    { 45.2381, 28.5714 },
-    { 45.2381, 19.0476 },
-    { 50, 9.5238 },
-    { 54.7619, 4.7619 },
-    { 59.5238, -4.7619 },
-    { 59.5238, -14.2857 },
-    { 54.7619, -23.8095 },
-    { 50, -28.5714 },
-    { 40.4762, -33.3333 },
-};
-
-static const StrokeRec char125[] = {
-   { 10, char125_stroke0 },
-   { 17, char125_stroke1 },
-   { 10, char125_stroke2 },
-};
-
-/* char: 126 '~' */
-
-static const CoordRec char126_stroke0[] = {
-    { 9.5238, 28.5714 },
-    { 9.5238, 38.0952 },
-    { 14.2857, 52.381 },
-    { 23.8095, 57.1429 },
-    { 33.3333, 57.1429 },
-    { 42.8571, 52.381 },
-    { 61.9048, 38.0952 },
-    { 71.4286, 33.3333 },
-    { 80.9524, 33.3333 },
-    { 90.4762, 38.0952 },
-    { 95.2381, 47.619 },
-};
-
-static const CoordRec char126_stroke1[] = {
-    { 9.5238, 38.0952 },
-    { 14.2857, 47.619 },
-    { 23.8095, 52.381 },
-    { 33.3333, 52.381 },
-    { 42.8571, 47.619 },
-    { 61.9048, 33.3333 },
-    { 71.4286, 28.5714 },
-    { 80.9524, 28.5714 },
-    { 90.4762, 33.3333 },
-    { 95.2381, 47.619 },
-    { 95.2381, 57.1429 },
-};
-
-static const StrokeRec char126[] = {
-   { 11, char126_stroke0 },
-   { 11, char126_stroke1 },
-};
-
-/* char: 127 */
-
-static const CoordRec char127_stroke0[] = {
-    { 71.4286, 100 },
-    { 33.3333, -33.3333 },
-};
-
-static const CoordRec char127_stroke1[] = {
-    { 47.619, 66.6667 },
-    { 33.3333, 61.9048 },
-    { 23.8095, 52.381 },
-    { 19.0476, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 42.8571 },
-    { 80.9524, 52.381 },
-    { 71.4286, 61.9048 },
-    { 57.1428, 66.6667 },
-    { 47.619, 66.6667 },
-};
-
-static const StrokeRec char127[] = {
-   { 2, char127_stroke0 },
-   { 17, char127_stroke1 },
-};
-
-static const StrokeCharRec chars[] = {
-    { 0, /* char0 */ 0, 0, 0 },
-    { 0, /* char1 */ 0, 0, 0 },
-    { 0, /* char2 */ 0, 0, 0 },
-    { 0, /* char3 */ 0, 0, 0 },
-    { 0, /* char4 */ 0, 0, 0 },
-    { 0, /* char5 */ 0, 0, 0 },
-    { 0, /* char6 */ 0, 0, 0 },
-    { 0, /* char7 */ 0, 0, 0 },
-    { 0, /* char8 */ 0, 0, 0 },
-    { 0, /* char9 */ 0, 0, 0 },
-    { 0, /* char10 */ 0, 0, 0 },
-    { 0, /* char11 */ 0, 0, 0 },
-    { 0, /* char12 */ 0, 0, 0 },
-    { 0, /* char13 */ 0, 0, 0 },
-    { 0, /* char14 */ 0, 0, 0 },
-    { 0, /* char15 */ 0, 0, 0 },
-    { 0, /* char16 */ 0, 0, 0 },
-    { 0, /* char17 */ 0, 0, 0 },
-    { 0, /* char18 */ 0, 0, 0 },
-    { 0, /* char19 */ 0, 0, 0 },
-    { 0, /* char20 */ 0, 0, 0 },
-    { 0, /* char21 */ 0, 0, 0 },
-    { 0, /* char22 */ 0, 0, 0 },
-    { 0, /* char23 */ 0, 0, 0 },
-    { 0, /* char24 */ 0, 0, 0 },
-    { 0, /* char25 */ 0, 0, 0 },
-    { 0, /* char26 */ 0, 0, 0 },
-    { 0, /* char27 */ 0, 0, 0 },
-    { 0, /* char28 */ 0, 0, 0 },
-    { 0, /* char29 */ 0, 0, 0 },
-    { 0, /* char30 */ 0, 0, 0 },
-    { 0, /* char31 */ 0, 0, 0 },
-    { 0, /* char32 */ 0, 52.381, 104.762 },
-    { 2, char33, 52.381, 104.762 },
-    { 2, char34, 52.381, 104.762 },
-    { 4, char35, 52.381, 104.762 },
-    { 3, char36, 52.381, 104.762 },
-    { 3, char37, 52.381, 104.762 },
-    { 1, char38, 52.381, 104.762 },
-    { 1, char39, 52.381, 104.762 },
-    { 1, char40, 52.381, 104.762 },
-    { 1, char41, 52.381, 104.762 },
-    { 3, char42, 52.381, 104.762 },
-    { 2, char43, 52.381, 104.762 },
-    { 1, char44, 52.381, 104.762 },
-    { 1, char45, 52.381, 104.762 },
-    { 1, char46, 52.381, 104.762 },
-    { 1, char47, 52.381, 104.762 },
-    { 1, char48, 52.381, 104.762 },
-    { 1, char49, 52.381, 104.762 },
-    { 1, char50, 52.381, 104.762 },
-    { 1, char51, 52.381, 104.762 },
-    { 2, char52, 52.381, 104.762 },
-    { 1, char53, 52.381, 104.762 },
-    { 1, char54, 52.381, 104.762 },
-    { 2, char55, 52.381, 104.762 },
-    { 1, char56, 52.381, 104.762 },
-    { 1, char57, 52.381, 104.762 },
-    { 2, char58, 52.381, 104.762 },
-    { 2, char59, 52.381, 104.762 },
-    { 1, char60, 52.381, 104.762 },
-    { 2, char61, 52.381, 104.762 },
-    { 1, char62, 52.381, 104.762 },
-    { 2, char63, 52.381, 104.762 },
-    { 2, char64, 52.381, 104.762 },
-    { 3, char65, 52.381, 104.762 },
-    { 3, char66, 52.381, 104.762 },
-    { 1, char67, 52.381, 104.762 },
-    { 2, char68, 52.381, 104.762 },
-    { 4, char69, 52.381, 104.762 },
-    { 3, char70, 52.381, 104.762 },
-    { 2, char71, 52.381, 104.762 },
-    { 3, char72, 52.381, 104.762 },
-    { 1, char73, 52.381, 104.762 },
-    { 1, char74, 52.381, 104.762 },
-    { 3, char75, 52.381, 104.762 },
-    { 2, char76, 52.381, 104.762 },
-    { 4, char77, 52.381, 104.762 },
-    { 3, char78, 52.381, 104.762 },
-    { 1, char79, 52.381, 104.762 },
-    { 2, char80, 52.381, 104.762 },
-    { 2, char81, 52.381, 104.762 },
-    { 3, char82, 52.381, 104.762 },
-    { 1, char83, 52.381, 104.762 },
-    { 2, char84, 52.381, 104.762 },
-    { 1, char85, 52.381, 104.762 },
-    { 2, char86, 52.381, 104.762 },
-    { 4, char87, 52.381, 104.762 },
-    { 2, char88, 52.381, 104.762 },
-    { 2, char89, 52.381, 104.762 },
-    { 3, char90, 52.381, 104.762 },
-    { 4, char91, 52.381, 104.762 },
-    { 1, char92, 52.381, 104.762 },
-    { 4, char93, 52.381, 104.762 },
-    { 2, char94, 52.381, 104.762 },
-    { 1, char95, 52.381, 104.762 },
-    { 2, char96, 52.381, 104.762 },
-    { 2, char97, 52.381, 104.762 },
-    { 2, char98, 52.381, 104.762 },
-    { 1, char99, 52.381, 104.762 },
-    { 2, char100, 52.381, 104.762 },
-    { 1, char101, 52.381, 104.762 },
-    { 2, char102, 52.381, 104.762 },
-    { 2, char103, 52.381, 104.762 },
-    { 2, char104, 52.381, 104.762 },
-    { 2, char105, 52.381, 104.762 },
-    { 2, char106, 52.381, 104.762 },
-    { 3, char107, 52.381, 104.762 },
-    { 1, char108, 52.381, 104.762 },
-    { 3, char109, 52.381, 104.762 },
-    { 2, char110, 52.381, 104.762 },
-    { 1, char111, 52.381, 104.762 },
-    { 2, char112, 52.381, 104.762 },
-    { 2, char113, 52.381, 104.762 },
-    { 2, char114, 52.381, 104.762 },
-    { 1, char115, 52.381, 104.762 },
-    { 2, char116, 52.381, 104.762 },
-    { 2, char117, 52.381, 104.762 },
-    { 2, char118, 52.381, 104.762 },
-    { 4, char119, 52.381, 104.762 },
-    { 2, char120, 52.381, 104.762 },
-    { 2, char121, 52.381, 104.762 },
-    { 3, char122, 52.381, 104.762 },
-    { 3, char123, 52.381, 104.762 },
-    { 1, char124, 52.381, 104.762 },
-    { 3, char125, 52.381, 104.762 },
-    { 2, char126, 52.381, 104.762 },
-    { 2, char127, 52.381, 104.762 },
-};
-
-StrokeFontRec glutStrokeMonoRoman = { "Roman", 128, chars, 119.048, -33.3333 };
-
diff --git a/src/glut/beos/glut_roman.c b/src/glut/beos/glut_roman.c
deleted file mode 100644
index af2b4ec956d..00000000000
--- a/src/glut/beos/glut_roman.c
+++ /dev/null
@@ -1,2451 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#include "glutstroke.h"
-
-/* char: 33 '!' */
-
-static const CoordRec char33_stroke0[] = {
-    { 13.3819, 100 },
-    { 13.3819, 33.3333 },
-};
-
-static const CoordRec char33_stroke1[] = {
-    { 13.3819, 9.5238 },
-    { 8.62, 4.7619 },
-    { 13.3819, 0 },
-    { 18.1438, 4.7619 },
-    { 13.3819, 9.5238 },
-};
-
-static const StrokeRec char33[] = {
-   { 2, char33_stroke0 },
-   { 5, char33_stroke1 },
-};
-
-/* char: 34 '"' */
-
-static const CoordRec char34_stroke0[] = {
-    { 4.02, 100 },
-    { 4.02, 66.6667 },
-};
-
-static const CoordRec char34_stroke1[] = {
-    { 42.1152, 100 },
-    { 42.1152, 66.6667 },
-};
-
-static const StrokeRec char34[] = {
-   { 2, char34_stroke0 },
-   { 2, char34_stroke1 },
-};
-
-/* char: 35 '#' */
-
-static const CoordRec char35_stroke0[] = {
-    { 41.2952, 119.048 },
-    { 7.9619, -33.3333 },
-};
-
-static const CoordRec char35_stroke1[] = {
-    { 69.8667, 119.048 },
-    { 36.5333, -33.3333 },
-};
-
-static const CoordRec char35_stroke2[] = {
-    { 7.9619, 57.1429 },
-    { 74.6286, 57.1429 },
-};
-
-static const CoordRec char35_stroke3[] = {
-    { 3.2, 28.5714 },
-    { 69.8667, 28.5714 },
-};
-
-static const StrokeRec char35[] = {
-   { 2, char35_stroke0 },
-   { 2, char35_stroke1 },
-   { 2, char35_stroke2 },
-   { 2, char35_stroke3 },
-};
-
-/* char: 36 '$' */
-
-static const CoordRec char36_stroke0[] = {
-    { 28.6295, 119.048 },
-    { 28.6295, -19.0476 },
-};
-
-static const CoordRec char36_stroke1[] = {
-    { 47.6771, 119.048 },
-    { 47.6771, -19.0476 },
-};
-
-static const CoordRec char36_stroke2[] = {
-    { 71.4867, 85.7143 },
-    { 61.9629, 95.2381 },
-    { 47.6771, 100 },
-    { 28.6295, 100 },
-    { 14.3438, 95.2381 },
-    { 4.82, 85.7143 },
-    { 4.82, 76.1905 },
-    { 9.5819, 66.6667 },
-    { 14.3438, 61.9048 },
-    { 23.8676, 57.1429 },
-    { 52.439, 47.619 },
-    { 61.9629, 42.8571 },
-    { 66.7248, 38.0952 },
-    { 71.4867, 28.5714 },
-    { 71.4867, 14.2857 },
-    { 61.9629, 4.7619 },
-    { 47.6771, 0 },
-    { 28.6295, 0 },
-    { 14.3438, 4.7619 },
-    { 4.82, 14.2857 },
-};
-
-static const StrokeRec char36[] = {
-   { 2, char36_stroke0 },
-   { 2, char36_stroke1 },
-   { 20, char36_stroke2 },
-};
-
-/* char: 37 '%' */
-
-static const CoordRec char37_stroke0[] = {
-    { 92.0743, 100 },
-    { 6.36, 0 },
-};
-
-static const CoordRec char37_stroke1[] = {
-    { 30.1695, 100 },
-    { 39.6933, 90.4762 },
-    { 39.6933, 80.9524 },
-    { 34.9314, 71.4286 },
-    { 25.4076, 66.6667 },
-    { 15.8838, 66.6667 },
-    { 6.36, 76.1905 },
-    { 6.36, 85.7143 },
-    { 11.1219, 95.2381 },
-    { 20.6457, 100 },
-    { 30.1695, 100 },
-    { 39.6933, 95.2381 },
-    { 53.979, 90.4762 },
-    { 68.2648, 90.4762 },
-    { 82.5505, 95.2381 },
-    { 92.0743, 100 },
-};
-
-static const CoordRec char37_stroke2[] = {
-    { 73.0267, 33.3333 },
-    { 63.5029, 28.5714 },
-    { 58.741, 19.0476 },
-    { 58.741, 9.5238 },
-    { 68.2648, 0 },
-    { 77.7886, 0 },
-    { 87.3124, 4.7619 },
-    { 92.0743, 14.2857 },
-    { 92.0743, 23.8095 },
-    { 82.5505, 33.3333 },
-    { 73.0267, 33.3333 },
-};
-
-static const StrokeRec char37[] = {
-   { 2, char37_stroke0 },
-   { 16, char37_stroke1 },
-   { 11, char37_stroke2 },
-};
-
-/* char: 38 '&' */
-
-static const CoordRec char38_stroke0[] = {
-    { 101.218, 57.1429 },
-    { 101.218, 61.9048 },
-    { 96.4562, 66.6667 },
-    { 91.6943, 66.6667 },
-    { 86.9324, 61.9048 },
-    { 82.1705, 52.381 },
-    { 72.6467, 28.5714 },
-    { 63.1229, 14.2857 },
-    { 53.599, 4.7619 },
-    { 44.0752, 0 },
-    { 25.0276, 0 },
-    { 15.5038, 4.7619 },
-    { 10.7419, 9.5238 },
-    { 5.98, 19.0476 },
-    { 5.98, 28.5714 },
-    { 10.7419, 38.0952 },
-    { 15.5038, 42.8571 },
-    { 48.8371, 61.9048 },
-    { 53.599, 66.6667 },
-    { 58.361, 76.1905 },
-    { 58.361, 85.7143 },
-    { 53.599, 95.2381 },
-    { 44.0752, 100 },
-    { 34.5514, 95.2381 },
-    { 29.7895, 85.7143 },
-    { 29.7895, 76.1905 },
-    { 34.5514, 61.9048 },
-    { 44.0752, 47.619 },
-    { 67.8848, 14.2857 },
-    { 77.4086, 4.7619 },
-    { 86.9324, 0 },
-    { 96.4562, 0 },
-    { 101.218, 4.7619 },
-    { 101.218, 9.5238 },
-};
-
-static const StrokeRec char38[] = {
-   { 34, char38_stroke0 },
-};
-
-/* char: 39 ''' */
-
-static const CoordRec char39_stroke0[] = {
-    { 4.44, 100 },
-    { 4.44, 66.6667 },
-};
-
-static const StrokeRec char39[] = {
-   { 2, char39_stroke0 },
-};
-
-/* char: 40 '(' */
-
-static const CoordRec char40_stroke0[] = {
-    { 40.9133, 119.048 },
-    { 31.3895, 109.524 },
-    { 21.8657, 95.2381 },
-    { 12.3419, 76.1905 },
-    { 7.58, 52.381 },
-    { 7.58, 33.3333 },
-    { 12.3419, 9.5238 },
-    { 21.8657, -9.5238 },
-    { 31.3895, -23.8095 },
-    { 40.9133, -33.3333 },
-};
-
-static const StrokeRec char40[] = {
-   { 10, char40_stroke0 },
-};
-
-/* char: 41 ')' */
-
-static const CoordRec char41_stroke0[] = {
-    { 5.28, 119.048 },
-    { 14.8038, 109.524 },
-    { 24.3276, 95.2381 },
-    { 33.8514, 76.1905 },
-    { 38.6133, 52.381 },
-    { 38.6133, 33.3333 },
-    { 33.8514, 9.5238 },
-    { 24.3276, -9.5238 },
-    { 14.8038, -23.8095 },
-    { 5.28, -33.3333 },
-};
-
-static const StrokeRec char41[] = {
-   { 10, char41_stroke0 },
-};
-
-/* char: 42 '*' */
-
-static const CoordRec char42_stroke0[] = {
-    { 30.7695, 71.4286 },
-    { 30.7695, 14.2857 },
-};
-
-static const CoordRec char42_stroke1[] = {
-    { 6.96, 57.1429 },
-    { 54.579, 28.5714 },
-};
-
-static const CoordRec char42_stroke2[] = {
-    { 54.579, 57.1429 },
-    { 6.96, 28.5714 },
-};
-
-static const StrokeRec char42[] = {
-   { 2, char42_stroke0 },
-   { 2, char42_stroke1 },
-   { 2, char42_stroke2 },
-};
-
-/* char: 43 '+' */
-
-static const CoordRec char43_stroke0[] = {
-    { 48.8371, 85.7143 },
-    { 48.8371, 0 },
-};
-
-static const CoordRec char43_stroke1[] = {
-    { 5.98, 42.8571 },
-    { 91.6943, 42.8571 },
-};
-
-static const StrokeRec char43[] = {
-   { 2, char43_stroke0 },
-   { 2, char43_stroke1 },
-};
-
-/* char: 44 ',' */
-
-static const CoordRec char44_stroke0[] = {
-    { 18.2838, 4.7619 },
-    { 13.5219, 0 },
-    { 8.76, 4.7619 },
-    { 13.5219, 9.5238 },
-    { 18.2838, 4.7619 },
-    { 18.2838, -4.7619 },
-    { 13.5219, -14.2857 },
-    { 8.76, -19.0476 },
-};
-
-static const StrokeRec char44[] = {
-   { 8, char44_stroke0 },
-};
-
-/* char: 45 '-' */
-
-static const CoordRec char45_stroke0[] = {
-    { 7.38, 42.8571 },
-    { 93.0943, 42.8571 },
-};
-
-static const StrokeRec char45[] = {
-   { 2, char45_stroke0 },
-};
-
-/* char: 46 '.' */
-
-static const CoordRec char46_stroke0[] = {
-    { 13.1019, 9.5238 },
-    { 8.34, 4.7619 },
-    { 13.1019, 0 },
-    { 17.8638, 4.7619 },
-    { 13.1019, 9.5238 },
-};
-
-static const StrokeRec char46[] = {
-   { 5, char46_stroke0 },
-};
-
-/* char: 47 '/' */
-
-static const CoordRec char47_stroke0[] = {
-    { 7.24, -14.2857 },
-    { 73.9067, 100 },
-};
-
-static const StrokeRec char47[] = {
-   { 2, char47_stroke0 },
-};
-
-/* char: 48 '0' */
-
-static const CoordRec char48_stroke0[] = {
-    { 33.5514, 100 },
-    { 19.2657, 95.2381 },
-    { 9.7419, 80.9524 },
-    { 4.98, 57.1429 },
-    { 4.98, 42.8571 },
-    { 9.7419, 19.0476 },
-    { 19.2657, 4.7619 },
-    { 33.5514, 0 },
-    { 43.0752, 0 },
-    { 57.361, 4.7619 },
-    { 66.8848, 19.0476 },
-    { 71.6467, 42.8571 },
-    { 71.6467, 57.1429 },
-    { 66.8848, 80.9524 },
-    { 57.361, 95.2381 },
-    { 43.0752, 100 },
-    { 33.5514, 100 },
-};
-
-static const StrokeRec char48[] = {
-   { 17, char48_stroke0 },
-};
-
-/* char: 49 '1' */
-
-static const CoordRec char49_stroke0[] = {
-    { 11.82, 80.9524 },
-    { 21.3438, 85.7143 },
-    { 35.6295, 100 },
-    { 35.6295, 0 },
-};
-
-static const StrokeRec char49[] = {
-   { 4, char49_stroke0 },
-};
-
-/* char: 50 '2' */
-
-static const CoordRec char50_stroke0[] = {
-    { 10.1819, 76.1905 },
-    { 10.1819, 80.9524 },
-    { 14.9438, 90.4762 },
-    { 19.7057, 95.2381 },
-    { 29.2295, 100 },
-    { 48.2771, 100 },
-    { 57.801, 95.2381 },
-    { 62.5629, 90.4762 },
-    { 67.3248, 80.9524 },
-    { 67.3248, 71.4286 },
-    { 62.5629, 61.9048 },
-    { 53.039, 47.619 },
-    { 5.42, 0 },
-    { 72.0867, 0 },
-};
-
-static const StrokeRec char50[] = {
-   { 14, char50_stroke0 },
-};
-
-/* char: 51 '3' */
-
-static const CoordRec char51_stroke0[] = {
-    { 14.5238, 100 },
-    { 66.9048, 100 },
-    { 38.3333, 61.9048 },
-    { 52.619, 61.9048 },
-    { 62.1429, 57.1429 },
-    { 66.9048, 52.381 },
-    { 71.6667, 38.0952 },
-    { 71.6667, 28.5714 },
-    { 66.9048, 14.2857 },
-    { 57.381, 4.7619 },
-    { 43.0952, 0 },
-    { 28.8095, 0 },
-    { 14.5238, 4.7619 },
-    { 9.7619, 9.5238 },
-    { 5, 19.0476 },
-};
-
-static const StrokeRec char51[] = {
-   { 15, char51_stroke0 },
-};
-
-/* char: 52 '4' */
-
-static const CoordRec char52_stroke0[] = {
-    { 51.499, 100 },
-    { 3.88, 33.3333 },
-    { 75.3086, 33.3333 },
-};
-
-static const CoordRec char52_stroke1[] = {
-    { 51.499, 100 },
-    { 51.499, 0 },
-};
-
-static const StrokeRec char52[] = {
-   { 3, char52_stroke0 },
-   { 2, char52_stroke1 },
-};
-
-/* char: 53 '5' */
-
-static const CoordRec char53_stroke0[] = {
-    { 62.0029, 100 },
-    { 14.3838, 100 },
-    { 9.6219, 57.1429 },
-    { 14.3838, 61.9048 },
-    { 28.6695, 66.6667 },
-    { 42.9552, 66.6667 },
-    { 57.241, 61.9048 },
-    { 66.7648, 52.381 },
-    { 71.5267, 38.0952 },
-    { 71.5267, 28.5714 },
-    { 66.7648, 14.2857 },
-    { 57.241, 4.7619 },
-    { 42.9552, 0 },
-    { 28.6695, 0 },
-    { 14.3838, 4.7619 },
-    { 9.6219, 9.5238 },
-    { 4.86, 19.0476 },
-};
-
-static const StrokeRec char53[] = {
-   { 17, char53_stroke0 },
-};
-
-/* char: 54 '6' */
-
-static const CoordRec char54_stroke0[] = {
-    { 62.7229, 85.7143 },
-    { 57.961, 95.2381 },
-    { 43.6752, 100 },
-    { 34.1514, 100 },
-    { 19.8657, 95.2381 },
-    { 10.3419, 80.9524 },
-    { 5.58, 57.1429 },
-    { 5.58, 33.3333 },
-    { 10.3419, 14.2857 },
-    { 19.8657, 4.7619 },
-    { 34.1514, 0 },
-    { 38.9133, 0 },
-    { 53.199, 4.7619 },
-    { 62.7229, 14.2857 },
-    { 67.4848, 28.5714 },
-    { 67.4848, 33.3333 },
-    { 62.7229, 47.619 },
-    { 53.199, 57.1429 },
-    { 38.9133, 61.9048 },
-    { 34.1514, 61.9048 },
-    { 19.8657, 57.1429 },
-    { 10.3419, 47.619 },
-    { 5.58, 33.3333 },
-};
-
-static const StrokeRec char54[] = {
-   { 23, char54_stroke0 },
-};
-
-/* char: 55 '7' */
-
-static const CoordRec char55_stroke0[] = {
-    { 72.2267, 100 },
-    { 24.6076, 0 },
-};
-
-static const CoordRec char55_stroke1[] = {
-    { 5.56, 100 },
-    { 72.2267, 100 },
-};
-
-static const StrokeRec char55[] = {
-   { 2, char55_stroke0 },
-   { 2, char55_stroke1 },
-};
-
-/* char: 56 '8' */
-
-static const CoordRec char56_stroke0[] = {
-    { 29.4095, 100 },
-    { 15.1238, 95.2381 },
-    { 10.3619, 85.7143 },
-    { 10.3619, 76.1905 },
-    { 15.1238, 66.6667 },
-    { 24.6476, 61.9048 },
-    { 43.6952, 57.1429 },
-    { 57.981, 52.381 },
-    { 67.5048, 42.8571 },
-    { 72.2667, 33.3333 },
-    { 72.2667, 19.0476 },
-    { 67.5048, 9.5238 },
-    { 62.7429, 4.7619 },
-    { 48.4571, 0 },
-    { 29.4095, 0 },
-    { 15.1238, 4.7619 },
-    { 10.3619, 9.5238 },
-    { 5.6, 19.0476 },
-    { 5.6, 33.3333 },
-    { 10.3619, 42.8571 },
-    { 19.8857, 52.381 },
-    { 34.1714, 57.1429 },
-    { 53.219, 61.9048 },
-    { 62.7429, 66.6667 },
-    { 67.5048, 76.1905 },
-    { 67.5048, 85.7143 },
-    { 62.7429, 95.2381 },
-    { 48.4571, 100 },
-    { 29.4095, 100 },
-};
-
-static const StrokeRec char56[] = {
-   { 29, char56_stroke0 },
-};
-
-/* char: 57 '9' */
-
-static const CoordRec char57_stroke0[] = {
-    { 68.5048, 66.6667 },
-    { 63.7429, 52.381 },
-    { 54.219, 42.8571 },
-    { 39.9333, 38.0952 },
-    { 35.1714, 38.0952 },
-    { 20.8857, 42.8571 },
-    { 11.3619, 52.381 },
-    { 6.6, 66.6667 },
-    { 6.6, 71.4286 },
-    { 11.3619, 85.7143 },
-    { 20.8857, 95.2381 },
-    { 35.1714, 100 },
-    { 39.9333, 100 },
-    { 54.219, 95.2381 },
-    { 63.7429, 85.7143 },
-    { 68.5048, 66.6667 },
-    { 68.5048, 42.8571 },
-    { 63.7429, 19.0476 },
-    { 54.219, 4.7619 },
-    { 39.9333, 0 },
-    { 30.4095, 0 },
-    { 16.1238, 4.7619 },
-    { 11.3619, 14.2857 },
-};
-
-static const StrokeRec char57[] = {
-   { 23, char57_stroke0 },
-};
-
-/* char: 58 ':' */
-
-static const CoordRec char58_stroke0[] = {
-    { 14.0819, 66.6667 },
-    { 9.32, 61.9048 },
-    { 14.0819, 57.1429 },
-    { 18.8438, 61.9048 },
-    { 14.0819, 66.6667 },
-};
-
-static const CoordRec char58_stroke1[] = {
-    { 14.0819, 9.5238 },
-    { 9.32, 4.7619 },
-    { 14.0819, 0 },
-    { 18.8438, 4.7619 },
-    { 14.0819, 9.5238 },
-};
-
-static const StrokeRec char58[] = {
-   { 5, char58_stroke0 },
-   { 5, char58_stroke1 },
-};
-
-/* char: 59 ';' */
-
-static const CoordRec char59_stroke0[] = {
-    { 12.9619, 66.6667 },
-    { 8.2, 61.9048 },
-    { 12.9619, 57.1429 },
-    { 17.7238, 61.9048 },
-    { 12.9619, 66.6667 },
-};
-
-static const CoordRec char59_stroke1[] = {
-    { 17.7238, 4.7619 },
-    { 12.9619, 0 },
-    { 8.2, 4.7619 },
-    { 12.9619, 9.5238 },
-    { 17.7238, 4.7619 },
-    { 17.7238, -4.7619 },
-    { 12.9619, -14.2857 },
-    { 8.2, -19.0476 },
-};
-
-static const StrokeRec char59[] = {
-   { 5, char59_stroke0 },
-   { 8, char59_stroke1 },
-};
-
-/* char: 60 '<' */
-
-static const CoordRec char60_stroke0[] = {
-    { 79.2505, 85.7143 },
-    { 3.06, 42.8571 },
-    { 79.2505, 0 },
-};
-
-static const StrokeRec char60[] = {
-   { 3, char60_stroke0 },
-};
-
-/* char: 61 '=' */
-
-static const CoordRec char61_stroke0[] = {
-    { 5.7, 57.1429 },
-    { 91.4143, 57.1429 },
-};
-
-static const CoordRec char61_stroke1[] = {
-    { 5.7, 28.5714 },
-    { 91.4143, 28.5714 },
-};
-
-static const StrokeRec char61[] = {
-   { 2, char61_stroke0 },
-   { 2, char61_stroke1 },
-};
-
-/* char: 62 '>' */
-
-static const CoordRec char62_stroke0[] = {
-    { 2.78, 85.7143 },
-    { 78.9705, 42.8571 },
-    { 2.78, 0 },
-};
-
-static const StrokeRec char62[] = {
-   { 3, char62_stroke0 },
-};
-
-/* char: 63 '?' */
-
-static const CoordRec char63_stroke0[] = {
-    { 8.42, 76.1905 },
-    { 8.42, 80.9524 },
-    { 13.1819, 90.4762 },
-    { 17.9438, 95.2381 },
-    { 27.4676, 100 },
-    { 46.5152, 100 },
-    { 56.039, 95.2381 },
-    { 60.801, 90.4762 },
-    { 65.5629, 80.9524 },
-    { 65.5629, 71.4286 },
-    { 60.801, 61.9048 },
-    { 56.039, 57.1429 },
-    { 36.9914, 47.619 },
-    { 36.9914, 33.3333 },
-};
-
-static const CoordRec char63_stroke1[] = {
-    { 36.9914, 9.5238 },
-    { 32.2295, 4.7619 },
-    { 36.9914, 0 },
-    { 41.7533, 4.7619 },
-    { 36.9914, 9.5238 },
-};
-
-static const StrokeRec char63[] = {
-   { 14, char63_stroke0 },
-   { 5, char63_stroke1 },
-};
-
-/* char: 64 '@' */
-
-static const CoordRec char64_stroke0[] = {
-    { 49.2171, 52.381 },
-    { 39.6933, 57.1429 },
-    { 30.1695, 57.1429 },
-    { 25.4076, 47.619 },
-    { 25.4076, 42.8571 },
-    { 30.1695, 33.3333 },
-    { 39.6933, 33.3333 },
-    { 49.2171, 38.0952 },
-};
-
-static const CoordRec char64_stroke1[] = {
-    { 49.2171, 57.1429 },
-    { 49.2171, 38.0952 },
-    { 53.979, 33.3333 },
-    { 63.5029, 33.3333 },
-    { 68.2648, 42.8571 },
-    { 68.2648, 47.619 },
-    { 63.5029, 61.9048 },
-    { 53.979, 71.4286 },
-    { 39.6933, 76.1905 },
-    { 34.9314, 76.1905 },
-    { 20.6457, 71.4286 },
-    { 11.1219, 61.9048 },
-    { 6.36, 47.619 },
-    { 6.36, 42.8571 },
-    { 11.1219, 28.5714 },
-    { 20.6457, 19.0476 },
-    { 34.9314, 14.2857 },
-    { 39.6933, 14.2857 },
-    { 53.979, 19.0476 },
-};
-
-static const StrokeRec char64[] = {
-   { 8, char64_stroke0 },
-   { 19, char64_stroke1 },
-};
-
-/* char: 65 'A' */
-
-static const CoordRec char65_stroke0[] = {
-    { 40.5952, 100 },
-    { 2.5, 0 },
-};
-
-static const CoordRec char65_stroke1[] = {
-    { 40.5952, 100 },
-    { 78.6905, 0 },
-};
-
-static const CoordRec char65_stroke2[] = {
-    { 16.7857, 33.3333 },
-    { 64.4048, 33.3333 },
-};
-
-static const StrokeRec char65[] = {
-   { 2, char65_stroke0 },
-   { 2, char65_stroke1 },
-   { 2, char65_stroke2 },
-};
-
-/* char: 66 'B' */
-
-static const CoordRec char66_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char66_stroke1[] = {
-    { 11.42, 100 },
-    { 54.2771, 100 },
-    { 68.5629, 95.2381 },
-    { 73.3248, 90.4762 },
-    { 78.0867, 80.9524 },
-    { 78.0867, 71.4286 },
-    { 73.3248, 61.9048 },
-    { 68.5629, 57.1429 },
-    { 54.2771, 52.381 },
-};
-
-static const CoordRec char66_stroke2[] = {
-    { 11.42, 52.381 },
-    { 54.2771, 52.381 },
-    { 68.5629, 47.619 },
-    { 73.3248, 42.8571 },
-    { 78.0867, 33.3333 },
-    { 78.0867, 19.0476 },
-    { 73.3248, 9.5238 },
-    { 68.5629, 4.7619 },
-    { 54.2771, 0 },
-    { 11.42, 0 },
-};
-
-static const StrokeRec char66[] = {
-   { 2, char66_stroke0 },
-   { 9, char66_stroke1 },
-   { 10, char66_stroke2 },
-};
-
-/* char: 67 'C' */
-
-static const CoordRec char67_stroke0[] = {
-    { 78.0886, 76.1905 },
-    { 73.3267, 85.7143 },
-    { 63.8029, 95.2381 },
-    { 54.279, 100 },
-    { 35.2314, 100 },
-    { 25.7076, 95.2381 },
-    { 16.1838, 85.7143 },
-    { 11.4219, 76.1905 },
-    { 6.66, 61.9048 },
-    { 6.66, 38.0952 },
-    { 11.4219, 23.8095 },
-    { 16.1838, 14.2857 },
-    { 25.7076, 4.7619 },
-    { 35.2314, 0 },
-    { 54.279, 0 },
-    { 63.8029, 4.7619 },
-    { 73.3267, 14.2857 },
-    { 78.0886, 23.8095 },
-};
-
-static const StrokeRec char67[] = {
-   { 18, char67_stroke0 },
-};
-
-/* char: 68 'D' */
-
-static const CoordRec char68_stroke0[] = {
-    { 11.96, 100 },
-    { 11.96, 0 },
-};
-
-static const CoordRec char68_stroke1[] = {
-    { 11.96, 100 },
-    { 45.2933, 100 },
-    { 59.579, 95.2381 },
-    { 69.1029, 85.7143 },
-    { 73.8648, 76.1905 },
-    { 78.6267, 61.9048 },
-    { 78.6267, 38.0952 },
-    { 73.8648, 23.8095 },
-    { 69.1029, 14.2857 },
-    { 59.579, 4.7619 },
-    { 45.2933, 0 },
-    { 11.96, 0 },
-};
-
-static const StrokeRec char68[] = {
-   { 2, char68_stroke0 },
-   { 12, char68_stroke1 },
-};
-
-/* char: 69 'E' */
-
-static const CoordRec char69_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char69_stroke1[] = {
-    { 11.42, 100 },
-    { 73.3248, 100 },
-};
-
-static const CoordRec char69_stroke2[] = {
-    { 11.42, 52.381 },
-    { 49.5152, 52.381 },
-};
-
-static const CoordRec char69_stroke3[] = {
-    { 11.42, 0 },
-    { 73.3248, 0 },
-};
-
-static const StrokeRec char69[] = {
-   { 2, char69_stroke0 },
-   { 2, char69_stroke1 },
-   { 2, char69_stroke2 },
-   { 2, char69_stroke3 },
-};
-
-/* char: 70 'F' */
-
-static const CoordRec char70_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char70_stroke1[] = {
-    { 11.42, 100 },
-    { 73.3248, 100 },
-};
-
-static const CoordRec char70_stroke2[] = {
-    { 11.42, 52.381 },
-    { 49.5152, 52.381 },
-};
-
-static const StrokeRec char70[] = {
-   { 2, char70_stroke0 },
-   { 2, char70_stroke1 },
-   { 2, char70_stroke2 },
-};
-
-/* char: 71 'G' */
-
-static const CoordRec char71_stroke0[] = {
-    { 78.4886, 76.1905 },
-    { 73.7267, 85.7143 },
-    { 64.2029, 95.2381 },
-    { 54.679, 100 },
-    { 35.6314, 100 },
-    { 26.1076, 95.2381 },
-    { 16.5838, 85.7143 },
-    { 11.8219, 76.1905 },
-    { 7.06, 61.9048 },
-    { 7.06, 38.0952 },
-    { 11.8219, 23.8095 },
-    { 16.5838, 14.2857 },
-    { 26.1076, 4.7619 },
-    { 35.6314, 0 },
-    { 54.679, 0 },
-    { 64.2029, 4.7619 },
-    { 73.7267, 14.2857 },
-    { 78.4886, 23.8095 },
-    { 78.4886, 38.0952 },
-};
-
-static const CoordRec char71_stroke1[] = {
-    { 54.679, 38.0952 },
-    { 78.4886, 38.0952 },
-};
-
-static const StrokeRec char71[] = {
-   { 19, char71_stroke0 },
-   { 2, char71_stroke1 },
-};
-
-/* char: 72 'H' */
-
-static const CoordRec char72_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char72_stroke1[] = {
-    { 78.0867, 100 },
-    { 78.0867, 0 },
-};
-
-static const CoordRec char72_stroke2[] = {
-    { 11.42, 52.381 },
-    { 78.0867, 52.381 },
-};
-
-static const StrokeRec char72[] = {
-   { 2, char72_stroke0 },
-   { 2, char72_stroke1 },
-   { 2, char72_stroke2 },
-};
-
-/* char: 73 'I' */
-
-static const CoordRec char73_stroke0[] = {
-    { 10.86, 100 },
-    { 10.86, 0 },
-};
-
-static const StrokeRec char73[] = {
-   { 2, char73_stroke0 },
-};
-
-/* char: 74 'J' */
-
-static const CoordRec char74_stroke0[] = {
-    { 50.119, 100 },
-    { 50.119, 23.8095 },
-    { 45.3571, 9.5238 },
-    { 40.5952, 4.7619 },
-    { 31.0714, 0 },
-    { 21.5476, 0 },
-    { 12.0238, 4.7619 },
-    { 7.2619, 9.5238 },
-    { 2.5, 23.8095 },
-    { 2.5, 33.3333 },
-};
-
-static const StrokeRec char74[] = {
-   { 10, char74_stroke0 },
-};
-
-/* char: 75 'K' */
-
-static const CoordRec char75_stroke0[] = {
-    { 11.28, 100 },
-    { 11.28, 0 },
-};
-
-static const CoordRec char75_stroke1[] = {
-    { 77.9467, 100 },
-    { 11.28, 33.3333 },
-};
-
-static const CoordRec char75_stroke2[] = {
-    { 35.0895, 57.1429 },
-    { 77.9467, 0 },
-};
-
-static const StrokeRec char75[] = {
-   { 2, char75_stroke0 },
-   { 2, char75_stroke1 },
-   { 2, char75_stroke2 },
-};
-
-/* char: 76 'L' */
-
-static const CoordRec char76_stroke0[] = {
-    { 11.68, 100 },
-    { 11.68, 0 },
-};
-
-static const CoordRec char76_stroke1[] = {
-    { 11.68, 0 },
-    { 68.8229, 0 },
-};
-
-static const StrokeRec char76[] = {
-   { 2, char76_stroke0 },
-   { 2, char76_stroke1 },
-};
-
-/* char: 77 'M' */
-
-static const CoordRec char77_stroke0[] = {
-    { 10.86, 100 },
-    { 10.86, 0 },
-};
-
-static const CoordRec char77_stroke1[] = {
-    { 10.86, 100 },
-    { 48.9552, 0 },
-};
-
-static const CoordRec char77_stroke2[] = {
-    { 87.0505, 100 },
-    { 48.9552, 0 },
-};
-
-static const CoordRec char77_stroke3[] = {
-    { 87.0505, 100 },
-    { 87.0505, 0 },
-};
-
-static const StrokeRec char77[] = {
-   { 2, char77_stroke0 },
-   { 2, char77_stroke1 },
-   { 2, char77_stroke2 },
-   { 2, char77_stroke3 },
-};
-
-/* char: 78 'N' */
-
-static const CoordRec char78_stroke0[] = {
-    { 11.14, 100 },
-    { 11.14, 0 },
-};
-
-static const CoordRec char78_stroke1[] = {
-    { 11.14, 100 },
-    { 77.8067, 0 },
-};
-
-static const CoordRec char78_stroke2[] = {
-    { 77.8067, 100 },
-    { 77.8067, 0 },
-};
-
-static const StrokeRec char78[] = {
-   { 2, char78_stroke0 },
-   { 2, char78_stroke1 },
-   { 2, char78_stroke2 },
-};
-
-/* char: 79 'O' */
-
-static const CoordRec char79_stroke0[] = {
-    { 34.8114, 100 },
-    { 25.2876, 95.2381 },
-    { 15.7638, 85.7143 },
-    { 11.0019, 76.1905 },
-    { 6.24, 61.9048 },
-    { 6.24, 38.0952 },
-    { 11.0019, 23.8095 },
-    { 15.7638, 14.2857 },
-    { 25.2876, 4.7619 },
-    { 34.8114, 0 },
-    { 53.859, 0 },
-    { 63.3829, 4.7619 },
-    { 72.9067, 14.2857 },
-    { 77.6686, 23.8095 },
-    { 82.4305, 38.0952 },
-    { 82.4305, 61.9048 },
-    { 77.6686, 76.1905 },
-    { 72.9067, 85.7143 },
-    { 63.3829, 95.2381 },
-    { 53.859, 100 },
-    { 34.8114, 100 },
-};
-
-static const StrokeRec char79[] = {
-   { 21, char79_stroke0 },
-};
-
-/* char: 80 'P' */
-
-static const CoordRec char80_stroke0[] = {
-    { 12.1, 100 },
-    { 12.1, 0 },
-};
-
-static const CoordRec char80_stroke1[] = {
-    { 12.1, 100 },
-    { 54.9571, 100 },
-    { 69.2429, 95.2381 },
-    { 74.0048, 90.4762 },
-    { 78.7667, 80.9524 },
-    { 78.7667, 66.6667 },
-    { 74.0048, 57.1429 },
-    { 69.2429, 52.381 },
-    { 54.9571, 47.619 },
-    { 12.1, 47.619 },
-};
-
-static const StrokeRec char80[] = {
-   { 2, char80_stroke0 },
-   { 10, char80_stroke1 },
-};
-
-/* char: 81 'Q' */
-
-static const CoordRec char81_stroke0[] = {
-    { 33.8714, 100 },
-    { 24.3476, 95.2381 },
-    { 14.8238, 85.7143 },
-    { 10.0619, 76.1905 },
-    { 5.3, 61.9048 },
-    { 5.3, 38.0952 },
-    { 10.0619, 23.8095 },
-    { 14.8238, 14.2857 },
-    { 24.3476, 4.7619 },
-    { 33.8714, 0 },
-    { 52.919, 0 },
-    { 62.4429, 4.7619 },
-    { 71.9667, 14.2857 },
-    { 76.7286, 23.8095 },
-    { 81.4905, 38.0952 },
-    { 81.4905, 61.9048 },
-    { 76.7286, 76.1905 },
-    { 71.9667, 85.7143 },
-    { 62.4429, 95.2381 },
-    { 52.919, 100 },
-    { 33.8714, 100 },
-};
-
-static const CoordRec char81_stroke1[] = {
-    { 48.1571, 19.0476 },
-    { 76.7286, -9.5238 },
-};
-
-static const StrokeRec char81[] = {
-   { 21, char81_stroke0 },
-   { 2, char81_stroke1 },
-};
-
-/* char: 82 'R' */
-
-static const CoordRec char82_stroke0[] = {
-    { 11.68, 100 },
-    { 11.68, 0 },
-};
-
-static const CoordRec char82_stroke1[] = {
-    { 11.68, 100 },
-    { 54.5371, 100 },
-    { 68.8229, 95.2381 },
-    { 73.5848, 90.4762 },
-    { 78.3467, 80.9524 },
-    { 78.3467, 71.4286 },
-    { 73.5848, 61.9048 },
-    { 68.8229, 57.1429 },
-    { 54.5371, 52.381 },
-    { 11.68, 52.381 },
-};
-
-static const CoordRec char82_stroke2[] = {
-    { 45.0133, 52.381 },
-    { 78.3467, 0 },
-};
-
-static const StrokeRec char82[] = {
-   { 2, char82_stroke0 },
-   { 10, char82_stroke1 },
-   { 2, char82_stroke2 },
-};
-
-/* char: 83 'S' */
-
-static const CoordRec char83_stroke0[] = {
-    { 74.6667, 85.7143 },
-    { 65.1429, 95.2381 },
-    { 50.8571, 100 },
-    { 31.8095, 100 },
-    { 17.5238, 95.2381 },
-    { 8, 85.7143 },
-    { 8, 76.1905 },
-    { 12.7619, 66.6667 },
-    { 17.5238, 61.9048 },
-    { 27.0476, 57.1429 },
-    { 55.619, 47.619 },
-    { 65.1429, 42.8571 },
-    { 69.9048, 38.0952 },
-    { 74.6667, 28.5714 },
-    { 74.6667, 14.2857 },
-    { 65.1429, 4.7619 },
-    { 50.8571, 0 },
-    { 31.8095, 0 },
-    { 17.5238, 4.7619 },
-    { 8, 14.2857 },
-};
-
-static const StrokeRec char83[] = {
-   { 20, char83_stroke0 },
-};
-
-/* char: 84 'T' */
-
-static const CoordRec char84_stroke0[] = {
-    { 35.6933, 100 },
-    { 35.6933, 0 },
-};
-
-static const CoordRec char84_stroke1[] = {
-    { 2.36, 100 },
-    { 69.0267, 100 },
-};
-
-static const StrokeRec char84[] = {
-   { 2, char84_stroke0 },
-   { 2, char84_stroke1 },
-};
-
-/* char: 85 'U' */
-
-static const CoordRec char85_stroke0[] = {
-    { 11.54, 100 },
-    { 11.54, 28.5714 },
-    { 16.3019, 14.2857 },
-    { 25.8257, 4.7619 },
-    { 40.1114, 0 },
-    { 49.6352, 0 },
-    { 63.921, 4.7619 },
-    { 73.4448, 14.2857 },
-    { 78.2067, 28.5714 },
-    { 78.2067, 100 },
-};
-
-static const StrokeRec char85[] = {
-   { 10, char85_stroke0 },
-};
-
-/* char: 86 'V' */
-
-static const CoordRec char86_stroke0[] = {
-    { 2.36, 100 },
-    { 40.4552, 0 },
-};
-
-static const CoordRec char86_stroke1[] = {
-    { 78.5505, 100 },
-    { 40.4552, 0 },
-};
-
-static const StrokeRec char86[] = {
-   { 2, char86_stroke0 },
-   { 2, char86_stroke1 },
-};
-
-/* char: 87 'W' */
-
-static const CoordRec char87_stroke0[] = {
-    { 2.22, 100 },
-    { 26.0295, 0 },
-};
-
-static const CoordRec char87_stroke1[] = {
-    { 49.839, 100 },
-    { 26.0295, 0 },
-};
-
-static const CoordRec char87_stroke2[] = {
-    { 49.839, 100 },
-    { 73.6486, 0 },
-};
-
-static const CoordRec char87_stroke3[] = {
-    { 97.4581, 100 },
-    { 73.6486, 0 },
-};
-
-static const StrokeRec char87[] = {
-   { 2, char87_stroke0 },
-   { 2, char87_stroke1 },
-   { 2, char87_stroke2 },
-   { 2, char87_stroke3 },
-};
-
-/* char: 88 'X' */
-
-static const CoordRec char88_stroke0[] = {
-    { 2.5, 100 },
-    { 69.1667, 0 },
-};
-
-static const CoordRec char88_stroke1[] = {
-    { 69.1667, 100 },
-    { 2.5, 0 },
-};
-
-static const StrokeRec char88[] = {
-   { 2, char88_stroke0 },
-   { 2, char88_stroke1 },
-};
-
-/* char: 89 'Y' */
-
-static const CoordRec char89_stroke0[] = {
-    { 1.52, 100 },
-    { 39.6152, 52.381 },
-    { 39.6152, 0 },
-};
-
-static const CoordRec char89_stroke1[] = {
-    { 77.7105, 100 },
-    { 39.6152, 52.381 },
-};
-
-static const StrokeRec char89[] = {
-   { 3, char89_stroke0 },
-   { 2, char89_stroke1 },
-};
-
-/* char: 90 'Z' */
-
-static const CoordRec char90_stroke0[] = {
-    { 69.1667, 100 },
-    { 2.5, 0 },
-};
-
-static const CoordRec char90_stroke1[] = {
-    { 2.5, 100 },
-    { 69.1667, 100 },
-};
-
-static const CoordRec char90_stroke2[] = {
-    { 2.5, 0 },
-    { 69.1667, 0 },
-};
-
-static const StrokeRec char90[] = {
-   { 2, char90_stroke0 },
-   { 2, char90_stroke1 },
-   { 2, char90_stroke2 },
-};
-
-/* char: 91 '[' */
-
-static const CoordRec char91_stroke0[] = {
-    { 7.78, 119.048 },
-    { 7.78, -33.3333 },
-};
-
-static const CoordRec char91_stroke1[] = {
-    { 12.5419, 119.048 },
-    { 12.5419, -33.3333 },
-};
-
-static const CoordRec char91_stroke2[] = {
-    { 7.78, 119.048 },
-    { 41.1133, 119.048 },
-};
-
-static const CoordRec char91_stroke3[] = {
-    { 7.78, -33.3333 },
-    { 41.1133, -33.3333 },
-};
-
-static const StrokeRec char91[] = {
-   { 2, char91_stroke0 },
-   { 2, char91_stroke1 },
-   { 2, char91_stroke2 },
-   { 2, char91_stroke3 },
-};
-
-/* char: 92 '\' */
-
-static const CoordRec char92_stroke0[] = {
-    { 5.84, 100 },
-    { 72.5067, -14.2857 },
-};
-
-static const StrokeRec char92[] = {
-   { 2, char92_stroke0 },
-};
-
-/* char: 93 ']' */
-
-static const CoordRec char93_stroke0[] = {
-    { 33.0114, 119.048 },
-    { 33.0114, -33.3333 },
-};
-
-static const CoordRec char93_stroke1[] = {
-    { 37.7733, 119.048 },
-    { 37.7733, -33.3333 },
-};
-
-static const CoordRec char93_stroke2[] = {
-    { 4.44, 119.048 },
-    { 37.7733, 119.048 },
-};
-
-static const CoordRec char93_stroke3[] = {
-    { 4.44, -33.3333 },
-    { 37.7733, -33.3333 },
-};
-
-static const StrokeRec char93[] = {
-   { 2, char93_stroke0 },
-   { 2, char93_stroke1 },
-   { 2, char93_stroke2 },
-   { 2, char93_stroke3 },
-};
-
-/* char: 94 '^' */
-
-static const CoordRec char94_stroke0[] = {
-    { 44.0752, 109.524 },
-    { 5.98, 42.8571 },
-};
-
-static const CoordRec char94_stroke1[] = {
-    { 44.0752, 109.524 },
-    { 82.1705, 42.8571 },
-};
-
-static const StrokeRec char94[] = {
-   { 2, char94_stroke0 },
-   { 2, char94_stroke1 },
-};
-
-/* char: 95 '_' */
-
-static const CoordRec char95_stroke0[] = {
-    { -1.1, -33.3333 },
-    { 103.662, -33.3333 },
-    { 103.662, -28.5714 },
-    { -1.1, -28.5714 },
-    { -1.1, -33.3333 },
-};
-
-static const StrokeRec char95[] = {
-   { 5, char95_stroke0 },
-};
-
-/* char: 96 '`' */
-
-static const CoordRec char96_stroke0[] = {
-    { 33.0219, 100 },
-    { 56.8314, 71.4286 },
-};
-
-static const CoordRec char96_stroke1[] = {
-    { 33.0219, 100 },
-    { 28.26, 95.2381 },
-    { 56.8314, 71.4286 },
-};
-
-static const StrokeRec char96[] = {
-   { 2, char96_stroke0 },
-   { 3, char96_stroke1 },
-};
-
-/* char: 97 'a' */
-
-static const CoordRec char97_stroke0[] = {
-    { 63.8229, 66.6667 },
-    { 63.8229, 0 },
-};
-
-static const CoordRec char97_stroke1[] = {
-    { 63.8229, 52.381 },
-    { 54.299, 61.9048 },
-    { 44.7752, 66.6667 },
-    { 30.4895, 66.6667 },
-    { 20.9657, 61.9048 },
-    { 11.4419, 52.381 },
-    { 6.68, 38.0952 },
-    { 6.68, 28.5714 },
-    { 11.4419, 14.2857 },
-    { 20.9657, 4.7619 },
-    { 30.4895, 0 },
-    { 44.7752, 0 },
-    { 54.299, 4.7619 },
-    { 63.8229, 14.2857 },
-};
-
-static const StrokeRec char97[] = {
-   { 2, char97_stroke0 },
-   { 14, char97_stroke1 },
-};
-
-/* char: 98 'b' */
-
-static const CoordRec char98_stroke0[] = {
-    { 8.76, 100 },
-    { 8.76, 0 },
-};
-
-static const CoordRec char98_stroke1[] = {
-    { 8.76, 52.381 },
-    { 18.2838, 61.9048 },
-    { 27.8076, 66.6667 },
-    { 42.0933, 66.6667 },
-    { 51.6171, 61.9048 },
-    { 61.141, 52.381 },
-    { 65.9029, 38.0952 },
-    { 65.9029, 28.5714 },
-    { 61.141, 14.2857 },
-    { 51.6171, 4.7619 },
-    { 42.0933, 0 },
-    { 27.8076, 0 },
-    { 18.2838, 4.7619 },
-    { 8.76, 14.2857 },
-};
-
-static const StrokeRec char98[] = {
-   { 2, char98_stroke0 },
-   { 14, char98_stroke1 },
-};
-
-/* char: 99 'c' */
-
-static const CoordRec char99_stroke0[] = {
-    { 62.6629, 52.381 },
-    { 53.139, 61.9048 },
-    { 43.6152, 66.6667 },
-    { 29.3295, 66.6667 },
-    { 19.8057, 61.9048 },
-    { 10.2819, 52.381 },
-    { 5.52, 38.0952 },
-    { 5.52, 28.5714 },
-    { 10.2819, 14.2857 },
-    { 19.8057, 4.7619 },
-    { 29.3295, 0 },
-    { 43.6152, 0 },
-    { 53.139, 4.7619 },
-    { 62.6629, 14.2857 },
-};
-
-static const StrokeRec char99[] = {
-   { 14, char99_stroke0 },
-};
-
-/* char: 100 'd' */
-
-static const CoordRec char100_stroke0[] = {
-    { 61.7829, 100 },
-    { 61.7829, 0 },
-};
-
-static const CoordRec char100_stroke1[] = {
-    { 61.7829, 52.381 },
-    { 52.259, 61.9048 },
-    { 42.7352, 66.6667 },
-    { 28.4495, 66.6667 },
-    { 18.9257, 61.9048 },
-    { 9.4019, 52.381 },
-    { 4.64, 38.0952 },
-    { 4.64, 28.5714 },
-    { 9.4019, 14.2857 },
-    { 18.9257, 4.7619 },
-    { 28.4495, 0 },
-    { 42.7352, 0 },
-    { 52.259, 4.7619 },
-    { 61.7829, 14.2857 },
-};
-
-static const StrokeRec char100[] = {
-   { 2, char100_stroke0 },
-   { 14, char100_stroke1 },
-};
-
-/* char: 101 'e' */
-
-static const CoordRec char101_stroke0[] = {
-    { 5.72, 38.0952 },
-    { 62.8629, 38.0952 },
-    { 62.8629, 47.619 },
-    { 58.101, 57.1429 },
-    { 53.339, 61.9048 },
-    { 43.8152, 66.6667 },
-    { 29.5295, 66.6667 },
-    { 20.0057, 61.9048 },
-    { 10.4819, 52.381 },
-    { 5.72, 38.0952 },
-    { 5.72, 28.5714 },
-    { 10.4819, 14.2857 },
-    { 20.0057, 4.7619 },
-    { 29.5295, 0 },
-    { 43.8152, 0 },
-    { 53.339, 4.7619 },
-    { 62.8629, 14.2857 },
-};
-
-static const StrokeRec char101[] = {
-   { 17, char101_stroke0 },
-};
-
-/* char: 102 'f' */
-
-static const CoordRec char102_stroke0[] = {
-    { 38.7752, 100 },
-    { 29.2514, 100 },
-    { 19.7276, 95.2381 },
-    { 14.9657, 80.9524 },
-    { 14.9657, 0 },
-};
-
-static const CoordRec char102_stroke1[] = {
-    { 0.68, 66.6667 },
-    { 34.0133, 66.6667 },
-};
-
-static const StrokeRec char102[] = {
-   { 5, char102_stroke0 },
-   { 2, char102_stroke1 },
-};
-
-/* char: 103 'g' */
-
-static const CoordRec char103_stroke0[] = {
-    { 62.5029, 66.6667 },
-    { 62.5029, -9.5238 },
-    { 57.741, -23.8095 },
-    { 52.979, -28.5714 },
-    { 43.4552, -33.3333 },
-    { 29.1695, -33.3333 },
-    { 19.6457, -28.5714 },
-};
-
-static const CoordRec char103_stroke1[] = {
-    { 62.5029, 52.381 },
-    { 52.979, 61.9048 },
-    { 43.4552, 66.6667 },
-    { 29.1695, 66.6667 },
-    { 19.6457, 61.9048 },
-    { 10.1219, 52.381 },
-    { 5.36, 38.0952 },
-    { 5.36, 28.5714 },
-    { 10.1219, 14.2857 },
-    { 19.6457, 4.7619 },
-    { 29.1695, 0 },
-    { 43.4552, 0 },
-    { 52.979, 4.7619 },
-    { 62.5029, 14.2857 },
-};
-
-static const StrokeRec char103[] = {
-   { 7, char103_stroke0 },
-   { 14, char103_stroke1 },
-};
-
-/* char: 104 'h' */
-
-static const CoordRec char104_stroke0[] = {
-    { 9.6, 100 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char104_stroke1[] = {
-    { 9.6, 47.619 },
-    { 23.8857, 61.9048 },
-    { 33.4095, 66.6667 },
-    { 47.6952, 66.6667 },
-    { 57.219, 61.9048 },
-    { 61.981, 47.619 },
-    { 61.981, 0 },
-};
-
-static const StrokeRec char104[] = {
-   { 2, char104_stroke0 },
-   { 7, char104_stroke1 },
-};
-
-/* char: 105 'i' */
-
-static const CoordRec char105_stroke0[] = {
-    { 10.02, 100 },
-    { 14.7819, 95.2381 },
-    { 19.5438, 100 },
-    { 14.7819, 104.762 },
-    { 10.02, 100 },
-};
-
-static const CoordRec char105_stroke1[] = {
-    { 14.7819, 66.6667 },
-    { 14.7819, 0 },
-};
-
-static const StrokeRec char105[] = {
-   { 5, char105_stroke0 },
-   { 2, char105_stroke1 },
-};
-
-/* char: 106 'j' */
-
-static const CoordRec char106_stroke0[] = {
-    { 17.3876, 100 },
-    { 22.1495, 95.2381 },
-    { 26.9114, 100 },
-    { 22.1495, 104.762 },
-    { 17.3876, 100 },
-};
-
-static const CoordRec char106_stroke1[] = {
-    { 22.1495, 66.6667 },
-    { 22.1495, -14.2857 },
-    { 17.3876, -28.5714 },
-    { 7.8638, -33.3333 },
-    { -1.66, -33.3333 },
-};
-
-static const StrokeRec char106[] = {
-   { 5, char106_stroke0 },
-   { 5, char106_stroke1 },
-};
-
-/* char: 107 'k' */
-
-static const CoordRec char107_stroke0[] = {
-    { 9.6, 100 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char107_stroke1[] = {
-    { 57.219, 66.6667 },
-    { 9.6, 19.0476 },
-};
-
-static const CoordRec char107_stroke2[] = {
-    { 28.6476, 38.0952 },
-    { 61.981, 0 },
-};
-
-static const StrokeRec char107[] = {
-   { 2, char107_stroke0 },
-   { 2, char107_stroke1 },
-   { 2, char107_stroke2 },
-};
-
-/* char: 108 'l' */
-
-static const CoordRec char108_stroke0[] = {
-    { 10.02, 100 },
-    { 10.02, 0 },
-};
-
-static const StrokeRec char108[] = {
-   { 2, char108_stroke0 },
-};
-
-/* char: 109 'm' */
-
-static const CoordRec char109_stroke0[] = {
-    { 9.6, 66.6667 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char109_stroke1[] = {
-    { 9.6, 47.619 },
-    { 23.8857, 61.9048 },
-    { 33.4095, 66.6667 },
-    { 47.6952, 66.6667 },
-    { 57.219, 61.9048 },
-    { 61.981, 47.619 },
-    { 61.981, 0 },
-};
-
-static const CoordRec char109_stroke2[] = {
-    { 61.981, 47.619 },
-    { 76.2667, 61.9048 },
-    { 85.7905, 66.6667 },
-    { 100.076, 66.6667 },
-    { 109.6, 61.9048 },
-    { 114.362, 47.619 },
-    { 114.362, 0 },
-};
-
-static const StrokeRec char109[] = {
-   { 2, char109_stroke0 },
-   { 7, char109_stroke1 },
-   { 7, char109_stroke2 },
-};
-
-/* char: 110 'n' */
-
-static const CoordRec char110_stroke0[] = {
-    { 9.18, 66.6667 },
-    { 9.18, 0 },
-};
-
-static const CoordRec char110_stroke1[] = {
-    { 9.18, 47.619 },
-    { 23.4657, 61.9048 },
-    { 32.9895, 66.6667 },
-    { 47.2752, 66.6667 },
-    { 56.799, 61.9048 },
-    { 61.561, 47.619 },
-    { 61.561, 0 },
-};
-
-static const StrokeRec char110[] = {
-   { 2, char110_stroke0 },
-   { 7, char110_stroke1 },
-};
-
-/* char: 111 'o' */
-
-static const CoordRec char111_stroke0[] = {
-    { 28.7895, 66.6667 },
-    { 19.2657, 61.9048 },
-    { 9.7419, 52.381 },
-    { 4.98, 38.0952 },
-    { 4.98, 28.5714 },
-    { 9.7419, 14.2857 },
-    { 19.2657, 4.7619 },
-    { 28.7895, 0 },
-    { 43.0752, 0 },
-    { 52.599, 4.7619 },
-    { 62.1229, 14.2857 },
-    { 66.8848, 28.5714 },
-    { 66.8848, 38.0952 },
-    { 62.1229, 52.381 },
-    { 52.599, 61.9048 },
-    { 43.0752, 66.6667 },
-    { 28.7895, 66.6667 },
-};
-
-static const StrokeRec char111[] = {
-   { 17, char111_stroke0 },
-};
-
-/* char: 112 'p' */
-
-static const CoordRec char112_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, -33.3333 },
-};
-
-static const CoordRec char112_stroke1[] = {
-    { 9.46, 52.381 },
-    { 18.9838, 61.9048 },
-    { 28.5076, 66.6667 },
-    { 42.7933, 66.6667 },
-    { 52.3171, 61.9048 },
-    { 61.841, 52.381 },
-    { 66.6029, 38.0952 },
-    { 66.6029, 28.5714 },
-    { 61.841, 14.2857 },
-    { 52.3171, 4.7619 },
-    { 42.7933, 0 },
-    { 28.5076, 0 },
-    { 18.9838, 4.7619 },
-    { 9.46, 14.2857 },
-};
-
-static const StrokeRec char112[] = {
-   { 2, char112_stroke0 },
-   { 14, char112_stroke1 },
-};
-
-/* char: 113 'q' */
-
-static const CoordRec char113_stroke0[] = {
-    { 61.9829, 66.6667 },
-    { 61.9829, -33.3333 },
-};
-
-static const CoordRec char113_stroke1[] = {
-    { 61.9829, 52.381 },
-    { 52.459, 61.9048 },
-    { 42.9352, 66.6667 },
-    { 28.6495, 66.6667 },
-    { 19.1257, 61.9048 },
-    { 9.6019, 52.381 },
-    { 4.84, 38.0952 },
-    { 4.84, 28.5714 },
-    { 9.6019, 14.2857 },
-    { 19.1257, 4.7619 },
-    { 28.6495, 0 },
-    { 42.9352, 0 },
-    { 52.459, 4.7619 },
-    { 61.9829, 14.2857 },
-};
-
-static const StrokeRec char113[] = {
-   { 2, char113_stroke0 },
-   { 14, char113_stroke1 },
-};
-
-/* char: 114 'r' */
-
-static const CoordRec char114_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, 0 },
-};
-
-static const CoordRec char114_stroke1[] = {
-    { 9.46, 38.0952 },
-    { 14.2219, 52.381 },
-    { 23.7457, 61.9048 },
-    { 33.2695, 66.6667 },
-    { 47.5552, 66.6667 },
-};
-
-static const StrokeRec char114[] = {
-   { 2, char114_stroke0 },
-   { 5, char114_stroke1 },
-};
-
-/* char: 115 's' */
-
-static const CoordRec char115_stroke0[] = {
-    { 57.081, 52.381 },
-    { 52.319, 61.9048 },
-    { 38.0333, 66.6667 },
-    { 23.7476, 66.6667 },
-    { 9.4619, 61.9048 },
-    { 4.7, 52.381 },
-    { 9.4619, 42.8571 },
-    { 18.9857, 38.0952 },
-    { 42.7952, 33.3333 },
-    { 52.319, 28.5714 },
-    { 57.081, 19.0476 },
-    { 57.081, 14.2857 },
-    { 52.319, 4.7619 },
-    { 38.0333, 0 },
-    { 23.7476, 0 },
-    { 9.4619, 4.7619 },
-    { 4.7, 14.2857 },
-};
-
-static const StrokeRec char115[] = {
-   { 17, char115_stroke0 },
-};
-
-/* char: 116 't' */
-
-static const CoordRec char116_stroke0[] = {
-    { 14.8257, 100 },
-    { 14.8257, 19.0476 },
-    { 19.5876, 4.7619 },
-    { 29.1114, 0 },
-    { 38.6352, 0 },
-};
-
-static const CoordRec char116_stroke1[] = {
-    { 0.54, 66.6667 },
-    { 33.8733, 66.6667 },
-};
-
-static const StrokeRec char116[] = {
-   { 5, char116_stroke0 },
-   { 2, char116_stroke1 },
-};
-
-/* char: 117 'u' */
-
-static const CoordRec char117_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, 19.0476 },
-    { 14.2219, 4.7619 },
-    { 23.7457, 0 },
-    { 38.0314, 0 },
-    { 47.5552, 4.7619 },
-    { 61.841, 19.0476 },
-};
-
-static const CoordRec char117_stroke1[] = {
-    { 61.841, 66.6667 },
-    { 61.841, 0 },
-};
-
-static const StrokeRec char117[] = {
-   { 7, char117_stroke0 },
-   { 2, char117_stroke1 },
-};
-
-/* char: 118 'v' */
-
-static const CoordRec char118_stroke0[] = {
-    { 1.8, 66.6667 },
-    { 30.3714, 0 },
-};
-
-static const CoordRec char118_stroke1[] = {
-    { 58.9429, 66.6667 },
-    { 30.3714, 0 },
-};
-
-static const StrokeRec char118[] = {
-   { 2, char118_stroke0 },
-   { 2, char118_stroke1 },
-};
-
-/* char: 119 'w' */
-
-static const CoordRec char119_stroke0[] = {
-    { 2.5, 66.6667 },
-    { 21.5476, 0 },
-};
-
-static const CoordRec char119_stroke1[] = {
-    { 40.5952, 66.6667 },
-    { 21.5476, 0 },
-};
-
-static const CoordRec char119_stroke2[] = {
-    { 40.5952, 66.6667 },
-    { 59.6429, 0 },
-};
-
-static const CoordRec char119_stroke3[] = {
-    { 78.6905, 66.6667 },
-    { 59.6429, 0 },
-};
-
-static const StrokeRec char119[] = {
-   { 2, char119_stroke0 },
-   { 2, char119_stroke1 },
-   { 2, char119_stroke2 },
-   { 2, char119_stroke3 },
-};
-
-/* char: 120 'x' */
-
-static const CoordRec char120_stroke0[] = {
-    { 1.66, 66.6667 },
-    { 54.041, 0 },
-};
-
-static const CoordRec char120_stroke1[] = {
-    { 54.041, 66.6667 },
-    { 1.66, 0 },
-};
-
-static const StrokeRec char120[] = {
-   { 2, char120_stroke0 },
-   { 2, char120_stroke1 },
-};
-
-/* char: 121 'y' */
-
-static const CoordRec char121_stroke0[] = {
-    { 6.5619, 66.6667 },
-    { 35.1333, 0 },
-};
-
-static const CoordRec char121_stroke1[] = {
-    { 63.7048, 66.6667 },
-    { 35.1333, 0 },
-    { 25.6095, -19.0476 },
-    { 16.0857, -28.5714 },
-    { 6.5619, -33.3333 },
-    { 1.8, -33.3333 },
-};
-
-static const StrokeRec char121[] = {
-   { 2, char121_stroke0 },
-   { 6, char121_stroke1 },
-};
-
-/* char: 122 'z' */
-
-static const CoordRec char122_stroke0[] = {
-    { 56.821, 66.6667 },
-    { 4.44, 0 },
-};
-
-static const CoordRec char122_stroke1[] = {
-    { 4.44, 66.6667 },
-    { 56.821, 66.6667 },
-};
-
-static const CoordRec char122_stroke2[] = {
-    { 4.44, 0 },
-    { 56.821, 0 },
-};
-
-static const StrokeRec char122[] = {
-   { 2, char122_stroke0 },
-   { 2, char122_stroke1 },
-   { 2, char122_stroke2 },
-};
-
-/* char: 123 '{' */
-
-static const CoordRec char123_stroke0[] = {
-    { 31.1895, 119.048 },
-    { 21.6657, 114.286 },
-    { 16.9038, 109.524 },
-    { 12.1419, 100 },
-    { 12.1419, 90.4762 },
-    { 16.9038, 80.9524 },
-    { 21.6657, 76.1905 },
-    { 26.4276, 66.6667 },
-    { 26.4276, 57.1429 },
-    { 16.9038, 47.619 },
-};
-
-static const CoordRec char123_stroke1[] = {
-    { 21.6657, 114.286 },
-    { 16.9038, 104.762 },
-    { 16.9038, 95.2381 },
-    { 21.6657, 85.7143 },
-    { 26.4276, 80.9524 },
-    { 31.1895, 71.4286 },
-    { 31.1895, 61.9048 },
-    { 26.4276, 52.381 },
-    { 7.38, 42.8571 },
-    { 26.4276, 33.3333 },
-    { 31.1895, 23.8095 },
-    { 31.1895, 14.2857 },
-    { 26.4276, 4.7619 },
-    { 21.6657, 0 },
-    { 16.9038, -9.5238 },
-    { 16.9038, -19.0476 },
-    { 21.6657, -28.5714 },
-};
-
-static const CoordRec char123_stroke2[] = {
-    { 16.9038, 38.0952 },
-    { 26.4276, 28.5714 },
-    { 26.4276, 19.0476 },
-    { 21.6657, 9.5238 },
-    { 16.9038, 4.7619 },
-    { 12.1419, -4.7619 },
-    { 12.1419, -14.2857 },
-    { 16.9038, -23.8095 },
-    { 21.6657, -28.5714 },
-    { 31.1895, -33.3333 },
-};
-
-static const StrokeRec char123[] = {
-   { 10, char123_stroke0 },
-   { 17, char123_stroke1 },
-   { 10, char123_stroke2 },
-};
-
-/* char: 124 '|' */
-
-static const CoordRec char124_stroke0[] = {
-    { 11.54, 119.048 },
-    { 11.54, -33.3333 },
-};
-
-static const StrokeRec char124[] = {
-   { 2, char124_stroke0 },
-};
-
-/* char: 125 '}' */
-
-static const CoordRec char125_stroke0[] = {
-    { 9.18, 119.048 },
-    { 18.7038, 114.286 },
-    { 23.4657, 109.524 },
-    { 28.2276, 100 },
-    { 28.2276, 90.4762 },
-    { 23.4657, 80.9524 },
-    { 18.7038, 76.1905 },
-    { 13.9419, 66.6667 },
-    { 13.9419, 57.1429 },
-    { 23.4657, 47.619 },
-};
-
-static const CoordRec char125_stroke1[] = {
-    { 18.7038, 114.286 },
-    { 23.4657, 104.762 },
-    { 23.4657, 95.2381 },
-    { 18.7038, 85.7143 },
-    { 13.9419, 80.9524 },
-    { 9.18, 71.4286 },
-    { 9.18, 61.9048 },
-    { 13.9419, 52.381 },
-    { 32.9895, 42.8571 },
-    { 13.9419, 33.3333 },
-    { 9.18, 23.8095 },
-    { 9.18, 14.2857 },
-    { 13.9419, 4.7619 },
-    { 18.7038, 0 },
-    { 23.4657, -9.5238 },
-    { 23.4657, -19.0476 },
-    { 18.7038, -28.5714 },
-};
-
-static const CoordRec char125_stroke2[] = {
-    { 23.4657, 38.0952 },
-    { 13.9419, 28.5714 },
-    { 13.9419, 19.0476 },
-    { 18.7038, 9.5238 },
-    { 23.4657, 4.7619 },
-    { 28.2276, -4.7619 },
-    { 28.2276, -14.2857 },
-    { 23.4657, -23.8095 },
-    { 18.7038, -28.5714 },
-    { 9.18, -33.3333 },
-};
-
-static const StrokeRec char125[] = {
-   { 10, char125_stroke0 },
-   { 17, char125_stroke1 },
-   { 10, char125_stroke2 },
-};
-
-/* char: 126 '~' */
-
-static const CoordRec char126_stroke0[] = {
-    { 2.92, 28.5714 },
-    { 2.92, 38.0952 },
-    { 7.6819, 52.381 },
-    { 17.2057, 57.1429 },
-    { 26.7295, 57.1429 },
-    { 36.2533, 52.381 },
-    { 55.301, 38.0952 },
-    { 64.8248, 33.3333 },
-    { 74.3486, 33.3333 },
-    { 83.8724, 38.0952 },
-    { 88.6343, 47.619 },
-};
-
-static const CoordRec char126_stroke1[] = {
-    { 2.92, 38.0952 },
-    { 7.6819, 47.619 },
-    { 17.2057, 52.381 },
-    { 26.7295, 52.381 },
-    { 36.2533, 47.619 },
-    { 55.301, 33.3333 },
-    { 64.8248, 28.5714 },
-    { 74.3486, 28.5714 },
-    { 83.8724, 33.3333 },
-    { 88.6343, 47.619 },
-    { 88.6343, 57.1429 },
-};
-
-static const StrokeRec char126[] = {
-   { 11, char126_stroke0 },
-   { 11, char126_stroke1 },
-};
-
-/* char: 127 */
-
-static const CoordRec char127_stroke0[] = {
-    { 52.381, 100 },
-    { 14.2857, -33.3333 },
-};
-
-static const CoordRec char127_stroke1[] = {
-    { 28.5714, 66.6667 },
-    { 14.2857, 61.9048 },
-    { 4.7619, 52.381 },
-    { 0, 38.0952 },
-    { 0, 23.8095 },
-    { 4.7619, 14.2857 },
-    { 14.2857, 4.7619 },
-    { 28.5714, 0 },
-    { 38.0952, 0 },
-    { 52.381, 4.7619 },
-    { 61.9048, 14.2857 },
-    { 66.6667, 28.5714 },
-    { 66.6667, 42.8571 },
-    { 61.9048, 52.381 },
-    { 52.381, 61.9048 },
-    { 38.0952, 66.6667 },
-    { 28.5714, 66.6667 },
-};
-
-static const StrokeRec char127[] = {
-   { 2, char127_stroke0 },
-   { 17, char127_stroke1 },
-};
-
-static const StrokeCharRec chars[] = {
-    { 0, /* char0 */ 0, 0, 0 },
-    { 0, /* char1 */ 0, 0, 0 },
-    { 0, /* char2 */ 0, 0, 0 },
-    { 0, /* char3 */ 0, 0, 0 },
-    { 0, /* char4 */ 0, 0, 0 },
-    { 0, /* char5 */ 0, 0, 0 },
-    { 0, /* char6 */ 0, 0, 0 },
-    { 0, /* char7 */ 0, 0, 0 },
-    { 0, /* char8 */ 0, 0, 0 },
-    { 0, /* char9 */ 0, 0, 0 },
-    { 0, /* char10 */ 0, 0, 0 },
-    { 0, /* char11 */ 0, 0, 0 },
-    { 0, /* char12 */ 0, 0, 0 },
-    { 0, /* char13 */ 0, 0, 0 },
-    { 0, /* char14 */ 0, 0, 0 },
-    { 0, /* char15 */ 0, 0, 0 },
-    { 0, /* char16 */ 0, 0, 0 },
-    { 0, /* char17 */ 0, 0, 0 },
-    { 0, /* char18 */ 0, 0, 0 },
-    { 0, /* char19 */ 0, 0, 0 },
-    { 0, /* char20 */ 0, 0, 0 },
-    { 0, /* char21 */ 0, 0, 0 },
-    { 0, /* char22 */ 0, 0, 0 },
-    { 0, /* char23 */ 0, 0, 0 },
-    { 0, /* char24 */ 0, 0, 0 },
-    { 0, /* char25 */ 0, 0, 0 },
-    { 0, /* char26 */ 0, 0, 0 },
-    { 0, /* char27 */ 0, 0, 0 },
-    { 0, /* char28 */ 0, 0, 0 },
-    { 0, /* char29 */ 0, 0, 0 },
-    { 0, /* char30 */ 0, 0, 0 },
-    { 0, /* char31 */ 0, 0, 0 },
-    { 0, /* char32 */ 0, 52.381, 104.762 },
-    { 2, char33, 13.3819, 26.6238 },
-    { 2, char34, 23.0676, 51.4352 },
-    { 4, char35, 36.5333, 79.4886 },
-    { 3, char36, 38.1533, 76.2067 },
-    { 3, char37, 49.2171, 96.5743 },
-    { 1, char38, 53.599, 101.758 },
-    { 1, char39, 4.44, 13.62 },
-    { 1, char40, 21.8657, 47.1733 },
-    { 1, char41, 24.3276, 47.5333 },
-    { 3, char42, 30.7695, 59.439 },
-    { 2, char43, 48.8371, 97.2543 },
-    { 1, char44, 13.5219, 26.0638 },
-    { 1, char45, 50.2371, 100.754 },
-    { 1, char46, 13.1019, 26.4838 },
-    { 1, char47, 40.5733, 82.1067 },
-    { 1, char48, 38.3133, 77.0667 },
-    { 1, char49, 30.8676, 66.5295 },
-    { 1, char50, 38.7533, 77.6467 },
-    { 1, char51, 38.3333, 77.0467 },
-    { 2, char52, 37.2133, 80.1686 },
-    { 1, char53, 38.1933, 77.6867 },
-    { 1, char54, 34.1514, 73.8048 },
-    { 2, char55, 38.8933, 77.2267 },
-    { 1, char56, 38.9333, 77.6667 },
-    { 1, char57, 39.9333, 74.0648 },
-    { 2, char58, 14.0819, 26.2238 },
-    { 2, char59, 12.9619, 26.3038 },
-    { 1, char60, 41.1552, 81.6105 },
-    { 2, char61, 48.5571, 97.2543 },
-    { 1, char62, 40.8752, 81.6105 },
-    { 2, char63, 36.9914, 73.9029 },
-    { 2, char64, 34.9314, 74.3648 },
-    { 3, char65, 40.5952, 80.4905 },
-    { 3, char66, 44.7533, 83.6267 },
-    { 1, char67, 39.9933, 84.4886 },
-    { 2, char68, 45.2933, 85.2867 },
-    { 4, char69, 39.9914, 78.1848 },
-    { 3, char70, 39.9914, 78.7448 },
-    { 2, char71, 40.3933, 89.7686 },
-    { 3, char72, 44.7533, 89.0867 },
-    { 1, char73, 10.86, 21.3 },
-    { 1, char74, 31.0714, 59.999 },
-    { 3, char75, 44.6133, 79.3267 },
-    { 2, char76, 40.2514, 71.3229 },
-    { 4, char77, 48.9552, 97.2105 },
-    { 3, char78, 44.4733, 88.8067 },
-    { 1, char79, 44.3352, 88.8305 },
-    { 2, char80, 45.4333, 85.6667 },
-    { 2, char81, 43.3952, 88.0905 },
-    { 3, char82, 45.0133, 82.3667 },
-    { 1, char83, 41.3333, 80.8267 },
-    { 2, char84, 35.6933, 71.9467 },
-    { 1, char85, 44.8733, 89.4867 },
-    { 2, char86, 40.4552, 81.6105 },
-    { 4, char87, 49.839, 100.518 },
-    { 2, char88, 35.8333, 72.3667 },
-    { 2, char89, 39.6152, 79.6505 },
-    { 3, char90, 35.8333, 73.7467 },
-    { 4, char91, 22.0657, 46.1133 },
-    { 1, char92, 39.1733, 78.2067 },
-    { 4, char93, 23.4876, 46.3933 },
-    { 2, char94, 44.0752, 90.2305 },
-    { 1, char95, 51.281, 104.062 },
-    { 2, char96, 42.5457, 83.5714 },
-    { 2, char97, 35.2514, 66.6029 },
-    { 2, char98, 37.3314, 70.4629 },
-    { 1, char99, 34.0914, 68.9229 },
-    { 2, char100, 33.2114, 70.2629 },
-    { 1, char101, 34.2914, 68.5229 },
-    { 2, char102, 14.9657, 38.6552 },
-    { 2, char103, 33.9314, 70.9829 },
-    { 2, char104, 33.4095, 71.021 },
-    { 2, char105, 14.7819, 28.8638 },
-    { 2, char106, 17.3876, 36.2314 },
-    { 3, char107, 33.4095, 62.521 },
-    { 1, char108, 10.02, 19.34 },
-    { 3, char109, 61.981, 123.962 },
-    { 2, char110, 32.9895, 70.881 },
-    { 1, char111, 33.5514, 71.7448 },
-    { 2, char112, 38.0314, 70.8029 },
-    { 2, char113, 33.4114, 70.7429 },
-    { 2, char114, 23.7457, 49.4952 },
-    { 1, char115, 28.5095, 62.321 },
-    { 2, char116, 14.8257, 39.3152 },
-    { 2, char117, 33.2695, 71.161 },
-    { 2, char118, 30.3714, 60.6029 },
-    { 4, char119, 40.5952, 80.4905 },
-    { 2, char120, 25.4695, 56.401 },
-    { 2, char121, 35.1333, 66.0648 },
-    { 3, char122, 28.2495, 61.821 },
-    { 3, char123, 21.6657, 41.6295 },
-    { 1, char124, 11.54, 23.78 },
-    { 3, char125, 18.7038, 41.4695 },
-    { 2, char126, 45.7771, 91.2743 },
-    { 2, char127, 33.3333, 66.6667 },
-};
-
-StrokeFontRec glutStrokeRoman = { "Roman", 128, chars, 119.048, -33.3333 };
-
diff --git a/src/glut/beos/glut_shapes.c b/src/glut/beos/glut_shapes.c
deleted file mode 100644
index ce5bebb2be2..00000000000
--- a/src/glut/beos/glut_shapes.c
+++ /dev/null
@@ -1,596 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/**
-(c) Copyright 1993, Silicon Graphics, Inc.
-
-ALL RIGHTS RESERVED
-
-Permission to use, copy, modify, and distribute this software
-for any purpose and without fee is hereby granted, provided
-that the above copyright notice appear in all copies and that
-both the copyright notice and this permission notice appear in
-supporting documentation, and that the name of Silicon
-Graphics, Inc. not be used in advertising or publicity
-pertaining to distribution of the software without specific,
-written prior permission.
-
-THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
-"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
-OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
-EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
-ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
-CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
-INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
-SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
-NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
-OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
-PERFORMANCE OF THIS SOFTWARE.
-
-US Government Users Restricted Rights
-
-Use, duplication, or disclosure by the Government is subject to
-restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
-(c)(1)(ii) of the Rights in Technical Data and Computer
-Software clause at DFARS 252.227-7013 and/or in similar or
-successor clauses in the FAR or the DOD or NASA FAR
-Supplement.  Unpublished-- rights reserved under the copyright
-laws of the United States.  Contractor/manufacturer is Silicon
-Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
-94039-7311.
-
-OpenGL(TM) is a trademark of Silicon Graphics, Inc.
-*/
-
-#include <math.h>
-#include "glutint.h"
-
-/* Some <math.h> files do not define M_PI... */
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-static GLUquadricObj *quadObj;
-
-#define QUAD_OBJ_INIT() { if(!quadObj) initQuadObj(); }
-
-static void
-initQuadObj(void)
-{
-  quadObj = gluNewQuadric();
-  if (!quadObj)
-    __glutFatalError("out of memory.");
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_LINE);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluSphere(quadObj, radius, slices, stacks);
-}
-
-void APIENTRY
-glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_FILL);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluSphere(quadObj, radius, slices, stacks);
-}
-
-void APIENTRY
-glutWireCone(GLdouble base, GLdouble height,
-  GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_LINE);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
-}
-
-void APIENTRY
-glutSolidCone(GLdouble base, GLdouble height,
-  GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_FILL);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
-}
-
-/* ENDCENTRY */
-
-static void
-drawBox(GLfloat size, GLenum type)
-{
-  static GLfloat n[6][3] =
-  {
-    {-1.0, 0.0, 0.0},
-    {0.0, 1.0, 0.0},
-    {1.0, 0.0, 0.0},
-    {0.0, -1.0, 0.0},
-    {0.0, 0.0, 1.0},
-    {0.0, 0.0, -1.0}
-  };
-  static GLint faces[6][4] =
-  {
-    {0, 1, 2, 3},
-    {3, 2, 6, 7},
-    {7, 6, 5, 4},
-    {4, 5, 1, 0},
-    {5, 6, 2, 1},
-    {7, 4, 0, 3}
-  };
-  GLfloat v[8][3];
-  GLint i;
-
-  v[0][0] = v[1][0] = v[2][0] = v[3][0] = -size / 2;
-  v[4][0] = v[5][0] = v[6][0] = v[7][0] = size / 2;
-  v[0][1] = v[1][1] = v[4][1] = v[5][1] = -size / 2;
-  v[2][1] = v[3][1] = v[6][1] = v[7][1] = size / 2;
-  v[0][2] = v[3][2] = v[4][2] = v[7][2] = -size / 2;
-  v[1][2] = v[2][2] = v[5][2] = v[6][2] = size / 2;
-
-  for (i = 5; i >= 0; i--) {
-    glBegin(type);
-    glNormal3fv(&n[i][0]);
-    glVertex3fv(&v[faces[i][0]][0]);
-    glVertex3fv(&v[faces[i][1]][0]);
-    glVertex3fv(&v[faces[i][2]][0]);
-    glVertex3fv(&v[faces[i][3]][0]);
-    glEnd();
-  }
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireCube(GLdouble size)
-{
-  drawBox(size, GL_LINE_LOOP);
-}
-
-void APIENTRY
-glutSolidCube(GLdouble size)
-{
-  drawBox(size, GL_QUADS);
-}
-
-/* ENDCENTRY */
-
-static void
-doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings)
-{
-  int i, j;
-  GLfloat theta, phi, theta1;
-  GLfloat cosTheta, sinTheta;
-  GLfloat cosTheta1, sinTheta1;
-  GLfloat ringDelta, sideDelta;
-
-  ringDelta = 2.0 * M_PI / rings;
-  sideDelta = 2.0 * M_PI / nsides;
-
-  theta = 0.0;
-  cosTheta = 1.0;
-  sinTheta = 0.0;
-  for (i = rings - 1; i >= 0; i--) {
-    theta1 = theta + ringDelta;
-    cosTheta1 = cos(theta1);
-    sinTheta1 = sin(theta1);
-    glBegin(GL_QUAD_STRIP);
-    phi = 0.0;
-    for (j = nsides; j >= 0; j--) {
-      GLfloat cosPhi, sinPhi, dist;
-
-      phi += sideDelta;
-      cosPhi = cos(phi);
-      sinPhi = sin(phi);
-      dist = R + r * cosPhi;
-
-      glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
-      glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
-      glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
-      glVertex3f(cosTheta * dist, -sinTheta * dist,  r * sinPhi);
-    }
-    glEnd();
-    theta = theta1;
-    cosTheta = cosTheta1;
-    sinTheta = sinTheta1;
-  }
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireTorus(GLdouble innerRadius, GLdouble outerRadius,
-  GLint nsides, GLint rings)
-{
-  glPushAttrib(GL_POLYGON_BIT);
-  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-  doughnut(innerRadius, outerRadius, nsides, rings);
-  glPopAttrib();
-}
-
-void APIENTRY
-glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius,
-  GLint nsides, GLint rings)
-{
-  doughnut(innerRadius, outerRadius, nsides, rings);
-}
-
-/* ENDCENTRY */
-
-static GLfloat dodec[20][3];
-
-static void
-initDodecahedron(void)
-{
-  GLfloat alpha, beta;
-
-  alpha = sqrt(2.0 / (3.0 + sqrt(5.0)));
-  beta = 1.0 + sqrt(6.0 / (3.0 + sqrt(5.0)) -
-    2.0 + 2.0 * sqrt(2.0 / (3.0 + sqrt(5.0))));
-  /* *INDENT-OFF* */
-  dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta;
-  dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta;
-  dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1;
-  dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1;
-  dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1;
-  dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1;
-  dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1;
-  dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1;
-  dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1;
-  dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1;
-  dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0;
-  dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0;
-  dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0;
-  dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0;
-  dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta;
-  dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta;
-  dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha;
-  dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha;
-  dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha;
-  dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha;
-  /* *INDENT-ON* */
-
-}
-
-#define DIFF3(_a,_b,_c) { \
-    (_c)[0] = (_a)[0] - (_b)[0]; \
-    (_c)[1] = (_a)[1] - (_b)[1]; \
-    (_c)[2] = (_a)[2] - (_b)[2]; \
-}
-
-static void
-crossprod(GLfloat v1[3], GLfloat v2[3], GLfloat prod[3])
-{
-  GLfloat p[3];         /* in case prod == v1 or v2 */
-
-  p[0] = v1[1] * v2[2] - v2[1] * v1[2];
-  p[1] = v1[2] * v2[0] - v2[2] * v1[0];
-  p[2] = v1[0] * v2[1] - v2[0] * v1[1];
-  prod[0] = p[0];
-  prod[1] = p[1];
-  prod[2] = p[2];
-}
-
-static void
-normalize(GLfloat v[3])
-{
-  GLfloat d;
-
-  d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (d == 0.0) {
-    __glutWarning("normalize: zero length vector");
-    v[0] = d = 1.0;
-  }
-  d = 1 / d;
-  v[0] *= d;
-  v[1] *= d;
-  v[2] *= d;
-}
-
-static void
-pentagon(int a, int b, int c, int d, int e, GLenum shadeType)
-{
-  GLfloat n0[3], d1[3], d2[3];
-
-  DIFF3(dodec[a], dodec[b], d1);
-  DIFF3(dodec[b], dodec[c], d2);
-  crossprod(d1, d2, n0);
-  normalize(n0);
-
-  glBegin(shadeType);
-  glNormal3fv(n0);
-  glVertex3fv(&dodec[a][0]);
-  glVertex3fv(&dodec[b][0]);
-  glVertex3fv(&dodec[c][0]);
-  glVertex3fv(&dodec[d][0]);
-  glVertex3fv(&dodec[e][0]);
-  glEnd();
-}
-
-static void
-dodecahedron(GLenum type)
-{
-  static int inited = 0;
-
-  if (inited == 0) {
-    inited = 1;
-    initDodecahedron();
-  }
-  pentagon(0, 1, 9, 16, 5, type);
-  pentagon(1, 0, 3, 18, 7, type);
-  pentagon(1, 7, 11, 10, 9, type);
-  pentagon(11, 7, 18, 19, 6, type);
-  pentagon(8, 17, 16, 9, 10, type);
-  pentagon(2, 14, 15, 6, 19, type);
-  pentagon(2, 13, 12, 4, 14, type);
-  pentagon(2, 19, 18, 3, 13, type);
-  pentagon(3, 0, 5, 12, 13, type);
-  pentagon(6, 15, 8, 10, 11, type);
-  pentagon(4, 17, 8, 15, 14, type);
-  pentagon(4, 12, 5, 16, 17, type);
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireDodecahedron(void)
-{
-  dodecahedron(GL_LINE_LOOP);
-}
-
-void APIENTRY
-glutSolidDodecahedron(void)
-{
-  dodecahedron(GL_TRIANGLE_FAN);
-}
-
-/* ENDCENTRY */
-
-static void
-recorditem(GLfloat * n1, GLfloat * n2, GLfloat * n3,
-  GLenum shadeType)
-{
-  GLfloat q0[3], q1[3];
-
-  DIFF3(n1, n2, q0);
-  DIFF3(n2, n3, q1);
-  crossprod(q0, q1, q1);
-  normalize(q1);
-
-  glBegin(shadeType);
-  glNormal3fv(q1);
-  glVertex3fv(n1);
-  glVertex3fv(n2);
-  glVertex3fv(n3);
-  glEnd();
-}
-
-static void
-subdivide(GLfloat * v0, GLfloat * v1, GLfloat * v2,
-  GLenum shadeType)
-{
-  int depth;
-  GLfloat w0[3], w1[3], w2[3];
-  GLfloat l;
-  int i, j, k, n;
-
-  depth = 1;
-  for (i = 0; i < depth; i++) {
-    for (j = 0; i + j < depth; j++) {
-      k = depth - i - j;
-      for (n = 0; n < 3; n++) {
-        w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth;
-        w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n])
-          / depth;
-        w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n])
-          / depth;
-      }
-      l = sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]);
-      w0[0] /= l;
-      w0[1] /= l;
-      w0[2] /= l;
-      l = sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]);
-      w1[0] /= l;
-      w1[1] /= l;
-      w1[2] /= l;
-      l = sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]);
-      w2[0] /= l;
-      w2[1] /= l;
-      w2[2] /= l;
-      recorditem(w1, w0, w2, shadeType);
-    }
-  }
-}
-
-static void
-drawtriangle(int i, GLfloat data[][3], int ndx[][3],
-  GLenum shadeType)
-{
-  GLfloat *x0, *x1, *x2;
-
-  x0 = data[ndx[i][0]];
-  x1 = data[ndx[i][1]];
-  x2 = data[ndx[i][2]];
-  subdivide(x0, x1, x2, shadeType);
-}
-
-/* octahedron data: The octahedron produced is centered at the
-   origin and has radius 1.0 */
-static GLfloat odata[6][3] =
-{
-  {1.0, 0.0, 0.0},
-  {-1.0, 0.0, 0.0},
-  {0.0, 1.0, 0.0},
-  {0.0, -1.0, 0.0},
-  {0.0, 0.0, 1.0},
-  {0.0, 0.0, -1.0}
-};
-
-static int ondex[8][3] =
-{
-  {0, 4, 2},
-  {1, 2, 4},
-  {0, 3, 4},
-  {1, 4, 3},
-  {0, 2, 5},
-  {1, 5, 2},
-  {0, 5, 3},
-  {1, 3, 5}
-};
-
-static void
-octahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 7; i >= 0; i--) {
-    drawtriangle(i, odata, ondex, shadeType);
-  }
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireOctahedron(void)
-{
-  octahedron(GL_LINE_LOOP);
-}
-
-void APIENTRY
-glutSolidOctahedron(void)
-{
-  octahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
-
-/* icosahedron data: These numbers are rigged to make an
-   icosahedron of radius 1.0 */
-
-#define X .525731112119133606
-#define Z .850650808352039932
-
-static GLfloat idata[12][3] =
-{
-  {-X, 0, Z},
-  {X, 0, Z},
-  {-X, 0, -Z},
-  {X, 0, -Z},
-  {0, Z, X},
-  {0, Z, -X},
-  {0, -Z, X},
-  {0, -Z, -X},
-  {Z, X, 0},
-  {-Z, X, 0},
-  {Z, -X, 0},
-  {-Z, -X, 0}
-};
-
-static int index[20][3] =
-{
-  {0, 4, 1},
-  {0, 9, 4},
-  {9, 5, 4},
-  {4, 5, 8},
-  {4, 8, 1},
-  {8, 10, 1},
-  {8, 3, 10},
-  {5, 3, 8},
-  {5, 2, 3},
-  {2, 7, 3},
-  {7, 10, 3},
-  {7, 6, 10},
-  {7, 11, 6},
-  {11, 0, 6},
-  {0, 1, 6},
-  {6, 1, 10},
-  {9, 0, 11},
-  {9, 11, 2},
-  {9, 2, 5},
-  {7, 2, 11},
-};
-
-static void
-icosahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 19; i >= 0; i--) {
-    drawtriangle(i, idata, index, shadeType);
-  }
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireIcosahedron(void)
-{
-  icosahedron(GL_LINE_LOOP);
-}
-
-void APIENTRY
-glutSolidIcosahedron(void)
-{
-  icosahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
-
-/* tetrahedron data: */
-
-#define T       1.73205080756887729
-
-static GLfloat tdata[4][3] =
-{
-  {T, T, T},
-  {T, -T, -T},
-  {-T, T, -T},
-  {-T, -T, T}
-};
-
-static int tndex[4][3] =
-{
-  {0, 1, 3},
-  {2, 1, 0},
-  {3, 2, 0},
-  {1, 2, 3}
-};
-
-static void
-tetrahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 3; i >= 0; i--)
-    drawtriangle(i, tdata, tndex, shadeType);
-}
-
-/* CENTRY */
-void APIENTRY
-glutWireTetrahedron(void)
-{
-  tetrahedron(GL_LINE_LOOP);
-}
-
-void APIENTRY
-glutSolidTetrahedron(void)
-{
-  tetrahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glut_stroke.c b/src/glut/beos/glut_stroke.c
deleted file mode 100644
index 2fe408be1ad..00000000000
--- a/src/glut/beos/glut_stroke.c
+++ /dev/null
@@ -1,42 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutstroke.h"
-
-void APIENTRY 
-glutStrokeCharacter(GLUTstrokeFont font, int c)
-{
-  const StrokeCharRec *ch;
-  const StrokeRec *stroke;
-  const CoordRec *coord;
-  StrokeFontPtr fontinfo;
-  int i, j;
-
-
-#if defined(_WIN32)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  if (c < 0 || c >= fontinfo->num_chars)
-    return;
-  ch = &(fontinfo->ch[c]);
-  if (ch) {
-    for (i = ch->num_strokes, stroke = ch->stroke;
-      i > 0; i--, stroke++) {
-      glBegin(GL_LINE_STRIP);
-      for (j = stroke->num_coords, coord = stroke->coord;
-        j > 0; j--, coord++) {
-        glVertex2f(coord->x, coord->y);
-      }
-      glEnd();
-    }
-    glTranslatef(ch->right, 0.0, 0.0);
-  }
-}
diff --git a/src/glut/beos/glut_swidth.c b/src/glut/beos/glut_swidth.c
deleted file mode 100644
index e1b73745751..00000000000
--- a/src/glut/beos/glut_swidth.c
+++ /dev/null
@@ -1,58 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1995. */
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutstroke.h"
-
-/* CENTRY */
-int APIENTRY 
-glutStrokeWidth(GLUTstrokeFont font, int c)
-{
-  StrokeFontPtr fontinfo;
-  const StrokeCharRec *ch;
-
-#if defined(_WIN32)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  if (c < 0 || c >= fontinfo->num_chars)
-    return 0;
-  ch = &(fontinfo->ch[c]);
-  if (ch)
-    return ch->right;
-  else
-    return 0;
-}
-
-int APIENTRY 
-glutStrokeLength(GLUTstrokeFont font, const unsigned char *string)
-{
-  int c, length;
-  StrokeFontPtr fontinfo;
-  const StrokeCharRec *ch;
-
-#if defined(_WIN32)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  length = 0;
-  for (; *string != '\0'; string++) {
-    c = *string;
-    if (c >= 0 && c < fontinfo->num_chars) {
-      ch = &(fontinfo->ch[c]);
-      if (ch)
-        length += ch->right;
-    }
-  }
-  return length;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glut_teapot.c b/src/glut/beos/glut_teapot.c
deleted file mode 100644
index 3c9bdc1ab72..00000000000
--- a/src/glut/beos/glut_teapot.c
+++ /dev/null
@@ -1,210 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994. */
-
-/**
-(c) Copyright 1993, Silicon Graphics, Inc.
-
-ALL RIGHTS RESERVED
-
-Permission to use, copy, modify, and distribute this software
-for any purpose and without fee is hereby granted, provided
-that the above copyright notice appear in all copies and that
-both the copyright notice and this permission notice appear in
-supporting documentation, and that the name of Silicon
-Graphics, Inc. not be used in advertising or publicity
-pertaining to distribution of the software without specific,
-written prior permission.
-
-THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
-"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
-OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
-EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
-ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
-CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
-INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
-SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
-NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
-OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
-PERFORMANCE OF THIS SOFTWARE.
-
-US Government Users Restricted Rights
-
-Use, duplication, or disclosure by the Government is subject to
-restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
-(c)(1)(ii) of the Rights in Technical Data and Computer
-Software clause at DFARS 252.227-7013 and/or in similar or
-successor clauses in the FAR or the DOD or NASA FAR
-Supplement.  Unpublished-- rights reserved under the copyright
-laws of the United States.  Contractor/manufacturer is Silicon
-Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
-94039-7311.
-
-OpenGL(TM) is a trademark of Silicon Graphics, Inc.
-*/
-
-#include "glutint.h"
-
-/* Rim, body, lid, and bottom data must be reflected in x and
-   y; handle and spout data across the y axis only.  */
-
-static int patchdata[][16] =
-{
-    /* rim */
-  {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11,
-    12, 13, 14, 15},
-    /* body */
-  {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-    24, 25, 26, 27},
-  {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36,
-    37, 38, 39, 40},
-    /* lid */
-  {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101,
-    101, 0, 1, 2, 3,},
-  {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112,
-    113, 114, 115, 116, 117},
-    /* bottom */
-  {118, 118, 118, 118, 124, 122, 119, 121, 123, 126,
-    125, 120, 40, 39, 38, 37},
-    /* handle */
-  {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-    53, 54, 55, 56},
-  {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-    28, 65, 66, 67},
-    /* spout */
-  {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
-    80, 81, 82, 83},
-  {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
-    92, 93, 94, 95}
-};
-/* *INDENT-OFF* */
-
-static float cpdata[][3] =
-{
-    {0.2, 0, 2.7}, {0.2, -0.112, 2.7}, {0.112, -0.2, 2.7}, {0,
-    -0.2, 2.7}, {1.3375, 0, 2.53125}, {1.3375, -0.749, 2.53125},
-    {0.749, -1.3375, 2.53125}, {0, -1.3375, 2.53125}, {1.4375,
-    0, 2.53125}, {1.4375, -0.805, 2.53125}, {0.805, -1.4375,
-    2.53125}, {0, -1.4375, 2.53125}, {1.5, 0, 2.4}, {1.5, -0.84,
-    2.4}, {0.84, -1.5, 2.4}, {0, -1.5, 2.4}, {1.75, 0, 1.875},
-    {1.75, -0.98, 1.875}, {0.98, -1.75, 1.875}, {0, -1.75,
-    1.875}, {2, 0, 1.35}, {2, -1.12, 1.35}, {1.12, -2, 1.35},
-    {0, -2, 1.35}, {2, 0, 0.9}, {2, -1.12, 0.9}, {1.12, -2,
-    0.9}, {0, -2, 0.9}, {-2, 0, 0.9}, {2, 0, 0.45}, {2, -1.12,
-    0.45}, {1.12, -2, 0.45}, {0, -2, 0.45}, {1.5, 0, 0.225},
-    {1.5, -0.84, 0.225}, {0.84, -1.5, 0.225}, {0, -1.5, 0.225},
-    {1.5, 0, 0.15}, {1.5, -0.84, 0.15}, {0.84, -1.5, 0.15}, {0,
-    -1.5, 0.15}, {-1.6, 0, 2.025}, {-1.6, -0.3, 2.025}, {-1.5,
-    -0.3, 2.25}, {-1.5, 0, 2.25}, {-2.3, 0, 2.025}, {-2.3, -0.3,
-    2.025}, {-2.5, -0.3, 2.25}, {-2.5, 0, 2.25}, {-2.7, 0,
-    2.025}, {-2.7, -0.3, 2.025}, {-3, -0.3, 2.25}, {-3, 0,
-    2.25}, {-2.7, 0, 1.8}, {-2.7, -0.3, 1.8}, {-3, -0.3, 1.8},
-    {-3, 0, 1.8}, {-2.7, 0, 1.575}, {-2.7, -0.3, 1.575}, {-3,
-    -0.3, 1.35}, {-3, 0, 1.35}, {-2.5, 0, 1.125}, {-2.5, -0.3,
-    1.125}, {-2.65, -0.3, 0.9375}, {-2.65, 0, 0.9375}, {-2,
-    -0.3, 0.9}, {-1.9, -0.3, 0.6}, {-1.9, 0, 0.6}, {1.7, 0,
-    1.425}, {1.7, -0.66, 1.425}, {1.7, -0.66, 0.6}, {1.7, 0,
-    0.6}, {2.6, 0, 1.425}, {2.6, -0.66, 1.425}, {3.1, -0.66,
-    0.825}, {3.1, 0, 0.825}, {2.3, 0, 2.1}, {2.3, -0.25, 2.1},
-    {2.4, -0.25, 2.025}, {2.4, 0, 2.025}, {2.7, 0, 2.4}, {2.7,
-    -0.25, 2.4}, {3.3, -0.25, 2.4}, {3.3, 0, 2.4}, {2.8, 0,
-    2.475}, {2.8, -0.25, 2.475}, {3.525, -0.25, 2.49375},
-    {3.525, 0, 2.49375}, {2.9, 0, 2.475}, {2.9, -0.15, 2.475},
-    {3.45, -0.15, 2.5125}, {3.45, 0, 2.5125}, {2.8, 0, 2.4},
-    {2.8, -0.15, 2.4}, {3.2, -0.15, 2.4}, {3.2, 0, 2.4}, {0, 0,
-    3.15}, {0.8, 0, 3.15}, {0.8, -0.45, 3.15}, {0.45, -0.8,
-    3.15}, {0, -0.8, 3.15}, {0, 0, 2.85}, {1.4, 0, 2.4}, {1.4,
-    -0.784, 2.4}, {0.784, -1.4, 2.4}, {0, -1.4, 2.4}, {0.4, 0,
-    2.55}, {0.4, -0.224, 2.55}, {0.224, -0.4, 2.55}, {0, -0.4,
-    2.55}, {1.3, 0, 2.55}, {1.3, -0.728, 2.55}, {0.728, -1.3,
-    2.55}, {0, -1.3, 2.55}, {1.3, 0, 2.4}, {1.3, -0.728, 2.4},
-    {0.728, -1.3, 2.4}, {0, -1.3, 2.4}, {0, 0, 0}, {1.425,
-    -0.798, 0}, {1.5, 0, 0.075}, {1.425, 0, 0}, {0.798, -1.425,
-    0}, {0, -1.5, 0.075}, {0, -1.425, 0}, {1.5, -0.84, 0.075},
-    {0.84, -1.5, 0.075}
-};
-
-static float tex[2][2][2] =
-{
-  { {0, 0},
-    {1, 0}},
-  { {0, 1},
-    {1, 1}}
-};
-
-/* *INDENT-ON* */
-
-static void
-teapot(GLint grid, GLdouble scale, GLenum type)
-{
-  float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
-  long i, j, k, l;
-
-  glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT);
-  glEnable(GL_AUTO_NORMAL);
-  glEnable(GL_NORMALIZE);
-  glEnable(GL_MAP2_VERTEX_3);
-  glEnable(GL_MAP2_TEXTURE_COORD_2);
-  glPushMatrix();
-  glRotatef(270.0, 1.0, 0.0, 0.0);
-  glScalef(0.5 * scale, 0.5 * scale, 0.5 * scale);
-  glTranslatef(0.0, 0.0, -1.5);
-  for (i = 0; i < 10; i++) {
-    for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++) {
-        for (l = 0; l < 3; l++) {
-          p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
-          q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
-          if (l == 1)
-            q[j][k][l] *= -1.0;
-          if (i < 6) {
-            r[j][k][l] =
-              cpdata[patchdata[i][j * 4 + (3 - k)]][l];
-            if (l == 0)
-              r[j][k][l] *= -1.0;
-            s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
-            if (l == 0)
-              s[j][k][l] *= -1.0;
-            if (l == 1)
-              s[j][k][l] *= -1.0;
-          }
-        }
-      }
-    }
-    glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2,
-      &tex[0][0][0]);
-    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-      &p[0][0][0]);
-    glMapGrid2f(grid, 0.0, 1.0, grid, 0.0, 1.0);
-    glEvalMesh2(type, 0, grid, 0, grid);
-    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-      &q[0][0][0]);
-    glEvalMesh2(type, 0, grid, 0, grid);
-    if (i < 6) {
-      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-        &r[0][0][0]);
-      glEvalMesh2(type, 0, grid, 0, grid);
-      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-        &s[0][0][0]);
-      glEvalMesh2(type, 0, grid, 0, grid);
-    }
-  }
-  glPopMatrix();
-  glPopAttrib();
-}
-
-/* CENTRY */
-void APIENTRY 
-glutSolidTeapot(GLdouble scale)
-{
-  teapot(14, scale, GL_FILL);
-}
-
-void APIENTRY 
-glutWireTeapot(GLdouble scale)
-{
-  teapot(10, scale, GL_LINE);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glut_tr10.c b/src/glut/beos/glut_tr10.c
deleted file mode 100644
index 0fac8070ca5..00000000000
--- a/src/glut/beos/glut_tr10.c
+++ /dev/null
@@ -1,1777 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapTimesRoman10 XXX
-#include "glutbitmap.h"
-#undef glutBitmapTimesRoman10
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0xa0,
-};
-
-static const BitmapCharRec ch255 = {5,9,0,2,5,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {4,9,0,2,5,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {5,10,0,2,5,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {5,7,0,0,5,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {5,8,0,0,5,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch250 = {5,8,0,0,5,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {5,8,0,0,5,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x80,0x70,0x48,0x48,0x48,0x38,0x4,
-};
-
-static const BitmapCharRec ch248 = {6,7,1,1,5,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,0,0,6,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,
-};
-
-static const BitmapCharRec ch246 = {4,7,0,0,5,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch245 = {4,8,0,0,5,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch244 = {4,8,0,0,5,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch243 = {4,8,0,0,5,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {4,8,0,0,5,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xd8,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch241 = {5,8,0,0,5,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x60,0x90,0x90,0x90,0x70,0xa0,0x70,0x40,
-};
-
-static const BitmapCharRec ch240 = {4,8,0,0,5,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,7,0,0,4,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,8,0,0,4,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch237 = {3,8,0,0,4,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {3,8,0,0,4,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,
-};
-
-static const BitmapCharRec ch235 = {3,7,0,0,4,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch234 = {3,8,0,0,4,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch233 = {3,8,0,0,4,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch232 = {3,8,0,0,4,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0xc0,0x20,0x40,0x60,0x80,0x80,0x80,0x60,
-};
-
-static const BitmapCharRec ch231 = {3,8,0,3,4,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0xd8,0xa0,0x70,0x28,0xd8,
-};
-
-static const BitmapCharRec ch230 = {5,5,0,0,6,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x40,0xa0,0x40,
-};
-
-static const BitmapCharRec ch229 = {3,8,0,0,4,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch228 = {3,7,0,0,4,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch227 = {4,8,0,0,4,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch226 = {3,8,0,0,4,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch225 = {3,8,0,0,4,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch224 = {3,8,0,0,4,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xe0,0x50,0x50,0x60,0x50,0x50,0x20,
-};
-
-static const BitmapCharRec ch223 = {4,7,0,0,5,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xe0,0x40,0x70,0x48,0x70,0x40,0xe0,
-};
-
-static const BitmapCharRec ch222 = {5,7,0,0,6,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x38,0x10,0x10,0x28,0x28,0x44,0xee,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,10,0,0,8,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,
-};
-
-static const BitmapCharRec ch220 = {7,9,0,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {7,10,0,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch218 = {7,10,0,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {7,10,0,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x7c,0x66,0x52,0x52,0x4a,0x66,0x3e,0x1,
-};
-
-static const BitmapCharRec ch216 = {8,9,0,1,8,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,0,0,6,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,
-};
-
-static const BitmapCharRec ch214 = {6,9,0,0,7,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {6,10,0,0,7,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch212 = {6,10,0,0,7,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch211 = {6,10,0,0,7,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch210 = {6,10,0,0,7,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {7,10,0,0,8,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0xf8,0x4c,0x44,0xe4,0x44,0x4c,0xf8,
-};
-
-static const BitmapCharRec ch208 = {6,7,0,0,7,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,9,0,0,4,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,10,0,0,4,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch205 = {3,10,0,0,4,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {3,10,0,0,4,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,
-};
-
-static const BitmapCharRec ch203 = {5,9,0,0,6,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch202 = {5,10,0,0,6,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch201 = {5,10,0,0,6,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch200 = {5,10,0,0,6,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x60,0x10,0x20,0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch199 = {6,10,0,3,7,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xef,0x49,0x78,0x2e,0x28,0x39,0x1f,
-};
-
-static const BitmapCharRec ch198 = {8,7,0,0,9,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,10,0,0,8,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,9,0,0,8,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,10,0,0,8,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,10,0,0,8,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,10,0,0,8,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,10,0,0,8,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0xe0,0xa0,0x80,0x40,0x40,0x0,0x40,
-};
-
-static const BitmapCharRec ch191 = {3,7,0,2,4,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x44,0x3e,0x2c,0xd4,0x28,0x48,0xe4,
-};
-
-static const BitmapCharRec ch190 = {7,7,0,0,8,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x4e,0x24,0x2a,0xf6,0x48,0xc8,0x44,
-};
-
-static const BitmapCharRec ch189 = {7,7,0,0,8,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x44,0x3e,0x2c,0xf4,0x48,0xc8,0x44,
-};
-
-static const BitmapCharRec ch188 = {7,7,0,0,8,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {4,4,0,-1,5,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0x40,0xa0,0x40,
-};
-
-static const BitmapCharRec ch186 = {3,5,0,-2,4,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xe0,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {3,4,0,-3,3,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x20,0x40,
-};
-
-static const BitmapCharRec ch184 = {3,3,0,3,4,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch183 = {1,1,0,-2,2,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
-};
-
-static const BitmapCharRec ch182 = {6,9,0,2,6,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xe8,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch181 = {5,7,0,2,5,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-5,3,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xe0,0x40,0xa0,0x60,
-};
-
-static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch175 = {3,1,0,-6,4,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
-};
-
-static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch173 = {3,1,0,-2,4,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch172 = {5,3,-1,-1,7,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x50,0xa0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch171 = {4,4,0,-1,5,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xc0,
-};
-
-static const BitmapCharRec ch170 = {3,5,0,-2,4,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
-};
-
-static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,-1,-6,5,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0xe0,0x90,0x20,0x50,0x90,0xa0,0x40,0x90,0x70,
-};
-
-static const BitmapCharRec ch167 = {4,9,0,1,5,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x0,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,7,0,0,2,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x70,0x20,0xf8,0x20,0xd8,0x50,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,7,0,0,5,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x88,0x70,0x50,0x50,0x70,0x88,
-};
-
-static const BitmapCharRec ch164 = {5,6,0,-1,5,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xf0,0xc8,0x40,0xe0,0x40,0x50,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,7,0,0,5,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x80,0xe0,0x90,0x80,0x90,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {4,7,0,1,5,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,7,-1,2,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,2,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,2,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-2,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0x80,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch125 = {3,9,0,2,4,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,9,0,2,2,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x20,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch123 = {3,9,0,2,4,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x90,0x40,0x20,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,5,0,0,5,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x40,0x40,0x20,0x30,0x50,0x48,0xdc,
-};
-
-static const BitmapCharRec ch121 = {6,7,1,2,5,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xd8,0x50,0x20,0x50,0xd8,
-};
-
-static const BitmapCharRec ch120 = {5,5,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x28,0x6c,0x54,0x92,0xdb,
-};
-
-static const BitmapCharRec ch119 = {8,5,0,0,8,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x60,0x50,0x90,0xd8,
-};
-
-static const BitmapCharRec ch118 = {5,5,0,0,5,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x68,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch117 = {5,5,0,0,5,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x30,0x40,0x40,0x40,0xe0,0x40,
-};
-
-static const BitmapCharRec ch116 = {4,6,0,0,4,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0xe0,0x20,0x60,0x80,0xe0,
-};
-
-static const BitmapCharRec ch115 = {3,5,0,0,4,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xe0,0x40,0x40,0x60,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,5,0,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x38,0x10,0x70,0x90,0x90,0x90,0x70,
-};
-
-static const BitmapCharRec ch113 = {5,7,0,2,5,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,
-};
-
-static const BitmapCharRec ch112 = {4,7,0,2,5,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x60,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch111 = {4,5,0,0,5,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xd8,0x90,0x90,0x90,0xe0,
-};
-
-static const BitmapCharRec ch110 = {5,5,0,0,5,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xdb,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {8,5,0,0,8,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch108 = {3,7,0,0,4,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x98,0x90,0xe0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {5,7,0,0,5,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x40,0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
-};
-
-static const BitmapCharRec ch106 = {2,9,0,2,3,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
-};
-
-static const BitmapCharRec ch105 = {2,7,0,0,3,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xd8,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,7,0,0,5,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0xe0,0x90,0x60,0x40,0xa0,0xa0,0x70,
-};
-
-static const BitmapCharRec ch103 = {4,7,0,2,5,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0xe0,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,7,0,0,4,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x60,0x80,0xc0,0xa0,0x60,
-};
-
-static const BitmapCharRec ch101 = {3,5,0,0,4,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x90,0x90,0x90,0x70,0x10,0x30,
-};
-
-static const BitmapCharRec ch100 = {5,7,0,0,5,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x60,0x80,0x80,0x80,0x60,
-};
-
-static const BitmapCharRec ch99 = {3,5,0,0,4,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {4,7,0,0,5,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,
-};
-
-static const BitmapCharRec ch97 = {3,5,0,0,4,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0x80,
-};
-
-static const BitmapCharRec ch96 = {2,2,0,-5,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch95 = {5,1,0,3,5,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0xa0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch94 = {3,3,-1,-4,5,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,9,0,2,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x20,0x20,0x40,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {3,7,0,0,3,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,9,0,2,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xf8,0x88,0x40,0x20,0x10,0x88,0xf8,
-};
-
-static const BitmapCharRec ch90 = {5,7,0,0,6,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x38,0x10,0x10,0x28,0x28,0x44,0xee,
-};
-
-static const BitmapCharRec ch89 = {7,7,0,0,8,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xee,0x44,0x28,0x10,0x28,0x44,0xee,
-};
-
-static const BitmapCharRec ch88 = {7,7,0,0,8,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0xc9,0x80,0x88,0x80,0xdd,0xc0,
-};
-
-static const BitmapCharRec ch87 = {10,7,0,0,10,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x10,0x28,0x28,0x6c,0x44,0xee,
-};
-
-static const BitmapCharRec ch86 = {7,7,0,0,8,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,
-};
-
-static const BitmapCharRec ch85 = {7,7,0,0,8,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x70,0x20,0x20,0x20,0x20,0xa8,0xf8,
-};
-
-static const BitmapCharRec ch84 = {5,7,0,0,6,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0xe0,0x90,0x10,0x60,0xc0,0x90,0x70,
-};
-
-static const BitmapCharRec ch83 = {4,7,0,0,5,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xec,0x48,0x50,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch82 = {6,7,0,0,7,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0xc,0x18,0x70,0xcc,0x84,0x84,0x84,0xcc,0x78,
-};
-
-static const BitmapCharRec ch81 = {6,9,0,2,7,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xe0,0x40,0x40,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch80 = {5,7,0,0,6,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,
-};
-
-static const BitmapCharRec ch79 = {6,7,0,0,7,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,
-};
-
-static const BitmapCharRec ch78 = {7,7,0,0,8,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xeb,0x80,0x49,0x0,0x55,0x0,0x55,0x0,0x63,0x0,0x63,0x0,0xe3,0x80,
-};
-
-static const BitmapCharRec ch77 = {9,7,0,0,10,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf8,0x48,0x40,0x40,0x40,0x40,0xe0,
-};
-
-static const BitmapCharRec ch76 = {5,7,0,0,6,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xec,0x48,0x50,0x60,0x50,0x48,0xec,
-};
-
-static const BitmapCharRec ch75 = {6,7,0,0,7,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0xc0,0xa0,0x20,0x20,0x20,0x20,0x70,
-};
-
-static const BitmapCharRec ch74 = {4,7,0,0,4,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,
-};
-
-static const BitmapCharRec ch73 = {3,7,0,0,4,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xee,0x44,0x44,0x7c,0x44,0x44,0xee,
-};
-
-static const BitmapCharRec ch72 = {7,7,0,0,8,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x78,0xc4,0x84,0x9c,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch71 = {6,7,0,0,7,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xe0,0x40,0x40,0x70,0x40,0x48,0xf8,
-};
-
-static const BitmapCharRec ch70 = {5,7,0,0,6,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,
-};
-
-static const BitmapCharRec ch69 = {5,7,0,0,6,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf8,0x4c,0x44,0x44,0x44,0x4c,0xf8,
-};
-
-static const BitmapCharRec ch68 = {6,7,0,0,7,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch67 = {6,7,0,0,7,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf0,0x48,0x48,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch66 = {5,7,0,0,6,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,7,0,0,8,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x40,0x92,0xad,0xa5,0xa5,0x9d,0x42,0x3c,
-};
-
-static const BitmapCharRec ch64 = {8,9,0,2,9,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x40,0x0,0x40,0x40,0x20,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch63 = {3,7,0,0,4,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {3,5,0,0,5,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf8,0x0,0xf8,
-};
-
-static const BitmapCharRec ch61 = {5,3,0,-1,6,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x20,0x40,0x80,0x40,0x20,
-};
-
-static const BitmapCharRec ch60 = {3,5,-1,0,5,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x80,0x80,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch59 = {1,7,-1,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,5,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0xc0,0x20,0x70,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch57 = {4,7,0,0,5,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x60,0x90,0x90,0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch56 = {4,7,0,0,5,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x40,0x20,0x20,0x90,0xf0,
-};
-
-static const BitmapCharRec ch55 = {4,7,0,0,5,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x60,0x90,0x90,0x90,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch54 = {4,7,0,0,5,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0xe0,0x90,0x10,0x10,0xe0,0x40,0x70,
-};
-
-static const BitmapCharRec ch53 = {4,7,0,0,5,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x10,0x10,0xf8,0x90,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch52 = {5,7,0,0,5,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0xe0,0x10,0x10,0x60,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch51 = {4,7,0,0,5,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf0,0x40,0x20,0x20,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch50 = {4,7,0,0,5,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xe0,0x40,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch49 = {3,7,-1,0,5,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x60,0x90,0x90,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch48 = {4,7,0,0,5,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x20,0x20,
-};
-
-static const BitmapCharRec ch47 = {3,7,0,0,3,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch45 = {4,1,-1,-2,7,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch44 = {1,3,-1,2,3,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,0,0,6,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,0,-4,5,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,9,0,2,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,9,0,2,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x40,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,2,0,-5,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x76,0x8d,0x98,0x74,0x6e,0x50,0x30,
-};
-
-static const BitmapCharRec ch38 = {8,7,0,0,8,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x44,0x2a,0x2a,0x56,0xa8,0xa4,0x7e,
-};
-
-static const BitmapCharRec ch37 = {7,7,0,0,8,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0xe0,0x90,0x10,0x60,0x80,0x90,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {4,9,0,1,5,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0xf8,0x50,0xf8,0x50,0x50,
-};
-
-static const BitmapCharRec ch35 = {5,7,0,0,5,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,2,0,-5,4,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,7,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,2,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,2,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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 glutBitmapTimesRoman10 = {
-"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/beos/glut_tr24.c b/src/glut/beos/glut_tr24.c
deleted file mode 100644
index 22b0e516035..00000000000
--- a/src/glut/beos/glut_tr24.c
+++ /dev/null
@@ -1,2060 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapTimesRoman24 XXX
-#include "glutbitmap.h"
-#undef glutBitmapTimesRoman24
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch255 = {11,21,0,5,11,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
-0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0xe0,0x0,
-};
-
-static const BitmapCharRec ch254 = {10,22,-1,5,12,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,0x1,0x80,
-};
-
-static const BitmapCharRec ch253 = {11,22,0,5,11,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch252 = {11,16,-1,0,13,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch251 = {11,17,-1,0,13,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
-0x1,0x80,
-};
-
-static const BitmapCharRec ch250 = {11,17,-1,0,13,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch249 = {11,17,-1,0,13,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xc0,0x0,0xde,0x0,0x73,0x80,0x71,0x80,0xd0,0xc0,0xd8,0xc0,0xc8,0xc0,0xcc,0xc0,
-0xc4,0xc0,0xc6,0xc0,0x63,0x80,0x73,0x80,0x1e,0xc0,0x0,0xc0,
-};
-
-static const BitmapCharRec ch248 = {10,14,-1,1,12,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x6,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,
-0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch247 = {12,10,-1,-2,14,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch246 = {10,16,-1,0,12,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
-};
-
-static const BitmapCharRec ch245 = {10,16,-1,0,12,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch244 = {10,17,-1,0,12,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
-0x1,0x80,
-};
-
-static const BitmapCharRec ch243 = {10,17,-1,0,12,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch242 = {10,17,-1,0,12,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
-};
-
-static const BitmapCharRec ch241 = {11,16,-1,0,13,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1f,0x0,0xc6,0x0,0x3c,0x0,0x1e,0x0,0x71,0x80,
-0xc0,0x0,
-};
-
-static const BitmapCharRec ch240 = {10,17,-1,0,12,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x0,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch239 = {6,16,0,0,6,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x84,0x48,0x78,
-0x30,
-};
-
-static const BitmapCharRec ch238 = {6,17,0,0,6,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x80,0x60,0x38,
-0x18,
-};
-
-static const BitmapCharRec ch237 = {5,17,-1,0,6,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x8,0x30,0xe0,
-0xc0,
-};
-
-static const BitmapCharRec ch236 = {5,17,0,0,6,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch235 = {9,16,-1,0,11,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch234 = {9,17,-1,0,11,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch233 = {9,17,-1,0,11,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
-0x60,0x0,
-};
-
-static const BitmapCharRec ch232 = {9,17,-1,0,11,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x3c,0x0,0x66,0x0,0x6,0x0,0x1e,0x0,0x18,0x0,0x8,0x0,0x1e,0x0,0x7f,0x0,
-0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x41,0x80,
-0x63,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch231 = {9,18,-1,6,11,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x70,0xf0,0xfb,0xf8,0xc7,0x84,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0xfc,
-0x3,0xc,0x63,0xc,0x67,0x98,0x3c,0xf0,
-};
-
-static const BitmapCharRec ch230 = {14,12,-1,0,16,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x22,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch229 = {9,17,-1,0,11,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x66,0x0,
-};
-
-static const BitmapCharRec ch228 = {9,16,-1,0,11,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x5c,0x0,0x3a,0x0,
-};
-
-static const BitmapCharRec ch227 = {9,16,-1,0,11,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x42,0x0,0x24,0x0,0x3c,0x0,
-0x18,0x0,
-};
-
-static const BitmapCharRec ch226 = {9,17,-1,0,11,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch225 = {9,17,-1,0,11,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
-0x60,0x0,
-};
-
-static const BitmapCharRec ch224 = {9,17,-1,0,11,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xe7,0x0,0x6c,0x80,0x6c,0xc0,0x60,0xc0,0x60,0xc0,0x61,0xc0,0x61,0x80,0x63,0x80,
-0x67,0x0,0x6c,0x0,0x63,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch223 = {10,17,-1,0,12,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,
-0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,0x3f,0xc0,0x30,0x0,0x30,0x0,0x30,0x0,
-0xfc,0x0,
-};
-
-static const BitmapCharRec ch222 = {13,17,-1,0,15,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
-0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
-0xfc,0x3f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch221 = {16,22,0,0,16,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x0,0x0,0x6,0x30,0x6,0x30,
-};
-
-static const BitmapCharRec ch220 = {16,21,-1,0,18,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
-};
-
-static const BitmapCharRec ch219 = {16,22,-1,0,18,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch218 = {16,22,-1,0,18,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch217 = {16,22,-1,0,18,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x20,0x0,0x27,0xe0,0x1c,0x38,0x38,0x1c,0x68,0x6,0x64,0x6,0xc2,0x3,0xc2,0x3,
-0xc1,0x3,0xc1,0x3,0xc0,0x83,0xc0,0x83,0xc0,0x43,0x60,0x46,0x60,0x26,0x38,0x1c,
-0x1c,0x38,0x7,0xe4,0x0,0x4,
-};
-
-static const BitmapCharRec ch216 = {16,19,-1,1,18,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x80,0x40,0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,
-0x61,0x80,0xc0,0xc0,0x80,0x40,
-};
-
-static const BitmapCharRec ch215 = {10,11,-2,-1,14,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x0,0x6,0x60,0x6,0x60,
-};
-
-static const BitmapCharRec ch214 = {16,21,-1,0,18,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
-};
-
-static const BitmapCharRec ch213 = {16,21,-1,0,18,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
-};
-
-static const BitmapCharRec ch212 = {16,22,-1,0,18,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch211 = {16,22,-1,0,18,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch210 = {16,22,-1,0,18,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
-0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
-0xf0,0x1f,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
-};
-
-static const BitmapCharRec ch209 = {16,21,-1,0,18,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7f,0xe0,0x18,0x38,0x18,0x1c,0x18,0x6,0x18,0x6,0x18,0x3,0x18,0x3,0x18,0x3,
-0xff,0x3,0x18,0x3,0x18,0x3,0x18,0x3,0x18,0x6,0x18,0x6,0x18,0x1c,0x18,0x38,
-0x7f,0xe0,
-};
-
-static const BitmapCharRec ch208 = {16,17,0,0,17,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x0,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch207 = {6,21,-1,0,8,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x7e,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x7e,0x0,0x81,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch206 = {8,22,-1,0,8,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x40,0x30,0x1c,0xc,
-};
-
-static const BitmapCharRec ch205 = {6,22,-1,0,8,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x8,0x30,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch204 = {6,22,-1,0,8,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x0,0x0,0x19,0x80,0x19,0x80,
-};
-
-static const BitmapCharRec ch203 = {13,21,-1,0,15,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x10,0x20,0xc,0xc0,0x7,0x80,0x3,0x0,
-};
-
-static const BitmapCharRec ch202 = {13,22,-1,0,15,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x4,0x0,0x3,0x0,0x1,0xc0,0x0,0xc0,
-};
-
-static const BitmapCharRec ch201 = {13,22,-1,0,15,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x1,0x0,0x6,0x0,0x1c,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch200 = {13,22,-1,0,15,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x7,0x80,0xc,0xc0,0x0,0xc0,0x3,0xc0,0x3,0x0,0x1,0x0,0x7,0xe0,0x1e,0x38,
-0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,0x7,0xe4,
-};
-
-static const BitmapCharRec ch199 = {14,23,-1,6,16,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xf9,0xff,0xf0,0x30,0x60,0x30,0x10,0x60,0x10,0x10,0x60,0x10,0x18,0x60,0x0,0x8,
-0x60,0x0,0xf,0xe0,0x80,0xc,0x60,0x80,0x4,0x7f,0x80,0x4,0x60,0x80,0x6,0x60,
-0x80,0x2,0x60,0x0,0x2,0x60,0x0,0x1,0x60,0x20,0x1,0x60,0x20,0x1,0xe0,0x60,
-0x3,0xff,0xe0,
-};
-
-static const BitmapCharRec ch198 = {20,17,0,0,21,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x1,0xc0,0x0,0x2,0x20,0x0,0x2,0x20,0x0,0x1,0xc0,0x0,
-};
-
-static const BitmapCharRec ch197 = {17,21,0,0,17,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x30,0x0,0x6,0x30,0x0,
-};
-
-static const BitmapCharRec ch196 = {17,21,0,0,17,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xfc,0x1f,0x80,0x30,0x7,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0xe0,0x0,0x3,0x90,0x0,
-};
-
-static const BitmapCharRec ch195 = {17,21,0,0,17,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x8,0x10,0x0,0x6,0x60,0x0,0x3,0xc0,0x0,0x1,
-0x80,0x0,
-};
-
-static const BitmapCharRec ch194 = {17,22,0,0,17,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xc0,0x0,0x0,0x70,0x0,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch193 = {17,22,0,0,17,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0xc0,0x0,0x3,0x80,0x0,0x3,
-0x0,0x0,
-};
-
-static const BitmapCharRec ch192 = {17,22,0,0,17,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x3e,0x63,0xc1,0xc3,0xc3,0xe0,0x70,0x30,0x38,0x18,0x18,0x8,0x8,0x0,0x0,0xc,
-0xc,
-};
-
-static const BitmapCharRec ch191 = {8,17,-1,5,11,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x18,0x2,0x0,0x8,0x2,0x0,0xc,0x7f,0x80,0x4,0x22,0x0,0x6,0x32,0x0,0x3,
-0x12,0x0,0x1,0xa,0x0,0x71,0x8e,0x0,0x88,0x86,0x0,0x8c,0xc2,0x0,0xc,0x60,
-0x0,0x8,0x20,0x0,0x30,0x30,0x0,0x8,0x10,0x0,0x8c,0x18,0x0,0x4c,0xc,0x0,
-0x38,0x4,0x0,
-};
-
-static const BitmapCharRec ch190 = {17,17,0,0,18,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x30,0x7e,0x10,0x22,0x18,0x10,0x8,0x18,0xc,0x8,0x6,0x4,0x2,0x6,0xfb,0x46,
-0x21,0x26,0x21,0x9c,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
-0x20,0x8,
-};
-
-static const BitmapCharRec ch189 = {15,17,-1,0,18,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x30,0x4,0x10,0x4,0x18,0xff,0x8,0x44,0xc,0x64,0x6,0x24,0x2,0x14,0xfb,0x1c,
-0x21,0xc,0x21,0x84,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
-0x20,0x8,
-};
-
-static const BitmapCharRec ch188 = {16,17,-1,0,18,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x88,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,0x19,0x80,0x19,0x80,0x33,0x0,0x66,0x0,
-0xcc,0x0,0x88,0x0,
-};
-
-static const BitmapCharRec ch187 = {9,10,-2,-1,12,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xfc,0x0,0x78,0xcc,0xcc,0xcc,0xcc,0xcc,0x78,
-};
-
-static const BitmapCharRec ch186 = {6,9,-1,-8,8,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,0x60,0x20,
-};
-
-static const BitmapCharRec ch185 = {5,10,-1,-7,7,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0x78,0xcc,0xc,0x3c,0x30,0x10,
-};
-
-static const BitmapCharRec ch184 = {6,6,-1,6,8,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-2,-6,6,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,
-0x9,0x0,0x9,0x0,0x9,0x0,0x19,0x0,0x39,0x0,0x79,0x0,0x79,0x0,0xf9,0x0,
-0xf9,0x0,0xf9,0x0,0x79,0x0,0x79,0x0,0x39,0x0,0x1f,0x80,
-};
-
-static const BitmapCharRec ch182 = {9,22,-1,5,11,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x40,0x0,0xe0,0x0,0xc0,0x0,0x40,0x0,0x40,0x0,0x5c,0xe0,0x7e,0xc0,0x71,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0xe1,0xc0,
-};
-
-static const BitmapCharRec ch181 = {11,17,-1,5,13,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x60,0x38,0x18,
-};
-
-static const BitmapCharRec ch180 = {5,4,-2,-13,8,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x70,0x88,0x8c,0xc,0x8,0x30,0x8,0x8c,0x4c,0x38,
-};
-
-static const BitmapCharRec ch179 = {6,10,0,-7,7,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xfc,0x44,0x20,0x30,0x10,0x8,0xc,0x8c,0x4c,0x38,
-};
-
-static const BitmapCharRec ch178 = {6,10,0,-7,7,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xff,0xf0,0xff,0xf0,0x0,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0xff,0xf0,0xff,0xf0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch177 = {12,15,-1,0,14,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x38,0x44,0x82,0x82,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch176 = {7,7,-1,-10,9,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xfc,0xfc,
-};
-
-static const BitmapCharRec ch175 = {6,2,-1,-14,8,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x60,0x3,0x0,0x47,0x19,0x0,0xc2,
-0x31,0x80,0x82,0x20,0x80,0x82,0x40,0x80,0x83,0xe0,0x80,0x82,0x30,0x80,0x82,0x10,
-0x80,0xc2,0x11,0x80,0x42,0x31,0x0,0x67,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
-0x7,0xf0,0x0,
-};
-
-static const BitmapCharRec ch174 = {17,17,-1,0,19,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xfe,0xfe,
-};
-
-static const BitmapCharRec ch173 = {7,2,-1,-5,9,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch172 = {12,7,-1,-3,14,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x8,0x80,0x19,0x80,0x33,0x0,0x66,0x0,0xcc,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,
-0x19,0x80,0x8,0x80,
-};
-
-static const BitmapCharRec ch171 = {9,10,-2,-1,13,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0x7e,0x0,0x76,0xcc,0xcc,0x7c,0xc,0xcc,0x78,
-};
-
-static const BitmapCharRec ch170 = {7,9,0,-8,8,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x61,0xc3,0x0,0x47,0x71,0x0,0xc4,
-0x19,0x80,0x8c,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x8c,0x0,
-0x80,0xc4,0x19,0x80,0x47,0x31,0x0,0x61,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
-0x7,0xf0,0x0,
-};
-
-static const BitmapCharRec ch169 = {17,17,-1,0,19,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xcc,0xcc,
-};
-
-static const BitmapCharRec ch168 = {6,2,-1,-14,8,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x38,0x64,0x62,0x6,0xe,0x1c,0x38,0x74,0xe2,0xc3,0x83,0x87,0x4e,0x3c,0x38,0x70,
-0x60,0x46,0x26,0x1c,
-};
-
-static const BitmapCharRec ch167 = {8,20,-2,2,12,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch166 = {2,17,-2,0,6,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x1f,0xe0,0x3,0x0,0x1f,0xe0,
-0x3,0x0,0x7,0x80,0xc,0x80,0xc,0xc0,0x18,0x40,0x18,0x60,0x30,0x20,0x70,0x30,
-0xf8,0x7c,
-};
-
-static const BitmapCharRec ch165 = {14,17,0,0,14,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0xc0,0x60,0xee,0xe0,0x7f,0xc0,0x31,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x31,0x80,0x7f,0xc0,0xee,0xe0,0xc0,0x60,
-};
-
-static const BitmapCharRec ch164 = {11,12,-1,-3,13,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xe7,0x80,0xbe,0xc0,0x78,0x40,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x30,0x0,0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x31,0x80,0x19,0x80,
-0xf,0x0,
-};
-
-static const BitmapCharRec ch163 = {10,17,-1,0,12,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x0,0x40,0x0,0x3e,0x0,0x7f,0x0,0x70,0x80,0xd0,0x0,0xc8,0x0,0xc8,0x0,
-0xc8,0x0,0xc4,0x0,0xc4,0x0,0x43,0x80,0x63,0x80,0x1f,0x0,0x1,0x0,0x1,0x0,
-};
-
-static const BitmapCharRec ch162 = {9,16,-1,2,12,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch161 = {2,17,-4,5,8,ch161data};
-
-/* char: 0xa0 */
-
-#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,6,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,6,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x83,0x80,0xc7,0xc0,0x7c,0x60,0x38,0x20,
-};
-
-static const BitmapCharRec ch126 = {11,4,-1,-5,13,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xe0,0x30,0x18,0x18,0x18,0x18,0x18,0x18,0x8,0xc,0x4,0x3,0x4,0xc,0x8,0x18,
-0x18,0x18,0x18,0x18,0x30,0xe0,
-};
-
-static const BitmapCharRec ch125 = {8,22,-1,5,10,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch124 = {2,17,-2,0,6,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x7,0xc,0x18,0x18,0x18,0x18,0x18,0x18,0x10,0x30,0x20,0xc0,0x20,0x30,0x10,0x18,
-0x18,0x18,0x18,0x18,0xc,0x7,
-};
-
-static const BitmapCharRec ch123 = {8,22,-1,5,10,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xff,0xc3,0x61,0x70,0x30,0x38,0x18,0x1c,0xe,0x86,0xc3,0xff,
-};
-
-static const BitmapCharRec ch122 = {8,12,-1,0,10,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,
-};
-
-static const BitmapCharRec ch121 = {11,17,0,5,11,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xf1,0xe0,0x60,0xc0,0x21,0x80,0x33,0x80,0x1b,0x0,0xe,0x0,0xc,0x0,0x1a,0x0,
-0x39,0x0,0x31,0x80,0x60,0xc0,0xf1,0xe0,
-};
-
-static const BitmapCharRec ch120 = {11,12,-1,0,13,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x4,0x10,0x0,0xe,0x38,0x0,0xe,0x38,0x0,0x1a,0x28,0x0,0x1a,0x64,0x0,0x19,
-0x64,0x0,0x31,0x64,0x0,0x30,0xc2,0x0,0x30,0xc2,0x0,0x60,0xc2,0x0,0x60,0xc3,
-0x0,0xf1,0xe7,0x80,
-};
-
-static const BitmapCharRec ch119 = {17,12,0,0,17,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x4,0x0,0xe,0x0,0xe,0x0,0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,
-0x30,0x80,0x60,0x80,0x60,0xc0,0xf1,0xe0,
-};
-
-static const BitmapCharRec ch118 = {11,12,0,0,11,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,
-};
-
-static const BitmapCharRec ch117 = {11,12,-1,0,13,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x1c,0x32,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x70,0x30,0x10,
-};
-
-static const BitmapCharRec ch116 = {7,15,0,0,7,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0xf8,0xc6,0x83,0x3,0x7,0x1e,0x7c,0x70,0xe0,0xc2,0x66,0x3e,
-};
-
-static const BitmapCharRec ch115 = {8,12,-1,0,10,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x76,0x6e,0xe6,
-};
-
-static const BitmapCharRec ch114 = {7,12,-1,0,8,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x3,0xc0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1d,0x80,0x73,0x80,0x61,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x73,0x80,
-0x1d,0x80,
-};
-
-static const BitmapCharRec ch113 = {10,17,-1,5,12,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
-0xee,0x0,
-};
-
-static const BitmapCharRec ch112 = {10,17,-1,5,12,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,
-};
-
-static const BitmapCharRec ch111 = {10,12,-1,0,12,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,
-};
-
-static const BitmapCharRec ch110 = {11,12,-1,0,13,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xf1,0xe3,0xc0,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,
-0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x71,0xe3,0x80,0x6f,0x9f,
-0x0,0xe7,0xe,0x0,
-};
-
-static const BitmapCharRec ch109 = {18,12,-1,0,20,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,
-0xe0,
-};
-
-static const BitmapCharRec ch108 = {4,17,-1,0,6,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0xf3,0xe0,0x61,0xc0,0x63,0x80,0x67,0x0,0x6e,0x0,0x6c,0x0,0x78,0x0,0x68,0x0,
-0x64,0x0,0x66,0x0,0x63,0x0,0x67,0xc0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch107 = {11,17,-1,0,12,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0xc0,0xe0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0x70,0x0,0x0,0x0,0x30,0x30,
-};
-
-static const BitmapCharRec ch106 = {4,22,0,5,6,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x0,0x0,0x60,
-0x60,
-};
-
-static const BitmapCharRec ch105 = {4,17,-1,0,6,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0x67,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch104 = {11,17,-1,0,13,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x3f,0x0,0xf1,0xc0,0xc0,0x60,0xc0,0x20,0x60,0x60,0x3f,0xc0,0x7f,0x0,0x60,0x0,
-0x30,0x0,0x3e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1f,0xc0,
-};
-
-static const BitmapCharRec ch103 = {11,17,-1,5,12,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x30,0x30,0x30,0x16,
-0xe,
-};
-
-static const BitmapCharRec ch102 = {7,17,0,0,7,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,
-};
-
-static const BitmapCharRec ch101 = {9,12,-1,0,11,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x1e,0xc0,0x73,0x80,0x61,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,
-0xc1,0x80,0x61,0x80,0x73,0x80,0x1d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
-0x3,0x80,
-};
-
-static const BitmapCharRec ch100 = {10,17,-1,0,12,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0x41,0x80,0x63,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch99 = {9,12,-1,0,11,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0x5e,0x0,0x73,0x80,0x61,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x61,0x80,0x73,0x80,0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch98 = {10,17,-1,0,12,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,
-};
-
-static const BitmapCharRec ch97 = {9,12,-1,0,11,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x60,0xe0,0x80,0xc0,0x60,
-};
-
-static const BitmapCharRec ch96 = {3,5,-2,-12,7,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,0xf8,0xff,0xf8,
-};
-
-static const BitmapCharRec ch95 = {13,2,0,5,13,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x80,0x80,0xc1,0x80,0x41,0x0,0x63,0x0,0x22,0x0,0x36,0x0,0x14,0x0,0x1c,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch94 = {9,9,-1,-8,11,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0xf8,
-};
-
-static const BitmapCharRec ch93 = {5,21,-1,4,8,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x6,0x6,0x4,0xc,0xc,0x8,0x18,0x18,0x10,0x30,0x30,0x20,0x60,0x60,0x40,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch92 = {7,17,0,0,7,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf8,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0xc0,0xc0,0xf8,
-};
-
-static const BitmapCharRec ch91 = {5,21,-2,4,8,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xff,0xf8,0xe0,0x18,0x70,0x8,0x30,0x8,0x38,0x0,0x18,0x0,0x1c,0x0,0xe,0x0,
-0x6,0x0,0x7,0x0,0x3,0x0,0x3,0x80,0x1,0xc0,0x80,0xc0,0x80,0xe0,0xc0,0x70,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch90 = {13,17,-1,0,15,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
-0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
-0xfc,0x3f,
-};
-
-static const BitmapCharRec ch89 = {16,17,0,0,16,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xfc,0xf,0xc0,0x30,0x3,0x80,0x18,0x7,0x0,0x8,0xe,0x0,0x4,0xc,0x0,0x6,
-0x18,0x0,0x2,0x38,0x0,0x1,0x70,0x0,0x0,0xe0,0x0,0x0,0xc0,0x0,0x1,0xc0,
-0x0,0x3,0xa0,0x0,0x3,0x10,0x0,0x6,0x8,0x0,0xe,0xc,0x0,0x1c,0x6,0x0,
-0x7e,0xf,0x80,
-};
-
-static const BitmapCharRec ch88 = {18,17,0,0,18,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x1,0x83,0x0,0x1,0x83,0x0,0x1,0x83,0x80,0x3,0x87,0x80,0x3,0x46,0x80,0x3,
-0x46,0xc0,0x6,0x46,0x40,0x6,0x4c,0x40,0x6,0x4c,0x60,0xc,0x2c,0x60,0xc,0x2c,
-0x20,0x18,0x2c,0x20,0x18,0x18,0x30,0x18,0x18,0x10,0x30,0x18,0x10,0x30,0x18,0x18,
-0xfc,0x7e,0x7e,
-};
-
-static const BitmapCharRec ch87 = {23,17,0,0,23,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x1,0x80,0x0,0x1,0x80,0x0,0x1,0x80,0x0,0x3,0xc0,0x0,0x3,0x40,0x0,0x3,
-0x60,0x0,0x6,0x20,0x0,0x6,0x20,0x0,0x6,0x30,0x0,0xc,0x10,0x0,0xc,0x18,
-0x0,0x18,0x8,0x0,0x18,0x8,0x0,0x18,0xc,0x0,0x30,0x4,0x0,0x30,0x6,0x0,
-0xfc,0x1f,0x80,
-};
-
-static const BitmapCharRec ch86 = {17,17,0,0,17,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,
-};
-
-static const BitmapCharRec ch85 = {16,17,-1,0,18,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,
-0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x83,0x4,0x83,0x4,0xc3,0xc,
-0xff,0xfc,
-};
-
-static const BitmapCharRec ch84 = {14,17,-1,0,16,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x9e,0x0,0xf1,0x80,0xc0,0xc0,0x80,0x60,0x80,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,
-0xf,0x80,0x1e,0x0,0x78,0x0,0xe0,0x0,0xc0,0x40,0xc0,0x40,0xc0,0xc0,0x63,0xc0,
-0x1e,0x40,
-};
-
-static const BitmapCharRec ch83 = {11,17,-1,0,13,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xfc,0x1e,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0x60,0x30,0xc0,0x31,0xc0,0x33,0x80,
-0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x38,0x30,0x18,0x30,0x38,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch82 = {15,17,-1,0,16,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x0,0xf,0x0,0x38,0x0,0x70,0x0,0xe0,0x1,0xc0,0x7,0xe0,0x1c,0x38,0x38,0x1c,
-0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,0x7,0xe0,
-};
-
-static const BitmapCharRec ch81 = {16,22,-1,5,18,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch80 = {13,17,-1,0,15,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,
-};
-
-static const BitmapCharRec ch79 = {16,17,-1,0,18,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
-0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
-0xf0,0x1f,
-};
-
-static const BitmapCharRec ch78 = {16,17,-1,0,18,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xf8,0x21,0xf8,0x20,0x60,0x60,0x20,0x60,0x60,0x20,0xd0,0x60,0x20,0xd0,0x60,0x21,
-0x88,0x60,0x21,0x88,0x60,0x23,0x8,0x60,0x23,0x4,0x60,0x26,0x4,0x60,0x26,0x2,
-0x60,0x2c,0x2,0x60,0x2c,0x2,0x60,0x38,0x1,0x60,0x38,0x1,0x60,0x30,0x0,0xe0,
-0xf0,0x0,0xf8,
-};
-
-static const BitmapCharRec ch77 = {21,17,-1,0,22,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0xfc,0x0,
-};
-
-static const BitmapCharRec ch76 = {13,17,-1,0,14,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xfc,0x1f,0x30,0xe,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0xe0,0x31,0xc0,0x33,0x80,
-0x3f,0x0,0x3e,0x0,0x33,0x0,0x31,0x80,0x30,0xc0,0x30,0x60,0x30,0x30,0x30,0x18,
-0xfc,0x7e,
-};
-
-static const BitmapCharRec ch75 = {16,17,-1,0,17,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x78,0x0,0xcc,0x0,0xc6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0x1f,0x80,
-};
-
-static const BitmapCharRec ch74 = {9,17,-1,0,11,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,
-};
-
-static const BitmapCharRec ch73 = {6,17,-1,0,8,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,
-0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x3f,0xfe,0x0,0x30,0x6,0x0,0x30,0x6,
-0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,
-0xfc,0x1f,0x80,
-};
-
-static const BitmapCharRec ch72 = {17,17,-1,0,19,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x7,0xe0,0x1e,0x38,0x38,0x1c,0x60,0xc,0x60,0xc,0xc0,0xc,0xc0,0xc,0xc0,0x3f,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
-0x7,0xe4,
-};
-
-static const BitmapCharRec ch71 = {16,17,-1,0,18,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x20,0x30,0x20,
-0x3f,0xe0,0x30,0x20,0x30,0x20,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch70 = {12,17,-1,0,14,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch69 = {13,17,-1,0,15,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xff,0xc0,0x30,0x70,0x30,0x38,0x30,0xc,0x30,0xc,0x30,0x6,0x30,0x6,0x30,0x6,
-0x30,0x6,0x30,0x6,0x30,0x6,0x30,0x6,0x30,0xc,0x30,0xc,0x30,0x38,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch68 = {15,17,-1,0,17,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x7,0xe0,0x1e,0x38,0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
-0x7,0xe4,
-};
-
-static const BitmapCharRec ch67 = {14,17,-1,0,16,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xff,0xe0,0x30,0x78,0x30,0x18,0x30,0xc,0x30,0xc,0x30,0xc,0x30,0x18,0x30,0x38,
-0x3f,0xe0,0x30,0x40,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch66 = {14,17,-1,0,16,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,
-};
-
-static const BitmapCharRec ch65 = {17,17,0,0,17,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3,0xf0,0x0,0xe,0xc,0x0,0x18,0x0,0x0,0x30,0x0,0x0,0x61,0xde,0x0,0x63,
-0x7b,0x0,0xc6,0x39,0x80,0xc6,0x18,0x80,0xc6,0x18,0xc0,0xc6,0x18,0x40,0xc6,0xc,
-0x40,0xc3,0xc,0x40,0xc3,0x8c,0x40,0xe1,0xfc,0x40,0x60,0xec,0xc0,0x70,0x0,0x80,
-0x38,0x1,0x80,0x1c,0x3,0x0,0xf,0xe,0x0,0x3,0xf8,0x0,
-};
-
-static const BitmapCharRec ch64 = {18,20,-2,3,22,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x30,0x30,0x0,0x0,0x10,0x10,0x10,0x18,0x18,0xc,0xe,0x7,0xc3,0xc3,0x83,0xc6,
-0x7c,
-};
-
-static const BitmapCharRec ch63 = {8,17,-2,0,11,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0x0,0x70,0x0,0x1c,0x0,0x7,0x0,0x1,0xc0,0x0,0x60,0x1,0xc0,0x7,0x0,
-0x1c,0x0,0x70,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch62 = {11,11,-1,-1,13,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch61 = {12,6,-1,-4,14,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x0,0x60,0x1,0xc0,0x7,0x0,0x1c,0x0,0x70,0x0,0xc0,0x0,0x70,0x0,0x1c,0x0,
-0x7,0x0,0x1,0xc0,0x0,0x60,
-};
-
-static const BitmapCharRec ch60 = {11,11,-1,-1,13,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {3,14,-2,3,7,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,11,-2,0,6,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0xf0,0x0,0x1c,0x0,0x6,0x0,0x3,0x0,0x3,0x80,0x1,0x80,0x1d,0x80,0x73,0xc0,
-0x61,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0x61,0x80,0x77,0x80,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch57 = {10,17,-1,0,12,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x1e,0x0,0x73,0x80,0xe1,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x41,0xc0,0x61,0x80,
-0x37,0x0,0x1e,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch56 = {10,17,-1,0,12,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x18,0x0,0x18,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0x4,0x0,0x6,0x0,0x6,0x0,
-0x2,0x0,0x3,0x0,0x3,0x0,0x1,0x0,0x1,0x80,0x81,0x80,0xc0,0xc0,0xff,0xc0,
-0x7f,0xc0,
-};
-
-static const BitmapCharRec ch55 = {10,17,-1,0,12,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x1e,0x0,0x7b,0x80,0x61,0x80,0xe0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc1,0x80,0xf3,0x80,0xee,0x0,0x60,0x0,0x70,0x0,0x30,0x0,0x18,0x0,0xe,0x0,
-0x3,0xc0,
-};
-
-static const BitmapCharRec ch54 = {10,17,-1,0,12,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7e,0x0,0xe3,0x80,0xc1,0x80,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x1,0xc0,
-0x3,0x80,0xf,0x80,0x7e,0x0,0x78,0x0,0x60,0x0,0x20,0x0,0x20,0x0,0x1f,0x80,
-0x1f,0xc0,
-};
-
-static const BitmapCharRec ch53 = {10,17,-1,0,12,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0xff,0xc0,0xff,0xc0,0xc3,0x0,0x43,0x0,
-0x63,0x0,0x23,0x0,0x33,0x0,0x13,0x0,0x1b,0x0,0xb,0x0,0x7,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch52 = {10,17,-1,0,12,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x78,0x0,0xe6,0x0,0xc3,0x0,0x1,0x0,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0x80,
-0x7,0x0,0x1e,0x0,0xc,0x0,0x6,0x0,0x83,0x0,0x83,0x0,0x47,0x0,0x7e,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch51 = {9,17,-1,0,12,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xff,0x80,0xff,0xc0,0x60,0x40,0x30,0x0,0x18,0x0,0xc,0x0,0x4,0x0,0x6,0x0,
-0x3,0x0,0x3,0x0,0x1,0x80,0x1,0x80,0x81,0x80,0x81,0x80,0x43,0x80,0x7f,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch50 = {10,17,-1,0,12,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x78,0x18,
-0x8,
-};
-
-static const BitmapCharRec ch49 = {8,17,-2,0,12,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0xe1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch48 = {10,17,-1,0,12,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0xc0,0xc0,0xc0,0x60,0x60,0x20,0x30,0x30,0x10,0x18,0x18,0x8,0xc,0xc,0x4,0x6,
-0x6,0x3,0x3,0x3,
-};
-
-static const BitmapCharRec ch47 = {8,20,1,3,7,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-2,0,6,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch45 = {12,2,-1,-6,14,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {3,5,-2,3,7,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xff,0xf0,0xff,0xf0,0x6,0x0,
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch43 = {12,12,-1,-1,14,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x8,0x0,0x1c,0x0,0xc9,0x80,0xeb,0x80,0x1c,0x0,0xeb,0x80,0xc9,0x80,0x1c,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch42 = {9,9,-2,-8,12,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x20,0x30,0x10,0x18,0x18,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0x18,
-0x18,0x10,0x30,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {6,22,-1,5,8,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x4,0x8,0x10,0x30,0x20,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,
-0x60,0x20,0x30,0x10,0x8,0x4,
-};
-
-static const BitmapCharRec ch40 = {6,22,-1,5,8,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch39 = {3,5,-3,-12,8,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x3c,0x3c,0x7f,0x7e,0xe1,0xe1,0xc0,0xc0,0xc1,0xc0,0xc1,0xa0,0x63,0x20,0x37,0x10,
-0x1e,0x18,0xe,0x3e,0xf,0x0,0x1d,0x80,0x18,0xc0,0x18,0x40,0x18,0x40,0xc,0xc0,
-0x7,0x80,
-};
-
-static const BitmapCharRec ch38 = {16,17,-1,0,18,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x30,0x3c,0x0,0x18,0x72,0x0,0xc,0x61,0x0,0x4,0x60,0x80,0x6,0x60,0x80,0x3,
-0x30,0x80,0x1,0x19,0x80,0x1,0x8f,0x0,0x78,0xc0,0x0,0xe4,0x40,0x0,0xc2,0x60,
-0x0,0xc1,0x30,0x0,0xc1,0x10,0x0,0x61,0x18,0x0,0x33,0xfc,0x0,0x1e,0xc,0x0,
-};
-
-static const BitmapCharRec ch37 = {17,16,-1,0,19,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x4,0x0,0x4,0x0,0x3f,0x0,0xe5,0xc0,0xc4,0xc0,0x84,0x60,0x84,0x60,0x4,0x60,
-0x4,0xe0,0x7,0xc0,0x7,0x80,0x1e,0x0,0x3c,0x0,0x74,0x0,0x64,0x0,0x64,0x20,
-0x64,0x60,0x34,0xe0,0x1f,0x80,0x4,0x0,0x4,0x0,
-};
-
-static const BitmapCharRec ch36 = {11,21,0,2,12,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0xff,0xc0,0xff,0xc0,0x11,0x0,
-0x11,0x0,0x11,0x0,0x7f,0xe0,0x7f,0xe0,0x8,0x80,0x8,0x80,0x8,0x80,0x8,0x80,
-0x8,0x80,
-};
-
-static const BitmapCharRec ch35 = {11,17,-1,0,13,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x88,0xcc,0xcc,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch34 = {6,5,-1,-12,10,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch33 = {2,17,-3,0,8,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,6,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,6,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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 glutBitmapTimesRoman24 = {
-"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/beos/glut_util.c b/src/glut/beos/glut_util.c
deleted file mode 100644
index 29e79513a3f..00000000000
--- a/src/glut/beos/glut_util.c
+++ /dev/null
@@ -1,81 +0,0 @@
-
-/* 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. */
-
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "glutint.h"
-
-/* strdup is actually not a standard ANSI C or POSIX routine
-   so implement a private one for GLUT.  OpenVMS does not have a
-   strdup; Linux's standard libc doesn't declare strdup by default
-   (unless BSD or SVID interfaces are requested). */
-char *
-__glutStrdup(const char *string)
-{
-  char *copy;
-
-  copy = (char*) malloc(strlen(string) + 1);
-  if (copy == NULL)
-    return NULL;
-  strcpy(copy, string);
-  return copy;
-}
-
-void
-__glutWarning(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Warning in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-}
-
-/* CENTRY */
-void APIENTRY 
-glutReportErrors(void)
-{
-  GLenum error;
-
-  while ((error = glGetError()) != GL_NO_ERROR)
-    __glutWarning("GL error: %s", gluErrorString(error));
-}
-/* ENDCENTRY */
-
-void
-__glutFatalError(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Fatal Error in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-  exit(1);
-}
-
-void
-__glutFatalUsage(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Fatal API Usage in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-  abort();
-}
diff --git a/src/glut/beos/glut_vidresize.c b/src/glut/beos/glut_vidresize.c
deleted file mode 100644
index a9d9e632f54..00000000000
--- a/src/glut/beos/glut_vidresize.c
+++ /dev/null
@@ -1,230 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996. */
-
-/* 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. */
-
-#include <stdlib.h>
-
-#if !defined(_WIN32) && !defined(__BEOS__)
-#include <GL/glx.h>
-#endif
-
-#ifdef __sgi
-#include <dlfcn.h>
-#endif
-
-#include "glutint.h"
-
-/* Grumble.  The IRIX 6.3 and early IRIX 6.4 OpenGL headers
-   support the video resize extension, but failed to define
-   GLX_SGIX_video_resize. */
-#ifdef GLX_SYNC_FRAME_SGIX
-#define GLX_SGIX_video_resize 1
-#endif
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-static int canVideoResize = -1;
-static int videoResizeChannel;
-#else
-static int canVideoResize = 0;
-#endif
-static int videoResizeInUse = 0;
-static int dx = -1, dy = -1, dw = -1, dh = -1;
-
-/* XXX Note that IRIX 6.2, 6.3, and some 6.4 versions have a
-   bug where programs seg-fault when they attempt video
-   resizing from an indirect OpenGL context (either local or
-   over a network). */
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-
-static volatile int errorCaught;
-
-/* ARGSUSED */
-static
-catchXSGIvcErrors(Display * dpy, XErrorEvent * event)
-{
-  errorCaught = 1;
-  return 0;
-}
-#endif
-
-/* CENTRY */
-int APIENTRY 
-glutVideoResizeGet(GLenum param)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (canVideoResize < 0) {
-    canVideoResize = __glutIsSupportedByGLX("GLX_SGIX_video_resize");
-    if (canVideoResize) {
-#if __sgi
-      /* This is a hack because IRIX 6.2, 6.3, and some 6.4
-         versions were released with GLX_SGIX_video_resize
-         being advertised by the X server though the video
-         resize extension is not actually supported.  We try to
-         determine if the libGL.so we are using actually has a
-         video resize entrypoint before we try to use the
-         feature. */
-      void (*func) (void);
-      void *glxDso = dlopen("libGL.so", RTLD_LAZY);
-
-      func = (void (*)(void)) dlsym(glxDso, "glXQueryChannelDeltasSGIX");
-      if (!func) {
-        canVideoResize = 0;
-      } else
-#endif
-      {
-        char *channelString;
-        int (*handler) (Display *, XErrorEvent *);
-
-        channelString = getenv("GLUT_VIDEO_RESIZE_CHANNEL");
-        videoResizeChannel = channelString ? atoi(channelString) : 0;
-
-        /* Work around another annoying problem with SGI's
-           GLX_SGIX_video_resize implementation.  Early IRIX
-           6.4 OpenGL's advertise the extension and have the
-           video resize API, but an XSGIvc X protocol errors
-           result trying to use the API.  Set up an error
-           handler to intercept what would otherwise be a fatal
-           error.  If an error was recieved, do not report that
-           video resize is possible. */
-        handler = XSetErrorHandler(catchXSGIvcErrors);
-
-        errorCaught = 0;
-
-        glXQueryChannelDeltasSGIX(__glutDisplay, __glutScreen,
-          videoResizeChannel, &dx, &dy, &dw, &dh);
-
-        /* glXQueryChannelDeltasSGIX is an inherent X server
-           round-trip so we know we will have gotten either the
-           correct reply or and error by this time. */
-        XSetErrorHandler(handler);
-
-        /* Still yet another work around.  In IRIX 6.4 betas,
-           glXQueryChannelDeltasSGIX will return as if it
-           succeeded, but the values are filled with junk.
-           Watch to make sure the delta variables really make
-           sense. */
-        if (errorCaught ||
-          dx < 0 || dy < 0 || dw < 0 || dh < 0 ||
-          dx > 2048 || dy > 2048 || dw > 2048 || dh > 2048) {
-          canVideoResize = 0;
-        }
-      }
-    }
-  }
-#endif /* GLX_SGIX_video_resize */
-
-  switch (param) {
-  case GLUT_VIDEO_RESIZE_POSSIBLE:
-    return canVideoResize;
-  case GLUT_VIDEO_RESIZE_IN_USE:
-    return videoResizeInUse;
-  case GLUT_VIDEO_RESIZE_X_DELTA:
-    return dx;
-  case GLUT_VIDEO_RESIZE_Y_DELTA:
-    return dy;
-  case GLUT_VIDEO_RESIZE_WIDTH_DELTA:
-    return dw;
-  case GLUT_VIDEO_RESIZE_HEIGHT_DELTA:
-    return dh;
-  case GLUT_VIDEO_RESIZE_X:
-  case GLUT_VIDEO_RESIZE_Y:
-  case GLUT_VIDEO_RESIZE_WIDTH:
-  case GLUT_VIDEO_RESIZE_HEIGHT:
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-    if (videoResizeInUse) {
-      int x, y, width, height;
-
-      glXQueryChannelRectSGIX(__glutDisplay, __glutScreen,
-        videoResizeChannel, &x, &y, &width, &height);
-      switch (param) {
-      case GLUT_VIDEO_RESIZE_X:
-        return x;
-      case GLUT_VIDEO_RESIZE_Y:
-        return y;
-      case GLUT_VIDEO_RESIZE_WIDTH:
-        return width;
-      case GLUT_VIDEO_RESIZE_HEIGHT:
-        return height;
-      }
-    }
-#endif
-    return -1;
-  default:
-    __glutWarning("invalid glutVideoResizeGet parameter: %d", param);
-    return -1;
-  }
-}
-
-void APIENTRY 
-glutSetupVideoResizing(void)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
-    glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, __glutCurrentWindow->win);
-    videoResizeInUse = 1;
-  } else
-#endif
-    __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n");
-}
-
-void APIENTRY 
-glutStopVideoResizing(void)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
-    if (videoResizeInUse) {
-      glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
-        videoResizeChannel, None);
-      videoResizeInUse = 0;
-    }
-  }
-#endif
-}
-
-/* ARGSUSED */
-void APIENTRY 
-glutVideoResize(int x, int y, int width, int height)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (videoResizeInUse) {
-#ifdef GLX_SYNC_SWAP_SGIX
-    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
-       6.2; the original unpatched IRIX 6.2 behavior is always
-       GLX_SYNC_SWAP_SGIX. */
-    glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, GLX_SYNC_SWAP_SGIX);
-#endif
-    glXChannelRectSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, x, y, width, height);
-  }
-#endif
-}
-
-/* ARGSUSED */
-void APIENTRY 
-glutVideoPan(int x, int y, int width, int height)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (videoResizeInUse) {
-#ifdef GLX_SYNC_FRAME_SGIX
-    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
-       6.2; the original unpatched IRIX 6.2 behavior is always
-       GLX_SYNC_SWAP_SGIX.  We just ignore that we cannot
-       accomplish GLX_SYNC_FRAME_SGIX on IRIX unpatched 6.2;
-       this means you'd need a glutSwapBuffers to actually
-       realize the video resize. */
-    glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, GLX_SYNC_FRAME_SGIX);
-#endif
-    glXChannelRectSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, x, y, width, height);
-  }
-#endif
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/beos/glutbitmap.h b/src/glut/beos/glutbitmap.h
deleted file mode 100644
index 32bf53c097b..00000000000
--- a/src/glut/beos/glutbitmap.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef __glutbitmap_h__
-#define __glutbitmap_h__
-
-/* 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. */
-
-#include <GL/glut.h>
-
-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 *GLUTbitmapFont;
-
-#endif /* __glutbitmap_h__ */
diff --git a/src/glut/beos/glutint.h b/src/glut/beos/glutint.h
deleted file mode 100644
index 06b417e9ca8..00000000000
--- a/src/glut/beos/glutint.h
+++ /dev/null
@@ -1,814 +0,0 @@
-#ifndef __glutint_h__
-#define __glutint_h__
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
-
-/* 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. */
-
-#if defined(__CYGWIN32__)
-#include <sys/time.h>
-#endif
-
-#if defined(_WIN32)
-#include "glutwin32.h"
-#elif !defined(__BEOS__)
-#ifdef __sgi
-#define SUPPORT_FORTRAN
-#endif
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <GL/glx.h>
-#endif
-
-#include <GL/glut.h>
-
-/* Non-Win32 platforms need APIENTRY defined to nothing
-   because all the GLUT routines have the APIENTRY prefix
-   to make Win32 happy. */
-#ifndef APIENTRY
-#define APIENTRY
-#endif
-
-#ifdef __vms
-#if ( __VMS_VER < 70000000 )
-struct timeval {
-  __int64 val;
-};
-extern int sys$gettim(struct timeval *);
-#else
-#include <time.h>
-#endif
-#else
-#include <sys/types.h>
-#if !defined(_WIN32)
-#include <sys/time.h>
-#else
-#include <winsock.h>
-#endif
-#endif
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-
-/* For VMS6.2 or lower :
-   One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
-   0.0001 milliseconds. This means that there are 0.01
-   ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
-   ticks/second. */
-
-#define TICKS_PER_MILLISECOND 10000
-#define TICKS_PER_SECOND      10000000
-
-#define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
-
-#define ADD_TIME(dest, src1, src2) { \
-  (dest).val = (src1).val + (src2).val; \
-}
-
-#define TIMEDELTA(dest, src1, src2) { \
-  (dest).val = (src1).val - (src2).val; \
-}
-
-#define IS_AFTER(t1, t2) ((t2).val > (t1).val)
-
-#define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
-
-#else
-#if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but
-                                       wants 2 args. */
-#define GETTIMEOFDAY(_x) gettimeofday(_x)
-#else
-#define GETTIMEOFDAY(_x) gettimeofday(_x, NULL)
-#endif
-#define ADD_TIME(dest, src1, src2) { \
-  if(((dest).tv_usec = \
-    (src1).tv_usec + (src2).tv_usec) >= 1000000) { \
-    (dest).tv_usec -= 1000000; \
-    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \
-  } else { \
-    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \
-    if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
-      (dest).tv_sec --;(dest).tv_usec += 1000000; \
-    } \
-  } \
-}
-#define TIMEDELTA(dest, src1, src2) { \
-  if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \
-    (dest).tv_usec += 1000000; \
-    (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \
-  } else { \
-     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \
-  } \
-}
-#define IS_AFTER(t1, t2) \
-  (((t2).tv_sec > (t1).tv_sec) || \
-  (((t2).tv_sec == (t1).tv_sec) && \
-  ((t2).tv_usec > (t1).tv_usec)))
-#define IS_AT_OR_AFTER(t1, t2) \
-  (((t2).tv_sec > (t1).tv_sec) || \
-  (((t2).tv_sec == (t1).tv_sec) && \
-  ((t2).tv_usec >= (t1).tv_usec)))
-#endif
-
-#define IGNORE_IN_GAME_MODE() \
-  { if (__glutGameModeWindow) return; }
-
-/* BeOS doesn't need most of this file */
-#ifndef __BEOS__
-
-#define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
-#define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
-#define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
-#define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
-#define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
-#define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
-#define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
-#define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
-#define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
-#define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
-#define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
-#define GLUT_MAP_WORK               (1 << 0)
-#define GLUT_EVENT_MASK_WORK        (1 << 1)
-#define GLUT_REDISPLAY_WORK         (1 << 2)
-#define GLUT_CONFIGURE_WORK         (1 << 3)
-#define GLUT_COLORMAP_WORK          (1 << 4)
-#define GLUT_DEVICE_MASK_WORK	    (1 << 5)
-#define GLUT_FINISH_WORK	    (1 << 6)
-#define GLUT_DEBUG_WORK		    (1 << 7)
-#define GLUT_DUMMY_WORK		    (1 << 8)
-#define GLUT_FULL_SCREEN_WORK       (1 << 9)
-#define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
-#define GLUT_REPAIR_WORK            (1 << 11)
-#define GLUT_OVERLAY_REPAIR_WORK    (1 << 12)
-
-/* Frame buffer capability macros and types. */
-#define RGBA                    0
-#define BUFFER_SIZE             1
-#define DOUBLEBUFFER            2
-#define STEREO                  3
-#define AUX_BUFFERS             4
-#define RED_SIZE                5  /* Used as mask bit for
-                                      "color selected". */
-#define GREEN_SIZE              6
-#define BLUE_SIZE               7
-#define ALPHA_SIZE              8
-#define DEPTH_SIZE              9
-#define STENCIL_SIZE            10
-#define ACCUM_RED_SIZE          11  /* Used as mask bit for
-                                       "acc selected". */
-#define ACCUM_GREEN_SIZE        12
-#define ACCUM_BLUE_SIZE         13
-#define ACCUM_ALPHA_SIZE        14
-#define LEVEL                   15
-
-#define NUM_GLXCAPS             (LEVEL + 1)
-
-#define XVISUAL                 (NUM_GLXCAPS + 0)
-#define TRANSPARENT             (NUM_GLXCAPS + 1)
-#define SAMPLES                 (NUM_GLXCAPS + 2)
-#define XSTATICGRAY             (NUM_GLXCAPS + 3)  /* Used as
-                                                      mask bit
-                                                      for "any
-                                                      visual type 
-                                                      selected". */
-#define XGRAYSCALE              (NUM_GLXCAPS + 4)
-#define XSTATICCOLOR            (NUM_GLXCAPS + 5)
-#define XPSEUDOCOLOR            (NUM_GLXCAPS + 6)
-#define XTRUECOLOR              (NUM_GLXCAPS + 7)
-#define XDIRECTCOLOR            (NUM_GLXCAPS + 8)
-#define SLOW                    (NUM_GLXCAPS + 9)
-#define CONFORMANT              (NUM_GLXCAPS + 10)
-
-#define NUM_CAPS                (NUM_GLXCAPS + 11)
-
-/* Frame buffer capablities that don't have a corresponding
-   FrameBufferMode entry.  These get used as mask bits. */
-#define NUM                     (NUM_CAPS + 0)
-#define RGBA_MODE               (NUM_CAPS + 1)
-#define CI_MODE                 (NUM_CAPS + 2)
-#define LUMINANCE_MODE		(NUM_CAPS + 3)
-
-#define NONE			0
-#define EQ			1
-#define NEQ			2
-#define LTE			3
-#define GTE			4
-#define GT			5
-#define LT			6
-#define MIN			7
-
-typedef struct _Criterion {
-  int capability;
-  int comparison;
-  int value;
-} Criterion;
-
-typedef struct _FrameBufferMode {
-  XVisualInfo *vi;
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-
-  /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable
-     (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows
-     the visual's fbconfig is OpenGL-capable.  The reason for this is typically
-     an RGBA luminance fbconfig such as 16-bit StaticGray that could
-     not be advertised as a GLX visual since StaticGray visuals are
-     required (by the GLX specification) to be color index.  The
-     SGIX_fbconfig allows StaticGray visuals to instead advertised as
-     fbconfigs that can provide RGBA luminance support. */
-
-  GLXFBConfigSGIX fbc;
-#endif
-  int valid;
-  int cap[NUM_CAPS];
-} FrameBufferMode;
-
-/* DisplayMode capability macros for game mode. */
-#define DM_WIDTH        0  /* "width" */
-#define DM_HEIGHT       1  /* "height" */
-#define DM_PIXEL_DEPTH  2  /* "bpp" (bits per pixel) */
-#define DM_HERTZ        3  /* "hertz" */
-#define DM_NUM          4  /* "num" */
-
-#define NUM_DM_CAPS     (DM_NUM+1)
-
-typedef struct _DisplayMode {
-#ifdef _WIN32
-  DEVMODE devmode;
-#else
-  /* XXX The X Window System does not have a standard
-     mechanism for display setting changes.  On SGI
-     systems, GLUT could use the XSGIvc (SGI X video
-     control extension).  Perhaps this can be done in
-     a future release of GLUT. */
-#endif
-  int valid;
-  int cap[NUM_DM_CAPS];
-} DisplayMode;
-
-#endif  /* BeOS */
-
-/* GLUT  function types */
-typedef void (*GLUTdisplayCB) (void);
-typedef void (*GLUTreshapeCB) (int, int);
-typedef void (*GLUTkeyboardCB) (unsigned char, int, int);
-typedef void (*GLUTmouseCB) (int, int, int, int);
-typedef void (*GLUTmotionCB) (int, int);
-typedef void (*GLUTpassiveCB) (int, int);
-typedef void (*GLUTentryCB) (int);
-typedef void (*GLUTvisibilityCB) (int);
-typedef void (*GLUTwindowStatusCB) (int);
-typedef void (*GLUTidleCB) (void);
-typedef void (*GLUTtimerCB) (int);
-typedef void (*GLUTmenuStateCB) (int);  /* DEPRICATED. */
-typedef void (*GLUTmenuStatusCB) (int, int, int);
-typedef void (*GLUTselectCB) (int);
-typedef void (*GLUTspecialCB) (int, int, int);
-typedef void (*GLUTspaceMotionCB) (int, int, int);
-typedef void (*GLUTspaceRotateCB) (int, int, int);
-typedef void (*GLUTspaceButtonCB) (int, int);
-typedef void (*GLUTdialsCB) (int, int);
-typedef void (*GLUTbuttonBoxCB) (int, int);
-typedef void (*GLUTtabletMotionCB) (int, int);
-typedef void (*GLUTtabletButtonCB) (int, int, int, int);
-typedef void (*GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
-#ifdef SUPPORT_FORTRAN
-typedef void (*GLUTdisplayFCB) (void);
-typedef void (*GLUTreshapeFCB) (int *, int *);
-/* NOTE the pressed key is int, not unsigned char for Fortran! */
-typedef void (*GLUTkeyboardFCB) (int *, int *, int *);
-typedef void (*GLUTmouseFCB) (int *, int *, int *, int *);
-typedef void (*GLUTmotionFCB) (int *, int *);
-typedef void (*GLUTpassiveFCB) (int *, int *);
-typedef void (*GLUTentryFCB) (int *);
-typedef void (*GLUTvisibilityFCB) (int *);
-typedef void (*GLUTwindowStatusFCB) (int *);
-typedef void (*GLUTidleFCB) (void);
-typedef void (*GLUTtimerFCB) (int *);
-typedef void (*GLUTmenuStateFCB) (int *);  /* DEPRICATED. */
-typedef void (*GLUTmenuStatusFCB) (int *, int *, int *);
-typedef void (*GLUTselectFCB) (int *);
-typedef void (*GLUTspecialFCB) (int *, int *, int *);
-typedef void (*GLUTspaceMotionFCB) (int *, int *, int *);
-typedef void (*GLUTspaceRotateFCB) (int *, int *, int *);
-typedef void (*GLUTspaceButtonFCB) (int *, int *);
-typedef void (*GLUTdialsFCB) (int *, int *);
-typedef void (*GLUTbuttonBoxFCB) (int *, int *);
-typedef void (*GLUTtabletMotionFCB) (int *, int *);
-typedef void (*GLUTtabletButtonFCB) (int *, int *, int *, int *);
-typedef void (*GLUTjoystickFCB) (unsigned int *buttonMask, int *x, int *y, int *z);
-#endif
-
-#ifndef __BEOS__
-
-typedef struct _GLUTcolorcell GLUTcolorcell;
-struct _GLUTcolorcell {
-  /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
-  GLfloat component[3];
-};
-
-typedef struct _GLUTcolormap GLUTcolormap;
-struct _GLUTcolormap {
-  Visual *visual;       /* visual of the colormap */
-  Colormap cmap;        /* X colormap ID */
-  int refcnt;           /* number of windows using colormap */
-  int size;             /* number of cells in colormap */
-  int transparent;      /* transparent pixel, or -1 if opaque */
-  GLUTcolorcell *cells; /* array of cells */
-  GLUTcolormap *next;   /* next colormap in list */
-};
-
-typedef struct _GLUTwindow GLUTwindow;
-typedef struct _GLUToverlay GLUToverlay;
-struct _GLUTwindow {
-  int num;              /* Small integer window id (0-based). */
-
-  /* Window system related state. */
-#if defined(_WIN32)
-  int pf;               /* Pixel format. */
-  HDC hdc;              /* Window's Win32 device context. */
-#endif
-  Window win;           /* X window for GLUT window */
-  GLXContext ctx;       /* OpenGL context GLUT glut window */
-  XVisualInfo *vis;     /* visual for window */
-  Bool visAlloced;      /* if vis needs deallocate on destroy */
-  Colormap cmap;        /* RGB colormap for window; None if CI */
-  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
-  GLUToverlay *overlay; /* overlay; NULL if no overlay */
-#if defined(_WIN32)
-  HDC renderDc;         /* Win32's device context for rendering. */
-#endif
-  Window renderWin;     /* X window for rendering (might be
-                           overlay) */
-  GLXContext renderCtx; /* OpenGL context for rendering (might
-                           be overlay) */
-  /* GLUT settable or visible window state. */
-  int width;            /* window width in pixels */
-  int height;           /* window height in pixels */
-  int cursor;           /* cursor name */
-  int visState;         /* visibility state (-1 is unknown) */
-  int shownState;       /* if window mapped */
-  int entryState;       /* entry state (-1 is unknown) */
-#define GLUT_MAX_MENUS              3
-
-  int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
-  /* Window relationship state. */
-  GLUTwindow *parent;   /* parent window */
-  GLUTwindow *children; /* list of children */
-  GLUTwindow *siblings; /* list of siblings */
-  /* Misc. non-API visible (hidden) state. */
-  Bool treatAsSingle;   /* treat this window as single-buffered
-                           (it might be "fake" though) */
-  Bool forceReshape;    /* force reshape before display */
-#if !defined(_WIN32)
-  Bool isDirect;        /* if direct context (X11 only) */
-#endif
-  Bool usedSwapBuffers; /* if swap buffers used last display */
-  long eventMask;       /* mask of X events selected for */
-  int buttonUses;       /* number of button uses, ref cnt */
-  int tabletPos[2];     /* tablet position (-1 is invalid) */
-  /* Work list related state. */
-  unsigned int workMask;  /* mask of window work to be done */
-  GLUTwindow *prevWorkWin;  /* link list of windows to work on */
-  Bool desiredMapState; /* how to mapped window if on map work
-                           list */
-  Bool ignoreKeyRepeat;  /* if window ignores autorepeat */
-  int desiredConfMask;  /* mask of desired window configuration
-                         */
-  int desiredX;         /* desired X location */
-  int desiredY;         /* desired Y location */
-  int desiredWidth;     /* desired window width */
-  int desiredHeight;    /* desired window height */
-  int desiredStack;     /* desired window stack */
-  /* Per-window callbacks. */
-  GLUTdisplayCB display;  /* redraw */
-  GLUTreshapeCB reshape;  /* resize (width,height) */
-  GLUTmouseCB mouse;    /* mouse (button,state,x,y) */
-  GLUTmotionCB motion;  /* motion (x,y) */
-  GLUTpassiveCB passive;  /* passive motion (x,y) */
-  GLUTentryCB entry;    /* window entry/exit (state) */
-  GLUTkeyboardCB keyboard;  /* keyboard (ASCII,x,y) */
-  GLUTkeyboardCB keyboardUp;  /* keyboard up (ASCII,x,y) */
-  GLUTwindowStatusCB windowStatus;  /* window status */
-  GLUTvisibilityCB visibility;  /* visibility */
-  GLUTspecialCB special;  /* special key */
-  GLUTspecialCB specialUp;  /* special up key */
-  GLUTbuttonBoxCB buttonBox;  /* button box */
-  GLUTdialsCB dials;    /* dials */
-  GLUTspaceMotionCB spaceMotion;  /* Spaceball motion */
-  GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate */
-  GLUTspaceButtonCB spaceButton;  /* Spaceball button */
-  GLUTtabletMotionCB tabletMotion;  /* tablet motion */
-  GLUTtabletButtonCB tabletButton;  /* tablet button */
-#ifdef _WIN32
-  GLUTjoystickCB joystick;  /* joystick */
-  int joyPollInterval; /* joystick polling interval */
-#endif
-#ifdef SUPPORT_FORTRAN
-  /* Special Fortran display  unneeded since no
-     parameters! */
-  GLUTreshapeFCB freshape;  /* Fortran reshape  */
-  GLUTmouseFCB fmouse;  /* Fortran mouse  */
-  GLUTmotionFCB fmotion;  /* Fortran motion  */
-  GLUTpassiveFCB fpassive;  /* Fortran passive  */
-  GLUTentryFCB fentry;  /* Fortran entry  */
-  GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard  */
-  GLUTkeyboardFCB fkeyboardUp;  /* Fortran keyboard up */
-  GLUTwindowStatusFCB fwindowStatus;  /* Fortran visibility
-                                          */
-  GLUTvisibilityFCB fvisibility;  /* Fortran visibility
-                                      */
-  GLUTspecialFCB fspecial;  /* special key */
-  GLUTspecialFCB fspecialUp;  /* special key up */
-  GLUTbuttonBoxFCB fbuttonBox;  /* button box */
-  GLUTdialsFCB fdials;  /* dials */
-  GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion
-                                        */
-  GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate
-                                        */
-  GLUTspaceButtonFCB fspaceButton;  /* Spaceball button
-                                        */
-  GLUTtabletMotionFCB ftabletMotion;  /* tablet motion
-                                       */
-  GLUTtabletButtonFCB ftabletButton;  /* tablet button
-                                       */
-#ifdef _WIN32
-  GLUTjoystickFCB fjoystick;  /* joystick */
-#endif
-#endif
-};
-
-struct _GLUToverlay {
-#if defined(_WIN32)
-  int pf;
-  HDC hdc;
-#endif
-  Window win;
-  GLXContext ctx;
-  XVisualInfo *vis;     /* visual for window */
-  Bool visAlloced;      /* if vis needs deallocate on destroy */
-  Colormap cmap;        /* RGB colormap for window; None if CI */
-  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
-  int shownState;       /* if overlay window mapped */
-  Bool treatAsSingle;   /* treat as single-buffered */
-#if !defined(_WIN32)
-  Bool isDirect;        /* if direct context */
-#endif
-  int transparentPixel; /* transparent pixel value */
-  GLUTdisplayCB display;  /* redraw  */
-  /* Special Fortran display  unneeded since no
-     parameters! */
-};
-
-typedef struct _GLUTstale GLUTstale;
-struct _GLUTstale {
-  GLUTwindow *window;
-  Window win;
-  GLUTstale *next;
-};
-
-extern GLUTstale *__glutStaleWindowList;
-
-#define GLUT_OVERLAY_EVENT_FILTER_MASK \
-  (ExposureMask | \
-  StructureNotifyMask | \
-  EnterWindowMask | \
-  LeaveWindowMask)
-#define GLUT_DONT_PROPAGATE_FILTER_MASK \
-  (ButtonReleaseMask | \
-  ButtonPressMask | \
-  KeyPressMask | \
-  KeyReleaseMask | \
-  PointerMotionMask | \
-  Button1MotionMask | \
-  Button2MotionMask | \
-  Button3MotionMask)
-#define GLUT_HACK_STOP_PROPAGATE_MASK \
-  (KeyPressMask | \
-  KeyReleaseMask)
-
-typedef struct _GLUTmenu GLUTmenu;
-typedef struct _GLUTmenuItem GLUTmenuItem;
-struct _GLUTmenu {
-  int id;               /* small integer menu id (0-based) */
-  Window win;           /* X window for the menu */
-  GLUTselectCB select;  /*  function of menu */
-  GLUTmenuItem *list;   /* list of menu entries */
-  int num;              /* number of entries */
-#if !defined(_WIN32)
-  Bool managed;         /* are the InputOnly windows size
-                           validated? */
-  Bool searched;	/* help detect menu loops */
-  int pixheight;        /* height of menu in pixels */
-  int pixwidth;         /* width of menu in pixels */
-#endif
-  int submenus;         /* number of submenu entries */
-  GLUTmenuItem *highlighted;  /* pointer to highlighted menu
-                                 entry, NULL not highlighted */
-  GLUTmenu *cascade;    /* currently cascading this menu  */
-  GLUTmenuItem *anchor; /* currently anchored to this entry */
-  int x;                /* current x origin relative to the
-                           root window */
-  int y;                /* current y origin relative to the
-                           root window */
-#ifdef SUPPORT_FORTRAN
-  GLUTselectFCB fselect;  /*  function of menu */
-#endif
-};
-
-struct _GLUTmenuItem {
-  Window win;           /* InputOnly X window for entry */
-  GLUTmenu *menu;       /* menu entry belongs to */
-  Bool isTrigger;       /* is a submenu trigger? */
-  int value;            /* value to return for selecting this
-                           entry; doubles as submenu id
-                           (0-base) if submenu trigger */
-#if defined(_WIN32)
-  UINT unique;          /* unique menu item id (Win32 only) */
-#endif
-  char *label;          /* __glutStrdup'ed label string */
-  int len;              /* length of label string */
-  int pixwidth;         /* width of X window in pixels */
-  GLUTmenuItem *next;   /* next menu entry on list for menu */
-};
-
-typedef struct _GLUTtimer GLUTtimer;
-struct _GLUTtimer {
-  GLUTtimer *next;      /* list of timers */
-  struct timeval timeout;  /* time to be called */
-  GLUTtimerCB func;     /* timer  (value) */
-  int value;            /*  return value */
-#ifdef SUPPORT_FORTRAN
-  GLUTtimerFCB ffunc;   /* Fortran timer  */
-#endif
-};
-
-typedef struct _GLUTeventParser GLUTeventParser;
-struct _GLUTeventParser {
-  int (*func) (XEvent *);
-  GLUTeventParser *next;
-};
-
-/* Declarations to implement glutFullScreen support with
-   mwm/4Dwm. */
-
-/* The following X property format is defined in Motif 1.1's
-   Xm/MwmUtils.h, but GLUT should not depend on that header
-   file. Note: Motif 1.2 expanded this structure with
-   uninteresting fields (to GLUT) so just stick with the
-   smaller Motif 1.1 structure. */
-typedef struct {
-#define MWM_HINTS_DECORATIONS   2
-  long flags;
-  long functions;
-  long decorations;
-  long input_mode;
-} MotifWmHints;
-
-/* Make current and buffer swap macros. */
-#ifdef _WIN32
-#define MAKE_CURRENT_LAYER(window)                                    \
-  {                                                                   \
-    HGLRC currentContext = wglGetCurrentContext();                    \
-    HDC currentDc = wglGetCurrentDC();                                \
-                                                                      \
-    if (currentContext != window->renderCtx                           \
-      || currentDc != window->renderDc) {                             \
-      wglMakeCurrent(window->renderDc, window->renderCtx);            \
-    }                                                                 \
-  }
-#define MAKE_CURRENT_WINDOW(window)                                   \
-  {                                                                   \
-    HGLRC currentContext = wglGetCurrentContext();                    \
-    HDC currentDc = wglGetCurrentDC();                                \
-                                                                      \
-    if (currentContext != window->ctx || currentDc != window->hdc) {  \
-      wglMakeCurrent(window->hdc, window->ctx);                       \
-    }                                                                 \
-  }
-#define MAKE_CURRENT_OVERLAY(overlay) \
-  wglMakeCurrent(overlay->hdc, overlay->ctx)
-#define UNMAKE_CURRENT() \
-  wglMakeCurrent(NULL, NULL)
-#define SWAP_BUFFERS_WINDOW(window) \
-  SwapBuffers(window->hdc)
-#define SWAP_BUFFERS_LAYER(window) \
-  SwapBuffers(window->renderDc)
-#else
-#define MAKE_CURRENT_LAYER(window) \
-  glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx)
-#define MAKE_CURRENT_WINDOW(window) \
-  glXMakeCurrent(__glutDisplay, window->win, window->ctx)
-#define MAKE_CURRENT_OVERLAY(overlay) \
-  glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx)
-#define UNMAKE_CURRENT() \
-  glXMakeCurrent(__glutDisplay, None, NULL)
-#define SWAP_BUFFERS_WINDOW(window) \
-  glXSwapBuffers(__glutDisplay, window->win)
-#define SWAP_BUFFERS_LAYER(window) \
-  glXSwapBuffers(__glutDisplay, window->renderWin)
-#endif
-
-/* private variables from glut_event.c */
-extern GLUTwindow *__glutWindowWorkList;
-extern int __glutWindowDamaged;
-#ifdef SUPPORT_FORTRAN
-extern GLUTtimer *__glutTimerList;
-extern GLUTtimer *__glutNewTimer;
-#endif
-extern GLUTmenu *__glutMappedMenu;
-
-extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
-#if !defined(_WIN32)
-extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item,
-  int num, int type);
-extern void (*__glutFinishMenu)(Window win, int x, int y);
-extern void (*__glutPaintMenu)(GLUTmenu * menu);
-extern void (*__glutStartMenu)(GLUTmenu * menu,
-  GLUTwindow * window, int x, int y, int x_win, int y_win);
-extern GLUTmenu * (*__glutGetMenuByNum)(int menunum);
-extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu,
-  Window win, int *which);
-extern GLUTmenu * (*__glutGetMenu)(Window win);
-#endif
-
-/* private variables from glut_init.c */
-extern Atom __glutWMDeleteWindow;
-extern Display *__glutDisplay;
-extern unsigned int __glutDisplayMode;
-extern char *__glutDisplayString;
-extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc);
-extern GLboolean __glutDebug;
-extern GLboolean __glutForceDirect;
-extern GLboolean __glutIconic;
-extern GLboolean __glutTryDirect;
-extern Window __glutRoot;
-extern XSizeHints __glutSizeHints;
-extern char **__glutArgv;
-#endif  /* BeOS */
-extern char *__glutProgramName;
-#ifndef __BEOS__
-extern int __glutArgc;
-extern int __glutConnectionFD;
-extern int __glutInitHeight;
-extern int __glutInitWidth;
-extern int __glutInitX;
-extern int __glutInitY;
-extern int __glutScreen;
-extern int __glutScreenHeight;
-extern int __glutScreenWidth;
-extern Atom __glutMotifHints;
-extern unsigned int __glutModifierMask;
-
-/* private variables from glut_menu.c */
-extern GLUTmenuItem *__glutItemSelected;
-extern GLUTmenu **__glutMenuList;
-extern void (*__glutMenuStatusFunc) (int, int, int);
-extern void __glutMenuModificationError(void);
-extern void __glutSetMenuItem(GLUTmenuItem * item,
-  const char *label, int value, Bool isTrigger);
-
-/* private variables from glut_win.c */
-extern GLUTwindow **__glutWindowList;
-extern GLUTwindow *__glutCurrentWindow;
-extern GLUTwindow *__glutMenuWindow;
-extern GLUTmenu *__glutCurrentMenu;
-extern int __glutWindowListSize;
-extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
-extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle,
-  Bool * visAlloced, void **fbc);
-
-/* private variables from glut_mesa.c */
-extern int __glutMesaSwapHackSupport;
-
-/* private variables from glut_gamemode.c */
-extern GLUTwindow *__glutGameModeWindow;
-
-/* private routines from glut_cindex.c */
-extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis);
-extern void __glutFreeColormap(GLUTcolormap *);
-
-/* private routines from glut_cmap.c */
-extern void __glutSetupColormap(
-  XVisualInfo * vi,
-  GLUTcolormap ** colormap,
-  Colormap * cmap);
-#if !defined(_WIN32)
-extern void __glutEstablishColormapsProperty(
-  GLUTwindow * window);
-extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
-#endif
-
-/* private routines from glut_cursor.c */
-extern void __glutSetCursor(GLUTwindow *window);
-
-/* private routines from glut_event.c */
-extern void __glutPutOnWorkList(GLUTwindow * window,
-  int work_mask);
-extern void __glutRegisterEventParser(GLUTeventParser * parser);
-extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
-
-/* private routines from glut_init.c */
-#if !defined(_WIN32)
-extern void __glutOpenXConnection(char *display);
-#else
-extern void __glutOpenWin32Connection(char *display);
-#endif
-extern void __glutInitTime(struct timeval *beginning);
-
-/* private routines for glut_menu.c (or win32_menu.c) */
-#if defined(_WIN32)
-extern GLUTmenu *__glutGetMenu(Window win);
-extern GLUTmenu *__glutGetMenuByNum(int menunum);
-extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
-  Window win, int *which);
-extern void __glutStartMenu(GLUTmenu * menu,
-  GLUTwindow * window, int x, int y, int x_win, int y_win);
-extern void __glutFinishMenu(Window win, int x, int y);
-#endif
-extern void __glutSetMenu(GLUTmenu * menu);
-
-#endif  /* BeOS */
-#ifdef __cplusplus
-extern "C" {
-#endif
-/* private routines from glut_util.c */
-extern char * __glutStrdup(const char *string);
-extern void __glutWarning(char *format,...);
-extern void __glutFatalError(char *format,...);
-extern void __glutFatalUsage(char *format,...);
-#ifdef __cplusplus
-}
-#endif
-#ifndef __BEOS__
-
-/* private routines from glut_win.c */
-extern GLUTwindow *__glutGetWindow(Window win);
-extern void __glutChangeWindowEventMask(long mask, Bool add);
-extern XVisualInfo *__glutDetermineVisual(
-  unsigned int mode,
-  Bool * fakeSingle,
-  XVisualInfo * (getVisualInfo) (unsigned int));
-extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
-extern void __glutSetWindow(GLUTwindow * window);
-extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
-  int callingConvention);
-extern void  __glutDefaultReshape(int, int);
-extern GLUTwindow *__glutCreateWindow(
-  GLUTwindow * parent,
-  int x, int y, int width, int height, int gamemode);
-extern void __glutDestroyWindow(
-  GLUTwindow * window,
-  GLUTwindow * initialWindow);
-
-#if !defined(_WIN32)
-/* private routines from glut_glxext.c */
-extern int __glutIsSupportedByGLX(char *);
-#endif
-
-/* private routines from glut_input.c */
-extern void  __glutUpdateInputDeviceMask(GLUTwindow * window);
-
-/* private routines from glut_mesa.c */
-extern void __glutDetermineMesaSwapHackSupport(void);
-
-/* private routines from glut_gameglut.c */
-extern void __glutCloseDownGameMode(void);
-
-#if defined(_WIN32)
-/* private routines from win32_*.c */
-extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l);
-extern HDC XHDC;
-#endif
-
-#else  /* BeOS */
-/* BeOS specific C++ function prototypes */
-#ifdef __cplusplus
-
-#include <SupportDefs.h>
-
-/* private routines from glutInit.cpp */
-void __glutInitTime(bigtime_t *beginning);
-void __glutInit();
-
-/* private routines from glutMenu.cpp */
-class GlutMenu;         // avoid including glutMenu.h
-GlutMenu *__glutGetMenuByNum(int menunum);
-
-/* private routines from glutWindow.cpp */
-int __glutConvertDisplayMode(unsigned long *options);
-void __glutDefaultReshape(int width, int height);
-class GlutWindow;       // avoid including glutWindow.h in every source file
-void __glutSetWindow(GlutWindow * window);
-void __glutDestroyAllWindows();
-
-/* private routines from glutDstr.cpp */
-int __glutConvertDisplayModeFromString(unsigned long *options);
-
-/* private routines from glutCursor.cpp */
-void __glutSetCursor(int cursor);
-
-#endif /* __cplusplus */
-#endif  /* BeOS */
-
-#endif /* __glutint_h__ */
diff --git a/src/glut/beos/glutstroke.h b/src/glut/beos/glutstroke.h
deleted file mode 100644
index cbc9e156fea..00000000000
--- a/src/glut/beos/glutstroke.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#ifndef __glutstroke_h__
-#define __glutstroke_h__
-
-/* 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. */
-
-#if defined(_WIN32)
-#pragma warning (disable:4244)  /* disable bogus conversion warnings */
-#pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
-#endif
-
-typedef struct {
-  float x;
-  float y;
-} CoordRec, *CoordPtr;
-
-typedef struct {
-  int num_coords;
-  const CoordRec *coord;
-} StrokeRec, *StrokePtr;
-
-typedef struct {
-  int num_strokes;
-  const StrokeRec *stroke;
-  float center;
-  float right;
-} StrokeCharRec, *StrokeCharPtr;
-
-typedef struct {
-  const char *name;
-  int num_chars;
-  const StrokeCharRec *ch;
-  float top;
-  float bottom;
-} StrokeFontRec, *StrokeFontPtr;
-
-typedef void *GLUTstrokeFont;
-
-#endif /* __glutstroke_h__ */
diff --git a/src/glut/glx/Makefile b/src/glut/glx/Makefile
deleted file mode 100644
index 69f8052c092..00000000000
--- a/src/glut/glx/Makefile
+++ /dev/null
@@ -1,140 +0,0 @@
-# Makefile for GLUT
-#
-# NOTICE:  The OpenGL Utility Toolkit (GLUT) distribution contains source
-# code published in a book titled "Programming OpenGL for the X Window
-# System" (ISBN: 0-201-48359-9) published by Addison-Wesley.  The
-# programs and associated files contained in the distribution were
-# developed by Mark J. Kilgard and are Copyright 1994, 1995, 1996 by Mark
-# J. Kilgard (unless otherwise noted).  The programs are not in the
-# public domain, but they are freely distributable without licensing
-# fees.  These programs are provided without guarantee or warrantee
-# expressed or implied.
-#
-# GLUT source included with Mesa with permission from Mark Kilgard.
-
-
-TOP = ../../..
-
-include $(TOP)/configs/current
-
-
-##### MACROS #####
-
-GLUT_MAJOR = 3
-GLUT_MINOR = 7
-GLUT_TINY = 1
-
-SOURCES = \
-	glut_8x13.c \
-	glut_9x15.c \
-	glut_bitmap.c \
-	glut_bwidth.c \
-	glut_cindex.c \
-	glut_cmap.c \
-	glut_cursor.c \
-	glut_dials.c \
-	glut_dstr.c \
-	glut_event.c \
-	glut_ext.c \
-	glut_fcb.c \
-	glut_fullscrn.c \
-	glut_gamemode.c \
-	glut_get.c \
-	glut_glxext.c \
-	glut_hel10.c \
-	glut_hel12.c \
-	glut_hel18.c \
-	glut_init.c \
-	glut_input.c \
-	glut_joy.c \
-	glut_key.c \
-	glut_keyctrl.c \
-	glut_keyup.c \
-	glut_menu.c \
-	glut_menu2.c \
-	glut_mesa.c \
-	glut_modifier.c \
-	glut_mroman.c \
-	glut_overlay.c \
-	glut_ppm.c \
-	glut_roman.c \
-	glut_shapes.c \
-	glut_space.c \
-	glut_stroke.c \
-	glut_swap.c \
-	glut_swidth.c \
-	glut_tablet.c \
-	glut_teapot.c \
-	glut_tr10.c \
-	glut_tr24.c \
-	glut_util.c \
-	glut_vidresize.c \
-	glut_warp.c \
-	glut_win.c \
-	glut_winmisc.c \
-	layerutil.c
-
-
-OBJECTS = $(SOURCES:.c=.o)
-
-
-##### RULES #####
-
-.c.o:
-	$(CC) -c -I$(TOP)/include $(X11_INCLUDES) $(CFLAGS) $(GLUT_CFLAGS) $<
-
-
-
-##### TARGETS #####
-
-default: $(TOP)/$(LIB_DIR)/$(GLUT_LIB_NAME)
-
-
-# Make the library
-$(TOP)/$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS)
-	$(MKLIB) -o $(GLUT_LIB) -linker '$(CC)' -ldflags '$(LDFLAGS)' \
-		-major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \
-		$(MKLIB_OPTIONS) -install $(TOP)/$(LIB_DIR) \
-		-id $(INSTALL_LIB_DIR)/lib$(GLUT_LIB).$(GLUT_MAJOR).dylib \
-		$(GLUT_LIB_DEPS) $(OBJECTS)
-
-
-# glut pkgconfig file
-pcedit = sed \
-	-e 's,@INSTALL_DIR@,$(INSTALL_DIR),' \
-	-e 's,@INSTALL_LIB_DIR@,$(INSTALL_LIB_DIR),' \
-	-e 's,@INSTALL_INC_DIR@,$(INSTALL_INC_DIR),' \
-	-e 's,@VERSION@,$(GLUT_MAJOR).$(GLUT_MINOR).$(GLUT_TINY),' \
-	-e 's,@GLUT_PC_REQ_PRIV@,$(GLUT_PC_REQ_PRIV),' \
-	-e 's,@GLUT_PC_LIB_PRIV@,$(GLUT_PC_LIB_PRIV),' \
-	-e 's,@GLUT_PC_CFLAGS@,$(GLUT_PC_CFLAGS),' \
-	-e 's,@GLUT_LIB@,$(GLUT_LIB),'
-glut.pc: glut.pc.in
-	$(pcedit) $< > $@
-
-install: glut.pc
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -d $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-	$(INSTALL) -m 644 $(TOP)/include/GL/glut.h $(DESTDIR)$(INSTALL_INC_DIR)/GL
-	$(MINSTALL) $(TOP)/$(LIB_DIR)/$(GLUT_LIB_GLOB) $(DESTDIR)$(INSTALL_LIB_DIR)
-	$(INSTALL) -m 644 glut.pc $(DESTDIR)$(INSTALL_LIB_DIR)/pkgconfig
-
-
-clean:
-	-rm -f *.o *~
-	-rm -f *.lo
-	-rm -f *.la
-	-rm -f *.pc
-	-rm -rf .libs
-	-rm -f depend depend.bak
-
-
-depend: $(SOURCES)
-	@ echo "running $(MKDEP)"
-	@ rm -f depend
-	@ touch depend
-	@ $(MKDEP) $(MKDEP_OPTIONS) -I$(TOP)/include $(SOURCES) \
-		$(X11_INCLUDES) > /dev/null 
-
--include depend
diff --git a/src/glut/glx/Makefile.cygnus b/src/glut/glx/Makefile.cygnus
deleted file mode 100644
index 5d5fa6912c5..00000000000
--- a/src/glut/glx/Makefile.cygnus
+++ /dev/null
@@ -1,110 +0,0 @@
-# Makefile.cygnus for Cygnus-Win32 target
-# /Stephane Rehel, November 16 1997
-
-# Makefile for GLUT 3.7
-#
-# NOTICE:  The OpenGL Utility Toolkit (GLUT) distribution contains source
-# code published in a book titled "Programming OpenGL for the X Window
-# System" (ISBN: 0-201-48359-9) published by Addison-Wesley.  The
-# programs and associated files contained in the distribution were
-# developed by Mark J. Kilgard and are Copyright 1994, 1995, 1996 by Mark
-# J. Kilgard (unless otherwise noted).  The programs are not in the
-# public domain, but they are freely distributable without licensing
-# fees.  These programs are provided without guarantee or warrantee
-# expressed or implied.
-#
-# GLUT source included with Mesa with permission from Mark Kilgard.
-
-
-##### MACROS #####
-
-GLUT_MAJOR = 3
-GLUT_MINOR = 7
-GLUT_TINY = 0
-
-VPATH = RCS
-
-INCDIR = ../include
-LIBDIR = ../lib
-
-SOURCES = \
-	glut_8x13.c \
-	glut_9x15.c \
-	glut_bitmap.c \
-	glut_bwidth.c \
-	glut_cindex.c \
-	glut_cmap.c \
-	glut_cursor.c \
-	glut_dials.c \
-	glut_dstr.c \
-	glut_event.c \
-	glut_ext.c \
-	glut_fullscrn.c \
-	glut_get.c \
-	glut_hel10.c \
-	glut_hel12.c \
-	glut_hel18.c \
-	glut_init.c \
-	glut_input.c \
-	glut_mesa.c \
-	glut_modifier.c \
-	glut_mroman.c \
-	glut_overlay.c \
-	glut_roman.c \
-	glut_shapes.c \
-	glut_space.c \
-	glut_stroke.c \
-	glut_swap.c \
-	glut_swidth.c \
-	glut_tablet.c \
-	glut_teapot.c \
-	glut_tr10.c \
-	glut_tr24.c \
-	glut_util.c \
-	glut_vidresize.c \
-	glut_warp.c \
-	glut_win.c \
-	glut_winmisc.c \
-	win32_x11.c \
-	win32_glx.c \
-	win32_menu.c \
-	win32_util.c 
-
-OBJECTS = $(SOURCES:.c=.o)
-
-
-
-##### RULES #####
-
-.c.o:
-	$(CC) -c -I$(INCDIR) $(CFLAGS) $<
-
-
-
-##### TARGETS #####
-
-default:
-	@echo "Specify a target configuration"
-
-clean:
-	-rm *.o *~
-
-targets: $(LIBDIR)/$(GLUT_LIB)
-
-# Make the library
-$(LIBDIR)/$(GLUT_LIB): $(OBJECTS)
-	$(MAKELIB) $(GLUT_LIB) $(GLUT_MAJOR) $(GLUT_MINOR) $(GLUT_TINY) $(OBJECTS)
-	mv $(GLUT_LIB)* $(LIBDIR)
-
-include ../Make-config
-
-include depend
-
-
-
-#
-# Run 'make dep' to update the dependencies if you change what's included
-# by any source file.
-# 
-dep: $(SOURCES)
-	makedepend -fdepend -Y -I../include $(SOURCES)
diff --git a/src/glut/glx/Makefile.mgw b/src/glut/glx/Makefile.mgw
deleted file mode 100644
index 5e1fde03de2..00000000000
--- a/src/glut/glx/Makefile.mgw
+++ /dev/null
@@ -1,191 +0,0 @@
-# Mesa 3-D graphics library
-# Version:  5.1
-# 
-# Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
-# 
-# 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
-# BRIAN PAUL 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.
-
-# MinGW core makefile v1.4 for Mesa
-#
-#  Copyright (C) 2002 - Daniel Borca
-#  Email : [email protected]
-#  Web   : http://www.geocities.com/dborca
-
-# MinGW core-glut makefile updated for Mesa 7.0
-#
-#  Updated : by Heromyth, on 2007-7-21
-#  Email   : [email protected]
-#  Bugs    : 1) All the default settings work fine. But the setting X86=1 can't work. 
-#            The others havn't been tested yet.
-#            2) The generated DLLs are *not* compatible with the ones built
-#            with the other compilers like VC8, especially for GLUT. 
-#            3) Although more tests are needed, it can be used individually!
-
-
-#
-#  Available options:
-#
-#    Environment variables:
-#	CFLAGS
-#
-#	GLIDE		path to Glide3 SDK; used with FX.
-#			default = $(TOP)/glide3
-#	FX=1		build for 3dfx Glide3. Note that this disables
-#			compilation of most WMesa code and requires fxMesa.
-#			As a consequence, you'll need the Win32 Glide3
-#			library to build any application.
-#			default = no
-#	ICD=1		build the installable client driver interface
-#			(windows opengl driver interface)
-#			default = no
-#	X86=1		optimize for x86 (if possible, use MMX, SSE, 3DNow).
-#			default = no
-#
-#    Targets:
-#	all:		build GL
-#	clean:		remove object files
-#
-
-
-
-.PHONY: all clean
-.INTERMEDIATE: x86/gen_matypes.exe
-.SUFFIXES: .rc .res
-
-# Set this to the prefix of your build tools, i.e. mingw32-
-TOOLS_PREFIX = mingw32-
-
-TOP = ../../..
-
-LIBDIR = $(TOP)/lib
-
-LIB_NAME = glut32
-
-DLL_EXT = .dll
-IMP_EXT = .a
-LIB_PRE = lib
-STRIP = -s
-
-AR = ar
-ARFLAGS = crus
-DLLTOOL = dlltool
-
-GLUT_DLL = $(LIB_NAME)$(DLL_EXT)
-GLUT_IMP = $(LIB_PRE)$(LIB_NAME)$(IMP_EXT)
-GLUT_DEF = $(LIB_NAME).def
-
-LDLIBS = -L$(LIBDIR) -lwinmm -lgdi32 -luser32 -lopengl32 -lglu32 
-LDFLAGS = $(STRIP) -shared -fPIC -Wl,--kill-at
-
-CFLAGS += -DBUILD_GLUT32 -DGLUT_BUILDING_LIB -DMESA -D_DLL
-CFLAGS += -DNDEBUG -DLIBRARYBUILD -I$(TOP)/include 
-
-CC = $(TOOLS_PREFIX)gcc
-CXX = $(TOOLS_PREFIX)g++
-CXXFLAGS = $(CFLAGS)
-
-AR = ar
-ARFLAGS = crus
-
-UNLINK = del $(subst /,\,$(1))
-ifneq ($(wildcard $(addsuffix /rm.exe,$(subst ;, ,$(PATH)))),)
-UNLINK = $(RM) $(1)
-endif
-ifneq ($(wildcard $(addsuffix /rm,$(subst :, ,$(PATH)))),)
-UNLINK = $(RM) $(1)
-endif
-
-HDRS = glutint.h glutstroke.h glutbitmap.h glutwin32.h stroke.h win32_glx.h win32_x11.h
-
-SRCS = \
-	glut_bitmap.c \
-	glut_bwidth.c \
-	glut_cindex.c \
-	glut_cmap.c \
-	glut_cursor.c \
-	glut_dials.c \
-	glut_dstr.c \
-	glut_event.c \
-	glut_ext.c \
-	glut_fcb.c \
-	glut_fullscrn.c \
-	glut_gamemode.c \
-	glut_get.c \
-	glut_init.c \
-	glut_input.c \
-	glut_joy.c \
-	glut_key.c \
-	glut_keyctrl.c \
-	glut_keyup.c \
-	glut_mesa.c \
-	glut_modifier.c \
-	glut_overlay.c \
-	glut_shapes.c \
-	glut_space.c \
-	glut_stroke.c \
-	glut_swap.c \
-	glut_swidth.c \
-	glut_tablet.c \
-	glut_teapot.c \
-	glut_util.c \
-	glut_vidresize.c \
-	glut_warp.c \
-	glut_win.c \
-	glut_winmisc.c \
-	win32_glx.c \
-	win32_menu.c \
-	win32_util.c \
-	win32_winproc.c \
-	win32_x11.c
-	
-
-SRCSSEMIGENS = \
-	glut_8x13.c \
-	glut_9x15.c \
-	glut_hel10.c \
-	glut_hel12.c \
-	glut_hel18.c \
-	glut_mroman.c \
-	glut_roman.c \
-	glut_tr10.c \
-	glut_tr24.c
-
-
-
-SOURCES = $(SRCS) $(SRCSSEMIGENS)
-
-OBJECTS = $(addsuffix .o,$(basename $(SOURCES)))
-
-.c.o:
-	$(CC) -o $@ $(CFLAGS) -c $<
-.cc.o:
-	$(CXX) -o $@ $(CXXFLAGS) -c $<
-
-
-all: $(LIBDIR) $(LIBDIR)/$(GLUT_DLL) $(LIBDIR)/$(GLUT_IMP)
-
-$(LIBDIR):
-	mkdir -p $(LIBDIR)
-
-$(LIBDIR)/$(GLUT_DLL) $(LIBDIR)/$(GLUT_IMP): $(OBJECTS)
-	$(CXX) $(LDFLAGS) -o $(LIBDIR)/$(GLUT_DLL) $^ $(LDLIBS)
-	$(DLLTOOL) --as=as --dllname $(LIB_NAME) --output-def $(LIBDIR)/$(GLUT_DEF) $^
-	$(DLLTOOL) --as=as -k --dllname $(LIB_NAME) --output-lib $(LIBDIR)/$(GLUT_IMP) --def $(LIBDIR)/$(GLUT_DEF) 
-
-clean:
-	-$(call UNLINK,*.o)
\ No newline at end of file
diff --git a/src/glut/glx/Makefile.sgi b/src/glut/glx/Makefile.sgi
deleted file mode 100644
index 9514c324d24..00000000000
--- a/src/glut/glx/Makefile.sgi
+++ /dev/null
@@ -1,189 +0,0 @@
-#! smake
-#
-# Copyright (c) Mark J. Kilgard, 1995, 1998.
-#
-include $(ROOT)/usr/include/make/commondefs
-
-# NOTE:  In my GLUT development tree, many of the C source files for
-# GLUT are generated.  For this reason, "make full_clobber" will remove
-# these generated C files, while "make clobber" will not.
-
-TOP = ../..
-
-TARGETS = libglut.a
-
-LN = ln -s
-MV = mv
-RM = -rm -rf
-
-HDRS = glutint.h glutstroke.h layerutil.h glutbitmap.h
-
-SRCS = \
-	glut_bitmap.c \
-	glut_bwidth.c \
-	glut_cindex.c \
-	glut_cmap.c \
-	glut_cursor.c \
-	glut_dials.c \
-	glut_dstr.c \
-	glut_event.c \
-	glut_ext.c \
-	glut_fbc.c \
-	glut_fullscrn.c \
-	glut_gamemode.c \
-	glut_get.c \
-	glut_glxext.c \
-	glut_init.c \
-	glut_input.c \
-	glut_joy.c \
-	glut_key.c \
-	glut_keyctrl.c \
-	glut_keyup.c \
-	glut_menu.c \
-	glut_menu2.c \
-	glut_mesa.c \
-	glut_modifier.c \
-	glut_overlay.c \
-	glut_shapes.c \
-	glut_space.c \
-	glut_stroke.c \
-	glut_swap.c \
-	glut_swidth.c \
-	glut_tablet.c \
-	glut_teapot.c \
-	glut_util.c \
-	glut_vidresize.c \
-	glut_warp.c \
-	glut_win.c \
-	glut_winmisc.c \
-	layerutil.c
-
-SRCSSEMIGENS = \
-	glut_8x13.c \
-	glut_9x15.c \
-	glut_hel10.c \
-	glut_hel12.c \
-	glut_hel18.c \
-	glut_mroman.c \
-	glut_roman.c \
-	glut_tr10.c \
-	glut_tr24.c
-
-OBJS = $(SRCS:.c=.o) $(SRCSSEMIGENS:.c=.o)
-OTHERGENS = y.tab.c y.tab.h strokegen.c strokegen.h strokelex.c
-OTHERSRCS = strokegen.y strokelex.l stroke.h
-FONTS = Roman.stroke MonoRoman.stroke
-
-# Uncomment the LCDEFS line below if you want to build a version of
-# libglut.a that avoids using the SGI "fast atoms" optimization
-# introduced in IRIX 6.3.  This optimization eliminates serveral X server
-# round-trips.  If you are building libglut.a on an IRIX 6.3 or later
-# machine and want a chance (no guarantees) that GLUT executables built
-# against your libglut.a will work on IRIX 6.2 machines, uncomment out
-# the LCDEFS line below.  Otherwise, you'll get a run-time message about
-# "attempted access to unresolvable symbol in XXX: _XSGIFastInternAtom"
-#LCDEFS = -DNO_FAST_ATOMS
-
-LCOPTS = -I$(TOP)/include -fullwarn 
-LWOFF = ,813,852,827,826
-LDIRT = *~ $(OTHERGENS) strokegen *.bak hardcopy glutsrc.ps capturexfont *.pure dstr dstr.c *.gen
-
-default: $(TARGETS)
-
-sinclude ObjectType.mk
-
-$(OBJS) : $(HDRS)
-
-libglut.a : $(OBJS)
-	$(RM) $@
-	$(AR) crl $@ $(OBJS)
-
-.ORDER : strokegen.h strokegen.c
-
-strokegen.h strokegen.c : strokegen.y
-	$(YACC) -d strokegen.y
-	$(MV) y.tab.c strokegen.c
-	$(MV) y.tab.h strokegen.h
-
-# avoid warnings when compiling lex generated code
-strokegen.o : strokegen.c
-	$(CC) $(CFLAGS) -woff 726,825,635,818,819,820,824,831,835,822,821,1167,1498,1116,1136,1174,1196,803 -c -MDupdate Makedepend strokegen.c
-
-strokelex.c : strokelex.l
-	$(LEX) strokelex.l
-	$(MV) lex.yy.c strokelex.c
-
-# avoid warnings when compiling lex generated code
-strokelex.o : strokelex.c
-	$(CC) $(CFLAGS) -woff 831,825,817,835,702,819,635,824,822,1167,1498,1110,1196,1174,803 -c -MDupdate Makedepend strokelex.c
-
-strokegen : strokegen.o strokelex.o
-	$(CC) -o $@ $(LDFLAGS) strokegen.o strokelex.o -ll
-
-capturexfont : capturexfont.o
-	$(CC) -o $@ $(LDFLAGS) capturexfont.o -lX11
-
-# glut_roman.c and glut_mroman.c are now checked in, but here are rules to generate them
-glut_roman.c.gen : Roman.stroke strokegen
-	./strokegen -s glutStrokeRoman < Roman.stroke > $@
-glut_mroman.c.gen : MonoRoman.stroke strokegen
-	./strokegen -s glutStrokeMonoRoman < MonoRoman.stroke > $@
-
-glutsrc.ps : $(SRCS)
-	$(RM) hardcopy
-	mkdir -p hardcopy
-	for i in $(SRCS) ;\
-	do \
-	  grep -v CENTRY $$i | grep -v INDENT- > hardcopy/$$i; \
-	done
-	cd hardcopy ; enscript -p ../$@ -G -2r `echo $(SRCS) | fmt -1 | sort`
-	$(RM) hardcopy
-
-# The bitmap files can be generated using capturexfont, but because
-# they require a connection to an X server and potentially different
-# X servers have different fonts, these generated files are part
-# of the GLUT distribution.
-
-9_BY_15 = -misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1
-8_BY_13 = -misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1
-TR10 = -adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1
-TR24 = -adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1
-HEL10 = -adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1
-HEL12 = -adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1
-HEL18 = -adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1
-
-semigens : capturexfont
-	./capturexfont $(9_BY_15) glutBitmap9By15 > glut_9x15.c.gen
-	./capturexfont $(8_BY_13) glutBitmap8By13 > glut_8x13.c.gen
-	./capturexfont $(TR10) glutBitmapTimesRoman10 > glut_tr10.c.gen
-	./capturexfont $(TR24) glutBitmapTimesRoman24 > glut_tr24.c.gen
-	./capturexfont $(HEL10) glutBitmapHelvetica10 > glut_hel10.c.gen
-	./capturexfont $(HEL12) glutBitmapHelvetica12 > glut_hel12.c.gen
-	./capturexfont $(HEL18) glutBitmapHelvetica18 > glut_hel18.c.gen
-
-# unused test rule for test building 16-bit font
-JIS = -jis-fixed-medium-r-normal--24-230-75-75-c-240-jisx0208.1983-0
-glut_jis.c : 
-	./capturexfont $(JIS) glutBitmapJis > $@
-
-sources: $(SRCS)
-
-symcheck: libglut.a
-	-nm -Bo libglut.a | grep -v ' d ' | grep -v ' T glut' | grep -v ' D glut' | grep -v ' U ' | grep -v ' T __glut' | grep -v ' t ' | grep -v ' b ' | grep -v ' D __glut' | grep -v ' B __glut'
-
-dstr.c: glut_dstr.c
-	ln -s glut_dstr.c $@
-
-dstr: dstr.c glut_util.o glut_glxext.o
-	$(RM) $@
-	$(CC) -g -o $@ $(CFLAGS) -DTEST dstr.c glut_util.o glut_glxext.o -lGLU -lGL -lXext -lX11 -lm
-
-./glut.h : glut.h
-./glutint.h : glutint.h
-./glutstroke.h : glutstroke.h
-./strokegen.h : strokegen.h
-./stroke.h : stroke.h
-./layerutil.h : layerutil.h
-strokelex.o: strokelex.c strokegen.h
-
-include $(COMMONRULES)
diff --git a/src/glut/glx/Makefile.win b/src/glut/glx/Makefile.win
deleted file mode 100644
index 4ce7f6fc714..00000000000
--- a/src/glut/glx/Makefile.win
+++ /dev/null
@@ -1,99 +0,0 @@
-# Makefile for Win32
-
-!include <win32.mak>
-
-TOP = ..
-
-# NOTE: glut_menu.c and glut_glxext.c are NOT compiled into Win32 GLUT
-
-SRCS = glut_8x13.c glut_9x15.c glut_bitmap.c glut_bwidth.c glut_cindex.c glut_cmap.c glut_cursor.c glut_dials.c glut_dstr.c glut_event.c glut_ext.c glut_fbc.c glut_fullscrn.c glut_gamemode.c glut_get.c glut_hel10.c glut_hel12.c glut_hel18.c glut_init.c glut_input.c glut_joy.c glut_key.c glut_keyctrl.c glut_keyup.c glut_mesa.c glut_modifier.c glut_mroman.c glut_overlay.c glut_roman.c glut_shapes.c glut_space.c glut_stroke.c glut_swap.c glut_swidth.c glut_tablet.c glut_teapot.c glut_tr10.c glut_tr24.c glut_util.c glut_vidresize.c glut_warp.c glut_win.c glut_winmisc.c win32_glx.c win32_menu.c win32_util.c win32_winproc.c win32_x11.c
-
-all	: glutdll 
-
-!include "$(TOP)/mesawin32.mak"
-
-glutdll	: $(GLUTDLL)
-
-!IFDEF NODEBUG
-OPTIMIZE_CFLAGS = -DNDEBUG
-!ENDIF
-
-CFLAGS = $(cvarsdll) $(CFLAGS) $(OPTIMIZE_CFLAGS) -DMESA -DBUILD_GL32
-LFLAGS = $(dlllflags) $(lcommon) $(LFLAGS)
-
-OBJS   = $(SRCS:.c=.obj)
-MS_LIBS   = ../lib/$(MESALIB) ../lib/$(GLULIB) winmm.lib $(guilibsdll)
-SGI_LIBS   = $(SGI_OPENGL) $(SGI_GLU) winmm.lib $(guilibsdll)
-
-MesaGlut.dll : $(OBJS) glut.def
-	$(link) $(LFLAGS) -out:MesaGlut.dll -def:glut.def $(OBJS) $(MS_LIBS)
-	@echo "copying GLUT dynamic link library to lib directory..."
-	-copy $(GLUTDLL) ..\lib
-	@echo "copying GLUT import library to lib directory..."
-	-copy $(GLUTLIB) ..\lib
-
-glut.dll : $(OBJS) glut.def
-	$(link) $(LFLAGS) -out:glut.dll -def:glut.def $(OBJS) $(SGI_LIBS)
-
-install	: $(GLUTDLL)
-	@echo "copying GLUT dynamic link library to system directory..."
-	-copy $(GLUTDLL) $(DLLINSTALL)
-	@echo "copying GLUT header file to include directory..."
-	-copy ..\include\GL\glut.h $(INCLUDEINSTALL)
-	@echo "copying GLUT import library to library directory..."
-	-copy $(GLUTLIB) $(LIBINSTALL)
-
-.c.obj	:
-	$(cc)   $(CFLAGS) -I . $*.c
-
-# explicit object dependencies for all source files
-
-win32_glx.obj: win32_glx.c win32_glx.h
-win32_x11.obj: win32_x11.c win32_x11.h
-win32_menu.obj: win32_menu.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h
-win32_util.obj: win32_util.c glutint.h ..\include\GL\glutf90.h
-win32_winproc.obj: win32_winproc.c glutint.h ..\include\GL\glutf90.h
-
-glut_mroman.obj: glut_mroman.c glutstroke.h glutint.h ..\include\GL\glutf90.h
-glut_roman.obj: glut_roman.c glutstroke.h glutint.h ..\include\GL\glutf90.h
-glut_hel12.obj: glut_hel12.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_8x13.obj: glut_8x13.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_hel18.obj: glut_hel18.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_9x15.obj: glut_9x15.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_tr10.obj: glut_tr10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_hel10.obj: glut_hel10.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-glut_tr24.obj: glut_tr24.c glutbitmap.h glutint.h ..\include\GL\glutf90.h
-
-glut_bitmap.obj: glut_bitmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_bwidth.obj: glut_bwidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_cindex.obj: glut_cindex.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_cmap.obj: glut_cmap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_cursor.obj: glut_cursor.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_dials.obj: glut_dials.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_dstr.obj: glut_dstr.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_event.obj: glut_event.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_ext.obj: glut_ext.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_fullscrn.obj: glut_fullscrn.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_gamemode.obj: glut_gamemode.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_get.obj: glut_get.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_init.obj: glut_init.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_input.obj: glut_input.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_joy.obj: glut_joy.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_key.obj: glut_key.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_keyctrl.obj: glut_keyctrl.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_keyup.obj: glut_keyup.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_mesa.obj: glut_mesa.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_modifier.obj: glut_modifier.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_overlay.obj: glut_overlay.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_shapes.obj: glut_shapes.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_space.obj: glut_space.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_swap.obj: glut_swap.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_swidth.obj: glut_swidth.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_tablet.obj: glut_tablet.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_teapot.obj: glut_teapot.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_util.obj: glut_util.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_vidresize.obj: glut_vidresize.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_warp.obj: glut_warp.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-glut_win.obj: glut_win.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h
-glut_winmisc.obj: glut_winmisc.c glutint.h ..\include\GL\glutf90.h ..\include\GL\glut.h glutwin32.h win32_glx.h win32_x11.h
-
diff --git a/src/glut/glx/SConscript b/src/glut/glx/SConscript
deleted file mode 100644
index 9363b5ca5cc..00000000000
--- a/src/glut/glx/SConscript
+++ /dev/null
@@ -1,111 +0,0 @@
-Import('*')
-
-env = env.Clone()
-
-env.Replace(CPPDEFINES = [
-    'BUILD_GLUT32', 
-    'GLUT_BUILDING_LIB', 
-    'NDEBUG',
-    'GLUT_NO_WARNING_DISABLE',
-])
-
-env.AppendUnique(CPPPATH = [
-    '#/include',
-])
-
-sources = [
-    'glut_bitmap.c',
-    'glut_bwidth.c',
-    'glut_cindex.c',
-    'glut_cmap.c',
-    'glut_cursor.c',
-    'glut_dials.c',
-    'glut_dstr.c',
-    'glut_event.c',
-    'glut_ext.c',
-    'glut_fullscrn.c',
-    'glut_gamemode.c',
-    'glut_get.c',
-    'glut_init.c',
-    'glut_input.c',
-    'glut_joy.c',
-    'glut_key.c',
-    'glut_keyctrl.c',
-    'glut_keyup.c',
-    'glut_mesa.c',
-    'glut_modifier.c',
-    'glut_overlay.c',
-    'glut_ppm.c',
-    'glut_shapes.c',
-    'glut_space.c',
-    'glut_stroke.c',
-    'glut_swap.c',
-    'glut_swidth.c',
-    'glut_tablet.c',
-    'glut_teapot.c',
-    'glut_util.c',
-    'glut_vidresize.c',
-    'glut_warp.c',
-    'glut_win.c',
-    'glut_winmisc.c',
-    
-    'glut_8x13.c',
-    'glut_9x15.c',
-    'glut_hel10.c',
-    'glut_hel12.c',
-    'glut_hel18.c',
-    'glut_mroman.c',
-    'glut_roman.c',
-    'glut_tr10.c',
-    'glut_tr24.c',
-]
-
-if env['platform'] == 'windows':
-    env.PrependUnique(LIBS = [
-        'winmm', 
-        'gdi32', 
-        'user32', 
-        'opengl32', 
-        'glu32',
-    ])
-    target = 'glut32'
-    sources += [
-        'win32_glx.c',
-        'win32_menu.c',
-        'win32_util.c',
-        'win32_winproc.c',
-        'win32_x11.c',
-        'glut.def',
-    ]
-else:
-    env.PrependUnique(LIBS = [
-        'GLU',
-        'GL',
-        'X11',
-        'Xext',
-        'Xmu',
-        'Xi',
-    ])
-    target = 'glut'
-    sources += [
-        'glut_fcb.c',
-        'glut_menu.c',
-        'glut_menu2.c',
-        'glut_glxext.c',
-        'layerutil.c',
-    ]
-
-
-glut = env.SharedLibrary(
-    target = target,
-    source = sources,
-)
-
-env.InstallSharedLibrary(glut, version=(3, 7, 1))
-
-if env['platform'] == 'windows':
-    glut = env.FindIxes(glut, 'LIBPREFIX', 'LIBSUFFIX')
-else:
-    glut = env.FindIxes(glut, 'SHLIBPREFIX', 'SHLIBSUFFIX')
-
-Export('glut')
diff --git a/src/glut/glx/capturexfont.c b/src/glut/glx/capturexfont.c
deleted file mode 100644
index fd63fb7c49f..00000000000
--- a/src/glut/glx/capturexfont.c
+++ /dev/null
@@ -1,357 +0,0 @@
-
-/* 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. */
-
-/* capturexfont.c connects to an X server and downloads a
-   bitmap font from which a C source file is generated,
-   encoding  the font for GLUT's use. Example usage:
-   capturexfont.c 9x15 glutBitmap9By15 > glut_9x15.c */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <GL/gl.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-
-#define MAX_GLYPHS_PER_GRAB 512  /* This is big enough for 2^9
-                                    glyph character sets */
-
-static void
-outputChar(int num, int width, int height,
-  int xoff, int yoff, int advance, int data)
-{
-  if (width == 0 || height == 0) {
-    printf("#ifdef _WIN32\n");
-    printf("/* XXX Work around Microsoft OpenGL 1.1 bug where glBitmap with\n");
-    printf("   a height or width of zero does not advance the raster position\n");
-    printf("   as specified by OpenGL. (Cosmo OpenGL does not have this bug.) */\n");
-    printf("static const GLubyte ch%ddata[] = { 0x0 };\n", num);
-    printf("static const BitmapCharRec ch%d = {", num);
-    printf("%d,", 0);
-    printf("%d,", 0);
-    printf("%d,", xoff);
-    printf("%d,", yoff);
-    printf("%d,", advance);
-    printf("ch%ddata", num);
-    printf("};\n");
-    printf("#else\n");
-  }
-  printf("static const BitmapCharRec ch%d = {", num);
-  printf("%d,", width);
-  printf("%d,", height);
-  printf("%d,", xoff);
-  printf("%d,", yoff);
-  printf("%d,", advance);
-  if (data) {
-    printf("ch%ddata", num);
-  } else {
-    printf("0");
-  }
-  printf("};\n");
-  if (width == 0 || height == 0) {
-    printf("#endif\n");
-  }
-  printf("\n");
-}
-
-/* Can't just use isprint because it only works for the range
-   of ASCII characters (ie, TRUE for isascii) and capturexfont
-   might be run on 16-bit fonts. */
-#define PRINTABLE(ch)  (isascii(ch) ? isprint(ch) : 0)
-
-void
-captureXFont(Display * dpy, Font font, char *xfont, char *name)
-{
-  int first, last, count;
-  int cnt, len;
-  Pixmap offscreen;
-  Window drawable;
-  XFontStruct *fontinfo;
-  XImage *image;
-  GC xgc;
-  XGCValues values;
-  int width, height;
-  int i, j, k;
-  XCharStruct *charinfo;
-  XChar2b character;
-  GLubyte *bitmapData;
-  int x, y;
-  int spanLength;
-  int charWidth, charHeight, maxSpanLength, pixwidth;
-  int grabList[MAX_GLYPHS_PER_GRAB];
-  int glyphsPerGrab = MAX_GLYPHS_PER_GRAB;
-  int numToGrab;
-  int rows, pages, byte1, byte2, index;
-  int nullBitmap;
-
-  drawable = RootWindow(dpy, DefaultScreen(dpy));
-
-  fontinfo = XQueryFont(dpy, font);
-  pages = fontinfo->max_char_or_byte2 - fontinfo->min_char_or_byte2 + 1;
-  first = (fontinfo->min_byte1 << 8) + fontinfo->min_char_or_byte2;
-  last = (fontinfo->max_byte1 << 8) + fontinfo->max_char_or_byte2;
-  count = last - first + 1;
-
-  width = fontinfo->max_bounds.rbearing -
-    fontinfo->min_bounds.lbearing;
-  height = fontinfo->max_bounds.ascent +
-    fontinfo->max_bounds.descent;
-  /* 16-bit fonts have more than one row; indexing into
-     per_char is trickier. */
-  rows = fontinfo->max_byte1 - fontinfo->min_byte1 + 1;
-
-  maxSpanLength = (width + 7) / 8;
-  /* For portability reasons we don't use alloca for
-     bitmapData, but we could. */
-  bitmapData = malloc(height * maxSpanLength);
-  /* Be careful determining the width of the pixmap; the X
-     protocol allows pixmaps of width 2^16-1 (unsigned short
-     size) but drawing coordinates max out at 2^15-1 (signed
-     short size).  If the width is too large, we need to limit
-     the glyphs per grab. */
-  if ((glyphsPerGrab * 8 * maxSpanLength) >= (1 << 15)) {
-    glyphsPerGrab = (1 << 15) / (8 * maxSpanLength);
-  }
-  pixwidth = glyphsPerGrab * 8 * maxSpanLength;
-  offscreen = XCreatePixmap(dpy, drawable, pixwidth, height, 1);
-
-  values.font = font;
-  values.background = 0;
-  values.foreground = 0;
-  xgc = XCreateGC(dpy, offscreen,
-    GCFont | GCBackground | GCForeground, &values);
-  XFillRectangle(dpy, offscreen, xgc, 0, 0,
-    8 * maxSpanLength * glyphsPerGrab, height);
-  XSetForeground(dpy, xgc, 1);
-
-  numToGrab = 0;
-  if (fontinfo->per_char == NULL) {
-    charinfo = &(fontinfo->min_bounds);
-    charWidth = charinfo->rbearing - charinfo->lbearing;
-    charHeight = charinfo->ascent + charinfo->descent;
-    spanLength = (charWidth + 7) / 8;
-  }
-  printf("\n/* GENERATED FILE -- DO NOT MODIFY */\n\n");
-  printf("#include \"glutbitmap.h\"\n\n");
-  for (i = first; count; i++, count--) {
-    int undefined;
-    if (rows == 1) {
-      undefined = (fontinfo->min_char_or_byte2 > i ||
-        fontinfo->max_char_or_byte2 < i);
-    } else {
-      byte2 = i & 0xff;
-      byte1 = i >> 8;
-      undefined = (fontinfo->min_char_or_byte2 > byte2 ||
-        fontinfo->max_char_or_byte2 < byte2 ||
-        fontinfo->min_byte1 > byte1 ||
-        fontinfo->max_byte1 < byte1);
-
-    }
-    if (undefined) {
-      goto PossiblyDoGrab;
-    }
-    if (fontinfo->per_char != NULL) {
-      if (rows == 1) {
-        index = i - fontinfo->min_char_or_byte2;
-      } else {
-        byte2 = i & 0xff;
-        byte1 = i >> 8;
-        index =
-          (byte1 - fontinfo->min_byte1) * pages +
-          (byte2 - fontinfo->min_char_or_byte2);
-      }
-      charinfo = &(fontinfo->per_char[index]);
-      charWidth = charinfo->rbearing - charinfo->lbearing;
-      charHeight = charinfo->ascent + charinfo->descent;
-      if (charWidth == 0 || charHeight == 0) {
-        if (charinfo->width != 0) {
-          /* Still must move raster pos even if empty character 
-
-           */
-          outputChar(i, 0, 0, 0, 0, charinfo->width, 0);
-        }
-        goto PossiblyDoGrab;
-      }
-    }
-    grabList[numToGrab] = i;
-    character.byte2 = i & 255;
-    character.byte1 = i >> 8;
-
-    /* XXX We could use XDrawImageString16 which would also
-       paint the backing rectangle but X server bugs in some
-       scalable font rasterizers makes it more effective to do
-       XFillRectangles to clear the pixmap and then
-       XDrawImage16 for the text.  */
-    XDrawString16(dpy, offscreen, xgc,
-      -charinfo->lbearing + 8 * maxSpanLength * numToGrab,
-      charinfo->ascent, &character, 1);
-
-    numToGrab++;
-
-  PossiblyDoGrab:
-
-    if (numToGrab >= glyphsPerGrab || count == 1) {
-      image = XGetImage(dpy, offscreen,
-        0, 0, pixwidth, height, 1, XYPixmap);
-      for (j = numToGrab - 1; j >= 0; j--) {
-        if (fontinfo->per_char != NULL) {
-          byte2 = grabList[j] & 0xff;
-          byte1 = grabList[j] >> 8;
-          index =
-            (byte1 - fontinfo->min_byte1) * pages +
-            (byte2 - fontinfo->min_char_or_byte2);
-          charinfo = &(fontinfo->per_char[index]);
-          charWidth = charinfo->rbearing - charinfo->lbearing;
-          charHeight = charinfo->ascent + charinfo->descent;
-          spanLength = (charWidth + 7) / 8;
-        }
-        memset(bitmapData, 0, height * spanLength);
-        for (y = 0; y < charHeight; y++) {
-          for (x = 0; x < charWidth; x++) {
-            if (XGetPixel(image, j * maxSpanLength * 8 + x,
-                charHeight - 1 - y)) {
-              /* Little endian machines (such as DEC Alpha)
-                 could  benefit from reversing the bit order
-                 here and changing the GL_UNPACK_LSB_FIRST
-                 parameter in glutBitmapCharacter to GL_TRUE. */
-              bitmapData[y * spanLength + x / 8] |=
-                (1 << (7 - (x & 7)));
-            }
-          }
-        }
-        if (PRINTABLE(grabList[j])) {
-          printf("/* char: 0x%x '%c' */\n\n",
-            grabList[j], grabList[j]);
-        } else {
-          printf("/* char: 0x%x */\n\n", grabList[j]);
-        }
-
-        /* Determine if the bitmap is null. */
-        nullBitmap = 1;
-        len = (charinfo->ascent + charinfo->descent) *
-          ((charinfo->rbearing - charinfo->lbearing + 7) / 8);
-        cnt = 0;
-        while (cnt < len) {
-          for (k = 0; k < 16 && cnt < len; k++, cnt++) {
-            if (bitmapData[cnt] != 0) {
-              nullBitmap = 0;
-            }
-          }
-        }
-
-        if (!nullBitmap) {
-          printf("static const GLubyte ch%ddata[] = {\n", grabList[j]);
-          len = (charinfo->ascent + charinfo->descent) *
-            ((charinfo->rbearing - charinfo->lbearing + 7) / 8);
-          cnt = 0;
-          while (cnt < len) {
-            for (k = 0; k < 16 && cnt < len; k++, cnt++) {
-              printf("0x%x,", bitmapData[cnt]);
-            }
-            printf("\n");
-          }
-          printf("};\n\n");
-        } else {
-          charWidth = 0;
-          charHeight = 0;
-        }
-
-        outputChar(grabList[j], charWidth, charHeight,
-          -charinfo->lbearing, charinfo->descent,
-          charinfo->width, !nullBitmap);
-      }
-      XDestroyImage(image);
-      numToGrab = 0;
-      if (count > 0) {
-        XSetForeground(dpy, xgc, 0);
-        XFillRectangle(dpy, offscreen, xgc, 0, 0,
-          8 * maxSpanLength * glyphsPerGrab, height);
-        XSetForeground(dpy, xgc, 1);
-      }
-    }
-  }
-  XFreeGC(dpy, xgc);
-  XFreePixmap(dpy, offscreen);
-  /* For portability reasons we don't use alloca for
-     bitmapData, but we could. */
-  free(bitmapData);
-
-  printf("static const BitmapCharRec * const chars[] = {\n");
-  for (i = first; i <= last; i++) {
-    int undefined;
-    byte2 = i & 0xff;
-    byte1 = i >> 8;
-    undefined = (fontinfo->min_char_or_byte2 > byte2 ||
-      fontinfo->max_char_or_byte2 < byte2 ||
-      fontinfo->min_byte1 > byte1 ||
-      fontinfo->max_byte1 < byte1);
-    if (undefined) {
-      printf("0,\n");
-    } else {
-      if (fontinfo->per_char != NULL) {
-        if (rows == 1) {
-          index = i - fontinfo->min_char_or_byte2;
-        } else {
-          byte2 = i & 0xff;
-          byte1 = i >> 8;
-          index =
-            (byte1 - fontinfo->min_byte1) * pages +
-            (byte2 - fontinfo->min_char_or_byte2);
-        }
-        charinfo = &(fontinfo->per_char[index]);
-        charWidth = charinfo->rbearing - charinfo->lbearing;
-        charHeight = charinfo->ascent + charinfo->descent;
-        if (charWidth == 0 || charHeight == 0) {
-          if (charinfo->width == 0) {
-            printf("0,\n");
-            continue;
-          }
-        }
-      }
-      printf("&ch%d,\n", i);
-    }
-  }
-  printf("};\n\n");
-  printf("GLUTAPI const BitmapFontRec %s;\n", name);
-  printf("const BitmapFontRec %s = {\n", name);
-  printf("\"%s\",\n", xfont);
-  printf("%d,\n", last - first + 1);
-  printf("%d,\n", first);
-  printf("chars\n");
-  printf("};\n\n");
-  XFreeFont(dpy, fontinfo);
-}
-
-int
-main(int argc, char **argv)
-{
-  Display *dpy;
-  Font font;
-
-  if (argc != 3) {
-    fprintf(stderr, "usage: capturexfont XFONT NAME\n");
-    exit(1);
-  }
-  dpy = XOpenDisplay(NULL);
-  if (dpy == NULL) {
-    fprintf(stderr, "capturexfont: could not open X display\n");
-    exit(1);
-  }
-  font = XLoadFont(dpy, argv[1]);
-  if (font == None) {
-    fprintf(stderr, "capturexfont: bad font\n");
-    exit(1);
-  }
-  captureXFont(dpy, font, argv[1], argv[2]);
-  XCloseDisplay(dpy);
-  return 0;
-}
diff --git a/src/glut/glx/fxglut.def b/src/glut/glx/fxglut.def
deleted file mode 100644
index 805a0c72224..00000000000
--- a/src/glut/glx/fxglut.def
+++ /dev/null
@@ -1,103 +0,0 @@
-EXPORTS
-	glutInit
-	glutInitDisplayMode
-	glutInitDisplayString
-	glutInitWindowPosition
-	glutInitWindowSize
-	glutMainLoop
-	glutCreateWindow
-	glutCreateSubWindow
-	glutDestroyWindow
-	glutPostRedisplay
-	glutSwapBuffers
-	glutGetWindow
-	glutSetWindow
-	glutSetWindowTitle
-	glutSetIconTitle
-	glutPositionWindow
-	glutReshapeWindow
-	glutPopWindow
-	glutPushWindow
-	glutIconifyWindow
-	glutShowWindow
-	glutHideWindow
-	glutFullScreen
-	glutSetCursor
-	glutWarpPointer
-	glutEstablishOverlay
-	glutRemoveOverlay
-	glutUseLayer
-	glutPostOverlayRedisplay
-	glutShowOverlay
-	glutHideOverlay
-	glutCreateMenu
-	glutDestroyMenu
-	glutGetMenu
-	glutSetMenu
-	glutAddMenuEntry
-	glutAddSubMenu
-	glutChangeToMenuEntry
-	glutChangeToSubMenu
-	glutRemoveMenuItem
-	glutAttachMenu
-	glutDetachMenu
-	glutDisplayFunc
-	glutReshapeFunc
-	glutKeyboardFunc
-	glutMouseFunc
-	glutMotionFunc
-	glutPassiveMotionFunc
-	glutEntryFunc
-	glutVisibilityFunc
-	glutIdleFunc
-	glutTimerFunc
-	glutMenuStateFunc
-	glutSpecialFunc
-	glutSpaceballMotionFunc
-	glutSpaceballRotateFunc
-	glutSpaceballButtonFunc
-	glutButtonBoxFunc
-	glutDialsFunc
-	glutTabletMotionFunc
-	glutTabletButtonFunc
-	glutMenuStatusFunc
-	glutOverlayDisplayFunc
-	glutWindowStatusFunc
-	glutSetColor
-	glutGetColor
-	glutCopyColormap
-	glutGet
-	glutDeviceGet
-	glutExtensionSupported
-	glutGetModifiers
-	glutLayerGet
-	glutBitmapCharacter
-	glutBitmapWidth
-	glutStrokeCharacter
-	glutStrokeWidth
-	glutBitmapLength
-	glutStrokeLength
-	glutWireSphere
-	glutSolidSphere
-	glutWireCone
-	glutSolidCone
-	glutWireCube
-	glutSolidCube
-	glutWireTorus
-	glutSolidTorus
-	glutWireDodecahedron
-	glutSolidDodecahedron
-	glutWireTeapot
-	glutSolidTeapot
-	glutWireOctahedron
-	glutSolidOctahedron
-	glutWireTetrahedron
-	glutSolidTetrahedron
-	glutWireIcosahedron
-	glutSolidIcosahedron
-	glutVideoResizeGet
-	glutSetupVideoResizing
-	glutStopVideoResizing
-	glutVideoResize
-	glutVideoPan
-	glutReportErrors
diff --git a/src/glut/glx/glut.def b/src/glut/glx/glut.def
deleted file mode 100644
index 90010815e49..00000000000
--- a/src/glut/glx/glut.def
+++ /dev/null
@@ -1,125 +0,0 @@
-EXPORTS
-	glutAddMenuEntry
-	glutAddSubMenu
-	glutAttachMenu
-	glutBitmapCharacter
-	glutBitmapLength
-	glutBitmapWidth
-	glutButtonBoxFunc
-	glutChangeToMenuEntry
-	glutChangeToSubMenu
-	glutCopyColormap
-	glutCreateMenu
-	__glutCreateMenuWithExit
-	glutCreateSubWindow
-	glutCreateWindow
-	__glutCreateWindowWithExit
-	glutDestroyMenu
-	glutDestroyWindow
-	glutDetachMenu
-	glutDeviceGet
-	glutDialsFunc
-	glutDisplayFunc
-	glutEnterGameMode
-	glutEntryFunc
-	glutEstablishOverlay
-	glutExtensionSupported
-	glutForceJoystickFunc
-	glutFullScreen
-	glutGameModeGet
-	glutGameModeString
-	glutGet
-	glutGetColor
-	glutGetMenu
-	glutGetModifiers
-	glutGetWindow
-	glutHideOverlay
-	glutHideWindow
-	glutIconifyWindow
-	glutIdleFunc
-	glutIgnoreKeyRepeat
-	glutInit
-	__glutInitWithExit
-	glutInitDisplayMode
-	glutInitDisplayString
-	glutInitWindowPosition
-	glutInitWindowSize
-	glutJoystickFunc
-	glutKeyboardFunc
-	glutKeyboardUpFunc
-	glutLayerGet
-	glutLeaveGameMode
-	glutMainLoop
-	glutMenuStateFunc
-	glutMenuStatusFunc
-	glutMotionFunc
-	glutMouseFunc
-	glutOverlayDisplayFunc
-	glutPassiveMotionFunc
-	glutPopWindow
-	glutPositionWindow
-	glutPostOverlayRedisplay
-	glutPostRedisplay
-	glutPostWindowOverlayRedisplay
-	glutPostWindowRedisplay
-	glutPushWindow
-	glutRemoveMenuItem
-	glutRemoveOverlay
-	glutReportErrors
-	glutReshapeFunc
-	glutReshapeWindow
-	glutSetColor
-	glutSetCursor
-	glutSetIconTitle
-	glutSetKeyRepeat
-	glutSetMenu
-	glutSetWindow
-	glutSetWindowTitle
-	glutSetupVideoResizing
-	glutShowOverlay
-	glutShowWindow
-	glutSolidCone
-	glutSolidCube
-	glutSolidDodecahedron
-	glutSolidIcosahedron
-	glutSolidOctahedron
-	glutSolidSphere
-	glutSolidTeapot
-	glutSolidTetrahedron
-	glutSolidTorus
-	glutSpaceballButtonFunc
-	glutSpaceballMotionFunc
-	glutSpaceballRotateFunc
-	glutSpecialFunc
-	glutSpecialUpFunc
-	glutStopVideoResizing
-	glutStrokeCharacter
-	glutStrokeLength
-	glutStrokeWidth
-	glutSwapBuffers
-	glutTabletButtonFunc
-	glutTabletMotionFunc
-	glutTimerFunc
-	glutUseLayer
-	glutVideoPan
-	glutVideoResize
-	glutVideoResizeGet
-	glutVisibilityFunc
-	glutWarpPointer
-	glutWindowStatusFunc
-	glutWireCone
-	glutWireCube
-	glutWireDodecahedron
-	glutWireIcosahedron
-	glutWireOctahedron
-	glutWireSphere
-	glutWireTeapot
-	glutWireTetrahedron
-	glutWireTorus
-	glutStrokeRoman
-	glutBitmap9By15
-	glutBitmapHelvetica10
-	glutBitmapHelvetica18
-	glutBitmapTimesRoman24
-;    __glutSetFCB
-;    __glutGetFCB
diff --git a/src/glut/glx/glut.pc.in b/src/glut/glx/glut.pc.in
deleted file mode 100644
index 151dd0b802b..00000000000
--- a/src/glut/glx/glut.pc.in
+++ /dev/null
@@ -1,13 +0,0 @@
-prefix=@INSTALL_DIR@
-exec_prefix=${prefix}
-libdir=@INSTALL_LIB_DIR@
-includedir=@INSTALL_INC_DIR@
-
-Name: glut
-Description: Mesa OpenGL Utility Toolkit library
-Requires: gl glu
-Requires.private: @GLUT_PC_REQ_PRIV@
-Version: @VERSION@
-Libs: -L${libdir} -l@GLUT_LIB@
-Libs.private: @GLUT_PC_LIB_PRIV@
-Cflags: -I${includedir} @GLUT_PC_CFLAGS@
diff --git a/src/glut/glx/glut_8x13.c b/src/glut/glx/glut_8x13.c
deleted file mode 100644
index f4e18eb0a45..00000000000
--- a/src/glut/glx/glut_8x13.c
+++ /dev/null
@@ -1,2074 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmap8By13 XXX
-#include "glutbitmap.h"
-#undef glutBitmap8By13
-
-#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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmap8By13;
-const BitmapFontRec glutBitmap8By13 = {
-"-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1",
-256,
-0,
-chars
-};
-
diff --git a/src/glut/glx/glut_9x15.c b/src/glut/glx/glut_9x15.c
deleted file mode 100644
index 7dbec124d09..00000000000
--- a/src/glut/glx/glut_9x15.c
+++ /dev/null
@@ -1,2076 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmap9By15 XXX
-#include "glutbitmap.h"
-#undef glutBitmap9By15
-
-#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,9,ch0data};
-#else
-static const BitmapCharRec ch0 = {0,0,0,0,9,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,9,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,9,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,9,ch127data};
-#else
-static const BitmapCharRec ch127 = {0,0,0,0,9,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,9,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,9,0};
-#endif
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch255 = {6,14,-1,3,9,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {7,12,-1,3,9,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch253 = {6,14,-1,3,9,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch252 = {7,11,-1,0,9,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch251 = {7,11,-1,0,9,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch250 = {7,11,-1,0,9,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch249 = {7,11,-1,0,9,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x80,0x7c,0xa2,0xa2,0x92,0x8a,0x8a,0x7c,0x2,
-};
-
-static const BitmapCharRec ch248 = {7,9,-1,1,9,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x10,0x38,0x10,0x0,0xfe,0x0,0x10,0x38,0x10,
-};
-
-static const BitmapCharRec ch247 = {7,9,-1,0,9,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch246 = {7,11,-1,0,9,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {7,11,-1,0,9,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch244 = {7,11,-1,0,9,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch243 = {7,11,-1,0,9,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch242 = {7,11,-1,0,9,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch241 = {7,11,-1,0,9,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,0x8,0x50,0x30,0x48,
-};
-
-static const BitmapCharRec ch240 = {7,11,-1,0,9,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x50,0x50,
-};
-
-static const BitmapCharRec ch239 = {5,11,-2,0,9,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x90,0x60,
-};
-
-static const BitmapCharRec ch238 = {5,11,-2,0,9,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,0x10,
-};
-
-static const BitmapCharRec ch237 = {5,11,-2,0,9,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x30,0x40,
-};
-
-static const BitmapCharRec ch236 = {5,11,-2,0,9,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch235 = {7,11,-1,0,9,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch234 = {7,11,-1,0,9,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch233 = {7,11,-1,0,9,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch232 = {7,11,-1,0,9,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch231 = {7,10,-1,3,9,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x6e,0x92,0x90,0x7c,0x12,0x92,0x6c,
-};
-
-static const BitmapCharRec ch230 = {7,7,-1,0,9,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x18,0x24,0x18,
-};
-
-static const BitmapCharRec ch229 = {7,11,-1,0,9,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch228 = {7,11,-1,0,9,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch227 = {7,11,-1,0,9,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch226 = {7,11,-1,0,9,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch225 = {7,11,-1,0,9,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,0x0,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch224 = {7,11,-1,0,9,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0x80,0xbc,0xc2,0x82,0x82,0xfc,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch223 = {7,9,-1,1,9,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {7,10,-1,0,9,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,11,-1,0,9,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch220 = {7,11,-1,0,9,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch219 = {7,11,-1,0,9,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch218 = {7,11,-1,0,9,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch217 = {7,11,-1,0,9,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x7c,0xc2,0xa2,0xa2,0x92,0x92,0x8a,0x8a,0x86,0x7c,0x2,
-};
-
-static const BitmapCharRec ch216 = {7,12,-1,1,9,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x82,0x44,0x28,0x10,0x28,0x44,0x82,
-};
-
-static const BitmapCharRec ch215 = {7,7,-1,-1,9,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch214 = {7,11,-1,0,9,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {7,11,-1,0,9,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch212 = {7,11,-1,0,9,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch211 = {7,11,-1,0,9,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch210 = {7,11,-1,0,9,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x82,0x86,0x8a,0x92,0x92,0xa2,0xc2,0x82,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {7,11,-1,0,9,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0xfc,0x42,0x42,0x42,0x42,0xf2,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch208 = {7,10,-1,0,9,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x50,0x50,
-};
-
-static const BitmapCharRec ch207 = {5,11,-2,0,9,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x88,0x70,
-};
-
-static const BitmapCharRec ch206 = {5,11,-2,0,9,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x60,0x10,
-};
-
-static const BitmapCharRec ch205 = {5,11,-2,0,9,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,0x0,0x30,0x40,
-};
-
-static const BitmapCharRec ch204 = {5,11,-2,0,9,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch203 = {7,11,-1,0,9,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch202 = {7,11,-1,0,9,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch201 = {7,11,-1,0,9,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xfe,0x40,0x40,0x40,0x78,0x40,0x40,0xfe,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch200 = {7,11,-1,0,9,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x48,0x18,0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch199 = {7,13,-1,3,9,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x9e,0x90,0x90,0x90,0xfc,0x90,0x90,0x90,0x90,0x6e,
-};
-
-static const BitmapCharRec ch198 = {7,10,-1,0,9,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,11,-1,0,9,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x28,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch195 = {7,11,-1,0,9,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x44,0x38,
-};
-
-static const BitmapCharRec ch194 = {7,11,-1,0,9,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x30,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,11,-1,0,9,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x44,0x38,0x0,0x18,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,11,-1,0,9,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x7c,0x82,0x82,0x80,0x40,0x20,0x10,0x10,0x0,0x10,
-};
-
-static const BitmapCharRec ch191 = {7,10,-1,0,9,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x6,0x1a,0x12,0xa,0x66,0x92,0x10,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch190 = {7,10,-1,0,9,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x1e,0x10,0xc,0x2,0xf2,0x4c,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch189 = {7,10,-1,0,9,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x6,0x1a,0x12,0xa,0xe6,0x42,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch188 = {7,10,-1,0,9,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x90,0x48,0x24,0x12,0x12,0x24,0x48,0x90,
-};
-
-static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xf8,0x0,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch186 = {5,6,-1,-5,9,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {3,6,-1,-4,9,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0x60,0x90,0x30,
-};
-
-static const BitmapCharRec ch184 = {4,3,-2,3,9,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-4,-4,9,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0xa,0xa,0xa,0xa,0xa,0x7a,0x8a,0x8a,0x8a,0x7e,
-};
-
-static const BitmapCharRec ch182 = {7,10,-1,0,9,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xba,0xc6,0x82,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch181 = {7,9,-1,2,9,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0xc0,0x20,
-};
-
-static const BitmapCharRec ch180 = {3,2,-3,-9,9,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x60,0x90,0x10,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch179 = {4,6,-1,-4,9,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf0,0x80,0x60,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch178 = {4,6,-1,-4,9,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xfe,0x0,0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch177 = {7,9,-1,-1,9,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,-3,-6,9,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch175 = {6,1,-1,-9,9,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x3c,0x42,0xa5,0xa9,0xbd,0xa5,0xb9,0x42,0x3c,
-};
-
-static const BitmapCharRec ch174 = {8,9,0,-1,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch173 = {6,1,-1,-4,9,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x4,0x4,0x4,0xfc,
-};
-
-static const BitmapCharRec ch172 = {6,4,-1,-2,9,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x12,0x24,0x48,0x90,0x90,0x48,0x24,0x12,
-};
-
-static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xf8,0x0,0x78,0x90,0x70,0x90,0x60,
-};
-
-static const BitmapCharRec ch170 = {5,7,-3,-3,9,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x3c,0x42,0x99,0xa5,0xa1,0xa5,0x99,0x42,0x3c,
-};
-
-static const BitmapCharRec ch169 = {8,9,0,-1,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,2,-3,-9,9,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x8,0x70,0x88,0x88,0x88,0x70,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,11,-2,1,9,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,11,-4,1,9,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x10,0x10,0x10,0x7c,0x10,0x7c,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch165 = {7,10,-1,0,9,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x82,0x7c,0x44,0x44,0x7c,0x82,
-};
-
-static const BitmapCharRec ch164 = {7,6,-1,-3,9,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
-};
-
-static const BitmapCharRec ch163 = {7,10,-1,0,9,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x78,0xa4,0xa0,0x90,0x94,0x78,0x8,
-};
-
-static const BitmapCharRec ch162 = {6,8,-1,0,9,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,11,-4,0,9,ch161data};
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x8c,0x92,0x62,
-};
-
-static const BitmapCharRec ch126 = {7,3,-1,-7,9,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xe0,0x10,0x10,0x10,0x20,0x18,0x18,0x20,0x10,0x10,0x10,0xe0,
-};
-
-static const BitmapCharRec ch125 = {5,12,-1,1,9,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,12,-4,1,9,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x38,0x40,0x40,0x40,0x20,0xc0,0xc0,0x20,0x40,0x40,0x40,0x38,
-};
-
-static const BitmapCharRec ch123 = {5,12,-3,1,9,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xfe,0x40,0x20,0x10,0x8,0x4,0xfe,
-};
-
-static const BitmapCharRec ch122 = {7,7,-1,0,9,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x78,0x84,0x4,0x74,0x8c,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch121 = {6,10,-1,3,9,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x82,0x44,0x28,0x10,0x28,0x44,0x82,
-};
-
-static const BitmapCharRec ch120 = {7,7,-1,0,9,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x44,0xaa,0x92,0x92,0x92,0x82,0x82,
-};
-
-static const BitmapCharRec ch119 = {7,7,-1,0,9,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x10,0x28,0x28,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch118 = {7,7,-1,0,9,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x7a,0x84,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch117 = {7,7,-1,0,9,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x1c,0x22,0x20,0x20,0x20,0x20,0xfc,0x20,0x20,
-};
-
-static const BitmapCharRec ch116 = {7,9,-1,0,9,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x7c,0x82,0x2,0x7c,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch115 = {7,7,-1,0,9,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x40,0x40,0x40,0x40,0x42,0x62,0x9c,
-};
-
-static const BitmapCharRec ch114 = {7,7,-1,0,9,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x2,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,
-};
-
-static const BitmapCharRec ch113 = {7,10,-1,3,9,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0x80,0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,
-};
-
-static const BitmapCharRec ch112 = {7,10,-1,3,9,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch111 = {7,7,-1,0,9,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,
-};
-
-static const BitmapCharRec ch110 = {7,7,-1,0,9,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x82,0x92,0x92,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,
-};
-
-static const BitmapCharRec ch108 = {5,10,-2,0,9,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x82,0x8c,0xb0,0xc0,0xb0,0x8c,0x82,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {7,10,-1,0,9,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x78,0x84,0x84,0x84,0x4,0x4,0x4,0x4,0x4,0x1c,0x0,0x0,0xc,
-};
-
-static const BitmapCharRec ch106 = {6,13,-1,3,9,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0xe0,0x0,0x0,0x60,
-};
-
-static const BitmapCharRec ch105 = {5,10,-2,0,9,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x82,0x82,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {7,10,-1,0,9,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x7c,0x82,0x82,0x7c,0x80,0x78,0x84,0x84,0x84,0x7a,
-};
-
-static const BitmapCharRec ch103 = {7,10,-1,3,9,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x20,0x20,0x20,0x20,0xf8,0x20,0x20,0x22,0x22,0x1c,
-};
-
-static const BitmapCharRec ch102 = {7,10,-1,0,9,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x7c,0x80,0x80,0xfe,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch101 = {7,7,-1,0,9,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x7a,0x86,0x82,0x82,0x82,0x86,0x7a,0x2,0x2,0x2,
-};
-
-static const BitmapCharRec ch100 = {7,10,-1,0,9,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x7c,0x82,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch99 = {7,7,-1,0,9,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xbc,0xc2,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {7,10,-1,0,9,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x7a,0x86,0x82,0x7e,0x2,0x2,0x7c,
-};
-
-static const BitmapCharRec ch97 = {7,7,-1,0,9,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x10,0x20,0x40,0xc0,
-};
-
-static const BitmapCharRec ch96 = {4,4,-3,-6,9,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,
-};
-
-static const BitmapCharRec ch95 = {8,1,0,1,9,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x82,0x44,0x28,0x10,
-};
-
-static const BitmapCharRec ch94 = {7,4,-1,-6,9,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf0,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xf0,
-};
-
-static const BitmapCharRec ch93 = {4,12,-2,1,9,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x2,0x4,0x4,0x8,0x10,0x10,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch92 = {7,10,-1,0,9,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xf0,
-};
-
-static const BitmapCharRec ch91 = {4,12,-3,1,9,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xfe,0x80,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch90 = {7,10,-1,0,9,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x10,0x10,0x10,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,10,-1,0,9,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x82,0x82,0x44,0x28,0x10,0x10,0x28,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch88 = {7,10,-1,0,9,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x44,0xaa,0x92,0x92,0x92,0x92,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch87 = {7,10,-1,0,9,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x28,0x28,0x28,0x44,0x44,0x44,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,10,-1,0,9,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch85 = {7,10,-1,0,9,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0xfe,
-};
-
-static const BitmapCharRec ch84 = {7,10,-1,0,9,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x7c,0x82,0x82,0x2,0xc,0x70,0x80,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch83 = {7,10,-1,0,9,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x82,0x82,0x84,0x88,0x90,0xfc,0x82,0x82,0x82,0xfc,
-};
-
-static const BitmapCharRec ch82 = {7,10,-1,0,9,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x6,0x8,0x7c,0x92,0xa2,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch81 = {7,12,-1,2,9,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0x80,0x80,0x80,0x80,0x80,0xfc,0x82,0x82,0x82,0xfc,
-};
-
-static const BitmapCharRec ch80 = {7,10,-1,0,9,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x7c,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch79 = {7,10,-1,0,9,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x82,0x82,0x82,0x86,0x8a,0x92,0xa2,0xc2,0x82,0x82,
-};
-
-static const BitmapCharRec ch78 = {7,10,-1,0,9,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x82,0x82,0x82,0x92,0x92,0xaa,0xaa,0xc6,0x82,0x82,
-};
-
-static const BitmapCharRec ch77 = {7,10,-1,0,9,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xfe,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {7,10,-1,0,9,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x82,0x84,0x88,0x90,0xa0,0xe0,0x90,0x88,0x84,0x82,
-};
-
-static const BitmapCharRec ch75 = {7,10,-1,0,9,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x78,0x84,0x4,0x4,0x4,0x4,0x4,0x4,0x4,0x1e,
-};
-
-static const BitmapCharRec ch74 = {7,10,-1,0,9,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
-};
-
-static const BitmapCharRec ch73 = {5,10,-2,0,9,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x82,0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch72 = {7,10,-1,0,9,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x7c,0x82,0x82,0x82,0x8e,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch71 = {7,10,-1,0,9,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x40,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
-};
-
-static const BitmapCharRec ch70 = {7,10,-1,0,9,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xfe,0x40,0x40,0x40,0x40,0x78,0x40,0x40,0x40,0xfe,
-};
-
-static const BitmapCharRec ch69 = {7,10,-1,0,9,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xfc,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch68 = {7,10,-1,0,9,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x7c,0x82,0x80,0x80,0x80,0x80,0x80,0x80,0x82,0x7c,
-};
-
-static const BitmapCharRec ch67 = {7,10,-1,0,9,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xfc,0x42,0x42,0x42,0x42,0x7c,0x42,0x42,0x42,0xfc,
-};
-
-static const BitmapCharRec ch66 = {7,10,-1,0,9,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x44,0x28,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,10,-1,0,9,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x7c,0x80,0x80,0x9a,0xa6,0xa2,0x9e,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch64 = {7,10,-1,0,9,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x10,0x0,0x10,0x10,0x8,0x4,0x2,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch63 = {7,10,-1,0,9,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {5,10,-2,0,9,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xfe,0x0,0x0,0xfe,
-};
-
-static const BitmapCharRec ch61 = {7,4,-1,-2,9,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x8,0x10,0x20,0x40,0x80,0x80,0x40,0x20,0x10,0x8,
-};
-
-static const BitmapCharRec ch60 = {5,10,-2,0,9,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {2,10,-4,3,9,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,7,-4,0,9,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x78,0x4,0x2,0x2,0x7a,0x86,0x82,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch57 = {7,10,-1,0,9,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x38,0x44,0x82,0x82,0x44,0x38,0x44,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch56 = {7,10,-1,0,9,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x10,0x8,0x4,0x2,0x2,0xfe,
-};
-
-static const BitmapCharRec ch55 = {7,10,-1,0,9,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x7c,0x82,0x82,0x82,0xc2,0xbc,0x80,0x80,0x40,0x3c,
-};
-
-static const BitmapCharRec ch54 = {7,10,-1,0,9,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7c,0x82,0x2,0x2,0x2,0xc2,0xbc,0x80,0x80,0xfe,
-};
-
-static const BitmapCharRec ch53 = {7,10,-1,0,9,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x4,0x4,0x4,0xfe,0x84,0x44,0x24,0x14,0xc,0x4,
-};
-
-static const BitmapCharRec ch52 = {7,10,-1,0,9,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x7c,0x82,0x2,0x2,0x2,0x1c,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch51 = {7,10,-1,0,9,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xfe,0x80,0x40,0x30,0x8,0x4,0x2,0x82,0x82,0x7c,
-};
-
-static const BitmapCharRec ch50 = {7,10,-1,0,9,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xfe,0x10,0x10,0x10,0x10,0x10,0x90,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch49 = {7,10,-1,0,9,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x38,0x44,0x82,0x82,0x82,0x82,0x82,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch48 = {7,10,-1,0,9,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x40,0x40,0x20,0x10,0x10,0x8,0x4,0x4,0x2,
-};
-
-static const BitmapCharRec ch47 = {7,10,-1,0,9,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-4,0,9,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xfe,
-};
-
-static const BitmapCharRec ch45 = {7,1,-1,-4,9,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {2,5,-4,3,9,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x10,0x10,0x10,0xfe,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch43 = {7,7,-1,-1,9,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x10,0x92,0x54,0x38,0x54,0x92,0x10,
-};
-
-static const BitmapCharRec ch42 = {7,7,-1,-1,9,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,12,-3,1,9,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,12,-3,1,9,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x20,0x30,
-};
-
-static const BitmapCharRec ch39 = {4,4,-3,-6,9,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x62,0x94,0x88,0x94,0x62,0x60,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch38 = {7,10,-1,0,9,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x84,0x4a,0x4a,0x24,0x10,0x10,0x48,0xa4,0xa4,0x42,
-};
-
-static const BitmapCharRec ch37 = {7,10,-1,0,9,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x10,0x7c,0x92,0x12,0x12,0x14,0x38,0x50,0x90,0x92,0x7c,0x10,
-};
-
-static const BitmapCharRec ch36 = {7,12,-1,1,9,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x48,0x48,0xfc,0x48,0x48,0xfc,0x48,0x48,
-};
-
-static const BitmapCharRec ch35 = {6,8,-1,-1,9,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch34 = {4,3,-3,-7,9,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,11,-4,0,9,ch33data};
-
-/* char: 0x1f */
-
-static const GLubyte ch31data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch31 = {2,2,-4,-2,9,ch31data};
-
-/* char: 0x1e */
-
-static const GLubyte ch30data[] = {
-0x5c,0xa2,0x60,0x20,0x20,0xf8,0x20,0x20,0x22,0x1c,
-};
-
-static const BitmapCharRec ch30 = {7,10,-1,0,9,ch30data};
-
-/* char: 0x1d */
-
-static const GLubyte ch29data[] = {
-0x80,0x40,0xfe,0x10,0xfe,0x4,0x2,
-};
-
-static const BitmapCharRec ch29 = {7,7,-1,0,9,ch29data};
-
-/* char: 0x1c */
-
-static const GLubyte ch28data[] = {
-0x44,0x24,0x24,0x24,0x24,0x24,0xfe,
-};
-
-static const BitmapCharRec ch28 = {7,7,-1,0,9,ch28data};
-
-/* char: 0x1b */
-
-static const GLubyte ch27data[] = {
-0xfe,0x0,0x80,0x40,0x20,0x10,0x8,0x8,0x10,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch27 = {7,12,-1,2,9,ch27data};
-
-/* char: 0x1a */
-
-static const GLubyte ch26data[] = {
-0xfc,0x0,0x4,0x8,0x10,0x20,0x40,0x40,0x20,0x10,0x8,0x4,
-};
-
-static const BitmapCharRec ch26 = {6,12,-2,2,9,ch26data};
-
-/* char: 0x19 */
-
-static const GLubyte ch25data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch25 = {1,15,-4,3,9,ch25data};
-
-/* char: 0x18 */
-
-static const GLubyte ch24data[] = {
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,
-};
-
-static const BitmapCharRec ch24 = {9,7,0,3,9,ch24data};
-
-/* char: 0x17 */
-
-static const GLubyte ch23data[] = {
-0xff,0x80,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch23 = {9,9,0,-3,9,ch23data};
-
-/* char: 0x16 */
-
-static const GLubyte ch22data[] = {
-0x8,0x8,0x8,0x8,0x8,0x8,0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch22 = {5,15,0,3,9,ch22data};
-
-/* char: 0x15 */
-
-static const GLubyte ch21data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch21 = {5,15,-4,3,9,ch21data};
-
-/* char: 0x14 */
-
-static const GLubyte ch20data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch20 = {9,1,0,1,9,ch20data};
-
-/* char: 0x13 */
-
-static const GLubyte ch19data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch19 = {9,1,0,-1,9,ch19data};
-
-/* char: 0x12 */
-
-static const GLubyte ch18data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch18 = {9,1,0,-3,9,ch18data};
-
-/* char: 0x11 */
-
-static const GLubyte ch17data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch17 = {9,1,0,-5,9,ch17data};
-
-/* char: 0x10 */
-
-static const GLubyte ch16data[] = {
-0xff,0x80,
-};
-
-static const BitmapCharRec ch16 = {9,1,0,-7,9,ch16data};
-
-/* char: 0xf */
-
-static const GLubyte ch15data[] = {
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0xff,0x80,0x8,0x0,
-0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,0x8,0x0,
-};
-
-static const BitmapCharRec ch15 = {9,15,0,3,9,ch15data};
-
-/* char: 0xe */
-
-static const GLubyte ch14data[] = {
-0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch14 = {5,9,-4,-3,9,ch14data};
-
-/* char: 0xd */
-
-static const GLubyte ch13data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch13 = {5,7,-4,3,9,ch13data};
-
-/* char: 0xc */
-
-static const GLubyte ch12data[] = {
-0x8,0x8,0x8,0x8,0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch12 = {5,7,0,3,9,ch12data};
-
-/* char: 0xb */
-
-static const GLubyte ch11data[] = {
-0xf8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch11 = {5,9,0,-3,9,ch11data};
-
-/* char: 0xa */
-
-static const GLubyte ch10data[] = {
-0x8,0x8,0x8,0x8,0x3e,0x0,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch10 = {7,10,-1,2,9,ch10data};
-
-/* char: 0x9 */
-
-static const GLubyte ch9data[] = {
-0x3e,0x20,0x20,0x20,0x20,0x88,0x98,0xa8,0xc8,0x88,
-};
-
-static const BitmapCharRec ch9 = {7,10,-1,2,9,ch9data};
-
-/* char: 0x8 */
-
-static const GLubyte ch8data[] = {
-0xfe,0x10,0x10,0xfe,0x10,0x10,
-};
-
-static const BitmapCharRec ch8 = {7,6,-1,0,9,ch8data};
-
-/* char: 0x7 */
-
-static const GLubyte ch7data[] = {
-0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch7 = {5,4,-2,-6,9,ch7data};
-
-/* char: 0x6 */
-
-static const GLubyte ch6data[] = {
-0x20,0x20,0x3c,0x20,0x3e,0x0,0xf8,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch6 = {7,10,-1,2,9,ch6data};
-
-/* char: 0x5 */
-
-static const GLubyte ch5data[] = {
-0x22,0x22,0x3c,0x22,0x3c,0x0,0x78,0x80,0x80,0x78,
-};
-
-static const BitmapCharRec ch5 = {7,10,-1,2,9,ch5data};
-
-/* char: 0x4 */
-
-static const GLubyte ch4data[] = {
-0x10,0x10,0x1c,0x10,0x1e,0x80,0x80,0xe0,0x80,0xf0,
-};
-
-static const BitmapCharRec ch4 = {7,10,-1,2,9,ch4data};
-
-/* char: 0x3 */
-
-static const GLubyte ch3data[] = {
-0x8,0x8,0x8,0x3e,0x0,0x88,0x88,0xf8,0x88,0x88,
-};
-
-static const BitmapCharRec ch3 = {7,10,-1,2,9,ch3data};
-
-/* char: 0x2 */
-
-static const GLubyte ch2data[] = {
-0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,
-};
-
-static const BitmapCharRec ch2 = {8,14,0,3,9,ch2data};
-
-/* char: 0x1 */
-
-static const GLubyte ch1data[] = {
-0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,
-};
-
-static const BitmapCharRec ch1 = {7,7,-1,0,9,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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmap9By15;
-const BitmapFontRec glutBitmap9By15 = {
-"-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1",
-256,
-0,
-chars
-};
-
diff --git a/src/glut/glx/glut_bitmap.c b/src/glut/glx/glut_bitmap.c
deleted file mode 100644
index 8fec7f11710..00000000000
--- a/src/glut/glx/glut_bitmap.c
+++ /dev/null
@@ -1,57 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutbitmap.h"
-
-void GLUTAPIENTRY 
-glutBitmapCharacter(GLUTbitmapFont font, int c)
-{
-  const BitmapCharRec *ch;
-  BitmapFontPtr fontinfo;
-  GLint swapbytes, lsbfirst, rowlength;
-  GLint skiprows, skippixels, alignment;
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  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);
-  }
-}
diff --git a/src/glut/glx/glut_bwidth.c b/src/glut/glx/glut_bwidth.c
deleted file mode 100644
index f9cdb184da7..00000000000
--- a/src/glut/glx/glut_bwidth.c
+++ /dev/null
@@ -1,58 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutbitmap.h"
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutBitmapWidth(GLUTbitmapFont font, int c)
-{
-  BitmapFontPtr fontinfo;
-  const BitmapCharRec *ch;
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  if (c < fontinfo->first || c >= fontinfo->first + fontinfo->num_chars)
-    return 0;
-  ch = fontinfo->ch[c - fontinfo->first];
-  if (ch)
-    return ch->advance;
-  else
-    return 0;
-}
-
-int GLUTAPIENTRY 
-glutBitmapLength(GLUTbitmapFont font, const unsigned char *string)
-{
-  int c, length;
-  BitmapFontPtr fontinfo;
-  const BitmapCharRec *ch;
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (BitmapFontPtr) __glutFont(font);
-#else
-  fontinfo = (BitmapFontPtr) font;
-#endif
-
-  length = 0;
-  for (; *string != '\0'; string++) {
-    c = *string;
-    if (c >= fontinfo->first && c < fontinfo->first + fontinfo->num_chars) {
-      ch = fontinfo->ch[c - fontinfo->first];
-      if (ch)
-        length += ch->advance;
-    }
-  }
-  return length;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_cindex.c b/src/glut/glx/glut_cindex.c
deleted file mode 100644
index d0c12bf3a06..00000000000
--- a/src/glut/glx/glut_cindex.c
+++ /dev/null
@@ -1,252 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1996, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include "glutint.h"
-
-#define CLAMP(i) ((i) > 1.0 ? 1.0 : ((i) < 0.0 ? 0.0 : (i)))
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutSetColor(int ndx, GLfloat red, GLfloat green, GLfloat blue)
-{
-  GLUTcolormap *cmap, *newcmap;
-  XVisualInfo *vis;
-  XColor color;
-  int i;
-
-  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-    cmap = __glutCurrentWindow->colormap;
-    vis = __glutCurrentWindow->vis;
-  } else {
-    cmap = __glutCurrentWindow->overlay->colormap;
-    vis = __glutCurrentWindow->overlay->vis;
-    if (ndx == __glutCurrentWindow->overlay->transparentPixel) {
-      __glutWarning(
-        "glutSetColor: cannot set color of overlay transparent index %d\n",
-        ndx);
-      return;
-    }
-  }
-
-  if (!cmap) {
-    __glutWarning("glutSetColor: current window is RGBA");
-    return;
-  }
-#if defined(_WIN32)
-  if (ndx >= 256 ||     /* always assume 256 colors on Win32 */
-#else
-  if (ndx >= vis->visual->map_entries ||
-#endif
-    ndx < 0) {
-    __glutWarning("glutSetColor: index %d out of range", ndx);
-    return;
-  }
-  if (cmap->refcnt > 1) {
-    newcmap = __glutAssociateNewColormap(vis);
-    cmap->refcnt--;
-    /* Wouldn't it be nice if XCopyColormapAndFree could be
-       told not to free the old colormap's entries! */
-    for (i = cmap->size - 1; i >= 0; i--) {
-      if (i == ndx) {
-        /* We are going to set this cell shortly! */
-        continue;
-      }
-      if (cmap->cells[i].component[GLUT_RED] >= 0.0) {
-        color.pixel = i;
-        newcmap->cells[i].component[GLUT_RED] =
-          cmap->cells[i].component[GLUT_RED];
-        color.red = (GLfloat) 0xffff *
-          cmap->cells[i].component[GLUT_RED];
-        newcmap->cells[i].component[GLUT_GREEN] =
-          cmap->cells[i].component[GLUT_GREEN];
-        color.green = (GLfloat) 0xffff *
-          cmap->cells[i].component[GLUT_GREEN];
-        newcmap->cells[i].component[GLUT_BLUE] =
-          cmap->cells[i].component[GLUT_BLUE];
-        color.blue = (GLfloat) 0xffff *
-          cmap->cells[i].component[GLUT_BLUE];
-        color.flags = DoRed | DoGreen | DoBlue;
-#if defined(_WIN32)
-        if (IsWindowVisible(__glutCurrentWindow->win)) {
-          XHDC = __glutCurrentWindow->hdc;
-        } else {
-          XHDC = 0;
-        }
-#endif
-        XStoreColor(__glutDisplay, newcmap->cmap, &color);
-      } else {
-        /* Leave unallocated entries unallocated. */
-      }
-    }
-    cmap = newcmap;
-    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-      __glutCurrentWindow->colormap = cmap;
-      __glutCurrentWindow->cmap = cmap->cmap;
-    } else {
-      __glutCurrentWindow->overlay->colormap = cmap;
-      __glutCurrentWindow->overlay->cmap = cmap->cmap;
-    }
-    XSetWindowColormap(__glutDisplay,
-      __glutCurrentWindow->renderWin, cmap->cmap);
-
-#if !defined(_WIN32)
-    {
-      GLUTwindow *toplevel;
-
-      toplevel = __glutToplevelOf(__glutCurrentWindow);
-      if (toplevel->cmap != cmap->cmap) {
-        __glutPutOnWorkList(toplevel, GLUT_COLORMAP_WORK);
-      }
-    }
-#endif
-  }
-  color.pixel = ndx;
-  red = CLAMP(red);
-  cmap->cells[ndx].component[GLUT_RED] = red;
-  color.red = (GLfloat) 0xffff *red;
-  green = CLAMP(green);
-  cmap->cells[ndx].component[GLUT_GREEN] = green;
-  color.green = (GLfloat) 0xffff *green;
-  blue = CLAMP(blue);
-  cmap->cells[ndx].component[GLUT_BLUE] = blue;
-  color.blue = (GLfloat) 0xffff *blue;
-  color.flags = DoRed | DoGreen | DoBlue;
-#if defined(_WIN32)
-  if (IsWindowVisible(__glutCurrentWindow->win)) {
-    XHDC = __glutCurrentWindow->hdc;
-  } else {
-    XHDC = 0;
-  }
-#endif
-  XStoreColor(__glutDisplay, cmap->cmap, &color);
-}
-
-GLfloat GLUTAPIENTRY
-glutGetColor(int ndx, int comp)
-{
-  GLUTcolormap *colormap;
-  XVisualInfo *vis;
-
-  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-    colormap = __glutCurrentWindow->colormap;
-    vis = __glutCurrentWindow->vis;
-  } else {
-    colormap = __glutCurrentWindow->overlay->colormap;
-    vis = __glutCurrentWindow->overlay->vis;
-    if (ndx == __glutCurrentWindow->overlay->transparentPixel) {
-      __glutWarning("glutGetColor: requesting overlay transparent index %d\n",
-        ndx);
-      return -1.0;
-    }
-  }
-
-  if (!colormap) {
-    __glutWarning("glutGetColor: current window is RGBA");
-    return -1.0;
-  }
-#if defined(_WIN32)
-#define OUT_OF_RANGE_NDX(ndx) (ndx >= 256 || ndx < 0)
-#else
-#define OUT_OF_RANGE_NDX(ndx) (ndx >= vis->visual->map_entries || ndx < 0)
-#endif
-  if (OUT_OF_RANGE_NDX(ndx)) {
-    __glutWarning("glutGetColor: index %d out of range", ndx);
-    return -1.0;
-  }
-  return colormap->cells[ndx].component[comp];
-}
-
-void GLUTAPIENTRY
-glutCopyColormap(int winnum)
-{
-  GLUTwindow *window = __glutWindowList[winnum - 1];
-  GLUTcolormap *oldcmap, *newcmap;
-  XVisualInfo *dstvis;
-
-  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-    oldcmap = __glutCurrentWindow->colormap;
-    dstvis = __glutCurrentWindow->vis;
-    newcmap = window->colormap;
-  } else {
-    oldcmap = __glutCurrentWindow->overlay->colormap;
-    dstvis = __glutCurrentWindow->overlay->vis;
-    if (!window->overlay) {
-      __glutWarning("glutCopyColormap: window %d has no overlay", winnum);
-      return;
-    }
-    newcmap = window->overlay->colormap;
-  }
-
-  if (!oldcmap) {
-    __glutWarning("glutCopyColormap: destination colormap must be color index");
-    return;
-  }
-  if (!newcmap) {
-    __glutWarning(
-      "glutCopyColormap: source colormap of window %d must be color index",
-      winnum);
-    return;
-  }
-  if (newcmap == oldcmap) {
-    /* Source and destination are the same; now copy needed. */
-    return;
-  }
-#if !defined(_WIN32)
-  /* Play safe: compare visual IDs, not Visual*'s. */
-  if (newcmap->visual->visualid == oldcmap->visual->visualid) {
-#endif
-    /* Visuals match!  "Copy" by reference...  */
-    __glutFreeColormap(oldcmap);
-    newcmap->refcnt++;
-    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-      __glutCurrentWindow->colormap = newcmap;
-      __glutCurrentWindow->cmap = newcmap->cmap;
-    } else {
-      __glutCurrentWindow->overlay->colormap = newcmap;
-      __glutCurrentWindow->overlay->cmap = newcmap->cmap;
-    }
-    XSetWindowColormap(__glutDisplay, __glutCurrentWindow->renderWin,
-      newcmap->cmap);
-#if !defined(_WIN32)
-    __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
-  } else {
-    GLUTcolormap *copycmap;
-    XColor color;
-    int i, last;
-
-    /* Visuals different - need a distinct X colormap! */
-    copycmap = __glutAssociateNewColormap(dstvis);
-    /* Wouldn't it be nice if XCopyColormapAndFree could be
-       told not to free the old colormap's entries! */
-    last = newcmap->size;
-    if (last > copycmap->size) {
-      last = copycmap->size;
-    }
-    for (i = last - 1; i >= 0; i--) {
-      if (newcmap->cells[i].component[GLUT_RED] >= 0.0) {
-        color.pixel = i;
-        copycmap->cells[i].component[GLUT_RED] =
-          newcmap->cells[i].component[GLUT_RED];
-        color.red = (GLfloat) 0xffff *
-          newcmap->cells[i].component[GLUT_RED];
-        copycmap->cells[i].component[GLUT_GREEN] =
-          newcmap->cells[i].component[GLUT_GREEN];
-        color.green = (GLfloat) 0xffff *
-          newcmap->cells[i].component[GLUT_GREEN];
-        copycmap->cells[i].component[GLUT_BLUE] =
-          newcmap->cells[i].component[GLUT_BLUE];
-        color.blue = (GLfloat) 0xffff *
-          newcmap->cells[i].component[GLUT_BLUE];
-        color.flags = DoRed | DoGreen | DoBlue;
-        XStoreColor(__glutDisplay, copycmap->cmap, &color);
-      }
-    }
-  }
-#endif
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_cmap.c b/src/glut/glx/glut_cmap.c
deleted file mode 100644
index e6cb742cfec..00000000000
--- a/src/glut/glx/glut_cmap.c
+++ /dev/null
@@ -1,422 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1996, 1997.  */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>  /* SunOS multithreaded assert() needs <stdio.h>.  Lame. */
-#include <assert.h>
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>  /* for XA_RGB_DEFAULT_MAP atom */
-#if defined(__vms)
-#include <Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
-#else
-#include <X11/Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
-#endif
-#endif
-
-/* SGI optimization introduced in IRIX 6.3 to avoid X server
-   round trips for interning common X atoms. */
-#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
-#include <X11/SGIFastAtom.h>
-#else
-#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
-#endif
-
-#include "glutint.h"
-#include "layerutil.h"
-
-GLUTcolormap *__glutColormapList = NULL;
-
-GLUTcolormap *
-__glutAssociateNewColormap(XVisualInfo * vis)
-{
-  GLUTcolormap *cmap;
-  int transparentPixel, i;
-  unsigned long pixels[255];
-
-  cmap = (GLUTcolormap *) malloc(sizeof(GLUTcolormap));
-  if (!cmap)
-    __glutFatalError("out of memory.");
-#if defined(_WIN32)
-  pixels[0] = 0;        /* avoid compilation warnings on win32 */
-  cmap->visual = 0;
-  cmap->size = 256;     /* always assume 256 on Win32 */
-#else
-  cmap->visual = vis->visual;
-  cmap->size = vis->visual->map_entries;
-#endif
-  cmap->refcnt = 1;
-  cmap->cells = (GLUTcolorcell *)
-    malloc(sizeof(GLUTcolorcell) * cmap->size);
-  if (!cmap->cells)
-    __glutFatalError("out of memory.");
-  /* make all color cell entries be invalid */
-  for (i = cmap->size - 1; i >= 0; i--) {
-    cmap->cells[i].component[GLUT_RED] = -1.0;
-    cmap->cells[i].component[GLUT_GREEN] = -1.0;
-    cmap->cells[i].component[GLUT_BLUE] = -1.0;
-  }
-  transparentPixel = __glutGetTransparentPixel(__glutDisplay, vis);
-  if (transparentPixel == -1 || transparentPixel >= cmap->size) {
-
-    /* If there is no transparent pixel or if the transparent
-       pixel is outside the range of valid colormap cells (HP
-       can implement their overlays this smart way since their
-       transparent pixel is 255), we can AllocAll the colormap.
-       See note below.  */
-
-    cmap->cmap = XCreateColormap(__glutDisplay,
-      __glutRoot, cmap->visual, AllocAll);
-  } else {
-
-    /* On machines where zero (or some other value in the range
-       of 0 through map_entries-1), BadAlloc may be generated
-       when an AllocAll overlay colormap is allocated since the
-       transparent pixel precludes all the cells in the colormap
-       being allocated (the transparent pixel is pre-allocated).
-       So in this case, use XAllocColorCells to allocate
-       map_entries-1 pixels (that is, all but the transparent
-       pixel.  */
-
-#if defined(_WIN32)
-    cmap->cmap = XCreateColormap(__glutDisplay,
-      __glutRoot, 0, AllocNone);
-#else
-    cmap->cmap = XCreateColormap(__glutDisplay,
-      __glutRoot, vis->visual, AllocNone);
-    XAllocColorCells(__glutDisplay, cmap->cmap, False, 0, 0,
-      pixels, cmap->size - 1);
-#endif
-  }
-  cmap->next = __glutColormapList;
-  __glutColormapList = cmap;
-  return cmap;
-}
-
-static GLUTcolormap *
-associateColormap(XVisualInfo * vis)
-{
-#if !defined(_WIN32)
-  GLUTcolormap *cmap = __glutColormapList;
-
-  while (cmap != NULL) {
-    /* Play safe: compare visual IDs, not Visual*'s. */
-    if (cmap->visual->visualid == vis->visual->visualid) {
-      /* Already have created colormap for the visual. */
-      cmap->refcnt++;
-      return cmap;
-    }
-    cmap = cmap->next;
-  }
-#endif
-  return __glutAssociateNewColormap(vis);
-}
-
-void
-__glutSetupColormap(XVisualInfo * vi, GLUTcolormap ** colormap, Colormap * cmap)
-{
-#if defined(_WIN32)
-  if (vi->dwFlags & PFD_NEED_PALETTE || vi->iPixelType == PFD_TYPE_COLORINDEX) {
-    *colormap = associateColormap(vi);
-    *cmap = (*colormap)->cmap;
-  } else {
-    *colormap = NULL;
-    *cmap = 0;
-  }
-#else
-  Status status;
-  XStandardColormap *standardCmaps;
-  int i, numCmaps;
-  static Atom hpColorRecoveryAtom = -1;
-  int isRGB, visualClass, rc;
-
-#if defined(__cplusplus) || defined(c_plusplus)
-  visualClass = vi->c_class;
-#else
-  visualClass = vi->class;
-#endif
-  switch (visualClass) {
-  case PseudoColor:
-    /* Mesa might return a PseudoColor visual for RGB mode. */
-    rc = glXGetConfig(__glutDisplay, vi, GLX_RGBA, &isRGB);
-    if (rc == 0 && isRGB) {
-      /* Must be Mesa. */
-      *colormap = NULL;
-      if (MaxCmapsOfScreen(DefaultScreenOfDisplay(__glutDisplay)) == 1
-        && vi->visual == DefaultVisual(__glutDisplay, __glutScreen)) {
-        char *privateCmap = getenv("MESA_PRIVATE_CMAP");
-
-        if (privateCmap) {
-          /* User doesn't want to share colormaps. */
-          *cmap = XCreateColormap(__glutDisplay, __glutRoot,
-            vi->visual, AllocNone);
-        } else {
-          /* Share the root colormap. */
-          *cmap = DefaultColormap(__glutDisplay, __glutScreen);
-        }
-      } else {
-        /* Get our own PseudoColor colormap. */
-        *cmap = XCreateColormap(__glutDisplay, __glutRoot,
-          vi->visual, AllocNone);
-      }
-    } else {
-      /* CI mode, real GLX never returns a PseudoColor visual
-         for RGB mode. */
-      *colormap = associateColormap(vi);
-      *cmap = (*colormap)->cmap;
-    }
-    break;
-  case TrueColor:
-    *colormap = NULL;   /* NULL if RGBA */
-
-    /* Hewlett-Packard supports a feature called "HP Color
-       Recovery". Mesa has code to use HP Color Recovery.  For
-       Mesa to use this feature, the atom
-       _HP_RGB_SMOOTH_MAP_LIST must be defined on the root
-       window AND the colormap obtainable by XGetRGBColormaps
-       for that atom must be set on the window.  If that
-       colormap is not set, the output will look stripy. */
-
-    if (hpColorRecoveryAtom == -1) {
-      char *xvendor;
-
-#define VENDOR_HP "Hewlett-Packard"
-
-      /* Only makes sense to make XInternAtom round-trip if we
-         know that we are connected to an HP X server. */
-      xvendor = ServerVendor(__glutDisplay);
-      if (!strncmp(xvendor, VENDOR_HP, sizeof(VENDOR_HP) - 1)) {
-        hpColorRecoveryAtom = XInternAtom(__glutDisplay, "_HP_RGB_SMOOTH_MAP_LIST", True);
-      } else {
-        hpColorRecoveryAtom = None;
-      }
-    }
-    if (hpColorRecoveryAtom != None) {
-      status = XGetRGBColormaps(__glutDisplay, __glutRoot,
-        &standardCmaps, &numCmaps, hpColorRecoveryAtom);
-      if (status == 1) {
-        for (i = 0; i < numCmaps; i++) {
-          if (standardCmaps[i].visualid == vi->visualid) {
-            *cmap = standardCmaps[i].colormap;
-            XFree(standardCmaps);
-            return;
-          }
-        }
-        XFree(standardCmaps);
-      }
-    }
-#ifndef SOLARIS_2_4_BUG
-    /* Solaris 2.4 and 2.5 have a bug in their
-       XmuLookupStandardColormap implementations.  Please
-       compile your Solaris 2.4 or 2.5 version of GLUT with
-       -DSOLARIS_2_4_BUG to work around this bug. The symptom
-       of the bug is that programs will get a BadMatch error
-       from X_CreateWindow when creating a GLUT window because
-       Solaris 2.4 and 2.5 create a  corrupted RGB_DEFAULT_MAP
-       property.  Note that this workaround prevents Colormap
-       sharing between applications, perhaps leading
-       unnecessary colormap installations or colormap flashing.
-       Sun fixed this bug in Solaris 2.6. */
-    status = XmuLookupStandardColormap(__glutDisplay,
-      vi->screen, vi->visualid, vi->depth, XA_RGB_DEFAULT_MAP,
-      /* replace */ False, /* retain */ True);
-    if (status == 1) {
-      status = XGetRGBColormaps(__glutDisplay, __glutRoot,
-        &standardCmaps, &numCmaps, XA_RGB_DEFAULT_MAP);
-      if (status == 1) {
-        for (i = 0; i < numCmaps; i++) {
-          if (standardCmaps[i].visualid == vi->visualid) {
-            *cmap = standardCmaps[i].colormap;
-            XFree(standardCmaps);
-            return;
-          }
-        }
-        XFree(standardCmaps);
-      }
-    }
-#endif
-    /* If no standard colormap but TrueColor, just make a
-       private one. */
-    /* XXX Should do a better job of internal sharing for
-       privately allocated TrueColor colormaps. */
-    *cmap = XCreateColormap(__glutDisplay, __glutRoot,
-      vi->visual, AllocNone);
-    break;
-  case DirectColor:
-    *colormap = NULL;   /* NULL if RGBA */
-    *cmap = XCreateColormap(__glutDisplay, __glutRoot,
-                            vi->visual, AllocAll);
-    if (vi->depth == 24) {
-      /* init the red, green, blue maps to linear ramps */
-      XColor xc[256];
-      int i;
-      for (i = 0; i < 256; i++) {
-        xc[i].pixel = (i << 16) | (i << 8) | i;
-        xc[i].red = (i << 8) | i;
-        xc[i].green = (i << 8) | i;
-        xc[i].blue = (i << 8) | i;
-        xc[i].flags = DoRed | DoGreen | DoBlue;
-      }
-      XStoreColors(__glutDisplay, *cmap, xc, 256);
-    }
-    else {
-       fprintf(stderr, "GLUT Error: DirectColor visuals other than 24-bits "
-               "not fully supported.\n");
-    }
-    break;
-  case StaticColor:
-  case StaticGray:
-  case GrayScale:
-    /* Mesa supports these visuals */
-    *colormap = NULL;
-    *cmap = XCreateColormap(__glutDisplay, __glutRoot,
-      vi->visual, AllocNone);
-    break;
-  default:
-    __glutFatalError(
-      "could not allocate colormap for visual type: %d.",
-      visualClass);
-  }
-  return;
-#endif
-}
-
-#if !defined(_WIN32)
-static int
-findColormaps(GLUTwindow * window,
-  Window * winlist, Colormap * cmaplist, int num, int max)
-{
-  GLUTwindow *child;
-  int i;
-
-  /* Do not allow more entries that maximum number of
-     colormaps! */
-  if (num >= max)
-    return num;
-  /* Is cmap for this window already on the list? */
-  for (i = 0; i < num; i++) {
-    if (cmaplist[i] == window->cmap)
-      goto normalColormapAlreadyListed;
-  }
-  /* Not found on the list; add colormap and window. */
-  winlist[num] = window->win;
-  cmaplist[num] = window->cmap;
-  num++;
-
-normalColormapAlreadyListed:
-
-  /* Repeat above but for the overlay colormap if there one. */
-  if (window->overlay) {
-    if (num >= max)
-      return num;
-    for (i = 0; i < num; i++) {
-      if (cmaplist[i] == window->overlay->cmap)
-        goto overlayColormapAlreadyListed;
-    }
-    winlist[num] = window->overlay->win;
-    cmaplist[num] = window->overlay->cmap;
-    num++;
-  }
-overlayColormapAlreadyListed:
-
-  /* Recursively search children. */
-  child = window->children;
-  while (child) {
-    num = findColormaps(child, winlist, cmaplist, num, max);
-    child = child->siblings;
-  }
-  return num;
-}
-
-void
-__glutEstablishColormapsProperty(GLUTwindow * window)
-{
-  /* this routine is strictly X.  Win32 doesn't need to do
-     anything of this sort (but has to do other wacky stuff
-     later). */
-  static Atom wmColormapWindows = None;
-  Window *winlist;
-  Colormap *cmaplist;
-  Status status;
-  int maxcmaps, num, i;
-
-  assert(!window->parent);
-  maxcmaps = MaxCmapsOfScreen(ScreenOfDisplay(__glutDisplay,
-      __glutScreen));
-  /* For portability reasons we don't use alloca for winlist
-     and cmaplist, but we could. */
-  winlist = (Window *) malloc(maxcmaps * sizeof(Window));
-  cmaplist = (Colormap *) malloc(maxcmaps * sizeof(Colormap));
-  for (i = 0; i < maxcmaps; i++) {
-    cmaplist[i] = 0;
-  }
-  num = findColormaps(window, winlist, cmaplist, 0, maxcmaps);
-  if (num < 2) {
-    /* Property no longer needed; remove it. */
-    wmColormapWindows = XSGIFastInternAtom(__glutDisplay,
-      "WM_COLORMAP_WINDOWS", SGI_XA_WM_COLORMAP_WINDOWS, False);
-    if (wmColormapWindows == None) {
-      __glutWarning("Could not intern X atom for WM_COLORMAP_WINDOWS.");
-      return;
-    }
-    XDeleteProperty(__glutDisplay, window->win, wmColormapWindows);
-  } else {
-    status = XSetWMColormapWindows(__glutDisplay, window->win,
-      winlist, num);
-    /* XSetWMColormapWindows should always work unless the
-       WM_COLORMAP_WINDOWS property cannot be intern'ed.  We
-       check to be safe. */
-    if (status == False)
-      __glutFatalError("XSetWMColormapWindows returned False.");
-  }
-  /* For portability reasons we don't use alloca for winlist
-     and cmaplist, but we could. */
-  free(winlist);
-  free(cmaplist);
-}
-
-GLUTwindow *
-__glutToplevelOf(GLUTwindow * window)
-{
-  while (window->parent) {
-    window = window->parent;
-  }
-  return window;
-}
-#endif
-
-void
-__glutFreeColormap(GLUTcolormap * cmap)
-{
-  GLUTcolormap *cur, **prev;
-
-  cmap->refcnt--;
-  if (cmap->refcnt == 0) {
-    /* remove from colormap list */
-    cur = __glutColormapList;
-    prev = &__glutColormapList;
-    while (cur) {
-      if (cur == cmap) {
-        *prev = cmap->next;
-        break;
-      }
-      prev = &(cur->next);
-      cur = cur->next;
-    }
-    /* actually free colormap */
-    XFreeColormap(__glutDisplay, cmap->cmap);
-    free(cmap->cells);
-    free(cmap);
-  }
-}
-
diff --git a/src/glut/glx/glut_cursor.c b/src/glut/glx/glut_cursor.c
deleted file mode 100644
index 797cb49fb09..00000000000
--- a/src/glut/glx/glut_cursor.c
+++ /dev/null
@@ -1,201 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1995, 1998. */
-
-/* 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. */
-
-#include "glutint.h"
-
-#if !defined(_WIN32)
-#include <X11/Xatom.h>  /* For XA_CURSOR */
-#include <X11/cursorfont.h>
-#endif
-
-typedef struct _CursorTable {
-#if defined(_WIN32)
-  char* glyph;
-#else
-  int glyph;
-#endif
-  Cursor cursor;
-} CursorTable;
-/* *INDENT-OFF* */
-
-static CursorTable cursorTable[] = {
-  {XC_arrow, None},		  /* GLUT_CURSOR_RIGHT_ARROW */
-  {XC_top_left_arrow, None},	  /* GLUT_CURSOR_LEFT_ARROW */
-  {XC_hand1, None},		  /* GLUT_CURSOR_INFO */
-  {XC_pirate, None},		  /* GLUT_CURSOR_DESTROY */
-  {XC_question_arrow, None},	  /* GLUT_CURSOR_HELP */
-  {XC_exchange, None},		  /* GLUT_CURSOR_CYCLE */
-  {XC_spraycan, None},		  /* GLUT_CURSOR_SPRAY */
-  {XC_watch, None},		  /* GLUT_CURSOR_WAIT */
-  {XC_xterm, None},		  /* GLUT_CURSOR_TEXT */
-  {XC_crosshair, None},		  /* GLUT_CURSOR_CROSSHAIR */
-  {XC_sb_v_double_arrow, None},	  /* GLUT_CURSOR_UP_DOWN */
-  {XC_sb_h_double_arrow, None},	  /* GLUT_CURSOR_LEFT_RIGHT */
-  {XC_top_side, None},		  /* GLUT_CURSOR_TOP_SIDE */
-  {XC_bottom_side, None},	  /* GLUT_CURSOR_BOTTOM_SIDE */
-  {XC_left_side, None},		  /* GLUT_CURSOR_LEFT_SIDE */
-  {XC_right_side, None},	  /* GLUT_CURSOR_RIGHT_SIDE */
-  {XC_top_left_corner, None},	  /* GLUT_CURSOR_TOP_LEFT_CORNER */
-  {XC_top_right_corner, None},	  /* GLUT_CURSOR_TOP_RIGHT_CORNER */
-  {XC_bottom_right_corner, None}, /* GLUT_CURSOR_BOTTOM_RIGHT_CORNER */
-  {XC_bottom_left_corner, None},  /* GLUT_CURSOR_BOTTOM_LEFT_CORNER */
-};
-/* *INDENT-ON* */
-
-#if !defined(_WIN32)
-static Cursor blankCursor = None;
-static Cursor fullCrosshairCusor = None;
-
-/* SGI X server's support a special property called the
-   _SGI_CROSSHAIR_CURSOR that when installed as a window's
-   cursor, becomes a full screen crosshair cursor.  SGI
-   has special cursor generation hardware for this case. */
-static Cursor
-getFullCrosshairCursor(void)
-{
-  Cursor cursor;
-  Atom crosshairAtom, actualType;
-  int rc, actualFormat;
-  unsigned long n, left;
-  unsigned char *value;
-
-  if (fullCrosshairCusor == None) {
-    crosshairAtom = XInternAtom(__glutDisplay,
-      "_SGI_CROSSHAIR_CURSOR", True);
-    if (crosshairAtom != None) {
-      value = 0;        /* Make compiler happy. */
-      rc = XGetWindowProperty(__glutDisplay, __glutRoot,
-        crosshairAtom, 0, 1, False, XA_CURSOR, &actualType,
-        &actualFormat, &n, &left, &value);
-      if (rc == Success && actualFormat == 32 && n >= 1) {
-        cursor = ((unsigned long *)value)[0];
-        XFree(value);
-        return cursor;
-      }
-    }
-  }
-  return XCreateFontCursor(__glutDisplay, XC_crosshair);
-}
-
-/* X11 forces you to create a blank cursor if you want
-   to disable the cursor. */
-static Cursor
-makeBlankCursor(void)
-{
-  static char data[1] =
-  {0};
-  Cursor cursor;
-  Pixmap blank;
-  XColor dummy;
-
-  blank = XCreateBitmapFromData(__glutDisplay, __glutRoot,
-    data, 1, 1);
-  if (blank == None)
-    __glutFatalError("out of memory.");
-  cursor = XCreatePixmapCursor(__glutDisplay, blank, blank,
-    &dummy, &dummy, 0, 0);
-  XFreePixmap(__glutDisplay, blank);
-
-  return cursor;
-}
-#endif /* !_WIN32 */
-
-/* Win32 and X11 use this same function to accomplish
-   fairly different tasks.  X11 lets you just define the
-   cursor for a window and the window system takes care
-   of making sure that the window's cursor is installed
-   when the mouse is in the window.  Win32 requires the
-   application to handle a WM_SETCURSOR message to install
-   the right cursor when windows are entered.  Think of
-   the Win32 __glutSetCursor (called from __glutWindowProc)
-   as "install cursor".  Think of the X11 __glutSetCursor
-   (called from glutSetCursor) as "define cursor". */
-void 
-__glutSetCursor(GLUTwindow *window)
-{
-  int cursor = window->cursor;
-  Cursor xcursor = 0;
-
-  if (cursor >= 0 &&
-    cursor < sizeof(cursorTable) / sizeof(cursorTable[0])) {
-    if (cursorTable[cursor].cursor == None) {
-      cursorTable[cursor].cursor = XCreateFontCursor(__glutDisplay,
-        cursorTable[cursor].glyph);
-    }
-    xcursor = cursorTable[cursor].cursor;
-  } else {
-    /* Special cases. */
-    switch (cursor) {
-    case GLUT_CURSOR_INHERIT:
-#if defined(_WIN32)
-      while (window->parent) {
-        window = window->parent;
-        if (window->cursor != GLUT_CURSOR_INHERIT) {
-          __glutSetCursor(window);
-          return;
-        }
-      }
-      /* XXX Default to an arrow cursor.  Is this
-         right or should we be letting the default
-         window proc be installing some system cursor? */
-      xcursor = cursorTable[0].cursor;
-      if (xcursor == NULL) {
-        xcursor =
-          cursorTable[0].cursor =
-          LoadCursor(NULL, cursorTable[0].glyph);
-      }
-#else
-      xcursor = None;
-#endif
-      break;
-    case GLUT_CURSOR_NONE:
-#if defined(_WIN32)
-      xcursor = NULL;
-#else
-      if (blankCursor == None) {
-        blankCursor = makeBlankCursor();
-      }
-      xcursor = blankCursor;
-#endif
-      break;
-    case GLUT_CURSOR_FULL_CROSSHAIR:
-#if defined(_WIN32)
-      xcursor = (HICON) IDC_CROSS;
-#else
-      if (fullCrosshairCusor == None) {
-        fullCrosshairCusor = getFullCrosshairCursor();
-      }
-      xcursor = fullCrosshairCusor;
-#endif
-      break;
-    }
-  }
-  XDefineCursor(__glutDisplay,
-    window->win, xcursor);
-  XFlush(__glutDisplay);
-}
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutSetCursor(int cursor)
-{
-#ifdef _WIN32
-  POINT point;
-
-  __glutCurrentWindow->cursor = cursor;
-  /* Are we in the window right now?  If so,
-     install the cursor. */
-  GetCursorPos(&point);
-  if (__glutCurrentWindow->win == WindowFromPoint(point)) {
-    __glutSetCursor(__glutCurrentWindow);
-  }
-#else
-  __glutCurrentWindow->cursor = cursor;
-  __glutSetCursor(__glutCurrentWindow);
-#endif
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_dials.c b/src/glut/glx/glut_dials.c
deleted file mode 100644
index e015b91bc42..00000000000
--- a/src/glut/glx/glut_dials.c
+++ /dev/null
@@ -1,26 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-
-void GLUTAPIENTRY 
-glutButtonBoxFunc(GLUTbuttonBoxCB buttonBoxFunc)
-{
-  __glutCurrentWindow->buttonBox = buttonBoxFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
-
-void GLUTAPIENTRY 
-glutDialsFunc(GLUTdialsCB dialsFunc)
-{
-  __glutCurrentWindow->dials = dialsFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
diff --git a/src/glut/glx/glut_dstr.c b/src/glut/glx/glut_dstr.c
deleted file mode 100644
index 319930c4b11..00000000000
--- a/src/glut/glx/glut_dstr.c
+++ /dev/null
@@ -1,1626 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1997. */
-
-/* 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. */
-
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "glutint.h"
-
-/* glxcaps matches the criteria macros listed in glutint.h, but
-   only list the first set (those that correspond to GLX visual
-   attributes). */
-static int glxcap[NUM_GLXCAPS] =
-{
-  GLX_RGBA,
-  GLX_BUFFER_SIZE,
-  GLX_DOUBLEBUFFER,
-  GLX_STEREO,
-  GLX_AUX_BUFFERS,
-  GLX_RED_SIZE,
-  GLX_GREEN_SIZE,
-  GLX_BLUE_SIZE,
-  GLX_ALPHA_SIZE,
-  GLX_DEPTH_SIZE,
-  GLX_STENCIL_SIZE,
-  GLX_ACCUM_RED_SIZE,
-  GLX_ACCUM_GREEN_SIZE,
-  GLX_ACCUM_BLUE_SIZE,
-  GLX_ACCUM_ALPHA_SIZE,
-  GLX_LEVEL,
-};
-
-#ifdef TEST
-
-#if !defined(_WIN32)
-char *__glutProgramName = "dstr";
-Display *__glutDisplay;
-int __glutScreen;
-XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc) = NULL;
-char *__glutDisplayString = NULL;
-#endif
-static int verbose = 0;
-
-static char *compstr[] =
-{
-  "none", "=", "!=", "<=", ">=", ">", "<", "~"
-};
-static char *capstr[] =
-{
-  "rgba", "bufsize", "double", "stereo", "auxbufs", "red", "green", "blue", "alpha",
-  "depth", "stencil", "acred", "acgreen", "acblue", "acalpha", "level", "xvisual",
-  "transparent", "samples", "xstaticgray", "xgrayscale", "xstaticcolor", "xpseudocolor",
-  "xtruecolor", "xdirectcolor", "slow", "conformant", "num"
-};
-
-static void
-printCriteria(Criterion * criteria, int ncriteria)
-{
-  int i;
-  printf("Criteria: %d\n", ncriteria);
-  for (i = 0; i < ncriteria; i++) {
-    printf("  %s %s %d\n",
-      capstr[criteria[i].capability],
-      compstr[criteria[i].comparison],
-      criteria[i].value);
-  }
-}
-
-#endif /* TEST */
-
-static int isMesaGLX = -1;
-
-static int
-determineMesaGLX(void)
-{
-#ifdef GLX_VERSION_1_1
-  const char *vendor, *version, *ch;
-
-  vendor = glXGetClientString(__glutDisplay, GLX_VENDOR);
-  if (!strcmp(vendor, "Brian Paul")) {
-    version = glXGetClientString(__glutDisplay, GLX_VERSION);
-    for (ch = version; *ch != ' ' && *ch != '\0'; ch++);
-    for (; *ch == ' ' && *ch != '\0'; ch++);
-
-#define MESA_NAME "Mesa "  /* Trailing space is intentional. */
-
-    if (!strncmp(MESA_NAME, ch, sizeof(MESA_NAME) - 1)) {
-      return 1;
-    }
-  }
-#else
-  /* Recent versions for Mesa should support GLX 1.1 and
-     therefore glXGetClientString.  If we get into this case,
-     we would be compiling against a true OpenGL not supporting
-     GLX 1.1, and the resulting compiled library won't work well 
-     with Mesa then. */
-#endif
-  return 0;
-}
-
-static XVisualInfo **
-getMesaVisualList(int *n)
-{
-  XVisualInfo **vlist, *vinfo;
-  int attribs[23];
-  int i, x, cnt;
-
-  vlist = (XVisualInfo **) malloc((32 + 16) * sizeof(XVisualInfo *));
-  if (!vlist)
-    __glutFatalError("out of memory.");
-
-  cnt = 0;
-  for (i = 0; i < 32; i++) {
-    x = 0;
-    attribs[x] = GLX_RGBA;
-    x++;
-    attribs[x] = GLX_RED_SIZE;
-    x++;
-    attribs[x] = 1;
-    x++;
-    attribs[x] = GLX_GREEN_SIZE;
-    x++;
-    attribs[x] = 1;
-    x++;
-    attribs[x] = GLX_BLUE_SIZE;
-    x++;
-    attribs[x] = 1;
-    x++;
-    if (i & 1) {
-      attribs[x] = GLX_DEPTH_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-    }
-    if (i & 2) {
-      attribs[x] = GLX_STENCIL_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-    }
-    if (i & 4) {
-      attribs[x] = GLX_ACCUM_RED_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-      attribs[x] = GLX_ACCUM_GREEN_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-      attribs[x] = GLX_ACCUM_BLUE_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-    }
-    if (i & 8) {
-      attribs[x] = GLX_ALPHA_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-      if (i & 4) {
-        attribs[x] = GLX_ACCUM_ALPHA_SIZE;
-        x++;
-        attribs[x] = 1;
-        x++;
-      }
-    }
-    if (i & 16) {
-      attribs[x] = GLX_DOUBLEBUFFER;
-      x++;
-    }
-    attribs[x] = None;
-    x++;
-    assert(x <= sizeof(attribs) / sizeof(attribs[0]));
-    vinfo = glXChooseVisual(__glutDisplay, __glutScreen, attribs);
-    if (vinfo) {
-      vlist[cnt] = vinfo;
-      cnt++;
-    }
-  }
-  for (i = 0; i < 16; i++) {
-    x = 0;
-    if (i & 1) {
-      attribs[x] = GLX_DEPTH_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-    }
-    if (i & 2) {
-      attribs[x] = GLX_STENCIL_SIZE;
-      x++;
-      attribs[x] = 1;
-      x++;
-    }
-    if (i & 4) {
-      attribs[x] = GLX_DOUBLEBUFFER;
-      x++;
-    }
-    if (i & 8) {
-      attribs[x] = GLX_LEVEL;
-      x++;
-      attribs[x] = 1;
-      x++;
-#if defined(GLX_TRANSPARENT_TYPE_EXT) && defined(GLX_TRANSPARENT_INDEX_EXT)
-      attribs[x] = GLX_TRANSPARENT_TYPE_EXT;
-      x++;
-      attribs[x] = GLX_TRANSPARENT_INDEX_EXT;
-      x++;
-#endif
-    }
-    attribs[x] = None;
-    x++;
-    assert(x <= sizeof(attribs) / sizeof(attribs[0]));
-    vinfo = glXChooseVisual(__glutDisplay, __glutScreen, attribs);
-    if (vinfo) {
-      vlist[cnt] = vinfo;
-      cnt++;
-    }
-  }
-
-  *n = cnt;
-  return vlist;
-}
-
-static FrameBufferMode *
-loadVisuals(int *nitems_return)
-{
-  XVisualInfo *vinfo, **vlist, template;
-  FrameBufferMode *fbmodes, *mode;
-  int n, i, j, rc, glcapable;
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-  int multisample;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-  int visual_info;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
-  int visual_rating;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-  int fbconfig;
-#endif
-
-  isMesaGLX = determineMesaGLX();
-  if (isMesaGLX) {
-    vlist = getMesaVisualList(&n);
-  } else {
-#if !defined(_WIN32)
-    template.screen = __glutScreen;
-    vinfo = XGetVisualInfo(__glutDisplay, VisualScreenMask, &template, &n);
-#else
-    vinfo = XGetVisualInfo(__glutDisplay, 0, &template, &n);
-#endif
-    if (vinfo == NULL) {
-      *nitems_return = 0;
-      return NULL;
-    }
-    assert(n > 0);
-
-    /* Make an array of XVisualInfo* pointers to help the Mesa
-       case because each glXChooseVisual call returns a
-       distinct XVisualInfo*, not a handy array like
-       XGetVisualInfo.  (Mesa expects us to return the _exact_
-       pointer returned by glXChooseVisual so we could not just
-       copy the returned structure.) */
-    vlist = (XVisualInfo **) malloc(n * sizeof(XVisualInfo *));
-    if (!vlist)
-      __glutFatalError("out of memory.");
-    for (i = 0; i < n; i++) {
-      vlist[i] = &vinfo[i];
-    }
-  }
-
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-  multisample = __glutIsSupportedByGLX("GLX_SGIS_multisample") ||
-                __glutIsSupportedByGLX("GLX_ARB_multisample");
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-  visual_info = __glutIsSupportedByGLX("GLX_EXT_visual_info");
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
-  visual_rating = __glutIsSupportedByGLX("GLX_EXT_visual_rating");
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-  fbconfig = __glutIsSupportedByGLX("GLX_SGIX_fbconfig");
-#endif
-
-  fbmodes = (FrameBufferMode *) malloc(n * sizeof(FrameBufferMode));
-  if (fbmodes == NULL) {
-    *nitems_return = -1;
-    free(vlist);
-    return NULL;
-  }
-  for (i = 0; i < n; i++) {
-    mode = &fbmodes[i];
-    mode->vi = vlist[i];
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-    mode->fbc = NULL;
-#endif
-    rc = glXGetConfig(__glutDisplay, vlist[i], GLX_USE_GL, &glcapable);
-    if (rc == 0 && glcapable) {
-      mode->valid = 1;  /* Assume the best until proven
-                           otherwise. */
-      for (j = 0; j < NUM_GLXCAPS; j++) {
-        rc = glXGetConfig(__glutDisplay, vlist[i], glxcap[j], &mode->cap[j]);
-        if (rc != 0) {
-          mode->valid = 0;
-        }
-      }
-#if defined(_WIN32)
-      mode->cap[XVISUAL] = ChoosePixelFormat(XHDC, vlist[i]);
-#else
-      mode->cap[XVISUAL] = (int) vlist[i]->visualid;
-#endif
-      mode->cap[XSTATICGRAY] = 0;
-      mode->cap[XGRAYSCALE] = 0;
-      mode->cap[XSTATICCOLOR] = 0;
-      mode->cap[XPSEUDOCOLOR] = 0;
-      mode->cap[XTRUECOLOR] = 0;
-      mode->cap[XDIRECTCOLOR] = 0;
-#if !defined(_WIN32)
-#if defined(__cplusplus) || defined(c_plusplus)
-      switch (vlist[i]->c_class) {
-#else
-      switch (vlist[i]->class) {
-#endif
-      case StaticGray:
-        mode->cap[XSTATICGRAY] = 1;
-        break;
-      case GrayScale:
-        mode->cap[XGRAYSCALE] = 1;
-        break;
-      case StaticColor:
-        mode->cap[XSTATICCOLOR] = 1;
-        break;
-      case PseudoColor:
-        mode->cap[XPSEUDOCOLOR] = 1;
-        break;
-      case TrueColor:
-        mode->cap[XTRUECOLOR] = 1;
-        break;
-      case DirectColor:
-        mode->cap[XDIRECTCOLOR] = 1;
-        break;
-      }
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
-      if (visual_rating) {
-        int rating;
-
-/* [email protected] reported that DEC UNIX (OSF1) V4.0
-   564 for Alpha did not properly define GLX_VISUAL_CAVEAT_EXT
-   in <GL/glx.h> despite claiming to support
-   GLX_EXT_visual_rating. */
-#ifndef GLX_VISUAL_CAVEAT_EXT
-#define GLX_VISUAL_CAVEAT_EXT 0x20
-#endif
-
-        rc = glXGetConfig(__glutDisplay,
-	  vlist[i], GLX_VISUAL_CAVEAT_EXT, &rating);
-        if (rc != 0) {
-          mode->cap[SLOW] = 0;
-          mode->cap[CONFORMANT] = 1;
-        } else {
-          switch (rating) {
-          case GLX_SLOW_VISUAL_EXT:
-            mode->cap[SLOW] = 1;
-            mode->cap[CONFORMANT] = 1;
-            break;
-
-/* IRIX 5.3 for the R10K Indigo2 may have shipped without this
-   properly defined in /usr/include/GL/glxtokens.h */
-#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
-#define GLX_NON_CONFORMANT_VISUAL_EXT   0x800D
-#endif
-
-          case GLX_NON_CONFORMANT_VISUAL_EXT:
-            mode->cap[SLOW] = 0;
-            mode->cap[CONFORMANT] = 0;
-            break;
-          case GLX_NONE_EXT:
-          default:     /* XXX Hopefully this is a good default
-                           assumption. */
-            mode->cap[SLOW] = 0;
-            mode->cap[CONFORMANT] = 1;
-            break;
-          }
-        }
-      } else {
-        mode->cap[TRANSPARENT] = 0;
-      }
-#else
-      mode->cap[SLOW] = 0;
-      mode->cap[CONFORMANT] = 1;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-      if (visual_info) {
-        int transparent;
-
-/* [email protected] reported that DEC UNIX (OSF1) V4.0
-   564 for Alpha did not properly define
-   GLX_TRANSPARENT_TYPE_EXT in <GL/glx.h> despite claiming to
-   support GLX_EXT_visual_info. */
-#ifndef GLX_TRANSPARENT_TYPE_EXT
-#define GLX_TRANSPARENT_TYPE_EXT 0x23
-#endif
-
-        rc = glXGetConfig(__glutDisplay,
-          vlist[i], GLX_TRANSPARENT_TYPE_EXT, &transparent);
-        if (rc != 0) {
-          mode->cap[TRANSPARENT] = 0;
-        } else {
-          mode->cap[TRANSPARENT] = (transparent != GLX_NONE_EXT);
-        }
-      } else {
-        mode->cap[TRANSPARENT] = 0;
-      }
-#else
-      mode->cap[TRANSPARENT] = 0;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
-      if (multisample) {
-        rc = glXGetConfig(__glutDisplay,
-	  vlist[i], GLX_SAMPLES_SGIS, &mode->cap[SAMPLES]);
-        if (rc != 0) {
-          mode->cap[SAMPLES] = 0;
-        }
-      } else {
-        mode->cap[SAMPLES] = 0;
-      }
-#else
-      mode->cap[SAMPLES] = 0;
-#endif
-    } else {
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-      if (fbconfig) {
-        GLXFBConfigSGIX fbc;
-        int fbconfigID, drawType, renderType;
-
-        fbc = __glut_glXGetFBConfigFromVisualSGIX(__glutDisplay, vlist[i]);
-        if (fbc) {
-          rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
-	    GLX_FBCONFIG_ID_SGIX, &fbconfigID);
-          if ((rc == 0) && (fbconfigID != None)) {
-            rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
-	      GLX_DRAWABLE_TYPE_SGIX, &drawType);
-            if ((rc == 0) && (drawType & GLX_WINDOW_BIT_SGIX)) {
-              rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay, fbc,
-	        GLX_RENDER_TYPE_SGIX, &renderType);
-              if ((rc == 0) && (renderType & GLX_RGBA_BIT_SGIX)) {
-                mode->fbc = fbc;
-                mode->valid = 1;  /* Assume the best until
-                                     proven otherwise. */
-
-		assert(glxcap[0] == GLX_RGBA);
-                mode->cap[0] = 1;
-
-                /* Start with "j = 1" to skip the GLX_RGBA attribute. */
-                for (j = 1; j < NUM_GLXCAPS; j++) {
-                  rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay,
-		    fbc, glxcap[j], &mode->cap[j]);
-                  if (rc != 0) {
-                    mode->valid = 0;
-                  }
-                }
-
-                mode->cap[XVISUAL] = (int) vlist[i]->visualid;
-                mode->cap[XSTATICGRAY] = 0;
-                mode->cap[XGRAYSCALE] = 0;
-                mode->cap[XSTATICCOLOR] = 0;
-                mode->cap[XPSEUDOCOLOR] = 0;
-                mode->cap[XTRUECOLOR] = 0;
-                mode->cap[XDIRECTCOLOR] = 0;
-#if defined(__cplusplus) || defined(c_plusplus)
-                switch (vlist[i]->c_class) {
-#else
-                switch (vlist[i]->class) {
-#endif
-                case StaticGray:
-                  mode->cap[XSTATICGRAY] = 1;
-                  break;
-                case GrayScale:
-                  mode->cap[XGRAYSCALE] = 1;
-                  break;
-                case StaticColor:
-                  mode->cap[XSTATICCOLOR] = 1;
-                  break;
-                case PseudoColor:
-                  mode->cap[XPSEUDOCOLOR] = 1;
-                  break;
-                case TrueColor:
-                  mode->cap[XTRUECOLOR] = 1;
-                  break;
-                case DirectColor:
-                  mode->cap[XDIRECTCOLOR] = 1;
-                  break;
-                }
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
-                if (visual_rating) {
-                  int rating;
-
-/* [email protected] reported that DEC UNIX (OSF1) V4.0
-   564 for Alpha did not properly define GLX_VISUAL_CAVEAT_EXT
-   in <GL/glx.h> despite claiming to support
-   GLX_EXT_visual_rating. */
-#ifndef GLX_VISUAL_CAVEAT_EXT
-#define GLX_VISUAL_CAVEAT_EXT 0x20
-#endif
-
-                  rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay,
-		    fbc, GLX_VISUAL_CAVEAT_EXT, &rating);
-                  if (rc != 0) {
-                    mode->cap[SLOW] = 0;
-                    mode->cap[CONFORMANT] = 1;
-                  } else {
-                    switch (rating) {
-                    case GLX_SLOW_VISUAL_EXT:
-                      mode->cap[SLOW] = 1;
-                      mode->cap[CONFORMANT] = 1;
-                      break;
-
-/* IRIX 5.3 for the R10K Indigo2 may have shipped without this
-   properly defined in /usr/include/GL/glxtokens.h */
-#ifndef GLX_NON_CONFORMANT_VISUAL_EXT
-#define GLX_NON_CONFORMANT_VISUAL_EXT   0x800D
-#endif
-
-                    case GLX_NON_CONFORMANT_VISUAL_EXT:
-                      mode->cap[SLOW] = 0;
-                      mode->cap[CONFORMANT] = 0;
-                      break;
-                    case GLX_NONE_EXT:
-                    default:  /* XXX Hopefully this is a good
-                                  default assumption. */
-                      mode->cap[SLOW] = 0;
-                      mode->cap[CONFORMANT] = 1;
-                      break;
-                    }
-                  }
-                } else {
-                  mode->cap[TRANSPARENT] = 0;
-                }
-#else
-                mode->cap[SLOW] = 0;
-                mode->cap[CONFORMANT] = 1;
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-                if (visual_info) {
-                  int transparent;
-
-/* [email protected] reported that DEC UNIX (OSF1) V4.0
-   564 for Alpha did not properly define
-   GLX_TRANSPARENT_TYPE_EXT in <GL/glx.h> despite claiming to
-   support GLX_EXT_visual_info. */
-#ifndef GLX_TRANSPARENT_TYPE_EXT
-#define GLX_TRANSPARENT_TYPE_EXT 0x23
-#endif
-
-                  rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay,
-		    fbc, GLX_TRANSPARENT_TYPE_EXT, &transparent);
-                  if (rc != 0) {
-                    mode->cap[TRANSPARENT] = 0;
-                  } else {
-                    mode->cap[TRANSPARENT] = (transparent != GLX_NONE_EXT);
-                  }
-                } else {
-                  mode->cap[TRANSPARENT] = 0;
-                }
-#else
-                mode->cap[TRANSPARENT] = 0;
-#endif
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-                if (multisample) {
-                  rc = __glut_glXGetFBConfigAttribSGIX(__glutDisplay,
-		    fbc, GLX_SAMPLES_SGIS, &mode->cap[SAMPLES]);
-                  if (rc != 0) {
-                    mode->cap[SAMPLES] = 0;
-                  }
-                } else {
-                  mode->cap[SAMPLES] = 0;
-                }
-#else
-                mode->cap[SAMPLES] = 0;
-#endif
-
-              } else {
-                /* Fbconfig is not RGBA; GLUT only uses RGBA
-                   FBconfigs. */
-                /* XXX Code could be exteneded to handle color
-                   index FBconfigs, but seems a color index
-                   window-renderable FBconfig would also be
-                   advertised as an X visual. */
-                mode->valid = 0;
-              }
-            } else {
-              /* Fbconfig does not support window rendering;
-                 not a valid FBconfig for GLUT windows. */
-              mode->valid = 0;
-            }
-          } else {
-            /* FBconfig ID is None (zero); not a valid
-               FBconfig. */
-            mode->valid = 0;
-          }
-        } else {
-          /* FBconfig ID is None (zero); not a valid FBconfig. */
-          mode->valid = 0;
-        }
-      } else {
-        /* No SGIX_fbconfig GLX sever implementation support. */
-        mode->valid = 0;
-      }
-#else
-      /* No SGIX_fbconfig GLX extension API support. */
-      mode->valid = 0;
-#endif
-    }
-  }
-
-  free(vlist);
-  *nitems_return = n;
-  return fbmodes;
-}
-
-static XVisualInfo *
-findMatch(FrameBufferMode * fbmodes, int nfbmodes,
-  Criterion * criteria, int ncriteria, void **fbc)
-{
-  FrameBufferMode *found;
-  int *bestScore, *thisScore;
-  int i, j, numok, result = 0, worse, better;
-
-  found = NULL;
-  numok = 1;            /* "num" capability is indexed from 1,
-                           not 0. */
-
-  /* XXX alloca canidate. */
-  bestScore = (int *) malloc(ncriteria * sizeof(int));
-  if (!bestScore)
-    __glutFatalError("out of memory.");
-  for (j = 0; j < ncriteria; j++) {
-    /* Very negative number. */
-    bestScore[j] = -32768;
-  }
-
-  /* XXX alloca canidate. */
-  thisScore = (int *) malloc(ncriteria * sizeof(int));
-  if (!thisScore)
-    __glutFatalError("out of memory.");
-
-  for (i = 0; i < nfbmodes; i++) {
-    if (fbmodes[i].valid) {
-#ifdef TEST
-#if !defined(_WIN32)
-      if (verbose)
-        printf("Visual 0x%x\n", fbmodes[i].vi->visualid);
-#endif
-#endif
-
-      worse = 0;
-      better = 0;
-
-      for (j = 0; j < ncriteria; j++) {
-        int cap, cvalue, fbvalue;
-
-        cap = criteria[j].capability;
-        cvalue = criteria[j].value;
-        if (cap == NUM) {
-          fbvalue = numok;
-        } else {
-          fbvalue = fbmodes[i].cap[cap];
-        }
-#ifdef TEST
-        if (verbose)
-          printf("  %s %s %d to %d\n",
-            capstr[cap], compstr[criteria[j].comparison], cvalue, fbvalue);
-#endif
-        switch (criteria[j].comparison) {
-        case EQ:
-          result = cvalue == fbvalue;
-          thisScore[j] = 1;
-          break;
-        case NEQ:
-          result = cvalue != fbvalue;
-          thisScore[j] = 1;
-          break;
-        case LT:
-          result = fbvalue < cvalue;
-          thisScore[j] = fbvalue - cvalue;
-          break;
-        case GT:
-          result = fbvalue > cvalue;
-          thisScore[j] = fbvalue - cvalue;
-          break;
-        case LTE:
-          result = fbvalue <= cvalue;
-          thisScore[j] = fbvalue - cvalue;
-          break;
-        case GTE:
-          result = (fbvalue >= cvalue);
-          thisScore[j] = fbvalue - cvalue;
-          break;
-        case MIN:
-          result = fbvalue >= cvalue;
-          thisScore[j] = cvalue - fbvalue;
-          break;
-        }
-
-#ifdef TEST
-        if (verbose)
-          printf("                result=%d   score=%d   bestScore=%d\n", result, thisScore[j], bestScore[j]);
-#endif
-
-        if (result) {
-          if (better || thisScore[j] > bestScore[j]) {
-            better = 1;
-          } else if (thisScore[j] == bestScore[j]) {
-            /* Keep looking. */
-          } else {
-            goto nextFBM;
-          }
-        } else {
-          if (cap == NUM) {
-            worse = 1;
-          } else {
-            goto nextFBM;
-          }
-        }
-
-      }
-
-      if (better && !worse) {
-        found = &fbmodes[i];
-        for (j = 0; j < ncriteria; j++) {
-          bestScore[j] = thisScore[j];
-        }
-      }
-      numok++;
-
-    nextFBM:;
-
-    }
-  }
-  free(bestScore);
-  free(thisScore);
-  if (found) {
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-    *fbc = found->fbc;
-#endif
-    return found->vi;
-  } else {
-    return NULL;
-  }
-}
-
-static int
-parseCriteria(char *word, Criterion * criterion, int *mask,
-  Bool * allowDoubleAsSingle)
-{
-  char *cstr, *vstr, *response;
-  int comparator, value = 0;
-  int rgb, rgba, acc, acca, count, i;
-
-  cstr = strpbrk(word, "=><!~");
-  if (cstr) {
-    switch (cstr[0]) {
-    case '=':
-      comparator = EQ;
-      vstr = &cstr[1];
-      break;
-    case '~':
-      comparator = MIN;
-      vstr = &cstr[1];
-      break;
-    case '>':
-      if (cstr[1] == '=') {
-        comparator = GTE;
-        vstr = &cstr[2];
-      } else {
-        comparator = GT;
-        vstr = &cstr[1];
-      }
-      break;
-    case '<':
-      if (cstr[1] == '=') {
-        comparator = LTE;
-        vstr = &cstr[2];
-      } else {
-        comparator = LT;
-        vstr = &cstr[1];
-      }
-      break;
-    case '!':
-      if (cstr[1] == '=') {
-        comparator = NEQ;
-        vstr = &cstr[2];
-      } else {
-        return -1;
-      }
-      break;
-    default:
-      return -1;
-    }
-    value = (int) strtol(vstr, &response, 0);
-    if (response == vstr) {
-      /* Not a valid number. */
-      return -1;
-    }
-    *cstr = '\0';
-  } else {
-    comparator = NONE;
-  }
-  switch (word[0]) {
-  case 'a':
-    if (!strcmp(word, "alpha")) {
-      criterion[0].capability = ALPHA_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << RGBA);
-      *mask |= (1 << ALPHA_SIZE);
-      *mask |= (1 << RGBA_MODE);
-      return 1;
-    }
-    acca = !strcmp(word, "acca");
-    acc = !strcmp(word, "acc");
-    if (acc || acca) {
-      criterion[0].capability = ACCUM_RED_SIZE;
-      criterion[1].capability = ACCUM_GREEN_SIZE;
-      criterion[2].capability = ACCUM_BLUE_SIZE;
-      criterion[3].capability = ACCUM_ALPHA_SIZE;
-      if (acca) {
-        count = 4;
-      } else {
-        count = 3;
-        criterion[3].comparison = MIN;
-        criterion[3].value = 0;
-      }
-      if (comparator == NONE) {
-        comparator = GTE;
-        value = 8;
-      }
-      for (i = 0; i < count; i++) {
-        criterion[i].comparison = comparator;
-        criterion[i].value = value;
-      }
-      *mask |= (1 << ACCUM_RED_SIZE);
-      return 4;
-    }
-    if (!strcmp(word, "auxbufs")) {
-      criterion[0].capability = AUX_BUFFERS;
-      if (comparator == NONE) {
-        criterion[0].comparison = MIN;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << AUX_BUFFERS);
-      return 1;
-    }
-    return -1;
-  case 'b':
-    if (!strcmp(word, "blue")) {
-      criterion[0].capability = BLUE_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << RGBA);
-      *mask |= (1 << RGBA_MODE);
-      return 1;
-    }
-    if (!strcmp(word, "buffer")) {
-      criterion[0].capability = BUFFER_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      return 1;
-    }
-    return -1;
-  case 'c':
-    if (!strcmp(word, "conformant")) {
-      criterion[0].capability = CONFORMANT;
-      if (comparator == NONE) {
-        criterion[0].comparison = EQ;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << CONFORMANT);
-      return 1;
-    }
-    return -1;
-  case 'd':
-    if (!strcmp(word, "depth")) {
-      criterion[0].capability = DEPTH_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 12;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << DEPTH_SIZE);
-      return 1;
-    }
-    if (!strcmp(word, "double")) {
-      criterion[0].capability = DOUBLEBUFFER;
-      if (comparator == NONE) {
-        criterion[0].comparison = EQ;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << DOUBLEBUFFER);
-      return 1;
-    }
-    return -1;
-  case 'g':
-    if (!strcmp(word, "green")) {
-      criterion[0].capability = GREEN_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << RGBA);
-      *mask |= (1 << RGBA_MODE);
-      return 1;
-    }
-    return -1;
-  case 'i':
-    if (!strcmp(word, "index")) {
-      criterion[0].capability = RGBA;
-      criterion[0].comparison = EQ;
-      criterion[0].value = 0;
-      *mask |= (1 << RGBA);
-      *mask |= (1 << CI_MODE);
-      criterion[1].capability = BUFFER_SIZE;
-      if (comparator == NONE) {
-        criterion[1].comparison = GTE;
-        criterion[1].value = 1;
-      } else {
-        criterion[1].comparison = comparator;
-        criterion[1].value = value;
-      }
-      return 2;
-    }
-    return -1;
-  case 'l':
-    if (!strcmp(word, "luminance")) {
-      criterion[0].capability = RGBA;
-      criterion[0].comparison = EQ;
-      criterion[0].value = 1;
-
-      criterion[1].capability = RED_SIZE;
-      if (comparator == NONE) {
-        criterion[1].comparison = GTE;
-        criterion[1].value = 1;
-      } else {
-        criterion[1].comparison = comparator;
-        criterion[1].value = value;
-      }
-
-      criterion[2].capability = GREEN_SIZE;
-      criterion[2].comparison = EQ;
-      criterion[2].value = 0;
-
-      criterion[3].capability = BLUE_SIZE;
-      criterion[3].comparison = EQ;
-      criterion[3].value = 0;
-
-      *mask |= (1 << RGBA);
-      *mask |= (1 << RGBA_MODE);
-      *mask |= (1 << LUMINANCE_MODE);
-      return 4;
-    }
-    return -1;
-  case 'n':
-    if (!strcmp(word, "num")) {
-      criterion[0].capability = NUM;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-  case 'r':
-    if (!strcmp(word, "red")) {
-      criterion[0].capability = RED_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = GTE;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << RGBA);
-      *mask |= (1 << RGBA_MODE);
-      return 1;
-    }
-    rgba = !strcmp(word, "rgba");
-    rgb = !strcmp(word, "rgb");
-    if (rgb || rgba) {
-      criterion[0].capability = RGBA;
-      criterion[0].comparison = EQ;
-      criterion[0].value = 1;
-
-      criterion[1].capability = RED_SIZE;
-      criterion[2].capability = GREEN_SIZE;
-      criterion[3].capability = BLUE_SIZE;
-      criterion[4].capability = ALPHA_SIZE;
-      if (rgba) {
-        count = 5;
-      } else {
-        count = 4;
-        criterion[4].comparison = MIN;
-        criterion[4].value = 0;
-      }
-      if (comparator == NONE) {
-        comparator = GTE;
-        value = 1;
-      }
-      for (i = 1; i < count; i++) {
-        criterion[i].comparison = comparator;
-        criterion[i].value = value;
-      }
-      *mask |= (1 << RGBA);
-      *mask |= (1 << RGBA_MODE);
-      return 5;
-    }
-    return -1;
-  case 's':
-    if (!strcmp(word, "stencil")) {
-      criterion[0].capability = STENCIL_SIZE;
-      if (comparator == NONE) {
-        criterion[0].comparison = MIN;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << STENCIL_SIZE);
-      return 1;
-    }
-    if (!strcmp(word, "single")) {
-      criterion[0].capability = DOUBLEBUFFER;
-      if (comparator == NONE) {
-        criterion[0].comparison = EQ;
-        criterion[0].value = 0;
-        *allowDoubleAsSingle = True;
-        *mask |= (1 << DOUBLEBUFFER);
-        return 1;
-      } else {
-        return -1;
-      }
-    }
-    if (!strcmp(word, "stereo")) {
-      criterion[0].capability = STEREO;
-      if (comparator == NONE) {
-        criterion[0].comparison = EQ;
-        criterion[0].value = 1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << STEREO);
-      return 1;
-    }
-    if (!strcmp(word, "samples")) {
-      criterion[0].capability = SAMPLES;
-      if (comparator == NONE) {
-        criterion[0].comparison = LTE;
-        criterion[0].value = 4;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << SAMPLES);
-      return 1;
-    }
-    if (!strcmp(word, "slow")) {
-      criterion[0].capability = SLOW;
-      if (comparator == NONE) {
-        /* Just "slow" means permit fast visuals, but accept
-           slow ones in preference. Presumably the slow ones
-           must be higher quality or something else desirable. */
-        criterion[0].comparison = GTE;
-        criterion[0].value = 0;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-      }
-      *mask |= (1 << SLOW);
-      return 1;
-    }
-    return -1;
-#if defined(_WIN32)
-  case 'w':
-    if (!strcmp(word, "win32pfd")) {
-      criterion[0].capability = XVISUAL;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-#endif
-#if !defined(_WIN32)
-  case 'x':
-    if (!strcmp(word, "xvisual")) {
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].capability = XVISUAL;
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        /* Set everything in "mask" so that no default criteria
-           get used.  Assume the program really wants the
-           xvisual specified. */
-        *mask |= ~0;
-        return 1;
-      }
-    }
-    /* Be a little over-eager to fill in the comparison and
-       value so we won't have to replicate the code after each
-       string match. */
-    if (comparator == NONE) {
-      criterion[0].comparison = EQ;
-      criterion[0].value = 1;
-    } else {
-      criterion[0].comparison = comparator;
-      criterion[0].value = value;
-    }
-
-    if (!strcmp(word, "xstaticgray")) {
-      criterion[0].capability = XSTATICGRAY;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    if (!strcmp(word, "xgrayscale")) {
-      criterion[0].capability = XGRAYSCALE;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    if (!strcmp(word, "xstaticcolor")) {
-      criterion[0].capability = XSTATICCOLOR;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    if (!strcmp(word, "xpseudocolor")) {
-      criterion[0].capability = XPSEUDOCOLOR;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    if (!strcmp(word, "xtruecolor")) {
-      criterion[0].capability = XTRUECOLOR;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    if (!strcmp(word, "xdirectcolor")) {
-      criterion[0].capability = XDIRECTCOLOR;
-      *mask |= (1 << XSTATICGRAY);  /* Indicates _any_ visual
-                                       class selected. */
-      return 1;
-    }
-    return -1;
-#endif
-  default:
-    return -1;
-  }
-}
-
-static Criterion *
-parseModeString(char *mode, int *ncriteria, Bool * allowDoubleAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask)
-{
-  Criterion *criteria = NULL;
-  int n, mask, parsed, i;
-  char *copy, *word;
-
-  *allowDoubleAsSingle = False;
-  copy = __glutStrdup(mode);
-  /* Attempt to estimate how many criteria entries should be
-     needed. */
-  n = 0;
-  word = strtok(copy, " \t");
-  while (word) {
-    n++;
-    word = strtok(NULL, " \t");
-  }
-  /* Overestimate by 4 times ("rgba" might add four criteria
-     entries) plus add in possible defaults plus space for
-     required criteria. */
-  criteria = (Criterion *) malloc((4 * n + 30 + nRequired) * sizeof(Criterion));
-  if (!criteria) {
-    __glutFatalError("out of memory.");
-  }
-
-  /* Re-copy the copy of the mode string. */
-  strcpy(copy, mode);
-
-  /* First add the required criteria (these match at the
-     highest priority). Typically these will be used to force a
-     specific level (layer), transparency, and/or visual type. */
-  mask = requiredMask;
-  for (i = 0; i < nRequired; i++) {
-    criteria[i] = requiredCriteria[i];
-  }
-  n = nRequired;
-
-  word = strtok(copy, " \t");
-  while (word) {
-    parsed = parseCriteria(word, &criteria[n], &mask, allowDoubleAsSingle);
-    if (parsed >= 0) {
-      n += parsed;
-    } else {
-      __glutWarning("Unrecognized display string word: %s (ignoring)\n", word);
-    }
-    word = strtok(NULL, " \t");
-  }
-
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-  if (__glutIsSupportedByGLX("GLX_SGIS_multisample") ||
-      __glutIsSupportedByGLX("GLX_ARB_multisample")) {
-    if (!(mask & (1 << SAMPLES))) {
-      criteria[n].capability = SAMPLES;
-      criteria[n].comparison = EQ;
-      criteria[n].value = 0;
-      n++;
-    } else {
-      /* Multisample visuals are marked nonconformant.  If
-         multisampling was requeste and no conformant
-         preference was set, assume that we will settle for a
-         non-conformant visual to get multisampling. */
-      if (!(mask & (1 << CONFORMANT))) {
-        criteria[n].capability = CONFORMANT;
-        criteria[n].comparison = MIN;
-        criteria[n].value = 0;
-        n++;
-        mask |= (1 << CONFORMANT);
-      }
-    }
-  }
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-  if (__glutIsSupportedByGLX("GLX_EXT_visual_info")) {
-    if (!(mask & (1 << TRANSPARENT))) {
-      criteria[n].capability = TRANSPARENT;
-      criteria[n].comparison = EQ;
-      criteria[n].value = 0;
-      n++;
-    }
-  }
-#endif
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_rating)
-  if (__glutIsSupportedByGLX("GLX_EXT_visual_rating")) {
-    if (!(mask & (1 << SLOW))) {
-      criteria[n].capability = SLOW;
-      criteria[n].comparison = EQ;
-      criteria[n].value = 0;
-      n++;
-    }
-    if (!(mask & (1 << CONFORMANT))) {
-      criteria[n].capability = CONFORMANT;
-      criteria[n].comparison = EQ;
-      criteria[n].value = 1;
-      n++;
-    }
-  }
-#endif
-  if (!(mask & (1 << ACCUM_RED_SIZE))) {
-    criteria[n].capability = ACCUM_RED_SIZE;
-    criteria[n].comparison = MIN;
-    criteria[n].value = 0;
-    criteria[n + 1].capability = ACCUM_GREEN_SIZE;
-    criteria[n + 1].comparison = MIN;
-    criteria[n + 1].value = 0;
-    criteria[n + 2].capability = ACCUM_BLUE_SIZE;
-    criteria[n + 2].comparison = MIN;
-    criteria[n + 2].value = 0;
-    criteria[n + 3].capability = ACCUM_ALPHA_SIZE;
-    criteria[n + 3].comparison = MIN;
-    criteria[n + 3].value = 0;
-    n += 4;
-  }
-  if (!(mask & (1 << AUX_BUFFERS))) {
-    criteria[n].capability = AUX_BUFFERS;
-    criteria[n].comparison = MIN;
-    criteria[n].value = 0;
-    n++;
-  }
-  if (!(mask & (1 << RGBA))) {
-    criteria[n].capability = RGBA;
-    criteria[n].comparison = EQ;
-    criteria[n].value = 1;
-    criteria[n + 1].capability = RED_SIZE;
-    criteria[n + 1].comparison = GTE;
-    criteria[n + 1].value = 1;
-    criteria[n + 2].capability = GREEN_SIZE;
-    criteria[n + 2].comparison = GTE;
-    criteria[n + 2].value = 1;
-    criteria[n + 3].capability = BLUE_SIZE;
-    criteria[n + 3].comparison = GTE;
-    criteria[n + 3].value = 1;
-    criteria[n + 4].capability = ALPHA_SIZE;
-    criteria[n + 4].comparison = MIN;
-    criteria[n + 4].value = 0;
-    n += 5;
-    mask |= (1 << RGBA_MODE);
-  }
-#if !defined(_WIN32)
-  if (!(mask & (1 << XSTATICGRAY))) {
-    assert(isMesaGLX != -1);
-    if ((mask & (1 << RGBA_MODE)) && !isMesaGLX) {
-      /* Normally, request an RGBA mode visual be TrueColor,
-         except in the case of Mesa where we trust Mesa (and
-         other code in GLUT) to handle any type of RGBA visual
-         reasonably. */
-      if (mask & (1 << LUMINANCE_MODE)) {
-	/* If RGBA luminance was requested, actually go for
-	   a StaticGray visual. */
-        criteria[n].capability = XSTATICGRAY;
-      } else {
-        criteria[n].capability = XTRUECOLOR;
-      }
-      criteria[n].value = 1;
-      criteria[n].comparison = EQ;
-
-      n++;
-    }
-    if (mask & (1 << CI_MODE)) {
-      criteria[n].capability = XPSEUDOCOLOR;
-      criteria[n].value = 1;
-      criteria[n].comparison = EQ;
-      n++;
-    }
-  }
-#endif
-  if (!(mask & (1 << STEREO))) {
-    criteria[n].capability = STEREO;
-    criteria[n].comparison = EQ;
-    criteria[n].value = 0;
-    n++;
-  }
-  if (!(mask & (1 << DOUBLEBUFFER))) {
-    criteria[n].capability = DOUBLEBUFFER;
-    criteria[n].comparison = EQ;
-    criteria[n].value = 0;
-    *allowDoubleAsSingle = True;
-    n++;
-  }
-  if (!(mask & (1 << DEPTH_SIZE))) {
-    criteria[n].capability = DEPTH_SIZE;
-    criteria[n].comparison = MIN;
-    criteria[n].value = 0;
-    n++;
-  }
-  if (!(mask & (1 << STENCIL_SIZE))) {
-    criteria[n].capability = STENCIL_SIZE;
-    criteria[n].comparison = MIN;
-    criteria[n].value = 0;
-    n++;
-  }
-  if (!(mask & (1 << LEVEL))) {
-    criteria[n].capability = LEVEL;
-    criteria[n].comparison = EQ;
-    criteria[n].value = 0;
-    n++;
-  }
-  if (n) {
-    /* Since over-estimated the size needed; squeeze it down to
-       reality. */
-    criteria = (Criterion *) realloc(criteria, n * sizeof(Criterion));
-    if (!criteria) {
-      /* Should never happen since should be shrinking down! */
-      __glutFatalError("out of memory.");
-    }
-  } else {
-    /* For portability, avoid "realloc(ptr,0)" call. */
-    free(criteria);
-    criteria = NULL;
-  }
-
-  free(copy);
-  *ncriteria = n;
-  return criteria;
-}
-
-static FrameBufferMode *fbmodes = NULL;
-static int nfbmodes = 0;
-
-static XVisualInfo *
-getVisualInfoFromString(char *string, Bool * treatAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc)
-{
-  Criterion *criteria;
-  XVisualInfo *visinfo;
-  Bool allowDoubleAsSingle;
-  int ncriteria, i;
-
-  if (!fbmodes) {
-    fbmodes = loadVisuals(&nfbmodes);
-  }
-  criteria = parseModeString(string, &ncriteria,
-    &allowDoubleAsSingle, requiredCriteria, nRequired, requiredMask);
-  if (criteria == NULL) {
-    __glutWarning("failed to parse mode string");
-    return NULL;
-  }
-#ifdef TEST
-  printCriteria(criteria, ncriteria);
-#endif
-  visinfo = findMatch(fbmodes, nfbmodes, criteria, ncriteria, fbc);
-  if (visinfo) {
-    *treatAsSingle = 0;
-  } else {
-    if (allowDoubleAsSingle) {
-      /* Rewrite criteria so that we now look for a double
-         buffered visual which will then get treated as a
-         single buffered visual. */
-      for (i = 0; i < ncriteria; i++) {
-        if (criteria[i].capability == DOUBLEBUFFER
-          && criteria[i].comparison == EQ
-          && criteria[i].value == 0) {
-          criteria[i].value = 1;
-        }
-      }
-      visinfo = findMatch(fbmodes, nfbmodes, criteria, ncriteria, fbc);
-      if (visinfo) {
-        *treatAsSingle = 1;
-      }
-    }
-  }
-  free(criteria);
-
-  if (visinfo) {
-#if defined(_WIN32)
-    /* We could have a valid pixel format for drawing to a
-       bitmap. However, we don't want to draw into a bitmap, we 
-       need one that can be used with a window, so make sure
-       that this is true. */
-    if (!(visinfo->dwFlags & PFD_DRAW_TO_WINDOW))
-      return NULL;
-#endif
-    return visinfo;
-  } else {
-    return NULL;
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutInitDisplayString(const char *string)
-{
-#ifdef _WIN32
-  XHDC = GetDC(GetDesktopWindow());
-#endif
-
-  __glutDetermineVisualFromString = getVisualInfoFromString;
-  if (__glutDisplayString) {
-    free(__glutDisplayString);
-  }
-  if (string) {
-    __glutDisplayString = __glutStrdup(string);
-    if (!__glutDisplayString)
-      __glutFatalError("out of memory.");
-  } else {
-    __glutDisplayString = NULL;
-  }
-}
-/* ENDCENTRY */
-
-#ifdef TEST
-
-Criterion requiredWindowCriteria[] =
-{
-  {LEVEL, EQ, 0},
-  {TRANSPARENT, EQ, 0}
-};
-int numRequiredWindowCriteria = sizeof(requiredWindowCriteria) / sizeof(Criterion);
-int requiredWindowCriteriaMask = (1 << LEVEL) | (1 << TRANSPARENT);
-
-Criterion requiredOverlayCriteria[] =
-{
-  {LEVEL, EQ, 1},
-  {TRANSPARENT, EQ, 1},
-  {XPSEUDOCOLOR, EQ, 1},
-  {RGBA, EQ, 0},
-  {BUFFER_SIZE, GTE, 1}
-};
-int numRequiredOverlayCriteria = sizeof(requiredOverlayCriteria) / sizeof(Criterion);
-int requiredOverlayCriteriaMask =
-(1 << LEVEL) | (1 << TRANSPARENT) | (1 << XSTATICGRAY) | (1 << RGBA) | (1 << CI_MODE);
-
-int
-main(int argc, char **argv)
-{
-  Display *dpy;
-  XVisualInfo *vinfo;
-  Bool treatAsSingle;
-  char *str, buffer[1024];
-  int tty = isatty(fileno(stdin));
-  int overlay = 0, showconfig = 0;
-  void *fbc;
-
-#if !defined(_WIN32)
-  dpy = XOpenDisplay(NULL);
-  if (dpy == NULL) {
-    printf("Could not connect to X server\n");
-    exit(1);
-  }
-  __glutDisplay = dpy;
-  __glutScreen = DefaultScreen(__glutDisplay);
-#endif
-  while (!feof(stdin)) {
-    if (tty)
-      printf("dstr> ");
-    str = fgets(buffer, 1023, stdin);
-    if (str) {
-      printf("\n");
-      if (!strcmp("v", str)) {
-        verbose = 1 - verbose;
-        printf("verbose = %d\n\n", verbose);
-      } else if (!strcmp("s", str)) {
-        showconfig = 1 - showconfig;
-        printf("showconfig = %d\n\n", showconfig);
-      } else if (!strcmp("o", str)) {
-        overlay = 1 - overlay;
-        printf("overlay = %d\n\n", overlay);
-      } else {
-        if (overlay) {
-          vinfo = getVisualInfoFromString(str, &treatAsSingle,
-            requiredOverlayCriteria, numRequiredOverlayCriteria, requiredOverlayCriteriaMask, &fbc);
-        } else {
-          vinfo = getVisualInfoFromString(str, &treatAsSingle,
-            requiredWindowCriteria, numRequiredWindowCriteria, requiredWindowCriteriaMask, &fbc);
-        }
-        if (vinfo) {
-          printf("\n");
-          if (!tty)
-            printf("Display string: %s", str);
-#ifdef _WIN32
-          printf("Visual = 0x%x\n", 0);
-#else
-          printf("Visual = 0x%x%s\n", vinfo->visualid, fbc ? " (needs FBC)" : "");
-#endif
-          if (treatAsSingle) {
-            printf("Treat as SINGLE.\n");
-          }
-          if (showconfig) {
-            int glxCapable, bufferSize, level, renderType, doubleBuffer,
-              stereo, auxBuffers, redSize, greenSize, blueSize,
-              alphaSize, depthSize, stencilSize, acRedSize, acGreenSize,
-              acBlueSize, acAlphaSize;
-
-            glXGetConfig(dpy, vinfo, GLX_BUFFER_SIZE, &bufferSize);
-            glXGetConfig(dpy, vinfo, GLX_LEVEL, &level);
-            glXGetConfig(dpy, vinfo, GLX_RGBA, &renderType);
-            glXGetConfig(dpy, vinfo, GLX_DOUBLEBUFFER, &doubleBuffer);
-            glXGetConfig(dpy, vinfo, GLX_STEREO, &stereo);
-            glXGetConfig(dpy, vinfo, GLX_AUX_BUFFERS, &auxBuffers);
-            glXGetConfig(dpy, vinfo, GLX_RED_SIZE, &redSize);
-            glXGetConfig(dpy, vinfo, GLX_GREEN_SIZE, &greenSize);
-            glXGetConfig(dpy, vinfo, GLX_BLUE_SIZE, &blueSize);
-            glXGetConfig(dpy, vinfo, GLX_ALPHA_SIZE, &alphaSize);
-            glXGetConfig(dpy, vinfo, GLX_DEPTH_SIZE, &depthSize);
-            glXGetConfig(dpy, vinfo, GLX_STENCIL_SIZE, &stencilSize);
-            glXGetConfig(dpy, vinfo, GLX_ACCUM_RED_SIZE, &acRedSize);
-            glXGetConfig(dpy, vinfo, GLX_ACCUM_GREEN_SIZE, &acGreenSize);
-            glXGetConfig(dpy, vinfo, GLX_ACCUM_BLUE_SIZE, &acBlueSize);
-            glXGetConfig(dpy, vinfo, GLX_ACCUM_ALPHA_SIZE, &acAlphaSize);
-            printf("RGBA = (%d, %d, %d, %d)\n", redSize, greenSize, blueSize, alphaSize);
-            printf("acc  = (%d, %d, %d, %d)\n", acRedSize, acGreenSize, acBlueSize, acAlphaSize);
-            printf("db   = %d\n", doubleBuffer);
-            printf("str  = %d\n", stereo);
-            printf("aux  = %d\n", auxBuffers);
-            printf("lvl  = %d\n", level);
-            printf("buf  = %d\n", bufferSize);
-            printf("rgba = %d\n", renderType);
-            printf("z    = %d\n", depthSize);
-            printf("s    = %d\n", stencilSize);
-          }
-        } else {
-          printf("\n");
-          printf("No match.\n");
-        }
-        printf("\n");
-      }
-    }
-  }
-  printf("\n");
-  return 0;
-}
-#endif
diff --git a/src/glut/glx/glut_event.c b/src/glut/glx/glut_event.c
deleted file mode 100644
index c450ee96b83..00000000000
--- a/src/glut/glx/glut_event.c
+++ /dev/null
@@ -1,1391 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1997, 1998. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include <assert.h>
-#include <string.h>  /* Some FD_ZERO macros use memset without
-                        prototyping memset. */
-
-/* Much of the following #ifdef logic to include the proper
-   prototypes for the select system call is based on logic
-   from the X11R6.3 version of <X11/Xpoll.h>. */
-
-#if !defined(_WIN32)
-# ifdef __sgi
-#  include <bstring.h>    /* prototype for bzero used by FD_ZERO */
-# endif
-# if (defined(__FreeBSD__) || defined(SVR4) || defined(CRAY) || defined(AIXV3)) && !defined(FD_SETSIZE)
-#  include <sys/select.h> /* select system call interface */
-#  ifdef luna
-#   include <sysent.h>
-#  endif
-# endif
-  /* AIX 4.2 fubar-ed <sys/select.h>, so go to heroic measures to get it */
-# if defined(AIXV4) && !defined(NFDBITS)
-#  include <sys/select.h>
-# endif
-#endif /* !_WIN32 */
-
-#include <sys/types.h>
-
-#if !defined(_WIN32)
-# if defined(__vms) && ( __VMS_VER < 70000000 )
-#  include <sys/time.h>
-# else
-#  ifndef __vms
-#   include <sys/time.h>
-#  endif
-# endif
-# include <unistd.h>
-# include <X11/Xlib.h>
-# include <X11/keysym.h>
-#else
-# ifdef __CYGWIN32__
-#  include <sys/time.h>
-# else
-#  include <sys/timeb.h>
-# endif
-# ifdef __hpux
-   /* XXX Bert Gijsbers <[email protected]> reports that HP-UX
-      needs different keysyms for the End, Insert, and Delete keys
-      to work on an HP 715.  It would be better if HP generated
-      standard keysyms for standard keys. */
-#  include <X11/HPkeysym.h>
-# endif
-#endif /* !_WIN32 */
-
-#include "glutint.h"
-
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-#include <ssdef.h>
-#include <psldef.h>
-extern int SYS$CLREF(int efn);
-extern int SYS$SETIMR(unsigned int efn, struct timeval6 *timeout, void *ast,
-  unsigned int request_id, unsigned int flags);
-extern int SYS$WFLOR(unsigned int efn, unsigned int mask);
-extern int SYS$CANTIM(unsigned int request_id, unsigned int mode);
-#endif /* __vms, VMs 6.2 or earlier */
-
-static GLUTtimer *freeTimerList = NULL;
-
-GLUTidleCB __glutIdleFunc = NULL;
-GLUTtimer *__glutTimerList = NULL;
-#ifdef SUPPORT_FORTRAN
-GLUTtimer *__glutNewTimer;
-#endif
-GLUTwindow *__glutWindowWorkList = NULL;
-GLUTmenu *__glutMappedMenu;
-GLUTmenu *__glutCurrentMenu = NULL;
-
-void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
-#if !defined(_WIN32)
-void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type) = NULL;
-void (*__glutFinishMenu)(Window win, int x, int y);
-void (*__glutPaintMenu)(GLUTmenu * menu);
-void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win);
-GLUTmenu * (*__glutGetMenuByNum)(int menunum);
-GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which);
-GLUTmenu * (*__glutGetMenu)(Window win);
-#endif
-
-Atom __glutMotifHints = None;
-/* Modifier mask of ~0 implies not in core input callback. */
-unsigned int __glutModifierMask = (unsigned int) ~0;
-int __glutWindowDamaged = 0;
-
-void GLUTAPIENTRY
-glutIdleFunc(GLUTidleCB idleFunc)
-{
-  __glutIdleFunc = idleFunc;
-}
-
-void GLUTAPIENTRY
-glutTimerFunc(unsigned int interval, GLUTtimerCB timerFunc, int value)
-{
-  GLUTtimer *timer, *other;
-  GLUTtimer **prevptr;
-#ifdef OLD_VMS
-   struct timeval6 now;
-#else
-   struct timeval now;
-#endif
-   
-  if (!timerFunc)
-    return;
-
-  if (freeTimerList) {
-    timer = freeTimerList;
-    freeTimerList = timer->next;
-  } else {
-    timer = (GLUTtimer *) malloc(sizeof(GLUTtimer));
-    if (!timer)
-      __glutFatalError("out of memory.");
-  }
-
-  timer->func = timerFunc;
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-  /* VMS time is expressed in units of 100 ns */
-  timer->timeout.val = interval * TICKS_PER_MILLISECOND;
-#else
-  timer->timeout.tv_sec = (int) interval / 1000;
-  timer->timeout.tv_usec = (int) (interval % 1000) * 1000;
-#endif
-  timer->value = value;
-  timer->next = NULL;
-  GETTIMEOFDAY(&now);
-  ADD_TIME(timer->timeout, timer->timeout, now);
-  prevptr = &__glutTimerList;
-  other = *prevptr;
-  while (other && IS_AFTER(other->timeout, timer->timeout)) {
-    prevptr = &other->next;
-    other = *prevptr;
-  }
-  timer->next = other;
-#ifdef SUPPORT_FORTRAN
-  __glutNewTimer = timer;  /* for Fortran binding! */
-#endif
-  *prevptr = timer;
-}
-
-void
-handleTimeouts(void)
-{
-#ifdef OLD_VMS
-   struct timeval6 now;
-#else
-   struct timeval now;
-#endif
-   GLUTtimer *timer;
-
-  /* Assumption is that __glutTimerList is already determined
-     to be non-NULL. */
-  GETTIMEOFDAY(&now);
-  while (IS_AT_OR_AFTER(__glutTimerList->timeout, now)) {
-    timer = __glutTimerList;
-    /* call the timer function */
-    timer->func(timer->value);
-    /* remove from the linked list */
-    __glutTimerList = timer->next;
-    /* put this timer on the "free" list */
-    timer->next = freeTimerList;
-    freeTimerList = timer;
-
-    if (!__glutTimerList)
-      break;
-  }
-}
-
-void
-__glutPutOnWorkList(GLUTwindow * window, int workMask)
-{
-  if (window->workMask) {
-    /* Already on list; just OR in new workMask. */
-    window->workMask |= workMask;
-  } else {
-    /* Update work mask and add to window work list. */
-    window->workMask = workMask;
-    /* Assert that if the window does not have a
-       workMask already, the window should definitely
-       not be the head of the work list. */
-    assert(window != __glutWindowWorkList);
-    window->prevWorkWin = __glutWindowWorkList;
-    __glutWindowWorkList = window;
-  }
-}
-
-void
-__glutPostRedisplay(GLUTwindow * window, int layerMask)
-{
-  int shown = (layerMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) ?
-    window->shownState : window->overlay->shownState;
-
-  /* Post a redisplay if the window is visible (or the
-     visibility of the window is unknown, ie. window->visState
-     == -1) _and_ the layer is known to be shown. */
-  if (window->visState != GLUT_HIDDEN
-    && window->visState != GLUT_FULLY_COVERED && shown) {
-    __glutPutOnWorkList(window, layerMask);
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutPostRedisplay(void)
-{
-  __glutPostRedisplay(__glutCurrentWindow, GLUT_REDISPLAY_WORK);
-}
-
-/* The advantage of this routine is that it saves the cost of a
-   glutSetWindow call (entailing an expensive OpenGL context switch),
-   particularly useful when multiple windows need redisplays posted at
-   the same times.  See also glutPostWindowOverlayRedisplay. */
-void GLUTAPIENTRY
-glutPostWindowRedisplay(int win)
-{
-  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_REDISPLAY_WORK);
-}
-
-/* ENDCENTRY */
-static GLUTeventParser *eventParserList = NULL;
-
-/* __glutRegisterEventParser allows another module to register
-   to intercept X events types not otherwise acted on by the
-   GLUT processEventsAndTimeouts routine.  The X Input
-   extension support code uses an event parser for handling X
-   Input extension events.  */
-
-void
-__glutRegisterEventParser(GLUTeventParser * parser)
-{
-  parser->next = eventParserList;
-  eventParserList = parser;
-}
-
-
-#if !defined(_WIN32)
-static void
-markWindowHidden(GLUTwindow * window)
-{
-  if (GLUT_HIDDEN != window->visState) {
-    GLUTwindow *child;
-
-    if (window->windowStatus) {
-      window->visState = GLUT_HIDDEN;
-      __glutSetWindow(window);
-      window->windowStatus(GLUT_HIDDEN);
-    }
-    /* An unmap is only reported on a single window; its
-       descendents need to know they are no longer visible. */
-    child = window->children;
-    while (child) {
-      markWindowHidden(child);
-      child = child->siblings;
-    }
-  }
-}
-
-static void
-purgeStaleWindow(Window win)
-{
-  GLUTstale **pEntry = &__glutStaleWindowList;
-  GLUTstale *entry = __glutStaleWindowList;
-
-  /* Tranverse singly-linked stale window list look for the
-     window ID. */
-  while (entry) {
-    if (entry->win == win) {
-      /* Found it; delete it. */
-      *pEntry = entry->next;
-      free(entry);
-      return;
-    } else {
-      pEntry = &entry->next;
-      entry = *pEntry;
-    }
-  }
-}
-
-/* Unlike XNextEvent, if a signal arrives,
-   interruptibleXNextEvent will return (with a zero return
-   value).  This helps GLUT drop out of XNextEvent if a signal
-   is delivered.  The intent is so that a GLUT program can call 
-   glutIdleFunc in a signal handler to register an idle func
-   and then immediately get dropped into the idle func (after
-   returning from the signal handler).  The idea is to make
-   GLUT's main loop reliably interruptible by signals. */
-static int
-interruptibleXNextEvent(Display * dpy, XEvent * event)
-{
-  fd_set fds;
-  int rc;
-
-  /* Flush X protocol since XPending does not do this
-     implicitly. */
-  XFlush(__glutDisplay);
-  for (;;) {
-    if (XPending(__glutDisplay)) {
-      XNextEvent(dpy, event);
-      return 1;
-    }
-#ifndef VMS
-    /* the combination ConectionNumber-select is buggy on VMS. Sometimes it
-     * fails. This part of the code hangs the program on VMS7.2. But even
-     * without it the program seems to run correctly.
-     * Note that this is a bug in the VMS/DECWindows run-time-libraries.
-     * Compaq engeneering does not want or is not able to make a fix.
-     * (last sentence is a quotation from Compaq when I reported the
-     * problem January 2000) */
-    FD_ZERO(&fds);
-    FD_SET(__glutConnectionFD, &fds);
-    rc = select(__glutConnectionFD + 1, &fds, NULL, NULL, NULL);
-    if (rc < 0) {
-      if (errno == EINTR) {
-        return 0;
-      } else {
-        __glutFatalError("select error.");
-      }
-    }
-#endif
-  }
-}
-
-#endif
-
-static void
-processEventsAndTimeouts(void)
-{
-  do {
-#if defined(_WIN32)
-    MSG event;
-
-    if(!GetMessage(&event, NULL, 0, 0))	/* bail if no more messages */
-      exit(0);
-    TranslateMessage(&event);		/* translate virtual-key messages */
-    DispatchMessage(&event);		/* call the window proc */
-    /* see win32_event.c for event (message) processing procedures */
-#else
-    static int mappedMenuButton;
-    GLUTeventParser *parser;
-    XEvent event, ahead;
-    GLUTwindow *window;
-    GLUTkeyboardCB keyboard;
-    GLUTspecialCB special;
-    int gotEvent, width, height;
-
-    gotEvent = interruptibleXNextEvent(__glutDisplay, &event);
-    if (gotEvent) {
-      switch (event.type) {
-      case MappingNotify:
-        XRefreshKeyboardMapping((XMappingEvent *) & event);
-        break;
-      case ConfigureNotify:
-        window = __glutGetWindow(event.xconfigure.window);
-        if (window) {
-          if (window->win != event.xconfigure.window) {
-            /* Ignore ConfigureNotify sent to the overlay
-               planes. GLUT could get here because overlays
-               select for StructureNotify events to receive
-               DestroyNotify. */
-            break;
-          }
-          width = event.xconfigure.width;
-          height = event.xconfigure.height;
-          if (width != window->width || height != window->height) {
-            if (window->overlay) {
-              XResizeWindow(__glutDisplay, window->overlay->win, width, height);
-            }
-            window->width = width;
-            window->height = height;
-            __glutSetWindow(window);
-            /* Do not execute OpenGL out of sequence with
-               respect to the XResizeWindow request! */
-            glXWaitX();
-            window->reshape(width, height);
-            window->forceReshape = False;
-            /* A reshape should be considered like posting a
-               repair; this is necessary for the "Mesa
-               glXSwapBuffers to repair damage" hack to operate
-               correctly.  Without it, there's not an initial
-               back buffer render from which to blit from when
-               damage happens to the window. */
-            __glutPostRedisplay(window, GLUT_REPAIR_WORK);
-          }
-        }
-        break;
-      case Expose:
-        /* compress expose events */
-        while (XEventsQueued(__glutDisplay, QueuedAfterReading)
-          > 0) {
-          XPeekEvent(__glutDisplay, &ahead);
-          if (ahead.type != Expose ||
-            ahead.xexpose.window != event.xexpose.window) {
-            break;
-          }
-          XNextEvent(__glutDisplay, &event);
-        }
-        if (event.xexpose.count == 0) {
-          GLUTmenu *menu;
-
-          if (__glutMappedMenu &&
-            (menu = __glutGetMenu(event.xexpose.window))) {
-            __glutPaintMenu(menu);
-          } else {
-            window = __glutGetWindow(event.xexpose.window);
-            if (window) {
-              if (window->win == event.xexpose.window) {
-                __glutPostRedisplay(window, GLUT_REPAIR_WORK);
-              } else if (window->overlay && window->overlay->win == event.xexpose.window) {
-                __glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
-              }
-            }
-          }
-        } else {
-          /* there are more exposes to read; wait to redisplay */
-        }
-        break;
-      case ButtonPress:
-      case ButtonRelease:
-        if (__glutMappedMenu && event.type == ButtonRelease
-          && mappedMenuButton == event.xbutton.button) {
-          /* Menu is currently popped up and its button is
-             released. */
-          __glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);
-        } else {
-          window = __glutGetWindow(event.xbutton.window);
-          /* added button check for mice with > 3 buttons */
-          if (window) {
-            GLUTmenu *menu;
-	    int menuNum;
-
-            if (event.xbutton.button <= GLUT_MAX_MENUS)
-              menuNum = window->menu[event.xbutton.button - 1];
-            else
-              menuNum = 0;
-
-            /* Make sure that __glutGetMenuByNum is only called if there
-	       really is a menu present. */
-            if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {
-              if (event.type == ButtonPress && !__glutMappedMenu) {
-                __glutStartMenu(menu, window,
-                  event.xbutton.x_root, event.xbutton.y_root,
-                  event.xbutton.x, event.xbutton.y);
-                mappedMenuButton = event.xbutton.button;
-              } else {
-                /* Ignore a release of a button with a menu
-                   attatched to it when no menu is popped up,
-                   or ignore a press when another menu is
-                   already popped up. */
-              }
-            } else if (window->mouse) {
-              __glutSetWindow(window);
-              __glutModifierMask = event.xbutton.state;
-              window->mouse(event.xbutton.button - 1,
-                event.type == ButtonRelease ?
-                GLUT_UP : GLUT_DOWN,
-                event.xbutton.x, event.xbutton.y);
-              __glutModifierMask = ~0;
-            } else {
-              /* Stray mouse events.  Ignore. */
-            }
-          } else {
-            /* Window might have been destroyed and all the 
-               events for the window may not yet be received. */
-          }
-        }
-        break;
-      case MotionNotify:
-        if (!__glutMappedMenu) {
-          window = __glutGetWindow(event.xmotion.window);
-          if (window) {
-            /* If motion function registered _and_ buttons held 
-               * down, call motion function...  */
-            if (window->motion && event.xmotion.state &
-              (Button1Mask | Button2Mask | Button3Mask)) {
-              __glutSetWindow(window);
-              window->motion(event.xmotion.x, event.xmotion.y);
-            }
-            /* If passive motion function registered _and_
-               buttons not held down, call passive motion
-               function...  */
-            else if (window->passive &&
-                ((event.xmotion.state &
-                    (Button1Mask | Button2Mask | Button3Mask)) ==
-                0)) {
-              __glutSetWindow(window);
-              window->passive(event.xmotion.x,
-                event.xmotion.y);
-            }
-          }
-        } else {
-          /* Motion events are thrown away when a pop up menu
-             is active. */
-        }
-        break;
-      case KeyPress:
-      case KeyRelease:
-        window = __glutGetWindow(event.xkey.window);
-        if (!window) {
-          break;
-        }
-	if (event.type == KeyPress) {
-	  keyboard = window->keyboard;
-	} else {
-
-	  /* If we are ignoring auto repeated keys for this window,
-	     check if the next event in the X event queue is a KeyPress
-	     for the exact same key (and at the exact same time) as the
-	     key being released.  The X11 protocol will send auto
-	     repeated keys as such KeyRelease/KeyPress pairs. */
-
-	  if (window->ignoreKeyRepeat) {
-	    if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
-	      XPeekEvent(__glutDisplay, &ahead);
-	      if (ahead.type == KeyPress
-	        && ahead.xkey.window == event.xkey.window
-	        && ahead.xkey.keycode == event.xkey.keycode
-	        && ahead.xkey.time == event.xkey.time) {
-		/* Pop off the repeated KeyPress and ignore
-		   the auto repeated KeyRelease/KeyPress pair. */
-	        XNextEvent(__glutDisplay, &event);
-	        break;
-	      }
-	    }
-	  }
-	  keyboard = window->keyboardUp;
-	}
-        if (keyboard) {
-          char tmp[1];
-          int rc;
-
-          rc = XLookupString(&event.xkey, tmp, sizeof(tmp),
-            NULL, NULL);
-          if (rc) {
-            __glutSetWindow(window);
-            __glutModifierMask = event.xkey.state;
-            keyboard(tmp[0],
-              event.xkey.x, event.xkey.y);
-            __glutModifierMask = ~0;
-            break;
-          }
-        }
-	if (event.type == KeyPress) {
-	  special = window->special;
-        } else {
-	  special = window->specialUp;
-	}
-        if (special) {
-          KeySym ks;
-          int key;
-
-/* Introduced in X11R6:  (Partial list of) Keypad Functions.  Define
-   in place in case compiling against an older pre-X11R6
-   X11/keysymdef.h file. */
-#ifndef XK_KP_Home
-#define XK_KP_Home              0xFF95
-#endif
-#ifndef XK_KP_Left
-#define XK_KP_Left              0xFF96
-#endif
-#ifndef XK_KP_Up
-#define XK_KP_Up                0xFF97
-#endif
-#ifndef XK_KP_Right
-#define XK_KP_Right             0xFF98
-#endif
-#ifndef XK_KP_Down
-#define XK_KP_Down              0xFF99
-#endif
-#ifndef XK_KP_Prior
-#define XK_KP_Prior             0xFF9A
-#endif
-#ifndef XK_KP_Next
-#define XK_KP_Next              0xFF9B
-#endif
-#ifndef XK_KP_End
-#define XK_KP_End               0xFF9C
-#endif
-#ifndef XK_KP_Insert
-#define XK_KP_Insert            0xFF9E
-#endif
-#ifndef XK_KP_Delete
-#define XK_KP_Delete            0xFF9F
-#endif
-
-          ks = XLookupKeysym((XKeyEvent *) & event, 0);
-          /* XXX Verbose, but makes no assumptions about keysym
-             layout. */
-          switch (ks) {
-/* *INDENT-OFF* */
-          /* function keys */
-          case XK_F1:    key = GLUT_KEY_F1; break;
-          case XK_F2:    key = GLUT_KEY_F2; break;
-          case XK_F3:    key = GLUT_KEY_F3; break;
-          case XK_F4:    key = GLUT_KEY_F4; break;
-          case XK_F5:    key = GLUT_KEY_F5; break;
-          case XK_F6:    key = GLUT_KEY_F6; break;
-          case XK_F7:    key = GLUT_KEY_F7; break;
-          case XK_F8:    key = GLUT_KEY_F8; break;
-          case XK_F9:    key = GLUT_KEY_F9; break;
-          case XK_F10:   key = GLUT_KEY_F10; break;
-          case XK_F11:   key = GLUT_KEY_F11; break;
-          case XK_F12:   key = GLUT_KEY_F12; break;
-          /* directional keys */
-	  case XK_KP_Left:
-          case XK_Left:  key = GLUT_KEY_LEFT; break;
-	  case XK_KP_Up: /* Introduced in X11R6. */
-          case XK_Up:    key = GLUT_KEY_UP; break;
-	  case XK_KP_Right: /* Introduced in X11R6. */
-          case XK_Right: key = GLUT_KEY_RIGHT; break;
-	  case XK_KP_Down: /* Introduced in X11R6. */
-          case XK_Down:  key = GLUT_KEY_DOWN; break;
-/* *INDENT-ON* */
-
-	  case XK_KP_Prior: /* Introduced in X11R6. */
-          case XK_Prior:
-            /* XK_Prior same as X11R6's XK_Page_Up */
-            key = GLUT_KEY_PAGE_UP;
-            break;
-	  case XK_KP_Next: /* Introduced in X11R6. */
-          case XK_Next:
-            /* XK_Next same as X11R6's XK_Page_Down */
-            key = GLUT_KEY_PAGE_DOWN;
-            break;
-	  case XK_KP_Home: /* Introduced in X11R6. */
-          case XK_Home:
-            key = GLUT_KEY_HOME;
-            break;
-#ifdef __hpux
-          case XK_Select:
-#endif
-	  case XK_KP_End: /* Introduced in X11R6. */
-          case XK_End:
-            key = GLUT_KEY_END;
-            break;
-#ifdef __hpux
-          case XK_InsertChar:
-#endif
-	  case XK_KP_Insert: /* Introduced in X11R6. */
-          case XK_Insert:
-            key = GLUT_KEY_INSERT;
-            break;
-#ifdef __hpux
-          case XK_DeleteChar:
-#endif
-	  case XK_KP_Delete: /* Introduced in X11R6. */
-            /* The Delete character is really an ASCII key. */
-            __glutSetWindow(window);
-            assert(keyboard);
-            keyboard(127,  /* ASCII Delete character. */
-              event.xkey.x, event.xkey.y);
-            goto skip;
-          default:
-            goto skip;
-          }
-          __glutSetWindow(window);
-          __glutModifierMask = event.xkey.state;
-          special(key, event.xkey.x, event.xkey.y);
-          __glutModifierMask = ~0;
-        skip:;
-        }
-        break;
-      case EnterNotify:
-      case LeaveNotify:
-        if (event.xcrossing.mode != NotifyNormal ||
-          event.xcrossing.detail == NotifyNonlinearVirtual ||
-          event.xcrossing.detail == NotifyVirtual) {
-
-          /* Careful to ignore Enter/LeaveNotify events that
-             come from the pop-up menu pointer grab and ungrab. 
-             Also, ignore "virtual" Enter/LeaveNotify events
-             since they represent the pointer passing through
-             the window hierarchy without actually entering or
-             leaving the actual real estate of a window.  */
-
-          break;
-        }
-        if (__glutMappedMenu) {
-          GLUTmenuItem *item;
-          int num;
-
-          item = __glutGetMenuItem(__glutMappedMenu,
-            event.xcrossing.window, &num);
-          if (item) {
-            __glutMenuItemEnterOrLeave(item, num, event.type);
-            break;
-          }
-        }
-        window = __glutGetWindow(event.xcrossing.window);
-        if (window) {
-          if (window->entry) {
-            if (event.type == EnterNotify) {
-
-              /* With overlays established, X can report two
-                 enter events for both the overlay and normal
-                 plane window. Do not generate a second enter
-                 callback if we reported one without an
-                 intervening leave. */
-
-              if (window->entryState != EnterNotify) {
-                int num = window->num;
-                Window xid = window->win;
-
-                window->entryState = EnterNotify;
-                __glutSetWindow(window);
-                window->entry(GLUT_ENTERED);
-
-                if (__glutMappedMenu) {
-
-                  /* Do not generate any passive motion events
-                     when menus are in use. */
-
-                } else {
-
-                  /* An EnterNotify event can result in a
-                     "compound" callback if a passive motion
-                     callback is also registered. In this case,
-                     be a little paranoid about the possibility
-                     the window could have been destroyed in the
-                     entry callback. */
-
-                  window = __glutWindowList[num];
-                  if (window && window->passive && window->win == xid) {
-                    __glutSetWindow(window);
-                    window->passive(event.xcrossing.x, event.xcrossing.y);
-                  }
-                }
-              }
-            } else {
-              if (window->entryState != LeaveNotify) {
-
-                /* When an overlay is established for a window
-                   already mapped and with the pointer in it,
-                   the X server will generate a leave/enter
-                   event pair as the pointer leaves (without
-                   moving) from the normal plane X window to
-                   the newly mapped overlay  X window (or vice
-                   versa). This enter/leave pair should not be
-                   reported to the GLUT program since the pair
-                   is a consequence of creating (or destroying) 
-                   the overlay, not an actual leave from the
-                   GLUT window. */
-
-                if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
-                  XPeekEvent(__glutDisplay, &ahead);
-                  if (ahead.type == EnterNotify &&
-                    __glutGetWindow(ahead.xcrossing.window) == window) {
-                    XNextEvent(__glutDisplay, &event);
-                    break;
-                  }
-                }
-                window->entryState = LeaveNotify;
-                __glutSetWindow(window);
-                window->entry(GLUT_LEFT);
-              }
-            }
-          } else if (window->passive) {
-            __glutSetWindow(window);
-            window->passive(event.xcrossing.x, event.xcrossing.y);
-          }
-        }
-        break;
-      case UnmapNotify:
-        /* MapNotify events are not needed to maintain
-           visibility state since VisibilityNotify events will
-           be delivered when a window becomes visible from
-           mapping.  However, VisibilityNotify events are not
-           delivered when a window is unmapped (for the window
-           or its children). */
-        window = __glutGetWindow(event.xunmap.window);
-        if (window) {
-          if (window->win != event.xconfigure.window) {
-            /* Ignore UnmapNotify sent to the overlay planes.
-               GLUT could get here because overlays select for
-               StructureNotify events to receive DestroyNotify. 
-             */
-            break;
-          }
-          markWindowHidden(window);
-        }
-        break;
-      case VisibilityNotify:
-        window = __glutGetWindow(event.xvisibility.window);
-        if (window) {
-          /* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,
-             VisibilityPartiallyObscured+1 =
-             GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1 
-             =  GLUT_FULLY_COVERED. */
-          int visState = event.xvisibility.state + 1;
-
-          if (visState != window->visState) {
-            if (window->windowStatus) {
-              window->visState = visState;
-              __glutSetWindow(window);
-              window->windowStatus(visState);
-            }
-          }
-        }
-        break;
-      case ClientMessage:
-        if (event.xclient.data.l[0] == __glutWMDeleteWindow)
-          exit(0);
-        break;
-      case DestroyNotify:
-        purgeStaleWindow(event.xdestroywindow.window);
-        break;
-      case CirculateNotify:
-      case CreateNotify:
-      case GravityNotify:
-      case ReparentNotify:
-        /* Uninteresting to GLUT (but possible for GLUT to
-           receive). */
-        break;
-      default:
-        /* Pass events not directly handled by the GLUT main
-           event loop to any event parsers that have been
-           registered.  In this way, X Input extension events
-           are passed to the correct handler without forcing
-           all GLUT programs to support X Input event handling. 
-         */
-        parser = eventParserList;
-        while (parser) {
-          if (parser->func(&event))
-            break;
-          parser = parser->next;
-        }
-        break;
-      }
-    }
-#endif /* _WIN32 */
-    if (__glutTimerList) {
-      handleTimeouts();
-    }
-  }
-  while (XPending(__glutDisplay));
-}
-
-static void
-waitForSomething(void)
-{
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-  static struct timeval6 zerotime =
-  {0};
-  unsigned int timer_efn;
-#define timer_id 'glut' /* random :-) number */
-  unsigned int wait_mask;
-#else
-  static struct timeval zerotime =
-  {0, 0};
-#if !defined(_WIN32)
-  fd_set fds;
-#endif
-#endif
-#ifdef OLD_VMS
-   struct timeval6 now, timeout, waittime;
-#else
-   struct timeval now, timeout, waittime;
-#endif
-#if !defined(_WIN32)
-  int rc;
-#endif
-
-  /* Flush X protocol since XPending does not do this
-     implicitly. */
-  XFlush(__glutDisplay);
-  if (XPending(__glutDisplay)) {
-    /* It is possible (but quite rare) that XFlush may have
-       needed to wait for a writable X connection file
-       descriptor, and in the process, may have had to read off
-       X protocol from the file descriptor. If XPending is true,
-       this case occured and we should avoid waiting in select
-       since X protocol buffered within Xlib is due to be
-       processed and potentially no more X protocol is on the
-       file descriptor, so we would risk waiting improperly in
-       select. */
-    goto immediatelyHandleXinput;
-  }
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-  timeout = __glutTimerList->timeout;
-  GETTIMEOFDAY(&now);
-  wait_mask = 1 << (__glutConnectionFD & 31);
-  if (IS_AFTER(now, timeout)) {
-    /* We need an event flag for the timer. */
-    /* XXX The `right' way to do this is to use LIB$GET_EF, but
-       since it needs to be in the same cluster as the EFN for
-       the display, we will have hack it. */
-    timer_efn = __glutConnectionFD - 1;
-    if ((timer_efn / 32) != (__glutConnectionFD / 32)) {
-      timer_efn = __glutConnectionFD + 1;
-    }
-    rc = SYS$CLREF(timer_efn);
-    rc = SYS$SETIMR(timer_efn, &timeout, NULL, timer_id, 0);
-    wait_mask |= 1 << (timer_efn & 31);
-  } else {
-    timer_efn = 0;
-  }
-  rc = SYS$WFLOR(__glutConnectionFD, wait_mask);
-  if (timer_efn != 0 && SYS$CLREF(timer_efn) == SS$_WASCLR) {
-    rc = SYS$CANTIM(timer_id, PSL$C_USER);
-  }
-  /* XXX There does not seem to be checking of "rc" in the code
-     above.  Can any of the SYS$ routines above fail? */
-#else /* not vms6.2 or lower */
-#if !defined(_WIN32)
-  FD_ZERO(&fds);
-  FD_SET(__glutConnectionFD, &fds);
-#endif
-  timeout = __glutTimerList->timeout;
-  GETTIMEOFDAY(&now);
-  if (IS_AFTER(now, timeout)) {
-    TIMEDELTA(waittime, timeout, now);
-  } else {
-    waittime = zerotime;
-  }
-#if !defined(_WIN32)
-  rc = select(__glutConnectionFD + 1, &fds,
-    NULL, NULL, &waittime);
-  if (rc < 0 && errno != EINTR)
-    __glutFatalError("select error.");
-#else
-
-  MsgWaitForMultipleObjects(0, NULL, FALSE,
-    waittime.tv_sec*1000 + waittime.tv_usec/1000, QS_ALLINPUT);
-
-#endif
-#endif /* not vms6.2 or lower */
-  /* Without considering the cause of select unblocking, check
-     for pending X events and handle any timeouts (by calling
-     processEventsAndTimeouts).  We always look for X events
-     even if select returned with 0 (indicating a timeout);
-     otherwise we risk starving X event processing by continous
-     timeouts. */
-  if (XPending(__glutDisplay)) {
-  immediatelyHandleXinput:
-    processEventsAndTimeouts();
-  } else {
-    if (__glutTimerList)
-      handleTimeouts();
-  }
-}
-
-static void
-idleWait(void)
-{
-  if (XPending(__glutDisplay)) {
-    processEventsAndTimeouts();
-  } else {
-    if (__glutTimerList) {
-      handleTimeouts();
-    }
-  }
-  /* Make sure idle func still exists! */
-  if (__glutIdleFunc) {
-    __glutIdleFunc();
-  }
-}
-
-static GLUTwindow **beforeEnd;
-
-static GLUTwindow *
-processWindowWorkList(GLUTwindow * window)
-{
-  int workMask;
-
-  if (window->prevWorkWin) {
-    window->prevWorkWin = processWindowWorkList(window->prevWorkWin);
-  } else {
-    beforeEnd = &window->prevWorkWin;
-  }
-
-  /* Capture work mask for work that needs to be done to this
-     window, then clear the window's work mask (excepting the
-     dummy work bit, see below).  Then, process the captured
-     work mask.  This allows callbacks in the processing the
-     captured work mask to set the window's work mask for
-     subsequent processing. */
-
-  workMask = window->workMask;
-  assert((workMask & GLUT_DUMMY_WORK) == 0);
-
-  /* Set the dummy work bit, clearing all other bits, to
-     indicate that the window is currently on the window work
-     list _and_ that the window's work mask is currently being
-     processed.  This convinces __glutPutOnWorkList that this
-     window is on the work list still. */
-  window->workMask = GLUT_DUMMY_WORK;
-
-  /* Optimization: most of the time, the work to do is a
-     redisplay and not these other types of work.  Check for
-     the following cases as a group to before checking each one
-     individually one by one. This saves about 25 MIPS
-     instructions in the common redisplay only case. */
-  if (workMask & (GLUT_EVENT_MASK_WORK | GLUT_DEVICE_MASK_WORK |
-      GLUT_CONFIGURE_WORK | GLUT_COLORMAP_WORK | GLUT_MAP_WORK)) {
-#if !defined(_WIN32)
-    /* Be sure to set event mask BEFORE map window is done. */
-    if (workMask & GLUT_EVENT_MASK_WORK) {
-      long eventMask;
-
-      /* Make sure children are not propogating events this
-         window is selecting for.  Be sure to do this before
-         enabling events on the children's parent. */
-      if (window->children) {
-        GLUTwindow *child = window->children;
-        unsigned long attribMask = CWDontPropagate;
-        XSetWindowAttributes wa;
-
-        wa.do_not_propagate_mask = window->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
-        if (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK) {
-          wa.event_mask = child->eventMask | (window->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
-          attribMask |= CWEventMask;
-        }
-        do {
-          XChangeWindowAttributes(__glutDisplay, child->win,
-            attribMask, &wa);
-          child = child->siblings;
-        } while (child);
-      }
-      eventMask = window->eventMask;
-      if (window->parent && window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
-        eventMask |= (window->parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK);
-      XSelectInput(__glutDisplay, window->win, eventMask);
-      if (window->overlay)
-        XSelectInput(__glutDisplay, window->overlay->win,
-          window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK);
-    }
-#endif /* !_WIN32 */
-    /* Be sure to set device mask BEFORE map window is done. */
-    if (workMask & GLUT_DEVICE_MASK_WORK) {
-      __glutUpdateInputDeviceMaskFunc(window);
-    }
-    /* Be sure to configure window BEFORE map window is done. */
-    if (workMask & GLUT_CONFIGURE_WORK) {
-#if defined(_WIN32)
-      RECT changes;
-      POINT point;
-      UINT flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER
-	| SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOZORDER;
-
-      GetClientRect(window->win, &changes);
-      
-      /* If this window is a toplevel window, translate the 0,0 client
-         coordinate into a screen coordinate for proper placement. */
-      if (!window->parent) {
-        point.x = 0;
-        point.y = 0;
-        ClientToScreen(window->win, &point);
-        changes.left = point.x;
-        changes.top = point.y;
-      }
-      if (window->desiredConfMask & (CWX | CWY)) {
-        changes.left = window->desiredX;
-        changes.top = window->desiredY;
-	flags &= ~SWP_NOMOVE;
-      }
-      if (window->desiredConfMask & (CWWidth | CWHeight)) {
-        changes.right = changes.left + window->desiredWidth;
-        changes.bottom = changes.top + window->desiredHeight;
-	flags &= ~SWP_NOSIZE;
-	/* XXX If overlay exists, resize the overlay here, ie.
-	   if (window->overlay) ... */
-      }
-      if (window->desiredConfMask & CWStackMode) {
-	flags &= ~SWP_NOZORDER;
-	/* XXX Overlay support might require something special here. */
-      }
-
-      /* Adjust the window rectangle because Win32 thinks that the x, y,
-         width & height are the WHOLE window (including decorations),
-         whereas GLUT treats the x, y, width & height as only the CLIENT
-         area of the window.  Only do this to top level windows
-         that are not in game mode (since game mode windows do
-         not have any decorations). */
-      if (!window->parent && window != __glutGameModeWindow) {
-        AdjustWindowRect(&changes,
-          WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
-          FALSE);
-      }
-
-      /* Do the repositioning, moving, and push/pop. */
-      SetWindowPos(window->win,
-        window->desiredStack == Above ? HWND_TOP : HWND_NOTOPMOST,
-        changes.left, changes.top,
-        changes.right - changes.left, changes.bottom - changes.top,
-        flags);
-
-      /* Zero out the mask. */
-      window->desiredConfMask = 0;
-
-      /* This hack causes the window to go back to the right position
-         when it is taken out of fullscreen mode. */
-      if (workMask & GLUT_FULL_SCREEN_WORK) {
-        window->desiredConfMask |= CWX | CWY;
-        window->desiredX = point.x;
-        window->desiredY = point.y;
-      }
-#else /* !_WIN32 */
-      XWindowChanges changes;
-
-      changes.x = window->desiredX;
-      changes.y = window->desiredY;
-      if (window->desiredConfMask & (CWWidth | CWHeight)) {
-        changes.width = window->desiredWidth;
-        changes.height = window->desiredHeight;
-        if (window->overlay)
-          XResizeWindow(__glutDisplay, window->overlay->win,
-            window->desiredWidth, window->desiredHeight);
-        if (__glutMotifHints != None) {
-          if (workMask & GLUT_FULL_SCREEN_WORK) {
-            MotifWmHints hints;
-
-            hints.flags = MWM_HINTS_DECORATIONS;
-            hints.decorations = 0;  /* Absolutely no
-                                       decorations. */
-            XChangeProperty(__glutDisplay, window->win,
-              __glutMotifHints, __glutMotifHints, 32,
-              PropModeReplace, (unsigned char *) &hints, 4);
-            if (workMask & GLUT_MAP_WORK) {
-              /* Handle case where glutFullScreen is called
-                 before the first time that the window is
-                 mapped. Some window managers will randomly or
-                 interactively position the window the first
-                 time it is mapped if the window's
-                 WM_NORMAL_HINTS property does not request an
-                 explicit position. We don't want any such
-                 window manager interaction when going
-                 fullscreen.  Overwrite the WM_NORMAL_HINTS
-                 property installed by glutCreateWindow's
-                 XSetWMProperties property with one explicitly
-                 requesting a fullscreen window. */
-              XSizeHints hints;
-
-              hints.flags = USPosition | USSize;
-              hints.x = 0;
-              hints.y = 0;
-              hints.width = window->desiredWidth;
-              hints.height = window->desiredHeight;
-              XSetWMNormalHints(__glutDisplay, window->win, &hints);
-            }
-          } else {
-            XDeleteProperty(__glutDisplay, window->win, __glutMotifHints);
-          }
-        }
-      }
-      if (window->desiredConfMask & CWStackMode) {
-        changes.stack_mode = window->desiredStack;
-        /* Do not let glutPushWindow push window beneath the
-           underlay. */
-        if (window->parent && window->parent->overlay
-          && window->desiredStack == Below) {
-          changes.stack_mode = Above;
-          changes.sibling = window->parent->overlay->win;
-          window->desiredConfMask |= CWSibling;
-        }
-      }
-      XConfigureWindow(__glutDisplay, window->win,
-        window->desiredConfMask, &changes);
-      window->desiredConfMask = 0;
-#endif
-    }
-#if !defined(_WIN32)
-    /* Be sure to establish the colormaps BEFORE map window is
-       done. */
-    if (workMask & GLUT_COLORMAP_WORK) {
-      __glutEstablishColormapsProperty(window);
-    }
-#endif
-    if (workMask & GLUT_MAP_WORK) {
-      switch (window->desiredMapState) {
-      case WithdrawnState:
-        if (window->parent) {
-          XUnmapWindow(__glutDisplay, window->win);
-        } else {
-          XWithdrawWindow(__glutDisplay, window->win,
-            __glutScreen);
-        }
-        window->shownState = 0;
-        break;
-      case NormalState:
-        XMapWindow(__glutDisplay, window->win);
-        window->shownState = 1;
-        break;
-#ifdef _WIN32
-      case GameModeState:  /* Not an Xlib value. */
-        ShowWindow(window->win, SW_SHOW);
-        window->shownState = 1;
-        break;
-#endif
-      case IconicState:
-        XIconifyWindow(__glutDisplay, window->win, __glutScreen);
-        window->shownState = 0;
-        break;
-      }
-    }
-  }
-  if (workMask & (GLUT_REDISPLAY_WORK | GLUT_OVERLAY_REDISPLAY_WORK | GLUT_REPAIR_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
-    if (window->forceReshape) {
-      /* Guarantee that before a display callback is generated
-         for a window, a reshape callback must be generated. */
-      __glutSetWindow(window);
-      window->reshape(window->width, window->height);
-      window->forceReshape = False;
-
-      /* Setting the redisplay bit on the first reshape is
-         necessary to make the "Mesa glXSwapBuffers to repair
-         damage" hack operate correctly.  Without indicating a
-         redisplay is necessary, there's not an initial back
-         buffer render from which to blit from when damage
-         happens to the window. */
-      workMask |= GLUT_REDISPLAY_WORK;
-    }
-    /* The code below is more involved than otherwise necessary
-       because it is paranoid about the overlay or entire window
-       being removed or destroyed in the course of the callbacks.
-       Notice how the global __glutWindowDamaged is used to record
-       the layers' damage status.  See the code in glutLayerGet for
-       how __glutWindowDamaged is used. The  point is to not have to
-       update the "damaged" field after  the callback since the
-       window (or overlay) may be destroyed (or removed) when the
-       callback returns. */
-
-    if (window->overlay && window->overlay->display) {
-      int num = window->num;
-      Window xid = window->overlay ? window->overlay->win : None;
-
-      /* If an overlay display callback is registered, we
-         differentiate between a redisplay needed for the
-         overlay and/or normal plane.  If there is no overlay
-         display callback registered, we simply use the
-         standard display callback. */
-
-      if (workMask & (GLUT_REDISPLAY_WORK | GLUT_REPAIR_WORK)) {
-        if (__glutMesaSwapHackSupport) {
-          if (window->usedSwapBuffers) {
-            if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
-	      SWAP_BUFFERS_WINDOW(window);
-              goto skippedDisplayCallback1;
-            }
-          }
-        }
-        /* Render to normal plane. */
-#ifdef _WIN32
-        window->renderDc = window->hdc;
-#endif
-        window->renderWin = window->win;
-        window->renderCtx = window->ctx;
-        __glutWindowDamaged = (workMask & GLUT_REPAIR_WORK);
-        __glutSetWindow(window);
-        window->usedSwapBuffers = 0;
-        window->display();
-        __glutWindowDamaged = 0;
-
-      skippedDisplayCallback1:;
-      }
-      if (workMask & (GLUT_OVERLAY_REDISPLAY_WORK | GLUT_OVERLAY_REPAIR_WORK)) {
-        window = __glutWindowList[num];
-        if (window && window->overlay &&
-          window->overlay->win == xid && window->overlay->display) {
-
-          /* Render to overlay. */
-#ifdef _WIN32
-          window->renderDc = window->overlay->hdc;
-#endif
-          window->renderWin = window->overlay->win;
-          window->renderCtx = window->overlay->ctx;
-          __glutWindowDamaged = (workMask & GLUT_OVERLAY_REPAIR_WORK);
-          __glutSetWindow(window);
-          window->overlay->display();
-          __glutWindowDamaged = 0;
-        } else {
-          /* Overlay may have since been destroyed or the
-             overlay callback may have been disabled during
-             normal display callback. */
-        }
-      }
-    } else {
-      if (__glutMesaSwapHackSupport) {
-        if (!window->overlay && window->usedSwapBuffers) {
-          if ((workMask & (GLUT_REPAIR_WORK | GLUT_REDISPLAY_WORK)) == GLUT_REPAIR_WORK) {
-	    SWAP_BUFFERS_WINDOW(window);
-            goto skippedDisplayCallback2;
-          }
-        }
-      }
-      /* Render to normal plane (and possibly overlay). */
-      __glutWindowDamaged = (workMask & (GLUT_OVERLAY_REPAIR_WORK | GLUT_REPAIR_WORK));
-      __glutSetWindow(window);
-      window->usedSwapBuffers = 0;
-      window->display();
-      __glutWindowDamaged = 0;
-
-    skippedDisplayCallback2:;
-    }
-  }
-  /* Combine workMask with window->workMask to determine what
-     finish and debug work there is. */
-  assert(window);
-  workMask |= window->workMask;
-
-  if (workMask & GLUT_FINISH_WORK) {
-    /* Finish work makes sure a glFinish gets done to indirect
-       rendering contexts.  Indirect contexts tend to have much 
-       longer latency because lots of OpenGL extension requests 
-       can queue up in the X protocol stream. __glutSetWindow
-       is where the finish works gets queued for indirect
-       contexts. */
-    __glutSetWindow(window);
-#if !defined(_WIN32)
-    if (!window->isDirect)
-#endif
-    {
-       glFinish();
-    }
-  }
-  if (workMask & GLUT_DEBUG_WORK) {
-    __glutSetWindow(window);
-    glutReportErrors();
-  }
-  /* Strip out dummy, finish, and debug work bits. */
-  window->workMask &= ~(GLUT_DUMMY_WORK | GLUT_FINISH_WORK | GLUT_DEBUG_WORK);
-  if (window->workMask) {
-    /* Leave on work list. */
-    return window;
-  } else {
-    /* Remove current window from work list. */
-    return window->prevWorkWin;
-  }
-}
-
-static  /* X11 implementations do not need this global. */
-void
-__glutProcessWindowWorkLists(void)
-{
-  if (__glutWindowWorkList) {
-    GLUTwindow *remainder, *work;
-
-    work = __glutWindowWorkList;
-    __glutWindowWorkList = NULL;
-    if (work) {
-      remainder = processWindowWorkList(work);
-      if (remainder) {
-        *beforeEnd = __glutWindowWorkList;
-        __glutWindowWorkList = remainder;
-      }
-    }
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutMainLoop(void)
-{
-#if !defined(_WIN32)
-  if (!__glutDisplay)
-    __glutFatalUsage("main loop entered with out proper initialization.");
-#endif
-  if (!__glutWindowListSize)
-    __glutFatalUsage(
-      "main loop entered with no windows created.");
-  for (;;) {
-    __glutProcessWindowWorkLists();
-    if (__glutIdleFunc || __glutWindowWorkList) {
-      idleWait();
-    } else {
-      if (__glutTimerList) {
-        waitForSomething();
-      } else {
-        processEventsAndTimeouts();
-      }
-    }
-  }
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_ext.c b/src/glut/glx/glut_ext.c
deleted file mode 100644
index 922a94b20dd..00000000000
--- a/src/glut/glx/glut_ext.c
+++ /dev/null
@@ -1,201 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutExtensionSupported(const char *extension)
-{
-  static const GLubyte *extensions = NULL;
-  const GLubyte *start;
-  GLubyte *where, *terminator;
-
-  /* Extension names should not have spaces. */
-  where = (GLubyte *) strchr(extension, ' ');
-  if (where || *extension == '\0')
-    return 0;
-
-  if (!extensions) {
-    extensions = glGetString(GL_EXTENSIONS);
-  }
-  /* It takes a bit of care to be fool-proof about parsing the
-     OpenGL extensions string.  Don't be fooled by sub-strings,
-     etc. */
-  start = extensions;
-  for (;;) {
-    /* If your application crashes in the strstr routine below,
-       you are probably calling glutExtensionSupported without
-       having a current window.  Calling glGetString without
-       a current OpenGL context has unpredictable results.
-       Please fix your program. */
-    where = (GLubyte *) strstr((const char *) start, extension);
-    if (!where)
-      break;
-    terminator = where + strlen(extension);
-    if (where == start || *(where - 1) == ' ') {
-      if (*terminator == ' ' || *terminator == '\0') {
-        return 1;
-      }
-    }
-    start = terminator;
-  }
-  return 0;
-}
-
-
-struct name_address_pair {
-   const char *name;
-   const GLUTproc address;
-};
-
-static struct name_address_pair glut_functions[] = {
-   { "glutInit", (const GLUTproc) glutInit },
-   { "glutInitDisplayMode", (const GLUTproc) glutInitDisplayMode },
-   { "glutInitDisplayString", (const GLUTproc) glutInitDisplayString },
-   { "glutInitWindowPosition", (const GLUTproc) glutInitWindowPosition },
-   { "glutInitWindowSize", (const GLUTproc) glutInitWindowSize },
-   { "glutMainLoop", (const GLUTproc) glutMainLoop },
-   { "glutCreateWindow", (const GLUTproc) glutCreateWindow },
-   { "glutCreateSubWindow", (const GLUTproc) glutCreateSubWindow },
-   { "glutDestroyWindow", (const GLUTproc) glutDestroyWindow },
-   { "glutPostRedisplay", (const GLUTproc) glutPostRedisplay },
-   { "glutPostWindowRedisplay", (const GLUTproc) glutPostWindowRedisplay },
-   { "glutSwapBuffers", (const GLUTproc) glutSwapBuffers },
-   { "glutGetWindow", (const GLUTproc) glutGetWindow },
-   { "glutSetWindow", (const GLUTproc) glutSetWindow },
-   { "glutSetWindowTitle", (const GLUTproc) glutSetWindowTitle },
-   { "glutSetIconTitle", (const GLUTproc) glutSetIconTitle },
-   { "glutPositionWindow", (const GLUTproc) glutPositionWindow },
-   { "glutReshapeWindow", (const GLUTproc) glutReshapeWindow },
-   { "glutPopWindow", (const GLUTproc) glutPopWindow },
-   { "glutPushWindow", (const GLUTproc) glutPushWindow },
-   { "glutIconifyWindow", (const GLUTproc) glutIconifyWindow },
-   { "glutShowWindow", (const GLUTproc) glutShowWindow },
-   { "glutHideWindow", (const GLUTproc) glutHideWindow },
-   { "glutFullScreen", (const GLUTproc) glutFullScreen },
-   { "glutSetCursor", (const GLUTproc) glutSetCursor },
-   { "glutWarpPointer", (const GLUTproc) glutWarpPointer },
-   { "glutEstablishOverlay", (const GLUTproc) glutEstablishOverlay },
-   { "glutRemoveOverlay", (const GLUTproc) glutRemoveOverlay },
-   { "glutUseLayer", (const GLUTproc) glutUseLayer },
-   { "glutPostOverlayRedisplay", (const GLUTproc) glutPostOverlayRedisplay },
-   { "glutPostWindowOverlayRedisplay", (const GLUTproc) glutPostWindowOverlayRedisplay },
-   { "glutShowOverlay", (const GLUTproc) glutShowOverlay },
-   { "glutHideOverlay", (const GLUTproc) glutHideOverlay },
-   { "glutCreateMenu", (const GLUTproc) glutCreateMenu },
-   { "glutDestroyMenu", (const GLUTproc) glutDestroyMenu },
-   { "glutGetMenu", (const GLUTproc) glutGetMenu },
-   { "glutSetMenu", (const GLUTproc) glutSetMenu },
-   { "glutAddMenuEntry", (const GLUTproc) glutAddMenuEntry },
-   { "glutAddSubMenu", (const GLUTproc) glutAddSubMenu },
-   { "glutChangeToMenuEntry", (const GLUTproc) glutChangeToMenuEntry },
-   { "glutChangeToSubMenu", (const GLUTproc) glutChangeToSubMenu },
-   { "glutRemoveMenuItem", (const GLUTproc) glutRemoveMenuItem },
-   { "glutAttachMenu", (const GLUTproc) glutAttachMenu },
-   { "glutDetachMenu", (const GLUTproc) glutDetachMenu },
-   { "glutDisplayFunc", (const GLUTproc) glutDisplayFunc },
-   { "glutReshapeFunc", (const GLUTproc) glutReshapeFunc },
-   { "glutKeyboardFunc", (const GLUTproc) glutKeyboardFunc },
-   { "glutMouseFunc", (const GLUTproc) glutMouseFunc },
-   { "glutMotionFunc", (const GLUTproc) glutMotionFunc },
-   { "glutPassiveMotionFunc", (const GLUTproc) glutPassiveMotionFunc },
-   { "glutEntryFunc", (const GLUTproc) glutEntryFunc },
-   { "glutVisibilityFunc", (const GLUTproc) glutVisibilityFunc },
-   { "glutIdleFunc", (const GLUTproc) glutIdleFunc },
-   { "glutTimerFunc", (const GLUTproc) glutTimerFunc },
-   { "glutMenuStateFunc", (const GLUTproc) glutMenuStateFunc },
-   { "glutSpecialFunc", (const GLUTproc) glutSpecialFunc },
-   { "glutSpaceballMotionFunc", (const GLUTproc) glutSpaceballMotionFunc },
-   { "glutSpaceballRotateFunc", (const GLUTproc) glutSpaceballRotateFunc },
-   { "glutSpaceballButtonFunc", (const GLUTproc) glutSpaceballButtonFunc },
-   { "glutButtonBoxFunc", (const GLUTproc) glutButtonBoxFunc },
-   { "glutDialsFunc", (const GLUTproc) glutDialsFunc },
-   { "glutTabletMotionFunc", (const GLUTproc) glutTabletMotionFunc },
-   { "glutTabletButtonFunc", (const GLUTproc) glutTabletButtonFunc },
-   { "glutMenuStatusFunc", (const GLUTproc) glutMenuStatusFunc },
-   { "glutOverlayDisplayFunc", (const GLUTproc) glutOverlayDisplayFunc },
-   { "glutWindowStatusFunc", (const GLUTproc) glutWindowStatusFunc },
-   { "glutKeyboardUpFunc", (const GLUTproc) glutKeyboardUpFunc },
-   { "glutSpecialUpFunc", (const GLUTproc) glutSpecialUpFunc },
-   { "glutJoystickFunc", (const GLUTproc) glutJoystickFunc },
-   { "glutSetColor", (const GLUTproc) glutSetColor },
-   { "glutGetColor", (const GLUTproc) glutGetColor },
-   { "glutCopyColormap", (const GLUTproc) glutCopyColormap },
-   { "glutGet", (const GLUTproc) glutGet },
-   { "glutDeviceGet", (const GLUTproc) glutDeviceGet },
-   { "glutExtensionSupported", (const GLUTproc) glutExtensionSupported },
-   { "glutGetModifiers", (const GLUTproc) glutGetModifiers },
-   { "glutLayerGet", (const GLUTproc) glutLayerGet },
-   { "glutGetProcAddress", (const GLUTproc) glutGetProcAddress },
-   { "glutBitmapCharacter", (const GLUTproc) glutBitmapCharacter },
-   { "glutBitmapWidth", (const GLUTproc) glutBitmapWidth },
-   { "glutStrokeCharacter", (const GLUTproc) glutStrokeCharacter },
-   { "glutStrokeWidth", (const GLUTproc) glutStrokeWidth },
-   { "glutBitmapLength", (const GLUTproc) glutBitmapLength },
-   { "glutStrokeLength", (const GLUTproc) glutStrokeLength },
-   { "glutWireSphere", (const GLUTproc) glutWireSphere },
-   { "glutSolidSphere", (const GLUTproc) glutSolidSphere },
-   { "glutWireCone", (const GLUTproc) glutWireCone },
-   { "glutSolidCone", (const GLUTproc) glutSolidCone },
-   { "glutWireCube", (const GLUTproc) glutWireCube },
-   { "glutSolidCube", (const GLUTproc) glutSolidCube },
-   { "glutWireTorus", (const GLUTproc) glutWireTorus },
-   { "glutSolidTorus", (const GLUTproc) glutSolidTorus },
-   { "glutWireDodecahedron", (const GLUTproc) glutWireDodecahedron },
-   { "glutSolidDodecahedron", (const GLUTproc) glutSolidDodecahedron },
-   { "glutWireTeapot", (const GLUTproc) glutWireTeapot },
-   { "glutSolidTeapot", (const GLUTproc) glutSolidTeapot },
-   { "glutWireOctahedron", (const GLUTproc) glutWireOctahedron },
-   { "glutSolidOctahedron", (const GLUTproc) glutSolidOctahedron },
-   { "glutWireTetrahedron", (const GLUTproc) glutWireTetrahedron },
-   { "glutSolidTetrahedron", (const GLUTproc) glutSolidTetrahedron },
-   { "glutWireIcosahedron", (const GLUTproc) glutWireIcosahedron },
-   { "glutSolidIcosahedron", (const GLUTproc) glutSolidIcosahedron },
-   { "glutVideoResizeGet", (const GLUTproc) glutVideoResizeGet },
-   { "glutSetupVideoResizing", (const GLUTproc) glutSetupVideoResizing },
-   { "glutStopVideoResizing", (const GLUTproc) glutStopVideoResizing },
-   { "glutVideoResize", (const GLUTproc) glutVideoResize },
-   { "glutVideoPan", (const GLUTproc) glutVideoPan },
-   { "glutReportErrors", (const GLUTproc) glutReportErrors },
-   { "glutIgnoreKeyRepeat", (const GLUTproc) glutIgnoreKeyRepeat },
-   { "glutSetKeyRepeat", (const GLUTproc) glutSetKeyRepeat },
-   { "glutForceJoystickFunc", (const GLUTproc) glutForceJoystickFunc },
-   { "glutGameModeString", (const GLUTproc) glutGameModeString },
-   { "glutEnterGameMode", (const GLUTproc) glutEnterGameMode },
-   { "glutLeaveGameMode", (const GLUTproc) glutLeaveGameMode },
-   { "glutGameModeGet", (const GLUTproc) glutGameModeGet },
-   { NULL, NULL }
-};   
-
-
-/* XXX This isn't an official GLUT function, yet */
-GLUTproc GLUTAPIENTRY 
-glutGetProcAddress(const char *procName)
-{
-   /* Try GLUT functions first */
-   int i;
-   for (i = 0; glut_functions[i].name; i++) {
-      if (strcmp(glut_functions[i].name, procName) == 0)
-         return glut_functions[i].address;
-   }
-
-   /* Try core GL functions */
-#if defined(_WIN32)
-  return (GLUTproc) wglGetProcAddress((LPCSTR) procName);
-#elif defined(GLX_ARB_get_proc_address)
-  return (GLUTproc) glXGetProcAddressARB((const GLubyte *) procName);
-#else
-  return NULL;
-#endif
-}
-
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_fcb.c b/src/glut/glx/glut_fcb.c
deleted file mode 100644
index c8a3422b360..00000000000
--- a/src/glut/glx/glut_fcb.c
+++ /dev/null
@@ -1,164 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1998.  */
-
-/* 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. */
-
-/* I appreciate the guidance from William Mitchell
-   ([email protected]) in developing this friend interface
-   for use by the f90gl package.  See ../../README.fortran */
-
-#include "glutint.h"
-
-/* FCB stands for Fortran CallBack. */
-
-/* There is only one idleFunc, menuStateFunc, and menuStatusFunc, so they
-   can be saved in the wrappers for Fortran rather than the C structures. */
-
-/* Set a Fortran callback function. */
-
-void APIENTRY
-__glutSetFCB(int which, GLUTproc func)
-{
-#ifdef SUPPORT_FORTRAN
-  switch (which) {
-  case GLUT_FCB_DISPLAY:
-    __glutCurrentWindow->fdisplay = (GLUTdisplayFCB) func;
-    break;
-  case GLUT_FCB_RESHAPE:
-    __glutCurrentWindow->freshape = (GLUTreshapeFCB) func;
-    break;
-  case GLUT_FCB_MOUSE:
-    __glutCurrentWindow->fmouse = (GLUTmouseFCB) func;
-    break;
-  case GLUT_FCB_MOTION:
-    __glutCurrentWindow->fmotion = (GLUTmotionFCB) func;
-    break;
-  case GLUT_FCB_PASSIVE:
-    __glutCurrentWindow->fpassive = (GLUTpassiveFCB) func;
-    break;
-  case GLUT_FCB_ENTRY:
-    __glutCurrentWindow->fentry = (GLUTentryFCB) func;
-    break;
-  case GLUT_FCB_KEYBOARD:
-    __glutCurrentWindow->fkeyboard = (GLUTkeyboardFCB) func;
-    break;
-  case GLUT_FCB_KEYBOARD_UP:
-    __glutCurrentWindow->fkeyboardUp = (GLUTkeyboardFCB) func;
-    break;
-  case GLUT_FCB_WINDOW_STATUS:
-    __glutCurrentWindow->fwindowStatus = (GLUTwindowStatusFCB) func;
-    break;
-  case GLUT_FCB_VISIBILITY:
-    __glutCurrentWindow->fvisibility = (GLUTvisibilityFCB) func;
-    break;
-  case GLUT_FCB_SPECIAL:
-    __glutCurrentWindow->fspecial = (GLUTspecialFCB) func;
-    break;
-  case GLUT_FCB_SPECIAL_UP:
-    __glutCurrentWindow->fspecialUp = (GLUTspecialFCB) func;
-    break;
-  case GLUT_FCB_BUTTON_BOX:
-    __glutCurrentWindow->fbuttonBox = (GLUTbuttonBoxFCB) func;
-    break;
-  case GLUT_FCB_DIALS:
-    __glutCurrentWindow->fdials = (GLUTdialsFCB) func;
-    break;
-  case GLUT_FCB_SPACE_MOTION:
-    __glutCurrentWindow->fspaceMotion = (GLUTspaceMotionFCB) func;
-    break;
-  case GLUT_FCB_SPACE_ROTATE:
-    __glutCurrentWindow->fspaceRotate = (GLUTspaceRotateFCB) func;
-    break;
-  case GLUT_FCB_SPACE_BUTTON:
-    __glutCurrentWindow->fspaceButton = (GLUTspaceButtonFCB) func;
-    break;
-  case GLUT_FCB_TABLET_MOTION:
-    __glutCurrentWindow->ftabletMotion = (GLUTtabletMotionFCB) func;
-    break;
-  case GLUT_FCB_TABLET_BUTTON:
-    __glutCurrentWindow->ftabletButton = (GLUTtabletButtonFCB) func;
-    break;
-#ifdef _WIN32
-  case GLUT_FCB_JOYSTICK:
-    __glutCurrentWindow->fjoystick = (GLUTjoystickFCB) func;
-    break;
-#endif
-  case GLUT_FCB_OVERLAY_DISPLAY:
-    __glutCurrentWindow->overlay->fdisplay = (GLUTdisplayFCB) func;
-    break;
-  case GLUT_FCB_SELECT:
-    __glutCurrentMenu->fselect = (GLUTselectFCB) func;
-    break;
-  case GLUT_FCB_TIMER:
-    __glutNewTimer->ffunc = (GLUTtimerFCB) func;
-    break;
-  }
-#endif
-}
-
-/* Get a Fortran callback function. */
-
-GLUTproc APIENTRY
-__glutGetFCB(int which)
-{
-#ifdef SUPPORT_FORTRAN
-  switch (which) {
-  case GLUT_FCB_DISPLAY:
-    return __glutCurrentWindow->fdisplay;
-  case GLUT_FCB_RESHAPE:
-    return __glutCurrentWindow->freshape;
-  case GLUT_FCB_MOUSE:
-    return __glutCurrentWindow->fmouse;
-  case GLUT_FCB_MOTION:
-    return __glutCurrentWindow->fmotion;
-  case GLUT_FCB_PASSIVE:
-    return __glutCurrentWindow->fpassive;
-  case GLUT_FCB_ENTRY:
-    return __glutCurrentWindow->fentry;
-  case GLUT_FCB_KEYBOARD:
-    return __glutCurrentWindow->fkeyboard;
-  case GLUT_FCB_KEYBOARD_UP:
-    return __glutCurrentWindow->fkeyboardUp;
-  case GLUT_FCB_WINDOW_STATUS:
-    return __glutCurrentWindow->fwindowStatus;
-  case GLUT_FCB_VISIBILITY:
-    return __glutCurrentWindow->fvisibility;
-  case GLUT_FCB_SPECIAL:
-    return __glutCurrentWindow->fspecial;
-  case GLUT_FCB_SPECIAL_UP:
-    return __glutCurrentWindow->fspecialUp;
-  case GLUT_FCB_BUTTON_BOX:
-    return __glutCurrentWindow->fbuttonBox;
-  case GLUT_FCB_DIALS:
-    return __glutCurrentWindow->fdials;
-  case GLUT_FCB_SPACE_MOTION:
-    return __glutCurrentWindow->fspaceMotion;
-  case GLUT_FCB_SPACE_ROTATE:
-    return __glutCurrentWindow->fspaceRotate;
-  case GLUT_FCB_SPACE_BUTTON:
-    return __glutCurrentWindow->fspaceButton;
-  case GLUT_FCB_TABLET_MOTION:
-    return __glutCurrentWindow->ftabletMotion;
-  case GLUT_FCB_TABLET_BUTTON:
-    return __glutCurrentWindow->ftabletButton;
-  case GLUT_FCB_JOYSTICK:
-#ifdef _WIN32
-    return __glutCurrentWindow->fjoystick;
-#else
-    return NULL;
-#endif
-  case GLUT_FCB_OVERLAY_DISPLAY:
-    return __glutCurrentWindow->overlay->fdisplay;
-  case GLUT_FCB_SELECT:
-    return __glutCurrentMenu->fselect;
-  case GLUT_FCB_TIMER:
-     return __glutTimerList ? __glutTimerList->ffunc : NULL;
-  default:
-    return NULL;
-  }
-#else
-  return NULL;
-#endif
-}
diff --git a/src/glut/glx/glut_fullscrn.c b/src/glut/glx/glut_fullscrn.c
deleted file mode 100644
index 78a7a6148b6..00000000000
--- a/src/glut/glx/glut_fullscrn.c
+++ /dev/null
@@ -1,55 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1995, 1998. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdio.h>  /* SunOS multithreaded assert() needs <stdio.h>.  Lame. */
-#include <assert.h>
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#endif
-
-/* SGI optimization introduced in IRIX 6.3 to avoid X server
-   round trips for interning common X atoms. */
-#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
-#include <X11/SGIFastAtom.h>
-#else
-#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
-#endif
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutFullScreen(void)
-{
-  assert(!__glutCurrentWindow->parent);
-  IGNORE_IN_GAME_MODE();
-#if !defined(_WIN32)
-  if (__glutMotifHints == None) {
-    __glutMotifHints = XSGIFastInternAtom(__glutDisplay, "_MOTIF_WM_HINTS",
-      SGI_XA__MOTIF_WM_HINTS, 0);
-    if (__glutMotifHints == None) {
-      __glutWarning("Could not intern X atom for _MOTIF_WM_HINTS.");
-    }
-  }
-#endif
-
-  __glutCurrentWindow->desiredX = 0;
-  __glutCurrentWindow->desiredY = 0;
-  __glutCurrentWindow->desiredWidth = __glutScreenWidth;
-  __glutCurrentWindow->desiredHeight = __glutScreenHeight;
-  __glutCurrentWindow->desiredConfMask |= CWX | CWY | CWWidth | CWHeight;
-
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_gamemode.c b/src/glut/glx/glut_gamemode.c
deleted file mode 100644
index 4a92099f3fe..00000000000
--- a/src/glut/glx/glut_gamemode.c
+++ /dev/null
@@ -1,677 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1998. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "glutint.h"
-
-#ifndef _WIN32
-#include <X11/Xlib.h>
-
-/* SGI optimization introduced in IRIX 6.3 to avoid X server
-   round trips for interning common X atoms. */
-#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
-#include <X11/SGIFastAtom.h>
-#else
-#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
-#endif
-#endif  /* not _WIN32 */
-
-int __glutDisplaySettingsChanged = 0;
-static DisplayMode *dmodes, *currentDm = NULL;
-static int ndmodes = -1;
-GLUTwindow *__glutGameModeWindow = NULL;
-
-#ifdef TEST
-static char *compstr[] =
-{
-  "none", "=", "!=", "<=", ">=", ">", "<", "~"
-};
-static char *capstr[] =
-{
-  "width", "height", "bpp", "hertz", "num"
-};
-#endif
-
-void
-__glutCloseDownGameMode(void)
-{
-  if (__glutDisplaySettingsChanged) {
-#ifdef _WIN32
-    /* Assumes that display settings have been changed, that
-       is __glutDisplaySettingsChanged is true. */
-    ChangeDisplaySettings(NULL, 0);
-#endif
-    __glutDisplaySettingsChanged = 0;
-  }
-  __glutGameModeWindow = NULL;
-}
-
-void GLUTAPIENTRY
-glutLeaveGameMode(void)
-{
-  if (__glutGameModeWindow == NULL) {
-    __glutWarning("not in game mode so cannot leave game mode");
-    return;
-  }
-  __glutDestroyWindow(__glutGameModeWindow,
-    __glutGameModeWindow);
-  XFlush(__glutDisplay);
-  __glutGameModeWindow = NULL;
-}
-
-#ifdef _WIN32
-
-/* Same values as from MSDN's SetDisp.c example. */
-#define MIN_WIDTH 400
-#define MIN_FREQUENCY 60
-
-static void
-initGameModeSupport(void)
-{
-  DEVMODE dm;
-  DWORD mode;
-  int i;
-
-  if (ndmodes >= 0) {
-    /* ndmodes is initially -1 to indicate no
-       dmodes allocated yet. */
-    return;
-  }
-
-  /* Determine how many display modes there are. */
-  ndmodes = 0;
-  mode = 0;
-  while (EnumDisplaySettings(NULL, mode, &dm)) {
-    if (dm.dmPelsWidth >= MIN_WIDTH &&
-      (dm.dmDisplayFrequency == 0 ||
-      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
-      ndmodes++;
-    }
-    mode++;
-  }
-
-  /* Allocate memory for a list of all the display modes. */
-  dmodes = (DisplayMode*)
-    malloc(ndmodes * sizeof(DisplayMode));
-
-  /* Now that we know how many display modes to expect,
-     enumerate them again and save the information in
-     the list we allocated above. */
-  i = 0;
-  mode = 0;
-  while (EnumDisplaySettings(NULL, mode, &dm)) {
-    /* Try to reject any display settings that seem unplausible. */
-    if (dm.dmPelsWidth >= MIN_WIDTH &&
-      (dm.dmDisplayFrequency == 0 ||
-      dm.dmDisplayFrequency >= MIN_FREQUENCY)) {
-      dmodes[i].devmode = dm;
-      dmodes[i].valid = 1;  /* XXX Not used for now. */
-      dmodes[i].cap[DM_WIDTH] = dm.dmPelsWidth;
-      dmodes[i].cap[DM_HEIGHT] = dm.dmPelsHeight;
-      dmodes[i].cap[DM_PIXEL_DEPTH] = dm.dmBitsPerPel;
-      if (dm.dmDisplayFrequency == 0) {
- 	/* Guess a reasonable guess. */
-	/* Lame Windows 95 version of EnumDisplaySettings. */
-        dmodes[i].cap[DM_HERTZ] = 60;
-      } else {
-	dmodes[i].cap[DM_HERTZ] = dm.dmDisplayFrequency;
-      }
-      i++;
-    }
-    mode++;
-  }
-
-  assert(i == ndmodes);
-}
-
-#else
-
-/* X Windows version of initGameModeSupport. */
-static void
-initGameModeSupport(void)
-{
-  if (ndmodes >= 0) {
-    /* ndmodes is initially -1 to indicate no
-       dmodes allocated yet. */
-    return;
-  }
-
-  /* Determine how many display modes there are. */
-  ndmodes = 0;
-}
-
-#endif
-
-/* This routine is based on similiar code in glut_dstr.c */
-static DisplayMode *
-findMatch(DisplayMode * dmodes, int ndmodes,
-  Criterion * criteria, int ncriteria)
-{
-  DisplayMode *found;
-  int *bestScore, *thisScore;
-  int i, j, numok, result = 0, worse, better;
-
-  found = NULL;
-  numok = 1;            /* "num" capability is indexed from 1,
-                           not 0. */
-
-  /* XXX alloca canidate. */
-  bestScore = (int *) malloc(ncriteria * sizeof(int));
-  if (!bestScore) {
-    __glutFatalError("out of memory.");
-  }
-  for (j = 0; j < ncriteria; j++) {
-    /* Very negative number. */
-    bestScore[j] = -32768;
-  }
-
-  /* XXX alloca canidate. */
-  thisScore = (int *) malloc(ncriteria * sizeof(int));
-  if (!thisScore) {
-    __glutFatalError("out of memory.");
-  }
-
-  for (i = 0; i < ndmodes; i++) {
-    if (dmodes[i].valid) {
-      worse = 0;
-      better = 0;
-
-      for (j = 0; j < ncriteria; j++) {
-        int cap, cvalue, dvalue;
-
-        cap = criteria[j].capability;
-        cvalue = criteria[j].value;
-        if (cap == NUM) {
-          dvalue = numok;
-        } else {
-          dvalue = dmodes[i].cap[cap];
-        }
-#ifdef TEST
-        if (verbose)
-          printf("  %s %s %d to %d\n",
-            capstr[cap], compstr[criteria[j].comparison], cvalue, dvalue);
-#endif
-        switch (criteria[j].comparison) {
-        case EQ:
-          result = cvalue == dvalue;
-          thisScore[j] = 1;
-          break;
-        case NEQ:
-          result = cvalue != dvalue;
-          thisScore[j] = 1;
-          break;
-        case LT:
-          result = dvalue < cvalue;
-          thisScore[j] = dvalue - cvalue;
-          break;
-        case GT:
-          result = dvalue > cvalue;
-          thisScore[j] = dvalue - cvalue;
-          break;
-        case LTE:
-          result = dvalue <= cvalue;
-          thisScore[j] = dvalue - cvalue;
-          break;
-        case GTE:
-          result = (dvalue >= cvalue);
-          thisScore[j] = dvalue - cvalue;
-          break;
-        case MIN:
-          result = dvalue >= cvalue;
-          thisScore[j] = cvalue - dvalue;
-          break;
-        }
-
-#ifdef TEST
-        if (verbose)
-          printf("                result=%d   score=%d   bestScore=%d\n", result, thisScore[j], bestScore[j]);
-#endif
-
-        if (result) {
-          if (better || thisScore[j] > bestScore[j]) {
-            better = 1;
-          } else if (thisScore[j] == bestScore[j]) {
-            /* Keep looking. */
-          } else {
-            goto nextDM;
-          }
-        } else {
-          if (cap == NUM) {
-            worse = 1;
-          } else {
-            goto nextDM;
-          }
-        }
-
-      }
-
-      if (better && !worse) {
-        found = &dmodes[i];
-        for (j = 0; j < ncriteria; j++) {
-          bestScore[j] = thisScore[j];
-        }
-      }
-      numok++;
-
-    nextDM:;
-
-    }
-  }
-  free(bestScore);
-  free(thisScore);
-  return found;
-}
-
-/**
- * Parses strings in the form of:
- *  800x600
- *  800x600:16
- *  800x600@60
- *  800x600:16@60
- *  @60
- *  :16
- *  :16@60
- * NOTE that @ before : is not parsed.
- */
-static int
-specialCaseParse(char *word, Criterion * criterion, int mask)
-{
-  char *xstr, *response;
-  int got;
-  int width, height, bpp, hertz;
-
-  switch(word[0]) {
-  case '0':
-  case '1':
-  case '2':
-  case '3':
-  case '4':
-  case '5':
-  case '6':
-  case '7':
-  case '8':
-  case '9':
-    /* The WWWxHHH case. */
-    if (mask & (1 << DM_WIDTH)) {
-      return -1;
-    }
-    xstr = strpbrk(&word[1], "x");
-    if (xstr) {
-      width = (int) strtol(word, &response, 0);
-      if (response == word || response[0] != 'x') {
-        /* Not a valid number OR needs to be followed by 'x'. */
-	return -1;
-      }
-      height = (int) strtol(&xstr[1], &response, 0);
-      if (response == &xstr[1]) {
-        /* Not a valid number. */
-	return -1;
-      }
-      criterion[0].capability = DM_WIDTH;
-      criterion[0].comparison = EQ;
-      criterion[0].value = width;
-      criterion[1].capability = DM_HEIGHT;
-      criterion[1].comparison = EQ;
-      criterion[1].value = height;
-      got = specialCaseParse(response,
-        &criterion[2], 1 << DM_WIDTH);
-      if (got >= 0) {
-        return got + 2;
-      } else {
-        return -1;
-      }
-    }
-    return -1;
-  case ':':
-    /* The :BPP case. */
-    if (mask & (1 << DM_PIXEL_DEPTH)) {
-      return -1;
-    }
-    bpp = (int) strtol(&word[1], &response, 0);
-    if (response == &word[1]) {
-      /* Not a valid number. */
-      return -1;
-    }
-    criterion[0].capability = DM_PIXEL_DEPTH;
-    criterion[0].comparison = EQ;
-    criterion[0].value = bpp;
-    got = specialCaseParse(response,
-      &criterion[1], 1 << DM_WIDTH | 1 << DM_PIXEL_DEPTH);
-    if (got >= 0) {
-      return got + 1;
-    } else {
-      return -1;
-    }
-  case '@':
-    /* The @HZ case. */
-    if (mask & (1 << DM_HERTZ)) {
-      return -1;
-    }
-    hertz = (int) strtol(&word[1], &response, 0);
-    if (response == &word[1]) {
-      /* Not a valid number. */
-      return -1;
-    }
-    criterion[0].capability = DM_HERTZ;
-    criterion[0].comparison = EQ;
-    criterion[0].value = hertz;
-    got = specialCaseParse(response,
-      &criterion[1], ~DM_HERTZ);
-    if (got >= 0) {
-      return got + 1;
-    } else {
-      return -1;
-    }
-  case '\0':
-    return 0;
-  }
-  return -1;
-}
-
-/* This routine is based on similiar code in glut_dstr.c */
-static int
-parseCriteria(char *word, Criterion * criterion)
-{
-  char *cstr, *vstr, *response;
-  int comparator, value = 0;
-
-  cstr = strpbrk(word, "=><!~");
-  if (cstr) {
-    switch (cstr[0]) {
-    case '=':
-      comparator = EQ;
-      vstr = &cstr[1];
-      break;
-    case '~':
-      comparator = MIN;
-      vstr = &cstr[1];
-      break;
-    case '>':
-      if (cstr[1] == '=') {
-        comparator = GTE;
-        vstr = &cstr[2];
-      } else {
-        comparator = GT;
-        vstr = &cstr[1];
-      }
-      break;
-    case '<':
-      if (cstr[1] == '=') {
-        comparator = LTE;
-        vstr = &cstr[2];
-      } else {
-        comparator = LT;
-        vstr = &cstr[1];
-      }
-      break;
-    case '!':
-      if (cstr[1] == '=') {
-        comparator = NEQ;
-        vstr = &cstr[2];
-      } else {
-        return -1;
-      }
-      break;
-    default:
-      return -1;
-    }
-    value = (int) strtol(vstr, &response, 0);
-    if (response == vstr) {
-      /* Not a valid number. */
-      return -1;
-    }
-    *cstr = '\0';
-  } else {
-    comparator = NONE;
-  }
-  switch (word[0]) {
-  case 'b':
-    if (!strcmp(word, "bpp")) {
-      criterion[0].capability = DM_PIXEL_DEPTH;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-  case 'h':
-    if (!strcmp(word, "height")) {
-      criterion[0].capability = DM_HEIGHT;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    if (!strcmp(word, "hertz")) {
-      criterion[0].capability = DM_HERTZ;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-  case 'n':
-    if (!strcmp(word, "num")) {
-      criterion[0].capability = DM_NUM;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-  case 'w':
-    if (!strcmp(word, "width")) {
-      criterion[0].capability = DM_WIDTH;
-      if (comparator == NONE) {
-        return -1;
-      } else {
-        criterion[0].comparison = comparator;
-        criterion[0].value = value;
-        return 1;
-      }
-    }
-    return -1;
-  }
-  if (comparator == NONE) {
-    return specialCaseParse(word, criterion, 0);
-  }
-  return -1;
-}
-
-/* This routine is based on similiar code in glut_dstr.c */
-static Criterion *
-parseDisplayString(const char *display, int *ncriteria)
-{
-  Criterion *criteria = NULL;
-  int n, parsed;
-  char *copy, *word;
-
-  copy = __glutStrdup(display);
-  /* Attempt to estimate how many criteria entries should be
-     needed. */
-  n = 0;
-  word = strtok(copy, " \t");
-  while (word) {
-    n++;
-    word = strtok(NULL, " \t");
-  }
-  /* Allocate number of words of criteria.  A word
-     could contain as many as four criteria in the
-     worst case.  Example: 800x600:16@60 */
-  criteria = (Criterion *) malloc(4 * n * sizeof(Criterion));
-  if (!criteria) {
-    __glutFatalError("out of memory.");
-  }
-
-  /* Re-copy the copy of the display string. */
-  strcpy(copy, display);
-
-  n = 0;
-  word = strtok(copy, " \t");
-  while (word) {
-    parsed = parseCriteria(word, &criteria[n]);
-    if (parsed >= 0) {
-      n += parsed;
-    } else {
-      __glutWarning("Unrecognized game mode string word: %s (ignoring)\n", word);
-    }
-    word = strtok(NULL, " \t");
-  }
-
-  free(copy);
-  *ncriteria = n;
-  return criteria;
-}
-
-void GLUTAPIENTRY
-glutGameModeString(const char *string)
-{
-  Criterion *criteria;
-  int ncriteria;
-
-  initGameModeSupport();
-  criteria = parseDisplayString(string, &ncriteria);
-  currentDm = findMatch(dmodes, ndmodes, criteria, ncriteria);
-  free(criteria);
-}
-
-int GLUTAPIENTRY
-glutEnterGameMode(void)
-{
-  GLUTwindow *window;
-  int width, height;
-  Window win;
-
-  if (__glutMappedMenu) {
-    __glutFatalUsage("entering game mode not allowed while menus in use");
-  }
-  if (__glutGameModeWindow) {
-    /* Already in game mode, so blow away game mode
-       window so apps can change resolutions. */
-    window = __glutGameModeWindow;
-    /* Setting the game mode window to NULL tricks
-       the window destroy code into not undoing the
-       screen display change since we plan on immediately
-       doing another mode change. */
-    __glutGameModeWindow = NULL;
-    __glutDestroyWindow(window, window);
-  }
-
-  /* Assume default screen size until we find out if we
-     can actually change the display settings. */
-  width = __glutScreenWidth;
-  height = __glutScreenHeight;
-
-  if (currentDm) {
-#ifdef _WIN32
-    LONG status;
-    static int registered = 0;
-
-    status = ChangeDisplaySettings(&currentDm->devmode,
-      CDS_FULLSCREEN);
-    if (status == DISP_CHANGE_SUCCESSFUL) {
-      __glutDisplaySettingsChanged = 1;
-      width = currentDm->cap[DM_WIDTH];
-      height = currentDm->cap[DM_HEIGHT];
-      if (!registered) {
-        atexit(__glutCloseDownGameMode);
-        registered = 1;
-      }
-    } else {
-      /* Switch back to default resolution. */
-      ChangeDisplaySettings(NULL, 0);
-    }
-#endif
-  }
-
-  window = __glutCreateWindow(NULL, 0, 0,
-    width, height, /* game mode */ 1);
-  win = window->win;
-
-#if !defined(_WIN32)
-  if (__glutMotifHints == None) {
-    __glutMotifHints = XSGIFastInternAtom(__glutDisplay, "_MOTIF_WM_HINTS",
-      SGI_XA__MOTIF_WM_HINTS, 0);
-    if (__glutMotifHints == None) {
-      __glutWarning("Could not intern X atom for _MOTIF_WM_HINTS.");
-    }
-  }
-
-  /* Game mode window is a toplevel window. */
-  XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1);
-#endif
-
-  /* Schedule the fullscreen property to be added and to
-     make sure the window is configured right.  Win32
-     doesn't need this. */
-  window->desiredX = 0;
-  window->desiredY = 0;
-  window->desiredWidth = width;
-  window->desiredHeight = height;
-  window->desiredConfMask |= CWX | CWY | CWWidth | CWHeight;
-#ifdef _WIN32
-  /* Win32 does not want to use GLUT_FULL_SCREEN_WORK
-     for game mode because we need to be maximizing
-     the window in game mode, not just sizing it to
-     take up the full screen.  The Win32-ness of game
-     mode happens when you pass 1 in the gameMode parameter
-     to __glutCreateWindow above.  A gameMode of creates
-     a WS_POPUP window, not a standard WS_OVERLAPPEDWINDOW
-     window.  WS_POPUP ensures the taskbar is hidden. */
-  __glutPutOnWorkList(window,
-    GLUT_CONFIGURE_WORK);
-#else
-  __glutPutOnWorkList(window,
-    GLUT_CONFIGURE_WORK | GLUT_FULL_SCREEN_WORK);
-#endif
-
-  __glutGameModeWindow = window;
-  return window->num + 1;
-}
-
-int GLUTAPIENTRY
-glutGameModeGet(GLenum mode)
-{
-  switch (mode) {
-  case GLUT_GAME_MODE_ACTIVE:
-    return __glutGameModeWindow != NULL;
-  case GLUT_GAME_MODE_POSSIBLE:
-    return currentDm != NULL;
-  case GLUT_GAME_MODE_WIDTH:
-    return currentDm ? currentDm->cap[DM_WIDTH] : -1;
-  case GLUT_GAME_MODE_HEIGHT:
-    return currentDm ? currentDm->cap[DM_HEIGHT] : -1;
-  case GLUT_GAME_MODE_PIXEL_DEPTH:
-    return currentDm ? currentDm->cap[DM_PIXEL_DEPTH] : -1;
-  case GLUT_GAME_MODE_REFRESH_RATE:
-    return currentDm ? currentDm->cap[DM_HERTZ] : -1;
-  case GLUT_GAME_MODE_DISPLAY_CHANGED:
-    return __glutDisplaySettingsChanged;
-  default:
-    return -1;
-  }
-}
diff --git a/src/glut/glx/glut_get.c b/src/glut/glx/glut_get.c
deleted file mode 100644
index 9c1ca6caaea..00000000000
--- a/src/glut/glx/glut_get.c
+++ /dev/null
@@ -1,220 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
-
-/* 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. */
-
-#include <assert.h>
-#include <stdlib.h>  /* SunOS 4 needs NULL defined for GETTIMEOFDAY macro. */
-#include "glutint.h"
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutGet(GLenum param)
-{
-  Window win, root;
-  int x, y, value;
-  unsigned int width, height, border, depth;
-
-  switch (param) {
-  case GLUT_INIT_WINDOW_X:
-    return __glutInitX;
-  case GLUT_INIT_WINDOW_Y:
-    return __glutInitY;
-  case GLUT_INIT_WINDOW_WIDTH:
-    return __glutInitWidth;
-  case GLUT_INIT_WINDOW_HEIGHT:
-    return __glutInitHeight;
-  case GLUT_INIT_DISPLAY_MODE:
-    return __glutDisplayMode;
-  case GLUT_WINDOW_X:
-    XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
-      __glutRoot, 0, 0, &x, &y, &win);
-    return x;
-  case GLUT_WINDOW_Y:
-    XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
-      __glutRoot, 0, 0, &x, &y, &win);
-    return y;
-  case GLUT_WINDOW_WIDTH:
-    if (!__glutCurrentWindow->reshape) {
-      XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
-        &root, &x, &y,
-        &width, &height, &border, &depth);
-      return width;
-    }
-    return __glutCurrentWindow->width;
-  case GLUT_WINDOW_HEIGHT:
-    if (!__glutCurrentWindow->reshape) {
-      XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
-        &root, &x, &y,
-        &width, &height, &border, &depth);
-      return height;
-    }
-    return __glutCurrentWindow->height;
-
-#define GET_CONFIG(attrib) { \
-  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \
-    glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \
-      attrib, &value); \
-  } else { \
-    glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \
-      attrib, &value); \
-  } \
-}
-
-  case GLUT_WINDOW_BUFFER_SIZE:
-    GET_CONFIG(GLX_BUFFER_SIZE);
-    return value;
-  case GLUT_WINDOW_STENCIL_SIZE:
-    GET_CONFIG(GLX_STENCIL_SIZE);
-    return value;
-  case GLUT_WINDOW_DEPTH_SIZE:
-    GET_CONFIG(GLX_DEPTH_SIZE);
-    return value;
-  case GLUT_WINDOW_RED_SIZE:
-    GET_CONFIG(GLX_RED_SIZE);
-    return value;
-  case GLUT_WINDOW_GREEN_SIZE:
-    GET_CONFIG(GLX_GREEN_SIZE);
-    return value;
-  case GLUT_WINDOW_BLUE_SIZE:
-    GET_CONFIG(GLX_BLUE_SIZE);
-    return value;
-  case GLUT_WINDOW_ALPHA_SIZE:
-    GET_CONFIG(GLX_ALPHA_SIZE);
-    return value;
-  case GLUT_WINDOW_ACCUM_RED_SIZE:
-    GET_CONFIG(GLX_ACCUM_RED_SIZE);
-    return value;
-  case GLUT_WINDOW_ACCUM_GREEN_SIZE:
-    GET_CONFIG(GLX_ACCUM_GREEN_SIZE);
-    return value;
-  case GLUT_WINDOW_ACCUM_BLUE_SIZE:
-    GET_CONFIG(GLX_ACCUM_BLUE_SIZE);
-    return value;
-  case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
-    GET_CONFIG(GLX_ACCUM_ALPHA_SIZE);
-    return value;
-  case GLUT_WINDOW_DOUBLEBUFFER:
-    GET_CONFIG(GLX_DOUBLEBUFFER);
-    return value;
-  case GLUT_WINDOW_RGBA:
-    GET_CONFIG(GLX_RGBA);
-    return value;
-  case GLUT_WINDOW_COLORMAP_SIZE:
-    GET_CONFIG(GLX_RGBA);
-    if (value) {
-      return 0;
-    } else {
-#if defined(_WIN32)
-      /* KLUDGE: we always assume 256 colors in CI mode on
-         Win32 */
-      return 256;
-#else
-      if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { 
-        return __glutCurrentWindow->vis->visual->map_entries;
-      } else {
-        return __glutCurrentWindow->overlay->vis->visual->map_entries;
-      }
-#endif /* _WIN32 */
-    }
-  case GLUT_WINDOW_PARENT:
-    return __glutCurrentWindow->parent ?
-      __glutCurrentWindow->parent->num + 1 : 0;
-  case GLUT_WINDOW_NUM_CHILDREN:
-    {
-      int num = 0;
-      GLUTwindow *children = __glutCurrentWindow->children;
-
-      while (children) {
-        num++;
-        children = children->siblings;
-      }
-      return num;
-    }
-  case GLUT_WINDOW_NUM_SAMPLES:
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
-    if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) {
-      GET_CONFIG(GLX_SAMPLES_SGIS);
-      return value;
-    } else {
-      return 0;
-    }
-#else
-    /* Independent of GLX server support, multisampling not
-       supported by GLX client-side. */
-    return 0;
-#endif
-  case GLUT_WINDOW_STEREO:
-    GET_CONFIG(GLX_STEREO);
-    return value;
-  case GLUT_WINDOW_CURSOR:
-    return __glutCurrentWindow->cursor;
-  case GLUT_SCREEN_WIDTH:
-    return DisplayWidth(__glutDisplay, __glutScreen);
-  case GLUT_SCREEN_HEIGHT:
-    return DisplayHeight(__glutDisplay, __glutScreen);
-  case GLUT_SCREEN_WIDTH_MM:
-    return DisplayWidthMM(__glutDisplay, __glutScreen);
-  case GLUT_SCREEN_HEIGHT_MM:
-    return DisplayHeightMM(__glutDisplay, __glutScreen);
-  case GLUT_MENU_NUM_ITEMS:
-    return __glutCurrentMenu->num;
-  case GLUT_DISPLAY_MODE_POSSIBLE:
-    {
-      XVisualInfo *vi;
-      Bool dummy, visAlloced;
-      void *fbc;
-
-#if defined(_WIN32)      
-      /* Our fake glXChooseVisual (which is called by
-         __glutDetermineVisual) needs an HDC to work with, so grab one
-         from the "root" window. */
-      XHDC = GetDC(GetDesktopWindow());
-#endif
-      vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc);
-#if defined(_WIN32)      
-      ReleaseDC(GetDesktopWindow(), XHDC);
-#endif
-      if (vi) {
-        if (visAlloced)
-          XFree(vi);
-        return 1;
-      }
-      return 0;
-    }
-  case GLUT_ELAPSED_TIME:
-    {
-#ifdef OLD_VMS
-       struct timeval6 elapsed, beginning, now;
-#else
-       struct timeval elapsed, beginning, now;
-#endif
-
-       __glutInitTime(&beginning);
-      GETTIMEOFDAY(&now);
-      TIMEDELTA(elapsed, now, beginning);
-      /* Return elapsed milliseconds. */
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-      return (int) (elapsed.val / TICKS_PER_MILLISECOND);
-#else
-      return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000));
-#endif
-    }
-  case GLUT_WINDOW_FORMAT_ID:
-#if defined(_WIN32)
-    return GetPixelFormat(__glutCurrentWindow->hdc);
-#else
-    if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
-      return (int) __glutCurrentWindow->vis->visualid;
-    } else {
-      return (int) __glutCurrentWindow->overlay->vis->visualid;
-    }
-#endif
-  default:
-    __glutWarning("invalid glutGet parameter: %d", param);
-    return -1;
-  }
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_glxext.c b/src/glut/glx/glut_glxext.c
deleted file mode 100644
index 71b67e075d9..00000000000
--- a/src/glut/glx/glut_glxext.c
+++ /dev/null
@@ -1,255 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include <string.h>
-#include "glutint.h"
-
-#if defined(GLX_VERSION_1_1)
-int
-__glutIsSupportedByGLX(char *extension)
-{
-  static const char *extensions = NULL;
-  const char *start;
-  char *where, *terminator;
-  int major, minor;
-
-  glXQueryVersion(__glutDisplay, &major, &minor);
-  /* Be careful not to call glXQueryExtensionsString if it
-     looks like the server doesn't support GLX 1.1.
-     Unfortunately, the original GLX 1.0 didn't have the notion
-     of GLX extensions. */
-  if ((major == 1 && minor >= 1) || (major > 1)) {
-    if (!extensions)
-      extensions = glXQueryExtensionsString(__glutDisplay, __glutScreen);
-    /* It takes a bit of care to be fool-proof about parsing
-       the GLX extensions string.  Don't be fooled by
-       sub-strings,  etc. */
-    start = extensions;
-    for (;;) {
-      where = strstr(start, extension);
-      if (!where)
-        return 0;
-      terminator = where + strlen(extension);
-      if (where == start || *(where - 1) == ' ') {
-        if (*terminator == ' ' || *terminator == '\0') {
-          return 1;
-        }
-      }
-      start = terminator;
-    }
-  }
-  return 0;
-}
-#endif
-
-
-
-/*
- * Wrapping of GLX extension functions.
- * Technically, we should do a runtime test to see if we've got the
- * glXGetProcAddressARB() function.  I think GLX_ARB_get_proc_address
- * is pretty widely supported now and any system that has
- * GLX_ARB_get_proc_address defined in its header files should be OK
- * at runtime.
- */
-
-int
-__glut_glXBindChannelToWindowSGIX(Display *dpy, int screen,
-                                  int channel, Window window)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXBindChannelToWindowSGIX_t) (Display *, int, int, Window);
-  static glXBindChannelToWindowSGIX_t glXBindChannelToWindowSGIX_ptr = NULL;
-  if (!glXBindChannelToWindowSGIX_ptr) {
-    glXBindChannelToWindowSGIX_ptr = (glXBindChannelToWindowSGIX_t)
-      glXGetProcAddressARB((const GLubyte *) "glXBindChannelToWindowSGIX");
-  }
-  if (glXBindChannelToWindowSGIX_ptr)
-    return (*glXBindChannelToWindowSGIX_ptr)(dpy, screen, channel, window);
-  else
-    return 0;
-#elif defined(GLX_SGIX_video_resize)
-  return glXBindChannelToWindowSGIX(dpy, screen, channel, window);
-#else
-  return 0;
-#endif   
-}
-
-
-int
-__glut_glXChannelRectSGIX(Display *dpy, int screen, int channel,
-                          int x, int y, int w, int h)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXChannelRectSGIX_t)(Display *, int, int, int, int, int, int);
-  static glXChannelRectSGIX_t glXChannelRectSGIX_ptr = NULL;
-  if (!glXChannelRectSGIX_ptr) {
-    glXChannelRectSGIX_ptr = (glXChannelRectSGIX_t)
-      glXGetProcAddressARB((const GLubyte *) "glXChannelRectSGIX");
-  }
-  if (glXChannelRectSGIX_ptr)
-    return (*glXChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h);
-  else
-    return 0;
-#elif defined(GLX_SGIX_video_resize)
-  return glXChannelRectSGIX(dpy, screen, channel, x, y, w, h);
-#else
-  return 0;
-#endif   
-}
-
-
-int
-__glut_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel,
-                               int *x, int *y, int *w, int *h)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXQueryChannelRectSGIX_t)(Display *, int, int,
-                                           int *, int *, int *, int *);
-  static glXQueryChannelRectSGIX_t glXQueryChannelRectSGIX_ptr = NULL;
-  if (!glXQueryChannelRectSGIX_ptr) {
-    glXQueryChannelRectSGIX_ptr = (glXQueryChannelRectSGIX_t)
-      glXGetProcAddressARB((const GLubyte *) "glXQueryChannelRectSGIX");
-  }
-  if (glXQueryChannelRectSGIX_ptr)
-    return (*glXQueryChannelRectSGIX_ptr)(dpy, screen, channel, x, y, w, h);
-  else
-    return 0;
-#elif defined(GLX_SGIX_video_resize)
-  return glXQueryChannelRectSGIX(dpy, screen, channel, x, y, w, h);
-#else
-  return 0;
-#endif   
-}
-
-
-int
-__glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel,
-                                 int *dx, int *dy, int *dw, int *dh)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXQueryChannelDeltasSGIX_t)(Display *, int, int,
-                                             int *, int *, int *, int *);
-  static glXQueryChannelDeltasSGIX_t glXQueryChannelDeltasSGIX_ptr = NULL;
-  if (!glXQueryChannelDeltasSGIX_ptr) {
-    glXQueryChannelDeltasSGIX_ptr = (glXQueryChannelDeltasSGIX_t)
-      glXGetProcAddressARB((const GLubyte *) "glXQueryChannelDeltasSGIX");
-  }
-  if (glXQueryChannelDeltasSGIX_ptr)
-    return (*glXQueryChannelDeltasSGIX_ptr)(dpy, screen, channel,
-                                            dx, dy, dw, dh);
-  else
-    return 0;
-#elif defined(GLX_SGIX_video_resize)
-  return glXQueryChannelDeltasSGIX(dpy, screen, channel, dx, dy, dw, dh);
-#else
-  return 0;
-#endif   
-}
-
-
-int
-__glut_glXChannelRectSyncSGIX(Display *dpy, int screen,
-                              int channel, GLenum synctype)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXChannelRectSyncSGIX_t)(Display *, int, int, GLenum);
-  static glXChannelRectSyncSGIX_t glXChannelRectSyncSGIX_ptr = NULL;
-  if (!glXChannelRectSyncSGIX_ptr) {
-    glXChannelRectSyncSGIX_ptr = (glXChannelRectSyncSGIX_t)
-      glXGetProcAddressARB((const GLubyte *) "glXChannelRectSyncSGIX");
-  }
-  if (glXChannelRectSyncSGIX_ptr)
-    return (*glXChannelRectSyncSGIX_ptr)(dpy, screen, channel, synctype);
-  else
-    return 0;
-#elif defined(GLX_SGIX_video_resize)
-  return glXChannelRectSyncSGIX(dpy, screen, channel, synctype);
-#else
-  return 0;
-#endif   
-}
-
-
-
-GLXContext
-__glut_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config,
-                                      int render_type, GLXContext share_list,
-                                      Bool direct)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef GLXContext (*glXCreateContextWithConfigSGIX_t)(Display *,
-                                 GLXFBConfigSGIX, int, GLXContext, Bool);
-  static glXCreateContextWithConfigSGIX_t glXCreateContextWithConfig_ptr = NULL;
-  if (!glXCreateContextWithConfig_ptr) {
-    glXCreateContextWithConfig_ptr = (glXCreateContextWithConfigSGIX_t)
-       glXGetProcAddressARB((const GLubyte *) "glXCreateContextWithConfigSGIX");
-  }
-  if (glXCreateContextWithConfig_ptr)
-    return (*glXCreateContextWithConfig_ptr)(dpy, config, render_type,
-                                             share_list, direct);
-  else
-    return 0;
-#elif defined(GLX_SGIX_fbconfig)
-  return glXCreateContextWithConfigSGIX(dpy, config, render_type,
-                                        share_list, direct);
-#else
-  return 0;
-#endif
-}
-
-
-int
-__glut_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config,
-                                int attribute, int *value)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef int (*glXGetFBConfigAttribSGIX_t)(Display *,
-                                            GLXFBConfigSGIX, int, int *);
-  static glXGetFBConfigAttribSGIX_t glXGetFBConfigAttrib_ptr = NULL;
-  if (!glXGetFBConfigAttrib_ptr) {
-    glXGetFBConfigAttrib_ptr = (glXGetFBConfigAttribSGIX_t)
-       glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
-  }
-  if (glXGetFBConfigAttrib_ptr)
-    return (*glXGetFBConfigAttrib_ptr)(dpy, config, attribute, value);
-  else
-    return 0;
-#elif defined(GLX_SGIX_fbconfig)
-  return glXGetFBConfigAttribSGIX(dpy, config, attribute, value);
-#else
-  return 0;
-#endif
-}
-
-
-GLXFBConfigSGIX
-__glut_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
-{
-#ifdef GLX_ARB_get_proc_address
-  typedef GLXFBConfigSGIX (*glXGetFBConfigFromVisualSGIX_t)(Display *,
-                                                            XVisualInfo *);
-  static glXGetFBConfigFromVisualSGIX_t glXGetFBConfigFromVisual_ptr = NULL;
-  if (!glXGetFBConfigFromVisual_ptr) {
-    glXGetFBConfigFromVisual_ptr = (glXGetFBConfigFromVisualSGIX_t)
-       glXGetProcAddressARB((const GLubyte *) "glXGetFBConfigFromVisualSGIX");
-  }
-  if (glXGetFBConfigFromVisual_ptr)
-    return (*glXGetFBConfigFromVisual_ptr)(dpy, vis);
-  else
-    return 0;
-#elif defined(GLX_SGIX_fbconfig)
-  return glXGetFBConfigFromVisualSGIX(dpy, vis);
-#else
-  return 0;
-#endif
-}
-
-
-
-
diff --git a/src/glut/glx/glut_hel10.c b/src/glut/glx/glut_hel10.c
deleted file mode 100644
index 3de1750ce6c..00000000000
--- a/src/glut/glx/glut_hel10.c
+++ /dev/null
@@ -1,1779 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica10 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica10
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch255 = {4,10,0,2,5,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {5,10,0,2,6,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {4,11,0,2,5,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {4,8,0,0,5,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {4,9,0,0,5,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch250 = {4,9,0,0,5,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {4,9,0,0,5,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x70,0x88,0xc8,0xa8,0x98,0x74,
-};
-
-static const BitmapCharRec ch248 = {6,6,0,0,6,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,0,-1,6,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch246 = {5,8,0,0,6,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {5,9,0,0,6,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch244 = {5,9,0,0,6,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch243 = {5,9,0,0,6,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {5,9,0,0,6,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x90,0x90,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch241 = {4,9,0,0,5,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x70,0x88,0x88,0x88,0x88,0x78,0x90,0x60,0x50,
-};
-
-static const BitmapCharRec ch240 = {5,9,0,0,6,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,8,0,0,2,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,9,1,0,2,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch237 = {2,9,0,0,2,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {2,9,1,0,2,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,
-};
-
-static const BitmapCharRec ch235 = {4,8,0,0,5,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch234 = {4,9,0,0,5,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch233 = {4,9,0,0,5,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch232 = {4,9,0,0,5,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x60,0x20,0x60,0x90,0x80,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch231 = {4,8,0,2,5,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x6c,0x92,0x90,0x7e,0x12,0xec,
-};
-
-static const BitmapCharRec ch230 = {7,6,0,0,8,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x20,0x50,0x20,
-};
-
-static const BitmapCharRec ch229 = {5,9,0,0,5,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,
-};
-
-static const BitmapCharRec ch228 = {5,8,0,0,5,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch227 = {5,9,0,0,5,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch226 = {5,9,0,0,5,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch225 = {5,9,0,0,5,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch224 = {5,9,0,0,5,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xa0,0x90,0x90,0x90,0xa0,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch223 = {4,8,0,0,5,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0xf0,0x88,0x88,0xf0,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {5,8,-1,0,7,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,11,0,0,7,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
-};
-
-static const BitmapCharRec ch220 = {6,10,-1,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {6,11,-1,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch218 = {6,11,-1,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {6,11,-1,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x78,0xc4,0xa4,0xa4,0x94,0x94,0x8c,0x78,0x4,
-};
-
-static const BitmapCharRec ch216 = {6,10,-1,1,8,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,0,-1,6,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x48,
-};
-
-static const BitmapCharRec ch214 = {6,10,-1,0,8,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {6,11,-1,0,8,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch212 = {6,11,-1,0,8,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch211 = {6,11,-1,0,8,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch210 = {6,11,-1,0,8,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {6,11,-1,0,8,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x78,0x44,0x42,0x42,0xf2,0x42,0x44,0x78,
-};
-
-static const BitmapCharRec ch208 = {7,8,0,0,8,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,10,0,0,3,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,11,0,0,3,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch205 = {2,11,-1,0,3,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {2,11,0,0,3,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x50,
-};
-
-static const BitmapCharRec ch203 = {5,10,-1,0,7,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xf8,0x80,0x80,0xf8,0x80,0x80,0x80,0xf8,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch202 = {5,11,-1,0,7,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch201 = {5,11,-1,0,7,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch200 = {5,11,-1,0,7,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x10,0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch199 = {6,10,-1,2,8,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x8f,0x80,0x88,0x0,0x78,0x0,0x48,0x0,0x2f,0x80,0x28,0x0,0x18,0x0,0x1f,0x80,
-};
-
-static const BitmapCharRec ch198 = {9,8,0,0,10,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,11,0,0,7,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,10,0,0,7,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,11,0,0,7,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,11,0,0,7,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,11,0,0,7,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,11,0,0,7,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x60,0x90,0x80,0x40,0x20,0x20,0x0,0x20,
-};
-
-static const BitmapCharRec ch191 = {4,8,-1,2,6,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0xc8,0x0,0x24,0x0,0x44,0x0,0xe2,0x0,
-};
-
-static const BitmapCharRec ch190 = {9,8,0,0,9,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x27,0x12,0x15,0xb,0x48,0x44,0xc4,0x42,
-};
-
-static const BitmapCharRec ch189 = {8,8,0,0,9,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x21,0x0,0x17,0x80,0x13,0x0,0x9,0x0,0x48,0x0,0x44,0x0,0xc4,0x0,0x42,0x0,
-};
-
-static const BitmapCharRec ch188 = {9,8,0,0,9,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x28,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {5,5,0,0,6,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0xe0,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch186 = {3,5,0,-3,4,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {2,4,0,-3,3,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x40,
-};
-
-static const BitmapCharRec ch184 = {2,2,0,2,3,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,1,0,-3,3,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
-};
-
-static const BitmapCharRec ch182 = {6,10,0,2,6,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xf0,0x90,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch181 = {4,8,0,2,5,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-6,3,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xe0,0x40,0xa0,0x60,
-};
-
-static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch175 = {3,1,0,-7,3,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
-};
-
-static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch173 = {3,1,0,-3,4,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch172 = {5,3,-1,-2,7,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x28,0x50,0xa0,0x50,0x28,
-};
-
-static const BitmapCharRec ch171 = {5,5,0,0,6,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xe0,
-};
-
-static const BitmapCharRec ch170 = {3,5,0,-3,4,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
-};
-
-static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,0,-7,3,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x18,0x70,0xc8,0x98,0x70,0xc0,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,10,0,2,6,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x0,0x0,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,10,-1,2,3,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x20,0xf8,0x20,0xf8,0x50,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,8,0,0,6,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x90,0x60,0x90,0x90,0x60,0x90,
-};
-
-static const BitmapCharRec ch164 = {4,6,0,-1,5,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xb0,0x48,0x40,0x40,0xe0,0x40,0x48,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,8,0,0,6,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x70,0xa8,0xa0,0xa0,0xa8,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {5,8,0,1,6,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,8,-1,2,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,3,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,3,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0x80,0x40,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch125 = {3,10,0,2,3,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,10,-1,2,3,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x20,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch123 = {3,10,0,2,3,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x80,0x40,0x20,0x10,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,6,0,0,5,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x80,0x40,0x40,0x60,0xa0,0xa0,0x90,0x90,
-};
-
-static const BitmapCharRec ch121 = {4,8,0,2,5,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x88,0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch120 = {5,6,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x28,0x28,0x54,0x54,0x92,0x92,
-};
-
-static const BitmapCharRec ch119 = {7,6,0,0,8,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x20,0x50,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch118 = {5,6,0,0,6,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x70,0x90,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch117 = {4,6,0,0,5,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x60,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
-};
-
-static const BitmapCharRec ch116 = {3,8,0,0,4,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x60,0x90,0x10,0x60,0x90,0x60,
-};
-
-static const BitmapCharRec ch115 = {4,6,0,0,5,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x80,0x80,0x80,0x80,0xc0,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,6,0,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x8,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch113 = {5,8,0,2,6,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0xb0,0xc8,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch112 = {5,8,0,2,6,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch111 = {5,6,0,0,6,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x88,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch110 = {5,6,0,0,6,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x92,0x92,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {7,6,0,0,8,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch108 = {1,8,0,0,2,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x90,0x90,0xa0,0xc0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {4,8,0,0,5,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch106 = {1,9,0,1,2,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch105 = {1,8,0,0,2,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,8,0,0,6,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x70,0x8,0x68,0x98,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch103 = {5,8,0,2,6,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,8,0,0,4,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x60,0x90,0x80,0xf0,0x90,0x60,
-};
-
-static const BitmapCharRec ch101 = {4,6,0,0,5,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x98,0x88,0x88,0x98,0x68,0x8,0x8,
-};
-
-static const BitmapCharRec ch100 = {5,8,0,0,6,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x60,0x90,0x80,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch99 = {4,6,0,0,5,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xb0,0xc8,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {5,8,0,0,6,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x68,0x90,0x90,0x70,0x10,0xe0,
-};
-
-static const BitmapCharRec ch97 = {5,6,0,0,5,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x80,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,3,0,-5,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xfc,
-};
-
-static const BitmapCharRec ch95 = {6,1,0,2,6,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x88,0x50,0x50,0x20,0x20,
-};
-
-static const BitmapCharRec ch94 = {5,5,0,-3,6,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,10,0,2,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x20,0x20,0x40,0x40,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {3,8,0,0,3,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,10,-1,2,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xf8,0x80,0x40,0x20,0x20,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch90 = {5,8,-1,0,7,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x28,0x28,0x44,0x44,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,8,0,0,7,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x88,0x88,0x50,0x50,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch88 = {5,8,-1,0,7,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-};
-
-static const BitmapCharRec ch87 = {9,8,0,0,9,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,8,0,0,7,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch85 = {6,8,-1,0,8,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xf8,
-};
-
-static const BitmapCharRec ch84 = {5,8,0,0,5,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x70,0x88,0x88,0x8,0x70,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch83 = {5,8,-1,0,7,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x88,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch82 = {5,8,-1,0,7,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x2,0x7c,0x8c,0x94,0x84,0x84,0x84,0x84,0x78,
-};
-
-static const BitmapCharRec ch81 = {7,9,-1,1,8,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0x80,0x80,0x80,0x80,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch80 = {5,8,-1,0,7,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x78,
-};
-
-static const BitmapCharRec ch79 = {6,8,-1,0,8,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x8c,0x8c,0x94,0x94,0xa4,0xa4,0xc4,0xc4,
-};
-
-static const BitmapCharRec ch78 = {6,8,-1,0,8,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x92,0x92,0x92,0xaa,0xaa,0xc6,0xc6,0x82,
-};
-
-static const BitmapCharRec ch77 = {7,8,-1,0,9,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {4,8,-1,0,6,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x88,0x88,0x90,0x90,0xe0,0xa0,0x90,0x88,
-};
-
-static const BitmapCharRec ch75 = {5,8,-1,0,7,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x60,0x90,0x10,0x10,0x10,0x10,0x10,0x10,
-};
-
-static const BitmapCharRec ch74 = {4,8,0,0,5,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch73 = {1,8,-1,0,3,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x84,0x84,0x84,0x84,0xfc,0x84,0x84,0x84,
-};
-
-static const BitmapCharRec ch72 = {6,8,-1,0,8,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x74,0x8c,0x84,0x8c,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch71 = {6,8,-1,0,8,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x80,0x80,0x80,0x80,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch70 = {5,8,-1,0,6,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xf8,0x80,0x80,0x80,0xf8,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch69 = {5,8,-1,0,7,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf0,0x88,0x84,0x84,0x84,0x84,0x88,0xf0,
-};
-
-static const BitmapCharRec ch68 = {6,8,-1,0,8,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x78,0x84,0x80,0x80,0x80,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch67 = {6,8,-1,0,8,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf0,0x88,0x88,0x88,0xf0,0x88,0x88,0xf0,
-};
-
-static const BitmapCharRec ch66 = {5,8,-1,0,7,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x7c,0x44,0x28,0x28,0x10,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,8,0,0,7,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x0,0x40,0x0,0x9b,0x0,0xa4,0x80,0xa4,0x80,0xa2,0x40,0x92,0x40,0x4d,0x40,
-0x20,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch64 = {10,10,0,2,11,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x40,0x0,0x40,0x40,0x20,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch63 = {4,8,-1,0,6,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {3,5,-1,-1,6,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf0,0x0,0xf0,
-};
-
-static const BitmapCharRec ch61 = {4,3,0,-2,5,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x20,0x40,0x80,0x40,0x20,
-};
-
-static const BitmapCharRec ch60 = {3,5,-1,-1,6,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
-};
-
-static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch57 = {5,8,0,0,6,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x70,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch56 = {5,8,0,0,6,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x10,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch55 = {5,8,0,0,6,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x70,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch54 = {5,8,0,0,6,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x70,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch53 = {5,8,0,0,6,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x10,0x10,0xf8,0x90,0x50,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch52 = {5,8,0,0,6,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x70,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch51 = {5,8,0,0,6,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf8,0x80,0x40,0x30,0x8,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch50 = {5,8,0,0,6,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch49 = {2,8,-1,0,6,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch48 = {5,8,0,0,6,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x40,0x20,0x20,
-};
-
-static const BitmapCharRec ch47 = {3,8,0,0,3,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch45 = {5,1,-1,-3,7,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch44 = {2,3,0,2,3,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,0,-1,6,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,0,-5,4,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,10,-1,2,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,10,0,2,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch39 = {2,3,-1,-5,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x64,0x98,0x98,0xa4,0x60,0x50,0x50,0x20,
-};
-
-static const BitmapCharRec ch38 = {6,8,-1,0,8,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x26,0x29,0x16,0x10,0x8,0x68,0x94,0x64,
-};
-
-static const BitmapCharRec ch37 = {8,8,0,0,9,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0x70,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {5,9,0,1,6,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0xf8,0x28,0x7c,0x28,0x28,
-};
-
-static const BitmapCharRec ch35 = {6,7,0,0,6,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,2,-1,-6,4,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,8,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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 = {0,0,0,0,3,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,3,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmapHelvetica10;
-const BitmapFontRec glutBitmapHelvetica10 = {
-"-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/glx/glut_hel12.c b/src/glut/glx/glut_hel12.c
deleted file mode 100644
index e6f1bbb5e26..00000000000
--- a/src/glut/glx/glut_hel12.c
+++ /dev/null
@@ -1,1789 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica12 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica12
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0xc0,0x20,0x20,0x20,0x30,0x50,0x50,0x48,0x88,0x88,0x0,0x50,
-};
-
-static const BitmapCharRec ch255 = {5,12,-1,3,7,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {5,12,-1,3,7,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {5,13,-1,3,7,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {5,9,-1,0,7,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {5,10,-1,0,7,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch250 = {5,10,-1,0,7,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {5,10,-1,0,7,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xb8,0x44,0x64,0x54,0x4c,0x44,0x3a,
-};
-
-static const BitmapCharRec ch248 = {7,7,0,0,7,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,-1,-1,7,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch246 = {5,9,-1,0,7,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch245 = {5,10,-1,0,7,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch244 = {5,10,-1,0,7,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch243 = {5,10,-1,0,7,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {5,10,-1,0,7,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch241 = {5,10,-1,0,7,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x70,0x88,0x88,0x88,0x88,0x78,0x8,0x50,0x30,0x68,
-};
-
-static const BitmapCharRec ch240 = {5,10,-1,0,7,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,9,0,0,3,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,10,0,0,3,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch237 = {2,10,-1,0,3,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {2,10,0,0,3,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch235 = {5,9,-1,0,7,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch234 = {5,10,-1,0,7,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch233 = {5,10,-1,0,7,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch232 = {5,10,-1,0,7,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x60,0x10,0x20,0x70,0x88,0x80,0x80,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch231 = {5,10,-1,3,7,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x77,0x0,0x88,0x80,0x88,0x0,0x7f,0x80,0x8,0x80,0x88,0x80,0x77,0x0,
-};
-
-static const BitmapCharRec ch230 = {9,7,-1,0,11,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x30,0x48,0x30,
-};
-
-static const BitmapCharRec ch229 = {6,10,-1,0,7,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,
-};
-
-static const BitmapCharRec ch228 = {6,9,-1,0,7,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch227 = {6,10,-1,0,7,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch226 = {6,10,-1,0,7,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch225 = {6,10,-1,0,7,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch224 = {6,10,-1,0,7,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xb0,0x88,0x88,0x88,0xb0,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch223 = {5,9,-1,0,7,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0x80,0x80,0xf8,0x84,0x84,0x84,0xf8,0x80,0x80,
-};
-
-static const BitmapCharRec ch222 = {6,9,-1,0,8,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,12,-1,0,9,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x48,
-};
-
-static const BitmapCharRec ch220 = {6,11,-1,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {6,12,-1,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch218 = {6,12,-1,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x78,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x84,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {6,12,-1,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x0,0x5e,0x0,0x21,0x0,0x50,0x80,0x48,0x80,0x44,0x80,0x44,0x80,0x42,0x80,
-0x21,0x0,0x1e,0x80,0x0,0x40,
-};
-
-static const BitmapCharRec ch216 = {10,11,0,1,10,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,-1,-1,7,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x24,
-};
-
-static const BitmapCharRec ch214 = {8,11,-1,0,10,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch213 = {8,12,-1,0,10,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x14,0x8,
-};
-
-static const BitmapCharRec ch212 = {8,12,-1,0,10,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x4,
-};
-
-static const BitmapCharRec ch211 = {8,12,-1,0,10,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,0x0,0x8,0x10,
-};
-
-static const BitmapCharRec ch210 = {8,12,-1,0,10,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch209 = {7,12,-1,0,9,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7c,0x42,0x41,0x41,0xf1,0x41,0x41,0x42,0x7c,
-};
-
-static const BitmapCharRec ch208 = {8,9,0,0,9,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,11,0,0,3,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,12,0,0,3,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,0x40,
-};
-
-static const BitmapCharRec ch205 = {2,12,-1,0,3,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {2,12,0,0,3,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,
-};
-
-static const BitmapCharRec ch203 = {6,11,-1,0,8,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch202 = {6,12,-1,0,8,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch201 = {6,12,-1,0,8,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xfc,0x80,0x80,0x80,0xfc,0x80,0x80,0x80,0xfc,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch200 = {6,12,-1,0,8,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x30,0x8,0x8,0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch199 = {7,12,-1,3,9,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0x8f,0x80,0x88,0x0,0x88,0x0,0x78,0x0,0x4f,0x80,0x48,0x0,0x28,0x0,0x28,0x0,
-0x1f,0x80,
-};
-
-static const BitmapCharRec ch198 = {9,9,-1,0,11,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,12,-1,0,9,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,11,-1,0,9,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,12,-1,0,9,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,12,-1,0,9,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,12,-1,0,9,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x10,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,12,-1,0,9,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x70,0x88,0x88,0x40,0x40,0x20,0x20,0x0,0x20,
-};
-
-static const BitmapCharRec ch191 = {5,9,-1,3,7,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x21,0x0,0x17,0x80,0x15,0x0,0xb,0x0,0xc9,0x0,0x24,0x0,0x44,0x0,0x22,0x0,
-0xe1,0x0,
-};
-
-static const BitmapCharRec ch190 = {9,9,0,0,10,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x47,0x80,0x22,0x0,0x11,0x0,0x14,0x80,0x4b,0x0,0x48,0x0,0x44,0x0,0xc2,0x0,
-0x41,0x0,
-};
-
-static const BitmapCharRec ch189 = {9,9,0,0,10,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x41,0x0,0x27,0x80,0x15,0x0,0x13,0x0,0x49,0x0,0x44,0x0,0x44,0x0,0xc2,0x0,
-0x41,0x0,
-};
-
-static const BitmapCharRec ch188 = {9,9,0,0,10,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x28,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {5,5,-1,-1,7,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0xe0,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch186 = {3,5,-1,-4,5,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {2,5,-1,-3,4,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x20,0x20,0x40,
-};
-
-static const BitmapCharRec ch184 = {3,4,0,3,3,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch183 = {1,1,-1,-3,3,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x68,0x3c,
-};
-
-static const BitmapCharRec ch182 = {6,12,0,3,7,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0x80,0xe8,0x98,0x88,0x88,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch181 = {5,10,-1,3,7,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-8,2,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0x20,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,5,0,-3,4,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf0,0x40,0x20,0x90,0x60,
-};
-
-static const BitmapCharRec ch178 = {4,5,0,-3,4,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,-1,0,7,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-4,5,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch175 = {4,1,0,-8,4,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x3e,0x0,0x41,0x0,0x94,0x80,0x94,0x80,0x98,0x80,0x94,0x80,0x9c,0x80,0x41,0x0,
-0x3e,0x0,
-};
-
-static const BitmapCharRec ch174 = {9,9,-1,0,11,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch173 = {4,1,0,-3,5,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x4,0x4,0x4,0xfc,
-};
-
-static const BitmapCharRec ch172 = {6,4,-1,-2,8,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x28,0x50,0xa0,0x50,0x28,
-};
-
-static const BitmapCharRec ch171 = {5,5,-1,-1,7,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xe0,
-};
-
-static const BitmapCharRec ch170 = {3,5,-1,-4,5,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x3e,0x0,0x41,0x0,0x9c,0x80,0xa2,0x80,0xa0,0x80,0xa2,0x80,0x9c,0x80,0x41,0x0,
-0x3e,0x0,
-};
-
-static const BitmapCharRec ch169 = {9,9,-1,0,11,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,0,-8,3,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x70,0x88,0x8,0x30,0x48,0x88,0x88,0x90,0x60,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch167 = {5,12,0,3,6,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x80,0x0,0x0,0x0,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,11,-1,2,3,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x20,0x20,0xf8,0x20,0xf8,0x20,0x50,0x88,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,9,-1,0,7,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x84,0x78,0x48,0x48,0x78,0x84,
-};
-
-static const BitmapCharRec ch164 = {6,6,0,-1,7,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xb0,0x48,0x20,0x20,0xf0,0x40,0x40,0x48,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,9,-1,0,7,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x70,0xc8,0xa0,0xa0,0xa0,0xa8,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {5,9,-1,1,7,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,10,-1,3,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,4,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,4,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-3,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xc0,0x20,0x20,0x20,0x20,0x20,0x10,0x20,0x20,0x20,0x20,0xc0,
-};
-
-static const BitmapCharRec ch125 = {4,12,0,3,4,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,12,-1,3,3,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x30,0x40,0x40,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x40,0x30,
-};
-
-static const BitmapCharRec ch123 = {4,12,0,3,4,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x80,0x40,0x40,0x20,0x10,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,7,-1,0,6,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x80,0x40,0x20,0x20,0x50,0x50,0x90,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch121 = {5,10,-1,3,7,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0x84,0x84,0x48,0x30,0x30,0x48,0x84,
-};
-
-static const BitmapCharRec ch120 = {6,7,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x22,0x0,0x22,0x0,0x55,0x0,0x49,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-};
-
-static const BitmapCharRec ch119 = {9,7,0,0,9,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x20,0x50,0x50,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch118 = {5,7,-1,0,7,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x68,0x98,0x88,0x88,0x88,0x88,0x88,
-};
-
-static const BitmapCharRec ch117 = {5,7,-1,0,7,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x60,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x40,
-};
-
-static const BitmapCharRec ch116 = {3,9,0,0,3,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x60,0x90,0x10,0x60,0x80,0x90,0x60,
-};
-
-static const BitmapCharRec ch115 = {4,7,-1,0,6,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0x80,0x80,0x80,0x80,0x80,0xc0,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,7,-1,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x8,0x8,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch113 = {5,10,-1,3,7,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0x80,0x80,0x80,0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch112 = {5,10,-1,3,7,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch111 = {5,7,-1,0,7,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,
-};
-
-static const BitmapCharRec ch110 = {5,7,-1,0,7,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0x92,0x92,0x92,0x92,0x92,0xda,0xa4,
-};
-
-static const BitmapCharRec ch109 = {7,7,-1,0,9,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch108 = {1,9,-1,0,3,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x88,0x90,0xa0,0xc0,0xc0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {5,9,-1,0,6,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x0,0x40,
-};
-
-static const BitmapCharRec ch106 = {2,12,0,3,3,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch105 = {1,9,-1,0,3,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0x88,0x88,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,9,-1,0,7,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x70,0x88,0x8,0x68,0x98,0x88,0x88,0x88,0x98,0x68,
-};
-
-static const BitmapCharRec ch103 = {5,10,-1,3,7,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x40,0x40,0x40,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,9,0,0,3,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x70,0x88,0x80,0xf8,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch101 = {5,7,-1,0,7,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x98,0x88,0x88,0x88,0x98,0x68,0x8,0x8,
-};
-
-static const BitmapCharRec ch100 = {5,9,-1,0,7,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x70,0x88,0x80,0x80,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch99 = {5,7,-1,0,7,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xb0,0xc8,0x88,0x88,0x88,0xc8,0xb0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {5,9,-1,0,7,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x74,0x88,0x88,0x78,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch97 = {6,7,-1,0,7,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,3,0,-6,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xfe,
-};
-
-static const BitmapCharRec ch95 = {7,1,0,2,7,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x88,0x50,0x20,
-};
-
-static const BitmapCharRec ch94 = {5,3,0,-5,6,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,12,0,3,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x10,0x10,0x20,0x20,0x20,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {4,9,0,0,4,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,12,-1,3,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xfe,0x80,0x40,0x20,0x10,0x8,0x4,0x2,0xfe,
-};
-
-static const BitmapCharRec ch90 = {7,9,-1,0,9,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x10,0x10,0x10,0x10,0x28,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch89 = {7,9,-1,0,9,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0x82,0x44,0x44,0x28,0x10,0x28,0x44,0x44,0x82,
-};
-
-static const BitmapCharRec ch88 = {7,9,-1,0,9,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0x49,0x0,0x88,0x80,0x88,0x80,
-0x88,0x80,
-};
-
-static const BitmapCharRec ch87 = {9,9,-1,0,11,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x10,0x28,0x28,0x44,0x44,0x44,0x82,0x82,
-};
-
-static const BitmapCharRec ch86 = {7,9,-1,0,9,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,7,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x78,0x84,0x84,0x4,0x18,0x60,0x80,0x84,0x78,
-};
-
-static const BitmapCharRec ch83 = {6,9,-1,0,8,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0x84,0x84,0x84,0x88,0xf8,0x84,0x84,0x84,0xf8,
-};
-
-static const BitmapCharRec ch82 = {6,9,-1,0,8,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x3d,0x42,0x85,0x89,0x81,0x81,0x81,0x42,0x3c,
-};
-
-static const BitmapCharRec ch81 = {8,9,-1,0,10,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[] = {
-0x3c,0x42,0x81,0x81,0x81,0x81,0x81,0x42,0x3c,
-};
-
-static const BitmapCharRec ch79 = {8,9,-1,0,10,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0x82,0x86,0x8a,0x8a,0x92,0xa2,0xa2,0xc2,0x82,
-};
-
-static const BitmapCharRec ch78 = {7,9,-1,0,9,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0x88,0x80,0x88,0x80,0x94,0x80,0x94,0x80,0xa2,0x80,0xa2,0x80,0xc1,0x80,0xc1,0x80,
-0x80,0x80,
-};
-
-static const BitmapCharRec ch77 = {9,9,-1,0,11,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf8,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch76 = {5,9,-1,0,7,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0x82,0x84,0x88,0x90,0xe0,0xa0,0x90,0x88,0x84,
-};
-
-static const BitmapCharRec ch75 = {7,9,-1,0,8,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x70,0x88,0x88,0x8,0x8,0x8,0x8,0x8,0x8,
-};
-
-static const BitmapCharRec ch74 = {5,9,-1,0,7,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch73 = {1,9,-1,0,3,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0x82,0x82,0x82,0x82,0xfe,0x82,0x82,0x82,0x82,
-};
-
-static const BitmapCharRec ch72 = {7,9,-1,0,9,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x3a,0x46,0x82,0x82,0x8e,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch71 = {7,9,-1,0,9,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0x80,0x80,0x80,0x80,0xf8,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,0xfc,0x80,0x80,0x80,0xfc,
-};
-
-static const BitmapCharRec ch69 = {6,9,-1,0,8,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf8,0x84,0x82,0x82,0x82,0x82,0x82,0x84,0xf8,
-};
-
-static const BitmapCharRec ch68 = {7,9,-1,0,9,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x3c,0x42,0x80,0x80,0x80,0x80,0x80,0x42,0x3c,
-};
-
-static const BitmapCharRec ch67 = {7,9,-1,0,9,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf8,0x84,0x84,0x84,0xf8,0x84,0x84,0x84,0xf8,
-};
-
-static const BitmapCharRec ch66 = {6,9,-1,0,8,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0x82,0x82,0x82,0x7c,0x44,0x44,0x28,0x28,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,9,-1,0,9,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x0,0x40,0x0,0x9b,0x0,0xa6,0x80,0xa2,0x40,0xa2,0x40,0x92,0x40,0x4d,0x40,
-0x60,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch64 = {10,10,-1,1,12,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x20,0x0,0x20,0x20,0x10,0x10,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch63 = {5,9,-1,0,7,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0x30,0xc,0x30,0xc0,
-};
-
-static const BitmapCharRec ch62 = {6,5,-1,-1,7,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf8,0x0,0xf8,
-};
-
-static const BitmapCharRec ch61 = {5,3,-1,-2,7,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0xc,0x30,0xc0,0x30,0xc,
-};
-
-static const BitmapCharRec ch60 = {6,5,0,-1,7,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0x0,0x0,0x0,0x0,0x40,
-};
-
-static const BitmapCharRec ch59 = {2,8,0,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,6,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x70,0x88,0x8,0x8,0x78,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch57 = {5,9,-1,0,7,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x70,0x88,0x88,0x88,0x88,0x70,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch56 = {5,9,-1,0,7,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x20,0x20,0x20,0x10,0x10,0x8,0xf8,
-};
-
-static const BitmapCharRec ch55 = {5,9,-1,0,7,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x70,0x88,0x88,0x88,0xc8,0xb0,0x80,0x88,0x70,
-};
-
-static const BitmapCharRec ch54 = {5,9,-1,0,7,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x70,0x88,0x88,0x8,0x8,0xf0,0x80,0x80,0xf8,
-};
-
-static const BitmapCharRec ch53 = {5,9,-1,0,7,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x8,0x8,0xfc,0x88,0x48,0x28,0x28,0x18,0x8,
-};
-
-static const BitmapCharRec ch52 = {6,9,0,0,7,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x70,0x88,0x88,0x8,0x8,0x30,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch51 = {5,9,-1,0,7,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf8,0x80,0x80,0x40,0x20,0x10,0x8,0x88,0x70,
-};
-
-static const BitmapCharRec ch50 = {5,9,-1,0,7,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xe0,0x20,
-};
-
-static const BitmapCharRec ch49 = {3,9,-1,0,7,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x70,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x70,
-};
-
-static const BitmapCharRec ch48 = {5,9,-1,0,7,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x20,0x20,0x10,0x10,
-};
-
-static const BitmapCharRec ch47 = {4,9,0,0,4,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch45 = {5,1,-1,-3,8,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,
-};
-
-static const BitmapCharRec ch44 = {2,3,-1,2,4,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,-1,-1,7,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,-1,-6,5,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,12,0,3,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,12,-1,3,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,3,-1,-6,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x72,0x8c,0x84,0x8a,0x50,0x30,0x48,0x48,0x30,
-};
-
-static const BitmapCharRec ch38 = {7,9,-1,0,9,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x23,0x0,0x14,0x80,0x14,0x80,0x13,0x0,0x8,0x0,0x68,0x0,0x94,0x0,0x94,0x0,
-0x62,0x0,
-};
-
-static const BitmapCharRec ch37 = {9,9,-1,0,11,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0x70,0xa8,0xa8,0x28,0x70,0xa0,0xa8,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {5,10,-1,1,7,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0x50,0xfc,0x28,0xfc,0x28,0x28,
-};
-
-static const BitmapCharRec ch35 = {6,8,0,0,7,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,3,-1,-6,5,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,9,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,4,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,4,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmapHelvetica12;
-const BitmapFontRec glutBitmapHelvetica12 = {
-"-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/glx/glut_hel18.c b/src/glut/glx/glut_hel18.c
deleted file mode 100644
index 3ddcefd6421..00000000000
--- a/src/glut/glx/glut_hel18.c
+++ /dev/null
@@ -1,1898 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapHelvetica18 XXX
-#include "glutbitmap.h"
-#undef glutBitmapHelvetica18
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x66,
-0x66,
-};
-
-static const BitmapCharRec ch255 = {8,17,-1,4,10,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch254 = {9,18,-1,4,11,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,0x0,0x18,
-0xc,0x6,
-};
-
-static const BitmapCharRec ch253 = {8,18,-1,4,10,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x66,
-};
-
-static const BitmapCharRec ch252 = {8,13,-1,0,10,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch251 = {8,14,-1,0,10,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0x18,0xc,0x6,
-};
-
-static const BitmapCharRec ch250 = {8,14,-1,0,10,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x0,0xc,0x18,0x30,
-};
-
-static const BitmapCharRec ch249 = {8,14,-1,0,10,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xce,0x0,0x7f,0x80,0x31,0x80,0x78,0xc0,0x6c,0xc0,0x66,0xc0,0x63,0xc0,0x31,0x80,
-0x3f,0xc0,0xe,0x60,
-};
-
-static const BitmapCharRec ch248 = {11,10,0,0,11,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x18,0x18,0x0,0xff,0xff,0x0,0x18,0x18,
-};
-
-static const BitmapCharRec ch247 = {8,8,-1,-1,10,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x36,0x0,0x36,0x0,
-};
-
-static const BitmapCharRec ch246 = {9,13,-1,0,11,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x26,0x0,0x2d,0x0,0x19,0x0,
-};
-
-static const BitmapCharRec ch245 = {9,14,-1,0,11,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x33,0x0,0x1e,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch244 = {9,14,-1,0,11,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0x18,0x0,0xc,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch243 = {9,14,-1,0,11,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x0,0x0,0xc,0x0,0x18,0x0,0x30,0x0,
-};
-
-static const BitmapCharRec ch242 = {9,14,-1,0,11,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0x0,0x4c,0x5a,0x32,
-};
-
-static const BitmapCharRec ch241 = {8,14,-1,0,10,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,0x4c,0x0,0x38,0x0,0x36,0x0,0x60,0x0,
-};
-
-static const BitmapCharRec ch240 = {9,14,-1,0,11,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch239 = {5,13,0,0,4,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,0x78,0x30,
-};
-
-static const BitmapCharRec ch238 = {6,14,1,0,4,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0xc0,0x60,0x30,
-};
-
-static const BitmapCharRec ch237 = {4,14,0,0,4,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x0,0x30,0x60,0xc0,
-};
-
-static const BitmapCharRec ch236 = {4,14,0,0,4,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x36,0x36,
-};
-
-static const BitmapCharRec ch235 = {8,13,-1,0,10,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch234 = {8,14,-1,0,10,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0xc,0x6,
-};
-
-static const BitmapCharRec ch233 = {8,14,-1,0,10,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,0x0,0x18,0x30,0x60,
-};
-
-static const BitmapCharRec ch232 = {8,14,-1,0,10,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x78,0x6c,0xc,0x38,0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
-};
-
-static const BitmapCharRec ch231 = {8,14,-1,4,10,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x75,0xe0,0xef,0xf8,0xc7,0x18,0xc6,0x0,0xe6,0x0,0x7f,0xf8,0xe,0x18,0xc6,0x18,
-0xef,0xf0,0x7d,0xe0,
-};
-
-static const BitmapCharRec ch230 = {13,10,-1,0,15,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x38,0x6c,0x6c,0x38,
-};
-
-static const BitmapCharRec ch229 = {7,14,-1,0,9,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x6c,0x6c,
-};
-
-static const BitmapCharRec ch228 = {7,13,-1,0,9,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x4c,0x5a,0x32,
-};
-
-static const BitmapCharRec ch227 = {7,14,-1,0,9,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch226 = {7,14,-1,0,9,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x30,0x18,0xc,
-};
-
-static const BitmapCharRec ch225 = {7,14,-1,0,9,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,0x0,0x18,0x30,0x60,
-};
-
-static const BitmapCharRec ch224 = {7,14,-1,0,9,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xdc,0xde,0xc6,0xc6,0xc6,0xc6,0xdc,0xdc,0xc6,0xc6,0xc6,0xc6,0x7c,0x38,
-};
-
-static const BitmapCharRec ch223 = {7,14,-1,0,9,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc1,0xc0,0xff,0x80,0xff,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch222 = {10,14,-1,0,12,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,0x0,0x0,0x6,0x0,
-0x3,0x0,0x1,0x80,
-};
-
-static const BitmapCharRec ch221 = {12,18,-1,0,14,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
-0x19,0x80,
-};
-
-static const BitmapCharRec ch220 = {11,17,-1,0,13,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x19,0x80,
-0xf,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch219 = {11,18,-1,0,13,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch218 = {11,18,-1,0,13,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0x0,0x0,0x6,0x0,
-0xc,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch217 = {11,18,-1,0,13,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0xc7,0xc0,0xff,0xf0,0x78,0x38,0x38,0x18,0x6c,0x1c,0x6e,0xc,0x67,0xc,0x63,0x8c,
-0x61,0xcc,0x70,0xdc,0x30,0x78,0x38,0x38,0x1f,0xfc,0x7,0xcc,
-};
-
-static const BitmapCharRec ch216 = {14,14,0,0,15,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch215 = {10,9,0,0,10,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xd,0x80,
-0xd,0x80,
-};
-
-static const BitmapCharRec ch214 = {13,17,-1,0,15,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x9,0x80,
-0xb,0x40,0x6,0x40,
-};
-
-static const BitmapCharRec ch213 = {13,18,-1,0,15,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0xc,0xc0,
-0x7,0x80,0x3,0x0,
-};
-
-static const BitmapCharRec ch212 = {13,18,-1,0,15,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
-0x1,0x80,0x0,0xc0,
-};
-
-static const BitmapCharRec ch211 = {13,18,-1,0,15,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,0x0,0x0,0x3,0x0,
-0x6,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch210 = {13,18,-1,0,15,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
-0xcc,0x60,0xd8,0x60,0xd8,0x60,0xf0,0x60,0xe0,0x60,0xe0,0x60,0x0,0x0,0x13,0x0,
-0x16,0x80,0xc,0x80,
-};
-
-static const BitmapCharRec ch209 = {11,18,-1,0,13,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7f,0x80,0x7f,0xc0,0x60,0xe0,0x60,0x60,0x60,0x30,0x60,0x30,0xfc,0x30,0xfc,0x30,
-0x60,0x30,0x60,0x30,0x60,0x60,0x60,0xe0,0x7f,0xc0,0x7f,0x80,
-};
-
-static const BitmapCharRec ch208 = {12,14,0,0,13,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
-0xcc,
-};
-
-static const BitmapCharRec ch207 = {6,17,0,0,6,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0xcc,
-0x78,0x30,
-};
-
-static const BitmapCharRec ch206 = {6,18,0,0,6,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0xc0,
-0x60,0x30,
-};
-
-static const BitmapCharRec ch205 = {4,18,-2,0,6,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x30,
-0x60,0xc0,
-};
-
-static const BitmapCharRec ch204 = {4,18,0,0,6,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
-0x33,0x0,
-};
-
-static const BitmapCharRec ch203 = {9,17,-1,0,11,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0x33,0x0,
-0x1e,0x0,0xc,0x0,
-};
-
-static const BitmapCharRec ch202 = {9,18,-1,0,11,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch201 = {9,18,-1,0,11,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,0x0,0x0,0xc,0x0,
-0x18,0x0,0x30,0x0,
-};
-
-static const BitmapCharRec ch200 = {9,18,-1,0,11,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x1e,0x0,0x1b,0x0,0x3,0x0,0xe,0x0,0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,
-0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,
-0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch199 = {12,18,-1,4,14,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xc1,0xff,0xc1,0xff,0x61,0x80,0x61,0x80,0x7f,0x80,0x3f,0x80,0x31,0xfe,0x31,0xfe,
-0x19,0x80,0x19,0x80,0xd,0x80,0xd,0x80,0x7,0xff,0x7,0xff,
-};
-
-static const BitmapCharRec ch198 = {16,14,-1,0,18,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x19,0x80,0xf,0x0,
-};
-
-static const BitmapCharRec ch197 = {12,18,0,0,12,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
-0x19,0x80,
-};
-
-static const BitmapCharRec ch196 = {12,17,0,0,12,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x13,0x0,
-0x16,0x80,0xc,0x80,
-};
-
-static const BitmapCharRec ch195 = {12,18,0,0,12,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x19,0x80,
-0xf,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch194 = {12,18,0,0,12,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
-0x3,0x0,0x1,0x80,
-};
-
-static const BitmapCharRec ch193 = {12,18,0,0,12,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,0x0,0x0,0x6,0x0,
-0xc,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch192 = {12,18,0,0,12,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x7c,0xfe,0xc6,0xc6,0xe0,0x70,0x38,0x18,0x18,0x18,0x0,0x0,0x18,0x18,
-};
-
-static const BitmapCharRec ch191 = {7,14,-1,4,10,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x18,0x18,0x18,0x18,0xc,0xfc,0x6,0xd8,0x6,0x78,0x73,0x38,0xf9,0x18,0x99,0x88,
-0x30,0xc0,0x30,0xc0,0x98,0x60,0xf8,0x30,0x70,0x30,
-};
-
-static const BitmapCharRec ch190 = {14,13,0,0,15,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x30,0xf8,0x30,0xf8,0x18,0x60,0xc,0x30,0xc,0x18,0x66,0x98,0x62,0xf8,0x63,0x70,
-0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
-};
-
-static const BitmapCharRec ch189 = {13,13,-1,0,15,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x30,0x30,0x30,0x30,0x19,0xf8,0xd,0xb0,0xc,0xf0,0x66,0x70,0x62,0x30,0x63,0x10,
-0x61,0x80,0x61,0x80,0xe0,0xc0,0xe0,0x60,0x60,0x60,
-};
-
-static const BitmapCharRec ch188 = {13,13,-1,0,15,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x90,0xd8,0x6c,0x36,0x36,0x6c,0xd8,0x90,
-};
-
-static const BitmapCharRec ch187 = {7,8,-1,-1,9,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xf8,0x0,0x70,0xd8,0x88,0x88,0xd8,0x70,
-};
-
-static const BitmapCharRec ch186 = {5,8,-1,-6,7,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0x60,0x60,0x60,0x60,0x60,0xe0,0xe0,0x60,
-};
-
-static const BitmapCharRec ch185 = {3,8,-1,-5,6,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xf0,0xd8,0x18,0x70,0x60,
-};
-
-static const BitmapCharRec ch184 = {5,5,0,4,5,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-1,-4,4,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x32,0x72,0xf2,0xf2,0xf2,0xf2,
-0x72,0x3f,
-};
-
-static const BitmapCharRec ch182 = {8,18,-1,4,10,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0xc0,0xc0,0xc0,0xc0,0xdb,0xff,0xe7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch181 = {8,14,-1,4,10,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0xc0,0x60,0x30,
-};
-
-static const BitmapCharRec ch180 = {4,3,0,-11,4,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x70,0xf8,0x98,0x30,0x30,0x98,0xf8,0x70,
-};
-
-static const BitmapCharRec ch179 = {5,8,0,-5,6,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xf8,0xf8,0x60,0x30,0x18,0x98,0xf8,0x70,
-};
-
-static const BitmapCharRec ch178 = {5,8,0,-5,6,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xff,0xff,0x0,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,
-};
-
-static const BitmapCharRec ch177 = {8,11,-1,0,10,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x70,0xd8,0x88,0xd8,0x70,
-};
-
-static const BitmapCharRec ch176 = {5,5,-1,-8,7,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch175 = {5,1,0,-12,5,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0xf,0x80,0x30,0x60,0x40,0x10,0x48,0x50,0x88,0x88,0x89,0x8,0x8f,0x88,0x88,0x48,
-0x88,0x48,0x4f,0x90,0x40,0x10,0x30,0x60,0xf,0x80,
-};
-
-static const BitmapCharRec ch174 = {13,13,-1,0,14,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xf8,0xf8,
-};
-
-static const BitmapCharRec ch173 = {5,2,-1,-4,7,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x1,0x80,0x1,0x80,0x1,0x80,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch172 = {9,5,-1,-3,11,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x12,0x36,0x6c,0xd8,0xd8,0x6c,0x36,0x12,
-};
-
-static const BitmapCharRec ch171 = {7,8,-1,-1,9,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xf8,0x0,0x68,0xd8,0x48,0x38,0xc8,0x70,
-};
-
-static const BitmapCharRec ch170 = {5,8,-1,-6,7,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0xf,0x80,0x30,0x60,0x40,0x10,0x47,0x10,0x88,0x88,0x90,0x8,0x90,0x8,0x90,0x8,
-0x88,0x88,0x47,0x10,0x40,0x10,0x30,0x60,0xf,0x80,
-};
-
-static const BitmapCharRec ch169 = {13,13,-1,0,15,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xd8,0xd8,
-};
-
-static const BitmapCharRec ch168 = {5,2,0,-11,6,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x3c,0x7e,0xc3,0xc3,0x7,0xe,0x3e,0x73,0xe3,0xc3,0xc7,0x6e,0x7c,0xf0,0xc3,0xc3,
-0x7e,0x3c,
-};
-
-static const BitmapCharRec ch167 = {8,18,-1,4,10,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch166 = {2,17,-1,3,4,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x18,0x18,0x18,0x18,0xff,0x18,0xff,0x3c,0x66,0x66,0x66,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch165 = {8,13,-1,0,10,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0xc3,0xff,0x66,0x66,0x66,0xff,0xc3,
-};
-
-static const BitmapCharRec ch164 = {8,7,-1,-3,10,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xdf,0x0,0xff,0x80,0x60,0x80,0x30,0x0,0x18,0x0,0x18,0x0,0x7e,0x0,0x30,0x0,
-0x60,0x0,0x61,0x80,0x61,0x80,0x3f,0x0,0x1e,0x0,
-};
-
-static const BitmapCharRec ch163 = {9,13,0,0,10,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x10,0x10,0x3e,0x7f,0x6b,0xc8,0xc8,0xc8,0xc8,0x6b,0x7f,0x3e,0x4,0x4,
-};
-
-static const BitmapCharRec ch162 = {8,14,-1,2,10,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x40,0x40,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch161 = {2,14,-2,4,6,ch161data};
-
-/* char: 0xa0 */
-
-#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,5,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,5,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0xcc,0x7e,0x33,
-};
-
-static const BitmapCharRec ch126 = {8,3,-1,-4,10,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xc0,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x18,0xc,0x18,0x30,0x30,0x30,0x30,0x30,
-0x60,0xc0,
-};
-
-static const BitmapCharRec ch125 = {6,18,0,4,6,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch124 = {2,18,-1,4,4,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0xc,0x18,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0xc0,0x60,0x30,0x30,0x30,0x30,0x30,
-0x18,0xc,
-};
-
-static const BitmapCharRec ch123 = {6,18,0,4,6,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xfe,0xfe,0xc0,0x60,0x30,0x18,0xc,0x6,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch122 = {7,10,-1,0,9,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x70,0x70,0x18,0x18,0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch121 = {8,14,-1,4,10,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xc3,0xe7,0x66,0x3c,0x18,0x18,0x3c,0x66,0xe7,0xc3,
-};
-
-static const BitmapCharRec ch120 = {8,10,-1,0,10,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x19,0x80,0x19,0x80,0x39,0xc0,0x29,0x40,0x69,0x60,0x66,0x60,0x66,0x60,0xc6,0x30,
-0xc6,0x30,0xc6,0x30,
-};
-
-static const BitmapCharRec ch119 = {12,10,-1,0,14,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x18,0x18,0x3c,0x24,0x66,0x66,0x66,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch118 = {8,10,-1,0,10,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x73,0xfb,0xc7,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,
-};
-
-static const BitmapCharRec ch117 = {8,10,-1,0,10,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x18,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x30,
-};
-
-static const BitmapCharRec ch116 = {6,13,0,0,6,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0x78,0xfc,0xc6,0x6,0x3e,0xfc,0xc0,0xc6,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch115 = {7,10,-1,0,9,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xe0,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch114 = {5,10,-1,0,6,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,0x7f,0x80,0x3d,0x80,
-};
-
-static const BitmapCharRec ch113 = {9,14,-1,4,11,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,0xff,0x0,0xde,0x0,
-};
-
-static const BitmapCharRec ch112 = {9,14,-1,4,11,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x3e,0x0,0x7f,0x0,0x63,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x0,
-0x7f,0x0,0x3e,0x0,
-};
-
-static const BitmapCharRec ch111 = {9,10,-1,0,11,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,
-};
-
-static const BitmapCharRec ch110 = {8,10,-1,0,10,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xc6,0x30,0xe7,0x30,
-0xde,0xf0,0xcc,0x60,
-};
-
-static const BitmapCharRec ch109 = {12,10,-1,0,14,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch108 = {2,14,-1,0,4,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0xc7,0xc6,0xce,0xcc,0xd8,0xf8,0xf0,0xd8,0xcc,0xc6,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch107 = {8,14,-1,0,9,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0xe0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x0,0x0,
-0x30,0x30,
-};
-
-static const BitmapCharRec ch106 = {4,18,1,4,4,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch105 = {2,14,-1,0,4,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xe3,0xdf,0xce,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch104 = {8,14,-1,0,10,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x1c,0x0,0x7f,0x0,0x63,0x0,0x1,0x80,0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x7f,0x80,0x3d,0x80,
-};
-
-static const BitmapCharRec ch103 = {9,14,-1,4,11,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfc,0xfc,0x30,0x30,0x3c,0x1c,
-};
-
-static const BitmapCharRec ch102 = {6,14,0,0,6,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x3c,0x7f,0xe3,0xc0,0xc0,0xff,0xc3,0xc3,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch101 = {8,10,-1,0,10,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x3d,0x80,0x7f,0x80,0x63,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x63,0x80,
-0x7f,0x80,0x3d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
-};
-
-static const BitmapCharRec ch100 = {9,14,-1,0,11,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x3e,0x7f,0x63,0xc0,0xc0,0xc0,0xc0,0x63,0x7f,0x3e,
-};
-
-static const BitmapCharRec ch99 = {8,10,-1,0,10,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xde,0x0,0xff,0x0,0xe3,0x0,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xe3,0x0,
-0xff,0x0,0xde,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch98 = {9,14,-1,0,11,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x76,0xee,0xc6,0xc6,0xe6,0x7e,0xe,0xc6,0xee,0x7c,
-};
-
-static const BitmapCharRec ch97 = {7,10,-1,0,9,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0xc0,0x80,0x80,0x40,
-};
-
-static const BitmapCharRec ch96 = {2,5,-1,-9,4,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch95 = {10,2,0,4,10,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x82,0xc6,0x6c,0x38,0x10,
-};
-
-static const BitmapCharRec ch94 = {7,5,-1,-8,9,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf0,0xf0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xf0,0xf0,
-};
-
-static const BitmapCharRec ch93 = {4,18,0,4,5,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x18,0x18,0x10,0x10,0x30,0x30,0x20,0x20,0x60,0x60,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch92 = {5,14,0,0,5,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf0,0xf0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xf0,0xf0,
-};
-
-static const BitmapCharRec ch91 = {4,18,-1,4,5,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xff,0xc0,0xff,0xc0,0xc0,0x0,0x60,0x0,0x30,0x0,0x18,0x0,0x1c,0x0,0xc,0x0,
-0x6,0x0,0x3,0x0,0x1,0x80,0x0,0xc0,0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch90 = {10,14,-1,0,12,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xf,0x0,0x19,0x80,
-0x30,0xc0,0x30,0xc0,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
-};
-
-static const BitmapCharRec ch89 = {12,14,-1,0,14,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xc0,0x60,0xe0,0xe0,0x60,0xc0,0x71,0xc0,0x31,0x80,0x1b,0x0,0xe,0x0,0xe,0x0,
-0x1b,0x0,0x31,0x80,0x71,0xc0,0x60,0xc0,0xe0,0xe0,0xc0,0x60,
-};
-
-static const BitmapCharRec ch88 = {11,14,-1,0,13,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x18,0x18,0x18,0x18,0x1c,0x38,0x34,0x2c,0x36,0x6c,0x36,0x6c,0x66,0x66,0x66,0x66,
-0x62,0x46,0x63,0xc6,0xc3,0xc3,0xc1,0x83,0xc1,0x83,0xc1,0x83,
-};
-
-static const BitmapCharRec ch87 = {16,14,-1,0,18,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x6,0x0,0xf,0x0,0xf,0x0,0x19,0x80,0x19,0x80,0x19,0x80,0x30,0xc0,0x30,0xc0,
-0x30,0xc0,0x60,0x60,0x60,0x60,0x60,0x60,0xc0,0x30,0xc0,0x30,
-};
-
-static const BitmapCharRec ch86 = {12,14,-1,0,14,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x1f,0x0,0x7f,0xc0,0x60,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch85 = {11,14,-1,0,13,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,
-0xc,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0xff,0xc0,0xff,0xc0,
-};
-
-static const BitmapCharRec ch84 = {10,14,-1,0,12,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x3f,0x0,0x7f,0xc0,0xe0,0xe0,0xc0,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,0x1f,0x0,
-0x7c,0x0,0xe0,0x0,0xc0,0x60,0xe0,0xe0,0x7f,0xc0,0x1f,0x0,
-};
-
-static const BitmapCharRec ch83 = {11,14,-1,0,13,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0x80,0xc1,0x80,0xff,0x0,0xff,0x80,
-0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch82 = {10,14,-1,0,12,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x0,0x30,0xf,0xb0,0x3f,0xe0,0x70,0xf0,0x61,0xb0,0xe1,0xb8,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch81 = {13,15,-1,1,15,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x80,
-0xc1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch80 = {10,14,-1,0,12,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x38,0xc0,0x18,0xc0,0x18,0xc0,0x18,
-0xc0,0x18,0xe0,0x38,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch79 = {13,14,-1,0,15,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xc0,0x60,0xc0,0xe0,0xc1,0xe0,0xc1,0xe0,0xc3,0x60,0xc6,0x60,0xc6,0x60,0xcc,0x60,
-0xcc,0x60,0xd8,0x60,0xf0,0x60,0xf0,0x60,0xe0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch78 = {11,14,-1,0,13,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xc3,0xc,0xc3,0xc,0xc7,0x8c,0xc4,0x8c,0xcc,0xcc,0xcc,0xcc,0xd8,0x6c,0xd8,0x6c,
-0xf0,0x3c,0xf0,0x3c,0xe0,0x1c,0xe0,0x1c,0xc0,0xc,0xc0,0xc,
-};
-
-static const BitmapCharRec ch77 = {14,14,-1,0,16,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xff,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch76 = {8,14,-1,0,10,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xc0,0x70,0xc0,0xe0,0xc1,0xc0,0xc3,0x80,0xc7,0x0,0xce,0x0,0xfc,0x0,0xf8,0x0,
-0xdc,0x0,0xce,0x0,0xc7,0x0,0xc3,0x80,0xc1,0xc0,0xc0,0xe0,
-};
-
-static const BitmapCharRec ch75 = {12,14,-1,0,13,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x3c,0x7e,0xe7,0xc3,0xc3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,
-};
-
-static const BitmapCharRec ch74 = {8,14,-1,0,10,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch73 = {2,14,-2,0,6,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xff,0xe0,0xff,0xe0,
-0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-};
-
-static const BitmapCharRec ch72 = {11,14,-1,0,13,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0xf,0xb0,0x3f,0xf0,0x70,0x70,0x60,0x30,0xe0,0x30,0xc1,0xf0,0xc1,0xf0,0xc0,0x0,
-0xc0,0x0,0xe0,0x30,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch71 = {12,14,-1,0,14,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch70 = {9,14,-1,0,11,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xff,0x80,0xff,0x80,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x0,0xff,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,0xff,0x80,
-};
-
-static const BitmapCharRec ch69 = {9,14,-1,0,11,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xff,0x0,0xff,0x80,0xc1,0xc0,0xc0,0xc0,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,
-0xc0,0x60,0xc0,0x60,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch68 = {11,14,-1,0,13,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0xf,0x80,0x3f,0xe0,0x70,0x70,0x60,0x30,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xe0,0x0,0x60,0x30,0x70,0x70,0x3f,0xe0,0xf,0x80,
-};
-
-static const BitmapCharRec ch67 = {12,14,-1,0,14,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xff,0x80,0xff,0xc0,0xc0,0xe0,0xc0,0x60,0xc0,0x60,0xc0,0xe0,0xff,0xc0,0xff,0x80,
-0xc1,0x80,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0xff,0x80,0xff,0x0,
-};
-
-static const BitmapCharRec ch66 = {11,14,-1,0,13,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xc0,0x30,0xc0,0x30,0x60,0x60,0x60,0x60,0x7f,0xe0,0x3f,0xc0,0x30,0xc0,0x30,0xc0,
-0x19,0x80,0x19,0x80,0xf,0x0,0xf,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch65 = {12,14,0,0,12,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x7,0xe0,0x1f,0xf0,0x38,0x0,0x70,0x0,0x67,0x70,0xcf,0xf8,0xcc,0xcc,0xcc,0x66,
-0xcc,0x66,0xcc,0x63,0xc6,0x33,0x67,0x73,0x63,0xb3,0x30,0x6,0x1c,0xe,0xf,0xfc,
-0x3,0xf0,
-};
-
-static const BitmapCharRec ch64 = {16,17,-1,3,18,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x30,0x30,0x0,0x0,0x30,0x30,0x30,0x38,0x1c,0xe,0xc6,0xc6,0xfe,0x7c,
-};
-
-static const BitmapCharRec ch63 = {7,14,-1,0,10,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0xf0,0x3c,0xe,0x3,0xe,0x3c,0xf0,0xc0,
-};
-
-static const BitmapCharRec ch62 = {8,9,-1,0,10,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xfe,0xfe,0x0,0x0,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch61 = {7,6,-2,-2,11,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x3,0xf,0x3c,0x70,0xc0,0x70,0x3c,0xf,0x3,
-};
-
-static const BitmapCharRec ch60 = {8,9,-1,0,10,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x40,0x40,0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {2,13,-1,3,5,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,10,-1,0,5,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0x7c,0xfe,0xc6,0x3,0x3,0x3b,0x7f,0xc3,0xc3,0xc3,0xc7,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch57 = {8,13,-1,0,10,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x3c,0x7e,0xe7,0xc3,0xc3,0x66,0x7e,0x66,0xc3,0xc3,0xe7,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch56 = {8,13,-1,0,10,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x60,0x60,0x30,0x30,0x30,0x18,0x18,0xc,0xc,0x6,0x3,0xff,0xff,
-};
-
-static const BitmapCharRec ch55 = {8,13,-1,0,10,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x3c,0x7e,0xe3,0xc3,0xc3,0xc3,0xfe,0xdc,0xc0,0xc0,0x63,0x7f,0x3c,
-};
-
-static const BitmapCharRec ch54 = {8,13,-1,0,10,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7c,0xfe,0xc7,0xc3,0x3,0x3,0xc7,0xfe,0xfc,0xc0,0xc0,0xfe,0xfe,
-};
-
-static const BitmapCharRec ch53 = {8,13,-1,0,10,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x3,0x0,0x3,0x0,0x3,0x0,0xff,0x80,0xff,0x80,0xc3,0x0,0x63,0x0,0x33,0x0,
-0x33,0x0,0x1b,0x0,0xf,0x0,0x7,0x0,0x3,0x0,
-};
-
-static const BitmapCharRec ch52 = {9,13,-1,0,10,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x3c,0x7e,0xc7,0xc3,0x3,0x7,0x1e,0x1c,0x6,0xc3,0xc3,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch51 = {8,13,-1,0,10,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xff,0xff,0xc0,0xe0,0x70,0x38,0x1c,0xe,0x7,0x3,0xc3,0xfe,0x3c,
-};
-
-static const BitmapCharRec ch50 = {8,13,-1,0,10,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0xf8,0x18,
-};
-
-static const BitmapCharRec ch49 = {5,13,-2,0,10,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x3c,0x7e,0x66,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0xc3,0x66,0x7e,0x3c,
-};
-
-static const BitmapCharRec ch48 = {8,13,-1,0,10,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0xc0,0xc0,0x40,0x40,0x60,0x60,0x20,0x20,0x30,0x30,0x10,0x10,0x18,0x18,
-};
-
-static const BitmapCharRec ch47 = {5,14,0,0,5,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-1,0,5,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xff,0xff,
-};
-
-static const BitmapCharRec ch45 = {8,2,-1,-4,11,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {2,5,-1,3,5,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x18,0x18,0x18,0x18,0xff,0xff,0x18,0x18,0x18,0x18,
-};
-
-static const BitmapCharRec ch43 = {8,10,-1,0,10,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x88,0x70,0x70,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch42 = {5,6,-1,-8,7,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0xc0,0x60,0x60,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x60,0x60,
-0xc0,0x80,
-};
-
-static const BitmapCharRec ch41 = {4,18,-1,4,6,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x10,0x30,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,0x60,
-0x30,0x10,
-};
-
-static const BitmapCharRec ch40 = {4,18,-1,4,6,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x80,0x40,0x40,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,5,-1,-9,4,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x3c,0x70,0x7e,0xe0,0xe7,0xc0,0xc3,0x80,0xc3,0xc0,0xc6,0xc0,0xee,0xc0,0x7c,0x0,
-0x3c,0x0,0x66,0x0,0x66,0x0,0x7e,0x0,0x3c,0x0,
-};
-
-static const BitmapCharRec ch38 = {12,13,-1,0,13,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x18,0x78,0x18,0xfc,0xc,0xcc,0xc,0xcc,0x6,0xfc,0x6,0x78,0x3,0x0,0x7b,0x0,
-0xfd,0x80,0xcd,0x80,0xcc,0xc0,0xfc,0xc0,0x78,0x60,
-};
-
-static const BitmapCharRec ch37 = {14,13,-1,0,16,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x8,0x0,0x8,0x0,0x3e,0x0,0x7f,0x0,0xeb,0x80,0xc9,0x80,0x9,0x80,0xf,0x0,
-0x3e,0x0,0x78,0x0,0xe8,0x0,0xc8,0x0,0xcb,0x0,0x7f,0x0,0x3e,0x0,0x8,0x0,
-};
-
-static const BitmapCharRec ch36 = {9,16,-1,2,10,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x24,0x0,0x24,0x0,0x24,0x0,0xff,0x80,0xff,0x80,0x12,0x0,0x12,0x0,0x12,0x0,
-0x7f,0xc0,0x7f,0xc0,0x9,0x0,0x9,0x0,0x9,0x0,
-};
-
-static const BitmapCharRec ch35 = {10,13,0,0,10,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x90,0x90,0xd8,0xd8,0xd8,
-};
-
-static const BitmapCharRec ch34 = {5,5,0,-9,5,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0xc0,0xc0,0x0,0x0,0x80,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch33 = {2,14,-2,0,6,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,5,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,5,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmapHelvetica18;
-const BitmapFontRec glutBitmapHelvetica18 = {
-"-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/glx/glut_init.c b/src/glut/glx/glut_init.c
deleted file mode 100644
index 213819e7510..00000000000
--- a/src/glut/glx/glut_init.c
+++ /dev/null
@@ -1,393 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#endif
-
-/* SGI optimization introduced in IRIX 6.3 to avoid X server
-   round trips for interning common X atoms. */
-#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
-#include <X11/SGIFastAtom.h>
-#else
-#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
-#endif
-
-#include "glutint.h"
-
-/* GLUT inter-file variables */
-/* *INDENT-OFF* */
-char *__glutProgramName = NULL;
-int __glutArgc = 0;
-char **__glutArgv = NULL;
-char *__glutGeometry = NULL;
-Display *__glutDisplay = NULL;
-int __glutScreen;
-Window __glutRoot;
-int __glutScreenHeight;
-int __glutScreenWidth;
-GLboolean __glutIconic = GL_FALSE;
-GLboolean __glutDebug = GL_FALSE;
-unsigned int __glutDisplayMode =
-  GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH;
-char *__glutDisplayString = NULL;
-int __glutConnectionFD;
-XSizeHints __glutSizeHints;
-int __glutInitWidth = 300, __glutInitHeight = 300;
-int __glutInitX = -1, __glutInitY = -1;
-GLboolean __glutForceDirect = GL_FALSE,
-  __glutTryDirect = GL_TRUE;
-Atom __glutWMDeleteWindow;
-char *__glutPPMFile = NULL;
-/* *INDENT-ON* */
-
-#ifdef _WIN32
-void (__cdecl *__glutExitFunc)(int retval) = NULL;
-#endif
-
-static Bool synchronize = False;
-
-#if defined(_WIN32)
-
-#ifdef __BORLANDC__
-#include <float.h>  /* For masking floating point exceptions. */
-#endif
-
-void
-__glutOpenWin32Connection(char* display)
-{
-  static char *classname;
-  WNDCLASS  wc;
-  HINSTANCE hInstance = GetModuleHandle(NULL);
-  
-  /* Make sure we register the window only once. */
-  if(classname)
-    return;
-
-#ifdef __BORLANDC__
-  /* Under certain conditions (e.g. while rendering solid surfaces with
-     lighting enabled) Microsoft OpenGL libraries cause some illegal
-     operations like floating point overflow or division by zero. The
-     default behaviour of Microsoft compilers is to mask (ignore)
-     floating point exceptions, while Borland compilers do not.  The
-     following function of Borland RTL allows to mask exceptions.
-     Advice from Pier Giorgio Esposito ([email protected]). */
-  _control87(MCW_EM,MCW_EM);
-#endif
-
-  classname = "GLUT";
-
-  /* Clear (important!) and then fill in the window class structure. */
-  memset(&wc, 0, sizeof(WNDCLASS));
-  wc.style         = CS_OWNDC;
-  wc.lpfnWndProc   = (WNDPROC)__glutWindowProc;
-  wc.hInstance     = hInstance;
-  wc.hIcon         = LoadIcon(hInstance, "GLUT_ICON");
-  wc.hCursor       = LoadCursor(hInstance, IDC_ARROW);
-  wc.hbrBackground = NULL;
-  wc.lpszMenuName  = NULL;
-  wc.lpszClassName = classname;
-
-  /* Fill in a default icon if one isn't specified as a resource. */
-  if(!wc.hIcon)
-    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
-  
-  if(!RegisterClass(&wc)) {
-    __glutFatalError("RegisterClass() failed:"
-		     "Cannot register GLUT window class.");
-  }
- 
-  __glutScreenWidth     = GetSystemMetrics(SM_CXSCREEN);
-  __glutScreenHeight    = GetSystemMetrics(SM_CYSCREEN);
-
-  /* Set the root window to NULL because windows creates a top-level
-     window when the parent is NULL.  X creates a top-level window
-     when the parent is the root window. */
-  __glutRoot            = NULL;
-
-  /* Set the display to 1 -- we shouldn't be using this anywhere
-     (except as an argument to X calls). */
-  __glutDisplay         = (Display*)1;
-
-  /* There isn't any concept of multiple screens in Win32, therefore,
-     we don't need to keep track of the screen we're on... it's always
-     the same one. */
-  __glutScreen          = 0;
-}
-#else /* !_WIN32 */
-void
-__glutOpenXConnection(char *display)
-{
-  int errorBase, eventBase;
-
-  __glutDisplay = XOpenDisplay(display);
-  if (!__glutDisplay)
-    __glutFatalError("could not open display: %s",
-      XDisplayName(display));
-  if (synchronize)
-    XSynchronize(__glutDisplay, True);
-  if (!glXQueryExtension(__glutDisplay, &errorBase, &eventBase))
-    __glutFatalError(
-      "OpenGL GLX extension not supported by display: %s",
-      XDisplayName(display));
-  __glutScreen = DefaultScreen(__glutDisplay);
-  __glutRoot = RootWindow(__glutDisplay, __glutScreen);
-  __glutScreenWidth = DisplayWidth(__glutDisplay, __glutScreen);
-  __glutScreenHeight = DisplayHeight(__glutDisplay,
-    __glutScreen);
-  __glutConnectionFD = ConnectionNumber(__glutDisplay);
-  __glutWMDeleteWindow = XSGIFastInternAtom(__glutDisplay,
-    "WM_DELETE_WINDOW", SGI_XA_WM_DELETE_WINDOW, False);
-}
-#endif /* _WIN32 */
-
-void
-#ifdef OLD_VMS
-  __glutInitTime(struct timeval6 *beginning)
-#else
-  __glutInitTime(struct timeval *beginning)
-#endif
-{
-  static int beenhere = 0;
-#ifdef OLD_VMS
-   static struct timeval6 genesis;
-#else
-   static struct timeval genesis;
-#endif
-   
-  if (!beenhere) {
-    GETTIMEOFDAY(&genesis);
-    beenhere = 1;
-  }
-  *beginning = genesis;
-}
-
-static void
-removeArgs(int *argcp, char **argv, int numToRemove)
-{
-  int i, j;
-
-  for (i = 0, j = numToRemove; argv[j]; i++, j++) {
-    argv[i] = argv[j];
-  }
-  argv[i] = NULL;
-  *argcp -= numToRemove;
-}
-
-void GLUTAPIENTRY 
-glutInit(int *argcp, char **argv)
-{
-  char *display = NULL;
-  char *str, *geometry = NULL;
-#ifdef OLD_VMS
-   struct timeval6 unused;
-#else
-   struct timeval unused;
-#endif
-   int i;
-
-  if (__glutDisplay) {
-    __glutWarning("glutInit being called a second time.");
-    return;
-  }
-  /* Determine temporary program name. */
-  str = strrchr(argv[0], '/');
-  if (str == NULL) {
-    __glutProgramName = argv[0];
-  } else {
-    __glutProgramName = str + 1;
-  }
-
-  /* Make private copy of command line arguments. */
-  __glutArgc = *argcp;
-  __glutArgv = (char **) malloc(__glutArgc * sizeof(char *));
-  if (!__glutArgv)
-    __glutFatalError("out of memory.");
-  for (i = 0; i < __glutArgc; i++) {
-    __glutArgv[i] = __glutStrdup(argv[i]);
-    if (!__glutArgv[i])
-      __glutFatalError("out of memory.");
-  }
-
-  /* determine permanent program name */
-  str = strrchr(__glutArgv[0], '/');
-  if (str == NULL) {
-    __glutProgramName = __glutArgv[0];
-  } else {
-    __glutProgramName = str + 1;
-  }
-
-  /* parse arguments for standard options */
-  for (i = 1; i < __glutArgc; i++) {
-    if (!strcmp(__glutArgv[i], "-display")) {
-#if defined(_WIN32)
-      __glutWarning("-display option not supported by Win32 GLUT.");
-#endif
-      if (++i >= __glutArgc) {
-        __glutFatalError(
-          "follow -display option with X display name.");
-      }
-      display = __glutArgv[i];
-      removeArgs(argcp, &argv[1], 2);
-    } else if (!strcmp(__glutArgv[i], "-geometry")) {
-      if (++i >= __glutArgc) {
-        __glutFatalError(
-          "follow -geometry option with geometry parameter.");
-      }
-      geometry = __glutArgv[i];
-      removeArgs(argcp, &argv[1], 2);
-    } else if (!strcmp(__glutArgv[i], "-direct")) {
-#if defined(_WIN32)
-      __glutWarning("-direct option not supported by Win32 GLUT.");
-#endif
-      if (!__glutTryDirect)
-        __glutFatalError(
-          "cannot force both direct and indirect rendering.");
-      __glutForceDirect = GL_TRUE;
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-indirect")) {
-#if defined(_WIN32)
-      __glutWarning("-indirect option not supported by Win32 GLUT.");
-#endif
-      if (__glutForceDirect)
-        __glutFatalError(
-          "cannot force both direct and indirect rendering.");
-      __glutTryDirect = GL_FALSE;
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-iconic")) {
-      __glutIconic = GL_TRUE;
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-gldebug")) {
-      __glutDebug = GL_TRUE;
-      removeArgs(argcp, &argv[1], 1);
-    } else if (!strcmp(__glutArgv[i], "-sync")) {
-#if defined(_WIN32)
-      __glutWarning("-sync option not supported by Win32 GLUT.");
-#endif
-      synchronize = GL_TRUE;
-      removeArgs(argcp, &argv[1], 1);
-    } else {
-      /* Once unknown option encountered, stop command line
-         processing. */
-      break;
-    }
-  }
-#if defined(_WIN32)
-  __glutOpenWin32Connection(display);
-#else
-  __glutOpenXConnection(display);
-#endif
-  if (geometry) {
-    int flags, x, y, width, height;
-
-    /* Fix bogus "{width|height} may be used before set"
-       warning */
-    width = 0;
-    height = 0;
-
-    flags = XParseGeometry(geometry, &x, &y,
-      (unsigned int *) &width, (unsigned int *) &height);
-    if (WidthValue & flags) {
-      /* Careful because X does not allow zero or negative
-         width windows */
-      if (width > 0)
-        __glutInitWidth = width;
-    }
-    if (HeightValue & flags) {
-      /* Careful because X does not allow zero or negative
-         height windows */
-      if (height > 0)
-        __glutInitHeight = height;
-    }
-    glutInitWindowSize(__glutInitWidth, __glutInitHeight);
-    if (XValue & flags) {
-      if (XNegative & flags)
-        x = DisplayWidth(__glutDisplay, __glutScreen) +
-          x - __glutSizeHints.width;
-      /* Play safe: reject negative X locations */
-      if (x >= 0)
-        __glutInitX = x;
-    }
-    if (YValue & flags) {
-      if (YNegative & flags)
-        y = DisplayHeight(__glutDisplay, __glutScreen) +
-          y - __glutSizeHints.height;
-      /* Play safe: reject negative Y locations */
-      if (y >= 0)
-        __glutInitY = y;
-    }
-    glutInitWindowPosition(__glutInitX, __glutInitY);
-  }
-  __glutInitTime(&unused);
-
-  /* check if GLUT_FPS env var is set */
-  {
-     const char *fps = getenv("GLUT_FPS");
-     if (fps) {
-        sscanf(fps, "%d", &__glutFPS);
-        if (__glutFPS <= 0)
-           __glutFPS = 5000;  /* 5000 milliseconds */
-     }
-  }
-
-  /* check if GLUT_PPM_FILE env var is set */
-  __glutPPMFile = getenv("GLUT_PPM_FILE");
-}
-
-#ifdef _WIN32
-void GLUTAPIENTRY 
-__glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int))
-{
-  __glutExitFunc = exitfunc;
-  glutInit(argcp, argv);
-}
-#endif
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutInitWindowPosition(int x, int y)
-{
-  __glutInitX = x;
-  __glutInitY = y;
-  if (x >= 0 && y >= 0) {
-    __glutSizeHints.x = x;
-    __glutSizeHints.y = y;
-    __glutSizeHints.flags |= USPosition;
-  } else {
-    __glutSizeHints.flags &= ~USPosition;
-  }
-}
-
-void GLUTAPIENTRY 
-glutInitWindowSize(int width, int height)
-{
-  __glutInitWidth = width;
-  __glutInitHeight = height;
-  if (width > 0 && height > 0) {
-    __glutSizeHints.width = width;
-    __glutSizeHints.height = height;
-    __glutSizeHints.flags |= USSize;
-  } else {
-    __glutSizeHints.flags &= ~USSize;
-  }
-}
-
-void GLUTAPIENTRY 
-glutInitDisplayMode(unsigned int mask)
-{
-  __glutDisplayMode = mask;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_input.c b/src/glut/glx/glut_input.c
deleted file mode 100644
index 53f9dc5e0f8..00000000000
--- a/src/glut/glx/glut_input.c
+++ /dev/null
@@ -1,644 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#if defined(__vms)
-#include <X11/XInput.h>
-#else
-#include <X11/extensions/XInput.h>
-#endif
-#include <X11/Xutil.h>
-#else
-#ifdef __MINGW32__
-#include <GL/gl.h>
-#endif
-#include <windows.h>
-#ifndef __CYGWIN32__
-#include <mmsystem.h>  /* Win32 Multimedia API header. */
-#endif
-#endif /* !_WIN32 */
-
-#include "glutint.h"
-
-int __glutNumDials = 0;
-int __glutNumSpaceballButtons = 0;
-int __glutNumButtonBoxButtons = 0;
-int __glutNumTabletButtons = 0;
-int __glutNumMouseButtons = 3;  /* Good guess. */
-XDevice *__glutTablet = NULL;
-XDevice *__glutDials = NULL;
-XDevice *__glutSpaceball = NULL;
-
-int __glutHasJoystick = 0;
-int __glutNumJoystickButtons = 0;
-int __glutNumJoystickAxes = 0;
-
-#if !defined(_WIN32)
-typedef struct _Range {
-  int min;
-  int range;
-} Range;
-
-#define NUM_SPACEBALL_AXIS	6
-#define NUM_TABLET_AXIS		2
-#define NUM_DIALS_AXIS		8
-
-Range __glutSpaceballRange[NUM_SPACEBALL_AXIS];
-Range __glutTabletRange[NUM_TABLET_AXIS];
-int *__glutDialsResolution;
-
-/* Safely assumes 0 is an illegal event type for X Input
-   extension events. */
-int __glutDeviceMotionNotify = 0;
-int __glutDeviceButtonPress = 0;
-int __glutDeviceButtonPressGrab = 0;
-int __glutDeviceButtonRelease = 0;
-int __glutDeviceStateNotify = 0;
-
-static int
-normalizeTabletPos(int axis, int rawValue)
-{
-  assert(rawValue >= __glutTabletRange[axis].min);
-  assert(rawValue <= __glutTabletRange[axis].min
-    + __glutTabletRange[axis].range);
-  /* Normalize rawValue to between 0 and 4000. */
-  return ((rawValue - __glutTabletRange[axis].min) * 4000) /
-    __glutTabletRange[axis].range;
-}
-
-static int
-normalizeDialAngle(int axis, int rawValue)
-{
-  /* XXX Assumption made that the resolution of the device is
-     number of clicks for one complete dial revolution.  This
-     is true for SGI's dial & button box. */
-  return (rawValue * 360.0) / __glutDialsResolution[axis];
-}
-
-static int
-normalizeSpaceballAngle(int axis, int rawValue)
-{
-  assert(rawValue >= __glutSpaceballRange[axis].min);
-  assert(rawValue <= __glutSpaceballRange[axis].min +
-    __glutSpaceballRange[axis].range);
-  /* Normalize rawValue to between -1800 and 1800. */
-  return ((rawValue - __glutSpaceballRange[axis].min) * 3600) /
-    __glutSpaceballRange[axis].range - 1800;
-}
-
-static int
-normalizeSpaceballDelta(int axis, int rawValue)
-{
-  assert(rawValue >= __glutSpaceballRange[axis].min);
-  assert(rawValue <= __glutSpaceballRange[axis].min +
-    __glutSpaceballRange[axis].range);
-  /* Normalize rawValue to between -1000 and 1000. */
-  return ((rawValue - __glutSpaceballRange[axis].min) * 2000) /
-    __glutSpaceballRange[axis].range - 1000;
-}
-
-static void
-queryTabletPos(GLUTwindow * window)
-{
-  XDeviceState *state;
-  XInputClass *any;
-  XValuatorState *v;
-  int i;
-
-  state = XQueryDeviceState(__glutDisplay, __glutTablet);
-  any = state->data;
-  for (i = 0; i < state->num_classes; i++) {
-#if defined(__cplusplus) || defined(c_plusplus)
-    switch (any->c_class) {
-#else
-    switch (any->class) {
-#endif
-    case ValuatorClass:
-      v = (XValuatorState *) any;
-      if (v->num_valuators < 2)
-        goto end;
-      if (window->tabletPos[0] == -1)
-        window->tabletPos[0] = normalizeTabletPos(0, v->valuators[0]);
-      if (window->tabletPos[1] == -1)
-        window->tabletPos[1] = normalizeTabletPos(1, v->valuators[1]);
-    }
-    any = (XInputClass *) ((char *) any + any->length);
-  }
-end:
-  XFreeDeviceState(state);
-}
-
-static void
-tabletPosChange(GLUTwindow * window, int first, int count, int *data)
-{
-  int i, value, genEvent = 0;
-
-  for (i = first; i < first + count; i++) {
-    switch (i) {
-    case 0:            /* X axis */
-    case 1:            /* Y axis */
-      value = normalizeTabletPos(i, data[i - first]);
-      if (value != window->tabletPos[i]) {
-        window->tabletPos[i] = value;
-        genEvent = 1;
-      }
-      break;
-    }
-  }
-  if (window->tabletPos[0] == -1 || window->tabletPos[1] == -1)
-    queryTabletPos(window);
-  if (genEvent)
-    window->tabletMotion(window->tabletPos[0], window->tabletPos[1]);
-}
-#endif /* !_WIN32 */
-
-static int
-__glutProcessDeviceEvents(XEvent * event)
-{
-#if !defined(_WIN32)
-  GLUTwindow *window;
-
-  /* XXX Ugly code fan out. */
-
-  /* Can't use switch/case since X Input event types are
-     dynamic. */
-
-  if (__glutDeviceMotionNotify && event->type == __glutDeviceMotionNotify) {
-    XDeviceMotionEvent *devmot = (XDeviceMotionEvent *) event;
-
-    window = __glutGetWindow(devmot->window);
-    if (window) {
-      if (__glutTablet
-        && devmot->deviceid == __glutTablet->device_id
-        && window->tabletMotion) {
-        tabletPosChange(window, devmot->first_axis, devmot->axes_count,
-          devmot->axis_data);
-      } else if (__glutDials
-          && devmot->deviceid == __glutDials->device_id
-        && window->dials) {
-        int i, first = devmot->first_axis, count = devmot->axes_count;
-
-        for (i = first; i < first + count; i++)
-          window->dials(i + 1,
-            normalizeDialAngle(i, devmot->axis_data[i - first]));
-      } else if (__glutSpaceball
-        && devmot->deviceid == __glutSpaceball->device_id) {
-        /* XXX Assume that space ball motion events come in as
-           all the first 6 axes.  Assume first 3 axes are XYZ
-           translations; second 3 axes are XYZ rotations. */
-        if (devmot->first_axis == 0 && devmot->axes_count == 6) {
-          if (window->spaceMotion)
-            window->spaceMotion(
-              normalizeSpaceballDelta(0, devmot->axis_data[0]),
-              normalizeSpaceballDelta(1, devmot->axis_data[1]),
-              normalizeSpaceballDelta(2, devmot->axis_data[2]));
-          if (window->spaceRotate)
-            window->spaceRotate(
-              normalizeSpaceballAngle(3, devmot->axis_data[3]),
-              normalizeSpaceballAngle(4, devmot->axis_data[4]),
-              normalizeSpaceballAngle(5, devmot->axis_data[5]));
-        }
-      }
-      return 1;
-    }
-  } else if (__glutDeviceButtonPress
-    && event->type == __glutDeviceButtonPress) {
-    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
-
-    window = __glutGetWindow(devbtn->window);
-    if (window) {
-      if (__glutTablet
-        && devbtn->deviceid == __glutTablet->device_id
-        && window->tabletButton
-        && devbtn->first_axis == 0
-        && devbtn->axes_count == 2) {
-        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
-          devbtn->axis_data);
-        window->tabletButton(devbtn->button, GLUT_DOWN,
-          window->tabletPos[0], window->tabletPos[1]);
-      } else if (__glutDials
-          && devbtn->deviceid == __glutDials->device_id
-        && window->buttonBox) {
-        window->buttonBox(devbtn->button, GLUT_DOWN);
-      } else if (__glutSpaceball
-          && devbtn->deviceid == __glutSpaceball->device_id
-        && window->spaceButton) {
-        window->spaceButton(devbtn->button, GLUT_DOWN);
-      }
-      return 1;
-    }
-  } else if (__glutDeviceButtonRelease
-    && event->type == __glutDeviceButtonRelease) {
-    XDeviceButtonEvent *devbtn = (XDeviceButtonEvent *) event;
-
-    window = __glutGetWindow(devbtn->window);
-    if (window) {
-      if (__glutTablet
-        && devbtn->deviceid == __glutTablet->device_id
-        && window->tabletButton
-        && devbtn->first_axis == 0
-        && devbtn->axes_count == 2) {
-        tabletPosChange(window, devbtn->first_axis, devbtn->axes_count,
-          devbtn->axis_data);
-        window->tabletButton(devbtn->button, GLUT_UP,
-          window->tabletPos[0], window->tabletPos[1]);
-      } else if (__glutDials
-          && devbtn->deviceid == __glutDials->device_id
-        && window->buttonBox) {
-        window->buttonBox(devbtn->button, GLUT_UP);
-      } else if (__glutSpaceball
-          && devbtn->deviceid == __glutSpaceball->device_id
-        && window->spaceButton) {
-        window->spaceButton(devbtn->button, GLUT_UP);
-      }
-      return 1;
-    }
-  }
-#else
-  {
-    JOYINFOEX info;
-    JOYCAPS joyCaps;
-
-    memset(&info, 0, sizeof(JOYINFOEX)); 
-    info.dwSize = sizeof(JOYINFOEX); 
-    info.dwFlags = JOY_RETURNALL;
-
-    if (joyGetPosEx(JOYSTICKID1,&info) != JOYERR_NOERROR) {
-      __glutHasJoystick = 1;
-      joyGetDevCaps(JOYSTICKID1, &joyCaps, sizeof(joyCaps));
-      __glutNumJoystickButtons = joyCaps.wNumButtons;
-      __glutNumJoystickAxes = joyCaps.wNumAxes;
-    } else {
-      __glutHasJoystick = 0;
-      __glutNumJoystickButtons = 0;
-      __glutNumJoystickAxes = 0;
-    }
-  }
-#endif /* !_WIN32 */
-  return 0;
-}
-
-#if !defined(_WIN32)
-static GLUTeventParser eventParser =
-{__glutProcessDeviceEvents, NULL};
-
-static void
-addDeviceEventParser(void)
-{
-  static Bool been_here = False;
-
-  if (been_here)
-    return;
-  been_here = True;
-  __glutRegisterEventParser(&eventParser);
-}
-#endif
-
-static int
-probeDevices(void)
-{
-  static Bool been_here = False;
-  static int support;
-#if !defined(_WIN32)
-  XExtensionVersion *version;
-  XDeviceInfoPtr device_info, device;
-  XAnyClassPtr any;
-  XButtonInfoPtr b;
-  XValuatorInfoPtr v;
-  XAxisInfoPtr a;
-  int num_dev = 0, btns = 0, dials = 0;
-  int i, j, k;
-#endif /* !_WIN32 */
-
-  if (been_here) {
-    return support;
-  }
-  been_here = True;
-
-#if !defined(_WIN32)
-  version = XGetExtensionVersion(__glutDisplay, "XInputExtension");
-  /* Ugh.  XInput extension API forces annoying cast of a pointer
-     to a long so it can be compared with the NoSuchExtension
-     value (#defined to 1). */
-  if (version == NULL || ((long) version) == NoSuchExtension) {
-    support = 0;
-    return support;
-  }
-  XFree(version);
-  device_info = XListInputDevices(__glutDisplay, &num_dev);
-  if (device_info) {
-    for (i = 0; i < num_dev; i++) {
-      /* XXX These are SGI names for these devices;
-         unfortunately, no good standard exists for standard
-         types of X input extension devices. */
-
-      device = &device_info[i];
-      any = (XAnyClassPtr) device->inputclassinfo;
-
-      if (!__glutSpaceball && !strcmp(device->name, "spaceball")) {
-        v = NULL;
-        b = NULL;
-        for (j = 0; j < device->num_classes; j++) {
-#if defined(__cplusplus) || defined(c_plusplus)
-          switch (any->c_class) {
-#else
-          switch (any->class) {
-#endif
-          case ButtonClass:
-            b = (XButtonInfoPtr) any;
-            btns = b->num_buttons;
-            break;
-          case ValuatorClass:
-            v = (XValuatorInfoPtr) any;
-            /* Sanity check: at least 6 valuators? */
-            if (v->num_axes < NUM_SPACEBALL_AXIS)
-              goto skip_device;
-            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
-            for (k = 0; k < NUM_SPACEBALL_AXIS; k++, a++) {
-              __glutSpaceballRange[k].min = a->min_value;
-              __glutSpaceballRange[k].range = a->max_value - a->min_value;
-            }
-            break;
-          }
-          any = (XAnyClassPtr) ((char *) any + any->length);
-        }
-        if (v) {
-          __glutSpaceball = XOpenDevice(__glutDisplay, device->id);
-          if (__glutSpaceball) {
-            __glutNumSpaceballButtons = btns;
-            addDeviceEventParser();
-          }
-        }
-      } else if (!__glutDials && !strcmp(device->name, "dial+buttons")) {
-        v = NULL;
-        b = NULL;
-        for (j = 0; j < device->num_classes; j++) {
-#if defined(__cplusplus) || defined(c_plusplus)
-          switch (any->c_class) {
-#else
-          switch (any->class) {
-#endif
-          case ButtonClass:
-            b = (XButtonInfoPtr) any;
-            btns = b->num_buttons;
-            break;
-          case ValuatorClass:
-            v = (XValuatorInfoPtr) any;
-            /* Sanity check: at least 8 valuators? */
-            if (v->num_axes < NUM_DIALS_AXIS)
-              goto skip_device;
-            dials = v->num_axes;
-            __glutDialsResolution = (int *) malloc(sizeof(int) * dials);
-            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
-            for (k = 0; k < dials; k++, a++) {
-              __glutDialsResolution[k] = a->resolution;
-            }
-            break;
-          }
-          any = (XAnyClassPtr) ((char *) any + any->length);
-        }
-        if (v) {
-          __glutDials = XOpenDevice(__glutDisplay, device->id);
-          if (__glutDials) {
-            __glutNumButtonBoxButtons = btns;
-            __glutNumDials = dials;
-            addDeviceEventParser();
-          }
-        }
-      } else if (!__glutTablet && !strcmp(device->name, "tablet")) {
-        v = NULL;
-        b = NULL;
-        for (j = 0; j < device->num_classes; j++) {
-#if defined(__cplusplus) || defined(c_plusplus)
-          switch (any->c_class) {
-#else
-          switch (any->class) {
-#endif
-          case ButtonClass:
-            b = (XButtonInfoPtr) any;
-            btns = b->num_buttons;
-            break;
-          case ValuatorClass:
-            v = (XValuatorInfoPtr) any;
-            /* Sanity check: exactly 2 valuators? */
-            if (v->num_axes != NUM_TABLET_AXIS)
-              goto skip_device;
-            a = (XAxisInfoPtr) ((char *) v + sizeof(XValuatorInfo));
-            for (k = 0; k < NUM_TABLET_AXIS; k++, a++) {
-              __glutTabletRange[k].min = a->min_value;
-              __glutTabletRange[k].range = a->max_value - a->min_value;
-            }
-            break;
-          }
-          any = (XAnyClassPtr) ((char *) any + any->length);
-        }
-        if (v) {
-          __glutTablet = XOpenDevice(__glutDisplay, device->id);
-          if (__glutTablet) {
-            __glutNumTabletButtons = btns;
-            addDeviceEventParser();
-          }
-        }
-      } else if (!strcmp(device->name, "mouse")) {
-        for (j = 0; j < device->num_classes; j++) {
-#if defined(__cplusplus) || defined(c_plusplus)
-          if (any->c_class == ButtonClass) {
-#else
-          if (any->class == ButtonClass) {
-#endif
-            b = (XButtonInfoPtr) any;
-            __glutNumMouseButtons = b->num_buttons;
-          }
-          any = (XAnyClassPtr) ((char *) any + any->length);
-        }
-      }
-    skip_device:;
-    }
-    XFreeDeviceList(device_info);
-  }
-#else /* _WIN32 */
-  __glutNumMouseButtons = GetSystemMetrics(SM_CMOUSEBUTTONS);
-#endif /* !_WIN32 */
-  /* X Input extension might be supported, but only if there is
-     a tablet, dials, or spaceball do we claim devices are
-     supported. */
-  support = __glutTablet || __glutDials || __glutSpaceball;
-  return support;
-}
-
-void
-__glutUpdateInputDeviceMask(GLUTwindow * window)
-{
-#if !defined(_WIN32)
-  /* 5 (dial and buttons) + 5 (tablet locator and buttons) + 5
-     (Spaceball buttons and axis) = 15 */
-  XEventClass eventList[15];
-  int rc, numEvents;
-
-  rc = probeDevices();
-  if (rc) {
-    numEvents = 0;
-    if (__glutTablet) {
-      if (window->tabletMotion) {
-        DeviceMotionNotify(__glutTablet, __glutDeviceMotionNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->tabletButton) {
-        DeviceButtonPress(__glutTablet, __glutDeviceButtonPress,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonPressGrab(__glutTablet, __glutDeviceButtonPressGrab,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonRelease(__glutTablet, __glutDeviceButtonRelease,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->tabletMotion || window->tabletButton) {
-        DeviceStateNotify(__glutTablet, __glutDeviceStateNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-    }
-    if (__glutDials) {
-      if (window->dials) {
-        DeviceMotionNotify(__glutDials, __glutDeviceMotionNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->buttonBox) {
-        DeviceButtonPress(__glutDials, __glutDeviceButtonPress,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonPressGrab(__glutDials, __glutDeviceButtonPressGrab,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonRelease(__glutDials, __glutDeviceButtonRelease,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->dials || window->buttonBox) {
-        DeviceStateNotify(__glutDials, __glutDeviceStateNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-    }
-    if (__glutSpaceball) {
-      if (window->spaceMotion || window->spaceRotate) {
-        DeviceMotionNotify(__glutSpaceball, __glutDeviceMotionNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->spaceButton) {
-        DeviceButtonPress(__glutSpaceball, __glutDeviceButtonPress,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonPressGrab(__glutSpaceball, __glutDeviceButtonPressGrab,
-          eventList[numEvents]);
-        numEvents++;
-        DeviceButtonRelease(__glutSpaceball, __glutDeviceButtonRelease,
-          eventList[numEvents]);
-        numEvents++;
-      }
-      if (window->spaceMotion || window->spaceRotate || window->spaceButton) {
-        DeviceStateNotify(__glutSpaceball, __glutDeviceStateNotify,
-          eventList[numEvents]);
-        numEvents++;
-      }
-    }
-#if 0
-    if (window->children) {
-      GLUTwindow *child = window->children;
-
-      do {
-        XChangeDeviceDontPropagateList(__glutDisplay, child->win,
-          numEvents, eventList, AddToList);
-        child = child->siblings;
-      } while (child);
-    }
-#endif
-    XSelectExtensionEvent(__glutDisplay, window->win,
-      eventList, numEvents);
-    if (window->overlay) {
-      XSelectExtensionEvent(__glutDisplay, window->overlay->win,
-        eventList, numEvents);
-    }
-  } else {
-    /* X Input extension not supported; no chance for exotic
-       input devices. */
-  }
-#endif /* !_WIN32 */
-}
-
-/* CENTRY */
-int GLUTAPIENTRY
-glutDeviceGet(GLenum param)
-{
-  probeDevices();
-  switch (param) {
-  case GLUT_HAS_KEYBOARD:
-  case GLUT_HAS_MOUSE:
-    /* Assume window system always has mouse and keyboard. */
-    return 1;
-  case GLUT_HAS_SPACEBALL:
-    return __glutSpaceball != NULL;
-  case GLUT_HAS_DIAL_AND_BUTTON_BOX:
-    return __glutDials != NULL;
-  case GLUT_HAS_TABLET:
-    return __glutTablet != NULL;
-  case GLUT_NUM_MOUSE_BUTTONS:
-    return __glutNumMouseButtons;
-  case GLUT_NUM_SPACEBALL_BUTTONS:
-    return __glutNumSpaceballButtons;
-  case GLUT_NUM_BUTTON_BOX_BUTTONS:
-    return __glutNumButtonBoxButtons;
-  case GLUT_NUM_DIALS:
-    return __glutNumDials;
-  case GLUT_NUM_TABLET_BUTTONS:
-    return __glutNumTabletButtons;
-  case GLUT_DEVICE_IGNORE_KEY_REPEAT:
-    return __glutCurrentWindow->ignoreKeyRepeat;
-#ifndef _WIN32
-  case GLUT_DEVICE_KEY_REPEAT:
-    {
-      XKeyboardState state;
-
-      XGetKeyboardControl(__glutDisplay, &state);
-      return state.global_auto_repeat;
-    }
-  case GLUT_JOYSTICK_POLL_RATE:
-    return 0;
-#else
-  case GLUT_DEVICE_KEY_REPEAT:
-    /* Win32 cannot globally disable key repeat. */
-    return GLUT_KEY_REPEAT_ON;
-  case GLUT_JOYSTICK_POLL_RATE:
-    return __glutCurrentWindow->joyPollInterval;
-#endif
-  case GLUT_HAS_JOYSTICK:
-    return __glutHasJoystick;
-  case GLUT_JOYSTICK_BUTTONS:
-    return __glutNumJoystickButtons;
-  case GLUT_JOYSTICK_AXES:
-    return __glutNumJoystickAxes;
-  default:
-    __glutWarning("invalid glutDeviceGet parameter: %d", param);
-    return -1;
-  }
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_joy.c b/src/glut/glx/glut_joy.c
deleted file mode 100644
index 5025607922c..00000000000
--- a/src/glut/glx/glut_joy.c
+++ /dev/null
@@ -1,85 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1997, 1998. */
-
-/* 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. */
-
-#ifdef _WIN32
-#ifdef __MINGW32__
-#include <GL/gl.h>
-#endif
-#include <windows.h>
-#ifndef __CYGWIN32__
-#include <mmsystem.h>  /* Win32 Multimedia API header. */
-#endif
-#endif
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutJoystickFunc(GLUTjoystickCB joystickFunc, int pollInterval)
-{
-#ifdef _WIN32
-  if (joystickFunc && (pollInterval > 0)) {
-    if (__glutCurrentWindow->entryState == WM_SETFOCUS) {
-      MMRESULT result;
-
-      /* Capture joystick focus if current window has
-  	 focus now. */
-      result = joySetCapture(__glutCurrentWindow->win,
-        JOYSTICKID1, 0, TRUE);
-      if (result == JOYERR_NOERROR) {
-        (void) joySetThreshold(JOYSTICKID1, pollInterval);
-      }
-    }
-    __glutCurrentWindow->joyPollInterval = pollInterval;
-  } else {
-    /* Release joystick focus if current window has
-       focus now. */
-    if (__glutCurrentWindow->joystick
-      && (__glutCurrentWindow->joyPollInterval > 0)
-      && (__glutCurrentWindow->entryState == WM_SETFOCUS)) {
-      (void) joyReleaseCapture(JOYSTICKID1);
-    }
-    __glutCurrentWindow->joyPollInterval = 0;
-  }
-  __glutCurrentWindow->joystick = joystickFunc;
-#else
-  /* XXX No support currently for X11 joysticks. */
-#endif
-}
-
-void GLUTAPIENTRY
-glutForceJoystickFunc(void)
-{
-#ifdef _WIN32
-  if (__glutCurrentWindow->joystick) {
-    JOYINFOEX jix;
-    MMRESULT res;
-    int x, y, z;
-
-    /* Poll the joystick. */
-    jix.dwSize = sizeof(jix);
-    jix.dwFlags = JOY_RETURNALL;
-    res = joyGetPosEx(JOYSTICKID1,&jix);
-    if (res == JOYERR_NOERROR) {
-
-      /* Convert to int for scaling. */
-      x = jix.dwXpos;
-      y = jix.dwYpos;
-      z = jix.dwZpos;
-
-#define SCALE(v)  ((int) ((v - 32767)/32.768))
-
-      __glutCurrentWindow->joystick(jix.dwButtons,
-        SCALE(x), SCALE(y), SCALE(z));
-    }
-  }
-#else
-  /* XXX No support currently for X11 joysticks. */
-#endif
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_key.c b/src/glut/glx/glut_key.c
deleted file mode 100644
index 3e1f7e52c1b..00000000000
--- a/src/glut/glx/glut_key.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutKeyboardFunc(GLUTkeyboardCB keyboardFunc)
-{
-  __glutChangeWindowEventMask(KeyPressMask,
-    keyboardFunc != NULL || __glutCurrentWindow->special != NULL);
-  __glutCurrentWindow->keyboard = keyboardFunc;
-}
-
-void GLUTAPIENTRY
-glutSpecialFunc(GLUTspecialCB specialFunc)
-{
-  __glutChangeWindowEventMask(KeyPressMask,
-    specialFunc != NULL || __glutCurrentWindow->keyboard != NULL);
-  __glutCurrentWindow->special = specialFunc;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_keyctrl.c b/src/glut/glx/glut_keyctrl.c
deleted file mode 100644
index c76912e100a..00000000000
--- a/src/glut/glx/glut_keyctrl.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996, 1997. */
-
-/* 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. */
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutIgnoreKeyRepeat(int ignore)
-{
-  __glutCurrentWindow->ignoreKeyRepeat = ignore;
-}
-
-void GLUTAPIENTRY
-glutSetKeyRepeat(int repeatMode)
-{
-#if !defined(_WIN32)
-  XKeyboardControl values;
-
-  /* GLUT's repeatMode #define's match the Xlib API values. */
-  values.auto_repeat_mode = repeatMode;
-  XChangeKeyboardControl(__glutDisplay, KBAutoRepeatMode, &values);
-#endif
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_keyup.c b/src/glut/glx/glut_keyup.c
deleted file mode 100644
index ae97b2f967f..00000000000
--- a/src/glut/glx/glut_keyup.c
+++ /dev/null
@@ -1,29 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutKeyboardUpFunc(GLUTkeyboardCB keyboardUpFunc)
-{
-  __glutChangeWindowEventMask(KeyReleaseMask,
-    keyboardUpFunc != NULL || __glutCurrentWindow->specialUp != NULL);
-  __glutCurrentWindow->keyboardUp = keyboardUpFunc;
-}
-
-void GLUTAPIENTRY
-glutSpecialUpFunc(GLUTspecialCB specialUpFunc)
-{
-  __glutChangeWindowEventMask(KeyReleaseMask,
-    specialUpFunc != NULL || __glutCurrentWindow->keyboardUp != NULL);
-  __glutCurrentWindow->specialUp = specialUpFunc;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_menu.c b/src/glut/glx/glut_menu.c
deleted file mode 100644
index d136823c54f..00000000000
--- a/src/glut/glx/glut_menu.c
+++ /dev/null
@@ -1,1023 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/* 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. */
-
-/* The Win32 GLUT file win32_menu.c completely re-implements all
-   the menuing functionality implemented.  This file is used only by
-   the X Window System version of GLUT. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <assert.h>
-
-#include <unistd.h>
-#include <X11/Xlib.h>
-#include <X11/cursorfont.h>  /* for XC_arrow */
-
-#include "glutint.h"
-#include "layerutil.h"
-
-void (CDECL *__glutMenuStatusFunc) (int, int, int);
-GLUTmenuItem *__glutItemSelected;
-GLUTmenu **__glutMenuList = NULL;
-
-static int menuListSize = 0;
-static XFontStruct *menuFont = NULL;
-static Cursor menuCursor;
-static Colormap menuColormap;
-static Visual *menuVisual;
-static int menuDepth;
-static int fontHeight;
-static GC blackGC, grayGC, whiteGC;
-static unsigned long menuBlack, menuWhite, menuGray;
-static unsigned long useSaveUnders;
-
-/* A replacement for XAllocColor (originally by Brian Paul).
-   This  function should never fail to allocate a color.  When
-   XAllocColor fails, we return the nearest matching color.  If
-   we have to allocate many colors this function isn't a great
-   solution; the XQueryColors() could be done just once.  */
-static void
-noFaultXAllocColor(Display * dpy, Colormap cmap, int cmapSize,
-  XColor * color)
-{
-  XColor *ctable, subColor;
-  int i, bestmatch;
-  double mindist;       /* 3*2^16^2 exceeds 32-bit long int
-                           precision. */
-
-  for (;;) {
-    /* First try just using XAllocColor. */
-    if (XAllocColor(dpy, cmap, color)) {
-      return;
-    }
-
-    /* Retrieve color table entries. */
-    /* XXX alloca canidate. */
-    ctable = (XColor *) malloc(cmapSize * sizeof(XColor));
-    for (i = 0; i < cmapSize; i++)
-      ctable[i].pixel = i;
-    XQueryColors(dpy, cmap, ctable, cmapSize);
-
-    /* Find best match. */
-    bestmatch = -1;
-    mindist = 0.0;
-    for (i = 0; i < cmapSize; i++) {
-      double dr = (double) color->red - (double) ctable[i].red;
-      double dg = (double) color->green - (double) ctable[i].green;
-      double db = (double) color->blue - (double) ctable[i].blue;
-      double dist = dr * dr + dg * dg + db * db;
-      if (bestmatch < 0 || dist < mindist) {
-        bestmatch = i;
-        mindist = dist;
-      }
-    }
-
-    /* Return result. */
-    subColor.red = ctable[bestmatch].red;
-    subColor.green = ctable[bestmatch].green;
-    subColor.blue = ctable[bestmatch].blue;
-    free(ctable);
-    if (XAllocColor(dpy, cmap, &subColor)) {
-      *color = subColor;
-      return;
-    }
-    /* Extremely unlikely, but possibly color was deallocated
-       and reallocated by someone else before we could
-       XAllocColor the color cell we located.  If so, loop
-       again... */
-  }
-}
-
-static int
-ifSunCreator(void)
-{
-  char *xvendor, *glvendor, *renderer;
-  int isSunCreator = 0; /* Until proven that it is. */
-  int savedDisplayMode = 0;
-  char *savedDisplayString = 0;
-  GLUTwindow *window;
-
-#define VENDOR_SUN "Sun Microsystems"
-#define RENDERER_CREATOR "Creator"
-
-  /* Check the X vendor string first.  It is easier to check
-     than the OpenGL vendor and renderer strings since it
-     doesn't require a valid OpenGL rendering context.  Bail
-     early if not connected to a Sun. */
-  xvendor = ServerVendor(__glutDisplay);
-  if (!strncmp(xvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) {
-
-    /* We need a valid current OpenGL rendering context to be
-       able to call glGetString successfully.  If there is not
-       a current window, set up a temporary one just to call
-       glGetString with (gag, expensive). */
-    if (__glutCurrentWindow) {
-      window = NULL;
-    } else {
-      savedDisplayMode = __glutDisplayMode;
-      savedDisplayString = __glutDisplayString;
-      __glutDisplayMode = GLUT_RGB | GLUT_SINGLE;
-      __glutDisplayString = NULL;
-      window = __glutCreateWindow(NULL, 0, 0, 1, 1, 0);
-    }
-
-    glvendor = (char *) glGetString(GL_VENDOR);
-    if (!strncmp(glvendor, VENDOR_SUN, sizeof(VENDOR_SUN) - 1)) {
-      renderer = (char *) glGetString(GL_RENDERER);
-      if (!strncmp(renderer, RENDERER_CREATOR, sizeof(RENDERER_CREATOR) - 1)) {
-        isSunCreator = 1;
-      }
-    }
-    /* Destroy the temporary window for glGetString if one
-       needed to be created. */
-    if (window) {
-      __glutDestroyWindow(window, window);
-      __glutDisplayMode = savedDisplayMode;
-      __glutDisplayString = savedDisplayString;
-    }
-  }
-  return isSunCreator;
-}
-
-static void
-menuVisualSetup(void)
-{
-  XLayerVisualInfo template, *visual, *overlayVisuals;
-  XColor color;
-  Status status;
-  Bool presumablyMesa;
-  int layer, nVisuals, i, dummy;
-  unsigned long *placeHolders = NULL;
-  int numPlaceHolders = 0;
-  Bool allocateHigh;
-
-  allocateHigh = ifSunCreator();
-
-  /* Start with the highest overlay layer and work down.  I
-     don't think any hardware has more than 3 overlay layers. */
-  for (layer = 3; layer > 0; layer--) {
-    template.layer = layer;
-    template.vinfo.screen = __glutScreen;
-    overlayVisuals = __glutXGetLayerVisualInfo(__glutDisplay,
-      VisualScreenMask | VisualLayerMask, &template, &nVisuals);
-    if (overlayVisuals) {
-      /* First, check if the default visual is in this layer.
-         If the default visual is in this layer, we try to use
-         it since it has pre-defined black and white pixels and 
-
-         using the default visual will probably minimize
-         colormap flashing problems. Suggested by Thomas Roell
-         ([email protected]). */
-      for (i = 0; i < nVisuals; i++) {
-        visual = &overlayVisuals[i];
-        if (visual->vinfo.colormap_size >= 3) {
-          /* Compare visual IDs just to be safe. */
-          if (visual->vinfo.visual->visualid == DefaultVisual(__glutDisplay, __glutScreen)->visualid) {
-            /* Settle for default visual. */
-            menuVisual = DefaultVisual(__glutDisplay, __glutScreen);
-            menuDepth = DefaultDepth(__glutDisplay, __glutScreen);
-            menuColormap = DefaultColormap(__glutDisplay, __glutScreen);
-            menuBlack = BlackPixel(__glutDisplay, __glutScreen);
-            menuWhite = WhitePixel(__glutDisplay, __glutScreen);
-            color.red = color.green = color.blue = 0xaa00;
-            noFaultXAllocColor(__glutDisplay, menuColormap,
-              menuVisual->map_entries, &color);
-            menuGray = color.pixel;
-            useSaveUnders = 0;
-            XFree(overlayVisuals);
-            return;
-          }
-        }
-      }
-      for (i = 0; i < nVisuals; i++) {
-        visual = &overlayVisuals[i];
-        if (visual->vinfo.colormap_size >= 3) {
-          if (allocateHigh) {
-            /* For Sun's Creator graphics, try to force the
-               read-only colors to the high end of the colormap
-               by first allocating read-write place-holder cells
-               for all but the last three cells.  This helps
-               avoid colormap flashing problems. */
-            numPlaceHolders = visual->vinfo.colormap_size - 3;
-            if (numPlaceHolders > 0) {
-              placeHolders = (unsigned long *)
-                malloc(numPlaceHolders * sizeof(unsigned long));
-              /* A malloc failure would be harmless. */
-            }
-          }
-          menuColormap = XCreateColormap(__glutDisplay, __glutRoot,
-            visual->vinfo.visual, AllocNone);
-          if (placeHolders) {
-            /* Again for Sun's Creator graphics, do the actual
-               read-write place-holder cell allocation. */
-            status = XAllocColorCells(__glutDisplay, menuColormap, False, 0, 0,
-              placeHolders, numPlaceHolders);
-            if (!status) {
-              XFreeColormap(__glutDisplay, menuColormap);
-              free(placeHolders);
-              placeHolders = NULL;
-              continue;
-            }
-          }
-          /* Allocate overlay colormap cells in defined order:
-             gray, black, white to match the IRIS GL allocation
-             scheme.  Increases likelihood of less overlay
-             colormap flashing. */
-          /* XXX Nice if these 3 AllocColor's could be done in
-             one protocol round-trip. */
-          color.red = color.green = color.blue = 0xaa00;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          menuGray = color.pixel;
-          color.red = color.green = color.blue = 0x0000;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          menuBlack = color.pixel;
-          color.red = color.green = color.blue = 0xffff;
-          status = XAllocColor(__glutDisplay,
-            menuColormap, &color);
-          if (!status) {
-            XFreeColormap(__glutDisplay, menuColormap);
-            if (placeHolders) {
-              free(placeHolders);
-              placeHolders = NULL;
-            }
-            continue;
-          }
-          if (placeHolders) {
-            /* Now free the placeholder cells. */
-            XFreeColors(__glutDisplay, menuColormap,
-              placeHolders, numPlaceHolders, 0);
-            free(placeHolders);
-            placeHolders = NULL;
-          }
-          menuWhite = color.pixel;
-          menuVisual = visual->vinfo.visual;
-          menuDepth = visual->vinfo.depth;
-          /* If using overlays, do not request "save unders". */
-          useSaveUnders = 0;
-          XFree(overlayVisuals);
-          return;
-        }
-      }
-      XFree(overlayVisuals);
-    }
-  }
-  /* Settle for default visual. */
-  menuVisual = DefaultVisual(__glutDisplay, __glutScreen);
-  menuDepth = DefaultDepth(__glutDisplay, __glutScreen);
-  menuColormap = DefaultColormap(__glutDisplay, __glutScreen);
-  menuBlack = BlackPixel(__glutDisplay, __glutScreen);
-  menuWhite = WhitePixel(__glutDisplay, __glutScreen);
-  color.red = color.green = color.blue = 0xaa00;
-  noFaultXAllocColor(__glutDisplay, menuColormap,
-    menuVisual->map_entries, &color);
-  menuGray = color.pixel;
-
-  /* When no overlays are supported, we would like to use X
-     "save unders" to avoid exposes to windows obscured by
-     pop-up menus.  However, OpenGL's direct rendering support
-     means OpenGL interacts poorly with X backing store and
-     save unders.  X servers do not (in implementation
-     practice) redirect OpenGL rendering destined to obscured
-     window regions into backing store.
-
-     Implementation solutions exist for this problem, but they
-     are expensive and high-end OpenGL implementations
-     typically provide fast rendering and/or overlays to
-     obviate the problem associated of user interfaces (pop-up
-     menus) forcing redraws of complex normal plane scenes.
-     (See support for overlays pop-up menus above.)
-
-     Mesa 3D, however, does not support direct rendering.
-     Overlays are often unavailable to Mesa, and Mesa is also
-     relatively slow.  For these reasons, Mesa-rendering GLUT
-     programs can and should use X save unders.
-
-     Look for the GLX extension.  If _not_ supported, we are
-     presumably using Mesa so enable save unders. */
-
-  presumablyMesa = !XQueryExtension(__glutDisplay, "GLX",
-    &dummy, &dummy, &dummy);
-
-  if (presumablyMesa) {
-    useSaveUnders = CWSaveUnder;
-  } else {
-    useSaveUnders = 0;
-  }
-}
-
-static void
-menuSetup(void)
-{
-  if (menuFont) {
-    /* MenuFont overload to indicate menu initalization. */
-    return;
-  }
-  menuFont = XLoadQueryFont(__glutDisplay,
-    "-*-helvetica-bold-o-normal--14-*-*-*-p-*-iso8859-1");
-  if (!menuFont) {
-    /* Try back up font. */
-    menuFont = XLoadQueryFont(__glutDisplay, "fixed");
-  }
-  if (!menuFont) {
-    __glutFatalError("could not load font.");
-  }
-  menuVisualSetup();
-  fontHeight = menuFont->ascent + menuFont->descent;
-  menuCursor = XCreateFontCursor(__glutDisplay, XC_arrow);
-}
-
-static void
-menuGraphicsContextSetup(Window win)
-{
-  XGCValues gcvals;
-
-  if (blackGC != None) {
-    return;
-  }
-  gcvals.font = menuFont->fid;
-  gcvals.foreground = menuBlack;
-  blackGC = XCreateGC(__glutDisplay, win,
-    GCFont | GCForeground, &gcvals);
-  gcvals.foreground = menuGray;
-  grayGC = XCreateGC(__glutDisplay, win, GCForeground, &gcvals);
-  gcvals.foreground = menuWhite;
-  whiteGC = XCreateGC(__glutDisplay, win, GCForeground, &gcvals);
-}
-
-void
-__glutSetMenu(GLUTmenu * menu)
-{
-  __glutCurrentMenu = menu;
-}
-
-static void
-unmapMenu(GLUTmenu * menu)
-{
-  if (menu->cascade) {
-    unmapMenu(menu->cascade);
-    menu->cascade = NULL;
-  }
-  menu->anchor = NULL;
-  menu->highlighted = NULL;
-  XUnmapWindow(__glutDisplay, menu->win);
-}
-
-static void
-finishMenu(Window win, int x, int y)
-{
-  Window dummy;
-  int rc;
-
-  unmapMenu(__glutMappedMenu);
-  XUngrabPointer(__glutDisplay, CurrentTime);
-
-  /* Popping up an overlay popup menu will install its own
-     colormap.  If the window associated with the menu has an
-     overlay, install that window's overlay colormap so the
-     overlay isn't left using the popup menu's colormap. */
-  if (__glutMenuWindow->overlay) {
-    XInstallColormap(__glutDisplay,
-      __glutMenuWindow->overlay->colormap->cmap);
-  }
-
-  /* This XFlush is needed to to make sure the pointer is
-     really ungrabbed when the application's menu callback is
-     called. Otherwise, a deadlock might happen because the
-     application may try to read from an terminal window, but
-     yet the ungrab hasn't really happened since it hasn't been
-     flushed out. */
-  XFlush(__glutDisplay);
-
-  if (__glutMenuStatusFunc) {
-    if (win != __glutMenuWindow->win) {
-      /* The button release may have occurred in a window other
-         than the window requesting the pop-up menu (for
-         example, one of the submenu windows).  In this case, we
-         need to translate the coordinates into the coordinate
-         system of the window associated with the window. */
-      rc = XTranslateCoordinates(__glutDisplay, win, __glutMenuWindow->win,
-        x, y, &x, &y, &dummy);
-      assert(rc != False);  /* Will always be on same screen. */
-    }
-    __glutSetWindow(__glutMenuWindow);
-    __glutSetMenu(__glutMappedMenu);
-
-    /* Setting __glutMappedMenu to NULL permits operations that
-       change menus or destroy the menu window again. */
-    __glutMappedMenu = NULL;
-
-    __glutMenuStatusFunc(GLUT_MENU_NOT_IN_USE, x, y);
-  }
-  /* Setting __glutMappedMenu to NULL permits operations that
-     change menus or destroy the menu window again. */
-  __glutMappedMenu = NULL;
-
-  /* If an item is selected and it is not a submenu trigger,
-     generate menu callback. */
-  if (__glutItemSelected && !__glutItemSelected->isTrigger) {
-    __glutSetWindow(__glutMenuWindow);
-    /* When menu callback is triggered, current menu should be
-       set to the callback menu. */
-    __glutSetMenu(__glutItemSelected->menu);
-    __glutItemSelected->menu->select(
-      __glutItemSelected->value);
-  }
-  __glutMenuWindow = NULL;
-}
-
-#define MENU_BORDER 1
-#define MENU_GAP 2
-#define MENU_ARROW_GAP 6
-#define MENU_ARROW_WIDTH 8
-
-static void
-mapMenu(GLUTmenu * menu, int x, int y)
-{
-  XWindowChanges changes;
-  unsigned int mask;
-  int subMenuExtension, num;
-
-  /* If there are submenus, we need to provide extra space for
-     the submenu pull arrow.  */
-  if (menu->submenus > 0) {
-    subMenuExtension = MENU_ARROW_GAP + MENU_ARROW_WIDTH;
-  } else {
-    subMenuExtension = 0;
-  }
-
-  changes.stack_mode = Above;
-  mask = CWStackMode | CWX | CWY;
-  /* If the menu isn't managed (ie, validated so all the
-     InputOnly subwindows are the right size), do so.  */
-  if (!menu->managed) {
-    GLUTmenuItem *item;
-
-    item = menu->list;
-    num = menu->num;
-    while (item) {
-      XWindowChanges itemupdate;
-
-      itemupdate.y = (num - 1) * fontHeight + MENU_GAP;
-      itemupdate.width = menu->pixwidth;
-      itemupdate.width += subMenuExtension;
-      XConfigureWindow(__glutDisplay, item->win,
-        CWWidth | CWY, &itemupdate);
-      item = item->next;
-      num--;
-    }
-    menu->pixheight = MENU_GAP +
-      fontHeight * menu->num + MENU_GAP;
-    changes.height = menu->pixheight;
-    changes.width = MENU_GAP +
-      menu->pixwidth + subMenuExtension + MENU_GAP;
-    mask |= CWWidth | CWHeight;
-    menu->managed = True;
-  }
-  /* Make sure menu appears fully on screen. */
-  if (y + menu->pixheight >= __glutScreenHeight) {
-    changes.y = __glutScreenHeight - menu->pixheight;
-  } else {
-    changes.y = y;
-  }
-  if (x + menu->pixwidth + subMenuExtension >=
-    __glutScreenWidth) {
-    changes.x = __glutScreenWidth -
-      menu->pixwidth + subMenuExtension;
-  } else {
-    changes.x = x;
-  }
-
-  /* Rember where the menu is placed so submenus can be
-     properly placed relative to it. */
-  menu->x = changes.x;
-  menu->y = changes.y;
-
-  XConfigureWindow(__glutDisplay, menu->win, mask, &changes);
-  XInstallColormap(__glutDisplay, menuColormap);
-  /* XXX The XRaiseWindow below should not be necessary because
-     the XConfigureWindow requests an Above stack mode (same as
-     XRaiseWindow), but some Sun users complained this was still
-     necessary.  Probably some window manager or X server bug on
-     these machines?? */
-  XRaiseWindow(__glutDisplay, menu->win);
-  XMapWindow(__glutDisplay, menu->win);
-}
-
-static void
-startMenu(GLUTmenu * menu, GLUTwindow * window,
-  int x, int y, int x_win, int y_win)
-{
-  int grab;
-
-  assert(__glutMappedMenu == NULL);
-  grab = XGrabPointer(__glutDisplay, __glutRoot, True,
-    ButtonPressMask | ButtonReleaseMask,
-    GrabModeAsync, GrabModeAsync,
-    __glutRoot, menuCursor, CurrentTime);
-  if (grab != GrabSuccess) {
-    /* Somebody else has pointer grabbed, ignore menu
-       activation. */
-    return;
-  }
-  __glutMappedMenu = menu;
-  __glutMenuWindow = window;
-  __glutItemSelected = NULL;
-  if (__glutMenuStatusFunc) {
-    __glutSetMenu(menu);
-    __glutSetWindow(window);
-    __glutMenuStatusFunc(GLUT_MENU_IN_USE, x_win, y_win);
-  }
-  mapMenu(menu, x, y);
-}
-
-static void
-paintSubMenuArrow(Window win, int x, int y)
-{
-  XPoint p[5];
-
-  p[0].x = p[4].x = x;
-  p[0].y = p[4].y = y - menuFont->ascent + 1;
-  p[1].x = p[0].x + MENU_ARROW_WIDTH - 1;
-  p[1].y = p[0].y + (menuFont->ascent / 2) - 1;
-  p[2].x = p[1].x;
-  p[2].y = p[1].y + 1;
-  p[3].x = p[0].x;
-  p[3].y = p[0].y + menuFont->ascent - 2;
-  XFillPolygon(__glutDisplay, win,
-    whiteGC, p, 4, Convex, CoordModeOrigin);
-  XDrawLines(__glutDisplay, win, blackGC, p, 5, CoordModeOrigin);
-}
-
-static void
-paintMenuItem(GLUTmenuItem * item, int num)
-{
-  Window win = item->menu->win;
-  GC gc;
-  int y;
-  int subMenuExtension;
-
-  if (item->menu->submenus > 0) {
-    subMenuExtension = MENU_ARROW_GAP + MENU_ARROW_WIDTH;
-  } else {
-    subMenuExtension = 0;
-  }
-  if (item->menu->highlighted == item) {
-    gc = whiteGC;
-  } else {
-    gc = grayGC;
-  }
-  y = MENU_GAP + fontHeight * num - menuFont->descent;
-  XFillRectangle(__glutDisplay, win, gc,
-    MENU_GAP, y - fontHeight + menuFont->descent,
-    item->menu->pixwidth + subMenuExtension, fontHeight);
-  XDrawString(__glutDisplay, win, blackGC,
-    MENU_GAP, y, item->label, item->len);
-  if (item->isTrigger) {
-    paintSubMenuArrow(win,
-      item->menu->pixwidth + MENU_ARROW_GAP + 1, y);
-  }
-}
-
-static void
-paintMenu(GLUTmenu * menu)
-{
-  GLUTmenuItem *item;
-  int i = menu->num;
-  int y = MENU_GAP + fontHeight * i - menuFont->descent;
-
-  item = menu->list;
-  while (item) {
-    if (item->menu->highlighted == item) {
-      paintMenuItem(item, i);
-    } else {
-      /* Quick render of the menu item; assume background
-         already cleared to gray. */
-      XDrawString(__glutDisplay, menu->win, blackGC,
-        2, y, item->label, item->len);
-      if (item->isTrigger) {
-        paintSubMenuArrow(menu->win,
-          menu->pixwidth + MENU_ARROW_GAP + 1, y);
-      }
-    }
-    i--;
-    y -= fontHeight;
-    item = item->next;
-  }
-}
-
-static GLUTmenuItem *
-getMenuItem(GLUTmenu * menu, Window win, int *which)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  if (menu->searched) {
-    __glutFatalError("submenu infinite loop detected");
-  }
-  menu->searched = True;
-  i = menu->num;
-  item = menu->list;
-  while (item) {
-    if (item->win == win) {
-      *which = i;
-      menu->searched = False;
-      return item;
-    }
-    if (item->isTrigger) {
-      GLUTmenuItem *subitem;
-
-      subitem = __glutGetMenuItem(__glutMenuList[item->value],
-        win, which);
-      if (subitem) {
-        menu->searched = False;
-        return subitem;
-      }
-    }
-    i--;
-    item = item->next;
-  }
-  menu->searched = False;
-  return NULL;
-}
-
-static int
-getMenuItemIndex(GLUTmenuItem * item)
-{
-  int count = 0;
-
-  while (item) {
-    count++;
-    item = item->next;
-  }
-  return count;
-}
-
-static GLUTmenu *
-getMenu(Window win)
-{
-  GLUTmenu *menu;
-
-  menu = __glutMappedMenu;
-  while (menu) {
-    if (win == menu->win) {
-      return menu;
-    }
-    menu = menu->cascade;
-  }
-  return NULL;
-}
-
-static GLUTmenu *
-getMenuByNum(int menunum)
-{
-  if (menunum < 1 || menunum > menuListSize) {
-    return NULL;
-  }
-  return __glutMenuList[menunum - 1];
-}
-
-static int
-getUnusedMenuSlot(void)
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < menuListSize; i++) {
-    if (!__glutMenuList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  menuListSize++;
-  if (__glutMenuList) {
-    __glutMenuList = (GLUTmenu **)
-      realloc(__glutMenuList, menuListSize * sizeof(GLUTmenu *));
-  } else {
-    /* XXX Some realloc's do not correctly perform a malloc
-       when asked to perform a realloc on a NULL pointer,
-       though the ANSI C library spec requires this. */
-    __glutMenuList = (GLUTmenu **) malloc(sizeof(GLUTmenu *));
-  }
-  if (!__glutMenuList) {
-    __glutFatalError("out of memory.");
-  }
-  __glutMenuList[menuListSize - 1] = NULL;
-  return menuListSize - 1;
-}
-
-void
-__glutMenuModificationError(void)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
-  __glutFatalError("menu manipulation not allowed while menus in use.");
-}
-
-
-static void
-menuItemEnterOrLeave(GLUTmenuItem * item,
-  int num, int type)
-{
-  int alreadyUp = 0;
-
-  if (type == EnterNotify) {
-    GLUTmenuItem *prevItem = item->menu->highlighted;
-
-    if (prevItem && prevItem != item) {
-      /* If there's an already higlighted item in this menu
-         that is different from this one (we could be
-         re-entering an item with an already cascaded
-         submenu!), unhighlight the previous item. */
-      item->menu->highlighted = NULL;
-      paintMenuItem(prevItem, getMenuItemIndex(prevItem));
-    }
-    item->menu->highlighted = item;
-    __glutItemSelected = item;
-    if (item->menu->cascade) {
-      if (!item->isTrigger) {
-        /* Entered a menu item that is not a submenu trigger,
-           so pop down the current submenu cascade of this
-           menu.  */
-        unmapMenu(item->menu->cascade);
-        item->menu->cascade = NULL;
-      } else {
-        GLUTmenu *submenu = __glutMenuList[item->value];
-
-        if (submenu->anchor == item) {
-          /* We entered the submenu trigger for the submenu
-             that is already up, so don't take down the
-             submenu.  */
-          alreadyUp = 1;
-        } else {
-          /* Submenu already popped up for some other submenu
-             item of this menu; need to pop down that other
-             submenu cascade.  */
-          unmapMenu(item->menu->cascade);
-          item->menu->cascade = NULL;
-        }
-      }
-    }
-    if (!alreadyUp) {
-      /* Make sure the menu item gets painted with
-         highlighting. */
-      paintMenuItem(item, num);
-    } else {
-      /* If already up, should already be highlighted.  */
-    }
-  } else {
-    /* LeaveNotify: Handle leaving a menu item...  */
-    if (item->menu->cascade &&
-      item->menu->cascade->anchor == item) {
-      /* If there is a submenu casacaded from this item, do not
-         change the highlighting on this item upon leaving. */
-    } else {
-      /* Unhighlight this menu item.  */
-      item->menu->highlighted = NULL;
-      paintMenuItem(item, num);
-    }
-    __glutItemSelected = NULL;
-  }
-  if (item->isTrigger) {
-    if (type == EnterNotify && !alreadyUp) {
-      GLUTmenu *submenu = __glutMenuList[item->value];
-
-      mapMenu(submenu,
-        item->menu->x + item->menu->pixwidth +
-        MENU_ARROW_GAP + MENU_ARROW_WIDTH +
-        MENU_GAP + MENU_BORDER,
-        item->menu->y + fontHeight * (num - 1) + MENU_GAP);
-      item->menu->cascade = submenu;
-      submenu->anchor = item;
-    }
-  }
-}
-
-/* Installs callback functions for use by glut_event.c  The point
-   of this is so that GLUT's menu code only gets linked into
-   GLUT binaries (assuming a static library) if the GLUT menu
-   API is used. */
-static void
-installMenuCallbacks(void)
-{
-  __glutMenuItemEnterOrLeave = menuItemEnterOrLeave;
-  __glutFinishMenu = finishMenu;
-  __glutPaintMenu = paintMenu;
-  __glutStartMenu = startMenu;
-  __glutGetMenuByNum = getMenuByNum;
-  __glutGetMenu = getMenu;
-  __glutGetMenuItem = getMenuItem;
-}
-
-int GLUTAPIENTRY 
-glutCreateMenu(GLUTselectCB selectFunc)
-{
-  XSetWindowAttributes wa;
-  GLUTmenu *menu;
-  int menuid;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  if (!__glutDisplay) {
-    __glutOpenXConnection(NULL);
-  }
-
-  installMenuCallbacks();
-
-  menuid = getUnusedMenuSlot();
-  menu = (GLUTmenu *) malloc(sizeof(GLUTmenu));
-  if (!menu) {
-    __glutFatalError("out of memory.");
-  }
-  menu->id = menuid;
-  menu->num = 0;
-  menu->submenus = 0;
-  menu->managed = False;
-  menu->searched = False;
-  menu->pixwidth = 0;
-  menu->select = selectFunc;
-  menu->list = NULL;
-  menu->cascade = NULL;
-  menu->highlighted = NULL;
-  menu->anchor = NULL;
-  menuSetup();
-  wa.override_redirect = True;
-  wa.background_pixel = menuGray;
-  wa.border_pixel = menuBlack;
-  wa.colormap = menuColormap;
-  wa.event_mask = StructureNotifyMask | ExposureMask |
-    ButtonPressMask | ButtonReleaseMask |
-    EnterWindowMask | LeaveWindowMask;
-  /* Save unders really only enabled if useSaveUnders is set to
-     CWSaveUnder, ie. using Mesa 3D.  See earlier comments. */
-  wa.save_under = True;
-  menu->win = XCreateWindow(__glutDisplay, __glutRoot,
-  /* Real position determined when mapped. */
-    0, 0,
-  /* Real size will be determined when menu is manged. */
-    1, 1,
-    MENU_BORDER, menuDepth, InputOutput, menuVisual,
-    CWOverrideRedirect | CWBackPixel | CWBorderPixel |
-    CWEventMask | CWColormap | useSaveUnders,
-    &wa);
-  menuGraphicsContextSetup(menu->win);
-  __glutMenuList[menuid] = menu;
-  __glutSetMenu(menu);
-  return menuid + 1;
-}
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutGetMenu(void)
-{
-  if (__glutCurrentMenu) {
-    return __glutCurrentMenu->id + 1;
-  } else {
-    return 0;
-  }
-}
-
-void GLUTAPIENTRY 
-glutSetMenu(int menuid)
-{
-  GLUTmenu *menu;
-
-  if (menuid < 1 || menuid > menuListSize) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  menu = __glutMenuList[menuid - 1];
-  if (!menu) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  __glutSetMenu(menu);
-}
-/* ENDCENTRY */
-
-void
-__glutSetMenuItem(GLUTmenuItem * item, const char *label,
-  int value, Bool isTrigger)
-{
-  GLUTmenu *menu;
-
-  menu = item->menu;
-  item->label = __glutStrdup(label);
-  if (!item->label) {
-    __glutFatalError("out of memory.");
-  }
-  item->isTrigger = isTrigger;
-  item->len = (int) strlen(label);
-  item->value = value;
-  item->pixwidth = XTextWidth(menuFont, label, item->len) + 4;
-  if (item->pixwidth > menu->pixwidth) {
-    menu->pixwidth = item->pixwidth;
-  }
-  menu->managed = False;
-}
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutAddMenuEntry(const char *label, int value)
-{
-  XSetWindowAttributes wa;
-  GLUTmenuItem *entry;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!entry) {
-    __glutFatalError("out of memory.");
-  }
-  entry->menu = __glutCurrentMenu;
-  __glutSetMenuItem(entry, label, value, False);
-  wa.event_mask = EnterWindowMask | LeaveWindowMask;
-  entry->win = XCreateWindow(__glutDisplay,
-    __glutCurrentMenu->win, MENU_GAP,
-    __glutCurrentMenu->num * fontHeight + MENU_GAP,  /* x & y */
-    entry->pixwidth, fontHeight,  /* width & height */
-    0, CopyFromParent, InputOnly, CopyFromParent,
-    CWEventMask, &wa);
-  XMapWindow(__glutDisplay, entry->win);
-  __glutCurrentMenu->num++;
-  entry->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = entry;
-}
-
-void GLUTAPIENTRY 
-glutAddSubMenu(const char *label, int menu)
-{
-  XSetWindowAttributes wa;
-  GLUTmenuItem *submenu;
-
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!submenu) {
-    __glutFatalError("out of memory.");
-  }
-  __glutCurrentMenu->submenus++;
-  submenu->menu = __glutCurrentMenu;
-  __glutSetMenuItem(submenu, label, /* base 0 */ menu - 1, True);
-  wa.event_mask = EnterWindowMask | LeaveWindowMask;
-  submenu->win = XCreateWindow(__glutDisplay,
-    __glutCurrentMenu->win, MENU_GAP,
-    __glutCurrentMenu->num * fontHeight + MENU_GAP,  /* x & y */
-    submenu->pixwidth, fontHeight,  /* width & height */
-    0, CopyFromParent, InputOnly, CopyFromParent,
-    CWEventMask, &wa);
-  XMapWindow(__glutDisplay, submenu->win);
-  __glutCurrentMenu->num++;
-  submenu->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = submenu;
-}
-
-void GLUTAPIENTRY 
-glutAttachMenu(int button)
-{
-  /* if button >= GLUT_MAX_MENUS, we'll go out of array bounds below */
-  if (button >= GLUT_MAX_MENUS) {
-    return;
-  }
-  if (__glutMappedMenu) {
-    __glutMenuModificationError();
-  }
-  installMenuCallbacks();
-  if (__glutCurrentWindow->menu[button] < 1) {
-    __glutCurrentWindow->buttonUses++;
-  }
-  __glutChangeWindowEventMask(
-    ButtonPressMask | ButtonReleaseMask, True);
-  __glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_menu2.c b/src/glut/glx/glut_menu2.c
deleted file mode 100644
index 3a66101bc42..00000000000
--- a/src/glut/glx/glut_menu2.c
+++ /dev/null
@@ -1,188 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/* 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. */
-
-/* glut_menu2.c implements the little used GLUT menu calls in
-   a distinct file from glut_menu.c for slim static linking. */
-
-/* The Win32 GLUT file win32_menu.c completely re-implements all
-   the menuing functionality implemented.  This file is used only by
-   the X Window System version of GLUT. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <assert.h>
-
-#include <X11/Xlib.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-/* DEPRICATED, use glutMenuStatusFunc instead. */
-void GLUTAPIENTRY 
-glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
-{
-  __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc;
-}
-
-void GLUTAPIENTRY 
-glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
-{
-  __glutMenuStatusFunc = menuStatusFunc;
-}
-
-void GLUTAPIENTRY 
-glutDestroyMenu(int menunum)
-{
-  GLUTmenu *menu = __glutGetMenuByNum(menunum);
-  GLUTmenuItem *item, *next;
-
-  if (__glutMappedMenu)
-    __glutMenuModificationError();
-  assert(menu->id == menunum - 1);
-  XDestroySubwindows(__glutDisplay, menu->win);
-  XDestroyWindow(__glutDisplay, menu->win);
-  __glutMenuList[menunum - 1] = NULL;
-  /* free all menu entries */
-  item = menu->list;
-  while (item) {
-    assert(item->menu == menu);
-    next = item->next;
-    free(item->label);
-    free(item);
-    item = next;
-  }
-  if (__glutCurrentMenu == menu) {
-    __glutCurrentMenu = NULL;
-  }
-  free(menu);
-}
-
-void GLUTAPIENTRY 
-glutChangeToMenuEntry(int num, const char *label, int value)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  if (__glutMappedMenu)
-    __glutMenuModificationError();
-  i = __glutCurrentMenu->num;
-  item = __glutCurrentMenu->list;
-  while (item) {
-    if (i == num) {
-      if (item->isTrigger) {
-        /* If changing a submenu trigger to a menu entry, we
-           need to account for submenus.  */
-        item->menu->submenus--;
-      }
-      free(item->label);
-      __glutSetMenuItem(item, label, value, False);
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY 
-glutChangeToSubMenu(int num, const char *label, int menu)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  if (__glutMappedMenu)
-    __glutMenuModificationError();
-  i = __glutCurrentMenu->num;
-  item = __glutCurrentMenu->list;
-  while (item) {
-    if (i == num) {
-      if (!item->isTrigger) {
-        /* If changing a menu entry to as submenu trigger, we
-           need to account for submenus.  */
-        item->menu->submenus++;
-      }
-      free(item->label);
-      __glutSetMenuItem(item, label, /* base 0 */ menu - 1, True);
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY 
-glutRemoveMenuItem(int num)
-{
-  GLUTmenuItem *item, **prev, *remaining;
-  int pixwidth, i;
-
-  if (__glutMappedMenu)
-    __glutMenuModificationError();
-  i = __glutCurrentMenu->num;
-  prev = &__glutCurrentMenu->list;
-  item = __glutCurrentMenu->list;
-  /* If menu item is removed, the menu's pixwidth may need to
-     be recomputed. */
-  pixwidth = 1;
-  while (item) {
-    if (i == num) {
-      /* If this menu item's pixwidth is as wide as the menu's
-         pixwidth, removing this menu item will necessitate
-         shrinking the menu's pixwidth. */
-      if (item->pixwidth >= __glutCurrentMenu->pixwidth) {
-        /* Continue recalculating menu pixwidth, first skipping
-           the removed item. */
-        remaining = item->next;
-        while (remaining) {
-          if (remaining->pixwidth > pixwidth) {
-            pixwidth = remaining->pixwidth;
-          }
-          remaining = remaining->next;
-        }
-        __glutCurrentMenu->pixwidth = pixwidth;
-      }
-      __glutCurrentMenu->num--;
-      __glutCurrentMenu->managed = False;
-
-      /* Patch up menu's item list. */
-      *prev = item->next;
-
-      free(item->label);
-      free(item);
-      return;
-    }
-    if (item->pixwidth > pixwidth) {
-      pixwidth = item->pixwidth;
-    }
-    i--;
-    prev = &item->next;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY 
-glutDetachMenu(int button)
-{
-  if (__glutMappedMenu)
-    __glutMenuModificationError();
-  if (__glutCurrentWindow->menu[button] > 0) {
-    __glutCurrentWindow->buttonUses--;
-    __glutChangeWindowEventMask(ButtonPressMask | ButtonReleaseMask,
-      __glutCurrentWindow->buttonUses > 0);
-    __glutCurrentWindow->menu[button] = 0;
-  }
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_mesa.c b/src/glut/glx/glut_mesa.c
deleted file mode 100644
index 7e202fa0786..00000000000
--- a/src/glut/glx/glut_mesa.c
+++ /dev/null
@@ -1,57 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include <string.h>
-#include "glutint.h"
-
-int __glutMesaSwapHackSupport = 0;  /* Not supported until
-                                       proven otherwise. */
-
-/* Use the "Mesa swap hack" if reasonable if and only if
-   MESA_SWAP_HACK is set to something whose first character is
-   not "N" or "n" AND "Brian Paul" is the vendor string AND
-   "Mesa X11"* (or "Mesa" for backward compatibility)  is the
-   renderer string.
-
-   Anyone who modifies Mesa so that glXSwapBuffers does not
-   simply blit the previously rendered back buffer should
-   change either their vendor or renderer string to avoid
-   confusing GLUT. */
-
-void
-__glutDetermineMesaSwapHackSupport(void)
-{
-  static int doneAlready = 0;
-  char *env, *vendor, *renderer;
-
-  if (doneAlready)
-    return;
-  env = getenv("MESA_SWAP_HACK");
-  if (env) {
-    if ((env[0] != 'n') && (env[0] != 'N')) {
-      vendor = (char *) glGetString(GL_VENDOR);
-      renderer = (char *) glGetString(GL_RENDERER);
-
-      /* Old versions of X11 Mesa uses the renderer string
-         "Mesa"; Brian plans to start using "Mesa X11" to
-         distinguish the X version of Mesa from other flavor
-         such as Windows or 3Dfx. */
-
-#define MESA_X11 "Mesa X11"
-
-      /* XXX At some point in the future, eliminate the
-         backward compatibility for the old "Mesa" renderer
-         string. */
-
-      if (!strcmp(vendor, "Brian Paul") && (!strcmp(renderer, "Mesa") ||
-          !strncmp(renderer, MESA_X11, sizeof(MESA_X11) - 1)))
-        __glutMesaSwapHackSupport = 1;
-    }
-  }
-  doneAlready = 1;
-}
diff --git a/src/glut/glx/glut_modifier.c b/src/glut/glx/glut_modifier.c
deleted file mode 100644
index 69fa5aba952..00000000000
--- a/src/glut/glx/glut_modifier.c
+++ /dev/null
@@ -1,31 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-
-/* CENTRY */
-int GLUTAPIENTRY
-glutGetModifiers(void)
-{
-  int modifiers;
-
-  if(__glutModifierMask == (unsigned int) ~0) {
-    __glutWarning(
-      "glutCurrentModifiers: do not call outside core input callback.");
-    return 0;
-  }
-  modifiers = 0;
-  if(__glutModifierMask & (ShiftMask|LockMask))
-    modifiers |= GLUT_ACTIVE_SHIFT;
-  if(__glutModifierMask & ControlMask)
-    modifiers |= GLUT_ACTIVE_CTRL;
-  if(__glutModifierMask & Mod1Mask)
-    modifiers |= GLUT_ACTIVE_ALT;
-  return modifiers;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_mroman.c b/src/glut/glx/glut_mroman.c
deleted file mode 100644
index 08f879a5112..00000000000
--- a/src/glut/glx/glut_mroman.c
+++ /dev/null
@@ -1,2454 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutStrokeMonoRoman XXX
-#include "glutstroke.h"
-#undef glutStrokeMonoRoman
-
-/* char: 33 '!' */
-
-static const CoordRec char33_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 33.3333 },
-};
-
-static const CoordRec char33_stroke1[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char33[] = {
-   { 2, char33_stroke0 },
-   { 5, char33_stroke1 },
-};
-
-/* char: 34 '"' */
-
-static const CoordRec char34_stroke0[] = {
-    { 33.3334, 100 },
-    { 33.3334, 66.6667 },
-};
-
-static const CoordRec char34_stroke1[] = {
-    { 71.4286, 100 },
-    { 71.4286, 66.6667 },
-};
-
-static const StrokeRec char34[] = {
-   { 2, char34_stroke0 },
-   { 2, char34_stroke1 },
-};
-
-/* char: 35 '#' */
-
-static const CoordRec char35_stroke0[] = {
-    { 54.7619, 119.048 },
-    { 21.4286, -33.3333 },
-};
-
-static const CoordRec char35_stroke1[] = {
-    { 83.3334, 119.048 },
-    { 50, -33.3333 },
-};
-
-static const CoordRec char35_stroke2[] = {
-    { 21.4286, 57.1429 },
-    { 88.0952, 57.1429 },
-};
-
-static const CoordRec char35_stroke3[] = {
-    { 16.6667, 28.5714 },
-    { 83.3334, 28.5714 },
-};
-
-static const StrokeRec char35[] = {
-   { 2, char35_stroke0 },
-   { 2, char35_stroke1 },
-   { 2, char35_stroke2 },
-   { 2, char35_stroke3 },
-};
-
-/* char: 36 '$' */
-
-static const CoordRec char36_stroke0[] = {
-    { 42.8571, 119.048 },
-    { 42.8571, -19.0476 },
-};
-
-static const CoordRec char36_stroke1[] = {
-    { 61.9047, 119.048 },
-    { 61.9047, -19.0476 },
-};
-
-static const CoordRec char36_stroke2[] = {
-    { 85.7143, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 19.0476, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 23.8095, 66.6667 },
-    { 28.5714, 61.9048 },
-    { 38.0952, 57.1429 },
-    { 66.6666, 47.619 },
-    { 76.1905, 42.8571 },
-    { 80.9524, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 19.0476, 14.2857 },
-};
-
-static const StrokeRec char36[] = {
-   { 2, char36_stroke0 },
-   { 2, char36_stroke1 },
-   { 20, char36_stroke2 },
-};
-
-/* char: 37 '%' */
-
-static const CoordRec char37_stroke0[] = {
-    { 95.2381, 100 },
-    { 9.5238, 0 },
-};
-
-static const CoordRec char37_stroke1[] = {
-    { 33.3333, 100 },
-    { 42.8571, 90.4762 },
-    { 42.8571, 80.9524 },
-    { 38.0952, 71.4286 },
-    { 28.5714, 66.6667 },
-    { 19.0476, 66.6667 },
-    { 9.5238, 76.1905 },
-    { 9.5238, 85.7143 },
-    { 14.2857, 95.2381 },
-    { 23.8095, 100 },
-    { 33.3333, 100 },
-    { 42.8571, 95.2381 },
-    { 57.1428, 90.4762 },
-    { 71.4286, 90.4762 },
-    { 85.7143, 95.2381 },
-    { 95.2381, 100 },
-};
-
-static const CoordRec char37_stroke2[] = {
-    { 76.1905, 33.3333 },
-    { 66.6667, 28.5714 },
-    { 61.9048, 19.0476 },
-    { 61.9048, 9.5238 },
-    { 71.4286, 0 },
-    { 80.9524, 0 },
-    { 90.4762, 4.7619 },
-    { 95.2381, 14.2857 },
-    { 95.2381, 23.8095 },
-    { 85.7143, 33.3333 },
-    { 76.1905, 33.3333 },
-};
-
-static const StrokeRec char37[] = {
-   { 2, char37_stroke0 },
-   { 16, char37_stroke1 },
-   { 11, char37_stroke2 },
-};
-
-/* char: 38 '&' */
-
-static const CoordRec char38_stroke0[] = {
-    { 100, 57.1429 },
-    { 100, 61.9048 },
-    { 95.2381, 66.6667 },
-    { 90.4762, 66.6667 },
-    { 85.7143, 61.9048 },
-    { 80.9524, 52.381 },
-    { 71.4286, 28.5714 },
-    { 61.9048, 14.2857 },
-    { 52.3809, 4.7619 },
-    { 42.8571, 0 },
-    { 23.8095, 0 },
-    { 14.2857, 4.7619 },
-    { 9.5238, 9.5238 },
-    { 4.7619, 19.0476 },
-    { 4.7619, 28.5714 },
-    { 9.5238, 38.0952 },
-    { 14.2857, 42.8571 },
-    { 47.619, 61.9048 },
-    { 52.3809, 66.6667 },
-    { 57.1429, 76.1905 },
-    { 57.1429, 85.7143 },
-    { 52.3809, 95.2381 },
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 28.5714, 85.7143 },
-    { 28.5714, 76.1905 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 47.619 },
-    { 66.6667, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 85.7143, 0 },
-    { 95.2381, 0 },
-    { 100, 4.7619 },
-    { 100, 9.5238 },
-};
-
-static const StrokeRec char38[] = {
-   { 34, char38_stroke0 },
-};
-
-/* char: 39 ''' */
-
-static const CoordRec char39_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 66.6667 },
-};
-
-static const StrokeRec char39[] = {
-   { 2, char39_stroke0 },
-};
-
-/* char: 40 '(' */
-
-static const CoordRec char40_stroke0[] = {
-    { 69.0476, 119.048 },
-    { 59.5238, 109.524 },
-    { 50, 95.2381 },
-    { 40.4762, 76.1905 },
-    { 35.7143, 52.381 },
-    { 35.7143, 33.3333 },
-    { 40.4762, 9.5238 },
-    { 50, -9.5238 },
-    { 59.5238, -23.8095 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char40[] = {
-   { 10, char40_stroke0 },
-};
-
-/* char: 41 ')' */
-
-static const CoordRec char41_stroke0[] = {
-    { 35.7143, 119.048 },
-    { 45.2381, 109.524 },
-    { 54.7619, 95.2381 },
-    { 64.2857, 76.1905 },
-    { 69.0476, 52.381 },
-    { 69.0476, 33.3333 },
-    { 64.2857, 9.5238 },
-    { 54.7619, -9.5238 },
-    { 45.2381, -23.8095 },
-    { 35.7143, -33.3333 },
-};
-
-static const StrokeRec char41[] = {
-   { 10, char41_stroke0 },
-};
-
-/* char: 42 '*' */
-
-static const CoordRec char42_stroke0[] = {
-    { 52.381, 71.4286 },
-    { 52.381, 14.2857 },
-};
-
-static const CoordRec char42_stroke1[] = {
-    { 28.5715, 57.1429 },
-    { 76.1905, 28.5714 },
-};
-
-static const CoordRec char42_stroke2[] = {
-    { 76.1905, 57.1429 },
-    { 28.5715, 28.5714 },
-};
-
-static const StrokeRec char42[] = {
-   { 2, char42_stroke0 },
-   { 2, char42_stroke1 },
-   { 2, char42_stroke2 },
-};
-
-/* char: 43 '+' */
-
-static const CoordRec char43_stroke0[] = {
-    { 52.3809, 85.7143 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char43_stroke1[] = {
-    { 9.5238, 42.8571 },
-    { 95.2381, 42.8571 },
-};
-
-static const StrokeRec char43[] = {
-   { 2, char43_stroke0 },
-   { 2, char43_stroke1 },
-};
-
-/* char: 44 ',' */
-
-static const CoordRec char44_stroke0[] = {
-    { 57.1429, 4.7619 },
-    { 52.381, 0 },
-    { 47.6191, 4.7619 },
-    { 52.381, 9.5238 },
-    { 57.1429, 4.7619 },
-    { 57.1429, -4.7619 },
-    { 52.381, -14.2857 },
-    { 47.6191, -19.0476 },
-};
-
-static const StrokeRec char44[] = {
-   { 8, char44_stroke0 },
-};
-
-/* char: 45 '-' */
-
-static const CoordRec char45_stroke0[] = {
-    { 9.5238, 42.8571 },
-    { 95.2381, 42.8571 },
-};
-
-static const StrokeRec char45[] = {
-   { 2, char45_stroke0 },
-};
-
-/* char: 46 '.' */
-
-static const CoordRec char46_stroke0[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char46[] = {
-   { 5, char46_stroke0 },
-};
-
-/* char: 47 '/' */
-
-static const CoordRec char47_stroke0[] = {
-    { 19.0476, -14.2857 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char47[] = {
-   { 2, char47_stroke0 },
-};
-
-/* char: 48 '0' */
-
-static const CoordRec char48_stroke0[] = {
-    { 47.619, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 80.9524 },
-    { 19.0476, 57.1429 },
-    { 19.0476, 42.8571 },
-    { 23.8095, 19.0476 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 19.0476 },
-    { 85.7143, 42.8571 },
-    { 85.7143, 57.1429 },
-    { 80.9524, 80.9524 },
-    { 71.4286, 95.2381 },
-    { 57.1428, 100 },
-    { 47.619, 100 },
-};
-
-static const StrokeRec char48[] = {
-   { 17, char48_stroke0 },
-};
-
-/* char: 49 '1' */
-
-static const CoordRec char49_stroke0[] = {
-    { 40.4762, 80.9524 },
-    { 50, 85.7143 },
-    { 64.2857, 100 },
-    { 64.2857, 0 },
-};
-
-static const StrokeRec char49[] = {
-   { 4, char49_stroke0 },
-};
-
-/* char: 50 '2' */
-
-static const CoordRec char50_stroke0[] = {
-    { 23.8095, 76.1905 },
-    { 23.8095, 80.9524 },
-    { 28.5714, 90.4762 },
-    { 33.3333, 95.2381 },
-    { 42.8571, 100 },
-    { 61.9047, 100 },
-    { 71.4286, 95.2381 },
-    { 76.1905, 90.4762 },
-    { 80.9524, 80.9524 },
-    { 80.9524, 71.4286 },
-    { 76.1905, 61.9048 },
-    { 66.6666, 47.619 },
-    { 19.0476, 0 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char50[] = {
-   { 14, char50_stroke0 },
-};
-
-/* char: 51 '3' */
-
-static const CoordRec char51_stroke0[] = {
-    { 28.5714, 100 },
-    { 80.9524, 100 },
-    { 52.3809, 61.9048 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 80.9524, 52.381 },
-    { 85.7143, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 80.9524, 14.2857 },
-    { 71.4286, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-};
-
-static const StrokeRec char51[] = {
-   { 15, char51_stroke0 },
-};
-
-/* char: 52 '4' */
-
-static const CoordRec char52_stroke0[] = {
-    { 64.2857, 100 },
-    { 16.6667, 33.3333 },
-    { 88.0952, 33.3333 },
-};
-
-static const CoordRec char52_stroke1[] = {
-    { 64.2857, 100 },
-    { 64.2857, 0 },
-};
-
-static const StrokeRec char52[] = {
-   { 3, char52_stroke0 },
-   { 2, char52_stroke1 },
-};
-
-/* char: 53 '5' */
-
-static const CoordRec char53_stroke0[] = {
-    { 76.1905, 100 },
-    { 28.5714, 100 },
-    { 23.8095, 57.1429 },
-    { 28.5714, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 71.4286, 61.9048 },
-    { 80.9524, 52.381 },
-    { 85.7143, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 80.9524, 14.2857 },
-    { 71.4286, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-};
-
-static const StrokeRec char53[] = {
-   { 17, char53_stroke0 },
-};
-
-/* char: 54 '6' */
-
-static const CoordRec char54_stroke0[] = {
-    { 78.5714, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 59.5238, 100 },
-    { 50, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 80.9524 },
-    { 21.4286, 57.1429 },
-    { 21.4286, 33.3333 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 50, 0 },
-    { 54.7619, 0 },
-    { 69.0476, 4.7619 },
-    { 78.5714, 14.2857 },
-    { 83.3334, 28.5714 },
-    { 83.3334, 33.3333 },
-    { 78.5714, 47.619 },
-    { 69.0476, 57.1429 },
-    { 54.7619, 61.9048 },
-    { 50, 61.9048 },
-    { 35.7143, 57.1429 },
-    { 26.1905, 47.619 },
-    { 21.4286, 33.3333 },
-};
-
-static const StrokeRec char54[] = {
-   { 23, char54_stroke0 },
-};
-
-/* char: 55 '7' */
-
-static const CoordRec char55_stroke0[] = {
-    { 85.7143, 100 },
-    { 38.0952, 0 },
-};
-
-static const CoordRec char55_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char55[] = {
-   { 2, char55_stroke0 },
-   { 2, char55_stroke1 },
-};
-
-/* char: 56 '8' */
-
-static const CoordRec char56_stroke0[] = {
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 23.8095, 76.1905 },
-    { 28.5714, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 57.1428, 57.1429 },
-    { 71.4286, 52.381 },
-    { 80.9524, 42.8571 },
-    { 85.7143, 33.3333 },
-    { 85.7143, 19.0476 },
-    { 80.9524, 9.5238 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 23.8095, 9.5238 },
-    { 19.0476, 19.0476 },
-    { 19.0476, 33.3333 },
-    { 23.8095, 42.8571 },
-    { 33.3333, 52.381 },
-    { 47.619, 57.1429 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 66.6667 },
-    { 80.9524, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const StrokeRec char56[] = {
-   { 29, char56_stroke0 },
-};
-
-/* char: 57 '9' */
-
-static const CoordRec char57_stroke0[] = {
-    { 83.3334, 66.6667 },
-    { 78.5714, 52.381 },
-    { 69.0476, 42.8571 },
-    { 54.7619, 38.0952 },
-    { 50, 38.0952 },
-    { 35.7143, 42.8571 },
-    { 26.1905, 52.381 },
-    { 21.4286, 66.6667 },
-    { 21.4286, 71.4286 },
-    { 26.1905, 85.7143 },
-    { 35.7143, 95.2381 },
-    { 50, 100 },
-    { 54.7619, 100 },
-    { 69.0476, 95.2381 },
-    { 78.5714, 85.7143 },
-    { 83.3334, 66.6667 },
-    { 83.3334, 42.8571 },
-    { 78.5714, 19.0476 },
-    { 69.0476, 4.7619 },
-    { 54.7619, 0 },
-    { 45.2381, 0 },
-    { 30.9524, 4.7619 },
-    { 26.1905, 14.2857 },
-};
-
-static const StrokeRec char57[] = {
-   { 23, char57_stroke0 },
-};
-
-/* char: 58 ':' */
-
-static const CoordRec char58_stroke0[] = {
-    { 52.381, 66.6667 },
-    { 47.6191, 61.9048 },
-    { 52.381, 57.1429 },
-    { 57.1429, 61.9048 },
-    { 52.381, 66.6667 },
-};
-
-static const CoordRec char58_stroke1[] = {
-    { 52.381, 9.5238 },
-    { 47.6191, 4.7619 },
-    { 52.381, 0 },
-    { 57.1429, 4.7619 },
-    { 52.381, 9.5238 },
-};
-
-static const StrokeRec char58[] = {
-   { 5, char58_stroke0 },
-   { 5, char58_stroke1 },
-};
-
-/* char: 59 ';' */
-
-static const CoordRec char59_stroke0[] = {
-    { 52.381, 66.6667 },
-    { 47.6191, 61.9048 },
-    { 52.381, 57.1429 },
-    { 57.1429, 61.9048 },
-    { 52.381, 66.6667 },
-};
-
-static const CoordRec char59_stroke1[] = {
-    { 57.1429, 4.7619 },
-    { 52.381, 0 },
-    { 47.6191, 4.7619 },
-    { 52.381, 9.5238 },
-    { 57.1429, 4.7619 },
-    { 57.1429, -4.7619 },
-    { 52.381, -14.2857 },
-    { 47.6191, -19.0476 },
-};
-
-static const StrokeRec char59[] = {
-   { 5, char59_stroke0 },
-   { 8, char59_stroke1 },
-};
-
-/* char: 60 '<' */
-
-static const CoordRec char60_stroke0[] = {
-    { 90.4762, 85.7143 },
-    { 14.2857, 42.8571 },
-    { 90.4762, 0 },
-};
-
-static const StrokeRec char60[] = {
-   { 3, char60_stroke0 },
-};
-
-/* char: 61 '=' */
-
-static const CoordRec char61_stroke0[] = {
-    { 9.5238, 57.1429 },
-    { 95.2381, 57.1429 },
-};
-
-static const CoordRec char61_stroke1[] = {
-    { 9.5238, 28.5714 },
-    { 95.2381, 28.5714 },
-};
-
-static const StrokeRec char61[] = {
-   { 2, char61_stroke0 },
-   { 2, char61_stroke1 },
-};
-
-/* char: 62 '>' */
-
-static const CoordRec char62_stroke0[] = {
-    { 14.2857, 85.7143 },
-    { 90.4762, 42.8571 },
-    { 14.2857, 0 },
-};
-
-static const StrokeRec char62[] = {
-   { 3, char62_stroke0 },
-};
-
-/* char: 63 '?' */
-
-static const CoordRec char63_stroke0[] = {
-    { 23.8095, 76.1905 },
-    { 23.8095, 80.9524 },
-    { 28.5714, 90.4762 },
-    { 33.3333, 95.2381 },
-    { 42.8571, 100 },
-    { 61.9047, 100 },
-    { 71.4285, 95.2381 },
-    { 76.1905, 90.4762 },
-    { 80.9524, 80.9524 },
-    { 80.9524, 71.4286 },
-    { 76.1905, 61.9048 },
-    { 71.4285, 57.1429 },
-    { 52.3809, 47.619 },
-    { 52.3809, 33.3333 },
-};
-
-static const CoordRec char63_stroke1[] = {
-    { 52.3809, 9.5238 },
-    { 47.619, 4.7619 },
-    { 52.3809, 0 },
-    { 57.1428, 4.7619 },
-    { 52.3809, 9.5238 },
-};
-
-static const StrokeRec char63[] = {
-   { 14, char63_stroke0 },
-   { 5, char63_stroke1 },
-};
-
-/* char: 64 '@' */
-
-static const CoordRec char64_stroke0[] = {
-    { 64.2857, 52.381 },
-    { 54.7619, 57.1429 },
-    { 45.2381, 57.1429 },
-    { 40.4762, 47.619 },
-    { 40.4762, 42.8571 },
-    { 45.2381, 33.3333 },
-    { 54.7619, 33.3333 },
-    { 64.2857, 38.0952 },
-};
-
-static const CoordRec char64_stroke1[] = {
-    { 64.2857, 57.1429 },
-    { 64.2857, 38.0952 },
-    { 69.0476, 33.3333 },
-    { 78.5714, 33.3333 },
-    { 83.3334, 42.8571 },
-    { 83.3334, 47.619 },
-    { 78.5714, 61.9048 },
-    { 69.0476, 71.4286 },
-    { 54.7619, 76.1905 },
-    { 50, 76.1905 },
-    { 35.7143, 71.4286 },
-    { 26.1905, 61.9048 },
-    { 21.4286, 47.619 },
-    { 21.4286, 42.8571 },
-    { 26.1905, 28.5714 },
-    { 35.7143, 19.0476 },
-    { 50, 14.2857 },
-    { 54.7619, 14.2857 },
-    { 69.0476, 19.0476 },
-};
-
-static const StrokeRec char64[] = {
-   { 8, char64_stroke0 },
-   { 19, char64_stroke1 },
-};
-
-/* char: 65 'A' */
-
-static const CoordRec char65_stroke0[] = {
-    { 52.3809, 100 },
-    { 14.2857, 0 },
-};
-
-static const CoordRec char65_stroke1[] = {
-    { 52.3809, 100 },
-    { 90.4762, 0 },
-};
-
-static const CoordRec char65_stroke2[] = {
-    { 28.5714, 33.3333 },
-    { 76.1905, 33.3333 },
-};
-
-static const StrokeRec char65[] = {
-   { 2, char65_stroke0 },
-   { 2, char65_stroke1 },
-   { 2, char65_stroke2 },
-};
-
-/* char: 66 'B' */
-
-static const CoordRec char66_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char66_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 71.4286 },
-    { 80.9524, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 61.9047, 52.381 },
-};
-
-static const CoordRec char66_stroke2[] = {
-    { 19.0476, 52.381 },
-    { 61.9047, 52.381 },
-    { 76.1905, 47.619 },
-    { 80.9524, 42.8571 },
-    { 85.7143, 33.3333 },
-    { 85.7143, 19.0476 },
-    { 80.9524, 9.5238 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char66[] = {
-   { 2, char66_stroke0 },
-   { 9, char66_stroke1 },
-   { 10, char66_stroke2 },
-};
-
-/* char: 67 'C' */
-
-static const CoordRec char67_stroke0[] = {
-    { 88.0952, 76.1905 },
-    { 83.3334, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 64.2857, 100 },
-    { 45.2381, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 85.7143 },
-    { 21.4286, 76.1905 },
-    { 16.6667, 61.9048 },
-    { 16.6667, 38.0952 },
-    { 21.4286, 23.8095 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 64.2857, 0 },
-    { 73.8096, 4.7619 },
-    { 83.3334, 14.2857 },
-    { 88.0952, 23.8095 },
-};
-
-static const StrokeRec char67[] = {
-   { 18, char67_stroke0 },
-};
-
-/* char: 68 'D' */
-
-static const CoordRec char68_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char68_stroke1[] = {
-    { 19.0476, 100 },
-    { 52.3809, 100 },
-    { 66.6666, 95.2381 },
-    { 76.1905, 85.7143 },
-    { 80.9524, 76.1905 },
-    { 85.7143, 61.9048 },
-    { 85.7143, 38.0952 },
-    { 80.9524, 23.8095 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 52.3809, 0 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char68[] = {
-   { 2, char68_stroke0 },
-   { 12, char68_stroke1 },
-};
-
-/* char: 69 'E' */
-
-static const CoordRec char69_stroke0[] = {
-    { 21.4286, 100 },
-    { 21.4286, 0 },
-};
-
-static const CoordRec char69_stroke1[] = {
-    { 21.4286, 100 },
-    { 83.3334, 100 },
-};
-
-static const CoordRec char69_stroke2[] = {
-    { 21.4286, 52.381 },
-    { 59.5238, 52.381 },
-};
-
-static const CoordRec char69_stroke3[] = {
-    { 21.4286, 0 },
-    { 83.3334, 0 },
-};
-
-static const StrokeRec char69[] = {
-   { 2, char69_stroke0 },
-   { 2, char69_stroke1 },
-   { 2, char69_stroke2 },
-   { 2, char69_stroke3 },
-};
-
-/* char: 70 'F' */
-
-static const CoordRec char70_stroke0[] = {
-    { 21.4286, 100 },
-    { 21.4286, 0 },
-};
-
-static const CoordRec char70_stroke1[] = {
-    { 21.4286, 100 },
-    { 83.3334, 100 },
-};
-
-static const CoordRec char70_stroke2[] = {
-    { 21.4286, 52.381 },
-    { 59.5238, 52.381 },
-};
-
-static const StrokeRec char70[] = {
-   { 2, char70_stroke0 },
-   { 2, char70_stroke1 },
-   { 2, char70_stroke2 },
-};
-
-/* char: 71 'G' */
-
-static const CoordRec char71_stroke0[] = {
-    { 88.0952, 76.1905 },
-    { 83.3334, 85.7143 },
-    { 73.8096, 95.2381 },
-    { 64.2857, 100 },
-    { 45.2381, 100 },
-    { 35.7143, 95.2381 },
-    { 26.1905, 85.7143 },
-    { 21.4286, 76.1905 },
-    { 16.6667, 61.9048 },
-    { 16.6667, 38.0952 },
-    { 21.4286, 23.8095 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 64.2857, 0 },
-    { 73.8096, 4.7619 },
-    { 83.3334, 14.2857 },
-    { 88.0952, 23.8095 },
-    { 88.0952, 38.0952 },
-};
-
-static const CoordRec char71_stroke1[] = {
-    { 64.2857, 38.0952 },
-    { 88.0952, 38.0952 },
-};
-
-static const StrokeRec char71[] = {
-   { 19, char71_stroke0 },
-   { 2, char71_stroke1 },
-};
-
-/* char: 72 'H' */
-
-static const CoordRec char72_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char72_stroke1[] = {
-    { 85.7143, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char72_stroke2[] = {
-    { 19.0476, 52.381 },
-    { 85.7143, 52.381 },
-};
-
-static const StrokeRec char72[] = {
-   { 2, char72_stroke0 },
-   { 2, char72_stroke1 },
-   { 2, char72_stroke2 },
-};
-
-/* char: 73 'I' */
-
-static const CoordRec char73_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char73[] = {
-   { 2, char73_stroke0 },
-};
-
-/* char: 74 'J' */
-
-static const CoordRec char74_stroke0[] = {
-    { 76.1905, 100 },
-    { 76.1905, 23.8095 },
-    { 71.4286, 9.5238 },
-    { 66.6667, 4.7619 },
-    { 57.1429, 0 },
-    { 47.6191, 0 },
-    { 38.0953, 4.7619 },
-    { 33.3334, 9.5238 },
-    { 28.5715, 23.8095 },
-    { 28.5715, 33.3333 },
-};
-
-static const StrokeRec char74[] = {
-   { 10, char74_stroke0 },
-};
-
-/* char: 75 'K' */
-
-static const CoordRec char75_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char75_stroke1[] = {
-    { 85.7143, 100 },
-    { 19.0476, 33.3333 },
-};
-
-static const CoordRec char75_stroke2[] = {
-    { 42.8571, 57.1429 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char75[] = {
-   { 2, char75_stroke0 },
-   { 2, char75_stroke1 },
-   { 2, char75_stroke2 },
-};
-
-/* char: 76 'L' */
-
-static const CoordRec char76_stroke0[] = {
-    { 23.8095, 100 },
-    { 23.8095, 0 },
-};
-
-static const CoordRec char76_stroke1[] = {
-    { 23.8095, 0 },
-    { 80.9524, 0 },
-};
-
-static const StrokeRec char76[] = {
-   { 2, char76_stroke0 },
-   { 2, char76_stroke1 },
-};
-
-/* char: 77 'M' */
-
-static const CoordRec char77_stroke0[] = {
-    { 14.2857, 100 },
-    { 14.2857, 0 },
-};
-
-static const CoordRec char77_stroke1[] = {
-    { 14.2857, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char77_stroke2[] = {
-    { 90.4762, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char77_stroke3[] = {
-    { 90.4762, 100 },
-    { 90.4762, 0 },
-};
-
-static const StrokeRec char77[] = {
-   { 2, char77_stroke0 },
-   { 2, char77_stroke1 },
-   { 2, char77_stroke2 },
-   { 2, char77_stroke3 },
-};
-
-/* char: 78 'N' */
-
-static const CoordRec char78_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char78_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char78_stroke2[] = {
-    { 85.7143, 100 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char78[] = {
-   { 2, char78_stroke0 },
-   { 2, char78_stroke1 },
-   { 2, char78_stroke2 },
-};
-
-/* char: 79 'O' */
-
-static const CoordRec char79_stroke0[] = {
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 14.2857, 61.9048 },
-    { 14.2857, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 42.8571, 0 },
-    { 61.9047, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 23.8095 },
-    { 90.4762, 38.0952 },
-    { 90.4762, 61.9048 },
-    { 85.7143, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 71.4286, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const StrokeRec char79[] = {
-   { 21, char79_stroke0 },
-};
-
-/* char: 80 'P' */
-
-static const CoordRec char80_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char80_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 66.6667 },
-    { 80.9524, 57.1429 },
-    { 76.1905, 52.381 },
-    { 61.9047, 47.619 },
-    { 19.0476, 47.619 },
-};
-
-static const StrokeRec char80[] = {
-   { 2, char80_stroke0 },
-   { 10, char80_stroke1 },
-};
-
-/* char: 81 'Q' */
-
-static const CoordRec char81_stroke0[] = {
-    { 42.8571, 100 },
-    { 33.3333, 95.2381 },
-    { 23.8095, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 14.2857, 61.9048 },
-    { 14.2857, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 42.8571, 0 },
-    { 61.9047, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 23.8095 },
-    { 90.4762, 38.0952 },
-    { 90.4762, 61.9048 },
-    { 85.7143, 76.1905 },
-    { 80.9524, 85.7143 },
-    { 71.4286, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-};
-
-static const CoordRec char81_stroke1[] = {
-    { 57.1428, 19.0476 },
-    { 85.7143, -9.5238 },
-};
-
-static const StrokeRec char81[] = {
-   { 21, char81_stroke0 },
-   { 2, char81_stroke1 },
-};
-
-/* char: 82 'R' */
-
-static const CoordRec char82_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char82_stroke1[] = {
-    { 19.0476, 100 },
-    { 61.9047, 100 },
-    { 76.1905, 95.2381 },
-    { 80.9524, 90.4762 },
-    { 85.7143, 80.9524 },
-    { 85.7143, 71.4286 },
-    { 80.9524, 61.9048 },
-    { 76.1905, 57.1429 },
-    { 61.9047, 52.381 },
-    { 19.0476, 52.381 },
-};
-
-static const CoordRec char82_stroke2[] = {
-    { 52.3809, 52.381 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char82[] = {
-   { 2, char82_stroke0 },
-   { 10, char82_stroke1 },
-   { 2, char82_stroke2 },
-};
-
-/* char: 83 'S' */
-
-static const CoordRec char83_stroke0[] = {
-    { 85.7143, 85.7143 },
-    { 76.1905, 95.2381 },
-    { 61.9047, 100 },
-    { 42.8571, 100 },
-    { 28.5714, 95.2381 },
-    { 19.0476, 85.7143 },
-    { 19.0476, 76.1905 },
-    { 23.8095, 66.6667 },
-    { 28.5714, 61.9048 },
-    { 38.0952, 57.1429 },
-    { 66.6666, 47.619 },
-    { 76.1905, 42.8571 },
-    { 80.9524, 38.0952 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 14.2857 },
-    { 76.1905, 4.7619 },
-    { 61.9047, 0 },
-    { 42.8571, 0 },
-    { 28.5714, 4.7619 },
-    { 19.0476, 14.2857 },
-};
-
-static const StrokeRec char83[] = {
-   { 20, char83_stroke0 },
-};
-
-/* char: 84 'T' */
-
-static const CoordRec char84_stroke0[] = {
-    { 52.3809, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char84_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char84[] = {
-   { 2, char84_stroke0 },
-   { 2, char84_stroke1 },
-};
-
-/* char: 85 'U' */
-
-static const CoordRec char85_stroke0[] = {
-    { 19.0476, 100 },
-    { 19.0476, 28.5714 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 100 },
-};
-
-static const StrokeRec char85[] = {
-   { 10, char85_stroke0 },
-};
-
-/* char: 86 'V' */
-
-static const CoordRec char86_stroke0[] = {
-    { 14.2857, 100 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char86_stroke1[] = {
-    { 90.4762, 100 },
-    { 52.3809, 0 },
-};
-
-static const StrokeRec char86[] = {
-   { 2, char86_stroke0 },
-   { 2, char86_stroke1 },
-};
-
-/* char: 87 'W' */
-
-static const CoordRec char87_stroke0[] = {
-    { 4.7619, 100 },
-    { 28.5714, 0 },
-};
-
-static const CoordRec char87_stroke1[] = {
-    { 52.3809, 100 },
-    { 28.5714, 0 },
-};
-
-static const CoordRec char87_stroke2[] = {
-    { 52.3809, 100 },
-    { 76.1905, 0 },
-};
-
-static const CoordRec char87_stroke3[] = {
-    { 100, 100 },
-    { 76.1905, 0 },
-};
-
-static const StrokeRec char87[] = {
-   { 2, char87_stroke0 },
-   { 2, char87_stroke1 },
-   { 2, char87_stroke2 },
-   { 2, char87_stroke3 },
-};
-
-/* char: 88 'X' */
-
-static const CoordRec char88_stroke0[] = {
-    { 19.0476, 100 },
-    { 85.7143, 0 },
-};
-
-static const CoordRec char88_stroke1[] = {
-    { 85.7143, 100 },
-    { 19.0476, 0 },
-};
-
-static const StrokeRec char88[] = {
-   { 2, char88_stroke0 },
-   { 2, char88_stroke1 },
-};
-
-/* char: 89 'Y' */
-
-static const CoordRec char89_stroke0[] = {
-    { 14.2857, 100 },
-    { 52.3809, 52.381 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char89_stroke1[] = {
-    { 90.4762, 100 },
-    { 52.3809, 52.381 },
-};
-
-static const StrokeRec char89[] = {
-   { 3, char89_stroke0 },
-   { 2, char89_stroke1 },
-};
-
-/* char: 90 'Z' */
-
-static const CoordRec char90_stroke0[] = {
-    { 85.7143, 100 },
-    { 19.0476, 0 },
-};
-
-static const CoordRec char90_stroke1[] = {
-    { 19.0476, 100 },
-    { 85.7143, 100 },
-};
-
-static const CoordRec char90_stroke2[] = {
-    { 19.0476, 0 },
-    { 85.7143, 0 },
-};
-
-static const StrokeRec char90[] = {
-   { 2, char90_stroke0 },
-   { 2, char90_stroke1 },
-   { 2, char90_stroke2 },
-};
-
-/* char: 91 '[' */
-
-static const CoordRec char91_stroke0[] = {
-    { 35.7143, 119.048 },
-    { 35.7143, -33.3333 },
-};
-
-static const CoordRec char91_stroke1[] = {
-    { 40.4762, 119.048 },
-    { 40.4762, -33.3333 },
-};
-
-static const CoordRec char91_stroke2[] = {
-    { 35.7143, 119.048 },
-    { 69.0476, 119.048 },
-};
-
-static const CoordRec char91_stroke3[] = {
-    { 35.7143, -33.3333 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char91[] = {
-   { 2, char91_stroke0 },
-   { 2, char91_stroke1 },
-   { 2, char91_stroke2 },
-   { 2, char91_stroke3 },
-};
-
-/* char: 92 '\' */
-
-static const CoordRec char92_stroke0[] = {
-    { 19.0476, 100 },
-    { 85.7143, -14.2857 },
-};
-
-static const StrokeRec char92[] = {
-   { 2, char92_stroke0 },
-};
-
-/* char: 93 ']' */
-
-static const CoordRec char93_stroke0[] = {
-    { 64.2857, 119.048 },
-    { 64.2857, -33.3333 },
-};
-
-static const CoordRec char93_stroke1[] = {
-    { 69.0476, 119.048 },
-    { 69.0476, -33.3333 },
-};
-
-static const CoordRec char93_stroke2[] = {
-    { 35.7143, 119.048 },
-    { 69.0476, 119.048 },
-};
-
-static const CoordRec char93_stroke3[] = {
-    { 35.7143, -33.3333 },
-    { 69.0476, -33.3333 },
-};
-
-static const StrokeRec char93[] = {
-   { 2, char93_stroke0 },
-   { 2, char93_stroke1 },
-   { 2, char93_stroke2 },
-   { 2, char93_stroke3 },
-};
-
-/* char: 94 '^' */
-
-static const CoordRec char94_stroke0[] = {
-    { 52.3809, 109.524 },
-    { 14.2857, 42.8571 },
-};
-
-static const CoordRec char94_stroke1[] = {
-    { 52.3809, 109.524 },
-    { 90.4762, 42.8571 },
-};
-
-static const StrokeRec char94[] = {
-   { 2, char94_stroke0 },
-   { 2, char94_stroke1 },
-};
-
-/* char: 95 '_' */
-
-static const CoordRec char95_stroke0[] = {
-    { 0, -33.3333 },
-    { 104.762, -33.3333 },
-    { 104.762, -28.5714 },
-    { 0, -28.5714 },
-    { 0, -33.3333 },
-};
-
-static const StrokeRec char95[] = {
-   { 5, char95_stroke0 },
-};
-
-/* char: 96 '`' */
-
-static const CoordRec char96_stroke0[] = {
-    { 42.8572, 100 },
-    { 66.6667, 71.4286 },
-};
-
-static const CoordRec char96_stroke1[] = {
-    { 42.8572, 100 },
-    { 38.0953, 95.2381 },
-    { 66.6667, 71.4286 },
-};
-
-static const StrokeRec char96[] = {
-   { 2, char96_stroke0 },
-   { 3, char96_stroke1 },
-};
-
-/* char: 97 'a' */
-
-static const CoordRec char97_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, 0 },
-};
-
-static const CoordRec char97_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char97[] = {
-   { 2, char97_stroke0 },
-   { 14, char97_stroke1 },
-};
-
-/* char: 98 'b' */
-
-static const CoordRec char98_stroke0[] = {
-    { 23.8095, 100 },
-    { 23.8095, 0 },
-};
-
-static const CoordRec char98_stroke1[] = {
-    { 23.8095, 52.381 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 52.381 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 28.5714 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 33.3333, 4.7619 },
-    { 23.8095, 14.2857 },
-};
-
-static const StrokeRec char98[] = {
-   { 2, char98_stroke0 },
-   { 14, char98_stroke1 },
-};
-
-/* char: 99 'c' */
-
-static const CoordRec char99_stroke0[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char99[] = {
-   { 14, char99_stroke0 },
-};
-
-/* char: 100 'd' */
-
-static const CoordRec char100_stroke0[] = {
-    { 80.9524, 100 },
-    { 80.9524, 0 },
-};
-
-static const CoordRec char100_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char100[] = {
-   { 2, char100_stroke0 },
-   { 14, char100_stroke1 },
-};
-
-/* char: 101 'e' */
-
-static const CoordRec char101_stroke0[] = {
-    { 23.8095, 38.0952 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 47.619 },
-    { 76.1905, 57.1429 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char101[] = {
-   { 17, char101_stroke0 },
-};
-
-/* char: 102 'f' */
-
-static const CoordRec char102_stroke0[] = {
-    { 71.4286, 100 },
-    { 61.9048, 100 },
-    { 52.381, 95.2381 },
-    { 47.6191, 80.9524 },
-    { 47.6191, 0 },
-};
-
-static const CoordRec char102_stroke1[] = {
-    { 33.3334, 66.6667 },
-    { 66.6667, 66.6667 },
-};
-
-static const StrokeRec char102[] = {
-   { 5, char102_stroke0 },
-   { 2, char102_stroke1 },
-};
-
-/* char: 103 'g' */
-
-static const CoordRec char103_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, -9.5238 },
-    { 76.1905, -23.8095 },
-    { 71.4285, -28.5714 },
-    { 61.9047, -33.3333 },
-    { 47.619, -33.3333 },
-    { 38.0952, -28.5714 },
-};
-
-static const CoordRec char103_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char103[] = {
-   { 7, char103_stroke0 },
-   { 14, char103_stroke1 },
-};
-
-/* char: 104 'h' */
-
-static const CoordRec char104_stroke0[] = {
-    { 26.1905, 100 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char104_stroke1[] = {
-    { 26.1905, 47.619 },
-    { 40.4762, 61.9048 },
-    { 50, 66.6667 },
-    { 64.2857, 66.6667 },
-    { 73.8095, 61.9048 },
-    { 78.5715, 47.619 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char104[] = {
-   { 2, char104_stroke0 },
-   { 7, char104_stroke1 },
-};
-
-/* char: 105 'i' */
-
-static const CoordRec char105_stroke0[] = {
-    { 47.6191, 100 },
-    { 52.381, 95.2381 },
-    { 57.1429, 100 },
-    { 52.381, 104.762 },
-    { 47.6191, 100 },
-};
-
-static const CoordRec char105_stroke1[] = {
-    { 52.381, 66.6667 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char105[] = {
-   { 5, char105_stroke0 },
-   { 2, char105_stroke1 },
-};
-
-/* char: 106 'j' */
-
-static const CoordRec char106_stroke0[] = {
-    { 57.1429, 100 },
-    { 61.9048, 95.2381 },
-    { 66.6667, 100 },
-    { 61.9048, 104.762 },
-    { 57.1429, 100 },
-};
-
-static const CoordRec char106_stroke1[] = {
-    { 61.9048, 66.6667 },
-    { 61.9048, -14.2857 },
-    { 57.1429, -28.5714 },
-    { 47.6191, -33.3333 },
-    { 38.0953, -33.3333 },
-};
-
-static const StrokeRec char106[] = {
-   { 5, char106_stroke0 },
-   { 5, char106_stroke1 },
-};
-
-/* char: 107 'k' */
-
-static const CoordRec char107_stroke0[] = {
-    { 26.1905, 100 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char107_stroke1[] = {
-    { 73.8095, 66.6667 },
-    { 26.1905, 19.0476 },
-};
-
-static const CoordRec char107_stroke2[] = {
-    { 45.2381, 38.0952 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char107[] = {
-   { 2, char107_stroke0 },
-   { 2, char107_stroke1 },
-   { 2, char107_stroke2 },
-};
-
-/* char: 108 'l' */
-
-static const CoordRec char108_stroke0[] = {
-    { 52.381, 100 },
-    { 52.381, 0 },
-};
-
-static const StrokeRec char108[] = {
-   { 2, char108_stroke0 },
-};
-
-/* char: 109 'm' */
-
-static const CoordRec char109_stroke0[] = {
-    { 0, 66.6667 },
-    { 0, 0 },
-};
-
-static const CoordRec char109_stroke1[] = {
-    { 0, 47.619 },
-    { 14.2857, 61.9048 },
-    { 23.8095, 66.6667 },
-    { 38.0952, 66.6667 },
-    { 47.619, 61.9048 },
-    { 52.381, 47.619 },
-    { 52.381, 0 },
-};
-
-static const CoordRec char109_stroke2[] = {
-    { 52.381, 47.619 },
-    { 66.6667, 61.9048 },
-    { 76.1905, 66.6667 },
-    { 90.4762, 66.6667 },
-    { 100, 61.9048 },
-    { 104.762, 47.619 },
-    { 104.762, 0 },
-};
-
-static const StrokeRec char109[] = {
-   { 2, char109_stroke0 },
-   { 7, char109_stroke1 },
-   { 7, char109_stroke2 },
-};
-
-/* char: 110 'n' */
-
-static const CoordRec char110_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char110_stroke1[] = {
-    { 26.1905, 47.619 },
-    { 40.4762, 61.9048 },
-    { 50, 66.6667 },
-    { 64.2857, 66.6667 },
-    { 73.8095, 61.9048 },
-    { 78.5715, 47.619 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char110[] = {
-   { 2, char110_stroke0 },
-   { 7, char110_stroke1 },
-};
-
-/* char: 111 'o' */
-
-static const CoordRec char111_stroke0[] = {
-    { 45.2381, 66.6667 },
-    { 35.7143, 61.9048 },
-    { 26.1905, 52.381 },
-    { 21.4286, 38.0952 },
-    { 21.4286, 28.5714 },
-    { 26.1905, 14.2857 },
-    { 35.7143, 4.7619 },
-    { 45.2381, 0 },
-    { 59.5238, 0 },
-    { 69.0476, 4.7619 },
-    { 78.5714, 14.2857 },
-    { 83.3334, 28.5714 },
-    { 83.3334, 38.0952 },
-    { 78.5714, 52.381 },
-    { 69.0476, 61.9048 },
-    { 59.5238, 66.6667 },
-    { 45.2381, 66.6667 },
-};
-
-static const StrokeRec char111[] = {
-   { 17, char111_stroke0 },
-};
-
-/* char: 112 'p' */
-
-static const CoordRec char112_stroke0[] = {
-    { 23.8095, 66.6667 },
-    { 23.8095, -33.3333 },
-};
-
-static const CoordRec char112_stroke1[] = {
-    { 23.8095, 52.381 },
-    { 33.3333, 61.9048 },
-    { 42.8571, 66.6667 },
-    { 57.1428, 66.6667 },
-    { 66.6666, 61.9048 },
-    { 76.1905, 52.381 },
-    { 80.9524, 38.0952 },
-    { 80.9524, 28.5714 },
-    { 76.1905, 14.2857 },
-    { 66.6666, 4.7619 },
-    { 57.1428, 0 },
-    { 42.8571, 0 },
-    { 33.3333, 4.7619 },
-    { 23.8095, 14.2857 },
-};
-
-static const StrokeRec char112[] = {
-   { 2, char112_stroke0 },
-   { 14, char112_stroke1 },
-};
-
-/* char: 113 'q' */
-
-static const CoordRec char113_stroke0[] = {
-    { 80.9524, 66.6667 },
-    { 80.9524, -33.3333 },
-};
-
-static const CoordRec char113_stroke1[] = {
-    { 80.9524, 52.381 },
-    { 71.4285, 61.9048 },
-    { 61.9047, 66.6667 },
-    { 47.619, 66.6667 },
-    { 38.0952, 61.9048 },
-    { 28.5714, 52.381 },
-    { 23.8095, 38.0952 },
-    { 23.8095, 28.5714 },
-    { 28.5714, 14.2857 },
-    { 38.0952, 4.7619 },
-    { 47.619, 0 },
-    { 61.9047, 0 },
-    { 71.4285, 4.7619 },
-    { 80.9524, 14.2857 },
-};
-
-static const StrokeRec char113[] = {
-   { 2, char113_stroke0 },
-   { 14, char113_stroke1 },
-};
-
-/* char: 114 'r' */
-
-static const CoordRec char114_stroke0[] = {
-    { 33.3334, 66.6667 },
-    { 33.3334, 0 },
-};
-
-static const CoordRec char114_stroke1[] = {
-    { 33.3334, 38.0952 },
-    { 38.0953, 52.381 },
-    { 47.6191, 61.9048 },
-    { 57.1429, 66.6667 },
-    { 71.4286, 66.6667 },
-};
-
-static const StrokeRec char114[] = {
-   { 2, char114_stroke0 },
-   { 5, char114_stroke1 },
-};
-
-/* char: 115 's' */
-
-static const CoordRec char115_stroke0[] = {
-    { 78.5715, 52.381 },
-    { 73.8095, 61.9048 },
-    { 59.5238, 66.6667 },
-    { 45.2381, 66.6667 },
-    { 30.9524, 61.9048 },
-    { 26.1905, 52.381 },
-    { 30.9524, 42.8571 },
-    { 40.4762, 38.0952 },
-    { 64.2857, 33.3333 },
-    { 73.8095, 28.5714 },
-    { 78.5715, 19.0476 },
-    { 78.5715, 14.2857 },
-    { 73.8095, 4.7619 },
-    { 59.5238, 0 },
-    { 45.2381, 0 },
-    { 30.9524, 4.7619 },
-    { 26.1905, 14.2857 },
-};
-
-static const StrokeRec char115[] = {
-   { 17, char115_stroke0 },
-};
-
-/* char: 116 't' */
-
-static const CoordRec char116_stroke0[] = {
-    { 47.6191, 100 },
-    { 47.6191, 19.0476 },
-    { 52.381, 4.7619 },
-    { 61.9048, 0 },
-    { 71.4286, 0 },
-};
-
-static const CoordRec char116_stroke1[] = {
-    { 33.3334, 66.6667 },
-    { 66.6667, 66.6667 },
-};
-
-static const StrokeRec char116[] = {
-   { 5, char116_stroke0 },
-   { 2, char116_stroke1 },
-};
-
-/* char: 117 'u' */
-
-static const CoordRec char117_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 26.1905, 19.0476 },
-    { 30.9524, 4.7619 },
-    { 40.4762, 0 },
-    { 54.7619, 0 },
-    { 64.2857, 4.7619 },
-    { 78.5715, 19.0476 },
-};
-
-static const CoordRec char117_stroke1[] = {
-    { 78.5715, 66.6667 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char117[] = {
-   { 7, char117_stroke0 },
-   { 2, char117_stroke1 },
-};
-
-/* char: 118 'v' */
-
-static const CoordRec char118_stroke0[] = {
-    { 23.8095, 66.6667 },
-    { 52.3809, 0 },
-};
-
-static const CoordRec char118_stroke1[] = {
-    { 80.9524, 66.6667 },
-    { 52.3809, 0 },
-};
-
-static const StrokeRec char118[] = {
-   { 2, char118_stroke0 },
-   { 2, char118_stroke1 },
-};
-
-/* char: 119 'w' */
-
-static const CoordRec char119_stroke0[] = {
-    { 14.2857, 66.6667 },
-    { 33.3333, 0 },
-};
-
-static const CoordRec char119_stroke1[] = {
-    { 52.3809, 66.6667 },
-    { 33.3333, 0 },
-};
-
-static const CoordRec char119_stroke2[] = {
-    { 52.3809, 66.6667 },
-    { 71.4286, 0 },
-};
-
-static const CoordRec char119_stroke3[] = {
-    { 90.4762, 66.6667 },
-    { 71.4286, 0 },
-};
-
-static const StrokeRec char119[] = {
-   { 2, char119_stroke0 },
-   { 2, char119_stroke1 },
-   { 2, char119_stroke2 },
-   { 2, char119_stroke3 },
-};
-
-/* char: 120 'x' */
-
-static const CoordRec char120_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 78.5715, 0 },
-};
-
-static const CoordRec char120_stroke1[] = {
-    { 78.5715, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const StrokeRec char120[] = {
-   { 2, char120_stroke0 },
-   { 2, char120_stroke1 },
-};
-
-/* char: 121 'y' */
-
-static const CoordRec char121_stroke0[] = {
-    { 26.1905, 66.6667 },
-    { 54.7619, 0 },
-};
-
-static const CoordRec char121_stroke1[] = {
-    { 83.3334, 66.6667 },
-    { 54.7619, 0 },
-    { 45.2381, -19.0476 },
-    { 35.7143, -28.5714 },
-    { 26.1905, -33.3333 },
-    { 21.4286, -33.3333 },
-};
-
-static const StrokeRec char121[] = {
-   { 2, char121_stroke0 },
-   { 6, char121_stroke1 },
-};
-
-/* char: 122 'z' */
-
-static const CoordRec char122_stroke0[] = {
-    { 78.5715, 66.6667 },
-    { 26.1905, 0 },
-};
-
-static const CoordRec char122_stroke1[] = {
-    { 26.1905, 66.6667 },
-    { 78.5715, 66.6667 },
-};
-
-static const CoordRec char122_stroke2[] = {
-    { 26.1905, 0 },
-    { 78.5715, 0 },
-};
-
-static const StrokeRec char122[] = {
-   { 2, char122_stroke0 },
-   { 2, char122_stroke1 },
-   { 2, char122_stroke2 },
-};
-
-/* char: 123 '{' */
-
-static const CoordRec char123_stroke0[] = {
-    { 64.2857, 119.048 },
-    { 54.7619, 114.286 },
-    { 50, 109.524 },
-    { 45.2381, 100 },
-    { 45.2381, 90.4762 },
-    { 50, 80.9524 },
-    { 54.7619, 76.1905 },
-    { 59.5238, 66.6667 },
-    { 59.5238, 57.1429 },
-    { 50, 47.619 },
-};
-
-static const CoordRec char123_stroke1[] = {
-    { 54.7619, 114.286 },
-    { 50, 104.762 },
-    { 50, 95.2381 },
-    { 54.7619, 85.7143 },
-    { 59.5238, 80.9524 },
-    { 64.2857, 71.4286 },
-    { 64.2857, 61.9048 },
-    { 59.5238, 52.381 },
-    { 40.4762, 42.8571 },
-    { 59.5238, 33.3333 },
-    { 64.2857, 23.8095 },
-    { 64.2857, 14.2857 },
-    { 59.5238, 4.7619 },
-    { 54.7619, 0 },
-    { 50, -9.5238 },
-    { 50, -19.0476 },
-    { 54.7619, -28.5714 },
-};
-
-static const CoordRec char123_stroke2[] = {
-    { 50, 38.0952 },
-    { 59.5238, 28.5714 },
-    { 59.5238, 19.0476 },
-    { 54.7619, 9.5238 },
-    { 50, 4.7619 },
-    { 45.2381, -4.7619 },
-    { 45.2381, -14.2857 },
-    { 50, -23.8095 },
-    { 54.7619, -28.5714 },
-    { 64.2857, -33.3333 },
-};
-
-static const StrokeRec char123[] = {
-   { 10, char123_stroke0 },
-   { 17, char123_stroke1 },
-   { 10, char123_stroke2 },
-};
-
-/* char: 124 '|' */
-
-static const CoordRec char124_stroke0[] = {
-    { 52.381, 119.048 },
-    { 52.381, -33.3333 },
-};
-
-static const StrokeRec char124[] = {
-   { 2, char124_stroke0 },
-};
-
-/* char: 125 '}' */
-
-static const CoordRec char125_stroke0[] = {
-    { 40.4762, 119.048 },
-    { 50, 114.286 },
-    { 54.7619, 109.524 },
-    { 59.5238, 100 },
-    { 59.5238, 90.4762 },
-    { 54.7619, 80.9524 },
-    { 50, 76.1905 },
-    { 45.2381, 66.6667 },
-    { 45.2381, 57.1429 },
-    { 54.7619, 47.619 },
-};
-
-static const CoordRec char125_stroke1[] = {
-    { 50, 114.286 },
-    { 54.7619, 104.762 },
-    { 54.7619, 95.2381 },
-    { 50, 85.7143 },
-    { 45.2381, 80.9524 },
-    { 40.4762, 71.4286 },
-    { 40.4762, 61.9048 },
-    { 45.2381, 52.381 },
-    { 64.2857, 42.8571 },
-    { 45.2381, 33.3333 },
-    { 40.4762, 23.8095 },
-    { 40.4762, 14.2857 },
-    { 45.2381, 4.7619 },
-    { 50, 0 },
-    { 54.7619, -9.5238 },
-    { 54.7619, -19.0476 },
-    { 50, -28.5714 },
-};
-
-static const CoordRec char125_stroke2[] = {
-    { 54.7619, 38.0952 },
-    { 45.2381, 28.5714 },
-    { 45.2381, 19.0476 },
-    { 50, 9.5238 },
-    { 54.7619, 4.7619 },
-    { 59.5238, -4.7619 },
-    { 59.5238, -14.2857 },
-    { 54.7619, -23.8095 },
-    { 50, -28.5714 },
-    { 40.4762, -33.3333 },
-};
-
-static const StrokeRec char125[] = {
-   { 10, char125_stroke0 },
-   { 17, char125_stroke1 },
-   { 10, char125_stroke2 },
-};
-
-/* char: 126 '~' */
-
-static const CoordRec char126_stroke0[] = {
-    { 9.5238, 28.5714 },
-    { 9.5238, 38.0952 },
-    { 14.2857, 52.381 },
-    { 23.8095, 57.1429 },
-    { 33.3333, 57.1429 },
-    { 42.8571, 52.381 },
-    { 61.9048, 38.0952 },
-    { 71.4286, 33.3333 },
-    { 80.9524, 33.3333 },
-    { 90.4762, 38.0952 },
-    { 95.2381, 47.619 },
-};
-
-static const CoordRec char126_stroke1[] = {
-    { 9.5238, 38.0952 },
-    { 14.2857, 47.619 },
-    { 23.8095, 52.381 },
-    { 33.3333, 52.381 },
-    { 42.8571, 47.619 },
-    { 61.9048, 33.3333 },
-    { 71.4286, 28.5714 },
-    { 80.9524, 28.5714 },
-    { 90.4762, 33.3333 },
-    { 95.2381, 47.619 },
-    { 95.2381, 57.1429 },
-};
-
-static const StrokeRec char126[] = {
-   { 11, char126_stroke0 },
-   { 11, char126_stroke1 },
-};
-
-/* char: 127 */
-
-static const CoordRec char127_stroke0[] = {
-    { 71.4286, 100 },
-    { 33.3333, -33.3333 },
-};
-
-static const CoordRec char127_stroke1[] = {
-    { 47.619, 66.6667 },
-    { 33.3333, 61.9048 },
-    { 23.8095, 52.381 },
-    { 19.0476, 38.0952 },
-    { 19.0476, 23.8095 },
-    { 23.8095, 14.2857 },
-    { 33.3333, 4.7619 },
-    { 47.619, 0 },
-    { 57.1428, 0 },
-    { 71.4286, 4.7619 },
-    { 80.9524, 14.2857 },
-    { 85.7143, 28.5714 },
-    { 85.7143, 42.8571 },
-    { 80.9524, 52.381 },
-    { 71.4286, 61.9048 },
-    { 57.1428, 66.6667 },
-    { 47.619, 66.6667 },
-};
-
-static const StrokeRec char127[] = {
-   { 2, char127_stroke0 },
-   { 17, char127_stroke1 },
-};
-
-static const StrokeCharRec chars[] = {
-    { 0, /* char0 */ 0, 0, 0 },
-    { 0, /* char1 */ 0, 0, 0 },
-    { 0, /* char2 */ 0, 0, 0 },
-    { 0, /* char3 */ 0, 0, 0 },
-    { 0, /* char4 */ 0, 0, 0 },
-    { 0, /* char5 */ 0, 0, 0 },
-    { 0, /* char6 */ 0, 0, 0 },
-    { 0, /* char7 */ 0, 0, 0 },
-    { 0, /* char8 */ 0, 0, 0 },
-    { 0, /* char9 */ 0, 0, 0 },
-    { 0, /* char10 */ 0, 0, 0 },
-    { 0, /* char11 */ 0, 0, 0 },
-    { 0, /* char12 */ 0, 0, 0 },
-    { 0, /* char13 */ 0, 0, 0 },
-    { 0, /* char14 */ 0, 0, 0 },
-    { 0, /* char15 */ 0, 0, 0 },
-    { 0, /* char16 */ 0, 0, 0 },
-    { 0, /* char17 */ 0, 0, 0 },
-    { 0, /* char18 */ 0, 0, 0 },
-    { 0, /* char19 */ 0, 0, 0 },
-    { 0, /* char20 */ 0, 0, 0 },
-    { 0, /* char21 */ 0, 0, 0 },
-    { 0, /* char22 */ 0, 0, 0 },
-    { 0, /* char23 */ 0, 0, 0 },
-    { 0, /* char24 */ 0, 0, 0 },
-    { 0, /* char25 */ 0, 0, 0 },
-    { 0, /* char26 */ 0, 0, 0 },
-    { 0, /* char27 */ 0, 0, 0 },
-    { 0, /* char28 */ 0, 0, 0 },
-    { 0, /* char29 */ 0, 0, 0 },
-    { 0, /* char30 */ 0, 0, 0 },
-    { 0, /* char31 */ 0, 0, 0 },
-    { 0, /* char32 */ 0, 52.381, 104.762 },
-    { 2, char33, 52.381, 104.762 },
-    { 2, char34, 52.381, 104.762 },
-    { 4, char35, 52.381, 104.762 },
-    { 3, char36, 52.381, 104.762 },
-    { 3, char37, 52.381, 104.762 },
-    { 1, char38, 52.381, 104.762 },
-    { 1, char39, 52.381, 104.762 },
-    { 1, char40, 52.381, 104.762 },
-    { 1, char41, 52.381, 104.762 },
-    { 3, char42, 52.381, 104.762 },
-    { 2, char43, 52.381, 104.762 },
-    { 1, char44, 52.381, 104.762 },
-    { 1, char45, 52.381, 104.762 },
-    { 1, char46, 52.381, 104.762 },
-    { 1, char47, 52.381, 104.762 },
-    { 1, char48, 52.381, 104.762 },
-    { 1, char49, 52.381, 104.762 },
-    { 1, char50, 52.381, 104.762 },
-    { 1, char51, 52.381, 104.762 },
-    { 2, char52, 52.381, 104.762 },
-    { 1, char53, 52.381, 104.762 },
-    { 1, char54, 52.381, 104.762 },
-    { 2, char55, 52.381, 104.762 },
-    { 1, char56, 52.381, 104.762 },
-    { 1, char57, 52.381, 104.762 },
-    { 2, char58, 52.381, 104.762 },
-    { 2, char59, 52.381, 104.762 },
-    { 1, char60, 52.381, 104.762 },
-    { 2, char61, 52.381, 104.762 },
-    { 1, char62, 52.381, 104.762 },
-    { 2, char63, 52.381, 104.762 },
-    { 2, char64, 52.381, 104.762 },
-    { 3, char65, 52.381, 104.762 },
-    { 3, char66, 52.381, 104.762 },
-    { 1, char67, 52.381, 104.762 },
-    { 2, char68, 52.381, 104.762 },
-    { 4, char69, 52.381, 104.762 },
-    { 3, char70, 52.381, 104.762 },
-    { 2, char71, 52.381, 104.762 },
-    { 3, char72, 52.381, 104.762 },
-    { 1, char73, 52.381, 104.762 },
-    { 1, char74, 52.381, 104.762 },
-    { 3, char75, 52.381, 104.762 },
-    { 2, char76, 52.381, 104.762 },
-    { 4, char77, 52.381, 104.762 },
-    { 3, char78, 52.381, 104.762 },
-    { 1, char79, 52.381, 104.762 },
-    { 2, char80, 52.381, 104.762 },
-    { 2, char81, 52.381, 104.762 },
-    { 3, char82, 52.381, 104.762 },
-    { 1, char83, 52.381, 104.762 },
-    { 2, char84, 52.381, 104.762 },
-    { 1, char85, 52.381, 104.762 },
-    { 2, char86, 52.381, 104.762 },
-    { 4, char87, 52.381, 104.762 },
-    { 2, char88, 52.381, 104.762 },
-    { 2, char89, 52.381, 104.762 },
-    { 3, char90, 52.381, 104.762 },
-    { 4, char91, 52.381, 104.762 },
-    { 1, char92, 52.381, 104.762 },
-    { 4, char93, 52.381, 104.762 },
-    { 2, char94, 52.381, 104.762 },
-    { 1, char95, 52.381, 104.762 },
-    { 2, char96, 52.381, 104.762 },
-    { 2, char97, 52.381, 104.762 },
-    { 2, char98, 52.381, 104.762 },
-    { 1, char99, 52.381, 104.762 },
-    { 2, char100, 52.381, 104.762 },
-    { 1, char101, 52.381, 104.762 },
-    { 2, char102, 52.381, 104.762 },
-    { 2, char103, 52.381, 104.762 },
-    { 2, char104, 52.381, 104.762 },
-    { 2, char105, 52.381, 104.762 },
-    { 2, char106, 52.381, 104.762 },
-    { 3, char107, 52.381, 104.762 },
-    { 1, char108, 52.381, 104.762 },
-    { 3, char109, 52.381, 104.762 },
-    { 2, char110, 52.381, 104.762 },
-    { 1, char111, 52.381, 104.762 },
-    { 2, char112, 52.381, 104.762 },
-    { 2, char113, 52.381, 104.762 },
-    { 2, char114, 52.381, 104.762 },
-    { 1, char115, 52.381, 104.762 },
-    { 2, char116, 52.381, 104.762 },
-    { 2, char117, 52.381, 104.762 },
-    { 2, char118, 52.381, 104.762 },
-    { 4, char119, 52.381, 104.762 },
-    { 2, char120, 52.381, 104.762 },
-    { 2, char121, 52.381, 104.762 },
-    { 3, char122, 52.381, 104.762 },
-    { 3, char123, 52.381, 104.762 },
-    { 1, char124, 52.381, 104.762 },
-    { 3, char125, 52.381, 104.762 },
-    { 2, char126, 52.381, 104.762 },
-    { 2, char127, 52.381, 104.762 },
-};
-
-GLUTAPI const StrokeFontRec glutStrokeMonoRoman;
-const StrokeFontRec glutStrokeMonoRoman = { "Roman", 128, chars, 119.048, -33.3333 };
-
diff --git a/src/glut/glx/glut_overlay.c b/src/glut/glx/glut_overlay.c
deleted file mode 100644
index ce8e68d164a..00000000000
--- a/src/glut/glx/glut_overlay.c
+++ /dev/null
@@ -1,608 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996, 1997.  */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#if defined (__vms)
-#include <Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
-#else
-#include <X11/Xmu/StdCmap.h>  /* for XmuLookupStandardColormap */
-#endif
-#endif /* !_WIN32 */
-
-#include "glutint.h"
-#include "layerutil.h"
-
-static Criterion requiredOverlayCriteria[] =
-{
-  {LEVEL, EQ, 1},       /* This entry gets poked in
-                           determineOverlayVisual. */
-  {TRANSPARENT, EQ, 1},
-  {XPSEUDOCOLOR, EQ, 1},
-  {RGBA, EQ, 0},
-  {BUFFER_SIZE, GTE, 1}
-};
-static int numRequiredOverlayCriteria = sizeof(requiredOverlayCriteria) / sizeof(Criterion);
-static int requiredOverlayCriteriaMask =
-(1 << LEVEL) | (1 << TRANSPARENT) | (1 << XSTATICGRAY) | (1 << RGBA) | (1 << CI_MODE);
-
-#if !defined(_WIN32)
-static int
-checkOverlayAcceptability(XVisualInfo * vi, unsigned int mode)
-{
-  int value;
-
-  /* Must support OpenGL. */
-  glXGetConfig(__glutDisplay, vi, GLX_USE_GL, &value);
-  if (!value)
-    return 1;
-
-  /* Must be color index. */
-  glXGetConfig(__glutDisplay, vi, GLX_RGBA, &value);
-  if (value)
-    return 1;
-
-  /* Must match single/double buffering request. */
-  glXGetConfig(__glutDisplay, vi, GLX_DOUBLEBUFFER, &value);
-  if (GLUT_WIND_IS_DOUBLE(mode) != (value != 0))
-    return 1;
-
-  /* Must match mono/stereo request. */
-  glXGetConfig(__glutDisplay, vi, GLX_STEREO, &value);
-  if (GLUT_WIND_IS_STEREO(mode) != (value != 0))
-    return 1;
-
-  /* Alpha and accumulation buffers incompatible with color
-     index. */
-  if (GLUT_WIND_HAS_ALPHA(mode) || GLUT_WIND_HAS_ACCUM(mode))
-    return 1;
-
-  /* Look for depth buffer if requested. */
-  glXGetConfig(__glutDisplay, vi, GLX_DEPTH_SIZE, &value);
-  if (GLUT_WIND_HAS_DEPTH(mode) && (value <= 0))
-    return 1;
-
-  /* Look for stencil buffer if requested. */
-  glXGetConfig(__glutDisplay, vi, GLX_STENCIL_SIZE, &value);
-  if (GLUT_WIND_HAS_STENCIL(mode) && (value <= 0))
-    return 1;
-
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-  /* XXX Multisampled overlay color index??  Pretty unlikely. */
-  /* Look for multisampling if requested. */
-  if (__glutIsSupportedByGLX("GLX_SGIS_multisample") ||
-      __glutIsSupportedByGLX("GLX_ARB_multisample"))
-    glXGetConfig(__glutDisplay, vi, GLX_SAMPLES_SGIS, &value);
-  else
-    value = 0;
-  if (GLUT_WIND_IS_MULTISAMPLE(mode) && (value <= 0))
-    return 1;
-#endif
-
-  return 0;
-}
-#endif
-
-static XVisualInfo *
-getOverlayVisualInfoCI(unsigned int mode)
-{
-#if !defined(_WIN32)
-  XLayerVisualInfo *vi;
-  XLayerVisualInfo template;
-  XVisualInfo *goodVisual, *returnVisual;
-  int nitems, i, j, bad;
-
-  /* The GLX 1.0 glXChooseVisual is does not permit queries
-     based on pixel transparency (and GLX_BUFFER_SIZE uses
-     "smallest that meets" its requirement instead of "largest
-     that meets" that GLUT wants. So, GLUT implements its own
-     visual selection routine for color index overlays. */
-
-  /* Try three overlay layers. */
-  for (i = 1; i <= 3; i++) {
-    template.vinfo.screen = __glutScreen;
-    template.vinfo.class = PseudoColor;
-    template.layer = i;
-    template.type = TransparentPixel;
-    vi = __glutXGetLayerVisualInfo(__glutDisplay,
-      VisualTransparentType | VisualScreenMask | VisualClassMask | VisualLayerMask,
-      &template, &nitems);
-    if (vi) {
-      /* Check list for acceptable visual meeting requirements
-         of requested display mode. */
-      for (j = 0; j < nitems; j++) {
-        bad = checkOverlayAcceptability(&vi[j].vinfo, mode);
-        if (bad) {
-          /* Set vi[j].vinfo.visual to mark it unacceptable. */
-          vi[j].vinfo.visual = NULL;
-        }
-      }
-
-      /* Look through list to find deepest acceptable visual. */
-      goodVisual = NULL;
-      for (j = 0; j < nitems; j++) {
-        if (vi[j].vinfo.visual) {
-          if (goodVisual == NULL) {
-            goodVisual = &vi[j].vinfo;
-          } else {
-            if (goodVisual->depth < vi[j].vinfo.depth) {
-              goodVisual = &vi[j].vinfo;
-            }
-          }
-        }
-      }
-
-      /* If a visual is found, clean up and return the visual. */
-      if (goodVisual) {
-        returnVisual = (XVisualInfo *) malloc(sizeof(XVisualInfo));
-        if (returnVisual) {
-          *returnVisual = *goodVisual;
-        }
-        XFree(vi);
-        return returnVisual;
-      }
-      XFree(vi);
-    }
-  }
-#endif /* !_WIN32 */
-  return NULL;
-}
-
-/* ARGSUSED */
-static XVisualInfo *
-getOverlayVisualInfoRGB(unsigned int mode)
-{
-
-  /* XXX For now, transparent RGBA overlays are not supported
-     by GLUT.  RGBA overlays raise difficult questions about
-     what the transparent pixel (really color) value should be.
-
-     Color index overlay transparency is "easy" because the
-     transparent pixel value does not affect displayable colors
-     (except for stealing one color cell) since colors are
-     determined by indirection through a colormap, and because
-     it is uncommon for arbitrary pixel values in color index to
-     be "calculated" (as can occur with a host of RGBA operations
-     like lighting, blending, etc) so it is easy to avoid the
-     transparent pixel value.
-
-     Since it is typically easy to avoid the transparent pixel
-     value in color index mode, if GLUT tells the programmer what
-     pixel is transparent, then most program can easily avoid
-     generating that pixel value except when they intend
-     transparency.  GLUT returns whatever transparent pixel value
-     is provided by the system through glutGet(
-     GLUT_TRANSPARENT_INDEX).
-
-     Theory versus practice for RGBA overlay transparency: In
-     theory, the reasonable thing is enabling overlay transparency
-     when an overlay pixel's destination alpha is 0 because this
-     allows overlay transparency to be controlled via alpha and all
-     visibile colors are permited, but no hardware I am aware of
-     supports this practice (and it requires destination alpha which
-     is typically optional and quite uncommon for overlay windows!). 
-
-     In practice, the choice of  transparent pixel value is typically
-     "hardwired" into most graphics hardware to a single pixel value.
-     SGI hardware uses true black (0,0,0) without regard for the
-     destination alpha.  This is far from ideal because true black (a
-     common color that is easy to accidently generate) can not be
-     generated in an RGBA overlay. I am not sure what other vendors
-     do.
-
-     Pragmatically, most of the typical things you want to do in the
-     overlays can be done in color index (rubber banding, pop-up
-     menus, etc.).  One solution for GLUT would be to simply
-     "advertise" what RGB triple (or possibly RGBA quadruple or simply 
-     A alone) generates transparency.  The problem with this approach
-     is that it forces programmers to avoid whatever arbitrary color
-     various systems decide is transparent.  This is a difficult
-     burden to place on programmers that want to portably make use of
-     overlays.
-
-     To actually support transparent RGBA overlays, there are really
-     two reaonsable options.  ONE: Simply mandate that true black is
-     the RGBA overlay transparent color (what IRIS GL did).  This is
-     nice for programmers since only one option, nice for existing SGI 
-     hardware, bad for anyone (including SGI) who wants to improve
-     upon "true black" RGB transparency. 
-
-     Or TWO: Provide a set of queriable "transparency types" (like
-     "true black" or "alpha == 0" or "true white" or even a queriable
-     transparent color).  This is harder for programmers, OK for
-     existing SGI hardware, and it leaves open the issue of what other 
-     modes are reasonable.
-
-     Option TWO seems the more general approach, but since hardware
-     designers will likely only implement a single mode (this is a
-     scan out issue where bandwidth is pressing issue), codifying
-     multiple speculative approaches nobody may ever implement seems
-     silly.  And option ONE fiats a suboptimal solution.
-
-     Therefore, I defer any decision of how GLUT should support RGBA
-     overlay transparency and leave support for it unimplemented.
-     Nobody has been pressing me for RGBA overlay transparency (though 
-     people have requested color index overlay transparency
-     repeatedly).  Geez, if you read this far you are either really
-     bored or maybe actually  interested in this topic.  Anyway, if
-     you have ideas (particularly if you plan on implementing a
-     hardware scheme for RGBA overlay transparency), I'd be
-     interested.
-
-     For the record, SGI's expiremental Framebufer Configuration
-     experimental GLX extension uses option TWO.  Transparency modes
-     for "none" and "RGB" are defined (others could be defined later). 
-     What RGB value is the transparent one must be queried. 
-
-     I was hoping GLUT could have something that required less work
-     from the programmer to use portably. -mjk */
-
-  __glutWarning("RGBA overlays are not supported by GLUT (for now).");
-  return NULL;
-}
-
-static XVisualInfo *
-getOverlayVisualInfo(unsigned int mode)
-{
-  /* XXX GLUT_LUMINANCE not implemented for GLUT 3.0. */
-  if (GLUT_WIND_IS_LUMINANCE(mode))
-    return NULL;
-
-  if (GLUT_WIND_IS_RGB(mode))
-    return getOverlayVisualInfoRGB(mode);
-  else
-    return getOverlayVisualInfoCI(mode);
-}
-
-#if !defined(_WIN32)
-
-/* The GLUT overlay can come and go, and the overlay window has
-   a distinct X window ID.  Logically though, GLUT treats the
-   normal and overlay windows as a unified window.  In
-   particular, X input events typically go to the overlay window 
-   since it is "on top of" the normal window.  When an overlay
-   window ID is destroyed (due to glutRemoveOverlay or a call to 
-   glutEstablishOverlay when an overlay already exists), we
-   still keep track of the overlay window ID until we get back a 
-   DestroyNotify event for the overlay window. Otherwise, we
-   could lose track of X input events sent to a destroyed
-   overlay.  To avoid this, we keep the destroyed overlay window 
-   ID on a "stale window" list.  This lets us properly route X
-   input events generated on destroyed overlay windows to the
-   proper GLUT window. */
-static void
-addStaleWindow(GLUTwindow * window, Window win)
-{
-  GLUTstale *entry;
-
-  entry = (GLUTstale *) malloc(sizeof(GLUTstale));
-  if (!entry)
-    __glutFatalError("out of memory");
-  entry->window = window;
-  entry->win = win;
-  entry->next = __glutStaleWindowList;
-  __glutStaleWindowList = entry;
-}
-
-#endif
-
-void
-__glutFreeOverlay(GLUToverlay * overlay)
-{
-  if (overlay->visAlloced)
-    XFree(overlay->vis);
-  XDestroyWindow(__glutDisplay, overlay->win);
-  glXDestroyContext(__glutDisplay, overlay->ctx);
-  if (overlay->colormap) {
-    /* Only color index overlays have colormap data structure. */
-    __glutFreeColormap(overlay->colormap);
-  }
-  free(overlay);
-}
-
-static XVisualInfo *
-determineOverlayVisual(int *treatAsSingle, Bool * visAlloced, void **fbc)
-{
-  if (__glutDisplayString) {
-    XVisualInfo *vi;
-    int i;
-
-    /* __glutDisplayString should be NULL except if
-       glutInitDisplayString has been called to register a
-       different display string.  Calling glutInitDisplayString
-       means using a string instead of an integer mask determine 
-
-       the visual to use. Using the function pointer variable
-       __glutDetermineVisualFromString below avoids linking in
-       the code for implementing glutInitDisplayString (ie,
-       glut_dstr.o) unless glutInitDisplayString gets called by
-       the application. */
-
-    assert(__glutDetermineVisualFromString);
-
-    /* Try three overlay layers. */
-    *visAlloced = False;
-    *fbc = NULL;
-    for (i = 1; i <= 3; i++) {
-      requiredOverlayCriteria[0].value = i;
-      vi = __glutDetermineVisualFromString(__glutDisplayString, treatAsSingle,
-        requiredOverlayCriteria, numRequiredOverlayCriteria,
-        requiredOverlayCriteriaMask, fbc);
-      if (vi) {
-        return vi;
-      }
-    }
-    return NULL;
-  } else {
-    *visAlloced = True;
-    *fbc = NULL;
-    return __glutDetermineVisual(__glutDisplayMode,
-      treatAsSingle, getOverlayVisualInfo);
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutEstablishOverlay(void)
-{
-  GLUToverlay *overlay;
-  GLUTwindow *window;
-  XSetWindowAttributes wa;
-  void *fbc;
-
-  /* Register a routine to free an overlay with glut_win.c;
-     this keeps glut_win.c from pulling in all of
-     glut_overlay.c when no overlay functionality is used by
-     the application. */
-  __glutFreeOverlayFunc = __glutFreeOverlay;
-
-  window = __glutCurrentWindow;
-
-  /* Allow for an existant overlay to be re-established perhaps
-     if you wanted a different display mode. */
-  if (window->overlay) {
-#if !defined(_WIN32)
-    addStaleWindow(window, window->overlay->win);
-#endif
-    __glutFreeOverlay(window->overlay);
-  }
-  overlay = (GLUToverlay *) malloc(sizeof(GLUToverlay));
-  if (!overlay)
-    __glutFatalError("out of memory.");
-
-  overlay->vis = determineOverlayVisual(&overlay->treatAsSingle,
-    &overlay->visAlloced, &fbc);
-  if (!overlay->vis) {
-    __glutFatalError("lacks overlay support.");
-  }
-  overlay->ctx = NULL;
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-  if (fbc) {
-    window->ctx = __glut_glXCreateContextWithConfigSGIX(__glutDisplay, fbc,
-      GLX_RGBA_TYPE_SGIX, None, __glutTryDirect);
-  } else
-#endif
-  {
-    overlay->ctx = glXCreateContext(__glutDisplay, overlay->vis,
-      None, __glutTryDirect);
-  }
-  if (!overlay->ctx) {
-    __glutFatalError(
-      "failed to create overlay OpenGL rendering context.");
-  }
-#if !defined(_WIN32)
-  overlay->isDirect = glXIsDirect(__glutDisplay, overlay->ctx);
-  if (__glutForceDirect) {
-    if (!overlay->isDirect) {
-      __glutFatalError("direct rendering not possible.");
-    }
-  }
-#endif
-  __glutSetupColormap(overlay->vis, &overlay->colormap, &overlay->cmap);
-  overlay->transparentPixel = __glutGetTransparentPixel(__glutDisplay,
-    overlay->vis);
-  wa.colormap = overlay->cmap;
-  wa.background_pixel = overlay->transparentPixel;
-  wa.event_mask = window->eventMask & GLUT_OVERLAY_EVENT_FILTER_MASK;
-  wa.border_pixel = 0;
-#if defined(_WIN32)
-  /* XXX Overlays not supported in Win32 yet. */
-#else
-  overlay->win = XCreateWindow(__glutDisplay,
-    window->win,
-    0, 0, window->width, window->height, 0,
-    overlay->vis->depth, InputOutput, overlay->vis->visual,
-    CWBackPixel | CWBorderPixel | CWEventMask | CWColormap,
-    &wa);
-#endif
-  if (window->children) {
-    /* Overlay window must be lowered below any GLUT
-       subwindows. */
-    XLowerWindow(__glutDisplay, overlay->win);
-  }
-  XMapWindow(__glutDisplay, overlay->win);
-  overlay->shownState = 1;
-
-  overlay->display = NULL;
-
-  /* Make sure a reshape gets delivered. */
-  window->forceReshape = True;
-
-#if !defined(_WIN32)
-  __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
-#endif
-
-  window->overlay = overlay;
-  glutUseLayer(GLUT_OVERLAY);
-
-  if (overlay->treatAsSingle) {
-    glDrawBuffer(GL_FRONT);
-    glReadBuffer(GL_FRONT);
-  }
-}
-
-void GLUTAPIENTRY
-glutRemoveOverlay(void)
-{
-  GLUTwindow *window = __glutCurrentWindow;
-  GLUToverlay *overlay = __glutCurrentWindow->overlay;
-
-  if (!window->overlay)
-    return;
-
-  /* If using overlay, switch to the normal layer. */
-  if (window->renderWin == overlay->win) {
-    glutUseLayer(GLUT_NORMAL);
-  }
-#if !defined(_WIN32)
-  addStaleWindow(window, overlay->win);
-#endif
-  __glutFreeOverlay(overlay);
-  window->overlay = NULL;
-#if !defined(_WIN32)
-  __glutPutOnWorkList(__glutToplevelOf(window), GLUT_COLORMAP_WORK);
-#endif
-}
-
-void GLUTAPIENTRY
-glutUseLayer(GLenum layer)
-{
-  GLUTwindow *window = __glutCurrentWindow;
-
-  switch (layer) {
-  case GLUT_NORMAL:
-#ifdef _WIN32
-    window->renderDc = window->hdc;
-#endif
-    window->renderWin = window->win;
-    window->renderCtx = window->ctx;
-    break;
-  case GLUT_OVERLAY:
-    /* Did you crash here?  Calling glutUseLayer(GLUT_OVERLAY)
-       without an overlay established is erroneous.  Fix your
-       code. */
-#ifdef _WIN32
-    window->renderDc = window->overlay->hdc;
-#endif
-    window->renderWin = window->overlay->win;
-    window->renderCtx = window->overlay->ctx;
-    break;
-  default:
-    __glutWarning("glutUseLayer: unknown layer, %d.", layer);
-    break;
-  }
-  __glutSetWindow(window);
-}
-
-void GLUTAPIENTRY
-glutPostOverlayRedisplay(void)
-{
-  __glutPostRedisplay(__glutCurrentWindow, GLUT_OVERLAY_REDISPLAY_WORK);
-}
-
-/* The advantage of this routine is that it saves the cost of a
-   glutSetWindow call (entailing an expensive OpenGL context
-   switch), particularly useful when multiple windows need
-   redisplays posted at the same times. */
-void GLUTAPIENTRY
-glutPostWindowOverlayRedisplay(int win)
-{
-  __glutPostRedisplay(__glutWindowList[win - 1], GLUT_OVERLAY_REDISPLAY_WORK);
-}
-
-void GLUTAPIENTRY
-glutOverlayDisplayFunc(GLUTdisplayCB displayFunc)
-{
-  if (!__glutCurrentWindow->overlay) {
-    __glutWarning("glutOverlayDisplayFunc: window has no overlay established");
-    return;
-  }
-  __glutCurrentWindow->overlay->display = displayFunc;
-}
-
-void GLUTAPIENTRY
-glutHideOverlay(void)
-{
-  if (!__glutCurrentWindow->overlay) {
-    __glutWarning("glutHideOverlay: window has no overlay established");
-    return;
-  }
-  XUnmapWindow(__glutDisplay, __glutCurrentWindow->overlay->win);
-  __glutCurrentWindow->overlay->shownState = 0;
-}
-
-void GLUTAPIENTRY
-glutShowOverlay(void)
-{
-  if (!__glutCurrentWindow->overlay) {
-    __glutWarning("glutShowOverlay: window has no overlay established");
-    return;
-  }
-  XMapWindow(__glutDisplay, __glutCurrentWindow->overlay->win);
-  __glutCurrentWindow->overlay->shownState = 1;
-}
-
-int GLUTAPIENTRY
-glutLayerGet(GLenum param)
-{
-  switch (param) {
-  case GLUT_OVERLAY_POSSIBLE:
-    {
-      XVisualInfo *vi;
-      Bool dummy, visAlloced;
-      void *fbc;
-
-      vi = determineOverlayVisual(&dummy, &visAlloced, &fbc);
-      if (vi) {
-        if (visAlloced)
-          XFree(vi);
-        return 1;
-      }
-      return 0;
-    }
-  case GLUT_LAYER_IN_USE:
-    return __glutCurrentWindow->renderWin != __glutCurrentWindow->win;
-  case GLUT_HAS_OVERLAY:
-    return __glutCurrentWindow->overlay != NULL;
-  case GLUT_TRANSPARENT_INDEX:
-    if (__glutCurrentWindow->overlay) {
-      return __glutCurrentWindow->overlay->transparentPixel;
-    } else {
-      return -1;
-    }
-  case GLUT_NORMAL_DAMAGED:
-    /* __glutWindowDamaged is used so the damage state within
-       the window (or overlay belwo) can be cleared before
-       calling a display callback so on return, the state does
-       not have to be cleared (since upon return from the
-       callback the window could be destroyed (or layer
-       removed). */
-    return (__glutCurrentWindow->workMask & GLUT_REPAIR_WORK)
-      || __glutWindowDamaged;
-  case GLUT_OVERLAY_DAMAGED:
-    if (__glutCurrentWindow->overlay) {
-      return (__glutCurrentWindow->workMask & GLUT_OVERLAY_REPAIR_WORK)
-        || __glutWindowDamaged;
-    } else {
-      return -1;
-    }
-  default:
-    __glutWarning("invalid glutLayerGet param: %d", param);
-    return -1;
-  }
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_ppm.c b/src/glut/glx/glut_ppm.c
deleted file mode 100644
index 49dca8532fd..00000000000
--- a/src/glut/glx/glut_ppm.c
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * PPM file output
- * Brian Paul
- * 8 Dec 2008
- */
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "glutint.h"
-
-
-static void
-write_ppm_file(const char *filename, const GLubyte *buffer,
-               int width, int height)
-{
-   const int binary = 1;
-   FILE *f = fopen( filename, "w" );
-   if (f) {
-      const GLubyte *ptr = buffer;
-      int i, x, y;
-      if (binary) {
-         fprintf(f,"P6\n");
-         fprintf(f,"# ppm-file created by GLUT\n");
-         fprintf(f,"%i %i\n", width, height);
-         fprintf(f,"255\n");
-         fclose(f);
-         f = fopen( filename, "ab" );  /* reopen in binary append mode */
-         for (y = height - 1; y >= 0; y--) {
-            for (x = 0; x < width; x++) {
-               i = (y * width + x) * 4;
-               fputc(ptr[i], f);   /* write red */
-               fputc(ptr[i+1], f); /* write green */
-               fputc(ptr[i+2], f); /* write blue */
-            }
-         }
-      }
-      else {
-         /*ASCII*/
-         int counter = 0;
-         fprintf(f,"P3\n");
-         fprintf(f,"# ascii ppm file created by GLUT\n");
-         fprintf(f,"%i %i\n", width, height);
-         fprintf(f,"255\n");
-         for (y = height - 1; y >= 0; y--) {
-            for (x = 0; x < width; x++) {
-               i = (y * width + x) * 4;
-               fprintf(f, " %3d %3d %3d", ptr[i], ptr[i+1], ptr[i+2]);
-               counter++;
-               if (counter % 5 == 0)
-                  fprintf(f, "\n");
-            }
-         }
-      }
-      fclose(f);
-   }
-}
-
-
-/**
- * Called from SwapBuffers if the GLUT_PPM_FILE env var is set.
- */
-void __glutWritePPMFile(void)
-{
-   int w = glutGet(GLUT_WINDOW_WIDTH);
-   int h = glutGet(GLUT_WINDOW_HEIGHT);
-   GLubyte *buf;
-
-   assert(__glutPPMFile);
-
-   buf = (GLubyte *) malloc(w * h * 4);
-   if (buf) {
-      /* XXX save/restore pixel packing */
-      glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
-      write_ppm_file(__glutPPMFile, buf, w, h);
-      free(buf);
-   }
-
-   __glutPPMFile = NULL; /* only write one file */
-}
diff --git a/src/glut/glx/glut_roman.c b/src/glut/glx/glut_roman.c
deleted file mode 100644
index 95b9f8160f1..00000000000
--- a/src/glut/glx/glut_roman.c
+++ /dev/null
@@ -1,2454 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutStrokeRoman XXX
-#include "glutstroke.h"
-#undef glutStrokeRoman
-
-/* char: 33 '!' */
-
-static const CoordRec char33_stroke0[] = {
-    { 13.3819, 100 },
-    { 13.3819, 33.3333 },
-};
-
-static const CoordRec char33_stroke1[] = {
-    { 13.3819, 9.5238 },
-    { 8.62, 4.7619 },
-    { 13.3819, 0 },
-    { 18.1438, 4.7619 },
-    { 13.3819, 9.5238 },
-};
-
-static const StrokeRec char33[] = {
-   { 2, char33_stroke0 },
-   { 5, char33_stroke1 },
-};
-
-/* char: 34 '"' */
-
-static const CoordRec char34_stroke0[] = {
-    { 4.02, 100 },
-    { 4.02, 66.6667 },
-};
-
-static const CoordRec char34_stroke1[] = {
-    { 42.1152, 100 },
-    { 42.1152, 66.6667 },
-};
-
-static const StrokeRec char34[] = {
-   { 2, char34_stroke0 },
-   { 2, char34_stroke1 },
-};
-
-/* char: 35 '#' */
-
-static const CoordRec char35_stroke0[] = {
-    { 41.2952, 119.048 },
-    { 7.9619, -33.3333 },
-};
-
-static const CoordRec char35_stroke1[] = {
-    { 69.8667, 119.048 },
-    { 36.5333, -33.3333 },
-};
-
-static const CoordRec char35_stroke2[] = {
-    { 7.9619, 57.1429 },
-    { 74.6286, 57.1429 },
-};
-
-static const CoordRec char35_stroke3[] = {
-    { 3.2, 28.5714 },
-    { 69.8667, 28.5714 },
-};
-
-static const StrokeRec char35[] = {
-   { 2, char35_stroke0 },
-   { 2, char35_stroke1 },
-   { 2, char35_stroke2 },
-   { 2, char35_stroke3 },
-};
-
-/* char: 36 '$' */
-
-static const CoordRec char36_stroke0[] = {
-    { 28.6295, 119.048 },
-    { 28.6295, -19.0476 },
-};
-
-static const CoordRec char36_stroke1[] = {
-    { 47.6771, 119.048 },
-    { 47.6771, -19.0476 },
-};
-
-static const CoordRec char36_stroke2[] = {
-    { 71.4867, 85.7143 },
-    { 61.9629, 95.2381 },
-    { 47.6771, 100 },
-    { 28.6295, 100 },
-    { 14.3438, 95.2381 },
-    { 4.82, 85.7143 },
-    { 4.82, 76.1905 },
-    { 9.5819, 66.6667 },
-    { 14.3438, 61.9048 },
-    { 23.8676, 57.1429 },
-    { 52.439, 47.619 },
-    { 61.9629, 42.8571 },
-    { 66.7248, 38.0952 },
-    { 71.4867, 28.5714 },
-    { 71.4867, 14.2857 },
-    { 61.9629, 4.7619 },
-    { 47.6771, 0 },
-    { 28.6295, 0 },
-    { 14.3438, 4.7619 },
-    { 4.82, 14.2857 },
-};
-
-static const StrokeRec char36[] = {
-   { 2, char36_stroke0 },
-   { 2, char36_stroke1 },
-   { 20, char36_stroke2 },
-};
-
-/* char: 37 '%' */
-
-static const CoordRec char37_stroke0[] = {
-    { 92.0743, 100 },
-    { 6.36, 0 },
-};
-
-static const CoordRec char37_stroke1[] = {
-    { 30.1695, 100 },
-    { 39.6933, 90.4762 },
-    { 39.6933, 80.9524 },
-    { 34.9314, 71.4286 },
-    { 25.4076, 66.6667 },
-    { 15.8838, 66.6667 },
-    { 6.36, 76.1905 },
-    { 6.36, 85.7143 },
-    { 11.1219, 95.2381 },
-    { 20.6457, 100 },
-    { 30.1695, 100 },
-    { 39.6933, 95.2381 },
-    { 53.979, 90.4762 },
-    { 68.2648, 90.4762 },
-    { 82.5505, 95.2381 },
-    { 92.0743, 100 },
-};
-
-static const CoordRec char37_stroke2[] = {
-    { 73.0267, 33.3333 },
-    { 63.5029, 28.5714 },
-    { 58.741, 19.0476 },
-    { 58.741, 9.5238 },
-    { 68.2648, 0 },
-    { 77.7886, 0 },
-    { 87.3124, 4.7619 },
-    { 92.0743, 14.2857 },
-    { 92.0743, 23.8095 },
-    { 82.5505, 33.3333 },
-    { 73.0267, 33.3333 },
-};
-
-static const StrokeRec char37[] = {
-   { 2, char37_stroke0 },
-   { 16, char37_stroke1 },
-   { 11, char37_stroke2 },
-};
-
-/* char: 38 '&' */
-
-static const CoordRec char38_stroke0[] = {
-    { 101.218, 57.1429 },
-    { 101.218, 61.9048 },
-    { 96.4562, 66.6667 },
-    { 91.6943, 66.6667 },
-    { 86.9324, 61.9048 },
-    { 82.1705, 52.381 },
-    { 72.6467, 28.5714 },
-    { 63.1229, 14.2857 },
-    { 53.599, 4.7619 },
-    { 44.0752, 0 },
-    { 25.0276, 0 },
-    { 15.5038, 4.7619 },
-    { 10.7419, 9.5238 },
-    { 5.98, 19.0476 },
-    { 5.98, 28.5714 },
-    { 10.7419, 38.0952 },
-    { 15.5038, 42.8571 },
-    { 48.8371, 61.9048 },
-    { 53.599, 66.6667 },
-    { 58.361, 76.1905 },
-    { 58.361, 85.7143 },
-    { 53.599, 95.2381 },
-    { 44.0752, 100 },
-    { 34.5514, 95.2381 },
-    { 29.7895, 85.7143 },
-    { 29.7895, 76.1905 },
-    { 34.5514, 61.9048 },
-    { 44.0752, 47.619 },
-    { 67.8848, 14.2857 },
-    { 77.4086, 4.7619 },
-    { 86.9324, 0 },
-    { 96.4562, 0 },
-    { 101.218, 4.7619 },
-    { 101.218, 9.5238 },
-};
-
-static const StrokeRec char38[] = {
-   { 34, char38_stroke0 },
-};
-
-/* char: 39 ''' */
-
-static const CoordRec char39_stroke0[] = {
-    { 4.44, 100 },
-    { 4.44, 66.6667 },
-};
-
-static const StrokeRec char39[] = {
-   { 2, char39_stroke0 },
-};
-
-/* char: 40 '(' */
-
-static const CoordRec char40_stroke0[] = {
-    { 40.9133, 119.048 },
-    { 31.3895, 109.524 },
-    { 21.8657, 95.2381 },
-    { 12.3419, 76.1905 },
-    { 7.58, 52.381 },
-    { 7.58, 33.3333 },
-    { 12.3419, 9.5238 },
-    { 21.8657, -9.5238 },
-    { 31.3895, -23.8095 },
-    { 40.9133, -33.3333 },
-};
-
-static const StrokeRec char40[] = {
-   { 10, char40_stroke0 },
-};
-
-/* char: 41 ')' */
-
-static const CoordRec char41_stroke0[] = {
-    { 5.28, 119.048 },
-    { 14.8038, 109.524 },
-    { 24.3276, 95.2381 },
-    { 33.8514, 76.1905 },
-    { 38.6133, 52.381 },
-    { 38.6133, 33.3333 },
-    { 33.8514, 9.5238 },
-    { 24.3276, -9.5238 },
-    { 14.8038, -23.8095 },
-    { 5.28, -33.3333 },
-};
-
-static const StrokeRec char41[] = {
-   { 10, char41_stroke0 },
-};
-
-/* char: 42 '*' */
-
-static const CoordRec char42_stroke0[] = {
-    { 30.7695, 71.4286 },
-    { 30.7695, 14.2857 },
-};
-
-static const CoordRec char42_stroke1[] = {
-    { 6.96, 57.1429 },
-    { 54.579, 28.5714 },
-};
-
-static const CoordRec char42_stroke2[] = {
-    { 54.579, 57.1429 },
-    { 6.96, 28.5714 },
-};
-
-static const StrokeRec char42[] = {
-   { 2, char42_stroke0 },
-   { 2, char42_stroke1 },
-   { 2, char42_stroke2 },
-};
-
-/* char: 43 '+' */
-
-static const CoordRec char43_stroke0[] = {
-    { 48.8371, 85.7143 },
-    { 48.8371, 0 },
-};
-
-static const CoordRec char43_stroke1[] = {
-    { 5.98, 42.8571 },
-    { 91.6943, 42.8571 },
-};
-
-static const StrokeRec char43[] = {
-   { 2, char43_stroke0 },
-   { 2, char43_stroke1 },
-};
-
-/* char: 44 ',' */
-
-static const CoordRec char44_stroke0[] = {
-    { 18.2838, 4.7619 },
-    { 13.5219, 0 },
-    { 8.76, 4.7619 },
-    { 13.5219, 9.5238 },
-    { 18.2838, 4.7619 },
-    { 18.2838, -4.7619 },
-    { 13.5219, -14.2857 },
-    { 8.76, -19.0476 },
-};
-
-static const StrokeRec char44[] = {
-   { 8, char44_stroke0 },
-};
-
-/* char: 45 '-' */
-
-static const CoordRec char45_stroke0[] = {
-    { 7.38, 42.8571 },
-    { 93.0943, 42.8571 },
-};
-
-static const StrokeRec char45[] = {
-   { 2, char45_stroke0 },
-};
-
-/* char: 46 '.' */
-
-static const CoordRec char46_stroke0[] = {
-    { 13.1019, 9.5238 },
-    { 8.34, 4.7619 },
-    { 13.1019, 0 },
-    { 17.8638, 4.7619 },
-    { 13.1019, 9.5238 },
-};
-
-static const StrokeRec char46[] = {
-   { 5, char46_stroke0 },
-};
-
-/* char: 47 '/' */
-
-static const CoordRec char47_stroke0[] = {
-    { 7.24, -14.2857 },
-    { 73.9067, 100 },
-};
-
-static const StrokeRec char47[] = {
-   { 2, char47_stroke0 },
-};
-
-/* char: 48 '0' */
-
-static const CoordRec char48_stroke0[] = {
-    { 33.5514, 100 },
-    { 19.2657, 95.2381 },
-    { 9.7419, 80.9524 },
-    { 4.98, 57.1429 },
-    { 4.98, 42.8571 },
-    { 9.7419, 19.0476 },
-    { 19.2657, 4.7619 },
-    { 33.5514, 0 },
-    { 43.0752, 0 },
-    { 57.361, 4.7619 },
-    { 66.8848, 19.0476 },
-    { 71.6467, 42.8571 },
-    { 71.6467, 57.1429 },
-    { 66.8848, 80.9524 },
-    { 57.361, 95.2381 },
-    { 43.0752, 100 },
-    { 33.5514, 100 },
-};
-
-static const StrokeRec char48[] = {
-   { 17, char48_stroke0 },
-};
-
-/* char: 49 '1' */
-
-static const CoordRec char49_stroke0[] = {
-    { 11.82, 80.9524 },
-    { 21.3438, 85.7143 },
-    { 35.6295, 100 },
-    { 35.6295, 0 },
-};
-
-static const StrokeRec char49[] = {
-   { 4, char49_stroke0 },
-};
-
-/* char: 50 '2' */
-
-static const CoordRec char50_stroke0[] = {
-    { 10.1819, 76.1905 },
-    { 10.1819, 80.9524 },
-    { 14.9438, 90.4762 },
-    { 19.7057, 95.2381 },
-    { 29.2295, 100 },
-    { 48.2771, 100 },
-    { 57.801, 95.2381 },
-    { 62.5629, 90.4762 },
-    { 67.3248, 80.9524 },
-    { 67.3248, 71.4286 },
-    { 62.5629, 61.9048 },
-    { 53.039, 47.619 },
-    { 5.42, 0 },
-    { 72.0867, 0 },
-};
-
-static const StrokeRec char50[] = {
-   { 14, char50_stroke0 },
-};
-
-/* char: 51 '3' */
-
-static const CoordRec char51_stroke0[] = {
-    { 14.5238, 100 },
-    { 66.9048, 100 },
-    { 38.3333, 61.9048 },
-    { 52.619, 61.9048 },
-    { 62.1429, 57.1429 },
-    { 66.9048, 52.381 },
-    { 71.6667, 38.0952 },
-    { 71.6667, 28.5714 },
-    { 66.9048, 14.2857 },
-    { 57.381, 4.7619 },
-    { 43.0952, 0 },
-    { 28.8095, 0 },
-    { 14.5238, 4.7619 },
-    { 9.7619, 9.5238 },
-    { 5, 19.0476 },
-};
-
-static const StrokeRec char51[] = {
-   { 15, char51_stroke0 },
-};
-
-/* char: 52 '4' */
-
-static const CoordRec char52_stroke0[] = {
-    { 51.499, 100 },
-    { 3.88, 33.3333 },
-    { 75.3086, 33.3333 },
-};
-
-static const CoordRec char52_stroke1[] = {
-    { 51.499, 100 },
-    { 51.499, 0 },
-};
-
-static const StrokeRec char52[] = {
-   { 3, char52_stroke0 },
-   { 2, char52_stroke1 },
-};
-
-/* char: 53 '5' */
-
-static const CoordRec char53_stroke0[] = {
-    { 62.0029, 100 },
-    { 14.3838, 100 },
-    { 9.6219, 57.1429 },
-    { 14.3838, 61.9048 },
-    { 28.6695, 66.6667 },
-    { 42.9552, 66.6667 },
-    { 57.241, 61.9048 },
-    { 66.7648, 52.381 },
-    { 71.5267, 38.0952 },
-    { 71.5267, 28.5714 },
-    { 66.7648, 14.2857 },
-    { 57.241, 4.7619 },
-    { 42.9552, 0 },
-    { 28.6695, 0 },
-    { 14.3838, 4.7619 },
-    { 9.6219, 9.5238 },
-    { 4.86, 19.0476 },
-};
-
-static const StrokeRec char53[] = {
-   { 17, char53_stroke0 },
-};
-
-/* char: 54 '6' */
-
-static const CoordRec char54_stroke0[] = {
-    { 62.7229, 85.7143 },
-    { 57.961, 95.2381 },
-    { 43.6752, 100 },
-    { 34.1514, 100 },
-    { 19.8657, 95.2381 },
-    { 10.3419, 80.9524 },
-    { 5.58, 57.1429 },
-    { 5.58, 33.3333 },
-    { 10.3419, 14.2857 },
-    { 19.8657, 4.7619 },
-    { 34.1514, 0 },
-    { 38.9133, 0 },
-    { 53.199, 4.7619 },
-    { 62.7229, 14.2857 },
-    { 67.4848, 28.5714 },
-    { 67.4848, 33.3333 },
-    { 62.7229, 47.619 },
-    { 53.199, 57.1429 },
-    { 38.9133, 61.9048 },
-    { 34.1514, 61.9048 },
-    { 19.8657, 57.1429 },
-    { 10.3419, 47.619 },
-    { 5.58, 33.3333 },
-};
-
-static const StrokeRec char54[] = {
-   { 23, char54_stroke0 },
-};
-
-/* char: 55 '7' */
-
-static const CoordRec char55_stroke0[] = {
-    { 72.2267, 100 },
-    { 24.6076, 0 },
-};
-
-static const CoordRec char55_stroke1[] = {
-    { 5.56, 100 },
-    { 72.2267, 100 },
-};
-
-static const StrokeRec char55[] = {
-   { 2, char55_stroke0 },
-   { 2, char55_stroke1 },
-};
-
-/* char: 56 '8' */
-
-static const CoordRec char56_stroke0[] = {
-    { 29.4095, 100 },
-    { 15.1238, 95.2381 },
-    { 10.3619, 85.7143 },
-    { 10.3619, 76.1905 },
-    { 15.1238, 66.6667 },
-    { 24.6476, 61.9048 },
-    { 43.6952, 57.1429 },
-    { 57.981, 52.381 },
-    { 67.5048, 42.8571 },
-    { 72.2667, 33.3333 },
-    { 72.2667, 19.0476 },
-    { 67.5048, 9.5238 },
-    { 62.7429, 4.7619 },
-    { 48.4571, 0 },
-    { 29.4095, 0 },
-    { 15.1238, 4.7619 },
-    { 10.3619, 9.5238 },
-    { 5.6, 19.0476 },
-    { 5.6, 33.3333 },
-    { 10.3619, 42.8571 },
-    { 19.8857, 52.381 },
-    { 34.1714, 57.1429 },
-    { 53.219, 61.9048 },
-    { 62.7429, 66.6667 },
-    { 67.5048, 76.1905 },
-    { 67.5048, 85.7143 },
-    { 62.7429, 95.2381 },
-    { 48.4571, 100 },
-    { 29.4095, 100 },
-};
-
-static const StrokeRec char56[] = {
-   { 29, char56_stroke0 },
-};
-
-/* char: 57 '9' */
-
-static const CoordRec char57_stroke0[] = {
-    { 68.5048, 66.6667 },
-    { 63.7429, 52.381 },
-    { 54.219, 42.8571 },
-    { 39.9333, 38.0952 },
-    { 35.1714, 38.0952 },
-    { 20.8857, 42.8571 },
-    { 11.3619, 52.381 },
-    { 6.6, 66.6667 },
-    { 6.6, 71.4286 },
-    { 11.3619, 85.7143 },
-    { 20.8857, 95.2381 },
-    { 35.1714, 100 },
-    { 39.9333, 100 },
-    { 54.219, 95.2381 },
-    { 63.7429, 85.7143 },
-    { 68.5048, 66.6667 },
-    { 68.5048, 42.8571 },
-    { 63.7429, 19.0476 },
-    { 54.219, 4.7619 },
-    { 39.9333, 0 },
-    { 30.4095, 0 },
-    { 16.1238, 4.7619 },
-    { 11.3619, 14.2857 },
-};
-
-static const StrokeRec char57[] = {
-   { 23, char57_stroke0 },
-};
-
-/* char: 58 ':' */
-
-static const CoordRec char58_stroke0[] = {
-    { 14.0819, 66.6667 },
-    { 9.32, 61.9048 },
-    { 14.0819, 57.1429 },
-    { 18.8438, 61.9048 },
-    { 14.0819, 66.6667 },
-};
-
-static const CoordRec char58_stroke1[] = {
-    { 14.0819, 9.5238 },
-    { 9.32, 4.7619 },
-    { 14.0819, 0 },
-    { 18.8438, 4.7619 },
-    { 14.0819, 9.5238 },
-};
-
-static const StrokeRec char58[] = {
-   { 5, char58_stroke0 },
-   { 5, char58_stroke1 },
-};
-
-/* char: 59 ';' */
-
-static const CoordRec char59_stroke0[] = {
-    { 12.9619, 66.6667 },
-    { 8.2, 61.9048 },
-    { 12.9619, 57.1429 },
-    { 17.7238, 61.9048 },
-    { 12.9619, 66.6667 },
-};
-
-static const CoordRec char59_stroke1[] = {
-    { 17.7238, 4.7619 },
-    { 12.9619, 0 },
-    { 8.2, 4.7619 },
-    { 12.9619, 9.5238 },
-    { 17.7238, 4.7619 },
-    { 17.7238, -4.7619 },
-    { 12.9619, -14.2857 },
-    { 8.2, -19.0476 },
-};
-
-static const StrokeRec char59[] = {
-   { 5, char59_stroke0 },
-   { 8, char59_stroke1 },
-};
-
-/* char: 60 '<' */
-
-static const CoordRec char60_stroke0[] = {
-    { 79.2505, 85.7143 },
-    { 3.06, 42.8571 },
-    { 79.2505, 0 },
-};
-
-static const StrokeRec char60[] = {
-   { 3, char60_stroke0 },
-};
-
-/* char: 61 '=' */
-
-static const CoordRec char61_stroke0[] = {
-    { 5.7, 57.1429 },
-    { 91.4143, 57.1429 },
-};
-
-static const CoordRec char61_stroke1[] = {
-    { 5.7, 28.5714 },
-    { 91.4143, 28.5714 },
-};
-
-static const StrokeRec char61[] = {
-   { 2, char61_stroke0 },
-   { 2, char61_stroke1 },
-};
-
-/* char: 62 '>' */
-
-static const CoordRec char62_stroke0[] = {
-    { 2.78, 85.7143 },
-    { 78.9705, 42.8571 },
-    { 2.78, 0 },
-};
-
-static const StrokeRec char62[] = {
-   { 3, char62_stroke0 },
-};
-
-/* char: 63 '?' */
-
-static const CoordRec char63_stroke0[] = {
-    { 8.42, 76.1905 },
-    { 8.42, 80.9524 },
-    { 13.1819, 90.4762 },
-    { 17.9438, 95.2381 },
-    { 27.4676, 100 },
-    { 46.5152, 100 },
-    { 56.039, 95.2381 },
-    { 60.801, 90.4762 },
-    { 65.5629, 80.9524 },
-    { 65.5629, 71.4286 },
-    { 60.801, 61.9048 },
-    { 56.039, 57.1429 },
-    { 36.9914, 47.619 },
-    { 36.9914, 33.3333 },
-};
-
-static const CoordRec char63_stroke1[] = {
-    { 36.9914, 9.5238 },
-    { 32.2295, 4.7619 },
-    { 36.9914, 0 },
-    { 41.7533, 4.7619 },
-    { 36.9914, 9.5238 },
-};
-
-static const StrokeRec char63[] = {
-   { 14, char63_stroke0 },
-   { 5, char63_stroke1 },
-};
-
-/* char: 64 '@' */
-
-static const CoordRec char64_stroke0[] = {
-    { 49.2171, 52.381 },
-    { 39.6933, 57.1429 },
-    { 30.1695, 57.1429 },
-    { 25.4076, 47.619 },
-    { 25.4076, 42.8571 },
-    { 30.1695, 33.3333 },
-    { 39.6933, 33.3333 },
-    { 49.2171, 38.0952 },
-};
-
-static const CoordRec char64_stroke1[] = {
-    { 49.2171, 57.1429 },
-    { 49.2171, 38.0952 },
-    { 53.979, 33.3333 },
-    { 63.5029, 33.3333 },
-    { 68.2648, 42.8571 },
-    { 68.2648, 47.619 },
-    { 63.5029, 61.9048 },
-    { 53.979, 71.4286 },
-    { 39.6933, 76.1905 },
-    { 34.9314, 76.1905 },
-    { 20.6457, 71.4286 },
-    { 11.1219, 61.9048 },
-    { 6.36, 47.619 },
-    { 6.36, 42.8571 },
-    { 11.1219, 28.5714 },
-    { 20.6457, 19.0476 },
-    { 34.9314, 14.2857 },
-    { 39.6933, 14.2857 },
-    { 53.979, 19.0476 },
-};
-
-static const StrokeRec char64[] = {
-   { 8, char64_stroke0 },
-   { 19, char64_stroke1 },
-};
-
-/* char: 65 'A' */
-
-static const CoordRec char65_stroke0[] = {
-    { 40.5952, 100 },
-    { 2.5, 0 },
-};
-
-static const CoordRec char65_stroke1[] = {
-    { 40.5952, 100 },
-    { 78.6905, 0 },
-};
-
-static const CoordRec char65_stroke2[] = {
-    { 16.7857, 33.3333 },
-    { 64.4048, 33.3333 },
-};
-
-static const StrokeRec char65[] = {
-   { 2, char65_stroke0 },
-   { 2, char65_stroke1 },
-   { 2, char65_stroke2 },
-};
-
-/* char: 66 'B' */
-
-static const CoordRec char66_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char66_stroke1[] = {
-    { 11.42, 100 },
-    { 54.2771, 100 },
-    { 68.5629, 95.2381 },
-    { 73.3248, 90.4762 },
-    { 78.0867, 80.9524 },
-    { 78.0867, 71.4286 },
-    { 73.3248, 61.9048 },
-    { 68.5629, 57.1429 },
-    { 54.2771, 52.381 },
-};
-
-static const CoordRec char66_stroke2[] = {
-    { 11.42, 52.381 },
-    { 54.2771, 52.381 },
-    { 68.5629, 47.619 },
-    { 73.3248, 42.8571 },
-    { 78.0867, 33.3333 },
-    { 78.0867, 19.0476 },
-    { 73.3248, 9.5238 },
-    { 68.5629, 4.7619 },
-    { 54.2771, 0 },
-    { 11.42, 0 },
-};
-
-static const StrokeRec char66[] = {
-   { 2, char66_stroke0 },
-   { 9, char66_stroke1 },
-   { 10, char66_stroke2 },
-};
-
-/* char: 67 'C' */
-
-static const CoordRec char67_stroke0[] = {
-    { 78.0886, 76.1905 },
-    { 73.3267, 85.7143 },
-    { 63.8029, 95.2381 },
-    { 54.279, 100 },
-    { 35.2314, 100 },
-    { 25.7076, 95.2381 },
-    { 16.1838, 85.7143 },
-    { 11.4219, 76.1905 },
-    { 6.66, 61.9048 },
-    { 6.66, 38.0952 },
-    { 11.4219, 23.8095 },
-    { 16.1838, 14.2857 },
-    { 25.7076, 4.7619 },
-    { 35.2314, 0 },
-    { 54.279, 0 },
-    { 63.8029, 4.7619 },
-    { 73.3267, 14.2857 },
-    { 78.0886, 23.8095 },
-};
-
-static const StrokeRec char67[] = {
-   { 18, char67_stroke0 },
-};
-
-/* char: 68 'D' */
-
-static const CoordRec char68_stroke0[] = {
-    { 11.96, 100 },
-    { 11.96, 0 },
-};
-
-static const CoordRec char68_stroke1[] = {
-    { 11.96, 100 },
-    { 45.2933, 100 },
-    { 59.579, 95.2381 },
-    { 69.1029, 85.7143 },
-    { 73.8648, 76.1905 },
-    { 78.6267, 61.9048 },
-    { 78.6267, 38.0952 },
-    { 73.8648, 23.8095 },
-    { 69.1029, 14.2857 },
-    { 59.579, 4.7619 },
-    { 45.2933, 0 },
-    { 11.96, 0 },
-};
-
-static const StrokeRec char68[] = {
-   { 2, char68_stroke0 },
-   { 12, char68_stroke1 },
-};
-
-/* char: 69 'E' */
-
-static const CoordRec char69_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char69_stroke1[] = {
-    { 11.42, 100 },
-    { 73.3248, 100 },
-};
-
-static const CoordRec char69_stroke2[] = {
-    { 11.42, 52.381 },
-    { 49.5152, 52.381 },
-};
-
-static const CoordRec char69_stroke3[] = {
-    { 11.42, 0 },
-    { 73.3248, 0 },
-};
-
-static const StrokeRec char69[] = {
-   { 2, char69_stroke0 },
-   { 2, char69_stroke1 },
-   { 2, char69_stroke2 },
-   { 2, char69_stroke3 },
-};
-
-/* char: 70 'F' */
-
-static const CoordRec char70_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char70_stroke1[] = {
-    { 11.42, 100 },
-    { 73.3248, 100 },
-};
-
-static const CoordRec char70_stroke2[] = {
-    { 11.42, 52.381 },
-    { 49.5152, 52.381 },
-};
-
-static const StrokeRec char70[] = {
-   { 2, char70_stroke0 },
-   { 2, char70_stroke1 },
-   { 2, char70_stroke2 },
-};
-
-/* char: 71 'G' */
-
-static const CoordRec char71_stroke0[] = {
-    { 78.4886, 76.1905 },
-    { 73.7267, 85.7143 },
-    { 64.2029, 95.2381 },
-    { 54.679, 100 },
-    { 35.6314, 100 },
-    { 26.1076, 95.2381 },
-    { 16.5838, 85.7143 },
-    { 11.8219, 76.1905 },
-    { 7.06, 61.9048 },
-    { 7.06, 38.0952 },
-    { 11.8219, 23.8095 },
-    { 16.5838, 14.2857 },
-    { 26.1076, 4.7619 },
-    { 35.6314, 0 },
-    { 54.679, 0 },
-    { 64.2029, 4.7619 },
-    { 73.7267, 14.2857 },
-    { 78.4886, 23.8095 },
-    { 78.4886, 38.0952 },
-};
-
-static const CoordRec char71_stroke1[] = {
-    { 54.679, 38.0952 },
-    { 78.4886, 38.0952 },
-};
-
-static const StrokeRec char71[] = {
-   { 19, char71_stroke0 },
-   { 2, char71_stroke1 },
-};
-
-/* char: 72 'H' */
-
-static const CoordRec char72_stroke0[] = {
-    { 11.42, 100 },
-    { 11.42, 0 },
-};
-
-static const CoordRec char72_stroke1[] = {
-    { 78.0867, 100 },
-    { 78.0867, 0 },
-};
-
-static const CoordRec char72_stroke2[] = {
-    { 11.42, 52.381 },
-    { 78.0867, 52.381 },
-};
-
-static const StrokeRec char72[] = {
-   { 2, char72_stroke0 },
-   { 2, char72_stroke1 },
-   { 2, char72_stroke2 },
-};
-
-/* char: 73 'I' */
-
-static const CoordRec char73_stroke0[] = {
-    { 10.86, 100 },
-    { 10.86, 0 },
-};
-
-static const StrokeRec char73[] = {
-   { 2, char73_stroke0 },
-};
-
-/* char: 74 'J' */
-
-static const CoordRec char74_stroke0[] = {
-    { 50.119, 100 },
-    { 50.119, 23.8095 },
-    { 45.3571, 9.5238 },
-    { 40.5952, 4.7619 },
-    { 31.0714, 0 },
-    { 21.5476, 0 },
-    { 12.0238, 4.7619 },
-    { 7.2619, 9.5238 },
-    { 2.5, 23.8095 },
-    { 2.5, 33.3333 },
-};
-
-static const StrokeRec char74[] = {
-   { 10, char74_stroke0 },
-};
-
-/* char: 75 'K' */
-
-static const CoordRec char75_stroke0[] = {
-    { 11.28, 100 },
-    { 11.28, 0 },
-};
-
-static const CoordRec char75_stroke1[] = {
-    { 77.9467, 100 },
-    { 11.28, 33.3333 },
-};
-
-static const CoordRec char75_stroke2[] = {
-    { 35.0895, 57.1429 },
-    { 77.9467, 0 },
-};
-
-static const StrokeRec char75[] = {
-   { 2, char75_stroke0 },
-   { 2, char75_stroke1 },
-   { 2, char75_stroke2 },
-};
-
-/* char: 76 'L' */
-
-static const CoordRec char76_stroke0[] = {
-    { 11.68, 100 },
-    { 11.68, 0 },
-};
-
-static const CoordRec char76_stroke1[] = {
-    { 11.68, 0 },
-    { 68.8229, 0 },
-};
-
-static const StrokeRec char76[] = {
-   { 2, char76_stroke0 },
-   { 2, char76_stroke1 },
-};
-
-/* char: 77 'M' */
-
-static const CoordRec char77_stroke0[] = {
-    { 10.86, 100 },
-    { 10.86, 0 },
-};
-
-static const CoordRec char77_stroke1[] = {
-    { 10.86, 100 },
-    { 48.9552, 0 },
-};
-
-static const CoordRec char77_stroke2[] = {
-    { 87.0505, 100 },
-    { 48.9552, 0 },
-};
-
-static const CoordRec char77_stroke3[] = {
-    { 87.0505, 100 },
-    { 87.0505, 0 },
-};
-
-static const StrokeRec char77[] = {
-   { 2, char77_stroke0 },
-   { 2, char77_stroke1 },
-   { 2, char77_stroke2 },
-   { 2, char77_stroke3 },
-};
-
-/* char: 78 'N' */
-
-static const CoordRec char78_stroke0[] = {
-    { 11.14, 100 },
-    { 11.14, 0 },
-};
-
-static const CoordRec char78_stroke1[] = {
-    { 11.14, 100 },
-    { 77.8067, 0 },
-};
-
-static const CoordRec char78_stroke2[] = {
-    { 77.8067, 100 },
-    { 77.8067, 0 },
-};
-
-static const StrokeRec char78[] = {
-   { 2, char78_stroke0 },
-   { 2, char78_stroke1 },
-   { 2, char78_stroke2 },
-};
-
-/* char: 79 'O' */
-
-static const CoordRec char79_stroke0[] = {
-    { 34.8114, 100 },
-    { 25.2876, 95.2381 },
-    { 15.7638, 85.7143 },
-    { 11.0019, 76.1905 },
-    { 6.24, 61.9048 },
-    { 6.24, 38.0952 },
-    { 11.0019, 23.8095 },
-    { 15.7638, 14.2857 },
-    { 25.2876, 4.7619 },
-    { 34.8114, 0 },
-    { 53.859, 0 },
-    { 63.3829, 4.7619 },
-    { 72.9067, 14.2857 },
-    { 77.6686, 23.8095 },
-    { 82.4305, 38.0952 },
-    { 82.4305, 61.9048 },
-    { 77.6686, 76.1905 },
-    { 72.9067, 85.7143 },
-    { 63.3829, 95.2381 },
-    { 53.859, 100 },
-    { 34.8114, 100 },
-};
-
-static const StrokeRec char79[] = {
-   { 21, char79_stroke0 },
-};
-
-/* char: 80 'P' */
-
-static const CoordRec char80_stroke0[] = {
-    { 12.1, 100 },
-    { 12.1, 0 },
-};
-
-static const CoordRec char80_stroke1[] = {
-    { 12.1, 100 },
-    { 54.9571, 100 },
-    { 69.2429, 95.2381 },
-    { 74.0048, 90.4762 },
-    { 78.7667, 80.9524 },
-    { 78.7667, 66.6667 },
-    { 74.0048, 57.1429 },
-    { 69.2429, 52.381 },
-    { 54.9571, 47.619 },
-    { 12.1, 47.619 },
-};
-
-static const StrokeRec char80[] = {
-   { 2, char80_stroke0 },
-   { 10, char80_stroke1 },
-};
-
-/* char: 81 'Q' */
-
-static const CoordRec char81_stroke0[] = {
-    { 33.8714, 100 },
-    { 24.3476, 95.2381 },
-    { 14.8238, 85.7143 },
-    { 10.0619, 76.1905 },
-    { 5.3, 61.9048 },
-    { 5.3, 38.0952 },
-    { 10.0619, 23.8095 },
-    { 14.8238, 14.2857 },
-    { 24.3476, 4.7619 },
-    { 33.8714, 0 },
-    { 52.919, 0 },
-    { 62.4429, 4.7619 },
-    { 71.9667, 14.2857 },
-    { 76.7286, 23.8095 },
-    { 81.4905, 38.0952 },
-    { 81.4905, 61.9048 },
-    { 76.7286, 76.1905 },
-    { 71.9667, 85.7143 },
-    { 62.4429, 95.2381 },
-    { 52.919, 100 },
-    { 33.8714, 100 },
-};
-
-static const CoordRec char81_stroke1[] = {
-    { 48.1571, 19.0476 },
-    { 76.7286, -9.5238 },
-};
-
-static const StrokeRec char81[] = {
-   { 21, char81_stroke0 },
-   { 2, char81_stroke1 },
-};
-
-/* char: 82 'R' */
-
-static const CoordRec char82_stroke0[] = {
-    { 11.68, 100 },
-    { 11.68, 0 },
-};
-
-static const CoordRec char82_stroke1[] = {
-    { 11.68, 100 },
-    { 54.5371, 100 },
-    { 68.8229, 95.2381 },
-    { 73.5848, 90.4762 },
-    { 78.3467, 80.9524 },
-    { 78.3467, 71.4286 },
-    { 73.5848, 61.9048 },
-    { 68.8229, 57.1429 },
-    { 54.5371, 52.381 },
-    { 11.68, 52.381 },
-};
-
-static const CoordRec char82_stroke2[] = {
-    { 45.0133, 52.381 },
-    { 78.3467, 0 },
-};
-
-static const StrokeRec char82[] = {
-   { 2, char82_stroke0 },
-   { 10, char82_stroke1 },
-   { 2, char82_stroke2 },
-};
-
-/* char: 83 'S' */
-
-static const CoordRec char83_stroke0[] = {
-    { 74.6667, 85.7143 },
-    { 65.1429, 95.2381 },
-    { 50.8571, 100 },
-    { 31.8095, 100 },
-    { 17.5238, 95.2381 },
-    { 8, 85.7143 },
-    { 8, 76.1905 },
-    { 12.7619, 66.6667 },
-    { 17.5238, 61.9048 },
-    { 27.0476, 57.1429 },
-    { 55.619, 47.619 },
-    { 65.1429, 42.8571 },
-    { 69.9048, 38.0952 },
-    { 74.6667, 28.5714 },
-    { 74.6667, 14.2857 },
-    { 65.1429, 4.7619 },
-    { 50.8571, 0 },
-    { 31.8095, 0 },
-    { 17.5238, 4.7619 },
-    { 8, 14.2857 },
-};
-
-static const StrokeRec char83[] = {
-   { 20, char83_stroke0 },
-};
-
-/* char: 84 'T' */
-
-static const CoordRec char84_stroke0[] = {
-    { 35.6933, 100 },
-    { 35.6933, 0 },
-};
-
-static const CoordRec char84_stroke1[] = {
-    { 2.36, 100 },
-    { 69.0267, 100 },
-};
-
-static const StrokeRec char84[] = {
-   { 2, char84_stroke0 },
-   { 2, char84_stroke1 },
-};
-
-/* char: 85 'U' */
-
-static const CoordRec char85_stroke0[] = {
-    { 11.54, 100 },
-    { 11.54, 28.5714 },
-    { 16.3019, 14.2857 },
-    { 25.8257, 4.7619 },
-    { 40.1114, 0 },
-    { 49.6352, 0 },
-    { 63.921, 4.7619 },
-    { 73.4448, 14.2857 },
-    { 78.2067, 28.5714 },
-    { 78.2067, 100 },
-};
-
-static const StrokeRec char85[] = {
-   { 10, char85_stroke0 },
-};
-
-/* char: 86 'V' */
-
-static const CoordRec char86_stroke0[] = {
-    { 2.36, 100 },
-    { 40.4552, 0 },
-};
-
-static const CoordRec char86_stroke1[] = {
-    { 78.5505, 100 },
-    { 40.4552, 0 },
-};
-
-static const StrokeRec char86[] = {
-   { 2, char86_stroke0 },
-   { 2, char86_stroke1 },
-};
-
-/* char: 87 'W' */
-
-static const CoordRec char87_stroke0[] = {
-    { 2.22, 100 },
-    { 26.0295, 0 },
-};
-
-static const CoordRec char87_stroke1[] = {
-    { 49.839, 100 },
-    { 26.0295, 0 },
-};
-
-static const CoordRec char87_stroke2[] = {
-    { 49.839, 100 },
-    { 73.6486, 0 },
-};
-
-static const CoordRec char87_stroke3[] = {
-    { 97.4581, 100 },
-    { 73.6486, 0 },
-};
-
-static const StrokeRec char87[] = {
-   { 2, char87_stroke0 },
-   { 2, char87_stroke1 },
-   { 2, char87_stroke2 },
-   { 2, char87_stroke3 },
-};
-
-/* char: 88 'X' */
-
-static const CoordRec char88_stroke0[] = {
-    { 2.5, 100 },
-    { 69.1667, 0 },
-};
-
-static const CoordRec char88_stroke1[] = {
-    { 69.1667, 100 },
-    { 2.5, 0 },
-};
-
-static const StrokeRec char88[] = {
-   { 2, char88_stroke0 },
-   { 2, char88_stroke1 },
-};
-
-/* char: 89 'Y' */
-
-static const CoordRec char89_stroke0[] = {
-    { 1.52, 100 },
-    { 39.6152, 52.381 },
-    { 39.6152, 0 },
-};
-
-static const CoordRec char89_stroke1[] = {
-    { 77.7105, 100 },
-    { 39.6152, 52.381 },
-};
-
-static const StrokeRec char89[] = {
-   { 3, char89_stroke0 },
-   { 2, char89_stroke1 },
-};
-
-/* char: 90 'Z' */
-
-static const CoordRec char90_stroke0[] = {
-    { 69.1667, 100 },
-    { 2.5, 0 },
-};
-
-static const CoordRec char90_stroke1[] = {
-    { 2.5, 100 },
-    { 69.1667, 100 },
-};
-
-static const CoordRec char90_stroke2[] = {
-    { 2.5, 0 },
-    { 69.1667, 0 },
-};
-
-static const StrokeRec char90[] = {
-   { 2, char90_stroke0 },
-   { 2, char90_stroke1 },
-   { 2, char90_stroke2 },
-};
-
-/* char: 91 '[' */
-
-static const CoordRec char91_stroke0[] = {
-    { 7.78, 119.048 },
-    { 7.78, -33.3333 },
-};
-
-static const CoordRec char91_stroke1[] = {
-    { 12.5419, 119.048 },
-    { 12.5419, -33.3333 },
-};
-
-static const CoordRec char91_stroke2[] = {
-    { 7.78, 119.048 },
-    { 41.1133, 119.048 },
-};
-
-static const CoordRec char91_stroke3[] = {
-    { 7.78, -33.3333 },
-    { 41.1133, -33.3333 },
-};
-
-static const StrokeRec char91[] = {
-   { 2, char91_stroke0 },
-   { 2, char91_stroke1 },
-   { 2, char91_stroke2 },
-   { 2, char91_stroke3 },
-};
-
-/* char: 92 '\' */
-
-static const CoordRec char92_stroke0[] = {
-    { 5.84, 100 },
-    { 72.5067, -14.2857 },
-};
-
-static const StrokeRec char92[] = {
-   { 2, char92_stroke0 },
-};
-
-/* char: 93 ']' */
-
-static const CoordRec char93_stroke0[] = {
-    { 33.0114, 119.048 },
-    { 33.0114, -33.3333 },
-};
-
-static const CoordRec char93_stroke1[] = {
-    { 37.7733, 119.048 },
-    { 37.7733, -33.3333 },
-};
-
-static const CoordRec char93_stroke2[] = {
-    { 4.44, 119.048 },
-    { 37.7733, 119.048 },
-};
-
-static const CoordRec char93_stroke3[] = {
-    { 4.44, -33.3333 },
-    { 37.7733, -33.3333 },
-};
-
-static const StrokeRec char93[] = {
-   { 2, char93_stroke0 },
-   { 2, char93_stroke1 },
-   { 2, char93_stroke2 },
-   { 2, char93_stroke3 },
-};
-
-/* char: 94 '^' */
-
-static const CoordRec char94_stroke0[] = {
-    { 44.0752, 109.524 },
-    { 5.98, 42.8571 },
-};
-
-static const CoordRec char94_stroke1[] = {
-    { 44.0752, 109.524 },
-    { 82.1705, 42.8571 },
-};
-
-static const StrokeRec char94[] = {
-   { 2, char94_stroke0 },
-   { 2, char94_stroke1 },
-};
-
-/* char: 95 '_' */
-
-static const CoordRec char95_stroke0[] = {
-    { -1.1, -33.3333 },
-    { 103.662, -33.3333 },
-    { 103.662, -28.5714 },
-    { -1.1, -28.5714 },
-    { -1.1, -33.3333 },
-};
-
-static const StrokeRec char95[] = {
-   { 5, char95_stroke0 },
-};
-
-/* char: 96 '`' */
-
-static const CoordRec char96_stroke0[] = {
-    { 33.0219, 100 },
-    { 56.8314, 71.4286 },
-};
-
-static const CoordRec char96_stroke1[] = {
-    { 33.0219, 100 },
-    { 28.26, 95.2381 },
-    { 56.8314, 71.4286 },
-};
-
-static const StrokeRec char96[] = {
-   { 2, char96_stroke0 },
-   { 3, char96_stroke1 },
-};
-
-/* char: 97 'a' */
-
-static const CoordRec char97_stroke0[] = {
-    { 63.8229, 66.6667 },
-    { 63.8229, 0 },
-};
-
-static const CoordRec char97_stroke1[] = {
-    { 63.8229, 52.381 },
-    { 54.299, 61.9048 },
-    { 44.7752, 66.6667 },
-    { 30.4895, 66.6667 },
-    { 20.9657, 61.9048 },
-    { 11.4419, 52.381 },
-    { 6.68, 38.0952 },
-    { 6.68, 28.5714 },
-    { 11.4419, 14.2857 },
-    { 20.9657, 4.7619 },
-    { 30.4895, 0 },
-    { 44.7752, 0 },
-    { 54.299, 4.7619 },
-    { 63.8229, 14.2857 },
-};
-
-static const StrokeRec char97[] = {
-   { 2, char97_stroke0 },
-   { 14, char97_stroke1 },
-};
-
-/* char: 98 'b' */
-
-static const CoordRec char98_stroke0[] = {
-    { 8.76, 100 },
-    { 8.76, 0 },
-};
-
-static const CoordRec char98_stroke1[] = {
-    { 8.76, 52.381 },
-    { 18.2838, 61.9048 },
-    { 27.8076, 66.6667 },
-    { 42.0933, 66.6667 },
-    { 51.6171, 61.9048 },
-    { 61.141, 52.381 },
-    { 65.9029, 38.0952 },
-    { 65.9029, 28.5714 },
-    { 61.141, 14.2857 },
-    { 51.6171, 4.7619 },
-    { 42.0933, 0 },
-    { 27.8076, 0 },
-    { 18.2838, 4.7619 },
-    { 8.76, 14.2857 },
-};
-
-static const StrokeRec char98[] = {
-   { 2, char98_stroke0 },
-   { 14, char98_stroke1 },
-};
-
-/* char: 99 'c' */
-
-static const CoordRec char99_stroke0[] = {
-    { 62.6629, 52.381 },
-    { 53.139, 61.9048 },
-    { 43.6152, 66.6667 },
-    { 29.3295, 66.6667 },
-    { 19.8057, 61.9048 },
-    { 10.2819, 52.381 },
-    { 5.52, 38.0952 },
-    { 5.52, 28.5714 },
-    { 10.2819, 14.2857 },
-    { 19.8057, 4.7619 },
-    { 29.3295, 0 },
-    { 43.6152, 0 },
-    { 53.139, 4.7619 },
-    { 62.6629, 14.2857 },
-};
-
-static const StrokeRec char99[] = {
-   { 14, char99_stroke0 },
-};
-
-/* char: 100 'd' */
-
-static const CoordRec char100_stroke0[] = {
-    { 61.7829, 100 },
-    { 61.7829, 0 },
-};
-
-static const CoordRec char100_stroke1[] = {
-    { 61.7829, 52.381 },
-    { 52.259, 61.9048 },
-    { 42.7352, 66.6667 },
-    { 28.4495, 66.6667 },
-    { 18.9257, 61.9048 },
-    { 9.4019, 52.381 },
-    { 4.64, 38.0952 },
-    { 4.64, 28.5714 },
-    { 9.4019, 14.2857 },
-    { 18.9257, 4.7619 },
-    { 28.4495, 0 },
-    { 42.7352, 0 },
-    { 52.259, 4.7619 },
-    { 61.7829, 14.2857 },
-};
-
-static const StrokeRec char100[] = {
-   { 2, char100_stroke0 },
-   { 14, char100_stroke1 },
-};
-
-/* char: 101 'e' */
-
-static const CoordRec char101_stroke0[] = {
-    { 5.72, 38.0952 },
-    { 62.8629, 38.0952 },
-    { 62.8629, 47.619 },
-    { 58.101, 57.1429 },
-    { 53.339, 61.9048 },
-    { 43.8152, 66.6667 },
-    { 29.5295, 66.6667 },
-    { 20.0057, 61.9048 },
-    { 10.4819, 52.381 },
-    { 5.72, 38.0952 },
-    { 5.72, 28.5714 },
-    { 10.4819, 14.2857 },
-    { 20.0057, 4.7619 },
-    { 29.5295, 0 },
-    { 43.8152, 0 },
-    { 53.339, 4.7619 },
-    { 62.8629, 14.2857 },
-};
-
-static const StrokeRec char101[] = {
-   { 17, char101_stroke0 },
-};
-
-/* char: 102 'f' */
-
-static const CoordRec char102_stroke0[] = {
-    { 38.7752, 100 },
-    { 29.2514, 100 },
-    { 19.7276, 95.2381 },
-    { 14.9657, 80.9524 },
-    { 14.9657, 0 },
-};
-
-static const CoordRec char102_stroke1[] = {
-    { 0.68, 66.6667 },
-    { 34.0133, 66.6667 },
-};
-
-static const StrokeRec char102[] = {
-   { 5, char102_stroke0 },
-   { 2, char102_stroke1 },
-};
-
-/* char: 103 'g' */
-
-static const CoordRec char103_stroke0[] = {
-    { 62.5029, 66.6667 },
-    { 62.5029, -9.5238 },
-    { 57.741, -23.8095 },
-    { 52.979, -28.5714 },
-    { 43.4552, -33.3333 },
-    { 29.1695, -33.3333 },
-    { 19.6457, -28.5714 },
-};
-
-static const CoordRec char103_stroke1[] = {
-    { 62.5029, 52.381 },
-    { 52.979, 61.9048 },
-    { 43.4552, 66.6667 },
-    { 29.1695, 66.6667 },
-    { 19.6457, 61.9048 },
-    { 10.1219, 52.381 },
-    { 5.36, 38.0952 },
-    { 5.36, 28.5714 },
-    { 10.1219, 14.2857 },
-    { 19.6457, 4.7619 },
-    { 29.1695, 0 },
-    { 43.4552, 0 },
-    { 52.979, 4.7619 },
-    { 62.5029, 14.2857 },
-};
-
-static const StrokeRec char103[] = {
-   { 7, char103_stroke0 },
-   { 14, char103_stroke1 },
-};
-
-/* char: 104 'h' */
-
-static const CoordRec char104_stroke0[] = {
-    { 9.6, 100 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char104_stroke1[] = {
-    { 9.6, 47.619 },
-    { 23.8857, 61.9048 },
-    { 33.4095, 66.6667 },
-    { 47.6952, 66.6667 },
-    { 57.219, 61.9048 },
-    { 61.981, 47.619 },
-    { 61.981, 0 },
-};
-
-static const StrokeRec char104[] = {
-   { 2, char104_stroke0 },
-   { 7, char104_stroke1 },
-};
-
-/* char: 105 'i' */
-
-static const CoordRec char105_stroke0[] = {
-    { 10.02, 100 },
-    { 14.7819, 95.2381 },
-    { 19.5438, 100 },
-    { 14.7819, 104.762 },
-    { 10.02, 100 },
-};
-
-static const CoordRec char105_stroke1[] = {
-    { 14.7819, 66.6667 },
-    { 14.7819, 0 },
-};
-
-static const StrokeRec char105[] = {
-   { 5, char105_stroke0 },
-   { 2, char105_stroke1 },
-};
-
-/* char: 106 'j' */
-
-static const CoordRec char106_stroke0[] = {
-    { 17.3876, 100 },
-    { 22.1495, 95.2381 },
-    { 26.9114, 100 },
-    { 22.1495, 104.762 },
-    { 17.3876, 100 },
-};
-
-static const CoordRec char106_stroke1[] = {
-    { 22.1495, 66.6667 },
-    { 22.1495, -14.2857 },
-    { 17.3876, -28.5714 },
-    { 7.8638, -33.3333 },
-    { -1.66, -33.3333 },
-};
-
-static const StrokeRec char106[] = {
-   { 5, char106_stroke0 },
-   { 5, char106_stroke1 },
-};
-
-/* char: 107 'k' */
-
-static const CoordRec char107_stroke0[] = {
-    { 9.6, 100 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char107_stroke1[] = {
-    { 57.219, 66.6667 },
-    { 9.6, 19.0476 },
-};
-
-static const CoordRec char107_stroke2[] = {
-    { 28.6476, 38.0952 },
-    { 61.981, 0 },
-};
-
-static const StrokeRec char107[] = {
-   { 2, char107_stroke0 },
-   { 2, char107_stroke1 },
-   { 2, char107_stroke2 },
-};
-
-/* char: 108 'l' */
-
-static const CoordRec char108_stroke0[] = {
-    { 10.02, 100 },
-    { 10.02, 0 },
-};
-
-static const StrokeRec char108[] = {
-   { 2, char108_stroke0 },
-};
-
-/* char: 109 'm' */
-
-static const CoordRec char109_stroke0[] = {
-    { 9.6, 66.6667 },
-    { 9.6, 0 },
-};
-
-static const CoordRec char109_stroke1[] = {
-    { 9.6, 47.619 },
-    { 23.8857, 61.9048 },
-    { 33.4095, 66.6667 },
-    { 47.6952, 66.6667 },
-    { 57.219, 61.9048 },
-    { 61.981, 47.619 },
-    { 61.981, 0 },
-};
-
-static const CoordRec char109_stroke2[] = {
-    { 61.981, 47.619 },
-    { 76.2667, 61.9048 },
-    { 85.7905, 66.6667 },
-    { 100.076, 66.6667 },
-    { 109.6, 61.9048 },
-    { 114.362, 47.619 },
-    { 114.362, 0 },
-};
-
-static const StrokeRec char109[] = {
-   { 2, char109_stroke0 },
-   { 7, char109_stroke1 },
-   { 7, char109_stroke2 },
-};
-
-/* char: 110 'n' */
-
-static const CoordRec char110_stroke0[] = {
-    { 9.18, 66.6667 },
-    { 9.18, 0 },
-};
-
-static const CoordRec char110_stroke1[] = {
-    { 9.18, 47.619 },
-    { 23.4657, 61.9048 },
-    { 32.9895, 66.6667 },
-    { 47.2752, 66.6667 },
-    { 56.799, 61.9048 },
-    { 61.561, 47.619 },
-    { 61.561, 0 },
-};
-
-static const StrokeRec char110[] = {
-   { 2, char110_stroke0 },
-   { 7, char110_stroke1 },
-};
-
-/* char: 111 'o' */
-
-static const CoordRec char111_stroke0[] = {
-    { 28.7895, 66.6667 },
-    { 19.2657, 61.9048 },
-    { 9.7419, 52.381 },
-    { 4.98, 38.0952 },
-    { 4.98, 28.5714 },
-    { 9.7419, 14.2857 },
-    { 19.2657, 4.7619 },
-    { 28.7895, 0 },
-    { 43.0752, 0 },
-    { 52.599, 4.7619 },
-    { 62.1229, 14.2857 },
-    { 66.8848, 28.5714 },
-    { 66.8848, 38.0952 },
-    { 62.1229, 52.381 },
-    { 52.599, 61.9048 },
-    { 43.0752, 66.6667 },
-    { 28.7895, 66.6667 },
-};
-
-static const StrokeRec char111[] = {
-   { 17, char111_stroke0 },
-};
-
-/* char: 112 'p' */
-
-static const CoordRec char112_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, -33.3333 },
-};
-
-static const CoordRec char112_stroke1[] = {
-    { 9.46, 52.381 },
-    { 18.9838, 61.9048 },
-    { 28.5076, 66.6667 },
-    { 42.7933, 66.6667 },
-    { 52.3171, 61.9048 },
-    { 61.841, 52.381 },
-    { 66.6029, 38.0952 },
-    { 66.6029, 28.5714 },
-    { 61.841, 14.2857 },
-    { 52.3171, 4.7619 },
-    { 42.7933, 0 },
-    { 28.5076, 0 },
-    { 18.9838, 4.7619 },
-    { 9.46, 14.2857 },
-};
-
-static const StrokeRec char112[] = {
-   { 2, char112_stroke0 },
-   { 14, char112_stroke1 },
-};
-
-/* char: 113 'q' */
-
-static const CoordRec char113_stroke0[] = {
-    { 61.9829, 66.6667 },
-    { 61.9829, -33.3333 },
-};
-
-static const CoordRec char113_stroke1[] = {
-    { 61.9829, 52.381 },
-    { 52.459, 61.9048 },
-    { 42.9352, 66.6667 },
-    { 28.6495, 66.6667 },
-    { 19.1257, 61.9048 },
-    { 9.6019, 52.381 },
-    { 4.84, 38.0952 },
-    { 4.84, 28.5714 },
-    { 9.6019, 14.2857 },
-    { 19.1257, 4.7619 },
-    { 28.6495, 0 },
-    { 42.9352, 0 },
-    { 52.459, 4.7619 },
-    { 61.9829, 14.2857 },
-};
-
-static const StrokeRec char113[] = {
-   { 2, char113_stroke0 },
-   { 14, char113_stroke1 },
-};
-
-/* char: 114 'r' */
-
-static const CoordRec char114_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, 0 },
-};
-
-static const CoordRec char114_stroke1[] = {
-    { 9.46, 38.0952 },
-    { 14.2219, 52.381 },
-    { 23.7457, 61.9048 },
-    { 33.2695, 66.6667 },
-    { 47.5552, 66.6667 },
-};
-
-static const StrokeRec char114[] = {
-   { 2, char114_stroke0 },
-   { 5, char114_stroke1 },
-};
-
-/* char: 115 's' */
-
-static const CoordRec char115_stroke0[] = {
-    { 57.081, 52.381 },
-    { 52.319, 61.9048 },
-    { 38.0333, 66.6667 },
-    { 23.7476, 66.6667 },
-    { 9.4619, 61.9048 },
-    { 4.7, 52.381 },
-    { 9.4619, 42.8571 },
-    { 18.9857, 38.0952 },
-    { 42.7952, 33.3333 },
-    { 52.319, 28.5714 },
-    { 57.081, 19.0476 },
-    { 57.081, 14.2857 },
-    { 52.319, 4.7619 },
-    { 38.0333, 0 },
-    { 23.7476, 0 },
-    { 9.4619, 4.7619 },
-    { 4.7, 14.2857 },
-};
-
-static const StrokeRec char115[] = {
-   { 17, char115_stroke0 },
-};
-
-/* char: 116 't' */
-
-static const CoordRec char116_stroke0[] = {
-    { 14.8257, 100 },
-    { 14.8257, 19.0476 },
-    { 19.5876, 4.7619 },
-    { 29.1114, 0 },
-    { 38.6352, 0 },
-};
-
-static const CoordRec char116_stroke1[] = {
-    { 0.54, 66.6667 },
-    { 33.8733, 66.6667 },
-};
-
-static const StrokeRec char116[] = {
-   { 5, char116_stroke0 },
-   { 2, char116_stroke1 },
-};
-
-/* char: 117 'u' */
-
-static const CoordRec char117_stroke0[] = {
-    { 9.46, 66.6667 },
-    { 9.46, 19.0476 },
-    { 14.2219, 4.7619 },
-    { 23.7457, 0 },
-    { 38.0314, 0 },
-    { 47.5552, 4.7619 },
-    { 61.841, 19.0476 },
-};
-
-static const CoordRec char117_stroke1[] = {
-    { 61.841, 66.6667 },
-    { 61.841, 0 },
-};
-
-static const StrokeRec char117[] = {
-   { 7, char117_stroke0 },
-   { 2, char117_stroke1 },
-};
-
-/* char: 118 'v' */
-
-static const CoordRec char118_stroke0[] = {
-    { 1.8, 66.6667 },
-    { 30.3714, 0 },
-};
-
-static const CoordRec char118_stroke1[] = {
-    { 58.9429, 66.6667 },
-    { 30.3714, 0 },
-};
-
-static const StrokeRec char118[] = {
-   { 2, char118_stroke0 },
-   { 2, char118_stroke1 },
-};
-
-/* char: 119 'w' */
-
-static const CoordRec char119_stroke0[] = {
-    { 2.5, 66.6667 },
-    { 21.5476, 0 },
-};
-
-static const CoordRec char119_stroke1[] = {
-    { 40.5952, 66.6667 },
-    { 21.5476, 0 },
-};
-
-static const CoordRec char119_stroke2[] = {
-    { 40.5952, 66.6667 },
-    { 59.6429, 0 },
-};
-
-static const CoordRec char119_stroke3[] = {
-    { 78.6905, 66.6667 },
-    { 59.6429, 0 },
-};
-
-static const StrokeRec char119[] = {
-   { 2, char119_stroke0 },
-   { 2, char119_stroke1 },
-   { 2, char119_stroke2 },
-   { 2, char119_stroke3 },
-};
-
-/* char: 120 'x' */
-
-static const CoordRec char120_stroke0[] = {
-    { 1.66, 66.6667 },
-    { 54.041, 0 },
-};
-
-static const CoordRec char120_stroke1[] = {
-    { 54.041, 66.6667 },
-    { 1.66, 0 },
-};
-
-static const StrokeRec char120[] = {
-   { 2, char120_stroke0 },
-   { 2, char120_stroke1 },
-};
-
-/* char: 121 'y' */
-
-static const CoordRec char121_stroke0[] = {
-    { 6.5619, 66.6667 },
-    { 35.1333, 0 },
-};
-
-static const CoordRec char121_stroke1[] = {
-    { 63.7048, 66.6667 },
-    { 35.1333, 0 },
-    { 25.6095, -19.0476 },
-    { 16.0857, -28.5714 },
-    { 6.5619, -33.3333 },
-    { 1.8, -33.3333 },
-};
-
-static const StrokeRec char121[] = {
-   { 2, char121_stroke0 },
-   { 6, char121_stroke1 },
-};
-
-/* char: 122 'z' */
-
-static const CoordRec char122_stroke0[] = {
-    { 56.821, 66.6667 },
-    { 4.44, 0 },
-};
-
-static const CoordRec char122_stroke1[] = {
-    { 4.44, 66.6667 },
-    { 56.821, 66.6667 },
-};
-
-static const CoordRec char122_stroke2[] = {
-    { 4.44, 0 },
-    { 56.821, 0 },
-};
-
-static const StrokeRec char122[] = {
-   { 2, char122_stroke0 },
-   { 2, char122_stroke1 },
-   { 2, char122_stroke2 },
-};
-
-/* char: 123 '{' */
-
-static const CoordRec char123_stroke0[] = {
-    { 31.1895, 119.048 },
-    { 21.6657, 114.286 },
-    { 16.9038, 109.524 },
-    { 12.1419, 100 },
-    { 12.1419, 90.4762 },
-    { 16.9038, 80.9524 },
-    { 21.6657, 76.1905 },
-    { 26.4276, 66.6667 },
-    { 26.4276, 57.1429 },
-    { 16.9038, 47.619 },
-};
-
-static const CoordRec char123_stroke1[] = {
-    { 21.6657, 114.286 },
-    { 16.9038, 104.762 },
-    { 16.9038, 95.2381 },
-    { 21.6657, 85.7143 },
-    { 26.4276, 80.9524 },
-    { 31.1895, 71.4286 },
-    { 31.1895, 61.9048 },
-    { 26.4276, 52.381 },
-    { 7.38, 42.8571 },
-    { 26.4276, 33.3333 },
-    { 31.1895, 23.8095 },
-    { 31.1895, 14.2857 },
-    { 26.4276, 4.7619 },
-    { 21.6657, 0 },
-    { 16.9038, -9.5238 },
-    { 16.9038, -19.0476 },
-    { 21.6657, -28.5714 },
-};
-
-static const CoordRec char123_stroke2[] = {
-    { 16.9038, 38.0952 },
-    { 26.4276, 28.5714 },
-    { 26.4276, 19.0476 },
-    { 21.6657, 9.5238 },
-    { 16.9038, 4.7619 },
-    { 12.1419, -4.7619 },
-    { 12.1419, -14.2857 },
-    { 16.9038, -23.8095 },
-    { 21.6657, -28.5714 },
-    { 31.1895, -33.3333 },
-};
-
-static const StrokeRec char123[] = {
-   { 10, char123_stroke0 },
-   { 17, char123_stroke1 },
-   { 10, char123_stroke2 },
-};
-
-/* char: 124 '|' */
-
-static const CoordRec char124_stroke0[] = {
-    { 11.54, 119.048 },
-    { 11.54, -33.3333 },
-};
-
-static const StrokeRec char124[] = {
-   { 2, char124_stroke0 },
-};
-
-/* char: 125 '}' */
-
-static const CoordRec char125_stroke0[] = {
-    { 9.18, 119.048 },
-    { 18.7038, 114.286 },
-    { 23.4657, 109.524 },
-    { 28.2276, 100 },
-    { 28.2276, 90.4762 },
-    { 23.4657, 80.9524 },
-    { 18.7038, 76.1905 },
-    { 13.9419, 66.6667 },
-    { 13.9419, 57.1429 },
-    { 23.4657, 47.619 },
-};
-
-static const CoordRec char125_stroke1[] = {
-    { 18.7038, 114.286 },
-    { 23.4657, 104.762 },
-    { 23.4657, 95.2381 },
-    { 18.7038, 85.7143 },
-    { 13.9419, 80.9524 },
-    { 9.18, 71.4286 },
-    { 9.18, 61.9048 },
-    { 13.9419, 52.381 },
-    { 32.9895, 42.8571 },
-    { 13.9419, 33.3333 },
-    { 9.18, 23.8095 },
-    { 9.18, 14.2857 },
-    { 13.9419, 4.7619 },
-    { 18.7038, 0 },
-    { 23.4657, -9.5238 },
-    { 23.4657, -19.0476 },
-    { 18.7038, -28.5714 },
-};
-
-static const CoordRec char125_stroke2[] = {
-    { 23.4657, 38.0952 },
-    { 13.9419, 28.5714 },
-    { 13.9419, 19.0476 },
-    { 18.7038, 9.5238 },
-    { 23.4657, 4.7619 },
-    { 28.2276, -4.7619 },
-    { 28.2276, -14.2857 },
-    { 23.4657, -23.8095 },
-    { 18.7038, -28.5714 },
-    { 9.18, -33.3333 },
-};
-
-static const StrokeRec char125[] = {
-   { 10, char125_stroke0 },
-   { 17, char125_stroke1 },
-   { 10, char125_stroke2 },
-};
-
-/* char: 126 '~' */
-
-static const CoordRec char126_stroke0[] = {
-    { 2.92, 28.5714 },
-    { 2.92, 38.0952 },
-    { 7.6819, 52.381 },
-    { 17.2057, 57.1429 },
-    { 26.7295, 57.1429 },
-    { 36.2533, 52.381 },
-    { 55.301, 38.0952 },
-    { 64.8248, 33.3333 },
-    { 74.3486, 33.3333 },
-    { 83.8724, 38.0952 },
-    { 88.6343, 47.619 },
-};
-
-static const CoordRec char126_stroke1[] = {
-    { 2.92, 38.0952 },
-    { 7.6819, 47.619 },
-    { 17.2057, 52.381 },
-    { 26.7295, 52.381 },
-    { 36.2533, 47.619 },
-    { 55.301, 33.3333 },
-    { 64.8248, 28.5714 },
-    { 74.3486, 28.5714 },
-    { 83.8724, 33.3333 },
-    { 88.6343, 47.619 },
-    { 88.6343, 57.1429 },
-};
-
-static const StrokeRec char126[] = {
-   { 11, char126_stroke0 },
-   { 11, char126_stroke1 },
-};
-
-/* char: 127 */
-
-static const CoordRec char127_stroke0[] = {
-    { 52.381, 100 },
-    { 14.2857, -33.3333 },
-};
-
-static const CoordRec char127_stroke1[] = {
-    { 28.5714, 66.6667 },
-    { 14.2857, 61.9048 },
-    { 4.7619, 52.381 },
-    { 0, 38.0952 },
-    { 0, 23.8095 },
-    { 4.7619, 14.2857 },
-    { 14.2857, 4.7619 },
-    { 28.5714, 0 },
-    { 38.0952, 0 },
-    { 52.381, 4.7619 },
-    { 61.9048, 14.2857 },
-    { 66.6667, 28.5714 },
-    { 66.6667, 42.8571 },
-    { 61.9048, 52.381 },
-    { 52.381, 61.9048 },
-    { 38.0952, 66.6667 },
-    { 28.5714, 66.6667 },
-};
-
-static const StrokeRec char127[] = {
-   { 2, char127_stroke0 },
-   { 17, char127_stroke1 },
-};
-
-static const StrokeCharRec chars[] = {
-    { 0, /* char0 */ 0, 0, 0 },
-    { 0, /* char1 */ 0, 0, 0 },
-    { 0, /* char2 */ 0, 0, 0 },
-    { 0, /* char3 */ 0, 0, 0 },
-    { 0, /* char4 */ 0, 0, 0 },
-    { 0, /* char5 */ 0, 0, 0 },
-    { 0, /* char6 */ 0, 0, 0 },
-    { 0, /* char7 */ 0, 0, 0 },
-    { 0, /* char8 */ 0, 0, 0 },
-    { 0, /* char9 */ 0, 0, 0 },
-    { 0, /* char10 */ 0, 0, 0 },
-    { 0, /* char11 */ 0, 0, 0 },
-    { 0, /* char12 */ 0, 0, 0 },
-    { 0, /* char13 */ 0, 0, 0 },
-    { 0, /* char14 */ 0, 0, 0 },
-    { 0, /* char15 */ 0, 0, 0 },
-    { 0, /* char16 */ 0, 0, 0 },
-    { 0, /* char17 */ 0, 0, 0 },
-    { 0, /* char18 */ 0, 0, 0 },
-    { 0, /* char19 */ 0, 0, 0 },
-    { 0, /* char20 */ 0, 0, 0 },
-    { 0, /* char21 */ 0, 0, 0 },
-    { 0, /* char22 */ 0, 0, 0 },
-    { 0, /* char23 */ 0, 0, 0 },
-    { 0, /* char24 */ 0, 0, 0 },
-    { 0, /* char25 */ 0, 0, 0 },
-    { 0, /* char26 */ 0, 0, 0 },
-    { 0, /* char27 */ 0, 0, 0 },
-    { 0, /* char28 */ 0, 0, 0 },
-    { 0, /* char29 */ 0, 0, 0 },
-    { 0, /* char30 */ 0, 0, 0 },
-    { 0, /* char31 */ 0, 0, 0 },
-    { 0, /* char32 */ 0, 52.381, 104.762 },
-    { 2, char33, 13.3819, 26.6238 },
-    { 2, char34, 23.0676, 51.4352 },
-    { 4, char35, 36.5333, 79.4886 },
-    { 3, char36, 38.1533, 76.2067 },
-    { 3, char37, 49.2171, 96.5743 },
-    { 1, char38, 53.599, 101.758 },
-    { 1, char39, 4.44, 13.62 },
-    { 1, char40, 21.8657, 47.1733 },
-    { 1, char41, 24.3276, 47.5333 },
-    { 3, char42, 30.7695, 59.439 },
-    { 2, char43, 48.8371, 97.2543 },
-    { 1, char44, 13.5219, 26.0638 },
-    { 1, char45, 50.2371, 100.754 },
-    { 1, char46, 13.1019, 26.4838 },
-    { 1, char47, 40.5733, 82.1067 },
-    { 1, char48, 38.3133, 77.0667 },
-    { 1, char49, 30.8676, 66.5295 },
-    { 1, char50, 38.7533, 77.6467 },
-    { 1, char51, 38.3333, 77.0467 },
-    { 2, char52, 37.2133, 80.1686 },
-    { 1, char53, 38.1933, 77.6867 },
-    { 1, char54, 34.1514, 73.8048 },
-    { 2, char55, 38.8933, 77.2267 },
-    { 1, char56, 38.9333, 77.6667 },
-    { 1, char57, 39.9333, 74.0648 },
-    { 2, char58, 14.0819, 26.2238 },
-    { 2, char59, 12.9619, 26.3038 },
-    { 1, char60, 41.1552, 81.6105 },
-    { 2, char61, 48.5571, 97.2543 },
-    { 1, char62, 40.8752, 81.6105 },
-    { 2, char63, 36.9914, 73.9029 },
-    { 2, char64, 34.9314, 74.3648 },
-    { 3, char65, 40.5952, 80.4905 },
-    { 3, char66, 44.7533, 83.6267 },
-    { 1, char67, 39.9933, 84.4886 },
-    { 2, char68, 45.2933, 85.2867 },
-    { 4, char69, 39.9914, 78.1848 },
-    { 3, char70, 39.9914, 78.7448 },
-    { 2, char71, 40.3933, 89.7686 },
-    { 3, char72, 44.7533, 89.0867 },
-    { 1, char73, 10.86, 21.3 },
-    { 1, char74, 31.0714, 59.999 },
-    { 3, char75, 44.6133, 79.3267 },
-    { 2, char76, 40.2514, 71.3229 },
-    { 4, char77, 48.9552, 97.2105 },
-    { 3, char78, 44.4733, 88.8067 },
-    { 1, char79, 44.3352, 88.8305 },
-    { 2, char80, 45.4333, 85.6667 },
-    { 2, char81, 43.3952, 88.0905 },
-    { 3, char82, 45.0133, 82.3667 },
-    { 1, char83, 41.3333, 80.8267 },
-    { 2, char84, 35.6933, 71.9467 },
-    { 1, char85, 44.8733, 89.4867 },
-    { 2, char86, 40.4552, 81.6105 },
-    { 4, char87, 49.839, 100.518 },
-    { 2, char88, 35.8333, 72.3667 },
-    { 2, char89, 39.6152, 79.6505 },
-    { 3, char90, 35.8333, 73.7467 },
-    { 4, char91, 22.0657, 46.1133 },
-    { 1, char92, 39.1733, 78.2067 },
-    { 4, char93, 23.4876, 46.3933 },
-    { 2, char94, 44.0752, 90.2305 },
-    { 1, char95, 51.281, 104.062 },
-    { 2, char96, 42.5457, 83.5714 },
-    { 2, char97, 35.2514, 66.6029 },
-    { 2, char98, 37.3314, 70.4629 },
-    { 1, char99, 34.0914, 68.9229 },
-    { 2, char100, 33.2114, 70.2629 },
-    { 1, char101, 34.2914, 68.5229 },
-    { 2, char102, 14.9657, 38.6552 },
-    { 2, char103, 33.9314, 70.9829 },
-    { 2, char104, 33.4095, 71.021 },
-    { 2, char105, 14.7819, 28.8638 },
-    { 2, char106, 17.3876, 36.2314 },
-    { 3, char107, 33.4095, 62.521 },
-    { 1, char108, 10.02, 19.34 },
-    { 3, char109, 61.981, 123.962 },
-    { 2, char110, 32.9895, 70.881 },
-    { 1, char111, 33.5514, 71.7448 },
-    { 2, char112, 38.0314, 70.8029 },
-    { 2, char113, 33.4114, 70.7429 },
-    { 2, char114, 23.7457, 49.4952 },
-    { 1, char115, 28.5095, 62.321 },
-    { 2, char116, 14.8257, 39.3152 },
-    { 2, char117, 33.2695, 71.161 },
-    { 2, char118, 30.3714, 60.6029 },
-    { 4, char119, 40.5952, 80.4905 },
-    { 2, char120, 25.4695, 56.401 },
-    { 2, char121, 35.1333, 66.0648 },
-    { 3, char122, 28.2495, 61.821 },
-    { 3, char123, 21.6657, 41.6295 },
-    { 1, char124, 11.54, 23.78 },
-    { 3, char125, 18.7038, 41.4695 },
-    { 2, char126, 45.7771, 91.2743 },
-    { 2, char127, 33.3333, 66.6667 },
-};
-
-GLUTAPI const StrokeFontRec glutStrokeRoman;
-const StrokeFontRec glutStrokeRoman = { "Roman", 128, chars, 119.048, -33.3333 };
-
diff --git a/src/glut/glx/glut_shapes.c b/src/glut/glx/glut_shapes.c
deleted file mode 100644
index 20e21026c26..00000000000
--- a/src/glut/glx/glut_shapes.c
+++ /dev/null
@@ -1,596 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
-
-/**
-(c) Copyright 1993, Silicon Graphics, Inc.
-
-ALL RIGHTS RESERVED
-
-Permission to use, copy, modify, and distribute this software
-for any purpose and without fee is hereby granted, provided
-that the above copyright notice appear in all copies and that
-both the copyright notice and this permission notice appear in
-supporting documentation, and that the name of Silicon
-Graphics, Inc. not be used in advertising or publicity
-pertaining to distribution of the software without specific,
-written prior permission.
-
-THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
-"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
-OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
-EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
-ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
-CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
-INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
-SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
-NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
-OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
-PERFORMANCE OF THIS SOFTWARE.
-
-US Government Users Restricted Rights
-
-Use, duplication, or disclosure by the Government is subject to
-restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
-(c)(1)(ii) of the Rights in Technical Data and Computer
-Software clause at DFARS 252.227-7013 and/or in similar or
-successor clauses in the FAR or the DOD or NASA FAR
-Supplement.  Unpublished-- rights reserved under the copyright
-laws of the United States.  Contractor/manufacturer is Silicon
-Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
-94039-7311.
-
-OpenGL(TM) is a trademark of Silicon Graphics, Inc.
-*/
-
-#include <math.h>
-#include "glutint.h"
-
-/* Some <math.h> files do not define M_PI... */
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-static GLUquadricObj *quadObj;
-
-#define QUAD_OBJ_INIT() { if(!quadObj) initQuadObj(); }
-
-static void
-initQuadObj(void)
-{
-  quadObj = gluNewQuadric();
-  if (!quadObj)
-    __glutFatalError("out of memory.");
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireSphere(GLdouble radius, GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_LINE);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluSphere(quadObj, radius, slices, stacks);
-}
-
-void GLUTAPIENTRY
-glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_FILL);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluSphere(quadObj, radius, slices, stacks);
-}
-
-void GLUTAPIENTRY
-glutWireCone(GLdouble base, GLdouble height,
-  GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_LINE);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
-}
-
-void GLUTAPIENTRY
-glutSolidCone(GLdouble base, GLdouble height,
-  GLint slices, GLint stacks)
-{
-  QUAD_OBJ_INIT();
-  gluQuadricDrawStyle(quadObj, GLU_FILL);
-  gluQuadricNormals(quadObj, GLU_SMOOTH);
-  /* If we ever changed/used the texture or orientation state
-     of quadObj, we'd need to change it to the defaults here
-     with gluQuadricTexture and/or gluQuadricOrientation. */
-  gluCylinder(quadObj, base, 0.0, height, slices, stacks);
-}
-
-/* ENDCENTRY */
-
-static void
-drawBox(GLfloat size, GLenum type)
-{
-  static GLfloat n[6][3] =
-  {
-    {-1.0, 0.0, 0.0},
-    {0.0, 1.0, 0.0},
-    {1.0, 0.0, 0.0},
-    {0.0, -1.0, 0.0},
-    {0.0, 0.0, 1.0},
-    {0.0, 0.0, -1.0}
-  };
-  static GLint faces[6][4] =
-  {
-    {0, 1, 2, 3},
-    {3, 2, 6, 7},
-    {7, 6, 5, 4},
-    {4, 5, 1, 0},
-    {5, 6, 2, 1},
-    {7, 4, 0, 3}
-  };
-  GLfloat v[8][3];
-  GLint i;
-
-  v[0][0] = v[1][0] = v[2][0] = v[3][0] = -size / 2;
-  v[4][0] = v[5][0] = v[6][0] = v[7][0] = size / 2;
-  v[0][1] = v[1][1] = v[4][1] = v[5][1] = -size / 2;
-  v[2][1] = v[3][1] = v[6][1] = v[7][1] = size / 2;
-  v[0][2] = v[3][2] = v[4][2] = v[7][2] = -size / 2;
-  v[1][2] = v[2][2] = v[5][2] = v[6][2] = size / 2;
-
-  for (i = 5; i >= 0; i--) {
-    glBegin(type);
-    glNormal3fv(&n[i][0]);
-    glVertex3fv(&v[faces[i][0]][0]);
-    glVertex3fv(&v[faces[i][1]][0]);
-    glVertex3fv(&v[faces[i][2]][0]);
-    glVertex3fv(&v[faces[i][3]][0]);
-    glEnd();
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireCube(GLdouble size)
-{
-  drawBox(size, GL_LINE_LOOP);
-}
-
-void GLUTAPIENTRY
-glutSolidCube(GLdouble size)
-{
-  drawBox(size, GL_QUADS);
-}
-
-/* ENDCENTRY */
-
-static void
-doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings)
-{
-  int i, j;
-  GLfloat theta, phi, theta1;
-  GLfloat cosTheta, sinTheta;
-  GLfloat cosTheta1, sinTheta1;
-  GLfloat ringDelta, sideDelta;
-
-  ringDelta = 2.0 * M_PI / rings;
-  sideDelta = 2.0 * M_PI / nsides;
-
-  theta = 0.0;
-  cosTheta = 1.0;
-  sinTheta = 0.0;
-  for (i = rings - 1; i >= 0; i--) {
-    theta1 = theta + ringDelta;
-    cosTheta1 = cos(theta1);
-    sinTheta1 = sin(theta1);
-    glBegin(GL_QUAD_STRIP);
-    phi = 0.0;
-    for (j = nsides; j >= 0; j--) {
-      GLfloat cosPhi, sinPhi, dist;
-
-      phi += sideDelta;
-      cosPhi = cos(phi);
-      sinPhi = sin(phi);
-      dist = R + r * cosPhi;
-
-      glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
-      glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi);
-      glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi);
-      glVertex3f(cosTheta * dist, -sinTheta * dist,  r * sinPhi);
-    }
-    glEnd();
-    theta = theta1;
-    cosTheta = cosTheta1;
-    sinTheta = sinTheta1;
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireTorus(GLdouble innerRadius, GLdouble outerRadius,
-  GLint nsides, GLint rings)
-{
-  glPushAttrib(GL_POLYGON_BIT);
-  glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-  doughnut(innerRadius, outerRadius, nsides, rings);
-  glPopAttrib();
-}
-
-void GLUTAPIENTRY
-glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius,
-  GLint nsides, GLint rings)
-{
-  doughnut(innerRadius, outerRadius, nsides, rings);
-}
-
-/* ENDCENTRY */
-
-static GLfloat dodec[20][3];
-
-static void
-initDodecahedron(void)
-{
-  GLfloat alpha, beta;
-
-  alpha = sqrt(2.0 / (3.0 + sqrt(5.0)));
-  beta = 1.0 + sqrt(6.0 / (3.0 + sqrt(5.0)) -
-    2.0 + 2.0 * sqrt(2.0 / (3.0 + sqrt(5.0))));
-  /* *INDENT-OFF* */
-  dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta;
-  dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta;
-  dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1;
-  dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1;
-  dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1;
-  dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1;
-  dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1;
-  dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1;
-  dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1;
-  dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1;
-  dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0;
-  dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0;
-  dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0;
-  dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0;
-  dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta;
-  dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta;
-  dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha;
-  dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha;
-  dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha;
-  dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha;
-  /* *INDENT-ON* */
-
-}
-
-#define DIFF3(_a,_b,_c) { \
-    (_c)[0] = (_a)[0] - (_b)[0]; \
-    (_c)[1] = (_a)[1] - (_b)[1]; \
-    (_c)[2] = (_a)[2] - (_b)[2]; \
-}
-
-static void
-crossprod(GLfloat v1[3], GLfloat v2[3], GLfloat prod[3])
-{
-  GLfloat p[3];         /* in case prod == v1 or v2 */
-
-  p[0] = v1[1] * v2[2] - v2[1] * v1[2];
-  p[1] = v1[2] * v2[0] - v2[2] * v1[0];
-  p[2] = v1[0] * v2[1] - v2[0] * v1[1];
-  prod[0] = p[0];
-  prod[1] = p[1];
-  prod[2] = p[2];
-}
-
-static void
-normalize(GLfloat v[3])
-{
-  GLfloat d;
-
-  d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (d == 0.0) {
-    __glutWarning("normalize: zero length vector");
-    v[0] = d = 1.0;
-  }
-  d = 1 / d;
-  v[0] *= d;
-  v[1] *= d;
-  v[2] *= d;
-}
-
-static void
-pentagon(int a, int b, int c, int d, int e, GLenum shadeType)
-{
-  GLfloat n0[3], d1[3], d2[3];
-
-  DIFF3(dodec[a], dodec[b], d1);
-  DIFF3(dodec[b], dodec[c], d2);
-  crossprod(d1, d2, n0);
-  normalize(n0);
-
-  glBegin(shadeType);
-  glNormal3fv(n0);
-  glVertex3fv(&dodec[a][0]);
-  glVertex3fv(&dodec[b][0]);
-  glVertex3fv(&dodec[c][0]);
-  glVertex3fv(&dodec[d][0]);
-  glVertex3fv(&dodec[e][0]);
-  glEnd();
-}
-
-static void
-dodecahedron(GLenum type)
-{
-  static int inited = 0;
-
-  if (inited == 0) {
-    inited = 1;
-    initDodecahedron();
-  }
-  pentagon(0, 1, 9, 16, 5, type);
-  pentagon(1, 0, 3, 18, 7, type);
-  pentagon(1, 7, 11, 10, 9, type);
-  pentagon(11, 7, 18, 19, 6, type);
-  pentagon(8, 17, 16, 9, 10, type);
-  pentagon(2, 14, 15, 6, 19, type);
-  pentagon(2, 13, 12, 4, 14, type);
-  pentagon(2, 19, 18, 3, 13, type);
-  pentagon(3, 0, 5, 12, 13, type);
-  pentagon(6, 15, 8, 10, 11, type);
-  pentagon(4, 17, 8, 15, 14, type);
-  pentagon(4, 12, 5, 16, 17, type);
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireDodecahedron(void)
-{
-  dodecahedron(GL_LINE_LOOP);
-}
-
-void GLUTAPIENTRY
-glutSolidDodecahedron(void)
-{
-  dodecahedron(GL_TRIANGLE_FAN);
-}
-
-/* ENDCENTRY */
-
-static void
-recorditem(GLfloat * n1, GLfloat * n2, GLfloat * n3,
-  GLenum shadeType)
-{
-  GLfloat q0[3], q1[3];
-
-  DIFF3(n1, n2, q0);
-  DIFF3(n2, n3, q1);
-  crossprod(q0, q1, q1);
-  normalize(q1);
-
-  glBegin(shadeType);
-  glNormal3fv(q1);
-  glVertex3fv(n1);
-  glVertex3fv(n2);
-  glVertex3fv(n3);
-  glEnd();
-}
-
-static void
-subdivide(GLfloat * v0, GLfloat * v1, GLfloat * v2,
-  GLenum shadeType)
-{
-  int depth;
-  GLfloat w0[3], w1[3], w2[3];
-  GLfloat l;
-  int i, j, k, n;
-
-  depth = 1;
-  for (i = 0; i < depth; i++) {
-    for (j = 0; i + j < depth; j++) {
-      k = depth - i - j;
-      for (n = 0; n < 3; n++) {
-        w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth;
-        w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n])
-          / depth;
-        w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n])
-          / depth;
-      }
-      l = sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]);
-      w0[0] /= l;
-      w0[1] /= l;
-      w0[2] /= l;
-      l = sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]);
-      w1[0] /= l;
-      w1[1] /= l;
-      w1[2] /= l;
-      l = sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]);
-      w2[0] /= l;
-      w2[1] /= l;
-      w2[2] /= l;
-      recorditem(w1, w0, w2, shadeType);
-    }
-  }
-}
-
-static void
-drawtriangle(int i, GLfloat data[][3], int ndx[][3],
-  GLenum shadeType)
-{
-  GLfloat *x0, *x1, *x2;
-
-  x0 = data[ndx[i][0]];
-  x1 = data[ndx[i][1]];
-  x2 = data[ndx[i][2]];
-  subdivide(x0, x1, x2, shadeType);
-}
-
-/* octahedron data: The octahedron produced is centered at the
-   origin and has radius 1.0 */
-static GLfloat odata[6][3] =
-{
-  {1.0, 0.0, 0.0},
-  {-1.0, 0.0, 0.0},
-  {0.0, 1.0, 0.0},
-  {0.0, -1.0, 0.0},
-  {0.0, 0.0, 1.0},
-  {0.0, 0.0, -1.0}
-};
-
-static int ondex[8][3] =
-{
-  {0, 4, 2},
-  {1, 2, 4},
-  {0, 3, 4},
-  {1, 4, 3},
-  {0, 2, 5},
-  {1, 5, 2},
-  {0, 5, 3},
-  {1, 3, 5}
-};
-
-static void
-octahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 7; i >= 0; i--) {
-    drawtriangle(i, odata, ondex, shadeType);
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireOctahedron(void)
-{
-  octahedron(GL_LINE_LOOP);
-}
-
-void GLUTAPIENTRY
-glutSolidOctahedron(void)
-{
-  octahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
-
-/* icosahedron data: These numbers are rigged to make an
-   icosahedron of radius 1.0 */
-
-#define X .525731112119133606
-#define Z .850650808352039932
-
-static GLfloat idata[12][3] =
-{
-  {-X, 0, Z},
-  {X, 0, Z},
-  {-X, 0, -Z},
-  {X, 0, -Z},
-  {0, Z, X},
-  {0, Z, -X},
-  {0, -Z, X},
-  {0, -Z, -X},
-  {Z, X, 0},
-  {-Z, X, 0},
-  {Z, -X, 0},
-  {-Z, -X, 0}
-};
-
-static int index[20][3] =
-{
-  {0, 4, 1},
-  {0, 9, 4},
-  {9, 5, 4},
-  {4, 5, 8},
-  {4, 8, 1},
-  {8, 10, 1},
-  {8, 3, 10},
-  {5, 3, 8},
-  {5, 2, 3},
-  {2, 7, 3},
-  {7, 10, 3},
-  {7, 6, 10},
-  {7, 11, 6},
-  {11, 0, 6},
-  {0, 1, 6},
-  {6, 1, 10},
-  {9, 0, 11},
-  {9, 11, 2},
-  {9, 2, 5},
-  {7, 2, 11},
-};
-
-static void
-icosahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 19; i >= 0; i--) {
-    drawtriangle(i, idata, index, shadeType);
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireIcosahedron(void)
-{
-  icosahedron(GL_LINE_LOOP);
-}
-
-void GLUTAPIENTRY
-glutSolidIcosahedron(void)
-{
-  icosahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
-
-/* tetrahedron data: */
-
-#define T       1.73205080756887729
-
-static GLfloat tdata[4][3] =
-{
-  {T, T, T},
-  {T, -T, -T},
-  {-T, T, -T},
-  {-T, -T, T}
-};
-
-static int tndex[4][3] =
-{
-  {0, 1, 3},
-  {2, 1, 0},
-  {3, 2, 0},
-  {1, 2, 3}
-};
-
-static void
-tetrahedron(GLenum shadeType)
-{
-  int i;
-
-  for (i = 3; i >= 0; i--)
-    drawtriangle(i, tdata, tndex, shadeType);
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWireTetrahedron(void)
-{
-  tetrahedron(GL_LINE_LOOP);
-}
-
-void GLUTAPIENTRY
-glutSolidTetrahedron(void)
-{
-  tetrahedron(GL_TRIANGLES);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_space.c b/src/glut/glx/glut_space.c
deleted file mode 100644
index cde6ea732ce..00000000000
--- a/src/glut/glx/glut_space.c
+++ /dev/null
@@ -1,35 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-
-void GLUTAPIENTRY 
-glutSpaceballMotionFunc(GLUTspaceMotionCB spaceMotionFunc)
-{
-  __glutCurrentWindow->spaceMotion = spaceMotionFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
-
-void GLUTAPIENTRY 
-glutSpaceballRotateFunc(GLUTspaceRotateCB spaceRotateFunc)
-{
-  __glutCurrentWindow->spaceRotate = spaceRotateFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
-
-void GLUTAPIENTRY 
-glutSpaceballButtonFunc(GLUTspaceButtonCB spaceButtonFunc)
-{
-  __glutCurrentWindow->spaceButton = spaceButtonFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
diff --git a/src/glut/glx/glut_stroke.c b/src/glut/glx/glut_stroke.c
deleted file mode 100644
index 7569012ec4e..00000000000
--- a/src/glut/glx/glut_stroke.c
+++ /dev/null
@@ -1,42 +0,0 @@
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutstroke.h"
-
-void GLUTAPIENTRY 
-glutStrokeCharacter(GLUTstrokeFont font, int c)
-{
-  const StrokeCharRec *ch;
-  const StrokeRec *stroke;
-  const CoordRec *coord;
-  StrokeFontPtr fontinfo;
-  int i, j;
-
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  if (c < 0 || c >= fontinfo->num_chars)
-    return;
-  ch = &(fontinfo->ch[c]);
-  if (ch) {
-    for (i = ch->num_strokes, stroke = ch->stroke;
-      i > 0; i--, stroke++) {
-      glBegin(GL_LINE_STRIP);
-      for (j = stroke->num_coords, coord = stroke->coord;
-        j > 0; j--, coord++) {
-        glVertex2f(coord->x, coord->y);
-      }
-      glEnd();
-    }
-    glTranslatef(ch->right, 0.0, 0.0);
-  }
-}
diff --git a/src/glut/glx/glut_swap.c b/src/glut/glx/glut_swap.c
deleted file mode 100644
index 07a2da88a2c..00000000000
--- a/src/glut/glx/glut_swap.c
+++ /dev/null
@@ -1,71 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997.  */
-
-/* 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. */
-
-#include <stdio.h>
-#include "glutint.h"
-
-GLint __glutFPS = 0;
-GLint __glutSwapCount = 0;
-GLint __glutSwapTime = 0;
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutSwapBuffers(void)
-{
-  GLUTwindow *window = __glutCurrentWindow;
-
-  if (__glutPPMFile) {
-     __glutWritePPMFile();
-  }
-
-  if (window->renderWin == window->win) {
-    if (__glutCurrentWindow->treatAsSingle) {
-      /* Pretend the double buffered window is single buffered,
-         so treat glutSwapBuffers as a no-op. */
-      return;
-    }
-  } else {
-    if (__glutCurrentWindow->overlay->treatAsSingle) {
-      /* Pretend the double buffered overlay is single
-         buffered, so treat glutSwapBuffers as a no-op. */
-      return;
-    }
-  }
-
-  /* For the MESA_SWAP_HACK. */
-  window->usedSwapBuffers = 1;
-
-  SWAP_BUFFERS_LAYER(__glutCurrentWindow);
-
-  /* I considered putting the window being swapped on the
-     GLUT_FINISH_WORK work list because you could call
-     glutSwapBuffers from an idle callback which doesn't call
-     __glutSetWindow which normally adds indirect rendering
-     windows to the GLUT_FINISH_WORK work list.  Not being put
-     on the list could lead to the buffering up of multiple
-     redisplays and buffer swaps and hamper interactivity.  I
-     consider this an application bug due to not using
-     glutPostRedisplay to trigger redraws.  If
-     glutPostRedisplay were used, __glutSetWindow would be
-     called and a glFinish to throttle buffering would occur. */
-
-  if (__glutFPS) {
-     GLint t = glutGet(GLUT_ELAPSED_TIME);
-     __glutSwapCount++;
-     if (__glutSwapTime == 0)
-        __glutSwapTime = t;
-     else if (t - __glutSwapTime > __glutFPS) {
-        float time = 0.001 * (t - __glutSwapTime);
-        float fps = (float) __glutSwapCount / time;
-        fprintf(stderr, "GLUT: %d frames in %.2f seconds = %.2f FPS\n",
-                __glutSwapCount, time, fps);
-        __glutSwapTime = t;
-        __glutSwapCount = 0;
-     }
-  }
-}
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_swidth.c b/src/glut/glx/glut_swidth.c
deleted file mode 100644
index 4717bbff5b1..00000000000
--- a/src/glut/glx/glut_swidth.c
+++ /dev/null
@@ -1,58 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1995. */
-
-/* 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. */
-
-#include "glutint.h"
-#include "glutstroke.h"
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutStrokeWidth(GLUTstrokeFont font, int c)
-{
-  StrokeFontPtr fontinfo;
-  const StrokeCharRec *ch;
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  if (c < 0 || c >= fontinfo->num_chars)
-    return 0;
-  ch = &(fontinfo->ch[c]);
-  if (ch)
-    return ch->right;
-  else
-    return 0;
-}
-
-int GLUTAPIENTRY 
-glutStrokeLength(GLUTstrokeFont font, const unsigned char *string)
-{
-  int c, length;
-  StrokeFontPtr fontinfo;
-  const StrokeCharRec *ch;
-
-#if defined(_WIN32) || defined(GLUT_IMPORT_LIB)
-  fontinfo = (StrokeFontPtr) __glutFont(font);
-#else
-  fontinfo = (StrokeFontPtr) font;
-#endif
-
-  length = 0;
-  for (; *string != '\0'; string++) {
-    c = *string;
-    if (c >= 0 && c < fontinfo->num_chars) {
-      ch = &(fontinfo->ch[c]);
-      if (ch)
-        length += ch->right;
-    }
-  }
-  return length;
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_tablet.c b/src/glut/glx/glut_tablet.c
deleted file mode 100644
index 80c68288c1d..00000000000
--- a/src/glut/glx/glut_tablet.c
+++ /dev/null
@@ -1,33 +0,0 @@
-
-/* 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. */
-
-#include <stdlib.h>
-
-#include "glutint.h"
-
-void GLUTAPIENTRY 
-glutTabletMotionFunc(GLUTtabletMotionCB tabletMotionFunc)
-{
-  __glutCurrentWindow->tabletMotion = tabletMotionFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-  /* If deinstalling callback, invalidate tablet position. */
-  if (tabletMotionFunc == NULL) {
-    __glutCurrentWindow->tabletPos[0] = -1;
-    __glutCurrentWindow->tabletPos[1] = -1;
-  }
-}
-
-void GLUTAPIENTRY 
-glutTabletButtonFunc(GLUTtabletButtonCB tabletButtonFunc)
-{
-  __glutCurrentWindow->tabletButton = tabletButtonFunc;
-  __glutUpdateInputDeviceMaskFunc = __glutUpdateInputDeviceMask;
-  __glutPutOnWorkList(__glutCurrentWindow,
-    GLUT_DEVICE_MASK_WORK);
-}
diff --git a/src/glut/glx/glut_teapot.c b/src/glut/glx/glut_teapot.c
deleted file mode 100644
index ff46d96b85a..00000000000
--- a/src/glut/glx/glut_teapot.c
+++ /dev/null
@@ -1,210 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994. */
-
-/**
-(c) Copyright 1993, Silicon Graphics, Inc.
-
-ALL RIGHTS RESERVED
-
-Permission to use, copy, modify, and distribute this software
-for any purpose and without fee is hereby granted, provided
-that the above copyright notice appear in all copies and that
-both the copyright notice and this permission notice appear in
-supporting documentation, and that the name of Silicon
-Graphics, Inc. not be used in advertising or publicity
-pertaining to distribution of the software without specific,
-written prior permission.
-
-THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
-"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
-OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
-MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
-EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
-ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
-CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
-INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
-SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
-NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
-OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
-PERFORMANCE OF THIS SOFTWARE.
-
-US Government Users Restricted Rights
-
-Use, duplication, or disclosure by the Government is subject to
-restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
-(c)(1)(ii) of the Rights in Technical Data and Computer
-Software clause at DFARS 252.227-7013 and/or in similar or
-successor clauses in the FAR or the DOD or NASA FAR
-Supplement.  Unpublished-- rights reserved under the copyright
-laws of the United States.  Contractor/manufacturer is Silicon
-Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
-94039-7311.
-
-OpenGL(TM) is a trademark of Silicon Graphics, Inc.
-*/
-
-#include "glutint.h"
-
-/* Rim, body, lid, and bottom data must be reflected in x and
-   y; handle and spout data across the y axis only.  */
-
-static int patchdata[][16] =
-{
-    /* rim */
-  {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11,
-    12, 13, 14, 15},
-    /* body */
-  {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-    24, 25, 26, 27},
-  {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36,
-    37, 38, 39, 40},
-    /* lid */
-  {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101,
-    101, 0, 1, 2, 3,},
-  {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112,
-    113, 114, 115, 116, 117},
-    /* bottom */
-  {118, 118, 118, 118, 124, 122, 119, 121, 123, 126,
-    125, 120, 40, 39, 38, 37},
-    /* handle */
-  {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-    53, 54, 55, 56},
-  {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-    28, 65, 66, 67},
-    /* spout */
-  {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
-    80, 81, 82, 83},
-  {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
-    92, 93, 94, 95}
-};
-/* *INDENT-OFF* */
-
-static float cpdata[][3] =
-{
-    {0.2, 0, 2.7}, {0.2, -0.112, 2.7}, {0.112, -0.2, 2.7}, {0,
-    -0.2, 2.7}, {1.3375, 0, 2.53125}, {1.3375, -0.749, 2.53125},
-    {0.749, -1.3375, 2.53125}, {0, -1.3375, 2.53125}, {1.4375,
-    0, 2.53125}, {1.4375, -0.805, 2.53125}, {0.805, -1.4375,
-    2.53125}, {0, -1.4375, 2.53125}, {1.5, 0, 2.4}, {1.5, -0.84,
-    2.4}, {0.84, -1.5, 2.4}, {0, -1.5, 2.4}, {1.75, 0, 1.875},
-    {1.75, -0.98, 1.875}, {0.98, -1.75, 1.875}, {0, -1.75,
-    1.875}, {2, 0, 1.35}, {2, -1.12, 1.35}, {1.12, -2, 1.35},
-    {0, -2, 1.35}, {2, 0, 0.9}, {2, -1.12, 0.9}, {1.12, -2,
-    0.9}, {0, -2, 0.9}, {-2, 0, 0.9}, {2, 0, 0.45}, {2, -1.12,
-    0.45}, {1.12, -2, 0.45}, {0, -2, 0.45}, {1.5, 0, 0.225},
-    {1.5, -0.84, 0.225}, {0.84, -1.5, 0.225}, {0, -1.5, 0.225},
-    {1.5, 0, 0.15}, {1.5, -0.84, 0.15}, {0.84, -1.5, 0.15}, {0,
-    -1.5, 0.15}, {-1.6, 0, 2.025}, {-1.6, -0.3, 2.025}, {-1.5,
-    -0.3, 2.25}, {-1.5, 0, 2.25}, {-2.3, 0, 2.025}, {-2.3, -0.3,
-    2.025}, {-2.5, -0.3, 2.25}, {-2.5, 0, 2.25}, {-2.7, 0,
-    2.025}, {-2.7, -0.3, 2.025}, {-3, -0.3, 2.25}, {-3, 0,
-    2.25}, {-2.7, 0, 1.8}, {-2.7, -0.3, 1.8}, {-3, -0.3, 1.8},
-    {-3, 0, 1.8}, {-2.7, 0, 1.575}, {-2.7, -0.3, 1.575}, {-3,
-    -0.3, 1.35}, {-3, 0, 1.35}, {-2.5, 0, 1.125}, {-2.5, -0.3,
-    1.125}, {-2.65, -0.3, 0.9375}, {-2.65, 0, 0.9375}, {-2,
-    -0.3, 0.9}, {-1.9, -0.3, 0.6}, {-1.9, 0, 0.6}, {1.7, 0,
-    1.425}, {1.7, -0.66, 1.425}, {1.7, -0.66, 0.6}, {1.7, 0,
-    0.6}, {2.6, 0, 1.425}, {2.6, -0.66, 1.425}, {3.1, -0.66,
-    0.825}, {3.1, 0, 0.825}, {2.3, 0, 2.1}, {2.3, -0.25, 2.1},
-    {2.4, -0.25, 2.025}, {2.4, 0, 2.025}, {2.7, 0, 2.4}, {2.7,
-    -0.25, 2.4}, {3.3, -0.25, 2.4}, {3.3, 0, 2.4}, {2.8, 0,
-    2.475}, {2.8, -0.25, 2.475}, {3.525, -0.25, 2.49375},
-    {3.525, 0, 2.49375}, {2.9, 0, 2.475}, {2.9, -0.15, 2.475},
-    {3.45, -0.15, 2.5125}, {3.45, 0, 2.5125}, {2.8, 0, 2.4},
-    {2.8, -0.15, 2.4}, {3.2, -0.15, 2.4}, {3.2, 0, 2.4}, {0, 0,
-    3.15}, {0.8, 0, 3.15}, {0.8, -0.45, 3.15}, {0.45, -0.8,
-    3.15}, {0, -0.8, 3.15}, {0, 0, 2.85}, {1.4, 0, 2.4}, {1.4,
-    -0.784, 2.4}, {0.784, -1.4, 2.4}, {0, -1.4, 2.4}, {0.4, 0,
-    2.55}, {0.4, -0.224, 2.55}, {0.224, -0.4, 2.55}, {0, -0.4,
-    2.55}, {1.3, 0, 2.55}, {1.3, -0.728, 2.55}, {0.728, -1.3,
-    2.55}, {0, -1.3, 2.55}, {1.3, 0, 2.4}, {1.3, -0.728, 2.4},
-    {0.728, -1.3, 2.4}, {0, -1.3, 2.4}, {0, 0, 0}, {1.425,
-    -0.798, 0}, {1.5, 0, 0.075}, {1.425, 0, 0}, {0.798, -1.425,
-    0}, {0, -1.5, 0.075}, {0, -1.425, 0}, {1.5, -0.84, 0.075},
-    {0.84, -1.5, 0.075}
-};
-
-static float tex[2][2][2] =
-{
-  { {0, 0},
-    {1, 0}},
-  { {0, 1},
-    {1, 1}}
-};
-
-/* *INDENT-ON* */
-
-static void
-teapot(GLint grid, GLdouble scale, GLenum type)
-{
-  float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
-  long i, j, k, l;
-
-  glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT);
-  glEnable(GL_AUTO_NORMAL);
-  glEnable(GL_NORMALIZE);
-  glEnable(GL_MAP2_VERTEX_3);
-  glEnable(GL_MAP2_TEXTURE_COORD_2);
-  glPushMatrix();
-  glRotatef(270.0, 1.0, 0.0, 0.0);
-  glScalef(0.5 * scale, 0.5 * scale, 0.5 * scale);
-  glTranslatef(0.0, 0.0, -1.5);
-  for (i = 0; i < 10; i++) {
-    for (j = 0; j < 4; j++) {
-      for (k = 0; k < 4; k++) {
-        for (l = 0; l < 3; l++) {
-          p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
-          q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
-          if (l == 1)
-            q[j][k][l] *= -1.0;
-          if (i < 6) {
-            r[j][k][l] =
-              cpdata[patchdata[i][j * 4 + (3 - k)]][l];
-            if (l == 0)
-              r[j][k][l] *= -1.0;
-            s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
-            if (l == 0)
-              s[j][k][l] *= -1.0;
-            if (l == 1)
-              s[j][k][l] *= -1.0;
-          }
-        }
-      }
-    }
-    glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2,
-      &tex[0][0][0]);
-    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-      &p[0][0][0]);
-    glMapGrid2f(grid, 0.0, 1.0, grid, 0.0, 1.0);
-    glEvalMesh2(type, 0, grid, 0, grid);
-    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-      &q[0][0][0]);
-    glEvalMesh2(type, 0, grid, 0, grid);
-    if (i < 6) {
-      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-        &r[0][0][0]);
-      glEvalMesh2(type, 0, grid, 0, grid);
-      glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4,
-        &s[0][0][0]);
-      glEvalMesh2(type, 0, grid, 0, grid);
-    }
-  }
-  glPopMatrix();
-  glPopAttrib();
-}
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutSolidTeapot(GLdouble scale)
-{
-  teapot(7, scale, GL_FILL);
-}
-
-void GLUTAPIENTRY 
-glutWireTeapot(GLdouble scale)
-{
-  teapot(10, scale, GL_LINE);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_tr10.c b/src/glut/glx/glut_tr10.c
deleted file mode 100644
index dbf5ebde5e0..00000000000
--- a/src/glut/glx/glut_tr10.c
+++ /dev/null
@@ -1,1778 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapTimesRoman10 XXX
-#include "glutbitmap.h"
-#undef glutBitmapTimesRoman10
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0xa0,
-};
-
-static const BitmapCharRec ch255 = {5,9,0,2,5,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch254 = {4,9,0,2,5,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0x80,0xc0,0x40,0x60,0xa0,0x90,0xb8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch253 = {5,10,0,2,5,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x50,
-};
-
-static const BitmapCharRec ch252 = {5,7,0,0,5,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch251 = {5,8,0,0,5,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch250 = {5,8,0,0,5,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x68,0x90,0x90,0x90,0x90,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch249 = {5,8,0,0,5,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0x80,0x70,0x48,0x48,0x48,0x38,0x4,
-};
-
-static const BitmapCharRec ch248 = {6,7,1,1,5,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x20,0x0,0xf8,0x0,0x20,
-};
-
-static const BitmapCharRec ch247 = {5,5,0,0,6,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,
-};
-
-static const BitmapCharRec ch246 = {4,7,0,0,5,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch245 = {4,8,0,0,5,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch244 = {4,8,0,0,5,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch243 = {4,8,0,0,5,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x60,0x90,0x90,0x90,0x60,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch242 = {4,8,0,0,5,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xd8,0x90,0x90,0x90,0xe0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch241 = {5,8,0,0,5,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x60,0x90,0x90,0x90,0x70,0xa0,0x70,0x40,
-};
-
-static const BitmapCharRec ch240 = {4,8,0,0,5,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch239 = {3,7,0,0,4,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch238 = {3,8,0,0,4,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch237 = {3,8,0,0,4,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0xe0,0x40,0x40,0x40,0xc0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch236 = {3,8,0,0,4,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,
-};
-
-static const BitmapCharRec ch235 = {3,7,0,0,4,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch234 = {3,8,0,0,4,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch233 = {3,8,0,0,4,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x60,0x80,0xc0,0xa0,0x60,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch232 = {3,8,0,0,4,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0xc0,0x20,0x40,0x60,0x80,0x80,0x80,0x60,
-};
-
-static const BitmapCharRec ch231 = {3,8,0,3,4,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0xd8,0xa0,0x70,0x28,0xd8,
-};
-
-static const BitmapCharRec ch230 = {5,5,0,0,6,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x40,0xa0,0x40,
-};
-
-static const BitmapCharRec ch229 = {3,8,0,0,4,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch228 = {3,7,0,0,4,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch227 = {4,8,0,0,4,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch226 = {3,8,0,0,4,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch225 = {3,8,0,0,4,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch224 = {3,8,0,0,4,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xe0,0x50,0x50,0x60,0x50,0x50,0x20,
-};
-
-static const BitmapCharRec ch223 = {4,7,0,0,5,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xe0,0x40,0x70,0x48,0x70,0x40,0xe0,
-};
-
-static const BitmapCharRec ch222 = {5,7,0,0,6,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x38,0x10,0x10,0x28,0x28,0x44,0xee,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch221 = {7,10,0,0,8,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,
-};
-
-static const BitmapCharRec ch220 = {7,9,0,0,8,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch219 = {7,10,0,0,8,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch218 = {7,10,0,0,8,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch217 = {7,10,0,0,8,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x80,0x7c,0x66,0x52,0x52,0x4a,0x66,0x3e,0x1,
-};
-
-static const BitmapCharRec ch216 = {8,9,0,1,8,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x88,0x50,0x20,0x50,0x88,
-};
-
-static const BitmapCharRec ch215 = {5,5,0,0,6,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,
-};
-
-static const BitmapCharRec ch214 = {6,9,0,0,7,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch213 = {6,10,0,0,7,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch212 = {6,10,0,0,7,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch211 = {6,10,0,0,7,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch210 = {6,10,0,0,7,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,0x0,0x50,0x28,
-};
-
-static const BitmapCharRec ch209 = {7,10,0,0,8,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0xf8,0x4c,0x44,0xe4,0x44,0x4c,0xf8,
-};
-
-static const BitmapCharRec ch208 = {6,7,0,0,7,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,
-};
-
-static const BitmapCharRec ch207 = {3,9,0,0,4,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch206 = {3,10,0,0,4,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x20,
-};
-
-static const BitmapCharRec ch205 = {3,10,0,0,4,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,0x0,0x40,0x80,
-};
-
-static const BitmapCharRec ch204 = {3,10,0,0,4,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,
-};
-
-static const BitmapCharRec ch203 = {5,9,0,0,6,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x50,0x20,
-};
-
-static const BitmapCharRec ch202 = {5,10,0,0,6,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x10,
-};
-
-static const BitmapCharRec ch201 = {5,10,0,0,6,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,0x0,0x20,0x40,
-};
-
-static const BitmapCharRec ch200 = {5,10,0,0,6,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x60,0x10,0x20,0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch199 = {6,10,0,3,7,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xef,0x49,0x78,0x2e,0x28,0x39,0x1f,
-};
-
-static const BitmapCharRec ch198 = {8,7,0,0,9,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x10,0x28,0x10,
-};
-
-static const BitmapCharRec ch197 = {7,10,0,0,8,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,
-};
-
-static const BitmapCharRec ch196 = {7,9,0,0,8,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x14,
-};
-
-static const BitmapCharRec ch195 = {7,10,0,0,8,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x28,0x10,
-};
-
-static const BitmapCharRec ch194 = {7,10,0,0,8,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x8,
-};
-
-static const BitmapCharRec ch193 = {7,10,0,0,8,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,0x0,0x10,0x20,
-};
-
-static const BitmapCharRec ch192 = {7,10,0,0,8,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0xe0,0xa0,0x80,0x40,0x40,0x0,0x40,
-};
-
-static const BitmapCharRec ch191 = {3,7,0,2,4,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x44,0x3e,0x2c,0xd4,0x28,0x48,0xe4,
-};
-
-static const BitmapCharRec ch190 = {7,7,0,0,8,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x4e,0x24,0x2a,0xf6,0x48,0xc8,0x44,
-};
-
-static const BitmapCharRec ch189 = {7,7,0,0,8,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x44,0x3e,0x2c,0xf4,0x48,0xc8,0x44,
-};
-
-static const BitmapCharRec ch188 = {7,7,0,0,8,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0xa0,0x50,0x50,0xa0,
-};
-
-static const BitmapCharRec ch187 = {4,4,0,-1,5,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xe0,0x0,0x40,0xa0,0x40,
-};
-
-static const BitmapCharRec ch186 = {3,5,0,-2,4,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xe0,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch185 = {3,4,0,-3,3,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0xc0,0x20,0x40,
-};
-
-static const BitmapCharRec ch184 = {3,3,0,3,4,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch183 = {1,1,0,-2,2,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x28,0x28,0x28,0x28,0x68,0xe8,0xe8,0xe8,0x7c,
-};
-
-static const BitmapCharRec ch182 = {6,9,0,2,6,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x80,0x80,0xe8,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch181 = {5,7,0,2,5,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x40,
-};
-
-static const BitmapCharRec ch180 = {2,2,0,-5,3,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0xc0,0x20,0x40,0xe0,
-};
-
-static const BitmapCharRec ch179 = {3,4,0,-3,3,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xe0,0x40,0xa0,0x60,
-};
-
-static const BitmapCharRec ch178 = {3,4,0,-3,3,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xf8,0x0,0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch177 = {5,7,0,0,6,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch176 = {4,4,0,-3,4,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch175 = {3,1,0,-6,4,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x38,0x44,0xaa,0xb2,0xba,0x44,0x38,
-};
-
-static const BitmapCharRec ch174 = {7,7,-1,0,9,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xe0,
-};
-
-static const BitmapCharRec ch173 = {3,1,0,-2,4,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x8,0x8,0xf8,
-};
-
-static const BitmapCharRec ch172 = {5,3,-1,-1,7,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x50,0xa0,0xa0,0x50,
-};
-
-static const BitmapCharRec ch171 = {4,4,0,-1,5,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0xe0,0x0,0xa0,0x20,0xc0,
-};
-
-static const BitmapCharRec ch170 = {3,5,0,-2,4,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x38,0x44,0x9a,0xa2,0x9a,0x44,0x38,
-};
-
-static const BitmapCharRec ch169 = {7,7,-1,0,9,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xa0,
-};
-
-static const BitmapCharRec ch168 = {3,1,-1,-6,5,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0xe0,0x90,0x20,0x50,0x90,0xa0,0x40,0x90,0x70,
-};
-
-static const BitmapCharRec ch167 = {4,9,0,1,5,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0x80,0x80,0x80,0x0,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch166 = {1,7,0,0,2,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0x70,0x20,0xf8,0x20,0xd8,0x50,0x88,
-};
-
-static const BitmapCharRec ch165 = {5,7,0,0,5,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0x88,0x70,0x50,0x50,0x70,0x88,
-};
-
-static const BitmapCharRec ch164 = {5,6,0,-1,5,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xf0,0xc8,0x40,0xe0,0x40,0x50,0x30,
-};
-
-static const BitmapCharRec ch163 = {5,7,0,0,5,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x80,0xe0,0x90,0x80,0x90,0x70,0x10,
-};
-
-static const BitmapCharRec ch162 = {4,7,0,1,5,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0x80,0x80,0x80,0x80,0x80,0x0,0x80,
-};
-
-static const BitmapCharRec ch161 = {1,7,-1,2,3,ch161data};
-
-/* char: 0xa0 */
-
-#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,2,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,2,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x98,0x64,
-};
-
-static const BitmapCharRec ch126 = {6,2,0,-2,7,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0x80,0x40,0x40,0x40,0x20,0x40,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch125 = {3,9,0,2,4,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch124 = {1,9,0,2,2,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x20,0x40,0x40,0x40,0x80,0x40,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch123 = {3,9,0,2,4,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xf0,0x90,0x40,0x20,0xf0,
-};
-
-static const BitmapCharRec ch122 = {4,5,0,0,5,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0x40,0x40,0x20,0x30,0x50,0x48,0xdc,
-};
-
-static const BitmapCharRec ch121 = {6,7,1,2,5,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xd8,0x50,0x20,0x50,0xd8,
-};
-
-static const BitmapCharRec ch120 = {5,5,0,0,6,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x28,0x6c,0x54,0x92,0xdb,
-};
-
-static const BitmapCharRec ch119 = {8,5,0,0,8,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x20,0x60,0x50,0x90,0xd8,
-};
-
-static const BitmapCharRec ch118 = {5,5,0,0,5,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x68,0x90,0x90,0x90,0x90,
-};
-
-static const BitmapCharRec ch117 = {5,5,0,0,5,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x30,0x40,0x40,0x40,0xe0,0x40,
-};
-
-static const BitmapCharRec ch116 = {4,6,0,0,4,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0xe0,0x20,0x60,0x80,0xe0,
-};
-
-static const BitmapCharRec ch115 = {3,5,0,0,4,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xe0,0x40,0x40,0x60,0xa0,
-};
-
-static const BitmapCharRec ch114 = {3,5,0,0,4,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x38,0x10,0x70,0x90,0x90,0x90,0x70,
-};
-
-static const BitmapCharRec ch113 = {5,7,0,2,5,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xc0,0x80,0xe0,0x90,0x90,0x90,0xe0,
-};
-
-static const BitmapCharRec ch112 = {4,7,0,2,5,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x60,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch111 = {4,5,0,0,5,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xd8,0x90,0x90,0x90,0xe0,
-};
-
-static const BitmapCharRec ch110 = {5,5,0,0,5,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xdb,0x92,0x92,0x92,0xec,
-};
-
-static const BitmapCharRec ch109 = {8,5,0,0,8,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch108 = {3,7,0,0,4,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0x98,0x90,0xe0,0xa0,0x90,0x80,0x80,
-};
-
-static const BitmapCharRec ch107 = {5,7,0,0,5,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0x80,0x40,0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
-};
-
-static const BitmapCharRec ch106 = {2,9,0,2,3,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0x40,0x40,0x40,0x40,0xc0,0x0,0x40,
-};
-
-static const BitmapCharRec ch105 = {2,7,0,0,3,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xd8,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch104 = {5,7,0,0,5,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0xe0,0x90,0x60,0x40,0xa0,0xa0,0x70,
-};
-
-static const BitmapCharRec ch103 = {4,7,0,2,5,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0xe0,0x40,0x40,0x40,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch102 = {4,7,0,0,4,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x60,0x80,0xc0,0xa0,0x60,
-};
-
-static const BitmapCharRec ch101 = {3,5,0,0,4,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x68,0x90,0x90,0x90,0x70,0x10,0x30,
-};
-
-static const BitmapCharRec ch100 = {5,7,0,0,5,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x60,0x80,0x80,0x80,0x60,
-};
-
-static const BitmapCharRec ch99 = {3,5,0,0,4,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0xe0,0x90,0x90,0x90,0xe0,0x80,0x80,
-};
-
-static const BitmapCharRec ch98 = {4,7,0,0,5,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0xe0,0xa0,0x60,0x20,0xc0,
-};
-
-static const BitmapCharRec ch97 = {3,5,0,0,4,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0xc0,0x80,
-};
-
-static const BitmapCharRec ch96 = {2,2,0,-5,3,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xf8,
-};
-
-static const BitmapCharRec ch95 = {5,1,0,3,5,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0xa0,0xa0,0x40,
-};
-
-static const BitmapCharRec ch94 = {3,3,-1,-4,5,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xc0,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0xc0,
-};
-
-static const BitmapCharRec ch93 = {2,9,0,2,3,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x20,0x20,0x40,0x40,0x40,0x80,0x80,
-};
-
-static const BitmapCharRec ch92 = {3,7,0,0,3,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xc0,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xc0,
-};
-
-static const BitmapCharRec ch91 = {2,9,0,2,3,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xf8,0x88,0x40,0x20,0x10,0x88,0xf8,
-};
-
-static const BitmapCharRec ch90 = {5,7,0,0,6,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x38,0x10,0x10,0x28,0x28,0x44,0xee,
-};
-
-static const BitmapCharRec ch89 = {7,7,0,0,8,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xee,0x44,0x28,0x10,0x28,0x44,0xee,
-};
-
-static const BitmapCharRec ch88 = {7,7,0,0,8,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x22,0x0,0x22,0x0,0x55,0x0,0x55,0x0,0xc9,0x80,0x88,0x80,0xdd,0xc0,
-};
-
-static const BitmapCharRec ch87 = {10,7,0,0,10,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x10,0x10,0x28,0x28,0x6c,0x44,0xee,
-};
-
-static const BitmapCharRec ch86 = {7,7,0,0,8,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x38,0x6c,0x44,0x44,0x44,0x44,0xee,
-};
-
-static const BitmapCharRec ch85 = {7,7,0,0,8,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0x70,0x20,0x20,0x20,0x20,0xa8,0xf8,
-};
-
-static const BitmapCharRec ch84 = {5,7,0,0,6,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0xe0,0x90,0x10,0x60,0xc0,0x90,0x70,
-};
-
-static const BitmapCharRec ch83 = {4,7,0,0,5,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xec,0x48,0x50,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch82 = {6,7,0,0,7,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0xc,0x18,0x70,0xcc,0x84,0x84,0x84,0xcc,0x78,
-};
-
-static const BitmapCharRec ch81 = {6,9,0,2,7,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xe0,0x40,0x40,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch80 = {5,7,0,0,6,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x78,0xcc,0x84,0x84,0x84,0xcc,0x78,
-};
-
-static const BitmapCharRec ch79 = {6,7,0,0,7,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xe4,0x4c,0x4c,0x54,0x54,0x64,0xee,
-};
-
-static const BitmapCharRec ch78 = {7,7,0,0,8,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xeb,0x80,0x49,0x0,0x55,0x0,0x55,0x0,0x63,0x0,0x63,0x0,0xe3,0x80,
-};
-
-static const BitmapCharRec ch77 = {9,7,0,0,10,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xf8,0x48,0x40,0x40,0x40,0x40,0xe0,
-};
-
-static const BitmapCharRec ch76 = {5,7,0,0,6,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xec,0x48,0x50,0x60,0x50,0x48,0xec,
-};
-
-static const BitmapCharRec ch75 = {6,7,0,0,7,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0xc0,0xa0,0x20,0x20,0x20,0x20,0x70,
-};
-
-static const BitmapCharRec ch74 = {4,7,0,0,4,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xe0,0x40,0x40,0x40,0x40,0x40,0xe0,
-};
-
-static const BitmapCharRec ch73 = {3,7,0,0,4,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xee,0x44,0x44,0x7c,0x44,0x44,0xee,
-};
-
-static const BitmapCharRec ch72 = {7,7,0,0,8,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x78,0xc4,0x84,0x9c,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch71 = {6,7,0,0,7,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xe0,0x40,0x40,0x70,0x40,0x48,0xf8,
-};
-
-static const BitmapCharRec ch70 = {5,7,0,0,6,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xf8,0x48,0x40,0x70,0x40,0x48,0xf8,
-};
-
-static const BitmapCharRec ch69 = {5,7,0,0,6,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xf8,0x4c,0x44,0x44,0x44,0x4c,0xf8,
-};
-
-static const BitmapCharRec ch68 = {6,7,0,0,7,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x78,0xc4,0x80,0x80,0x80,0xc4,0x7c,
-};
-
-static const BitmapCharRec ch67 = {6,7,0,0,7,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xf0,0x48,0x48,0x70,0x48,0x48,0xf0,
-};
-
-static const BitmapCharRec ch66 = {5,7,0,0,6,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xee,0x44,0x7c,0x28,0x28,0x38,0x10,
-};
-
-static const BitmapCharRec ch65 = {7,7,0,0,8,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3e,0x40,0x92,0xad,0xa5,0xa5,0x9d,0x42,0x3c,
-};
-
-static const BitmapCharRec ch64 = {8,9,0,2,9,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x40,0x0,0x40,0x40,0x20,0xa0,0xe0,
-};
-
-static const BitmapCharRec ch63 = {3,7,0,0,4,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0x80,0x40,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch62 = {3,5,0,0,5,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xf8,0x0,0xf8,
-};
-
-static const BitmapCharRec ch61 = {5,3,0,-1,6,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x20,0x40,0x80,0x40,0x20,
-};
-
-static const BitmapCharRec ch60 = {3,5,-1,0,5,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0x80,0x80,0x80,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch59 = {1,7,-1,2,3,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0x80,0x0,0x0,0x0,0x80,
-};
-
-static const BitmapCharRec ch58 = {1,5,-1,0,3,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0xc0,0x20,0x70,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch57 = {4,7,0,0,5,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x60,0x90,0x90,0x60,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch56 = {4,7,0,0,5,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x40,0x40,0x40,0x20,0x20,0x90,0xf0,
-};
-
-static const BitmapCharRec ch55 = {4,7,0,0,5,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x60,0x90,0x90,0x90,0xe0,0x40,0x30,
-};
-
-static const BitmapCharRec ch54 = {4,7,0,0,5,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0xe0,0x90,0x10,0x10,0xe0,0x40,0x70,
-};
-
-static const BitmapCharRec ch53 = {4,7,0,0,5,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x10,0x10,0xf8,0x90,0x50,0x30,0x10,
-};
-
-static const BitmapCharRec ch52 = {5,7,0,0,5,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0xe0,0x10,0x10,0x60,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch51 = {4,7,0,0,5,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xf0,0x40,0x20,0x20,0x10,0x90,0x60,
-};
-
-static const BitmapCharRec ch50 = {4,7,0,0,5,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xe0,0x40,0x40,0x40,0x40,0xc0,0x40,
-};
-
-static const BitmapCharRec ch49 = {3,7,-1,0,5,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x60,0x90,0x90,0x90,0x90,0x90,0x60,
-};
-
-static const BitmapCharRec ch48 = {4,7,0,0,5,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0x80,0x80,0x40,0x40,0x40,0x20,0x20,
-};
-
-static const BitmapCharRec ch47 = {3,7,0,0,3,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0x80,
-};
-
-static const BitmapCharRec ch46 = {1,1,-1,0,3,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xf0,
-};
-
-static const BitmapCharRec ch45 = {4,1,-1,-2,7,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch44 = {1,3,-1,2,3,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x20,0x20,0xf8,0x20,0x20,
-};
-
-static const BitmapCharRec ch43 = {5,5,0,0,6,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0xa0,0x40,0xa0,
-};
-
-static const BitmapCharRec ch42 = {3,3,0,-4,5,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x40,0x20,0x20,0x20,0x40,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {3,9,0,2,4,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x20,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x20,
-};
-
-static const BitmapCharRec ch40 = {3,9,0,2,4,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0x40,0xc0,
-};
-
-static const BitmapCharRec ch39 = {2,2,0,-5,3,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x76,0x8d,0x98,0x74,0x6e,0x50,0x30,
-};
-
-static const BitmapCharRec ch38 = {8,7,0,0,8,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x44,0x2a,0x2a,0x56,0xa8,0xa4,0x7e,
-};
-
-static const BitmapCharRec ch37 = {7,7,0,0,8,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x20,0xe0,0x90,0x10,0x60,0x80,0x90,0x70,0x20,
-};
-
-static const BitmapCharRec ch36 = {4,9,0,1,5,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x50,0x50,0xf8,0x50,0xf8,0x50,0x50,
-};
-
-static const BitmapCharRec ch35 = {5,7,0,0,5,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0xa0,0xa0,
-};
-
-static const BitmapCharRec ch34 = {3,2,0,-5,4,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0x80,0x0,0x80,0x80,0x80,0x80,0x80,
-};
-
-static const BitmapCharRec ch33 = {1,7,-1,0,3,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,2,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,2,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmapTimesRoman10;
-const BitmapFontRec glutBitmapTimesRoman10 = {
-"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/glx/glut_tr24.c b/src/glut/glx/glut_tr24.c
deleted file mode 100644
index 5db9d36e197..00000000000
--- a/src/glut/glx/glut_tr24.c
+++ /dev/null
@@ -1,2061 +0,0 @@
-
-/* GENERATED FILE -- DO NOT MODIFY */
-
-#define glutBitmapTimesRoman24 XXX
-#include "glutbitmap.h"
-#undef glutBitmapTimesRoman24
-
-/* char: 0xff */
-
-static const GLubyte ch255data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch255 = {11,21,0,5,11,ch255data};
-
-/* char: 0xfe */
-
-static const GLubyte ch254data[] = {
-0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
-0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0xe0,0x0,
-};
-
-static const BitmapCharRec ch254 = {10,22,-1,5,12,ch254data};
-
-/* char: 0xfd */
-
-static const GLubyte ch253data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,0x1,0x80,
-};
-
-static const BitmapCharRec ch253 = {11,22,0,5,11,ch253data};
-
-/* char: 0xfc */
-
-static const GLubyte ch252data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch252 = {11,16,-1,0,13,ch252data};
-
-/* char: 0xfb */
-
-static const GLubyte ch251data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch251 = {11,17,-1,0,13,ch251data};
-
-/* char: 0xfa */
-
-static const GLubyte ch250data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
-0x1,0x80,
-};
-
-static const BitmapCharRec ch250 = {11,17,-1,0,13,ch250data};
-
-/* char: 0xf9 */
-
-static const GLubyte ch249data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch249 = {11,17,-1,0,13,ch249data};
-
-/* char: 0xf8 */
-
-static const GLubyte ch248data[] = {
-0xc0,0x0,0xde,0x0,0x73,0x80,0x71,0x80,0xd0,0xc0,0xd8,0xc0,0xc8,0xc0,0xcc,0xc0,
-0xc4,0xc0,0xc6,0xc0,0x63,0x80,0x73,0x80,0x1e,0xc0,0x0,0xc0,
-};
-
-static const BitmapCharRec ch248 = {10,14,-1,1,12,ch248data};
-
-/* char: 0xf7 */
-
-static const GLubyte ch247data[] = {
-0x6,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,
-0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch247 = {12,10,-1,-2,14,ch247data};
-
-/* char: 0xf6 */
-
-static const GLubyte ch246data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch246 = {10,16,-1,0,12,ch246data};
-
-/* char: 0xf5 */
-
-static const GLubyte ch245data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
-};
-
-static const BitmapCharRec ch245 = {10,16,-1,0,12,ch245data};
-
-/* char: 0xf4 */
-
-static const GLubyte ch244data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch244 = {10,17,-1,0,12,ch244data};
-
-/* char: 0xf3 */
-
-static const GLubyte ch243data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x8,0x0,0x6,0x0,0x3,0x80,
-0x1,0x80,
-};
-
-static const BitmapCharRec ch243 = {10,17,-1,0,12,ch243data};
-
-/* char: 0xf2 */
-
-static const GLubyte ch242data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,0x0,0x0,0x2,0x0,0xc,0x0,0x38,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch242 = {10,17,-1,0,12,ch242data};
-
-/* char: 0xf1 */
-
-static const GLubyte ch241data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,0x0,0x0,0x0,0x0,0x27,0x0,0x1c,0x80,
-};
-
-static const BitmapCharRec ch241 = {11,16,-1,0,13,ch241data};
-
-/* char: 0xf0 */
-
-static const GLubyte ch240data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1f,0x0,0xc6,0x0,0x3c,0x0,0x1e,0x0,0x71,0x80,
-0xc0,0x0,
-};
-
-static const BitmapCharRec ch240 = {10,17,-1,0,12,ch240data};
-
-/* char: 0xef */
-
-static const GLubyte ch239data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x0,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch239 = {6,16,0,0,6,ch239data};
-
-/* char: 0xee */
-
-static const GLubyte ch238data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x84,0x48,0x78,
-0x30,
-};
-
-static const BitmapCharRec ch238 = {6,17,0,0,6,ch238data};
-
-/* char: 0xed */
-
-static const GLubyte ch237data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x80,0x60,0x38,
-0x18,
-};
-
-static const BitmapCharRec ch237 = {5,17,-1,0,6,ch237data};
-
-/* char: 0xec */
-
-static const GLubyte ch236data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x70,0x0,0x8,0x30,0xe0,
-0xc0,
-};
-
-static const BitmapCharRec ch236 = {5,17,0,0,6,ch236data};
-
-/* char: 0xeb */
-
-static const GLubyte ch235data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x0,0x0,0x33,0x0,0x33,0x0,
-};
-
-static const BitmapCharRec ch235 = {9,16,-1,0,11,ch235data};
-
-/* char: 0xea */
-
-static const GLubyte ch234data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x21,0x0,0x12,0x0,0x1e,0x0,
-0xc,0x0,
-};
-
-static const BitmapCharRec ch234 = {9,17,-1,0,11,ch234data};
-
-/* char: 0xe9 */
-
-static const GLubyte ch233data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch233 = {9,17,-1,0,11,ch233data};
-
-/* char: 0xe8 */
-
-static const GLubyte ch232data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
-0x60,0x0,
-};
-
-static const BitmapCharRec ch232 = {9,17,-1,0,11,ch232data};
-
-/* char: 0xe7 */
-
-static const GLubyte ch231data[] = {
-0x3c,0x0,0x66,0x0,0x6,0x0,0x1e,0x0,0x18,0x0,0x8,0x0,0x1e,0x0,0x7f,0x0,
-0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x41,0x80,
-0x63,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch231 = {9,18,-1,6,11,ch231data};
-
-/* char: 0xe6 */
-
-static const GLubyte ch230data[] = {
-0x70,0xf0,0xfb,0xf8,0xc7,0x84,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0xfc,
-0x3,0xc,0x63,0xc,0x67,0x98,0x3c,0xf0,
-};
-
-static const BitmapCharRec ch230 = {14,12,-1,0,16,ch230data};
-
-/* char: 0xe5 */
-
-static const GLubyte ch229data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x1c,0x0,0x22,0x0,0x22,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch229 = {9,17,-1,0,11,ch229data};
-
-/* char: 0xe4 */
-
-static const GLubyte ch228data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x66,0x0,0x66,0x0,
-};
-
-static const BitmapCharRec ch228 = {9,16,-1,0,11,ch228data};
-
-/* char: 0xe3 */
-
-static const GLubyte ch227data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x0,0x0,0x5c,0x0,0x3a,0x0,
-};
-
-static const BitmapCharRec ch227 = {9,16,-1,0,11,ch227data};
-
-/* char: 0xe2 */
-
-static const GLubyte ch226data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x42,0x0,0x24,0x0,0x3c,0x0,
-0x18,0x0,
-};
-
-static const BitmapCharRec ch226 = {9,17,-1,0,11,ch226data};
-
-/* char: 0xe1 */
-
-static const GLubyte ch225data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x10,0x0,0xc,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch225 = {9,17,-1,0,11,ch225data};
-
-/* char: 0xe0 */
-
-static const GLubyte ch224data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,0x0,0x0,0x4,0x0,0x18,0x0,0x70,0x0,
-0x60,0x0,
-};
-
-static const BitmapCharRec ch224 = {9,17,-1,0,11,ch224data};
-
-/* char: 0xdf */
-
-static const GLubyte ch223data[] = {
-0xe7,0x0,0x6c,0x80,0x6c,0xc0,0x60,0xc0,0x60,0xc0,0x61,0xc0,0x61,0x80,0x63,0x80,
-0x67,0x0,0x6c,0x0,0x63,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch223 = {10,17,-1,0,12,ch223data};
-
-/* char: 0xde */
-
-static const GLubyte ch222data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,
-0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,0x3f,0xc0,0x30,0x0,0x30,0x0,0x30,0x0,
-0xfc,0x0,
-};
-
-static const BitmapCharRec ch222 = {13,17,-1,0,15,ch222data};
-
-/* char: 0xdd */
-
-static const GLubyte ch221data[] = {
-0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
-0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
-0xfc,0x3f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch221 = {16,22,0,0,16,ch221data};
-
-/* char: 0xdc */
-
-static const GLubyte ch220data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x0,0x0,0x6,0x30,0x6,0x30,
-};
-
-static const BitmapCharRec ch220 = {16,21,-1,0,18,ch220data};
-
-/* char: 0xdb */
-
-static const GLubyte ch219data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
-};
-
-static const BitmapCharRec ch219 = {16,22,-1,0,18,ch219data};
-
-/* char: 0xda */
-
-static const GLubyte ch218data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch218 = {16,22,-1,0,18,ch218data};
-
-/* char: 0xd9 */
-
-static const GLubyte ch217data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch217 = {16,22,-1,0,18,ch217data};
-
-/* char: 0xd8 */
-
-static const GLubyte ch216data[] = {
-0x20,0x0,0x27,0xe0,0x1c,0x38,0x38,0x1c,0x68,0x6,0x64,0x6,0xc2,0x3,0xc2,0x3,
-0xc1,0x3,0xc1,0x3,0xc0,0x83,0xc0,0x83,0xc0,0x43,0x60,0x46,0x60,0x26,0x38,0x1c,
-0x1c,0x38,0x7,0xe4,0x0,0x4,
-};
-
-static const BitmapCharRec ch216 = {16,19,-1,1,18,ch216data};
-
-/* char: 0xd7 */
-
-static const GLubyte ch215data[] = {
-0x80,0x40,0xc0,0xc0,0x61,0x80,0x33,0x0,0x1e,0x0,0xc,0x0,0x1e,0x0,0x33,0x0,
-0x61,0x80,0xc0,0xc0,0x80,0x40,
-};
-
-static const BitmapCharRec ch215 = {10,11,-2,-1,14,ch215data};
-
-/* char: 0xd6 */
-
-static const GLubyte ch214data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x0,0x6,0x60,0x6,0x60,
-};
-
-static const BitmapCharRec ch214 = {16,21,-1,0,18,ch214data};
-
-/* char: 0xd5 */
-
-static const GLubyte ch213data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
-};
-
-static const BitmapCharRec ch213 = {16,21,-1,0,18,ch213data};
-
-/* char: 0xd4 */
-
-static const GLubyte ch212data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x8,0x10,0x6,0x60,0x3,0xc0,0x1,0x80,
-};
-
-static const BitmapCharRec ch212 = {16,22,-1,0,18,ch212data};
-
-/* char: 0xd3 */
-
-static const GLubyte ch211data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x1,0x0,0x0,0xc0,0x0,0x70,0x0,0x30,
-};
-
-static const BitmapCharRec ch211 = {16,22,-1,0,18,ch211data};
-
-/* char: 0xd2 */
-
-static const GLubyte ch210data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,0x0,0x0,0x0,0x40,0x1,0x80,0x7,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch210 = {16,22,-1,0,18,ch210data};
-
-/* char: 0xd1 */
-
-static const GLubyte ch209data[] = {
-0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
-0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
-0xf0,0x1f,0x0,0x0,0x0,0x0,0x4,0xe0,0x3,0x90,
-};
-
-static const BitmapCharRec ch209 = {16,21,-1,0,18,ch209data};
-
-/* char: 0xd0 */
-
-static const GLubyte ch208data[] = {
-0x7f,0xe0,0x18,0x38,0x18,0x1c,0x18,0x6,0x18,0x6,0x18,0x3,0x18,0x3,0x18,0x3,
-0xff,0x3,0x18,0x3,0x18,0x3,0x18,0x3,0x18,0x6,0x18,0x6,0x18,0x1c,0x18,0x38,
-0x7f,0xe0,
-};
-
-static const BitmapCharRec ch208 = {16,17,0,0,17,ch208data};
-
-/* char: 0xcf */
-
-static const GLubyte ch207data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x0,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch207 = {6,21,-1,0,8,ch207data};
-
-/* char: 0xce */
-
-static const GLubyte ch206data[] = {
-0x7e,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x7e,0x0,0x81,0x66,0x3c,0x18,
-};
-
-static const BitmapCharRec ch206 = {8,22,-1,0,8,ch206data};
-
-/* char: 0xcd */
-
-static const GLubyte ch205data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x40,0x30,0x1c,0xc,
-};
-
-static const BitmapCharRec ch205 = {6,22,-1,0,8,ch205data};
-
-/* char: 0xcc */
-
-static const GLubyte ch204data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,0x0,0x8,0x30,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch204 = {6,22,-1,0,8,ch204data};
-
-/* char: 0xcb */
-
-static const GLubyte ch203data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x0,0x0,0x19,0x80,0x19,0x80,
-};
-
-static const BitmapCharRec ch203 = {13,21,-1,0,15,ch203data};
-
-/* char: 0xca */
-
-static const GLubyte ch202data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x10,0x20,0xc,0xc0,0x7,0x80,0x3,0x0,
-};
-
-static const BitmapCharRec ch202 = {13,22,-1,0,15,ch202data};
-
-/* char: 0xc9 */
-
-static const GLubyte ch201data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x4,0x0,0x3,0x0,0x1,0xc0,0x0,0xc0,
-};
-
-static const BitmapCharRec ch201 = {13,22,-1,0,15,ch201data};
-
-/* char: 0xc8 */
-
-static const GLubyte ch200data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,0x0,0x0,0x1,0x0,0x6,0x0,0x1c,0x0,0x18,0x0,
-};
-
-static const BitmapCharRec ch200 = {13,22,-1,0,15,ch200data};
-
-/* char: 0xc7 */
-
-static const GLubyte ch199data[] = {
-0x7,0x80,0xc,0xc0,0x0,0xc0,0x3,0xc0,0x3,0x0,0x1,0x0,0x7,0xe0,0x1e,0x38,
-0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,0x7,0xe4,
-};
-
-static const BitmapCharRec ch199 = {14,23,-1,6,16,ch199data};
-
-/* char: 0xc6 */
-
-static const GLubyte ch198data[] = {
-0xf9,0xff,0xf0,0x30,0x60,0x30,0x10,0x60,0x10,0x10,0x60,0x10,0x18,0x60,0x0,0x8,
-0x60,0x0,0xf,0xe0,0x80,0xc,0x60,0x80,0x4,0x7f,0x80,0x4,0x60,0x80,0x6,0x60,
-0x80,0x2,0x60,0x0,0x2,0x60,0x0,0x1,0x60,0x20,0x1,0x60,0x20,0x1,0xe0,0x60,
-0x3,0xff,0xe0,
-};
-
-static const BitmapCharRec ch198 = {20,17,0,0,21,ch198data};
-
-/* char: 0xc5 */
-
-static const GLubyte ch197data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x1,0xc0,0x0,0x2,0x20,0x0,0x2,0x20,0x0,0x1,0xc0,0x0,
-};
-
-static const BitmapCharRec ch197 = {17,21,0,0,17,ch197data};
-
-/* char: 0xc4 */
-
-static const GLubyte ch196data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6,0x30,0x0,0x6,0x30,0x0,
-};
-
-static const BitmapCharRec ch196 = {17,21,0,0,17,ch196data};
-
-/* char: 0xc3 */
-
-static const GLubyte ch195data[] = {
-0xfc,0x1f,0x80,0x30,0x7,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0xe0,0x0,0x3,0x90,0x0,
-};
-
-static const BitmapCharRec ch195 = {17,21,0,0,17,ch195data};
-
-/* char: 0xc2 */
-
-static const GLubyte ch194data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x8,0x10,0x0,0x6,0x60,0x0,0x3,0xc0,0x0,0x1,
-0x80,0x0,
-};
-
-static const BitmapCharRec ch194 = {17,22,0,0,17,ch194data};
-
-/* char: 0xc1 */
-
-static const GLubyte ch193data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xc0,0x0,0x0,0x70,0x0,0x0,
-0x30,0x0,
-};
-
-static const BitmapCharRec ch193 = {17,22,0,0,17,ch193data};
-
-/* char: 0xc0 */
-
-static const GLubyte ch192data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0xc0,0x0,0x3,0x80,0x0,0x3,
-0x0,0x0,
-};
-
-static const BitmapCharRec ch192 = {17,22,0,0,17,ch192data};
-
-/* char: 0xbf */
-
-static const GLubyte ch191data[] = {
-0x3e,0x63,0xc1,0xc3,0xc3,0xe0,0x70,0x30,0x38,0x18,0x18,0x8,0x8,0x0,0x0,0xc,
-0xc,
-};
-
-static const BitmapCharRec ch191 = {8,17,-1,5,11,ch191data};
-
-/* char: 0xbe */
-
-static const GLubyte ch190data[] = {
-0x18,0x2,0x0,0x8,0x2,0x0,0xc,0x7f,0x80,0x4,0x22,0x0,0x6,0x32,0x0,0x3,
-0x12,0x0,0x1,0xa,0x0,0x71,0x8e,0x0,0x88,0x86,0x0,0x8c,0xc2,0x0,0xc,0x60,
-0x0,0x8,0x20,0x0,0x30,0x30,0x0,0x8,0x10,0x0,0x8c,0x18,0x0,0x4c,0xc,0x0,
-0x38,0x4,0x0,
-};
-
-static const BitmapCharRec ch190 = {17,17,0,0,18,ch190data};
-
-/* char: 0xbd */
-
-static const GLubyte ch189data[] = {
-0x30,0x7e,0x10,0x22,0x18,0x10,0x8,0x18,0xc,0x8,0x6,0x4,0x2,0x6,0xfb,0x46,
-0x21,0x26,0x21,0x9c,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
-0x20,0x8,
-};
-
-static const BitmapCharRec ch189 = {15,17,-1,0,18,ch189data};
-
-/* char: 0xbc */
-
-static const GLubyte ch188data[] = {
-0x30,0x4,0x10,0x4,0x18,0xff,0x8,0x44,0xc,0x64,0x6,0x24,0x2,0x14,0xfb,0x1c,
-0x21,0xc,0x21,0x84,0x20,0xc0,0x20,0x40,0x20,0x60,0x20,0x20,0xa0,0x30,0x60,0x18,
-0x20,0x8,
-};
-
-static const BitmapCharRec ch188 = {16,17,-1,0,18,ch188data};
-
-/* char: 0xbb */
-
-static const GLubyte ch187data[] = {
-0x88,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,0x19,0x80,0x19,0x80,0x33,0x0,0x66,0x0,
-0xcc,0x0,0x88,0x0,
-};
-
-static const BitmapCharRec ch187 = {9,10,-2,-1,12,ch187data};
-
-/* char: 0xba */
-
-static const GLubyte ch186data[] = {
-0xfc,0x0,0x78,0xcc,0xcc,0xcc,0xcc,0xcc,0x78,
-};
-
-static const BitmapCharRec ch186 = {6,9,-1,-8,8,ch186data};
-
-/* char: 0xb9 */
-
-static const GLubyte ch185data[] = {
-0xf8,0x20,0x20,0x20,0x20,0x20,0x20,0xa0,0x60,0x20,
-};
-
-static const BitmapCharRec ch185 = {5,10,-1,-7,7,ch185data};
-
-/* char: 0xb8 */
-
-static const GLubyte ch184data[] = {
-0x78,0xcc,0xc,0x3c,0x30,0x10,
-};
-
-static const BitmapCharRec ch184 = {6,6,-1,6,8,ch184data};
-
-/* char: 0xb7 */
-
-static const GLubyte ch183data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch183 = {2,2,-2,-6,6,ch183data};
-
-/* char: 0xb6 */
-
-static const GLubyte ch182data[] = {
-0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,0x9,0x0,
-0x9,0x0,0x9,0x0,0x9,0x0,0x19,0x0,0x39,0x0,0x79,0x0,0x79,0x0,0xf9,0x0,
-0xf9,0x0,0xf9,0x0,0x79,0x0,0x79,0x0,0x39,0x0,0x1f,0x80,
-};
-
-static const BitmapCharRec ch182 = {9,22,-1,5,11,ch182data};
-
-/* char: 0xb5 */
-
-static const GLubyte ch181data[] = {
-0x40,0x0,0xe0,0x0,0xc0,0x0,0x40,0x0,0x40,0x0,0x5c,0xe0,0x7e,0xc0,0x71,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0xe1,0xc0,
-};
-
-static const BitmapCharRec ch181 = {11,17,-1,5,13,ch181data};
-
-/* char: 0xb4 */
-
-static const GLubyte ch180data[] = {
-0x80,0x60,0x38,0x18,
-};
-
-static const BitmapCharRec ch180 = {5,4,-2,-13,8,ch180data};
-
-/* char: 0xb3 */
-
-static const GLubyte ch179data[] = {
-0x70,0x88,0x8c,0xc,0x8,0x30,0x8,0x8c,0x4c,0x38,
-};
-
-static const BitmapCharRec ch179 = {6,10,0,-7,7,ch179data};
-
-/* char: 0xb2 */
-
-static const GLubyte ch178data[] = {
-0xfc,0x44,0x20,0x30,0x10,0x8,0xc,0x8c,0x4c,0x38,
-};
-
-static const BitmapCharRec ch178 = {6,10,0,-7,7,ch178data};
-
-/* char: 0xb1 */
-
-static const GLubyte ch177data[] = {
-0xff,0xf0,0xff,0xf0,0x0,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0xff,0xf0,0xff,0xf0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch177 = {12,15,-1,0,14,ch177data};
-
-/* char: 0xb0 */
-
-static const GLubyte ch176data[] = {
-0x38,0x44,0x82,0x82,0x82,0x44,0x38,
-};
-
-static const BitmapCharRec ch176 = {7,7,-1,-10,9,ch176data};
-
-/* char: 0xaf */
-
-static const GLubyte ch175data[] = {
-0xfc,0xfc,
-};
-
-static const BitmapCharRec ch175 = {6,2,-1,-14,8,ch175data};
-
-/* char: 0xae */
-
-static const GLubyte ch174data[] = {
-0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x60,0x3,0x0,0x47,0x19,0x0,0xc2,
-0x31,0x80,0x82,0x20,0x80,0x82,0x40,0x80,0x83,0xe0,0x80,0x82,0x30,0x80,0x82,0x10,
-0x80,0xc2,0x11,0x80,0x42,0x31,0x0,0x67,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
-0x7,0xf0,0x0,
-};
-
-static const BitmapCharRec ch174 = {17,17,-1,0,19,ch174data};
-
-/* char: 0xad */
-
-static const GLubyte ch173data[] = {
-0xfe,0xfe,
-};
-
-static const BitmapCharRec ch173 = {7,2,-1,-5,9,ch173data};
-
-/* char: 0xac */
-
-static const GLubyte ch172data[] = {
-0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch172 = {12,7,-1,-3,14,ch172data};
-
-/* char: 0xab */
-
-static const GLubyte ch171data[] = {
-0x8,0x80,0x19,0x80,0x33,0x0,0x66,0x0,0xcc,0x0,0xcc,0x0,0x66,0x0,0x33,0x0,
-0x19,0x80,0x8,0x80,
-};
-
-static const BitmapCharRec ch171 = {9,10,-2,-1,13,ch171data};
-
-/* char: 0xaa */
-
-static const GLubyte ch170data[] = {
-0x7e,0x0,0x76,0xcc,0xcc,0x7c,0xc,0xcc,0x78,
-};
-
-static const BitmapCharRec ch170 = {7,9,0,-8,8,ch170data};
-
-/* char: 0xa9 */
-
-static const GLubyte ch169data[] = {
-0x7,0xf0,0x0,0x1c,0x1c,0x0,0x30,0x6,0x0,0x61,0xc3,0x0,0x47,0x71,0x0,0xc4,
-0x19,0x80,0x8c,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x88,0x0,0x80,0x8c,0x0,
-0x80,0xc4,0x19,0x80,0x47,0x31,0x0,0x61,0xe3,0x0,0x30,0x6,0x0,0x1c,0x1c,0x0,
-0x7,0xf0,0x0,
-};
-
-static const BitmapCharRec ch169 = {17,17,-1,0,19,ch169data};
-
-/* char: 0xa8 */
-
-static const GLubyte ch168data[] = {
-0xcc,0xcc,
-};
-
-static const BitmapCharRec ch168 = {6,2,-1,-14,8,ch168data};
-
-/* char: 0xa7 */
-
-static const GLubyte ch167data[] = {
-0x38,0x64,0x62,0x6,0xe,0x1c,0x38,0x74,0xe2,0xc3,0x83,0x87,0x4e,0x3c,0x38,0x70,
-0x60,0x46,0x26,0x1c,
-};
-
-static const BitmapCharRec ch167 = {8,20,-2,2,12,ch167data};
-
-/* char: 0xa6 */
-
-static const GLubyte ch166data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch166 = {2,17,-2,0,6,ch166data};
-
-/* char: 0xa5 */
-
-static const GLubyte ch165data[] = {
-0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x1f,0xe0,0x3,0x0,0x1f,0xe0,
-0x3,0x0,0x7,0x80,0xc,0x80,0xc,0xc0,0x18,0x40,0x18,0x60,0x30,0x20,0x70,0x30,
-0xf8,0x7c,
-};
-
-static const BitmapCharRec ch165 = {14,17,0,0,14,ch165data};
-
-/* char: 0xa4 */
-
-static const GLubyte ch164data[] = {
-0xc0,0x60,0xee,0xe0,0x7f,0xc0,0x31,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x31,0x80,0x7f,0xc0,0xee,0xe0,0xc0,0x60,
-};
-
-static const BitmapCharRec ch164 = {11,12,-1,-3,13,ch164data};
-
-/* char: 0xa3 */
-
-static const GLubyte ch163data[] = {
-0xe7,0x80,0xbe,0xc0,0x78,0x40,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x30,0x0,0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x31,0x80,0x19,0x80,
-0xf,0x0,
-};
-
-static const BitmapCharRec ch163 = {10,17,-1,0,12,ch163data};
-
-/* char: 0xa2 */
-
-static const GLubyte ch162data[] = {
-0x40,0x0,0x40,0x0,0x3e,0x0,0x7f,0x0,0x70,0x80,0xd0,0x0,0xc8,0x0,0xc8,0x0,
-0xc8,0x0,0xc4,0x0,0xc4,0x0,0x43,0x80,0x63,0x80,0x1f,0x0,0x1,0x0,0x1,0x0,
-};
-
-static const BitmapCharRec ch162 = {9,16,-1,2,12,ch162data};
-
-/* char: 0xa1 */
-
-static const GLubyte ch161data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x0,0x0,0x0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch161 = {2,17,-4,5,8,ch161data};
-
-/* char: 0xa0 */
-
-#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,6,ch160data};
-#else
-static const BitmapCharRec ch160 = {0,0,0,0,6,0};
-#endif
-
-/* char: 0x7e '~' */
-
-static const GLubyte ch126data[] = {
-0x83,0x80,0xc7,0xc0,0x7c,0x60,0x38,0x20,
-};
-
-static const BitmapCharRec ch126 = {11,4,-1,-5,13,ch126data};
-
-/* char: 0x7d '}' */
-
-static const GLubyte ch125data[] = {
-0xe0,0x30,0x18,0x18,0x18,0x18,0x18,0x18,0x8,0xc,0x4,0x3,0x4,0xc,0x8,0x18,
-0x18,0x18,0x18,0x18,0x30,0xe0,
-};
-
-static const BitmapCharRec ch125 = {8,22,-1,5,10,ch125data};
-
-/* char: 0x7c '|' */
-
-static const GLubyte ch124data[] = {
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch124 = {2,17,-2,0,6,ch124data};
-
-/* char: 0x7b '{' */
-
-static const GLubyte ch123data[] = {
-0x7,0xc,0x18,0x18,0x18,0x18,0x18,0x18,0x10,0x30,0x20,0xc0,0x20,0x30,0x10,0x18,
-0x18,0x18,0x18,0x18,0xc,0x7,
-};
-
-static const BitmapCharRec ch123 = {8,22,-1,5,10,ch123data};
-
-/* char: 0x7a 'z' */
-
-static const GLubyte ch122data[] = {
-0xff,0xc3,0x61,0x70,0x30,0x38,0x18,0x1c,0xe,0x86,0xc3,0xff,
-};
-
-static const BitmapCharRec ch122 = {8,12,-1,0,10,ch122data};
-
-/* char: 0x79 'y' */
-
-static const GLubyte ch121data[] = {
-0xe0,0x0,0xf0,0x0,0x18,0x0,0x8,0x0,0xc,0x0,0x4,0x0,0xe,0x0,0xe,0x0,
-0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,0x30,0x80,0x60,0x80,0x60,0xc0,
-0xf1,0xe0,
-};
-
-static const BitmapCharRec ch121 = {11,17,0,5,11,ch121data};
-
-/* char: 0x78 'x' */
-
-static const GLubyte ch120data[] = {
-0xf1,0xe0,0x60,0xc0,0x21,0x80,0x33,0x80,0x1b,0x0,0xe,0x0,0xc,0x0,0x1a,0x0,
-0x39,0x0,0x31,0x80,0x60,0xc0,0xf1,0xe0,
-};
-
-static const BitmapCharRec ch120 = {11,12,-1,0,13,ch120data};
-
-/* char: 0x77 'w' */
-
-static const GLubyte ch119data[] = {
-0x4,0x10,0x0,0xe,0x38,0x0,0xe,0x38,0x0,0x1a,0x28,0x0,0x1a,0x64,0x0,0x19,
-0x64,0x0,0x31,0x64,0x0,0x30,0xc2,0x0,0x30,0xc2,0x0,0x60,0xc2,0x0,0x60,0xc3,
-0x0,0xf1,0xe7,0x80,
-};
-
-static const BitmapCharRec ch119 = {17,12,0,0,17,ch119data};
-
-/* char: 0x76 'v' */
-
-static const GLubyte ch118data[] = {
-0x4,0x0,0xe,0x0,0xe,0x0,0x1a,0x0,0x19,0x0,0x19,0x0,0x31,0x0,0x30,0x80,
-0x30,0x80,0x60,0x80,0x60,0xc0,0xf1,0xe0,
-};
-
-static const BitmapCharRec ch118 = {11,12,0,0,11,ch118data};
-
-/* char: 0x75 'u' */
-
-static const GLubyte ch117data[] = {
-0x1c,0xe0,0x3e,0xc0,0x71,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0xe1,0xc0,
-};
-
-static const BitmapCharRec ch117 = {11,12,-1,0,13,ch117data};
-
-/* char: 0x74 't' */
-
-static const GLubyte ch116data[] = {
-0x1c,0x32,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x70,0x30,0x10,
-};
-
-static const BitmapCharRec ch116 = {7,15,0,0,7,ch116data};
-
-/* char: 0x73 's' */
-
-static const GLubyte ch115data[] = {
-0xf8,0xc6,0x83,0x3,0x7,0x1e,0x7c,0x70,0xe0,0xc2,0x66,0x3e,
-};
-
-static const BitmapCharRec ch115 = {8,12,-1,0,10,ch115data};
-
-/* char: 0x72 'r' */
-
-static const GLubyte ch114data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x76,0x6e,0xe6,
-};
-
-static const BitmapCharRec ch114 = {7,12,-1,0,8,ch114data};
-
-/* char: 0x71 'q' */
-
-static const GLubyte ch113data[] = {
-0x3,0xc0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1d,0x80,0x73,0x80,0x61,0x80,
-0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0x61,0x80,0x73,0x80,
-0x1d,0x80,
-};
-
-static const BitmapCharRec ch113 = {10,17,-1,5,12,ch113data};
-
-/* char: 0x70 'p' */
-
-static const GLubyte ch112data[] = {
-0xf0,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x6e,0x0,0x73,0x80,0x61,0x80,
-0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x61,0x80,0x73,0x80,
-0xee,0x0,
-};
-
-static const BitmapCharRec ch112 = {10,17,-1,5,12,ch112data};
-
-/* char: 0x6f 'o' */
-
-static const GLubyte ch111data[] = {
-0x1e,0x0,0x73,0x80,0x61,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0x61,0x80,0x73,0x80,0x1e,0x0,
-};
-
-static const BitmapCharRec ch111 = {10,12,-1,0,12,ch111data};
-
-/* char: 0x6e 'n' */
-
-static const GLubyte ch110data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0xe7,0x0,
-};
-
-static const BitmapCharRec ch110 = {11,12,-1,0,13,ch110data};
-
-/* char: 0x6d 'm' */
-
-static const GLubyte ch109data[] = {
-0xf1,0xe3,0xc0,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,
-0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x60,0xc1,0x80,0x71,0xe3,0x80,0x6f,0x9f,
-0x0,0xe7,0xe,0x0,
-};
-
-static const BitmapCharRec ch109 = {18,12,-1,0,20,ch109data};
-
-/* char: 0x6c 'l' */
-
-static const GLubyte ch108data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,
-0xe0,
-};
-
-static const BitmapCharRec ch108 = {4,17,-1,0,6,ch108data};
-
-/* char: 0x6b 'k' */
-
-static const GLubyte ch107data[] = {
-0xf3,0xe0,0x61,0xc0,0x63,0x80,0x67,0x0,0x6e,0x0,0x6c,0x0,0x78,0x0,0x68,0x0,
-0x64,0x0,0x66,0x0,0x63,0x0,0x67,0xc0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch107 = {11,17,-1,0,12,ch107data};
-
-/* char: 0x6a 'j' */
-
-static const GLubyte ch106data[] = {
-0xc0,0xe0,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0x70,0x0,0x0,0x0,0x30,0x30,
-};
-
-static const BitmapCharRec ch106 = {4,22,0,5,6,ch106data};
-
-/* char: 0x69 'i' */
-
-static const GLubyte ch105data[] = {
-0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0x60,0xe0,0x0,0x0,0x0,0x60,
-0x60,
-};
-
-static const BitmapCharRec ch105 = {4,17,-1,0,6,ch105data};
-
-/* char: 0x68 'h' */
-
-static const GLubyte ch104data[] = {
-0xf1,0xe0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x71,0xc0,0x6f,0x80,0x67,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch104 = {11,17,-1,0,13,ch104data};
-
-/* char: 0x67 'g' */
-
-static const GLubyte ch103data[] = {
-0x3f,0x0,0xf1,0xc0,0xc0,0x60,0xc0,0x20,0x60,0x60,0x3f,0xc0,0x7f,0x0,0x60,0x0,
-0x30,0x0,0x3e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1f,0xc0,
-};
-
-static const BitmapCharRec ch103 = {11,17,-1,5,12,ch103data};
-
-/* char: 0x66 'f' */
-
-static const GLubyte ch102data[] = {
-0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0xfe,0x30,0x30,0x30,0x16,
-0xe,
-};
-
-static const BitmapCharRec ch102 = {7,17,0,0,7,ch102data};
-
-/* char: 0x65 'e' */
-
-static const GLubyte ch101data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xff,0x80,
-0xc1,0x80,0x41,0x80,0x63,0x0,0x1e,0x0,
-};
-
-static const BitmapCharRec ch101 = {9,12,-1,0,11,ch101data};
-
-/* char: 0x64 'd' */
-
-static const GLubyte ch100data[] = {
-0x1e,0xc0,0x73,0x80,0x61,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,0xc1,0x80,
-0xc1,0x80,0x61,0x80,0x73,0x80,0x1d,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,
-0x3,0x80,
-};
-
-static const BitmapCharRec ch100 = {10,17,-1,0,12,ch100data};
-
-/* char: 0x63 'c' */
-
-static const GLubyte ch99data[] = {
-0x1e,0x0,0x7f,0x0,0x70,0x80,0xe0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0x41,0x80,0x63,0x80,0x1f,0x0,
-};
-
-static const BitmapCharRec ch99 = {9,12,-1,0,11,ch99data};
-
-/* char: 0x62 'b' */
-
-static const GLubyte ch98data[] = {
-0x5e,0x0,0x73,0x80,0x61,0x80,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,0x60,0xc0,
-0x60,0xc0,0x61,0x80,0x73,0x80,0x6e,0x0,0x60,0x0,0x60,0x0,0x60,0x0,0x60,0x0,
-0xe0,0x0,
-};
-
-static const BitmapCharRec ch98 = {10,17,-1,0,12,ch98data};
-
-/* char: 0x61 'a' */
-
-static const GLubyte ch97data[] = {
-0x71,0x80,0xfb,0x0,0xc7,0x0,0xc3,0x0,0xc3,0x0,0x63,0x0,0x3b,0x0,0xf,0x0,
-0x3,0x0,0x63,0x0,0x67,0x0,0x3e,0x0,
-};
-
-static const BitmapCharRec ch97 = {9,12,-1,0,11,ch97data};
-
-/* char: 0x60 '`' */
-
-static const GLubyte ch96data[] = {
-0x60,0xe0,0x80,0xc0,0x60,
-};
-
-static const BitmapCharRec ch96 = {3,5,-2,-12,7,ch96data};
-
-/* char: 0x5f '_' */
-
-static const GLubyte ch95data[] = {
-0xff,0xf8,0xff,0xf8,
-};
-
-static const BitmapCharRec ch95 = {13,2,0,5,13,ch95data};
-
-/* char: 0x5e '^' */
-
-static const GLubyte ch94data[] = {
-0x80,0x80,0xc1,0x80,0x41,0x0,0x63,0x0,0x22,0x0,0x36,0x0,0x14,0x0,0x1c,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch94 = {9,9,-1,-8,11,ch94data};
-
-/* char: 0x5d ']' */
-
-static const GLubyte ch93data[] = {
-0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
-0x18,0x18,0x18,0x18,0xf8,
-};
-
-static const BitmapCharRec ch93 = {5,21,-1,4,8,ch93data};
-
-/* char: 0x5c '\' */
-
-static const GLubyte ch92data[] = {
-0x6,0x6,0x4,0xc,0xc,0x8,0x18,0x18,0x10,0x30,0x30,0x20,0x60,0x60,0x40,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch92 = {7,17,0,0,7,ch92data};
-
-/* char: 0x5b '[' */
-
-static const GLubyte ch91data[] = {
-0xf8,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0xc0,0xc0,0xf8,
-};
-
-static const BitmapCharRec ch91 = {5,21,-2,4,8,ch91data};
-
-/* char: 0x5a 'Z' */
-
-static const GLubyte ch90data[] = {
-0xff,0xf8,0xe0,0x18,0x70,0x8,0x30,0x8,0x38,0x0,0x18,0x0,0x1c,0x0,0xe,0x0,
-0x6,0x0,0x7,0x0,0x3,0x0,0x3,0x80,0x1,0xc0,0x80,0xc0,0x80,0xe0,0xc0,0x70,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch90 = {13,17,-1,0,15,ch90data};
-
-/* char: 0x59 'Y' */
-
-static const GLubyte ch89data[] = {
-0x7,0xe0,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0xc0,
-0x3,0x40,0x6,0x60,0x6,0x20,0xc,0x30,0x1c,0x10,0x18,0x18,0x38,0x8,0x30,0xc,
-0xfc,0x3f,
-};
-
-static const BitmapCharRec ch89 = {16,17,0,0,16,ch89data};
-
-/* char: 0x58 'X' */
-
-static const GLubyte ch88data[] = {
-0xfc,0xf,0xc0,0x30,0x3,0x80,0x18,0x7,0x0,0x8,0xe,0x0,0x4,0xc,0x0,0x6,
-0x18,0x0,0x2,0x38,0x0,0x1,0x70,0x0,0x0,0xe0,0x0,0x0,0xc0,0x0,0x1,0xc0,
-0x0,0x3,0xa0,0x0,0x3,0x10,0x0,0x6,0x8,0x0,0xe,0xc,0x0,0x1c,0x6,0x0,
-0x7e,0xf,0x80,
-};
-
-static const BitmapCharRec ch88 = {18,17,0,0,18,ch88data};
-
-/* char: 0x57 'W' */
-
-static const GLubyte ch87data[] = {
-0x1,0x83,0x0,0x1,0x83,0x0,0x1,0x83,0x80,0x3,0x87,0x80,0x3,0x46,0x80,0x3,
-0x46,0xc0,0x6,0x46,0x40,0x6,0x4c,0x40,0x6,0x4c,0x60,0xc,0x2c,0x60,0xc,0x2c,
-0x20,0x18,0x2c,0x20,0x18,0x18,0x30,0x18,0x18,0x10,0x30,0x18,0x10,0x30,0x18,0x18,
-0xfc,0x7e,0x7e,
-};
-
-static const BitmapCharRec ch87 = {23,17,0,0,23,ch87data};
-
-/* char: 0x56 'V' */
-
-static const GLubyte ch86data[] = {
-0x1,0x80,0x0,0x1,0x80,0x0,0x1,0x80,0x0,0x3,0xc0,0x0,0x3,0x40,0x0,0x3,
-0x60,0x0,0x6,0x20,0x0,0x6,0x20,0x0,0x6,0x30,0x0,0xc,0x10,0x0,0xc,0x18,
-0x0,0x18,0x8,0x0,0x18,0x8,0x0,0x18,0xc,0x0,0x30,0x4,0x0,0x30,0x6,0x0,
-0xfc,0x1f,0x80,
-};
-
-static const BitmapCharRec ch86 = {17,17,0,0,17,ch86data};
-
-/* char: 0x55 'U' */
-
-static const GLubyte ch85data[] = {
-0x7,0xe0,0x1c,0x30,0x18,0x8,0x30,0x8,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,0x30,0x4,
-0xfc,0x1f,
-};
-
-static const BitmapCharRec ch85 = {16,17,-1,0,18,ch85data};
-
-/* char: 0x54 'T' */
-
-static const GLubyte ch84data[] = {
-0xf,0xc0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,
-0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0x83,0x4,0x83,0x4,0xc3,0xc,
-0xff,0xfc,
-};
-
-static const BitmapCharRec ch84 = {14,17,-1,0,16,ch84data};
-
-/* char: 0x53 'S' */
-
-static const GLubyte ch83data[] = {
-0x9e,0x0,0xf1,0x80,0xc0,0xc0,0x80,0x60,0x80,0x60,0x0,0x60,0x0,0xe0,0x3,0xc0,
-0xf,0x80,0x1e,0x0,0x78,0x0,0xe0,0x0,0xc0,0x40,0xc0,0x40,0xc0,0xc0,0x63,0xc0,
-0x1e,0x40,
-};
-
-static const BitmapCharRec ch83 = {11,17,-1,0,13,ch83data};
-
-/* char: 0x52 'R' */
-
-static const GLubyte ch82data[] = {
-0xfc,0x1e,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0x60,0x30,0xc0,0x31,0xc0,0x33,0x80,
-0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x38,0x30,0x18,0x30,0x38,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch82 = {15,17,-1,0,16,ch82data};
-
-/* char: 0x51 'Q' */
-
-static const GLubyte ch81data[] = {
-0x0,0xf,0x0,0x38,0x0,0x70,0x0,0xe0,0x1,0xc0,0x7,0xe0,0x1c,0x38,0x38,0x1c,
-0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,0x7,0xe0,
-};
-
-static const BitmapCharRec ch81 = {16,22,-1,5,18,ch81data};
-
-/* char: 0x50 'P' */
-
-static const GLubyte ch80data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x3f,0xc0,0x30,0x70,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch80 = {13,17,-1,0,15,ch80data};
-
-/* char: 0x4f 'O' */
-
-static const GLubyte ch79data[] = {
-0x7,0xe0,0x1c,0x38,0x38,0x1c,0x60,0x6,0x60,0x6,0xc0,0x3,0xc0,0x3,0xc0,0x3,
-0xc0,0x3,0xc0,0x3,0xc0,0x3,0xc0,0x3,0x60,0x6,0x60,0x6,0x38,0x1c,0x1c,0x38,
-0x7,0xe0,
-};
-
-static const BitmapCharRec ch79 = {16,17,-1,0,18,ch79data};
-
-/* char: 0x4e 'N' */
-
-static const GLubyte ch78data[] = {
-0xf8,0xc,0x20,0x1c,0x20,0x1c,0x20,0x34,0x20,0x64,0x20,0x64,0x20,0xc4,0x21,0x84,
-0x21,0x84,0x23,0x4,0x26,0x4,0x26,0x4,0x2c,0x4,0x38,0x4,0x38,0x4,0x30,0x4,
-0xf0,0x1f,
-};
-
-static const BitmapCharRec ch78 = {16,17,-1,0,18,ch78data};
-
-/* char: 0x4d 'M' */
-
-static const GLubyte ch77data[] = {
-0xf8,0x21,0xf8,0x20,0x60,0x60,0x20,0x60,0x60,0x20,0xd0,0x60,0x20,0xd0,0x60,0x21,
-0x88,0x60,0x21,0x88,0x60,0x23,0x8,0x60,0x23,0x4,0x60,0x26,0x4,0x60,0x26,0x2,
-0x60,0x2c,0x2,0x60,0x2c,0x2,0x60,0x38,0x1,0x60,0x38,0x1,0x60,0x30,0x0,0xe0,
-0xf0,0x0,0xf8,
-};
-
-static const BitmapCharRec ch77 = {21,17,-1,0,22,ch77data};
-
-/* char: 0x4c 'L' */
-
-static const GLubyte ch76data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,
-0xfc,0x0,
-};
-
-static const BitmapCharRec ch76 = {13,17,-1,0,14,ch76data};
-
-/* char: 0x4b 'K' */
-
-static const GLubyte ch75data[] = {
-0xfc,0x1f,0x30,0xe,0x30,0x1c,0x30,0x38,0x30,0x70,0x30,0xe0,0x31,0xc0,0x33,0x80,
-0x3f,0x0,0x3e,0x0,0x33,0x0,0x31,0x80,0x30,0xc0,0x30,0x60,0x30,0x30,0x30,0x18,
-0xfc,0x7e,
-};
-
-static const BitmapCharRec ch75 = {16,17,-1,0,17,ch75data};
-
-/* char: 0x4a 'J' */
-
-static const GLubyte ch74data[] = {
-0x78,0x0,0xcc,0x0,0xc6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-0x1f,0x80,
-};
-
-static const BitmapCharRec ch74 = {9,17,-1,0,11,ch74data};
-
-/* char: 0x49 'I' */
-
-static const GLubyte ch73data[] = {
-0xfc,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
-0xfc,
-};
-
-static const BitmapCharRec ch73 = {6,17,-1,0,8,ch73data};
-
-/* char: 0x48 'H' */
-
-static const GLubyte ch72data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,
-0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x3f,0xfe,0x0,0x30,0x6,0x0,0x30,0x6,
-0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,0x30,0x6,0x0,
-0xfc,0x1f,0x80,
-};
-
-static const BitmapCharRec ch72 = {17,17,-1,0,19,ch72data};
-
-/* char: 0x47 'G' */
-
-static const GLubyte ch71data[] = {
-0x7,0xe0,0x1e,0x38,0x38,0x1c,0x60,0xc,0x60,0xc,0xc0,0xc,0xc0,0xc,0xc0,0x3f,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
-0x7,0xe4,
-};
-
-static const BitmapCharRec ch71 = {16,17,-1,0,18,ch71data};
-
-/* char: 0x46 'F' */
-
-static const GLubyte ch70data[] = {
-0xfc,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x30,0x20,0x30,0x20,
-0x3f,0xe0,0x30,0x20,0x30,0x20,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch70 = {12,17,-1,0,14,ch70data};
-
-/* char: 0x45 'E' */
-
-static const GLubyte ch69data[] = {
-0xff,0xf8,0x30,0x18,0x30,0x8,0x30,0x8,0x30,0x0,0x30,0x0,0x30,0x40,0x30,0x40,
-0x3f,0xc0,0x30,0x40,0x30,0x40,0x30,0x0,0x30,0x0,0x30,0x10,0x30,0x10,0x30,0x30,
-0xff,0xf0,
-};
-
-static const BitmapCharRec ch69 = {13,17,-1,0,15,ch69data};
-
-/* char: 0x44 'D' */
-
-static const GLubyte ch68data[] = {
-0xff,0xc0,0x30,0x70,0x30,0x38,0x30,0xc,0x30,0xc,0x30,0x6,0x30,0x6,0x30,0x6,
-0x30,0x6,0x30,0x6,0x30,0x6,0x30,0x6,0x30,0xc,0x30,0xc,0x30,0x38,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch68 = {15,17,-1,0,17,ch68data};
-
-/* char: 0x43 'C' */
-
-static const GLubyte ch67data[] = {
-0x7,0xe0,0x1e,0x38,0x38,0x8,0x60,0x4,0x60,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,
-0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0x60,0x4,0x60,0x4,0x38,0xc,0x1c,0x3c,
-0x7,0xe4,
-};
-
-static const BitmapCharRec ch67 = {14,17,-1,0,16,ch67data};
-
-/* char: 0x42 'B' */
-
-static const GLubyte ch66data[] = {
-0xff,0xe0,0x30,0x78,0x30,0x18,0x30,0xc,0x30,0xc,0x30,0xc,0x30,0x18,0x30,0x38,
-0x3f,0xe0,0x30,0x40,0x30,0x30,0x30,0x18,0x30,0x18,0x30,0x18,0x30,0x30,0x30,0x70,
-0xff,0xc0,
-};
-
-static const BitmapCharRec ch66 = {14,17,-1,0,16,ch66data};
-
-/* char: 0x41 'A' */
-
-static const GLubyte ch65data[] = {
-0xfc,0x1f,0x80,0x30,0x6,0x0,0x10,0x6,0x0,0x10,0xc,0x0,0x18,0xc,0x0,0x8,
-0xc,0x0,0xf,0xf8,0x0,0xc,0x18,0x0,0x4,0x18,0x0,0x4,0x30,0x0,0x6,0x30,
-0x0,0x2,0x30,0x0,0x2,0x60,0x0,0x1,0x60,0x0,0x1,0xc0,0x0,0x1,0xc0,0x0,
-0x0,0x80,0x0,
-};
-
-static const BitmapCharRec ch65 = {17,17,0,0,17,ch65data};
-
-/* char: 0x40 '@' */
-
-static const GLubyte ch64data[] = {
-0x3,0xf0,0x0,0xe,0xc,0x0,0x18,0x0,0x0,0x30,0x0,0x0,0x61,0xde,0x0,0x63,
-0x7b,0x0,0xc6,0x39,0x80,0xc6,0x18,0x80,0xc6,0x18,0xc0,0xc6,0x18,0x40,0xc6,0xc,
-0x40,0xc3,0xc,0x40,0xc3,0x8c,0x40,0xe1,0xfc,0x40,0x60,0xec,0xc0,0x70,0x0,0x80,
-0x38,0x1,0x80,0x1c,0x3,0x0,0xf,0xe,0x0,0x3,0xf8,0x0,
-};
-
-static const BitmapCharRec ch64 = {18,20,-2,3,22,ch64data};
-
-/* char: 0x3f '?' */
-
-static const GLubyte ch63data[] = {
-0x30,0x30,0x0,0x0,0x10,0x10,0x10,0x18,0x18,0xc,0xe,0x7,0xc3,0xc3,0x83,0xc6,
-0x7c,
-};
-
-static const BitmapCharRec ch63 = {8,17,-2,0,11,ch63data};
-
-/* char: 0x3e '>' */
-
-static const GLubyte ch62data[] = {
-0xc0,0x0,0x70,0x0,0x1c,0x0,0x7,0x0,0x1,0xc0,0x0,0x60,0x1,0xc0,0x7,0x0,
-0x1c,0x0,0x70,0x0,0xc0,0x0,
-};
-
-static const BitmapCharRec ch62 = {11,11,-1,-1,13,ch62data};
-
-/* char: 0x3d '=' */
-
-static const GLubyte ch61data[] = {
-0xff,0xf0,0xff,0xf0,0x0,0x0,0x0,0x0,0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch61 = {12,6,-1,-4,14,ch61data};
-
-/* char: 0x3c '<' */
-
-static const GLubyte ch60data[] = {
-0x0,0x60,0x1,0xc0,0x7,0x0,0x1c,0x0,0x70,0x0,0xc0,0x0,0x70,0x0,0x1c,0x0,
-0x7,0x0,0x1,0xc0,0x0,0x60,
-};
-
-static const BitmapCharRec ch60 = {11,11,-1,-1,13,ch60data};
-
-/* char: 0x3b ';' */
-
-static const GLubyte ch59data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch59 = {3,14,-2,3,7,ch59data};
-
-/* char: 0x3a ':' */
-
-static const GLubyte ch58data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0xc0,
-};
-
-static const BitmapCharRec ch58 = {2,11,-2,0,6,ch58data};
-
-/* char: 0x39 '9' */
-
-static const GLubyte ch57data[] = {
-0xf0,0x0,0x1c,0x0,0x6,0x0,0x3,0x0,0x3,0x80,0x1,0x80,0x1d,0x80,0x73,0xc0,
-0x61,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc1,0xc0,0x61,0x80,0x77,0x80,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch57 = {10,17,-1,0,12,ch57data};
-
-/* char: 0x38 '8' */
-
-static const GLubyte ch56data[] = {
-0x1e,0x0,0x73,0x80,0xe1,0x80,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x41,0xc0,0x61,0x80,
-0x37,0x0,0x1e,0x0,0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch56 = {10,17,-1,0,12,ch56data};
-
-/* char: 0x37 '7' */
-
-static const GLubyte ch55data[] = {
-0x18,0x0,0x18,0x0,0xc,0x0,0xc,0x0,0xc,0x0,0x4,0x0,0x6,0x0,0x6,0x0,
-0x2,0x0,0x3,0x0,0x3,0x0,0x1,0x0,0x1,0x80,0x81,0x80,0xc0,0xc0,0xff,0xc0,
-0x7f,0xc0,
-};
-
-static const BitmapCharRec ch55 = {10,17,-1,0,12,ch55data};
-
-/* char: 0x36 '6' */
-
-static const GLubyte ch54data[] = {
-0x1e,0x0,0x7b,0x80,0x61,0x80,0xe0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc1,0x80,0xf3,0x80,0xee,0x0,0x60,0x0,0x70,0x0,0x30,0x0,0x18,0x0,0xe,0x0,
-0x3,0xc0,
-};
-
-static const BitmapCharRec ch54 = {10,17,-1,0,12,ch54data};
-
-/* char: 0x35 '5' */
-
-static const GLubyte ch53data[] = {
-0x7e,0x0,0xe3,0x80,0xc1,0x80,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x0,0xc0,0x1,0xc0,
-0x3,0x80,0xf,0x80,0x7e,0x0,0x78,0x0,0x60,0x0,0x20,0x0,0x20,0x0,0x1f,0x80,
-0x1f,0xc0,
-};
-
-static const BitmapCharRec ch53 = {10,17,-1,0,12,ch53data};
-
-/* char: 0x34 '4' */
-
-static const GLubyte ch52data[] = {
-0x3,0x0,0x3,0x0,0x3,0x0,0x3,0x0,0xff,0xc0,0xff,0xc0,0xc3,0x0,0x43,0x0,
-0x63,0x0,0x23,0x0,0x33,0x0,0x13,0x0,0x1b,0x0,0xb,0x0,0x7,0x0,0x7,0x0,
-0x3,0x0,
-};
-
-static const BitmapCharRec ch52 = {10,17,-1,0,12,ch52data};
-
-/* char: 0x33 '3' */
-
-static const GLubyte ch51data[] = {
-0x78,0x0,0xe6,0x0,0xc3,0x0,0x1,0x0,0x1,0x80,0x1,0x80,0x1,0x80,0x3,0x80,
-0x7,0x0,0x1e,0x0,0xc,0x0,0x6,0x0,0x83,0x0,0x83,0x0,0x47,0x0,0x7e,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch51 = {9,17,-1,0,12,ch51data};
-
-/* char: 0x32 '2' */
-
-static const GLubyte ch50data[] = {
-0xff,0x80,0xff,0xc0,0x60,0x40,0x30,0x0,0x18,0x0,0xc,0x0,0x4,0x0,0x6,0x0,
-0x3,0x0,0x3,0x0,0x1,0x80,0x1,0x80,0x81,0x80,0x81,0x80,0x43,0x80,0x7f,0x0,
-0x1c,0x0,
-};
-
-static const BitmapCharRec ch50 = {10,17,-1,0,12,ch50data};
-
-/* char: 0x31 '1' */
-
-static const GLubyte ch49data[] = {
-0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x78,0x18,
-0x8,
-};
-
-static const BitmapCharRec ch49 = {8,17,-2,0,12,ch49data};
-
-/* char: 0x30 '0' */
-
-static const GLubyte ch48data[] = {
-0x1e,0x0,0x33,0x0,0x61,0x80,0x61,0x80,0xe1,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x61,0x80,0x61,0x80,0x33,0x0,
-0x1e,0x0,
-};
-
-static const BitmapCharRec ch48 = {10,17,-1,0,12,ch48data};
-
-/* char: 0x2f '/' */
-
-static const GLubyte ch47data[] = {
-0xc0,0xc0,0xc0,0x60,0x60,0x20,0x30,0x30,0x10,0x18,0x18,0x8,0xc,0xc,0x4,0x6,
-0x6,0x3,0x3,0x3,
-};
-
-static const BitmapCharRec ch47 = {8,20,1,3,7,ch47data};
-
-/* char: 0x2e '.' */
-
-static const GLubyte ch46data[] = {
-0xc0,0xc0,
-};
-
-static const BitmapCharRec ch46 = {2,2,-2,0,6,ch46data};
-
-/* char: 0x2d '-' */
-
-static const GLubyte ch45data[] = {
-0xff,0xf0,0xff,0xf0,
-};
-
-static const BitmapCharRec ch45 = {12,2,-1,-6,14,ch45data};
-
-/* char: 0x2c ',' */
-
-static const GLubyte ch44data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch44 = {3,5,-2,3,7,ch44data};
-
-/* char: 0x2b '+' */
-
-static const GLubyte ch43data[] = {
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,0xff,0xf0,0xff,0xf0,0x6,0x0,
-0x6,0x0,0x6,0x0,0x6,0x0,0x6,0x0,
-};
-
-static const BitmapCharRec ch43 = {12,12,-1,-1,14,ch43data};
-
-/* char: 0x2a '*' */
-
-static const GLubyte ch42data[] = {
-0x8,0x0,0x1c,0x0,0xc9,0x80,0xeb,0x80,0x1c,0x0,0xeb,0x80,0xc9,0x80,0x1c,0x0,
-0x8,0x0,
-};
-
-static const BitmapCharRec ch42 = {9,9,-2,-8,12,ch42data};
-
-/* char: 0x29 ')' */
-
-static const GLubyte ch41data[] = {
-0x80,0x40,0x20,0x30,0x10,0x18,0x18,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0xc,0x18,
-0x18,0x10,0x30,0x20,0x40,0x80,
-};
-
-static const BitmapCharRec ch41 = {6,22,-1,5,8,ch41data};
-
-/* char: 0x28 '(' */
-
-static const GLubyte ch40data[] = {
-0x4,0x8,0x10,0x30,0x20,0x60,0x60,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x60,
-0x60,0x20,0x30,0x10,0x8,0x4,
-};
-
-static const BitmapCharRec ch40 = {6,22,-1,5,8,ch40data};
-
-/* char: 0x27 ''' */
-
-static const GLubyte ch39data[] = {
-0xc0,0x60,0x20,0xe0,0xc0,
-};
-
-static const BitmapCharRec ch39 = {3,5,-3,-12,8,ch39data};
-
-/* char: 0x26 '&' */
-
-static const GLubyte ch38data[] = {
-0x3c,0x3c,0x7f,0x7e,0xe1,0xe1,0xc0,0xc0,0xc1,0xc0,0xc1,0xa0,0x63,0x20,0x37,0x10,
-0x1e,0x18,0xe,0x3e,0xf,0x0,0x1d,0x80,0x18,0xc0,0x18,0x40,0x18,0x40,0xc,0xc0,
-0x7,0x80,
-};
-
-static const BitmapCharRec ch38 = {16,17,-1,0,18,ch38data};
-
-/* char: 0x25 '%' */
-
-static const GLubyte ch37data[] = {
-0x30,0x3c,0x0,0x18,0x72,0x0,0xc,0x61,0x0,0x4,0x60,0x80,0x6,0x60,0x80,0x3,
-0x30,0x80,0x1,0x19,0x80,0x1,0x8f,0x0,0x78,0xc0,0x0,0xe4,0x40,0x0,0xc2,0x60,
-0x0,0xc1,0x30,0x0,0xc1,0x10,0x0,0x61,0x18,0x0,0x33,0xfc,0x0,0x1e,0xc,0x0,
-};
-
-static const BitmapCharRec ch37 = {17,16,-1,0,19,ch37data};
-
-/* char: 0x24 '$' */
-
-static const GLubyte ch36data[] = {
-0x4,0x0,0x4,0x0,0x3f,0x0,0xe5,0xc0,0xc4,0xc0,0x84,0x60,0x84,0x60,0x4,0x60,
-0x4,0xe0,0x7,0xc0,0x7,0x80,0x1e,0x0,0x3c,0x0,0x74,0x0,0x64,0x0,0x64,0x20,
-0x64,0x60,0x34,0xe0,0x1f,0x80,0x4,0x0,0x4,0x0,
-};
-
-static const BitmapCharRec ch36 = {11,21,0,2,12,ch36data};
-
-/* char: 0x23 '#' */
-
-static const GLubyte ch35data[] = {
-0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0x22,0x0,0xff,0xc0,0xff,0xc0,0x11,0x0,
-0x11,0x0,0x11,0x0,0x7f,0xe0,0x7f,0xe0,0x8,0x80,0x8,0x80,0x8,0x80,0x8,0x80,
-0x8,0x80,
-};
-
-static const BitmapCharRec ch35 = {11,17,-1,0,13,ch35data};
-
-/* char: 0x22 '"' */
-
-static const GLubyte ch34data[] = {
-0x88,0xcc,0xcc,0xcc,0xcc,
-};
-
-static const BitmapCharRec ch34 = {6,5,-1,-12,10,ch34data};
-
-/* char: 0x21 '!' */
-
-static const GLubyte ch33data[] = {
-0xc0,0xc0,0x0,0x0,0x0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,
-0xc0,
-};
-
-static const BitmapCharRec ch33 = {2,17,-3,0,8,ch33data};
-
-/* char: 0x20 ' ' */
-
-#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,6,ch32data};
-#else
-static const BitmapCharRec ch32 = {0,0,0,0,6,0};
-#endif
-
-static const BitmapCharRec * const chars[] = {
-&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,
-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,
-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,
-};
-
-GLUTAPI const BitmapFontRec glutBitmapTimesRoman24;
-const BitmapFontRec glutBitmapTimesRoman24 = {
-"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
-224,
-32,
-chars
-};
-
diff --git a/src/glut/glx/glut_util.c b/src/glut/glx/glut_util.c
deleted file mode 100644
index 4ebac64c1d9..00000000000
--- a/src/glut/glx/glut_util.c
+++ /dev/null
@@ -1,86 +0,0 @@
-
-/* 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. */
-
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "glutint.h"
-
-/* strdup is actually not a standard ANSI C or POSIX routine
-   so implement a private one for GLUT.  OpenVMS does not have a
-   strdup; Linux's standard libc doesn't declare strdup by default
-   (unless BSD or SVID interfaces are requested). */
-char *
-__glutStrdup(const char *string)
-{
-  char *copy;
-
-  copy = (char*) malloc(strlen(string) + 1);
-  if (copy == NULL)
-    return NULL;
-  strcpy(copy, string);
-  return copy;
-}
-
-void
-__glutWarning(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Warning in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-}
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutReportErrors(void)
-{
-  GLenum error;
-
-  while ((error = glGetError()) != GL_NO_ERROR)
-    __glutWarning("GL error: %s", gluErrorString(error));
-}
-/* ENDCENTRY */
-
-void
-__glutFatalError(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Fatal Error in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-#ifdef _WIN32
-  if (__glutExitFunc) {
-    __glutExitFunc(1);
-  }
-#endif
-  exit(1);
-}
-
-void
-__glutFatalUsage(char *format,...)
-{
-  va_list args;
-
-  va_start(args, format);
-  fprintf(stderr, "GLUT: Fatal API Usage in %s: ",
-    __glutProgramName ? __glutProgramName : "(unamed)");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  putc('\n', stderr);
-  abort();
-}
diff --git a/src/glut/glx/glut_vidresize.c b/src/glut/glx/glut_vidresize.c
deleted file mode 100644
index 5993e837099..00000000000
--- a/src/glut/glx/glut_vidresize.c
+++ /dev/null
@@ -1,231 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996. */
-
-/* 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. */
-
-#include <stdlib.h>
-
-#ifdef __sgi
-#include <dlfcn.h>
-#endif
-
-#include "glutint.h"
-
-/* Grumble.  The IRIX 6.3 and early IRIX 6.4 OpenGL headers
-   support the video resize extension, but failed to define
-   GLX_SGIX_video_resize. */
-#if 0
-#ifdef GLX_SYNC_FRAME_SGIX
-#define GLX_SGIX_video_resize 1
-#endif
-#endif
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-static int canVideoResize = -1;
-static int videoResizeChannel;
-#else
-static int canVideoResize = 0;
-#endif
-static int videoResizeInUse = 0;
-static int dx = -1, dy = -1, dw = -1, dh = -1;
-
-/* XXX Note that IRIX 6.2, 6.3, and some 6.4 versions have a
-   bug where programs seg-fault when they attempt video
-   resizing from an indirect OpenGL context (either local or
-   over a network). */
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-
-static volatile int errorCaught;
-
-/* ARGSUSED */
-static int
-catchXSGIvcErrors(Display * dpy, XErrorEvent * event)
-{
-  errorCaught = 1;
-  return 0;
-}
-#endif
-
-/* CENTRY */
-int GLUTAPIENTRY 
-glutVideoResizeGet(GLenum param)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (canVideoResize < 0) {
-    canVideoResize = __glutIsSupportedByGLX("GLX_SGIX_video_resize");
-    if (canVideoResize) {
-#if defined(__sgi) && __sgi
-      /* This is a hack because IRIX 6.2, 6.3, and some 6.4
-         versions were released with GLX_SGIX_video_resize
-         being advertised by the X server though the video
-         resize extension is not actually supported.  We try to
-         determine if the libGL.so we are using actually has a
-         video resize entrypoint before we try to use the
-         feature. */
-      void (*func) (void);
-      void *glxDso = dlopen("libGL.so", RTLD_LAZY);
-
-      func = (void (*)(void)) dlsym(glxDso, "glXQueryChannelDeltasSGIX");
-      if (!func) {
-        canVideoResize = 0;
-      } else
-#endif
-      {
-        char *channelString;
-        int (*handler) (Display *, XErrorEvent *);
-
-        channelString = getenv("GLUT_VIDEO_RESIZE_CHANNEL");
-        videoResizeChannel = channelString ? atoi(channelString) : 0;
-
-        /* Work around another annoying problem with SGI's
-           GLX_SGIX_video_resize implementation.  Early IRIX
-           6.4 OpenGL's advertise the extension and have the
-           video resize API, but an XSGIvc X protocol errors
-           result trying to use the API.  Set up an error
-           handler to intercept what would otherwise be a fatal
-           error.  If an error was recieved, do not report that
-           video resize is possible. */
-        handler = XSetErrorHandler(catchXSGIvcErrors);
-
-        errorCaught = 0;
-
-#if defined(GLX_GLXEXT_PROTOTYPES)
-#endif
-
-        __glut_glXQueryChannelDeltasSGIX(__glutDisplay, __glutScreen,
-          videoResizeChannel, &dx, &dy, &dw, &dh);
-
-        /* glXQueryChannelDeltasSGIX is an inherent X server
-           round-trip so we know we will have gotten either the
-           correct reply or and error by this time. */
-        XSetErrorHandler(handler);
-
-        /* Still yet another work around.  In IRIX 6.4 betas,
-           glXQueryChannelDeltasSGIX will return as if it
-           succeeded, but the values are filled with junk.
-           Watch to make sure the delta variables really make
-           sense. */
-        if (errorCaught ||
-          dx < 0 || dy < 0 || dw < 0 || dh < 0 ||
-          dx > 2048 || dy > 2048 || dw > 2048 || dh > 2048) {
-          canVideoResize = 0;
-        }
-      }
-    }
-  }
-#endif /* GLX_SGIX_video_resize */
-
-  switch (param) {
-  case GLUT_VIDEO_RESIZE_POSSIBLE:
-    return canVideoResize;
-  case GLUT_VIDEO_RESIZE_IN_USE:
-    return videoResizeInUse;
-  case GLUT_VIDEO_RESIZE_X_DELTA:
-    return dx;
-  case GLUT_VIDEO_RESIZE_Y_DELTA:
-    return dy;
-  case GLUT_VIDEO_RESIZE_WIDTH_DELTA:
-    return dw;
-  case GLUT_VIDEO_RESIZE_HEIGHT_DELTA:
-    return dh;
-  case GLUT_VIDEO_RESIZE_X:
-  case GLUT_VIDEO_RESIZE_Y:
-  case GLUT_VIDEO_RESIZE_WIDTH:
-  case GLUT_VIDEO_RESIZE_HEIGHT:
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-    if (videoResizeInUse) {
-      int x, y, width, height;
-
-      __glut_glXQueryChannelRectSGIX(__glutDisplay, __glutScreen,
-        videoResizeChannel, &x, &y, &width, &height);
-      switch (param) {
-      case GLUT_VIDEO_RESIZE_X:
-        return x;
-      case GLUT_VIDEO_RESIZE_Y:
-        return y;
-      case GLUT_VIDEO_RESIZE_WIDTH:
-        return width;
-      case GLUT_VIDEO_RESIZE_HEIGHT:
-        return height;
-      }
-    }
-#endif
-    return -1;
-  default:
-    __glutWarning("invalid glutVideoResizeGet parameter: %d", param);
-    return -1;
-  }
-}
-
-void GLUTAPIENTRY 
-glutSetupVideoResizing(void)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
-    __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, __glutCurrentWindow->win);
-    videoResizeInUse = 1;
-  } else
-#endif
-    __glutFatalError("glutEstablishVideoResizing: video resizing not possible.\n");
-}
-
-void GLUTAPIENTRY 
-glutStopVideoResizing(void)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (glutVideoResizeGet(GLUT_VIDEO_RESIZE_POSSIBLE)) {
-    if (videoResizeInUse) {
-      __glut_glXBindChannelToWindowSGIX(__glutDisplay, __glutScreen,
-        videoResizeChannel, None);
-      videoResizeInUse = 0;
-    }
-  }
-#endif
-}
-
-/* ARGSUSED */
-void GLUTAPIENTRY 
-glutVideoResize(int x, int y, int width, int height)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (videoResizeInUse) {
-#ifdef GLX_SYNC_SWAP_SGIX
-    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
-       6.2; the original unpatched IRIX 6.2 behavior is always
-       GLX_SYNC_SWAP_SGIX. */
-    __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, GLX_SYNC_SWAP_SGIX);
-#endif
-    __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, x, y, width, height);
-  }
-#endif
-}
-
-/* ARGSUSED */
-void GLUTAPIENTRY 
-glutVideoPan(int x, int y, int width, int height)
-{
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_video_resize)
-  if (videoResizeInUse) {
-#ifdef GLX_SYNC_FRAME_SGIX
-    /* glXChannelRectSyncSGIX introduced in a patch to IRIX
-       6.2; the original unpatched IRIX 6.2 behavior is always
-       GLX_SYNC_SWAP_SGIX.  We just ignore that we cannot
-       accomplish GLX_SYNC_FRAME_SGIX on IRIX unpatched 6.2;
-       this means you'd need a glutSwapBuffers to actually
-       realize the video resize. */
-    __glut_glXChannelRectSyncSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, GLX_SYNC_FRAME_SGIX);
-#endif
-    __glut_glXChannelRectSGIX(__glutDisplay, __glutScreen,
-      videoResizeChannel, x, y, width, height);
-  }
-#endif
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_warp.c b/src/glut/glx/glut_warp.c
deleted file mode 100644
index 3d48655ed1c..00000000000
--- a/src/glut/glx/glut_warp.c
+++ /dev/null
@@ -1,23 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1996, 1997. */
-
-/* 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. */
-
-#include <stdlib.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutWarpPointer(int x, int y)
-{
-  XWarpPointer(__glutDisplay, None, __glutCurrentWindow->win,
-    0, 0, 0, 0, x, y);
-  XFlush(__glutDisplay);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glut_win.c b/src/glut/glx/glut_win.c
deleted file mode 100644
index 18554b3e97f..00000000000
--- a/src/glut/glx/glut_win.c
+++ /dev/null
@@ -1,1035 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997.  */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#include <X11/Xatom.h>
-#endif
-
-#include "glutint.h"
-
-GLUTwindow *__glutCurrentWindow = NULL;
-GLUTwindow **__glutWindowList = NULL;
-int __glutWindowListSize = 0;
-#if !defined(_WIN32)
-GLUTstale *__glutStaleWindowList = NULL;
-#endif
-GLUTwindow *__glutMenuWindow = NULL;
-
-void (*__glutFreeOverlayFunc) (GLUToverlay *);
-XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc) = NULL;
-
-static Criterion requiredWindowCriteria[] =
-{
-  {LEVEL, EQ, 0},
-  {TRANSPARENT, EQ, 0}
-};
-static int numRequiredWindowCriteria = sizeof(requiredWindowCriteria) / sizeof(Criterion);
-static int requiredWindowCriteriaMask = (1 << LEVEL) | (1 << TRANSPARENT);
-
-static void
-cleanWindowWorkList(GLUTwindow * window)
-{
-  GLUTwindow **pEntry = &__glutWindowWorkList;
-  GLUTwindow *entry = __glutWindowWorkList;
-
-  /* Tranverse singly-linked window work list look for the
-     window. */
-  while (entry) {
-    if (entry == window) {
-      /* Found it; delete it. */
-      *pEntry = entry->prevWorkWin;
-      return;
-    } else {
-      pEntry = &entry->prevWorkWin;
-      entry = *pEntry;
-    }
-  }
-}
-
-#if !defined(_WIN32)
-
-static void
-cleanStaleWindowList(GLUTwindow * window)
-{
-  GLUTstale **pEntry = &__glutStaleWindowList;
-  GLUTstale *entry = __glutStaleWindowList;
-
-  /* Tranverse singly-linked stale window list look for the
-     window ID. */
-  while (entry) {
-    if (entry->window == window) {
-      /* Found it; delete it. */
-      *pEntry = entry->next;
-      free(entry);
-      return;
-    } else {
-      pEntry = &entry->next;
-      entry = *pEntry;
-    }
-  }
-}
-
-#endif
-
-static GLUTwindow *__glutWindowCache = NULL;
-
-GLUTwindow *
-__glutGetWindow(Window win)
-{
-  int i;
-
-  /* Does win belong to the last window ID looked up? */
-  if (__glutWindowCache && (win == __glutWindowCache->win ||
-      (__glutWindowCache->overlay && win ==
-        __glutWindowCache->overlay->win))) {
-    return
-      __glutWindowCache;
-  }
-  /* Otherwise scan the window list looking for the window ID. */
-  for (i = 0; i < __glutWindowListSize; i++) {
-    if (__glutWindowList[i]) {
-      if (win == __glutWindowList[i]->win) {
-        __glutWindowCache = __glutWindowList[i];
-        return __glutWindowCache;
-      }
-      if (__glutWindowList[i]->overlay) {
-        if (win == __glutWindowList[i]->overlay->win) {
-          __glutWindowCache = __glutWindowList[i];
-          return __glutWindowCache;
-        }
-      }
-    }
-  }
-#if !defined(_WIN32)
-  {
-    GLUTstale *entry;
-
-    /* Scan through destroyed overlay window IDs for which no
-       DestroyNotify has yet been received. */
-    for (entry = __glutStaleWindowList; entry; entry = entry->next) {
-      if (entry->win == win)
-        return entry->window;
-    }
-  }
-#endif
-  return NULL;
-}
-
-/* CENTRY */
-int GLUTAPIENTRY
-glutGetWindow(void)
-{
-  if (__glutCurrentWindow) {
-    return __glutCurrentWindow->num + 1;
-  } else {
-    return 0;
-  }
-}
-/* ENDCENTRY */
-
-void
-__glutSetWindow(GLUTwindow * window)
-{
-  /* It is tempting to try to short-circuit the call to
-     glXMakeCurrent if we "know" we are going to make current
-     to a window we are already current to.  In fact, this
-     assumption breaks when GLUT is expected to integrated with
-     other OpenGL windowing APIs that also make current to
-     OpenGL contexts.  Since glXMakeCurrent short-circuits the
-     "already bound" case, GLUT avoids the temptation to do so
-     too. */
-  __glutCurrentWindow = window;
-
-  MAKE_CURRENT_LAYER(__glutCurrentWindow);
-
-#if !defined(_WIN32)
-  /* We should be careful to force a finish between each
-     iteration through the GLUT main loop if indirect OpenGL 
-     contexts are in use; indirect contexts tend to have  much
-     longer latency because lots of OpenGL extension requests
-     can queue up in the X protocol stream.  We accomplish this
-     by posting GLUT_FINISH_WORK to be done. */
-  if (!__glutCurrentWindow->isDirect)
-    __glutPutOnWorkList(__glutCurrentWindow, GLUT_FINISH_WORK);
-#endif
-
-  /* If debugging is enabled, we'll want to check this window
-     for any OpenGL errors every iteration through the GLUT
-     main loop.  To accomplish this, we post the
-     GLUT_DEBUG_WORK to be done on this window. */
-  if (__glutDebug) {
-    __glutPutOnWorkList(__glutCurrentWindow, GLUT_DEBUG_WORK);
-  }
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutSetWindow(int win)
-{
-  GLUTwindow *window;
-
-  if (win < 1 || win > __glutWindowListSize) {
-    __glutWarning("glutSetWindow attempted on bogus window.");
-    return;
-  }
-  window = __glutWindowList[win - 1];
-  if (!window) {
-    __glutWarning("glutSetWindow attempted on bogus window.");
-    return;
-  }
-  __glutSetWindow(window);
-}
-/* ENDCENTRY */
-
-static int
-getUnusedWindowSlot(void)
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < __glutWindowListSize; i++) {
-    if (!__glutWindowList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  __glutWindowListSize++;
-  if (__glutWindowList) {
-    __glutWindowList = (GLUTwindow **)
-      realloc(__glutWindowList,
-      __glutWindowListSize * sizeof(GLUTwindow *));
-  } else {
-    /* XXX Some realloc's do not correctly perform a malloc
-       when asked to perform a realloc on a NULL pointer,
-       though the ANSI C library spec requires this. */
-    __glutWindowList = (GLUTwindow **)
-      malloc(sizeof(GLUTwindow *));
-  }
-  if (!__glutWindowList)
-    __glutFatalError("out of memory.");
-  __glutWindowList[__glutWindowListSize - 1] = NULL;
-  return __glutWindowListSize - 1;
-}
-
-static XVisualInfo *
-getVisualInfoCI(unsigned int mode)
-{
-  static int bufSizeList[] =
-  {16, 12, 8, 4, 2, 1, 0};
-  XVisualInfo *vi;
-  int list[32];
-  int i, n = 0;
-
-  /* Should not be looking at display mode mask if
-     __glutDisplayString is non-NULL. */
-  assert(!__glutDisplayString);
-
-  list[n++] = GLX_BUFFER_SIZE;
-  list[n++] = 1;
-  if (GLUT_WIND_IS_DOUBLE(mode)) {
-    list[n++] = GLX_DOUBLEBUFFER;
-  }
-  if (GLUT_WIND_IS_STEREO(mode)) {
-    list[n++] = GLX_STEREO;
-  }
-  if (GLUT_WIND_HAS_DEPTH(mode)) {
-    list[n++] = GLX_DEPTH_SIZE;
-    list[n++] = 1;
-  }
-  if (GLUT_WIND_HAS_STENCIL(mode)) {
-    list[n++] = GLX_STENCIL_SIZE;
-    list[n++] = 1;
-  }
-  list[n] = (int) None; /* terminate list */
-
-  /* glXChooseVisual specify GLX_BUFFER_SIZE prefers the
-     "smallest index buffer of at least the specified size".
-     This would be reasonable if GLUT allowed the user to
-     specify the required buffe size, but GLUT's display mode
-     is too simplistic (easy to use?). GLUT should try to find
-     the "largest".  So start with a large buffer size and
-     shrink until we find a matching one that exists. */
-
-  for (i = 0; bufSizeList[i]; i++) {
-    /* XXX Assumes list[1] is where GLX_BUFFER_SIZE parameter
-       is. */
-    list[1] = bufSizeList[i];
-    vi = glXChooseVisual(__glutDisplay,
-      __glutScreen, list);
-    if (vi)
-      return vi;
-  }
-  return NULL;
-}
-
-static XVisualInfo *
-getVisualInfoRGB(unsigned int mode)
-{
-  int list[32];
-  int n = 0;
-
-  /* Should not be looking at display mode mask if
-     __glutDisplayString is non-NULL. */
-  assert(!__glutDisplayString);
-
-  /* XXX Would a caching mechanism to minize the calls to
-     glXChooseVisual? You'd have to reference count
-     XVisualInfo* pointers.  Would also have to properly
-     interact with glutInitDisplayString. */
-
-  list[n++] = GLX_RGBA;
-  list[n++] = GLX_RED_SIZE;
-  list[n++] = 1;
-  list[n++] = GLX_GREEN_SIZE;
-  list[n++] = 1;
-  list[n++] = GLX_BLUE_SIZE;
-  list[n++] = 1;
-  if (GLUT_WIND_HAS_ALPHA(mode)) {
-    list[n++] = GLX_ALPHA_SIZE;
-    list[n++] = 1;
-  }
-  if (GLUT_WIND_IS_DOUBLE(mode)) {
-    list[n++] = GLX_DOUBLEBUFFER;
-  }
-  if (GLUT_WIND_IS_STEREO(mode)) {
-    list[n++] = GLX_STEREO;
-  }
-  if (GLUT_WIND_HAS_DEPTH(mode)) {
-    list[n++] = GLX_DEPTH_SIZE;
-    list[n++] = 1;
-  }
-  if (GLUT_WIND_HAS_STENCIL(mode)) {
-    list[n++] = GLX_STENCIL_SIZE;
-    list[n++] = 1;
-  }
-  if (GLUT_WIND_HAS_ACCUM(mode)) {
-    list[n++] = GLX_ACCUM_RED_SIZE;
-    list[n++] = 1;
-    list[n++] = GLX_ACCUM_GREEN_SIZE;
-    list[n++] = 1;
-    list[n++] = GLX_ACCUM_BLUE_SIZE;
-    list[n++] = 1;
-    if (GLUT_WIND_HAS_ALPHA(mode)) {
-      list[n++] = GLX_ACCUM_ALPHA_SIZE;
-      list[n++] = 1;
-    }
-  }
-#if defined(GLX_VERSION_1_1) && (defined(GLX_SGIS_multisample) || defined(GLX_ARB_multisample))
-  if (GLUT_WIND_IS_MULTISAMPLE(mode)) {
-    if (!__glutIsSupportedByGLX("GLX_SGIS_multisample") &&
-        !__glutIsSupportedByGLX("GLX_ARB_multisample"))
-      return NULL;
-#if defined(GLX_ARB_multisample)
-    list[n++] = GLX_SAMPLES_ARB;
-#elif defined(GLX_SGIS_multisample)
-    list[n++] = GLX_SAMPLES_SGIS;
-#endif
-    /* XXX Is 4 a reasonable minimum acceptable number of
-       samples? */
-    list[n++] = 4;
-  }
-#endif
-  list[n] = (int) None; /* terminate list */
-
-  return glXChooseVisual(__glutDisplay,
-    __glutScreen, list);
-}
-
-#ifndef VisualIDMask
-#define VisualIDMask 0
-#endif
-
-static XVisualInfo *
-getVisualInfoID(int id)
-{
-   XVisualInfo temp;
-   int count;
-#if !defined(_WIN32)
-   temp.visualid = id;
-#endif
-   return XGetVisualInfo(__glutDisplay, VisualIDMask, &temp, &count);
-}
-
-
-XVisualInfo *
-__glutGetVisualInfo(unsigned int mode)
-{
-  char *visStr;
-  /* XXX GLUT_LUMINANCE not implemented for GLUT 3.0. */
-  if (GLUT_WIND_IS_LUMINANCE(mode))
-    return NULL;
-
-  visStr = getenv("GLUT_FORCE_VISUAL");
-  if (visStr) {
-     int id = atoi(visStr);
-     return getVisualInfoID(id);
-  }
-
-  if (GLUT_WIND_IS_RGB(mode))
-    return getVisualInfoRGB(mode);
-  else
-    return getVisualInfoCI(mode);
-}
-
-XVisualInfo *
-__glutDetermineVisual(
-  unsigned int displayMode,
-  Bool * treatAsSingle,
-  XVisualInfo * (getVisualInfo) (unsigned int))
-{
-  XVisualInfo *vis;
-
-  /* Should not be looking at display mode mask if
-     __glutDisplayString is non-NULL. */
-  assert(!__glutDisplayString);
-
-  *treatAsSingle = GLUT_WIND_IS_SINGLE(displayMode);
-  vis = getVisualInfo(displayMode);
-  if (!vis) {
-    /* Fallback cases when can't get exactly what was asked
-       for... */
-    if (GLUT_WIND_IS_SINGLE(displayMode)) {
-      /* If we can't find a single buffered visual, try looking
-         for a double buffered visual.  We can treat a double
-         buffered visual as a single buffer visual by changing
-         the draw buffer to GL_FRONT and treating any swap
-         buffers as no-ops. */
-      displayMode |= GLUT_DOUBLE;
-      vis = getVisualInfo(displayMode);
-      *treatAsSingle = True;
-    }
-    if (!vis && GLUT_WIND_IS_MULTISAMPLE(displayMode)) {
-      /* If we can't seem to get multisampling (ie, not Reality
-         Engine class graphics!), go without multisampling.  It
-         is up to the application to query how many multisamples
-         were allocated (0 equals no multisampling) if the
-         application is going to use multisampling for more than
-         just antialiasing. */
-      displayMode &= ~GLUT_MULTISAMPLE;
-      vis = getVisualInfo(displayMode);
-    }
-  }
-  return vis;
-}
-
-static void GLUTCALLBACK
-__glutDefaultDisplay(void)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
-  __glutFatalError(
-    "redisplay needed for window %d, but no display callback.",
-    __glutCurrentWindow->num + 1);
-}
-
-void GLUTCALLBACK
-__glutDefaultReshape(int width, int height)
-{
-  GLUToverlay *overlay;
-
-  /* Adjust the viewport of the window (and overlay if one
-     exists). */
-  MAKE_CURRENT_WINDOW(__glutCurrentWindow);
-  glViewport(0, 0, (GLsizei) width, (GLsizei) height);
-  overlay = __glutCurrentWindow->overlay;
-  if (overlay) {
-    MAKE_CURRENT_OVERLAY(overlay);
-    glViewport(0, 0, (GLsizei) width, (GLsizei) height);
-  }
-  /* Make sure we are current to the current layer (application
-     should be able to count on the current layer not changing
-     unless the application explicitly calls glutUseLayer). */
-  MAKE_CURRENT_LAYER(__glutCurrentWindow);
-}
-
-XVisualInfo *
-__glutDetermineWindowVisual(Bool * treatAsSingle, Bool * visAlloced, void **fbc)
-{
-  if (__glutDisplayString) {
-
-    /* __glutDisplayString should be NULL except if
-       glutInitDisplayString has been called to register a
-       different display string.  Calling glutInitDisplayString
-       means using a string instead of an integer mask determine
-       the visual to use. Using the function pointer variable
-       __glutDetermineVisualFromString below avoids linking in
-       the code for implementing glutInitDisplayString (ie,
-       glut_dstr.o) unless glutInitDisplayString gets called by
-       the application. */
-
-    assert(__glutDetermineVisualFromString);
-    *visAlloced = False;
-    *fbc = NULL;
-    return __glutDetermineVisualFromString(__glutDisplayString, treatAsSingle,
-      requiredWindowCriteria, numRequiredWindowCriteria, requiredWindowCriteriaMask, fbc);
-  } else {
-    *visAlloced = True;
-    *fbc = NULL;
-    return __glutDetermineVisual(__glutDisplayMode,
-      treatAsSingle, __glutGetVisualInfo);
-  }
-}
-
-/* ARGSUSED5 */  /* Only Win32 uses gameMode parameter. */
-GLUTwindow *
-__glutCreateWindow(GLUTwindow * parent,
-  int x, int y, int width, int height, int gameMode)
-{
-  GLUTwindow *window;
-  XSetWindowAttributes wa;
-  unsigned long attribMask;
-  int winnum;
-  int i;
-  void *fbc;
-
-#if defined(_WIN32)
-  WNDCLASS wc;
-  int style;
-
-  if (!GetClassInfo(GetModuleHandle(NULL), "GLUT", &wc)) {
-    __glutOpenWin32Connection(NULL);
-  }
-#else
-  if (!__glutDisplay) {
-    __glutOpenXConnection(NULL);
-  }
-#endif
-  if (__glutGameModeWindow) {
-    __glutFatalError("cannot create windows in game mode.");
-  }
-  winnum = getUnusedWindowSlot();
-  window = (GLUTwindow *) malloc(sizeof(GLUTwindow));
-  if (!window) {
-    __glutFatalError("out of memory.");
-  }
-  window->num = winnum;
-
-#if !defined(_WIN32)
-  window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
-    &window->visAlloced, &fbc);
-  if (!window->vis) {
-    __glutFatalError(
-      "visual with necessary capabilities not found.");
-  }
-  __glutSetupColormap(window->vis, &window->colormap, &window->cmap);
-#endif
-  window->eventMask = StructureNotifyMask | ExposureMask;
-
-  attribMask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
-  wa.background_pixmap = None;
-  wa.border_pixel = 0;
-  wa.colormap = window->cmap;
-  wa.event_mask = window->eventMask;
-  if (parent) {
-    if (parent->eventMask & GLUT_HACK_STOP_PROPAGATE_MASK)
-      wa.event_mask |= GLUT_HACK_STOP_PROPAGATE_MASK;
-    attribMask |= CWDontPropagate;
-    wa.do_not_propagate_mask = parent->eventMask & GLUT_DONT_PROPAGATE_FILTER_MASK;
-  } else {
-    wa.do_not_propagate_mask = 0;
-  }
-
-  /* Stash width and height before Win32's __glutAdjustCoords
-     possibly overwrites the values. */
-  window->width = width;
-  window->height = height;
-  window->forceReshape = True;
-  window->ignoreKeyRepeat = False;
-
-#if defined(_WIN32)
-  __glutAdjustCoords(parent ? parent->win : NULL,
-    &x, &y, &width, &height);
-  if (parent) {
-    style = WS_CHILD;
-  } else {
-    if (gameMode) {
-      /* Game mode window should be a WS_POPUP window to
-         ensure that the taskbar is hidden by it.  A standard
-         WS_OVERLAPPEDWINDOW does not hide the task bar. */
-      style = WS_POPUP | WS_MAXIMIZE;
-    } else {
-      /* A standard toplevel window with borders and such. */
-      style = WS_OVERLAPPEDWINDOW;
-    }
-  }
-  window->win = CreateWindow("GLUT", "GLUT",
-    WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style,
-    x, y, width, height, parent ? parent->win : __glutRoot,
-    NULL, GetModuleHandle(NULL), 0);
-  window->hdc = GetDC(window->win);
-  /* Must set the XHDC for fake glXChooseVisual & fake
-     glXCreateContext & fake XAllocColorCells. */
-  XHDC = window->hdc;
-  window->vis = __glutDetermineWindowVisual(&window->treatAsSingle,
-    &window->visAlloced, &fbc);
-  if (!window->vis) {
-    __glutFatalError(
-      "pixel format with necessary capabilities not found.");
-  }
-  if (!SetPixelFormat(window->hdc,
-      ChoosePixelFormat(window->hdc, window->vis),
-      window->vis)) {
-    __glutFatalError("SetPixelFormat failed during window create.");
-  }
-  __glutSetupColormap(window->vis, &window->colormap, &window->cmap);
-  /* Make sure subwindows get a windowStatus callback. */
-  if (parent) {
-    PostMessage(parent->win, WM_ACTIVATE, 0, 0);
-  }
-  window->renderDc = window->hdc;
-#else
-  window->win = XCreateWindow(__glutDisplay,
-    parent == NULL ? __glutRoot : parent->win,
-    x, y, width, height, 0,
-    window->vis->depth, InputOutput, window->vis->visual,
-    attribMask, &wa);
-#endif
-  window->renderWin = window->win;
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-  if (fbc) {
-    window->ctx = __glut_glXCreateContextWithConfigSGIX(__glutDisplay, fbc,
-      GLX_RGBA_TYPE_SGIX, None, __glutTryDirect);
-  } else
-#endif
-  {
-    window->ctx = glXCreateContext(__glutDisplay, window->vis,
-      None, __glutTryDirect);
-  }
-  if (!window->ctx) {
-    __glutFatalError(
-      "failed to create OpenGL rendering context.");
-  }
-  window->renderCtx = window->ctx;
-#if !defined(_WIN32)
-  window->isDirect = glXIsDirect(__glutDisplay, window->ctx);
-  if (__glutForceDirect) {
-    if (!window->isDirect)
-      __glutFatalError("direct rendering not possible.");
-  }
-#endif
-
-  window->parent = parent;
-  if (parent) {
-    window->siblings = parent->children;
-    parent->children = window;
-  } else {
-    window->siblings = NULL;
-  }
-  window->overlay = NULL;
-  window->children = NULL;
-  window->display = __glutDefaultDisplay;
-  window->reshape = __glutDefaultReshape;
-  window->mouse = NULL;
-  window->motion = NULL;
-  window->passive = NULL;
-  window->entry = NULL;
-  window->keyboard = NULL;
-  window->keyboardUp = NULL;
-  window->windowStatus = NULL;
-  window->visibility = NULL;
-  window->special = NULL;
-  window->specialUp = NULL;
-  window->buttonBox = NULL;
-  window->dials = NULL;
-  window->spaceMotion = NULL;
-  window->spaceRotate = NULL;
-  window->spaceButton = NULL;
-  window->tabletMotion = NULL;
-  window->tabletButton = NULL;
-#ifdef _WIN32
-  window->joystick = NULL;
-  window->joyPollInterval = 0;
-#endif
-  window->tabletPos[0] = -1;
-  window->tabletPos[1] = -1;
-  window->shownState = 0;
-  window->visState = -1;  /* not VisibilityUnobscured,
-                             VisibilityPartiallyObscured, or
-                             VisibilityFullyObscured */
-  window->entryState = -1;  /* not EnterNotify or LeaveNotify */
-
-  window->desiredConfMask = 0;
-  window->buttonUses = 0;
-  window->cursor = GLUT_CURSOR_INHERIT;
-
-  /* Setup window to be mapped when glutMainLoop starts. */
-  window->workMask = GLUT_MAP_WORK;
-#ifdef _WIN32
-  if (gameMode) {
-    /* When mapping a game mode window, just show
-       the window.  We have already created the game
-       mode window with a maximize flag at creation
-       time.  Doing a ShowWindow(window->win, SW_SHOWNORMAL)
-       would be wrong for a game mode window since it
-       would unmaximize the window. */
-    window->desiredMapState = GameModeState;
-  } else {
-    window->desiredMapState = NormalState;
-  }
-#else
-  window->desiredMapState = NormalState;
-#endif
-  window->prevWorkWin = __glutWindowWorkList;
-  __glutWindowWorkList = window;
-
-  /* Initially, no menus attached. */
-  for (i = 0; i < GLUT_MAX_MENUS; i++) {
-    window->menu[i] = 0;
-  }
-
-  /* Add this new window to the window list. */
-  __glutWindowList[winnum] = window;
-
-  /* Make the new window the current window. */
-  __glutSetWindow(window);
-
-  __glutDetermineMesaSwapHackSupport();
-
-  if (window->treatAsSingle) {
-    /* We do this because either the window really is single
-       buffered (in which case this is redundant, but harmless,
-       because this is the initial single-buffered context
-       state); or we are treating a double buffered window as a
-       single-buffered window because the system does not appear
-       to export any suitable single- buffered visuals (in which
-       the following are necessary). */
-    glDrawBuffer(GL_FRONT);
-    glReadBuffer(GL_FRONT);
-  }
-  return window;
-}
-
-/* CENTRY */
-int GLUTAPIENTRY
-glutCreateWindow(const char *title)
-{
-  static int firstWindow = 1;
-  GLUTwindow *window;
-#if !defined(_WIN32)
-  XWMHints *wmHints;
-#endif
-  Window win;
-  XTextProperty textprop;
-
-  if (__glutGameModeWindow) {
-    __glutFatalError("cannot create windows in game mode.");
-  }
-  window = __glutCreateWindow(NULL,
-    __glutSizeHints.x, __glutSizeHints.y,
-    __glutInitWidth, __glutInitHeight,
-    /* not game mode */ 0);
-  win = window->win;
-  /* Setup ICCCM properties. */
-  textprop.value = (unsigned char *) title;
-  textprop.encoding = XA_STRING;
-  textprop.format = 8;
-  textprop.nitems = strlen(title);
-#if defined(_WIN32)
-  SetWindowText(win, title);
-  if (__glutIconic) {
-    window->desiredMapState = IconicState;
-  }
-#else
-  wmHints = XAllocWMHints();
-  wmHints->initial_state =
-    __glutIconic ? IconicState : NormalState;
-  wmHints->flags = StateHint;
-  XSetWMProperties(__glutDisplay, win, &textprop, &textprop,
-  /* Only put WM_COMMAND property on first window. */
-    firstWindow ? __glutArgv : NULL,
-    firstWindow ? __glutArgc : 0,
-    &__glutSizeHints, wmHints, NULL);
-  XFree(wmHints);
-  XSetWMProtocols(__glutDisplay, win, &__glutWMDeleteWindow, 1);
-#endif
-  firstWindow = 0;
-  return window->num + 1;
-}
-
-#ifdef _WIN32
-int GLUTAPIENTRY
-__glutCreateWindowWithExit(const char *title, void (__cdecl *exitfunc)(int))
-{
-  __glutExitFunc = exitfunc;
-  return glutCreateWindow(title);
-}
-#endif
-
-int GLUTAPIENTRY
-glutCreateSubWindow(int win, int x, int y, int width, int height)
-{
-  GLUTwindow *window;
-
-  window = __glutCreateWindow(__glutWindowList[win - 1],
-    x, y, width, height, /* not game mode */ 0);
-#if !defined(_WIN32)
-  {
-    GLUTwindow *toplevel;
-
-    toplevel = __glutToplevelOf(window);
-    if (toplevel->cmap != window->cmap) {
-      __glutPutOnWorkList(toplevel, GLUT_COLORMAP_WORK);
-    }
-  }
-#endif
-  return window->num + 1;
-}
-/* ENDCENTRY */
-
-void
-__glutDestroyWindow(GLUTwindow * window,
-  GLUTwindow * initialWindow)
-{
-  GLUTwindow **prev, *cur, *parent, *siblings;
-
-  /* Recursively destroy any children. */
-  cur = window->children;
-  while (cur) {
-    siblings = cur->siblings;
-    __glutDestroyWindow(cur, initialWindow);
-    cur = siblings;
-  }
-  /* Remove from parent's children list (only necessary for
-     non-initial windows and subwindows!). */
-  parent = window->parent;
-  if (parent && parent == initialWindow->parent) {
-    prev = &parent->children;
-    cur = parent->children;
-    while (cur) {
-      if (cur == window) {
-        *prev = cur->siblings;
-        break;
-      }
-      prev = &(cur->siblings);
-      cur = cur->siblings;
-    }
-  }
-  /* Unbind if bound to this window. */
-  if (window == __glutCurrentWindow) {
-    UNMAKE_CURRENT();
-    __glutCurrentWindow = NULL;
-  }
-  /* Begin tearing down window itself. */
-  if (window->overlay) {
-    __glutFreeOverlayFunc(window->overlay);
-  }
-  XDestroyWindow(__glutDisplay, window->win);
-  glXDestroyContext(__glutDisplay, window->ctx);
-  if (window->colormap) {
-    /* Only color index windows have colormap data structure. */
-    __glutFreeColormap(window->colormap);
-  }
-  /* NULLing the __glutWindowList helps detect is a window
-     instance has been destroyed, given a window number. */
-  __glutWindowList[window->num] = NULL;
-
-  /* Cleanup data structures that might contain window. */
-  cleanWindowWorkList(window);
-#if !defined(_WIN32)
-  cleanStaleWindowList(window);
-#endif
-  /* Remove window from the "get window cache" if it is there. */
-  if (__glutWindowCache == window)
-    __glutWindowCache = NULL;
-
-  if (window->visAlloced) {
-    /* Only free XVisualInfo* gotten from glXChooseVisual. */
-    XFree(window->vis);
-  }
-
-  if (window == __glutGameModeWindow) {
-    /* Destroying the game mode window should implicitly
-       have GLUT leave game mode. */
-    __glutCloseDownGameMode();
-  }
-
-  free(window);
-}
-
-/* CENTRY */
-void GLUTAPIENTRY
-glutDestroyWindow(int win)
-{
-  GLUTwindow *window = __glutWindowList[win - 1];
-
-  if (__glutMappedMenu && __glutMenuWindow == window) {
-    __glutFatalUsage("destroying menu window not allowed while menus in use");
-  }
-#if !defined(_WIN32)
-  /* If not a toplevel window... */
-  if (window->parent) {
-    /* Destroying subwindows may change colormap requirements;
-       recalculate toplevel window's WM_COLORMAP_WINDOWS
-       property. */
-    __glutPutOnWorkList(__glutToplevelOf(window->parent),
-      GLUT_COLORMAP_WORK);
-  }
-#endif
-  __glutDestroyWindow(window, window);
-  XFlush(__glutDisplay);
-}
-/* ENDCENTRY */
-
-void
-__glutChangeWindowEventMask(long eventMask, Bool add)
-{
-  if (add) {
-    /* Add eventMask to window's event mask. */
-    if ((__glutCurrentWindow->eventMask & eventMask) !=
-      eventMask) {
-      __glutCurrentWindow->eventMask |= eventMask;
-      __glutPutOnWorkList(__glutCurrentWindow,
-        GLUT_EVENT_MASK_WORK);
-    }
-  } else {
-    /* Remove eventMask from window's event mask. */
-    if (__glutCurrentWindow->eventMask & eventMask) {
-      __glutCurrentWindow->eventMask &= ~eventMask;
-      __glutPutOnWorkList(__glutCurrentWindow,
-        GLUT_EVENT_MASK_WORK);
-    }
-  }
-}
-
-void GLUTAPIENTRY
-glutDisplayFunc(GLUTdisplayCB displayFunc)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  if (!displayFunc)
-    __glutFatalError("NULL display callback not allowed in GLUT 3.0; update your code.");
-  __glutCurrentWindow->display = displayFunc;
-}
-
-void GLUTAPIENTRY
-glutMouseFunc(GLUTmouseCB mouseFunc)
-{
-  if (__glutCurrentWindow->mouse) {
-    if (!mouseFunc) {
-      /* Previous mouseFunc being disabled. */
-      __glutCurrentWindow->buttonUses--;
-      __glutChangeWindowEventMask(
-        ButtonPressMask | ButtonReleaseMask,
-        __glutCurrentWindow->buttonUses > 0);
-    }
-  } else {
-    if (mouseFunc) {
-      /* Previously no mouseFunc, new one being installed. */
-      __glutCurrentWindow->buttonUses++;
-      __glutChangeWindowEventMask(
-        ButtonPressMask | ButtonReleaseMask, True);
-    }
-  }
-  __glutCurrentWindow->mouse = mouseFunc;
-}
-
-void GLUTAPIENTRY
-glutMotionFunc(GLUTmotionCB motionFunc)
-{
-  /* Hack.  Some window managers (4Dwm by default) will mask
-     motion events if the client is not selecting for button
-     press and release events. So we select for press and
-     release events too (being careful to use reference
-     counting).  */
-  if (__glutCurrentWindow->motion) {
-    if (!motionFunc) {
-      /* previous mouseFunc being disabled */
-      __glutCurrentWindow->buttonUses--;
-      __glutChangeWindowEventMask(
-        ButtonPressMask | ButtonReleaseMask,
-        __glutCurrentWindow->buttonUses > 0);
-    }
-  } else {
-    if (motionFunc) {
-      /* Previously no mouseFunc, new one being installed. */
-      __glutCurrentWindow->buttonUses++;
-      __glutChangeWindowEventMask(
-        ButtonPressMask | ButtonReleaseMask, True);
-    }
-  }
-  /* Real work of selecting for passive mouse motion.  */
-  __glutChangeWindowEventMask(
-    Button1MotionMask | Button2MotionMask | Button3MotionMask,
-    motionFunc != NULL);
-  __glutCurrentWindow->motion = motionFunc;
-}
-
-void GLUTAPIENTRY
-glutPassiveMotionFunc(GLUTpassiveCB passiveMotionFunc)
-{
-  __glutChangeWindowEventMask(PointerMotionMask,
-    passiveMotionFunc != NULL);
-
-  /* Passive motion also requires watching enters and leaves so
-     that a fake passive motion event can be generated on an
-     enter. */
-  __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask,
-    __glutCurrentWindow->entry != NULL || passiveMotionFunc != NULL);
-
-  __glutCurrentWindow->passive = passiveMotionFunc;
-}
-
-void GLUTAPIENTRY
-glutEntryFunc(GLUTentryCB entryFunc)
-{
-  __glutChangeWindowEventMask(EnterWindowMask | LeaveWindowMask,
-    entryFunc != NULL || __glutCurrentWindow->passive);
-  __glutCurrentWindow->entry = entryFunc;
-  if (!entryFunc) {
-    __glutCurrentWindow->entryState = -1;
-  }
-}
-
-void GLUTAPIENTRY
-glutWindowStatusFunc(GLUTwindowStatusCB windowStatusFunc)
-{
-  __glutChangeWindowEventMask(VisibilityChangeMask,
-    windowStatusFunc != NULL);
-  __glutCurrentWindow->windowStatus = windowStatusFunc;
-  if (!windowStatusFunc) {
-    /* Make state invalid. */
-    __glutCurrentWindow->visState = -1;
-  }
-}
-
-static void GLUTCALLBACK
-visibilityHelper(int status)
-{
-  if (status == GLUT_HIDDEN || status == GLUT_FULLY_COVERED)
-    __glutCurrentWindow->visibility(GLUT_NOT_VISIBLE);
-  else
-    __glutCurrentWindow->visibility(GLUT_VISIBLE);
-}
-
-void GLUTAPIENTRY
-glutVisibilityFunc(GLUTvisibilityCB visibilityFunc)
-{
-  __glutCurrentWindow->visibility = visibilityFunc;
-  if (visibilityFunc)
-    glutWindowStatusFunc(visibilityHelper);
-  else
-    glutWindowStatusFunc(NULL);
-}
-
-void GLUTAPIENTRY
-glutReshapeFunc(GLUTreshapeCB reshapeFunc)
-{
-  if (reshapeFunc) {
-    __glutCurrentWindow->reshape = reshapeFunc;
-  } else {
-    __glutCurrentWindow->reshape = __glutDefaultReshape;
-  }
-}
diff --git a/src/glut/glx/glut_winmisc.c b/src/glut/glx/glut_winmisc.c
deleted file mode 100644
index 0fc4c805f20..00000000000
--- a/src/glut/glx/glut_winmisc.c
+++ /dev/null
@@ -1,124 +0,0 @@
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>  /* for XA_STRING atom */
-#endif
-
-#include "glutint.h"
-
-/* CENTRY */
-void GLUTAPIENTRY 
-glutSetWindowTitle(const char *title)
-{
-  XTextProperty textprop;
-
-  assert(!__glutCurrentWindow->parent);
-  IGNORE_IN_GAME_MODE();
-  textprop.value = (unsigned char *) title;
-  textprop.encoding = XA_STRING;
-  textprop.format = 8;
-  textprop.nitems = strlen(title);
-  XSetWMName(__glutDisplay,
-    __glutCurrentWindow->win, &textprop);
-  XFlush(__glutDisplay);
-}
-
-void GLUTAPIENTRY 
-glutSetIconTitle(const char *title)
-{
-  XTextProperty textprop;
-
-  assert(!__glutCurrentWindow->parent);
-  IGNORE_IN_GAME_MODE();
-  textprop.value = (unsigned char *) title;
-  textprop.encoding = XA_STRING;
-  textprop.format = 8;
-  textprop.nitems = strlen(title);
-  XSetWMIconName(__glutDisplay,
-    __glutCurrentWindow->win, &textprop);
-  XFlush(__glutDisplay);
-}
-
-void GLUTAPIENTRY 
-glutPositionWindow(int x, int y)
-{
-  IGNORE_IN_GAME_MODE();
-  __glutCurrentWindow->desiredX = x;
-  __glutCurrentWindow->desiredY = y;
-  __glutCurrentWindow->desiredConfMask |= CWX | CWY;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
-}
-
-void GLUTAPIENTRY 
-glutReshapeWindow(int w, int h)
-{
-  IGNORE_IN_GAME_MODE();
-  if (w <= 0 || h <= 0)
-    __glutWarning("glutReshapeWindow: non-positive width or height not allowed");
-
-  __glutCurrentWindow->desiredWidth = w;
-  __glutCurrentWindow->desiredHeight = h;
-  __glutCurrentWindow->desiredConfMask |= CWWidth | CWHeight;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
-}
-
-void GLUTAPIENTRY 
-glutPopWindow(void)
-{
-  IGNORE_IN_GAME_MODE();
-  __glutCurrentWindow->desiredStack = Above;
-  __glutCurrentWindow->desiredConfMask |= CWStackMode;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
-}
-
-void GLUTAPIENTRY 
-glutPushWindow(void)
-{
-  IGNORE_IN_GAME_MODE();
-  __glutCurrentWindow->desiredStack = Below;
-  __glutCurrentWindow->desiredConfMask |= CWStackMode;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_CONFIGURE_WORK);
-}
-
-void GLUTAPIENTRY 
-glutIconifyWindow(void)
-{
-  IGNORE_IN_GAME_MODE();
-  assert(!__glutCurrentWindow->parent);
-  __glutCurrentWindow->desiredMapState = IconicState;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
-}
-
-void GLUTAPIENTRY 
-glutShowWindow(void)
-{
-  IGNORE_IN_GAME_MODE();
-  __glutCurrentWindow->desiredMapState = NormalState;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
-}
-
-void GLUTAPIENTRY 
-glutHideWindow(void)
-{
-  IGNORE_IN_GAME_MODE();
-  __glutCurrentWindow->desiredMapState = WithdrawnState;
-  __glutPutOnWorkList(__glutCurrentWindow, GLUT_MAP_WORK);
-}
-
-/* ENDCENTRY */
diff --git a/src/glut/glx/glutbitmap.h b/src/glut/glx/glutbitmap.h
deleted file mode 100644
index 9584bb129da..00000000000
--- a/src/glut/glx/glutbitmap.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef __glutbitmap_h__
-#define __glutbitmap_h__
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
-
-/* 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. */
-
-#define GLUT_NO_LIB_PRAGMA  /* Avoid auto library linking when building
-                               the GLUT library itself. */
-#include <GL/glut.h>
-
-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 *GLUTbitmapFont;
-
-#endif /* __glutbitmap_h__ */
diff --git a/src/glut/glx/glutint.h b/src/glut/glx/glutint.h
deleted file mode 100644
index ba30af60f0a..00000000000
--- a/src/glut/glx/glutint.h
+++ /dev/null
@@ -1,798 +0,0 @@
-#ifndef __glutint_h__
-#define __glutint_h__
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
-
-/* 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. */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#if defined(__CYGWIN32__)
-#include <sys/time.h>
-#endif
-
-#define SUPPORT_FORTRAN  /* With GLUT 3.7, everyone supports Fortran. */
-
-#if defined(_WIN32)
-#include "glutwin32.h"
-#else
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#define GLX_GLXEXT_PROTOTYPES
-#include <GL/glx.h>
-#endif
-
-#ifndef GLUT_BUILDING_LIB
-#define GLUT_BUILDING_LIB  /* Building the GLUT library itself. */
-#endif
-
-#include <GL/glut.h>
-
-#ifndef _WIN32
-/* added by BrianP: */
-#ifndef APIENTRY
-#define APIENTRY GLAPIENTRY
-#endif
-#define __cdecl GLAPIENTRY
-#define CDECL GLAPIENTRY
-#endif
-
-/* GLUT_BUILDING_LIB is used by <GL/glut.h> to 1) not #pragma link
-   with the GLUT library, and 2) avoid the Win32 atexit hack. */
-
-#ifdef SUPPORT_FORTRAN
-#include <GL/glutf90.h>
-#endif
-
-#ifdef __vms
-#if ( __VMS_VER < 70000000 )
-#define OLD_VMS
-struct timeval6 {
-  __int64 val;
-};
-extern int sys$gettim(struct timeval6 *);
-#else
-#include <time.h>
-#endif
-#else
-#include <sys/types.h>
-#if !defined(_WIN32) || defined(__CYGWIN32__)
-#include <sys/time.h>
-#else
-#include <winsock.h>
-#endif
-#endif
-#if defined(__vms) && ( __VMS_VER < 70000000 )
-
-/* For VMS6.2 or lower :
-   One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
-   0.0001 milliseconds. This means that there are 0.01
-   ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
-   ticks/second. */
-
-#define TICKS_PER_MILLISECOND 10000
-#define TICKS_PER_SECOND      10000000
-
-#define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
-
-#define ADD_TIME(dest, src1, src2) { \
-  (dest).val = (src1).val + (src2).val; \
-}
-
-#define TIMEDELTA(dest, src1, src2) { \
-  (dest).val = (src1).val - (src2).val; \
-}
-
-#define IS_AFTER(t1, t2) ((t2).val > (t1).val)
-
-#define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
-
-#else
-#if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but
-                                       wants 2 args. */
-#define GETTIMEOFDAY(_x) gettimeofday(_x)
-#else
-#define GETTIMEOFDAY(_x) gettimeofday(_x, NULL)
-#endif
-#define ADD_TIME(dest, src1, src2) { \
-  if(((dest).tv_usec = \
-    (src1).tv_usec + (src2).tv_usec) >= 1000000) { \
-    (dest).tv_usec -= 1000000; \
-    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \
-  } else { \
-    (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \
-    if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
-      (dest).tv_sec --;(dest).tv_usec += 1000000; \
-    } \
-  } \
-}
-#define TIMEDELTA(dest, src1, src2) { \
-  if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \
-    (dest).tv_usec += 1000000; \
-    (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \
-  } else { \
-     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \
-  } \
-}
-#define IS_AFTER(t1, t2) \
-  (((t2).tv_sec > (t1).tv_sec) || \
-  (((t2).tv_sec == (t1).tv_sec) && \
-  ((t2).tv_usec > (t1).tv_usec)))
-#define IS_AT_OR_AFTER(t1, t2) \
-  (((t2).tv_sec > (t1).tv_sec) || \
-  (((t2).tv_sec == (t1).tv_sec) && \
-  ((t2).tv_usec >= (t1).tv_usec)))
-#endif
-
-#define IGNORE_IN_GAME_MODE() \
-  { if (__glutGameModeWindow) return; }
-
-#define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
-#define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
-#define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
-#define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
-#define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
-#define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
-#define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
-#define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
-#define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
-#define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
-#define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
-#define GLUT_MAP_WORK               (1 << 0)
-#define GLUT_EVENT_MASK_WORK        (1 << 1)
-#define GLUT_REDISPLAY_WORK         (1 << 2)
-#define GLUT_CONFIGURE_WORK         (1 << 3)
-#define GLUT_COLORMAP_WORK          (1 << 4)
-#define GLUT_DEVICE_MASK_WORK	    (1 << 5)
-#define GLUT_FINISH_WORK	    (1 << 6)
-#define GLUT_DEBUG_WORK		    (1 << 7)
-#define GLUT_DUMMY_WORK		    (1 << 8)
-#define GLUT_FULL_SCREEN_WORK       (1 << 9)
-#define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
-#define GLUT_REPAIR_WORK            (1 << 11)
-#define GLUT_OVERLAY_REPAIR_WORK    (1 << 12)
-
-/* Frame buffer capability macros and types. */
-#define RGBA                    0
-#define BUFFER_SIZE             1
-#define DOUBLEBUFFER            2
-#define STEREO                  3
-#define AUX_BUFFERS             4
-#define RED_SIZE                5  /* Used as mask bit for
-                                      "color selected". */
-#define GREEN_SIZE              6
-#define BLUE_SIZE               7
-#define ALPHA_SIZE              8
-#define DEPTH_SIZE              9
-#define STENCIL_SIZE            10
-#define ACCUM_RED_SIZE          11  /* Used as mask bit for
-                                       "acc selected". */
-#define ACCUM_GREEN_SIZE        12
-#define ACCUM_BLUE_SIZE         13
-#define ACCUM_ALPHA_SIZE        14
-#define LEVEL                   15
-
-#define NUM_GLXCAPS             (LEVEL + 1)
-
-#define XVISUAL                 (NUM_GLXCAPS + 0)
-#define TRANSPARENT             (NUM_GLXCAPS + 1)
-#define SAMPLES                 (NUM_GLXCAPS + 2)
-#define XSTATICGRAY             (NUM_GLXCAPS + 3)  /* Used as
-                                                      mask bit
-                                                      for "any
-                                                      visual type
-                                                      selected". */
-#define XGRAYSCALE              (NUM_GLXCAPS + 4)
-#define XSTATICCOLOR            (NUM_GLXCAPS + 5)
-#define XPSEUDOCOLOR            (NUM_GLXCAPS + 6)
-#define XTRUECOLOR              (NUM_GLXCAPS + 7)
-#define XDIRECTCOLOR            (NUM_GLXCAPS + 8)
-#define SLOW                    (NUM_GLXCAPS + 9)
-#define CONFORMANT              (NUM_GLXCAPS + 10)
-
-#define NUM_CAPS                (NUM_GLXCAPS + 11)
-
-/* Frame buffer capablities that don't have a corresponding
-   FrameBufferMode entry.  These get used as mask bits. */
-#define NUM                     (NUM_CAPS + 0)
-#define RGBA_MODE               (NUM_CAPS + 1)
-#define CI_MODE                 (NUM_CAPS + 2)
-#define LUMINANCE_MODE		(NUM_CAPS + 3)
-
-#define NONE			0
-#define EQ			1
-#define NEQ			2
-#define LTE			3
-#define GTE			4
-#define GT			5
-#define LT			6
-#define MIN			7
-
-typedef struct _Criterion {
-  int capability;
-  int comparison;
-  int value;
-} Criterion;
-
-typedef struct _FrameBufferMode {
-  XVisualInfo *vi;
-#if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
-
-  /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable
-     (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows
-     the visual's fbconfig is OpenGL-capable.  The reason for this is typically
-     an RGBA luminance fbconfig such as 16-bit StaticGray that could
-     not be advertised as a GLX visual since StaticGray visuals are
-     required (by the GLX specification) to be color index.  The
-     SGIX_fbconfig allows StaticGray visuals to instead advertised as
-     fbconfigs that can provide RGBA luminance support. */
-
-  GLXFBConfigSGIX fbc;
-#endif
-  int valid;
-  int cap[NUM_CAPS];
-} FrameBufferMode;
-
-/* DisplayMode capability macros for game mode. */
-#define DM_WIDTH        0  /* "width" */
-#define DM_HEIGHT       1  /* "height" */
-#define DM_PIXEL_DEPTH  2  /* "bpp" (bits per pixel) */
-#define DM_HERTZ        3  /* "hertz" */
-#define DM_NUM          4  /* "num" */
-
-#define NUM_DM_CAPS     (DM_NUM+1)
-
-typedef struct _DisplayMode {
-#ifdef _WIN32
-  DEVMODE devmode;
-#else
-  /* XXX The X Window System does not have a standard
-     mechanism for display setting changes.  On SGI
-     systems, GLUT could use the XSGIvc (SGI X video
-     control extension).  Perhaps this can be done in
-     a future release of GLUT. */
-#endif
-  int valid;
-  int cap[NUM_DM_CAPS];
-} DisplayMode;
-
-/* GLUT  function types */
-typedef void (GLUTCALLBACK *GLUTdisplayCB) (void);
-typedef void (GLUTCALLBACK *GLUTreshapeCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTkeyboardCB) (unsigned char, int, int);
-typedef void (GLUTCALLBACK *GLUTmouseCB) (int, int, int, int);
-typedef void (GLUTCALLBACK *GLUTmotionCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTpassiveCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTentryCB) (int);
-typedef void (GLUTCALLBACK *GLUTvisibilityCB) (int);
-typedef void (GLUTCALLBACK *GLUTwindowStatusCB) (int);
-typedef void (GLUTCALLBACK *GLUTidleCB) (void);
-typedef void (GLUTCALLBACK *GLUTtimerCB) (int);
-typedef void (GLUTCALLBACK *GLUTmenuStateCB) (int);  /* DEPRICATED. */
-typedef void (GLUTCALLBACK *GLUTmenuStatusCB) (int, int, int);
-typedef void (GLUTCALLBACK *GLUTselectCB) (int);
-typedef void (GLUTCALLBACK *GLUTspecialCB) (int, int, int);
-typedef void (GLUTCALLBACK *GLUTspaceMotionCB) (int, int, int);
-typedef void (GLUTCALLBACK *GLUTspaceRotateCB) (int, int, int);
-typedef void (GLUTCALLBACK *GLUTspaceButtonCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTdialsCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTbuttonBoxCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTtabletMotionCB) (int, int);
-typedef void (GLUTCALLBACK *GLUTtabletButtonCB) (int, int, int, int);
-typedef void (GLUTCALLBACK *GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
-
-typedef struct _GLUTcolorcell GLUTcolorcell;
-struct _GLUTcolorcell {
-  /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
-  GLfloat component[3];
-};
-
-typedef struct _GLUTcolormap GLUTcolormap;
-struct _GLUTcolormap {
-  Visual *visual;       /* visual of the colormap */
-  Colormap cmap;        /* X colormap ID */
-  int refcnt;           /* number of windows using colormap */
-  int size;             /* number of cells in colormap */
-  int transparent;      /* transparent pixel, or -1 if opaque */
-  GLUTcolorcell *cells; /* array of cells */
-  GLUTcolormap *next;   /* next colormap in list */
-};
-
-typedef struct _GLUTwindow GLUTwindow;
-typedef struct _GLUToverlay GLUToverlay;
-struct _GLUTwindow {
-  int num;              /* Small integer window id (0-based). */
-
-  /* Window system related state. */
-#if defined(_WIN32)
-  int pf;               /* Pixel format. */
-  HDC hdc;              /* Window's Win32 device context. */
-#endif
-  Window win;           /* X window for GLUT window */
-  GLXContext ctx;       /* OpenGL context GLUT glut window */
-  XVisualInfo *vis;     /* visual for window */
-  Bool visAlloced;      /* if vis needs deallocate on destroy */
-  Colormap cmap;        /* RGB colormap for window; None if CI */
-  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
-  GLUToverlay *overlay; /* overlay; NULL if no overlay */
-#if defined(_WIN32)
-  HDC renderDc;         /* Win32's device context for rendering. */
-#endif
-  Window renderWin;     /* X window for rendering (might be
-                           overlay) */
-  GLXContext renderCtx; /* OpenGL context for rendering (might
-                           be overlay) */
-  /* GLUT settable or visible window state. */
-  int width;            /* window width in pixels */
-  int height;           /* window height in pixels */
-  int cursor;           /* cursor name */
-  int visState;         /* visibility state (-1 is unknown) */
-  int shownState;       /* if window mapped */
-  int entryState;       /* entry state (-1 is unknown) */
-#define GLUT_MAX_MENUS              3
-
-  int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
-  /* Window relationship state. */
-  GLUTwindow *parent;   /* parent window */
-  GLUTwindow *children; /* list of children */
-  GLUTwindow *siblings; /* list of siblings */
-  /* Misc. non-API visible (hidden) state. */
-  Bool treatAsSingle;   /* treat this window as single-buffered
-                           (it might be "fake" though) */
-  Bool forceReshape;    /* force reshape before display */
-#if !defined(_WIN32)
-  Bool isDirect;        /* if direct context (X11 only) */
-#endif
-  Bool usedSwapBuffers; /* if swap buffers used last display */
-  long eventMask;       /* mask of X events selected for */
-  int buttonUses;       /* number of button uses, ref cnt */
-  int tabletPos[2];     /* tablet position (-1 is invalid) */
-  /* Work list related state. */
-  unsigned int workMask;  /* mask of window work to be done */
-  GLUTwindow *prevWorkWin;  /* link list of windows to work on */
-  Bool desiredMapState; /* how to mapped window if on map work
-                           list */
-  Bool ignoreKeyRepeat;  /* if window ignores autorepeat */
-  int desiredConfMask;  /* mask of desired window configuration
-                         */
-  int desiredX;         /* desired X location */
-  int desiredY;         /* desired Y location */
-  int desiredWidth;     /* desired window width */
-  int desiredHeight;    /* desired window height */
-  int desiredStack;     /* desired window stack */
-  /* Per-window callbacks. */
-  GLUTdisplayCB display;  /* redraw */
-  GLUTreshapeCB reshape;  /* resize (width,height) */
-  GLUTmouseCB mouse;    /* mouse (button,state,x,y) */
-  GLUTmotionCB motion;  /* motion (x,y) */
-  GLUTpassiveCB passive;  /* passive motion (x,y) */
-  GLUTentryCB entry;    /* window entry/exit (state) */
-  GLUTkeyboardCB keyboard;  /* keyboard (ASCII,x,y) */
-  GLUTkeyboardCB keyboardUp;  /* keyboard up (ASCII,x,y) */
-  GLUTwindowStatusCB windowStatus;  /* window status */
-  GLUTvisibilityCB visibility;  /* visibility */
-  GLUTspecialCB special;  /* special key */
-  GLUTspecialCB specialUp;  /* special up key */
-  GLUTbuttonBoxCB buttonBox;  /* button box */
-  GLUTdialsCB dials;    /* dials */
-  GLUTspaceMotionCB spaceMotion;  /* Spaceball motion */
-  GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate */
-  GLUTspaceButtonCB spaceButton;  /* Spaceball button */
-  GLUTtabletMotionCB tabletMotion;  /* tablet motion */
-  GLUTtabletButtonCB tabletButton;  /* tablet button */
-#ifdef _WIN32
-  GLUTjoystickCB joystick;  /* joystick */
-  int joyPollInterval; /* joystick polling interval */
-#endif
-#ifdef SUPPORT_FORTRAN
-  GLUTdisplayFCB fdisplay;  /* Fortran display  */
-  GLUTreshapeFCB freshape;  /* Fortran reshape  */
-  GLUTmouseFCB fmouse;  /* Fortran mouse  */
-  GLUTmotionFCB fmotion;  /* Fortran motion  */
-  GLUTpassiveFCB fpassive;  /* Fortran passive  */
-  GLUTentryFCB fentry;  /* Fortran entry  */
-  GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard  */
-  GLUTkeyboardFCB fkeyboardUp;  /* Fortran keyboard up */
-  GLUTwindowStatusFCB fwindowStatus;  /* Fortran window status */
-  GLUTvisibilityFCB fvisibility;  /* Fortran visibility */
-  GLUTspecialFCB fspecial;  /* special key */
-  GLUTspecialFCB fspecialUp;  /* special key up */
-  GLUTbuttonBoxFCB fbuttonBox;  /* button box */
-  GLUTdialsFCB fdials;  /* dials */
-  GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion */
-  GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate */
-  GLUTspaceButtonFCB fspaceButton;  /* Spaceball button */
-  GLUTtabletMotionFCB ftabletMotion;  /* tablet motion */
-  GLUTtabletButtonFCB ftabletButton;  /* tablet button */
-#ifdef _WIN32
-  GLUTjoystickFCB fjoystick;  /* joystick */
-#endif
-#endif
-};
-
-struct _GLUToverlay {
-#if defined(_WIN32)
-  int pf;
-  HDC hdc;
-#endif
-  Window win;
-  GLXContext ctx;
-  XVisualInfo *vis;     /* visual for window */
-  Bool visAlloced;      /* if vis needs deallocate on destroy */
-  Colormap cmap;        /* RGB colormap for window; None if CI */
-  GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
-  int shownState;       /* if overlay window mapped */
-  Bool treatAsSingle;   /* treat as single-buffered */
-#if !defined(_WIN32)
-  Bool isDirect;        /* if direct context */
-#endif
-  int transparentPixel; /* transparent pixel value */
-  GLUTdisplayCB display;  /* redraw  */
-#ifdef SUPPORT_FORTRAN
-  GLUTdisplayFCB fdisplay;  /* redraw  */
-#endif
-};
-
-typedef struct _GLUTstale GLUTstale;
-struct _GLUTstale {
-  GLUTwindow *window;
-  Window win;
-  GLUTstale *next;
-};
-
-extern GLUTstale *__glutStaleWindowList;
-
-#define GLUT_OVERLAY_EVENT_FILTER_MASK \
-  (ExposureMask | \
-  StructureNotifyMask | \
-  EnterWindowMask | \
-  LeaveWindowMask)
-#define GLUT_DONT_PROPAGATE_FILTER_MASK \
-  (ButtonReleaseMask | \
-  ButtonPressMask | \
-  KeyPressMask | \
-  KeyReleaseMask | \
-  PointerMotionMask | \
-  Button1MotionMask | \
-  Button2MotionMask | \
-  Button3MotionMask)
-#define GLUT_HACK_STOP_PROPAGATE_MASK \
-  (KeyPressMask | \
-  KeyReleaseMask)
-
-typedef struct _GLUTmenu GLUTmenu;
-typedef struct _GLUTmenuItem GLUTmenuItem;
-struct _GLUTmenu {
-  int id;               /* small integer menu id (0-based) */
-  Window win;           /* X window for the menu */
-  GLUTselectCB select;  /*  function of menu */
-  GLUTmenuItem *list;   /* list of menu entries */
-  int num;              /* number of entries */
-#if !defined(_WIN32)
-  Bool managed;         /* are the InputOnly windows size
-                           validated? */
-  Bool searched;	/* help detect menu loops */
-  int pixheight;        /* height of menu in pixels */
-  int pixwidth;         /* width of menu in pixels */
-#endif
-  int submenus;         /* number of submenu entries */
-  GLUTmenuItem *highlighted;  /* pointer to highlighted menu
-                                 entry, NULL not highlighted */
-  GLUTmenu *cascade;    /* currently cascading this menu  */
-  GLUTmenuItem *anchor; /* currently anchored to this entry */
-  int x;                /* current x origin relative to the
-                           root window */
-  int y;                /* current y origin relative to the
-                           root window */
-#ifdef SUPPORT_FORTRAN
-  GLUTselectFCB fselect;  /*  function of menu */
-#endif
-};
-
-struct _GLUTmenuItem {
-  Window win;           /* InputOnly X window for entry */
-  GLUTmenu *menu;       /* menu entry belongs to */
-  Bool isTrigger;       /* is a submenu trigger? */
-  int value;            /* value to return for selecting this
-                           entry; doubles as submenu id
-                           (0-base) if submenu trigger */
-#if defined(_WIN32)
-  UINT unique;          /* unique menu item id (Win32 only) */
-#endif
-  char *label;          /* __glutStrdup'ed label string */
-  int len;              /* length of label string */
-  int pixwidth;         /* width of X window in pixels */
-  GLUTmenuItem *next;   /* next menu entry on list for menu */
-};
-
-typedef struct _GLUTtimer GLUTtimer;
-struct _GLUTtimer {
-  GLUTtimer *next;      /* list of timers */
-#ifdef OLD_VMS
-   struct timeval6 timeout;  /* time to be called */
-#else
-   struct timeval timeout;  /* time to be called */
-#endif
-   GLUTtimerCB func;     /* timer  (value) */
-  int value;            /*  return value */
-#ifdef SUPPORT_FORTRAN
-  GLUTtimerFCB ffunc;   /* Fortran timer  */
-#endif
-};
-
-typedef struct _GLUTeventParser GLUTeventParser;
-struct _GLUTeventParser {
-  int (*func) (XEvent *);
-  GLUTeventParser *next;
-};
-
-/* Declarations to implement glutFullScreen support with
-   mwm/4Dwm. */
-
-/* The following X property format is defined in Motif 1.1's
-   Xm/MwmUtils.h, but GLUT should not depend on that header
-   file. Note: Motif 1.2 expanded this structure with
-   uninteresting fields (to GLUT) so just stick with the
-   smaller Motif 1.1 structure. */
-typedef struct {
-#define MWM_HINTS_DECORATIONS   2
-  long flags;
-  long functions;
-  long decorations;
-  long input_mode;
-} MotifWmHints;
-
-/* Make current and buffer swap macros. */
-#ifdef _WIN32
-#define MAKE_CURRENT_LAYER(window)                                    \
-  {                                                                   \
-    HGLRC currentContext = wglGetCurrentContext();                    \
-    HDC currentDc = wglGetCurrentDC();                                \
-                                                                      \
-    if (currentContext != window->renderCtx                           \
-      || currentDc != window->renderDc) {                             \
-      wglMakeCurrent(window->renderDc, window->renderCtx);            \
-    }                                                                 \
-  }
-#define MAKE_CURRENT_WINDOW(window)                                   \
-  {                                                                   \
-    HGLRC currentContext = wglGetCurrentContext();                    \
-    HDC currentDc = wglGetCurrentDC();                                \
-                                                                      \
-    if (currentContext != window->ctx || currentDc != window->hdc) {  \
-      wglMakeCurrent(window->hdc, window->ctx);                       \
-    }                                                                 \
-  }
-#define MAKE_CURRENT_OVERLAY(overlay) \
-  wglMakeCurrent(overlay->hdc, overlay->ctx)
-#define UNMAKE_CURRENT() \
-  wglMakeCurrent(NULL, NULL)
-#define SWAP_BUFFERS_WINDOW(window) \
-  SwapBuffers(window->hdc)
-#define SWAP_BUFFERS_LAYER(window) \
-  SwapBuffers(window->renderDc)
-#else
-#define MAKE_CURRENT_LAYER(window) \
-  glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx)
-#define MAKE_CURRENT_WINDOW(window) \
-  glXMakeCurrent(__glutDisplay, window->win, window->ctx)
-#define MAKE_CURRENT_OVERLAY(overlay) \
-  glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx)
-#define UNMAKE_CURRENT() \
-  glXMakeCurrent(__glutDisplay, None, NULL)
-#define SWAP_BUFFERS_WINDOW(window) \
-  glXSwapBuffers(__glutDisplay, window->win)
-#define SWAP_BUFFERS_LAYER(window) \
-  glXSwapBuffers(__glutDisplay, window->renderWin)
-#endif
-
-/* private variables from glut_event.c */
-extern GLUTwindow *__glutWindowWorkList;
-extern int __glutWindowDamaged;
-#ifdef SUPPORT_FORTRAN
-extern GLUTtimer *__glutTimerList;
-extern GLUTtimer *__glutNewTimer;
-#endif
-extern GLUTmenu *__glutMappedMenu;
-
-extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
-#if !defined(_WIN32)
-extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item,
-  int num, int type);
-extern void (*__glutFinishMenu)(Window win, int x, int y);
-extern void (*__glutPaintMenu)(GLUTmenu * menu);
-extern void (*__glutStartMenu)(GLUTmenu * menu,
-  GLUTwindow * window, int x, int y, int x_win, int y_win);
-extern GLUTmenu * (*__glutGetMenuByNum)(int menunum);
-extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu,
-  Window win, int *which);
-extern GLUTmenu * (*__glutGetMenu)(Window win);
-#endif
-
-/* private variables from glut_init.c */
-extern Atom __glutWMDeleteWindow;
-extern Display *__glutDisplay;
-extern unsigned int __glutDisplayMode;
-extern char *__glutDisplayString;
-extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
-  Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc);
-extern GLboolean __glutDebug;
-extern GLboolean __glutForceDirect;
-extern GLboolean __glutIconic;
-extern GLboolean __glutTryDirect;
-extern Window __glutRoot;
-extern XSizeHints __glutSizeHints;
-extern char **__glutArgv;
-extern char *__glutProgramName;
-extern int __glutArgc;
-extern int __glutConnectionFD;
-extern int __glutInitHeight;
-extern int __glutInitWidth;
-extern int __glutInitX;
-extern int __glutInitY;
-extern int __glutScreen;
-extern int __glutScreenHeight;
-extern int __glutScreenWidth;
-extern Atom __glutMotifHints;
-extern unsigned int __glutModifierMask;
-#ifdef _WIN32
-extern void (__cdecl *__glutExitFunc)(int retval);
-#endif
-extern char *__glutPPMFile;
-
-/* private variables from glut_menu.c */
-extern GLUTmenuItem *__glutItemSelected;
-extern GLUTmenu **__glutMenuList;
-extern void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
-extern void __glutMenuModificationError(void);
-extern void __glutSetMenuItem(GLUTmenuItem * item,
-  const char *label, int value, Bool isTrigger);
-
-/* private variables from glut_win.c */
-extern GLUTwindow **__glutWindowList;
-extern GLUTwindow *__glutCurrentWindow;
-extern GLUTwindow *__glutMenuWindow;
-extern GLUTmenu *__glutCurrentMenu;
-extern int __glutWindowListSize;
-extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
-extern void __glutFreeOverlay(GLUToverlay * overlay);
-extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle,
-  Bool * visAlloced, void **fbc);
-
-/* private variables from glut_ppm.c */
-extern void __glutWritePPMFile(void);
-
-/* private variables from glut_mesa.c */
-extern int __glutMesaSwapHackSupport;
-
-/* private variables from glut_gamemode.c */
-extern GLUTwindow *__glutGameModeWindow;
-
-/* private routines from glut_cindex.c */
-extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis);
-extern void __glutFreeColormap(GLUTcolormap *);
-
-/* private routines from glut_cmap.c */
-extern void __glutSetupColormap(
-  XVisualInfo * vi,
-  GLUTcolormap ** colormap,
-  Colormap * cmap);
-#if !defined(_WIN32)
-extern void __glutEstablishColormapsProperty(
-  GLUTwindow * window);
-extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
-#endif
-
-/* private routines from glut_cursor.c */
-extern void __glutSetCursor(GLUTwindow *window);
-
-/* private routines from glut_event.c */
-extern void __glutPutOnWorkList(GLUTwindow * window,
-  int work_mask);
-extern void __glutRegisterEventParser(GLUTeventParser * parser);
-extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
-extern void handleTimeouts(void);
-
-/* private routines from glut_init.c */
-#if !defined(_WIN32)
-extern void __glutOpenXConnection(char *display);
-#else
-extern void __glutOpenWin32Connection(char *display);
-#endif
-#ifdef OLD_VMS
-extern void __glutInitTime(struct timeval6 *beginning);
-#else
-extern void __glutInitTime(struct timeval *beginning);
-#endif
-
-/* private routines for glut_menu.c (or win32_menu.c) */
-#if defined(_WIN32)
-extern GLUTmenu *__glutGetMenu(Window win);
-extern GLUTmenu *__glutGetMenuByNum(int menunum);
-extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
-  Window win, int *which);
-extern void __glutStartMenu(GLUTmenu * menu,
-  GLUTwindow * window, int x, int y, int x_win, int y_win);
-extern void __glutFinishMenu(Window win, int x, int y);
-#endif
-extern void __glutSetMenu(GLUTmenu * menu);
-
-/* private routines from glut_util.c */
-extern char * __glutStrdup(const char *string);
-extern void __glutWarning(char *format,...);
-extern void __glutFatalError(char *format,...);
-extern void __glutFatalUsage(char *format,...);
-
-/* private routines from glut_win.c */
-extern GLUTwindow *__glutGetWindow(Window win);
-extern void __glutChangeWindowEventMask(long mask, Bool add);
-extern XVisualInfo *__glutDetermineVisual(
-  unsigned int mode,
-  Bool * fakeSingle,
-  XVisualInfo * (getVisualInfo) (unsigned int));
-extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
-extern void __glutSetWindow(GLUTwindow * window);
-extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
-  int callingConvention);
-extern void GLUTCALLBACK __glutDefaultReshape(int, int);
-extern GLUTwindow *__glutCreateWindow(
-  GLUTwindow * parent,
-  int x, int y, int width, int height, int gamemode);
-extern void __glutDestroyWindow(
-  GLUTwindow * window,
-  GLUTwindow * initialWindow);
-
-#if !defined(_WIN32)
-/* private routines from glut_glxext.c */
-extern int __glutIsSupportedByGLX(char *);
-extern int __glut_glXBindChannelToWindowSGIX(Display *dpy, int screen,
-                                             int channel, Window window);
-extern int __glut_glXChannelRectSGIX(Display *dpy, int screen, int channel,
-                                     int x, int y, int w, int h);
-extern int __glut_glXQueryChannelRectSGIX(Display *dpy, int screen,
-                                          int channel, int *x, int *y,
-                                          int *w, int *h);
-extern int __glut_glXQueryChannelDeltasSGIX(Display *dpy, int screen,
-                                            int channel, int *dx, int *dy,
-                                            int *dw, int *dh);
-extern int __glut_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel,
-                                         GLenum synctype);
-extern GLXContext __glut_glXCreateContextWithConfigSGIX(Display *dpy,
-                                                        GLXFBConfigSGIX config,
-                                                        int render_type,
-                                                        GLXContext share_list,
-                                                        Bool direct);
-extern int __glut_glXGetFBConfigAttribSGIX(Display *dpy,
-                                           GLXFBConfigSGIX config,
-                                           int attribute,
-                                           int *value);
-extern GLXFBConfigSGIX __glut_glXGetFBConfigFromVisualSGIX(Display *dpy,
-                                                           XVisualInfo *vis);
-#endif
-
-/* private routines from glut_input.c */
-extern void  __glutUpdateInputDeviceMask(GLUTwindow * window);
-
-/* private routines from glut_mesa.c */
-extern void __glutDetermineMesaSwapHackSupport(void);
-
-/* private routines from glut_gameglut.c */
-extern void __glutCloseDownGameMode(void);
-
-/* private variables from glut_swap.c (BrianP) */
-extern GLint __glutFPS;
-extern GLint __glutSwapCount;
-extern GLint __glutSwapTime;
-
-#if defined(_WIN32)
-/* private routines from win32_*.c */
-extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l);
-extern HDC XHDC;
-#endif
-
-
-#endif /* __glutint_h__ */
diff --git a/src/glut/glx/glutstroke.h b/src/glut/glx/glutstroke.h
deleted file mode 100644
index d6eac7aa516..00000000000
--- a/src/glut/glx/glutstroke.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef __glutstroke_h__
-#define __glutstroke_h__
-
-/* 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. */
-
-#define GLUT_NO_LIB_PRAGMA  /* Avoid auto library linking when building
-                               the GLUT library itself. */
-#include <GL/glut.h>
-
-#if defined(_MSC_VER)
-#pragma warning (disable:4244)  /* disable bogus conversion warnings */
-#pragma warning (disable:4305)  /* VC++ 5.0 version of above warning. */
-#endif
-
-typedef struct {
-  float x;
-  float y;
-} CoordRec, *CoordPtr;
-
-typedef struct {
-  int num_coords;
-  const CoordRec *coord;
-} StrokeRec, *StrokePtr;
-
-typedef struct {
-  int num_strokes;
-  const StrokeRec *stroke;
-  float center;
-  float right;
-} StrokeCharRec, *StrokeCharPtr;
-
-typedef struct {
-  const char *name;
-  int num_chars;
-  const StrokeCharRec *ch;
-  float top;
-  float bottom;
-} StrokeFontRec, *StrokeFontPtr;
-
-typedef void *GLUTstrokeFont;
-
-#endif /* __glutstroke_h__ */
diff --git a/src/glut/glx/glutwin32.h b/src/glut/glx/glutwin32.h
deleted file mode 100644
index 01db99fad6d..00000000000
--- a/src/glut/glx/glutwin32.h
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifndef __glutwin32_h__
-#define __glutwin32_h__
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-#include "win32_x11.h"
-#include "win32_glx.h"
-
-/* We have to undef some things because Microsoft likes to pollute the
-   global namespace. */
-#undef TRANSPARENT
-
-/* Win32 "equivalent" cursors - eventually, the X glyphs should be
-   converted to Win32 cursors -- then they will look the same */
-#define XC_arrow               IDC_ARROW
-#define XC_top_left_arrow      IDC_ARROW
-#define XC_hand1               IDC_SIZEALL
-#define XC_pirate              IDC_NO
-#define XC_question_arrow      IDC_HELP
-#define XC_exchange            IDC_NO
-#define XC_spraycan            IDC_SIZEALL
-#define XC_watch               IDC_WAIT
-#define XC_xterm               IDC_IBEAM
-#define XC_crosshair           IDC_CROSS
-#define XC_sb_v_double_arrow   IDC_SIZENS
-#define XC_sb_h_double_arrow   IDC_SIZEWE
-#define XC_top_side            IDC_UPARROW
-#define XC_bottom_side         IDC_SIZENS
-#define XC_left_side           IDC_SIZEWE
-#define XC_right_side          IDC_SIZEWE
-#define XC_top_left_corner     IDC_SIZENWSE
-#define XC_top_right_corner    IDC_SIZENESW
-#define XC_bottom_right_corner IDC_SIZENWSE
-#define XC_bottom_left_corner  IDC_SIZENESW
-
-#define XA_STRING 0
-
-/* Private routines from win32_util.c */
-#ifndef __CYGWIN32__
-struct timeval;
-extern int gettimeofday(struct timeval* tp, void* tzp);
-#endif
-extern void *__glutFont(void *font);
-extern int __glutGetTransparentPixel(Display *dpy, XVisualInfo *vinfo);
-extern void __glutAdjustCoords(Window parent, int *x, int *y, int *width, int *height);
-
-
-/* Cygwin B20.1 misses the following definitions */
-#ifdef __CYGWIN32__
-
-/* from winuser.h */
-#define CDS_FULLSCREEN 4
-
-/* from mmsystem.h */
-#define WINMMAPI __declspec(dllimport)
-typedef UINT MMRESULT;
-
-#define MM_JOY1MOVE 0x3A0
-#define MM_JOY1ZMOVE 0x3A2
-#define MM_JOY1BUTTONDOWN 0x3B5
-#define MM_JOY1BUTTONUP 0x3B7
-
-#define JOYERR_NOERROR 0
-#define JOYERR_PARMS 165
-
-#define JOY_RETURNALL 0x000000ffl
-
-#define JOYSTICKID1 0
-
-typedef struct joyinfoex_tag {
-    DWORD dwSize;                /* size of structure */
-    DWORD dwFlags;               /* flags to indicate what to return */
-    DWORD dwXpos;                /* x position */
-    DWORD dwYpos;                /* y position */
-    DWORD dwZpos;                /* z position */
-    DWORD dwRpos;                /* rudder/4th axis position */
-    DWORD dwUpos;                /* 5th axis position */
-    DWORD dwVpos;                /* 6th axis position */
-    DWORD dwButtons;             /* button states */
-    DWORD dwButtonNumber;        /* current button number pressed */
-    DWORD dwPOV;                 /* point of view state */
-    DWORD dwReserved1;           /* reserved for communication between winmm & driver */
-    DWORD dwReserved2;           /* reserved for future expansion */
-} JOYINFOEX, *PJOYINFOEX, /* NEAR */ *NPJOYINFOEX, /* FAR */ *LPJOYINFOEX;
-
-WINMMAPI MMRESULT WINAPI joyGetPosEx( UINT uJoyID, LPJOYINFOEX pji);
-WINMMAPI MMRESULT WINAPI joyReleaseCapture( UINT uJoyID);
-WINMMAPI MMRESULT WINAPI joySetCapture( HWND hwnd, UINT uJoyID, UINT uPeriod, BOOL fChanged);
-WINMMAPI MMRESULT WINAPI joySetThreshold( UINT uJoyID, UINT uThreshold);
-
-#endif
-
-#endif /* __glutwin32_h__ */
diff --git a/src/glut/glx/layerutil.c b/src/glut/glx/layerutil.c
deleted file mode 100644
index 36d43e59f0a..00000000000
--- a/src/glut/glx/layerutil.c
+++ /dev/null
@@ -1,203 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1993, 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. */
-
-/* Based on XLayerUtil.c: Revision: 1.5 */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "layerutil.h"
-
-/* SGI optimization introduced in IRIX 6.3 to avoid X server
-   round trips for interning common X atoms. */
-#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
-#include <X11/SGIFastAtom.h>
-#else
-#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
-#endif
-
-static Bool layersRead = False;
-static OverlayInfo **overlayInfoPerScreen;
-static unsigned long *numOverlaysPerScreen;
-
-static void
-findServerOverlayVisualsInfo(Display * dpy)
-{
-  static Atom overlayVisualsAtom;
-  Atom actualType;
-  Status status;
-  unsigned long sizeData, bytesLeft;
-  Window root;
-  int actualFormat, numScreens, i;
-
-  if (layersRead == False) {
-    overlayVisualsAtom = XSGIFastInternAtom(dpy,
-      "SERVER_OVERLAY_VISUALS", SGI_XA_SERVER_OVERLAY_VISUALS, True);
-    if (overlayVisualsAtom != None) {
-      numScreens = ScreenCount(dpy);
-      overlayInfoPerScreen = (OverlayInfo **)
-        malloc(numScreens * sizeof(OverlayInfo *));
-      numOverlaysPerScreen = (unsigned long *)
-        malloc(numScreens * sizeof(unsigned long));
-      if (overlayInfoPerScreen != NULL &&
-        numOverlaysPerScreen != NULL) {
-        for (i = 0; i < numScreens; i++) {
-          root = RootWindow(dpy, i);
-          status = XGetWindowProperty(dpy, root,
-            overlayVisualsAtom, 0L, (long) 10000, False,
-            overlayVisualsAtom, &actualType, &actualFormat,
-            &sizeData, &bytesLeft,
-            (unsigned char **) &overlayInfoPerScreen[i]);
-          if (status != Success ||
-            actualType != overlayVisualsAtom ||
-            actualFormat != 32 || sizeData < 4)
-            numOverlaysPerScreen[i] = 0;
-          else
-            /* Four 32-bit quantities per
-               SERVER_OVERLAY_VISUALS entry. */
-            numOverlaysPerScreen[i] = sizeData / 4;
-        }
-        layersRead = True;
-      } else {
-        if (overlayInfoPerScreen != NULL)
-          free(overlayInfoPerScreen);
-        if (numOverlaysPerScreen != NULL)
-          free(numOverlaysPerScreen);
-      }
-    }
-  }
-}
-
-int
-__glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
-{
-  int i, screen = vinfo->screen;
-  OverlayInfo *overlayInfo;
-
-  findServerOverlayVisualsInfo(dpy);
-  if (layersRead) {
-    for (i = 0; i < numOverlaysPerScreen[screen]; i++) {
-      overlayInfo = &overlayInfoPerScreen[screen][i];
-      if (vinfo->visualid == overlayInfo->overlay_visual) {
-        if (overlayInfo->transparent_type == TransparentPixel) {
-          return (int) overlayInfo->value;
-        } else {
-          return -1;
-        }
-      }
-    }
-  }
-  return -1;
-}
-
-XLayerVisualInfo *
-__glutXGetLayerVisualInfo(Display * dpy, long lvinfo_mask,
-  XLayerVisualInfo * lvinfo_template, int *nitems_return)
-{
-  XVisualInfo *vinfo;
-  XLayerVisualInfo *layerInfo;
-  int numVisuals, count, i, j;
-
-  vinfo = XGetVisualInfo(dpy, lvinfo_mask & VisualAllMask,
-    &lvinfo_template->vinfo, nitems_return);
-  if (vinfo == NULL)
-    return NULL;
-  numVisuals = *nitems_return;
-  findServerOverlayVisualsInfo(dpy);
-  layerInfo = (XLayerVisualInfo *)
-    malloc(numVisuals * sizeof(XLayerVisualInfo));
-  if (layerInfo == NULL) {
-    XFree(vinfo);
-    return NULL;
-  }
-  count = 0;
-  for (i = 0; i < numVisuals; i++) {
-    XVisualInfo *pVinfo = &vinfo[i];
-    int screen = pVinfo->screen;
-    OverlayInfo *overlayInfo = NULL;
-
-    overlayInfo = NULL;
-    if (layersRead) {
-      for (j = 0; j < numOverlaysPerScreen[screen]; j++)
-        if (pVinfo->visualid ==
-          overlayInfoPerScreen[screen][j].overlay_visual) {
-          overlayInfo = &overlayInfoPerScreen[screen][j];
-          break;
-        }
-    }
-    if (lvinfo_mask & VisualLayerMask) {
-      if (overlayInfo == NULL) {
-        if (lvinfo_template->layer != 0)
-          continue;
-      } else if (lvinfo_template->layer != overlayInfo->layer)
-        continue;
-    }
-    if (lvinfo_mask & VisualTransparentType) {
-      if (overlayInfo == NULL) {
-        if (lvinfo_template->type != None)
-          continue;
-      } else if (lvinfo_template->type !=
-        overlayInfo->transparent_type)
-        continue;
-    }
-    if (lvinfo_mask & VisualTransparentValue) {
-      if (overlayInfo == NULL)
-        /* Non-overlay visuals have no sense of
-           TransparentValue. */
-        continue;
-      else if (lvinfo_template->value != overlayInfo->value)
-        continue;
-    }
-    layerInfo[count].vinfo = *pVinfo;
-    if (overlayInfo == NULL) {
-      layerInfo[count].layer = 0;
-      layerInfo[count].type = None;
-      layerInfo[count].value = 0;  /* meaningless */
-    } else {
-      layerInfo[count].layer = overlayInfo->layer;
-      layerInfo[count].type = overlayInfo->transparent_type;
-      layerInfo[count].value = overlayInfo->value;
-    }
-    count++;
-  }
-  XFree(vinfo);
-  *nitems_return = count;
-  if (count == 0) {
-    XFree(layerInfo);
-    return NULL;
-  } else
-    return layerInfo;
-}
-
-#if 0                   /* Unused by GLUT. */
-Status
-__glutXMatchLayerVisualInfo(Display * dpy, int screen,
-  int depth, int visualClass, int layer,
-  XLayerVisualInfo * lvinfo_return)
-{
-  XLayerVisualInfo *lvinfo;
-  XLayerVisualInfo lvinfoTemplate;
-  int nitems;
-
-  lvinfoTemplate.vinfo.screen = screen;
-  lvinfoTemplate.vinfo.depth = depth;
-#if defined(__cplusplus) || defined(c_plusplus)
-  lvinfoTemplate.vinfo.c_class = visualClass;
-#else
-  lvinfoTemplate.vinfo.class = visualClass;
-#endif
-  lvinfoTemplate.layer = layer;
-  lvinfo = __glutXGetLayerVisualInfo(dpy,
-    VisualScreenMask | VisualDepthMask |
-    VisualClassMask | VisualLayerMask,
-    &lvinfoTemplate, &nitems);
-  if (lvinfo != NULL && nitems > 0) {
-    *lvinfo_return = *lvinfo;
-    return 1;
-  } else
-    return 0;
-}
-#endif
diff --git a/src/glut/glx/layerutil.h b/src/glut/glx/layerutil.h
deleted file mode 100644
index 8f580afe3b7..00000000000
--- a/src/glut/glx/layerutil.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef __layerutil_h__
-#define __layerutil_h__
-
-/* Copyright (c) Mark J. Kilgard, 1993, 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. */
-
-/* Based on XLayerUtil.h: Revision: 1.3 */
-
-#ifdef __VMS
-#include <GL/vms_x_fix.h>
-#endif
-
-#if !defined(_WIN32)
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xmd.h>
-#endif /* !_WIN32 */
-
-/* Transparent type values */
-/* None                       0 */
-#define TransparentPixel      1
-#define TransparentMask       2
-
-/* layered visual info template flags */
-#define VisualLayerMask		0x200
-#define VisualTransparentType	0x400
-#define VisualTransparentValue	0x800
-#define VisualAllLayerMask	0xFFF
-
-/* layered visual info structure */
-typedef struct _XLayerVisualInfo {
-  XVisualInfo vinfo;
-  long layer;
-  long type;
-  unsigned long value;
-} XLayerVisualInfo;
-
-/* SERVER_OVERLAY_VISUALS property element */
-typedef struct _OverlayInfo {
-  /* Avoid 64-bit portability problems by being careful to use
-     longs due to the way XGetWindowProperty is specified. Note
-     that these parameters are passed as CARD32s over X
-     protocol. */
-  long overlay_visual;
-  long transparent_type;
-  long value;
-  long layer;
-} OverlayInfo;
-
-extern int __glutGetTransparentPixel(Display *, XVisualInfo *);
-extern XLayerVisualInfo *__glutXGetLayerVisualInfo(Display *,
-  long, XLayerVisualInfo *, int *);
-extern Status __glutXMatchLayerVisualInfo(Display *,
-  int, int, int, int, XLayerVisualInfo *);
-
-#endif /* __layerutil_h__ */
diff --git a/src/glut/glx/stroke.h b/src/glut/glx/stroke.h
deleted file mode 100644
index 602b2fae9f7..00000000000
--- a/src/glut/glx/stroke.h
+++ /dev/null
@@ -1,133 +0,0 @@
-
-/*****************************************************************
-Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
-
-                        All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its 
-documentation for any purpose and without fee is hereby granted, 
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in 
-supporting documentation, and that the names of Sun Microsystems,
-the X Consortium, and MIT not be used in advertising or publicity 
-pertaining to distribution of the software without specific, written 
-prior permission.  
-
-SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
-INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT 
-SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
-DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-
-#ifndef WFONT_INCLUDED
-#define WFONT_INCLUDED
-
-#define WFONT_MAGIC	0x813
-#define WFONT_MAGIC_PLUS 0x715
-#define WFONT_MAGIC_PEX 0x70686e74
-#define START_PROPS 0x100
-#define START_DISPATCH(_num_props)  (START_PROPS + 160 * _num_props)
-#define START_PATH(_num_ch_, _num_props)  (START_DISPATCH(_num_props) + sizeof(Dispatch) * _num_ch_)
-#define NUM_DISPATCH	128
-
-typedef struct {
-  unsigned short x;
-  unsigned short y;
-} Path_point2dpx;
-
-typedef struct {
-  float x;
-  float y;
-} Path_point2df;
-
-typedef struct {
-  int x;
-  int y;
-  int z;
-} Path_point3di;
-
-typedef struct {
-  float x;
-  float y;
-  float z;
-} Path_point3df;
-
-typedef struct {
-  float x;
-  float y;
-  float z;
-  float w;
-} Path_point4df;
-
-typedef union {
-  Path_point2dpx *pt2dpx;
-  Path_point2df *pt2df;
-  Path_point3di *pt3di;
-  Path_point3df *pt3df;
-  Path_point4df *pt4df;
-} Path_pt_ptr;
-
-typedef enum {
-  PATH_2DF,
-  PATH_2DPX,
-  PATH_3DF,
-  PATH_3DI,
-  PATH_4DF
-} Path_type;
-
-typedef struct {
-  int n_pts;                    /* number of points in the subpath */
-  Path_pt_ptr pts;              /* pointer to them */
-  int closed;                   /* true if the subpath is closed */
-  int dcmp_flag;                /* flag for pgon dcmp, pgon type 
-                                 * and dcmped triangle type */
-} Path_subpath;
-
-typedef struct {
-  Path_type type;               /* type of vertices in this path */
-  int n_subpaths;               /* number of subpaths */
-  int n_vertices;               /* total number of vertices */
-  Path_subpath *subpaths;       /* array of subpaths */
-} Path;
-
-typedef Path *Path_handle;
-
-typedef struct {
-  char propname[80];            /* font property name */
-  char propvalue[80];           /* font property value */
-} Property;
-
-typedef struct {
-  int magic;                    /* magic number */
-  char name[80];                /* name of this font */
-  float top,                    /* extreme values */
-    bottom, max_width;
-  int num_ch;                   /* no. of fonts in the set */
-  int num_props;                /* no. of font properties */
-  Property *properties;         /* array of properties */
-} Font_header;
-
-typedef struct {
-  float center,                 /* center of the character */
-    right;                      /* right edge */
-  long offset;                  /* offset in the file of the character
-                                 * * description */
-} Dispatch;
-
-typedef struct {
-  float center, right;
-  Path strokes;
-} Ch_font;
-
-typedef struct {
-  char name[80];
-  float top, bottom, max_width;
-  int num_ch;                   /* # characters in the font */
-  Ch_font **ch_data;
-} Phg_font;
-
-#endif /*WFONT_INCLUDED */
diff --git a/src/glut/glx/win32_glx.c b/src/glut/glx/win32_glx.c
deleted file mode 100644
index 3522e606ec8..00000000000
--- a/src/glut/glx/win32_glx.c
+++ /dev/null
@@ -1,256 +0,0 @@
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-#include <stdio.h>
-#include "glutint.h"
-#include "win32_glx.h"
-
-/* global current HDC */
-extern HDC XHDC;
-
-GLXContext
-glXCreateContext(Display * display, XVisualInfo * visinfo,
-  GLXContext share, Bool direct)
-{
-  /* KLUDGE: GLX really expects a display pointer to be passed
-     in as the first parameter, but Win32 needs an HDC instead,
-     so BE SURE that the global XHDC is set before calling this
-     routine. */
-  HGLRC context;
-
-  context = wglCreateContext(XHDC);
-
-#if 0
-  /* XXX GLUT doesn't support it now, so don't worry about display list
-     and texture object sharing. */
-  if (share) {
-    wglShareLists(share, context);
-  }
-#endif
-
-  /* Since direct rendering is implicit, the direct flag is
-     ignored. */
-
-  return context;
-}
-
-int
-glXGetConfig(Display * display, XVisualInfo * visual, int attrib, int *value)
-{
-  if (!visual)
-    return GLX_BAD_VISUAL;
-
-  switch (attrib) {
-  case GLX_USE_GL:
-    if (visual->dwFlags & (PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW)) {
-      /* XXX Brad's Matrix Millenium II has problems creating
-         color index windows in 24-bit mode (lead to GDI crash)
-         and 32-bit mode (lead to black window).  The cColorBits
-         filed of the PIXELFORMATDESCRIPTOR returned claims to
-         have 24 and 32 bits respectively of color indices. 2^24
-         and 2^32 are ridiculously huge writable colormaps.
-         Assume that if we get back a color index
-         PIXELFORMATDESCRIPTOR with 24 or more bits, the
-         PIXELFORMATDESCRIPTOR doesn't really work and skip it.
-         -mjk */
-      if (visual->iPixelType == PFD_TYPE_COLORINDEX
-        && visual->cColorBits >= 24) {
-        *value = 0;
-      } else {
-	*value = 1;
-      }
-    } else {
-      *value = 0;
-    }
-    break;
-  case GLX_BUFFER_SIZE:
-    /* KLUDGE: if we're RGBA, return the number of bits/pixel,
-       otherwise, return 8 (we guessed at 256 colors in CI
-       mode). */
-    if (visual->iPixelType == PFD_TYPE_RGBA)
-      *value = visual->cColorBits;
-    else
-      *value = 8;
-    break;
-  case GLX_LEVEL:
-    /* The bReserved flag of the pfd contains the
-       overlay/underlay info. */
-    *value = visual->bReserved;
-    break;
-  case GLX_RGBA:
-    *value = visual->iPixelType == PFD_TYPE_RGBA;
-    break;
-  case GLX_DOUBLEBUFFER:
-    *value = visual->dwFlags & PFD_DOUBLEBUFFER;
-    break;
-  case GLX_STEREO:
-    *value = visual->dwFlags & PFD_STEREO;
-    break;
-  case GLX_AUX_BUFFERS:
-    *value = visual->cAuxBuffers;
-    break;
-  case GLX_RED_SIZE:
-    *value = visual->cRedBits;
-    break;
-  case GLX_GREEN_SIZE:
-    *value = visual->cGreenBits;
-    break;
-  case GLX_BLUE_SIZE:
-    *value = visual->cBlueBits;
-    break;
-  case GLX_ALPHA_SIZE:
-    *value = visual->cAlphaBits;
-    break;
-  case GLX_DEPTH_SIZE:
-    *value = visual->cDepthBits;
-    break;
-  case GLX_STENCIL_SIZE:
-    *value = visual->cStencilBits;
-    break;
-  case GLX_ACCUM_RED_SIZE:
-    *value = visual->cAccumRedBits;
-    break;
-  case GLX_ACCUM_GREEN_SIZE:
-    *value = visual->cAccumGreenBits;
-    break;
-  case GLX_ACCUM_BLUE_SIZE:
-    *value = visual->cAccumBlueBits;
-    break;
-  case GLX_ACCUM_ALPHA_SIZE:
-    *value = visual->cAccumAlphaBits;
-    break;
-  default:
-    return GLX_BAD_ATTRIB;
-  }
-  return 0;
-}
-
-XVisualInfo *
-glXChooseVisual(Display * display, int screen, int *attribList)
-{
-  /* KLUDGE: since we need the HDC, MAKE SURE to set XHDC
-     before calling this routine. */
-
-  int *p = attribList;
-  int pf;
-  PIXELFORMATDESCRIPTOR pfd;
-  PIXELFORMATDESCRIPTOR *match = NULL;
-  int stereo = 0;
-
-  /* Avoid seg-faults. */
-  if (!p)
-    return NULL;
-
-  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
-  pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
-  pfd.nVersion = 1;
-
-  /* Defaults. */
-  pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
-  pfd.iPixelType = PFD_TYPE_COLORINDEX;
-  pfd.cColorBits = 32;
-  pfd.cDepthBits = 0;
-
-  while (*p) {
-    switch (*p) {
-    case GLX_USE_GL:
-      pfd.dwFlags |= PFD_SUPPORT_OPENGL;
-      break;
-    case GLX_BUFFER_SIZE:
-      pfd.cColorBits = *(++p);
-      break;
-    case GLX_LEVEL:
-      /* the bReserved flag of the pfd contains the
-         overlay/underlay info. */
-      pfd.bReserved = *(++p);
-      break;
-    case GLX_RGBA:
-      pfd.iPixelType = PFD_TYPE_RGBA;
-      break;
-    case GLX_DOUBLEBUFFER:
-      pfd.dwFlags |= PFD_DOUBLEBUFFER;
-      break;
-    case GLX_STEREO:
-      stereo = 1;
-      pfd.dwFlags |= PFD_STEREO;
-      break;
-    case GLX_AUX_BUFFERS:
-      pfd.cAuxBuffers = *(++p);
-      break;
-    case GLX_RED_SIZE:
-      pfd.cRedBits = 8; /* Try to get the maximum. */
-      ++p;
-      break;
-    case GLX_GREEN_SIZE:
-      pfd.cGreenBits = 8;
-      ++p;
-      break;
-    case GLX_BLUE_SIZE:
-      pfd.cBlueBits = 8;
-      ++p;
-      break;
-    case GLX_ALPHA_SIZE:
-      pfd.cAlphaBits = 8;
-      ++p;
-      break;
-    case GLX_DEPTH_SIZE:
-      pfd.cDepthBits = 32;
-      ++p;
-      break;
-    case GLX_STENCIL_SIZE:
-      pfd.cStencilBits = *(++p);
-      break;
-    case GLX_ACCUM_RED_SIZE:
-    case GLX_ACCUM_GREEN_SIZE:
-    case GLX_ACCUM_BLUE_SIZE:
-    case GLX_ACCUM_ALPHA_SIZE:
-      /* I believe that WGL only used the cAccumRedBits,
-	 cAccumBlueBits, cAccumGreenBits, and cAccumAlphaBits fields
-	 when returning info about the accumulation buffer precision.
-	 Only cAccumBits is used for requesting an accumulation
-	 buffer. */
-      pfd.cAccumBits = 1;
-      ++p;
-      break;
-    }
-    ++p;
-  }
-
-  /* Let Win32 choose one for us. */
-  pf = ChoosePixelFormat(XHDC, &pfd);
-  if (pf > 0) {
-    match = (PIXELFORMATDESCRIPTOR *) malloc(sizeof(PIXELFORMATDESCRIPTOR));
-    DescribePixelFormat(XHDC, pf, sizeof(PIXELFORMATDESCRIPTOR), match);
-
-    /* ChoosePixelFormat is dumb in that it will return a pixel
-       format that doesn't have stereo even if it was requested
-       so we need to make sure that if stereo was selected, we
-       got it. */
-    if (stereo) {
-      if (!(match->dwFlags & PFD_STEREO)) {
-        free(match);
-	return NULL;
-      }
-    }
-    /* XXX Brad's Matrix Millenium II has problems creating
-       color index windows in 24-bit mode (lead to GDI crash)
-       and 32-bit mode (lead to black window).  The cColorBits
-       filed of the PIXELFORMATDESCRIPTOR returned claims to
-       have 24 and 32 bits respectively of color indices. 2^24
-       and 2^32 are ridiculously huge writable colormaps.
-       Assume that if we get back a color index
-       PIXELFORMATDESCRIPTOR with 24 or more bits, the
-       PIXELFORMATDESCRIPTOR doesn't really work and skip it.
-       -mjk */
-    if (match->iPixelType == PFD_TYPE_COLORINDEX
-      && match->cColorBits >= 24) {
-      free(match);
-      return NULL;
-    }
-  }
-  return match;
-}
diff --git a/src/glut/glx/win32_glx.h b/src/glut/glx/win32_glx.h
deleted file mode 100644
index d3630e7a1e1..00000000000
--- a/src/glut/glx/win32_glx.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef __win32_glx_h__
-#define __win32_glx_h__
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-#include "win32_x11.h"
-
-/* Type definitions (conversions). */
-typedef HGLRC GLXContext;
-
-#define GLX_USE_GL              1       /* support GLX rendering */
-#define GLX_BUFFER_SIZE         2       /* depth of the color buffer */
-#define GLX_LEVEL               3       /* level in plane stacking */
-#define GLX_RGBA                4       /* true if RGBA mode */
-#define GLX_DOUBLEBUFFER        5       /* double buffering supported */
-#define GLX_STEREO              6       /* stereo buffering supported */
-#define GLX_AUX_BUFFERS         7       /* number of aux buffers */
-#define GLX_RED_SIZE            8       /* number of red component bits */
-#define GLX_GREEN_SIZE          9       /* number of green component bits */
-#define GLX_BLUE_SIZE           10      /* number of blue component bits */
-#define GLX_ALPHA_SIZE          11      /* number of alpha component bits */
-#define GLX_DEPTH_SIZE          12      /* number of depth bits */
-#define GLX_STENCIL_SIZE        13      /* number of stencil bits */
-#define GLX_ACCUM_RED_SIZE      14      /* number of red accum bits */
-#define GLX_ACCUM_GREEN_SIZE    15      /* number of green accum bits */
-#define GLX_ACCUM_BLUE_SIZE     16      /* number of blue accum bits */
-#define GLX_ACCUM_ALPHA_SIZE    17      /* number of alpha accum bits */
-
-#define GLX_BAD_ATTRIB  2
-#define GLX_BAD_VISUAL  4
-
-/* Functions emulated by macros. */
-
-#define glXDestroyContext(display, context) \
-  wglDeleteContext(context)
-
-/* Function prototypes. */
-
-extern GLXContext glXCreateContext(
-  Display* display,
-  XVisualInfo* visinfo,
-  GLXContext share,
-  Bool direct);
-extern int glXGetConfig(
-  Display* display,
-  XVisualInfo* visual,
-  int attrib,
-  int* value);
-extern XVisualInfo* glXChooseVisual(
-  Display* display,
-  int screen,
-  int* attribList);
-
-#endif /* __win32_glx_h__ */
diff --git a/src/glut/glx/win32_menu.c b/src/glut/glx/win32_menu.c
deleted file mode 100644
index 12feb41b608..00000000000
--- a/src/glut/glx/win32_menu.c
+++ /dev/null
@@ -1,529 +0,0 @@
-
-/* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-
-/* This file completely re-implements glut_menu.c and glut_menu2.c
-   for Win32.  Note that neither glut_menu.c nor glut_menu2.c are
-   compiled into Win32 GLUT. */
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-#include <assert.h>
-
-#include "glutint.h"
-
-void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
-GLUTmenuItem *__glutItemSelected;
-unsigned __glutMenuButton;
-
-static GLUTmenu **menuList = NULL;
-static int menuListSize = 0;
-static UINT uniqueMenuHandler = 1;
-
-/* DEPRICATED, use glutMenuStatusFunc instead. */
-void GLUTAPIENTRY
-glutMenuStateFunc(GLUTmenuStateCB menuStateFunc)
-{
-  __glutMenuStatusFunc = (GLUTmenuStatusCB) menuStateFunc;
-}
-
-void GLUTAPIENTRY
-glutMenuStatusFunc(GLUTmenuStatusCB menuStatusFunc)
-{
-  __glutMenuStatusFunc = menuStatusFunc;
-}
-
-void
-__glutSetMenu(GLUTmenu * menu)
-{
-  __glutCurrentMenu = menu;
-}
-
-static void
-unmapMenu(GLUTmenu * menu)
-{
-  if (menu->cascade) {
-    unmapMenu(menu->cascade);
-    menu->cascade = NULL;
-  }
-  menu->anchor = NULL;
-  menu->highlighted = NULL;
-}
-
-void
-__glutFinishMenu(Window win, int x, int y)
-{
-
-  unmapMenu(__glutMappedMenu);
-
-  /* XXX Put in a GdiFlush just in case.  Probably unnecessary. -mjk  */
-  GdiFlush();
-
-  if (__glutMenuStatusFunc) {
-    __glutSetWindow(__glutMenuWindow);
-    __glutSetMenu(__glutMappedMenu);
-
-    /* Setting __glutMappedMenu to NULL permits operations that
-       change menus or destroy the menu window again. */
-    __glutMappedMenu = NULL;
-
-    __glutMenuStatusFunc(GLUT_MENU_NOT_IN_USE, x, y);
-  }
-  /* Setting __glutMappedMenu to NULL permits operations that
-     change menus or destroy the menu window again. */
-  __glutMappedMenu = NULL;
-
-  /* If an item is selected and it is not a submenu trigger,
-     generate menu callback. */
-  if (__glutItemSelected && !__glutItemSelected->isTrigger) {
-    __glutSetWindow(__glutMenuWindow);
-    /* When menu callback is triggered, current menu should be
-       set to the callback menu. */
-    __glutSetMenu(__glutItemSelected->menu);
-    __glutItemSelected->menu->select(__glutItemSelected->value);
-  }
-  __glutMenuWindow = NULL;
-}
-
-static void
-mapMenu(GLUTmenu * menu, int x, int y)
-{
-  TrackPopupMenu((HMENU) menu->win, TPM_LEFTALIGN |
-    ((__glutMenuButton == TPM_RIGHTBUTTON) ? TPM_RIGHTBUTTON : TPM_LEFTBUTTON),
-    x, y, 0, __glutCurrentWindow->win, NULL);
-}
-
-void
-__glutStartMenu(GLUTmenu * menu, GLUTwindow * window,
-		int x, int y, int x_win, int y_win)
-{
-  assert(__glutMappedMenu == NULL);
-  __glutMappedMenu = menu;
-  __glutMenuWindow = window;
-  __glutItemSelected = NULL;
-  if (__glutMenuStatusFunc) {
-    __glutSetMenu(menu);
-    __glutSetWindow(window);
-    __glutMenuStatusFunc(GLUT_MENU_IN_USE, x_win, y_win);
-  }
-  mapMenu(menu, x, y);
-}
-
-GLUTmenuItem *
-__glutGetUniqueMenuItem(GLUTmenu * menu, UINT unique)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  i = menu->num;
-  item = menu->list;
-  while (item) {
-    if (item->unique == unique) {
-      return item;
-    }
-    if (item->isTrigger) {
-      GLUTmenuItem *subitem;
-      subitem = __glutGetUniqueMenuItem(menuList[item->value], unique);
-      if (subitem) {
-        return subitem;
-      }
-    }
-    i--;
-    item = item->next;
-  }
-  return NULL;
-}
-
-GLUTmenuItem *
-__glutGetMenuItem(GLUTmenu * menu, Window win, int *which)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  i = menu->num;
-  item = menu->list;
-  while (item) {
-    if (item->win == win) {
-      *which = i;
-      return item;
-    }
-    if (item->isTrigger) {
-      GLUTmenuItem *subitem;
-
-      subitem = __glutGetMenuItem(menuList[item->value],
-        win, which);
-      if (subitem) {
-        return subitem;
-      }
-    }
-    i--;
-    item = item->next;
-  }
-  return NULL;
-}
-
-GLUTmenu *
-__glutGetMenu(Window win)
-{
-  GLUTmenu *menu;
-
-  menu = __glutMappedMenu;
-  while (menu) {
-    if (win == menu->win) {
-      return menu;
-    }
-    menu = menu->cascade;
-  }
-  return NULL;
-}
-
-GLUTmenu *
-__glutGetMenuByNum(int menunum)
-{
-  if (menunum < 1 || menunum > menuListSize) {
-    return NULL;
-  }
-  return menuList[menunum - 1];
-}
-
-static int
-getUnusedMenuSlot(void)
-{
-  int i;
-
-  /* Look for allocated, unused slot. */
-  for (i = 0; i < menuListSize; i++) {
-    if (!menuList[i]) {
-      return i;
-    }
-  }
-  /* Allocate a new slot. */
-  menuListSize++;
-  if (menuList) {
-    menuList = (GLUTmenu **)
-      realloc(menuList, menuListSize * sizeof(GLUTmenu *));
-  } else {
-    /* XXX Some realloc's do not correctly perform a malloc
-       when asked to perform a realloc on a NULL pointer,
-       though the ANSI C library spec requires this. */
-    menuList = (GLUTmenu **) malloc(sizeof(GLUTmenu *));
-  }
-  if (!menuList) {
-    __glutFatalError("out of memory.");
-  }
-  menuList[menuListSize - 1] = NULL;
-  return menuListSize - 1;
-}
-
-static void
-menuModificationError(void)
-{
-  /* XXX Remove the warning after GLUT 3.0. */
-  __glutWarning("The following is a new check for GLUT 3.0; update your code.");
-  __glutFatalError("menu manipulation not allowed while menus in use.");
-}
-
-int GLUTAPIENTRY
-glutCreateMenu(GLUTselectCB selectFunc)
-{
-  GLUTmenu *menu;
-  int menuid;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  menuid = getUnusedMenuSlot();
-  menu = (GLUTmenu *) malloc(sizeof(GLUTmenu));
-  if (!menu) {
-    __glutFatalError("out of memory.");
-  }
-  menu->id = menuid;
-  menu->num = 0;
-  menu->submenus = 0;
-  menu->select = selectFunc;
-  menu->list = NULL;
-  menu->cascade = NULL;
-  menu->highlighted = NULL;
-  menu->anchor = NULL;
-  menu->win = (HWND) CreatePopupMenu();
-  menuList[menuid] = menu;
-  __glutSetMenu(menu);
-  return menuid + 1;
-}
-
-int GLUTAPIENTRY
-__glutCreateMenuWithExit(GLUTselectCB selectFunc, void (__cdecl *exitfunc)(int))
-{
-  __glutExitFunc = exitfunc;
-  return glutCreateMenu(selectFunc);
-}
-
-void GLUTAPIENTRY
-glutDestroyMenu(int menunum)
-{
-  GLUTmenu *menu = __glutGetMenuByNum(menunum);
-  GLUTmenuItem *item, *next;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  assert(menu->id == menunum - 1);
-  DestroyMenu( (HMENU) menu->win);
-  menuList[menunum - 1] = NULL;
-  /* free all menu entries */
-  item = menu->list;
-  while (item) {
-    assert(item->menu == menu);
-    next = item->next;
-    free(item->label);
-    free(item);
-    item = next;
-  }
-  if (__glutCurrentMenu == menu) {
-    __glutCurrentMenu = NULL;
-  }
-  free(menu);
-}
-
-int GLUTAPIENTRY
-glutGetMenu(void)
-{
-  if (__glutCurrentMenu) {
-    return __glutCurrentMenu->id + 1;
-  } else {
-    return 0;
-  }
-}
-
-void GLUTAPIENTRY
-glutSetMenu(int menuid)
-{
-  GLUTmenu *menu;
-
-  if (menuid < 1 || menuid > menuListSize) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  menu = menuList[menuid - 1];
-  if (!menu) {
-    __glutWarning("glutSetMenu attempted on bogus menu.");
-    return;
-  }
-  __glutSetMenu(menu);
-}
-
-static void
-setMenuItem(GLUTmenuItem * item, const char *label,
-	    int value, Bool isTrigger)
-{
-  GLUTmenu *menu;
-
-  menu = item->menu;
-  item->label = __glutStrdup(label);
-  if (!item->label) {
-    __glutFatalError("out of memory.");
-  }
-  item->isTrigger = isTrigger;
-  item->len = (int) strlen(label);
-  item->value = value;
-  item->unique = uniqueMenuHandler++;
-  if (isTrigger) {
-    AppendMenu((HMENU) menu->win, MF_POPUP, (UINT)item->win, label);
-  } else {
-    AppendMenu((HMENU) menu->win, MF_STRING, item->unique, label);
-  }
-}
-
-void GLUTAPIENTRY
-glutAddMenuEntry(const char *label, int value)
-{
-  GLUTmenuItem *entry;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!entry) {
-    __glutFatalError("out of memory.");
-  }
-  entry->menu = __glutCurrentMenu;
-  setMenuItem(entry, label, value, FALSE);
-  __glutCurrentMenu->num++;
-  entry->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = entry;
-}
-
-void GLUTAPIENTRY
-glutAddSubMenu(const char *label, int menu)
-{
-  GLUTmenuItem *submenu;
-  GLUTmenu     *popupmenu;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
-  if (!submenu) {
-    __glutFatalError("out of memory.");
-  }
-  __glutCurrentMenu->submenus++;
-  submenu->menu = __glutCurrentMenu;
-  popupmenu = __glutGetMenuByNum(menu);
-  if (popupmenu) {
-    submenu->win = popupmenu->win;
-  }
-  setMenuItem(submenu, label, /* base 0 */ menu - 1, TRUE);
-  __glutCurrentMenu->num++;
-  submenu->next = __glutCurrentMenu->list;
-  __glutCurrentMenu->list = submenu;
-}
-
-void GLUTAPIENTRY
-glutChangeToMenuEntry(int num, const char *label, int value)
-{
-  GLUTmenuItem *item;
-  int i;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  i = __glutCurrentMenu->num;
-  item = __glutCurrentMenu->list;
-  while (item) {
-    if (i == num) {
-      if (item->isTrigger) {
-        /* If changing a submenu trigger to a menu entry, we
-           need to account for submenus.  */
-        item->menu->submenus--;
-	/* Nuke the Win32 menu. */
-	DestroyMenu((HMENU) item->win);
-      }
-      free(item->label);
-
-      item->label = strdup(label);
-      if (!item->label)
-	__glutFatalError("out of memory");
-      item->isTrigger = FALSE;
-      item->len = (int) strlen(label);
-      item->value = value;
-      item->unique = uniqueMenuHandler++;
-      ModifyMenu((HMENU) __glutCurrentMenu->win, (UINT) i - 1,
-        MF_BYPOSITION | MFT_STRING, item->unique, label);
-
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY
-glutChangeToSubMenu(int num, const char *label, int menu)
-{
-  GLUTmenu *popupmenu;
-  GLUTmenuItem *item;
-  int i;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  i = __glutCurrentMenu->num;
-  item = __glutCurrentMenu->list;
-  while (item) {
-    if (i == num) {
-      if (!item->isTrigger) {
-        /* If changing a menu entry to as submenu trigger, we
-           need to account for submenus.  */
-        item->menu->submenus++;
-	item->win = (HWND) CreatePopupMenu();
-      }
-      free(item->label);
-      
-      item->label = strdup(label);
-      if (!item->label)
-	__glutFatalError("out of memory");
-      item->isTrigger = TRUE;
-      item->len = (int) strlen(label);
-      item->value = menu - 1;
-      item->unique = uniqueMenuHandler++;
-      popupmenu = __glutGetMenuByNum(menu);
-      if (popupmenu)
-	item->win = popupmenu->win;
-      ModifyMenu((HMENU) __glutCurrentMenu->win, (UINT) i - 1,
-        MF_BYPOSITION | MF_POPUP, (UINT) item->win, label);
-      return;
-    }
-    i--;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY
-glutRemoveMenuItem(int num)
-{
-  GLUTmenuItem *item, **prev;
-  int i;
-
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  i = __glutCurrentMenu->num;
-  prev = &__glutCurrentMenu->list;
-  item = __glutCurrentMenu->list;
-  while (item) {
-    if (i == num) {
-      /* Found the menu item in list to remove. */
-      __glutCurrentMenu->num--;
-
-      /* Patch up menu's item list. */
-      *prev = item->next;
-
-      RemoveMenu((HMENU) __glutCurrentMenu->win, (UINT) i - 1, MF_BYPOSITION);
-
-      free(item->label);
-      free(item);
-      return;
-    }
-    i--;
-    prev = &item->next;
-    item = item->next;
-  }
-  __glutWarning("Current menu has no %d item.", num);
-}
-
-void GLUTAPIENTRY
-glutAttachMenu(int button)
-{
-  if (__glutCurrentWindow == __glutGameModeWindow) {
-    __glutWarning("cannot attach menus in game mode.");
-    return;
-  }
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  if (__glutCurrentWindow->menu[button] < 1) {
-    __glutCurrentWindow->buttonUses++;
-  }
-  __glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
-}
-
-void GLUTAPIENTRY
-glutDetachMenu(int button)
-{
-  if (__glutMappedMenu) {
-    menuModificationError();
-  }
-  if (__glutCurrentWindow->menu[button] > 0) {
-    __glutCurrentWindow->buttonUses--;
-    __glutCurrentWindow->menu[button] = 0;
-  }
-}
-
diff --git a/src/glut/glx/win32_util.c b/src/glut/glx/win32_util.c
deleted file mode 100644
index 25af48a1125..00000000000
--- a/src/glut/glx/win32_util.c
+++ /dev/null
@@ -1,121 +0,0 @@
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* portions Copyright (c) Mark Kilgard, 1997, 1998. */
-
-/* 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. */
-
-
-#include "glutint.h"
-#include "glutstroke.h"
-#include "glutbitmap.h"
-#include <sys/timeb.h>
-
-/* The following added by Paul Garceau <[email protected]> */
-#if defined(__MINGW32__)
-#include <GL/gl.h>
-#include <time.h>
-#include <windows.h>
-struct timeval;
-#endif
-
-extern StrokeFontRec glutStrokeRoman, glutStrokeMonoRoman;
-extern BitmapFontRec glutBitmap8By13, glutBitmap9By15, glutBitmapTimesRoman10, glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12, glutBitmapHelvetica18;
-
-#ifndef __CYGWIN32__
-int
-gettimeofday(struct timeval* tp, void* tzp)
-{
-  struct timeb tb;
-
-  ftime(&tb);
-  tp->tv_sec = tb.time;
-  tp->tv_usec = tb.millitm * 1000;
-
-  /* 0 indicates that the call succeeded. */
-  return 0;
-}
-#endif
-
-/* To get around the fact that Microsoft DLLs only allow functions
-   to be exported and now data addresses (as Unix DSOs support), the
-   GLUT API constants such as GLUT_STROKE_ROMAN have to get passed
-   through a case statement to get mapped to the actual data structure
-   address. */
-void*
-__glutFont(void *font)
-{
-  switch((int)font) {
-  case (int)GLUT_STROKE_ROMAN:
-    return &glutStrokeRoman;
-  case (int)GLUT_STROKE_MONO_ROMAN:
-    return &glutStrokeMonoRoman;
-  case (int)GLUT_BITMAP_9_BY_15:
-    return &glutBitmap9By15;
-  case (int)GLUT_BITMAP_8_BY_13:
-    return &glutBitmap8By13;
-  case (int)GLUT_BITMAP_TIMES_ROMAN_10:
-    return &glutBitmapTimesRoman10;
-  case (int)GLUT_BITMAP_TIMES_ROMAN_24:
-    return &glutBitmapTimesRoman24;
-  case (int)GLUT_BITMAP_HELVETICA_10:
-    return &glutBitmapHelvetica10;
-  case (int)GLUT_BITMAP_HELVETICA_12:
-    return &glutBitmapHelvetica12;
-  case (int)GLUT_BITMAP_HELVETICA_18:
-    return &glutBitmapHelvetica18;
-  }
-  __glutFatalError("font not found.");
-  /* NOTREACHED */
-  return NULL; /* MSVC compiler complains if there is no return at all */
-}
-
-int
-__glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
-{
-  /* the transparent pixel on Win32 is always index number 0.  So if
-     we put this routine in this file, we can avoid compiling the
-     whole of layerutil.c which is where this routine normally comes
-     from. */
-  return 0;
-}
-
-void
-__glutAdjustCoords(Window parent, int* x, int* y, int* width, int* height)
-{
-  RECT rect;
-
-  /* adjust the window rectangle because Win32 thinks that the x, y,
-     width & height are the WHOLE window (including decorations),
-     whereas GLUT treats the x, y, width & height as only the CLIENT
-     area of the window. */
-  rect.left = *x; rect.top = *y;
-  rect.right = *x + *width; rect.bottom = *y + *height;
-
-  /* must adjust the coordinates according to the correct style
-     because depending on the style, there may or may not be
-     borders. */
-  AdjustWindowRect(&rect, WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
-		   (parent ? WS_CHILD : WS_OVERLAPPEDWINDOW),
-		   FALSE);
-  /* FALSE in the third parameter = window has no menu bar */
-
-  /* readjust if the x and y are offscreen */
-  if(rect.left < 0) {
-    *x = 0;
-  } else {
-    *x = rect.left;
-  }
-  
-  if(rect.top < 0) {
-    *y = 0;
-  } else {
-    *y = rect.top;
-  }
-
-  *width = rect.right - rect.left;	/* adjusted width */
-  *height = rect.bottom - rect.top;	/* adjusted height */
-}
-
diff --git a/src/glut/glx/win32_winproc.c b/src/glut/glx/win32_winproc.c
deleted file mode 100644
index 1b3a2978280..00000000000
--- a/src/glut/glx/win32_winproc.c
+++ /dev/null
@@ -1,792 +0,0 @@
-
-/* Copyright (c) Nate Robins, 1997. */
-/* portions Copyright (c) Mark Kilgard, 1997, 1998. */
-
-/* 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. */
-
-
-#include "glutint.h"
-#include <sys/timeb.h>
-#ifdef __MINGW32__
-#include <ctype.h>
-#endif
-
-#if defined(_WIN32) && !defined(__CYGWIN32__)
-#include <mmsystem.h>  /* Win32 Multimedia API header. */
-#endif
-
-extern unsigned __glutMenuButton;
-extern GLUTidleCB __glutIdleFunc;
-extern GLUTtimer *__glutTimerList;
-extern GLUTmenuItem *__glutGetUniqueMenuItem(GLUTmenu * menu, UINT unique);
-static HMENU __glutHMenu;
-
-static void
-updateWindowState(GLUTwindow *window, int visState)
-{
-  GLUTwindow* child;
-
-  /* XXX shownState and visState are the same in Win32. */
-  window->shownState = visState;
-  if (visState != window->visState) {
-    if (window->windowStatus) {
-      window->visState = visState;
-      __glutSetWindow(window);
-      window->windowStatus(visState);
-    }
-  }
-  /* Since Win32 only sends an activate for the toplevel window,
-     update the visibility for all the child windows. */
-  child = window->children;
-  while (child) {
-    updateWindowState(child, visState);
-    child = child->siblings;
-  }
-}
-
-LONG WINAPI
-__glutWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{ 
-  POINT         point;			/* Point structure. */
-  PAINTSTRUCT   ps;			/* Paint structure. */
-  LPMINMAXINFO  minmax;			/* Minimum/maximum info structure. */
-  GLUTwindow*   window;			/* GLUT window associated with message. */
-  GLUTmenu*     menu;			/* GLUT menu associated with message. */
-  int x, y, width, height, key;
-  int button = -1;
-
-  switch(msg) {
-  case WM_CREATE:
-    return 0;
-  case WM_CLOSE:
-    if (__glutExitFunc) {
-      __glutExitFunc(0);
-    }
-    exit(0);
-    break;
-#if 0
-  case WM_DESTROY:
-    /* XXX NVidia's NT OpenGL can have problems closing down
-       its OpenGL internal data structures if we just allow
-       the process to terminate without unbinding and deleting
-       the windows context.  Apparently, DirectDraw unloads
-       before OPENGL32.DLL in the close down sequence, but
-       NVidia's NT OpenGL needs DirectDraw to close down its
-       data structures. */
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      if (window->ctx) {
-        wglMakeCurrent(NULL, NULL);
-        wglDeleteContext(window->ctx);
-      }
-    }
-    return 0;
-#endif
-  case WM_PAINT:
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      BeginPaint(hwnd, &ps);		/* Must have this for some Win32 reason. */
-      EndPaint(hwnd, &ps);
-      if (window->win == hwnd) {
-	__glutPostRedisplay(window, GLUT_REPAIR_WORK);
-      } else if (window->overlay && window->overlay->win == hwnd) {
-	__glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
-      }
-    }
-    return 0;
-
-  case WM_SYSKEYUP:
-  case WM_KEYUP:
-    window = __glutGetWindow(hwnd);
-    if (!window) {
-      break;
-    }
-    /* Win32 is dumb and sends these messages only to the parent
-       window.  Therefore, find out if we're in a child window and
-       call the child windows keyboard callback if we are. */
-    if (window->parent) {
-      GetCursorPos(&point);
-      ScreenToClient(hwnd, &point);
-      hwnd = ChildWindowFromPoint(hwnd, point);
-      window = __glutGetWindow(hwnd);
-    }
-    if (window->specialUp || window->keyboardUp) {
-      GetCursorPos(&point);
-      ScreenToClient(window->win, &point);
-      __glutSetWindow(window);
-      __glutModifierMask = 0;
-      if (GetKeyState(VK_SHIFT) < 0)  /* < 0 = high order bit is on */
-	__glutModifierMask |= ShiftMask;
-      if (GetKeyState(VK_SHIFT) < 0)  /* < 0 = high order bit is on */
-	__glutModifierMask |= ControlMask;
-      if (GetKeyState(VK_MENU) < 0)
-	__glutModifierMask |= Mod1Mask;
-      switch (wParam) {
-      /* *INDENT-OFF* */
-      case VK_F1:     key = GLUT_KEY_F1; break;
-      case VK_F2:     key = GLUT_KEY_F2; break;
-      case VK_F3:     key = GLUT_KEY_F3; break;
-      case VK_F4:     key = GLUT_KEY_F4; break;
-      case VK_F5:     key = GLUT_KEY_F5; break;
-      case VK_F6:     key = GLUT_KEY_F6; break;
-      case VK_F7:     key = GLUT_KEY_F7; break;
-      case VK_F8:     key = GLUT_KEY_F8; break;
-      case VK_F9:     key = GLUT_KEY_F9; break;
-      case VK_F10:    key = GLUT_KEY_F10; break;
-      case VK_F11:    key = GLUT_KEY_F11; break;
-      case VK_F12:    key = GLUT_KEY_F12; break;
-      case VK_LEFT:   key = GLUT_KEY_LEFT; break;
-      case VK_UP:     key = GLUT_KEY_UP; break;
-      case VK_RIGHT:  key = GLUT_KEY_RIGHT; break;
-      case VK_DOWN:   key = GLUT_KEY_DOWN; break;
-      case VK_PRIOR:  key = GLUT_KEY_PAGE_UP; break;
-      case VK_NEXT:   key = GLUT_KEY_PAGE_DOWN; break;
-      case VK_HOME:   key = GLUT_KEY_HOME; break;
-      case VK_END:    key = GLUT_KEY_END; break;
-      case VK_INSERT: key = GLUT_KEY_INSERT; break;
-      case VK_DELETE:
-        /* Delete is an ASCII character. */
-	if (window->keyboardUp) {
-	  window->keyboardUp((unsigned char) 127, point.x, point.y);
-	}
-	return 0;
-      /* *INDENT-ON* */
-      default:
-	if (window->keyboardUp) {
-	  key = MapVirtualKey(wParam, 2);  /* Map to ASCII. */
-	  if (isascii(key) && (key != 0)) {
-
-	    /* XXX Attempt to determine modified ASCII character
-	       is quite incomplete.  Digits, symbols, CapsLock,
-	       Ctrl, and numeric keypad are all ignored.  Fix this. */
-
-	    if (!(__glutModifierMask & ShiftMask))
-	      key = tolower(key);
-	    window->keyboardUp((unsigned char) key, point.x, point.y);
-          }
-        }
-	__glutModifierMask = (unsigned int) ~0;
-	return 0;
-      }
-      if (window->specialUp) {
-        window->specialUp(key, point.x, point.y);
-      }
-      __glutModifierMask = (unsigned int) ~0;
-    }
-    return 0;
-
-  case WM_SYSCHAR:
-  case WM_CHAR:
-    window = __glutGetWindow(hwnd);
-    if (!window) {
-      break;
-    }
-
-    /* Bit 30 of lParam is set if key already held down.  If
-       we are ignoring auto repeated key strokes for the window, bail. */
-    if (window->ignoreKeyRepeat && (lParam & (1 << 30)) ) {
-      break;
-    }
-
-    /* Win32 is dumb and sends these messages only to the parent
-       window.  Therefore, find out if we're in a child window and
-       call the child windows keyboard callback if we are. */
-    if (window->parent) {
-	GetCursorPos(&point);
-	ScreenToClient(hwnd, &point);
-	hwnd = ChildWindowFromPoint(hwnd, point);
-	window = __glutGetWindow(hwnd);
-    }
-    if (window->keyboard) {
-      GetCursorPos(&point);
-      ScreenToClient(window->win, &point);
-      __glutSetWindow(window);
-      __glutModifierMask = 0;
-      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
-	__glutModifierMask |= ShiftMask;
-      if (GetKeyState(VK_CONTROL) < 0)
-	__glutModifierMask |= ControlMask;
-      if (GetKeyState(VK_MENU) < 0)
-	__glutModifierMask |= Mod1Mask;
-      window->keyboard((unsigned char)wParam, point.x, point.y);
-      __glutModifierMask = (unsigned int) ~0;
-    }
-    return 0;
-
-  case WM_SYSKEYDOWN:
-  case WM_KEYDOWN:
-    window = __glutGetWindow(hwnd);
-    if (!window) {
-      break;
-    }
-
-    /* Bit 30 of lParam is set if key already held down.  If
-       we are ignoring auto repeated key strokes for the window, bail. */
-    if (window->ignoreKeyRepeat && (lParam & (1 << 30)) ) {
-      break;
-    }
-
-    /* Win32 is dumb and sends these messages only to the parent
-       window.  Therefore, find out if we're in a child window and
-       call the child windows keyboard callback if we are. */
-    if (window->parent) {
-	GetCursorPos(&point);
-	ScreenToClient(hwnd, &point);
-	hwnd = ChildWindowFromPoint(hwnd, point);
-	window = __glutGetWindow(hwnd);
-    }
-    if (window->special) {
-      switch (wParam) {
-	/* *INDENT-OFF* */
-	/* function keys */
-	case VK_F1:     key = GLUT_KEY_F1; break;
-	case VK_F2:     key = GLUT_KEY_F2; break;
-	case VK_F3:     key = GLUT_KEY_F3; break;
-	case VK_F4:     key = GLUT_KEY_F4; break;
-	case VK_F5:     key = GLUT_KEY_F5; break;
-	case VK_F6:     key = GLUT_KEY_F6; break;
-	case VK_F7:     key = GLUT_KEY_F7; break;
-	case VK_F8:     key = GLUT_KEY_F8; break;
-	case VK_F9:     key = GLUT_KEY_F9; break;
-	case VK_F10:    key = GLUT_KEY_F10; break;
-	case VK_F11:    key = GLUT_KEY_F11; break;
-	case VK_F12:    key = GLUT_KEY_F12; break;
-	/* directional keys */
-	case VK_LEFT:   key = GLUT_KEY_LEFT; break;
-	case VK_UP:     key = GLUT_KEY_UP; break;
-	case VK_RIGHT:  key = GLUT_KEY_RIGHT; break;
-	case VK_DOWN:   key = GLUT_KEY_DOWN; break;
-	/* *INDENT-ON* */
-
-	case VK_PRIOR:
-	  /* VK_PRIOR is Win32's Page Up */
-	  key = GLUT_KEY_PAGE_UP;
-	  break;
-	case VK_NEXT:
-	  /* VK_NEXT is Win32's Page Down */
-	  key = GLUT_KEY_PAGE_DOWN;
-	  break;
-	case VK_HOME:
-	  key = GLUT_KEY_HOME;
-	  break;
-	case VK_END:
-	  key = GLUT_KEY_END;
-	  break;
-	case VK_INSERT:
-	  key = GLUT_KEY_INSERT;
-	  break;
-        case VK_DELETE:
-	  goto handleDelete;
-	default:
-	  goto defproc;
-      }
-      GetCursorPos(&point);
-      ScreenToClient(window->win, &point);
-      __glutSetWindow(window);
-      __glutModifierMask = 0;
-      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
-	__glutModifierMask |= ShiftMask;
-      if (GetKeyState(VK_CONTROL) < 0)
-	__glutModifierMask |= ControlMask;
-      if (GetKeyState(VK_MENU) < 0)
-	__glutModifierMask |= Mod1Mask;
-      window->special(key, point.x, point.y);
-      __glutModifierMask = (unsigned int) ~0;
-    } else if (window->keyboard) {
-      /* Specially handle any keys that match ASCII values but
-         do not generate Windows WM_SYSCHAR or WM_CHAR messages. */
-      switch (wParam) {
-      case VK_DELETE:
-      handleDelete:
-        /* Delete is an ASCII character. */
-        GetCursorPos(&point);
-        ScreenToClient(window->win, &point);
-        __glutSetWindow(window);
-        __glutModifierMask = 0;
-        if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
-          __glutModifierMask |= ShiftMask;
-        if (GetKeyState(VK_CONTROL) < 0)
-          __glutModifierMask |= ControlMask;
-        if (GetKeyState(VK_MENU) < 0)
-          __glutModifierMask |= Mod1Mask;
-	window->keyboard((unsigned char) 127, point.x, point.y);
-        __glutModifierMask = (unsigned int) ~0;
-	return 0;
-      default:
-        /* Let the following WM_SYSCHAR or WM_CHAR message generate
-	   the keyboard callback. */
-        break;
-      }
-    }
-    return 0;
-
-  case WM_LBUTTONDOWN:
-    button = GLUT_LEFT_BUTTON;
-  case WM_MBUTTONDOWN:
-    if (button < 0)
-      button = GLUT_MIDDLE_BUTTON;
-  case WM_RBUTTONDOWN:
-    if (button < 0)
-      button = GLUT_RIGHT_BUTTON;
-    
-    /* finish the menu if we get a button down message (user must have
-       cancelled the menu). */
-    if (__glutMappedMenu) {
-      /* TODO: take this out once the menu on middle mouse stuff works
-	 properly. */
-      if (button == GLUT_MIDDLE_BUTTON)
-	return 0;
-      GetCursorPos(&point);
-      ScreenToClient(hwnd, &point);
-      __glutItemSelected = NULL;
-      __glutFinishMenu(hwnd, point.x, point.y);
-      return 0;
-    }
-
-    /* set the capture so we can get mouse events outside the window */
-    SetCapture(hwnd);
-
-    /* Win32 doesn't return the same numbers as X does when the mouse
-       goes beyond the upper or left side of the window.  roll the
-       Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
-    x = LOWORD(lParam);
-    y = HIWORD(lParam);
-    if(x & 1 << 15) x -= (1 << 16);
-    if(y & 1 << 15) y -= (1 << 16);
-	
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      menu = __glutGetMenuByNum(window->menu[button]);
-      if (menu) {
-	point.x = LOWORD(lParam); point.y = HIWORD(lParam);
-	ClientToScreen(window->win, &point);
-	__glutMenuButton = button == GLUT_RIGHT_BUTTON ? TPM_RIGHTBUTTON :
-                           button == GLUT_LEFT_BUTTON  ? TPM_LEFTBUTTON :
-                           0x0001;
-	__glutStartMenu(menu, window, point.x, point.y, x, y);
-      } else if (window->mouse) {
-	
-        __glutSetWindow(window);
-	__glutModifierMask = 0;
-	if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on. */
-	  __glutModifierMask |= ShiftMask;
-	if (GetKeyState(VK_CONTROL) < 0)
-	  __glutModifierMask |= ControlMask;
-	if (GetKeyState(VK_MENU) < 0)
-	  __glutModifierMask |= Mod1Mask;
-	window->mouse(button, GLUT_DOWN, x, y);
-	__glutModifierMask = (unsigned int)~0;
-      } else {
-	/* Stray mouse events.  Ignore. */
-      }
-    }
-    return 0;
-
-  case WM_LBUTTONUP:
-    button = GLUT_LEFT_BUTTON;
-  case WM_MBUTTONUP:
-    if (button < 0)
-      button = GLUT_MIDDLE_BUTTON;
-  case WM_RBUTTONUP:
-    if (button < 0)
-      button = GLUT_RIGHT_BUTTON;
-
-    /* Bail out if we're processing a menu. */
-    if (__glutMappedMenu) {
-      GetCursorPos(&point);
-      ScreenToClient(hwnd, &point);
-      /* if we're getting the middle button up signal, then something
-	 on the menu was selected. */
-      if (button == GLUT_MIDDLE_BUTTON) {
-	return 0;
-	/* For some reason, the code below always returns -1 even
-	   though the point IS IN THE ITEM!  Therefore, just bail out if
-	   we get a middle mouse up.  The user must select using the
-	   left mouse button.  Stupid Win32. */
-#if 0
- 	int item = MenuItemFromPoint(hwnd, __glutHMenu, point);
- 	if (item != -1)
- 	  __glutItemSelected = (GLUTmenuItem*)GetMenuItemID(__glutHMenu, item);
- 	else
- 	  __glutItemSelected = NULL;
- 	__glutFinishMenu(hwnd, point.x, point.y);
-#endif
-      } else {
-	__glutItemSelected = NULL;
-	__glutFinishMenu(hwnd, point.x, point.y);
-      }
-      return 0;
-    }
-
-    /* Release the mouse capture. */
-    ReleaseCapture();
-
-    window = __glutGetWindow(hwnd);
-    if (window && window->mouse) {
-      /* Win32 doesn't return the same numbers as X does when the
-	 mouse goes beyond the upper or left side of the window.  roll
-	 the Win32's 0..2^16 pointer co-ord range to 0 +/- 2^15. */
-      x = LOWORD(lParam);
-      y = HIWORD(lParam);
-      if(x & 1 << 15) x -= (1 << 16);
-      if(y & 1 << 15) y -= (1 << 16);
-      
-      __glutSetWindow(window);
-      __glutModifierMask = 0;
-      if (GetKeyState(VK_SHIFT) < 0)	/* < 0 = high order bit is on */
-	__glutModifierMask |= ShiftMask;
-      if (GetKeyState(VK_CONTROL) < 0)
-	__glutModifierMask |= ControlMask;
-      if (GetKeyState(VK_MENU) < 0)
-	__glutModifierMask |= Mod1Mask;
-      window->mouse(button, GLUT_UP, x, y);
-      __glutModifierMask = (unsigned int)~0;
-    } else {
-      /* Window might have been destroyed and all the 
-	 events for the window may not yet be received. */
-    }
-    return 0;
-
-  case WM_ENTERMENULOOP:
-    /* KLUDGE: create a timer that fires every 100 ms when we start a
-       menu so that we can still process the idle & timer events (that
-       way, the timers will fire during a menu pick and so will the
-       idle func. */
-    SetTimer(hwnd, 1, 1, NULL);
-    return 0;
-
-  case WM_TIMER:
-#if 0
-    /* If the timer id is 2, then this is the timer that is set up in
-       the main glut message processing loop, and we don't want to do
-       anything but acknowledge that we got it.  It is used to prevent
-       CPU spiking when an idle function is installed. */
-    if (wParam == 2)
-      return 0;
-#endif
-
-    /* only worry about the idle function and the timeouts, since
-       these are the only events we expect to process during
-       processing of a menu. */
-    /* we no longer process the idle functions (as outlined in the
-       README), since drawing can't be done until the menu has
-       finished...it's pretty lame when the animation goes on, but
-       doesn't update, so you get this weird jerkiness. */
-#if 0    
-     if (__glutIdleFunc)
-       __glutIdleFunc();
-#endif
-    if (__glutTimerList)
-      handleTimeouts();
-    return 0;
-
-  case WM_EXITMENULOOP:
-    /* nuke the above created timer...we don't need it anymore, since
-       the menu is gone now. */
-    KillTimer(hwnd, 1);
-    return 0;
-
-  case WM_MENUSELECT:
-    if (lParam != 0)
-      __glutHMenu = (HMENU)lParam;
-    return 0;
-
-  case WM_COMMAND:
-    if (__glutMappedMenu) {
-      if (GetSubMenu(__glutHMenu, LOWORD(wParam)))
-	__glutItemSelected = NULL;
-      else
-	__glutItemSelected = 
-	  __glutGetUniqueMenuItem(__glutMappedMenu, LOWORD(wParam));
-      GetCursorPos(&point);
-      ScreenToClient(hwnd, &point);
-      __glutFinishMenu(hwnd, point.x, point.y);
-    } 
-    return 0;
-
-  case WM_MOUSEMOVE:
-    if (!__glutMappedMenu) {
-      window = __glutGetWindow(hwnd);
-      if (window) {
-          /* If motion function registered _and_ buttons held *
-             down, call motion function...  */
-	x = LOWORD(lParam);
-	y = HIWORD(lParam);
-
-	/* Win32 doesn't return the same numbers as X does when the
-	   mouse goes beyond the upper or left side of the window.
-	   roll the Win32's 0..2^16 pointer co-ord range to 0..+/-2^15. */
-	if(x & 1 << 15) x -= (1 << 16);
-	if(y & 1 << 15) y -= (1 << 16);
-
-	if (window->motion && wParam &
-            (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) {
-	  __glutSetWindow(window);
-	  window->motion(x, y);
-	}
-	/* If passive motion function registered _and_
-	   buttons not held down, call passive motion
-	   function...  */
-	else if (window->passive &&
-		 ((wParam &
-		   (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) ==
-		  0)) {
-	  __glutSetWindow(window);
-	  window->passive(x, y);
-	}
-      }
-    } else {
-      /* Motion events are thrown away when a pop up menu is
-	 active. */
-    }
-    return 0;
-
-  case WM_GETMINMAXINFO:
-    /* this voodoo is brought to you by Win32 (again).  It allows the
-       window to be bigger than the screen, and smaller than 100x100
-       (although it doesn't seem to help the y minimum). */
-    minmax = (LPMINMAXINFO)lParam;
-#if 0
-    /* These two lines are disabled to fix incorrect handling of
-     * window maximization on Vista.  See bug 23182.
-     */
-    minmax->ptMaxSize.x = __glutScreenWidth;
-    minmax->ptMaxSize.y = __glutScreenHeight;
-#endif
-    minmax->ptMinTrackSize.x = 0;
-    minmax->ptMinTrackSize.y = 0;
-    minmax->ptMaxTrackSize.x = __glutScreenWidth + 
-      GetSystemMetrics(SM_CXSIZE) * 2;
-    minmax->ptMaxTrackSize.y = __glutScreenHeight + 
-      GetSystemMetrics(SM_CXSIZE) * 2 + GetSystemMetrics(SM_CYCAPTION);
-    return 0;
-
-  case WM_SIZE:
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      width = LOWORD(lParam);
-      height = HIWORD(lParam);
-      if (width != window->width || height != window->height) {
-#if 0  /* Win32 GLUT does not support overlays for now. */
- 	if (window->overlay) {
- 	  XResizeWindow(__glutDisplay, window->overlay->win, width, height);
- 	}
-#endif
-	window->width = width;
-	window->height = height;
-	__glutSetWindow(window);
-	/* Do not execute OpenGL out of sequence with respect
-	   to the SetWindowPos request! */
-	GdiFlush();
-	window->reshape(width, height);
-	window->forceReshape = FALSE;
-	/* A reshape should be considered like posting a
-	   repair request. */
-	__glutPostRedisplay(window, GLUT_REPAIR_WORK);
-      }
-    }
-    return 0;
-
-  case WM_SETCURSOR:
-    /* If the cursor is not in the client area, then we want to send
-       this message to the default window procedure ('cause its
-       probably in the border or title, and we don't handle that
-       cursor.  otherwise, set our cursor.  Win32 makes us set the
-       cursor every time the mouse moves (DUMB!). */
-    if(LOWORD(lParam) != HTCLIENT) {
-      goto defproc;
-    }
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      __glutSetCursor(window);
-    }
-    /* TODO: check out the info in DevStudio on WM_SETCURSOR in the
-       DefaultAction section. */
-    return 1;
-
-  case WM_SETFOCUS:
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      window->entryState = WM_SETFOCUS;
-      if (window->entry) {
-	__glutSetWindow(window);
-	window->entry(GLUT_ENTERED);
-	/* XXX Generation of fake passive notify?  See how much
-	   work the X11 code does to support fake passive notify
-	   callbacks. */
-      }
-      if (window->joystick && __glutCurrentWindow) {
-        if (__glutCurrentWindow->joyPollInterval > 0) {
-	  MMRESULT result;
-
-	  /* Because Win32 will only let one window capture the
-	     joystick at a time, we must capture it when we get the
-	     focus and release it when we lose the focus. */
-	  result = joySetCapture(__glutCurrentWindow->win,
-	    JOYSTICKID1, 0, TRUE);
-	  if (result != JOYERR_NOERROR) {
-	    return 0;
-          }
-	  (void) joySetThreshold(JOYSTICKID1,
-            __glutCurrentWindow->joyPollInterval);
-        }
-      }
-    }
-    return 0;
-
-  case WM_KILLFOCUS:
-    window = __glutGetWindow(hwnd);
-    if (window) {
-      window->entryState = WM_KILLFOCUS;
-      if (window->entry) {
-	__glutSetWindow(window);
-	window->entry(GLUT_LEFT);
-      }
-      if (window->joystick && __glutCurrentWindow) {
-	if (__glutCurrentWindow->joyPollInterval > 0) {
-	  /* Because Win32 will only let one window capture the
-	     joystick at a time, we must capture it when we get the
-	     focus and release it when we lose the focus. */
-	    (void) joyReleaseCapture(JOYSTICKID1);
-        }
-      }
-    }
-    return 0;
-  case WM_ACTIVATE:
-    window = __glutGetWindow(hwnd);
-    /* Make sure we re-select the correct palette if needed. */
-    if (LOWORD(wParam)) {
-      PostMessage(hwnd, WM_PALETTECHANGED, 0, 0);
-    }
-    if (window) {
-      int visState;
-
-      /* HIWORD(wParam) is the minimized flag. */
-      visState = !HIWORD(wParam);
-      updateWindowState(window, visState);
-    }
-    return 0;
-
-  /* Colour Palette Management */
-  case WM_PALETTECHANGED:
-    if (hwnd == (HWND)wParam) {
-      /* Don't respond to the message that we sent! */
-      break;
-    }
-    /* fall through to WM_QUERYNEWPALETTE */
-
-  case WM_QUERYNEWPALETTE:
-    window = __glutGetWindow(hwnd);
-    if (window && window->colormap) {
-      UnrealizeObject(window->colormap->cmap);
-      SelectPalette(window->hdc, window->colormap->cmap, FALSE);
-      RealizePalette(window->hdc);
-      return TRUE;
-    }
-    return FALSE;
-
-  case MM_JOY1MOVE:
-  case MM_JOY1ZMOVE:
-    window = __glutGetWindow(hwnd);
-    if (window->joystick) {
-      JOYINFOEX jix;
-      int x, y, z;
-
-      /* Because WIN32 only supports messages for X, Y, and Z
-         translations, we must poll for the rest */
-      jix.dwSize = sizeof(jix);
-      jix.dwFlags = JOY_RETURNALL;
-      joyGetPosEx(JOYSTICKID1,&jix);
-
-#define SCALE(v)  ((int) ((v - 32767)/32.768))
-
-      /* Convert to integer for scaling. */
-      x = jix.dwXpos;
-      y = jix.dwYpos;
-      z = jix.dwZpos;
-      window->joystick(jix.dwButtons, SCALE(x), SCALE(y), SCALE(z));
-
-      return TRUE;
-    }
-    return FALSE;
-  case MM_JOY1BUTTONDOWN:
-  case MM_JOY1BUTTONUP:
-    window = __glutGetWindow(hwnd);
-    if (window->joystick) {
-      JOYINFOEX jix;
-
-      /* Because WIN32 only supports messages for X, Y, and Z
-         translations, we must poll for the rest */
-      jix.dwSize = sizeof(jix);
-      jix.dwFlags = JOY_RETURNALL;
-      joyGetPosEx(JOYSTICKID1,&jix);
-
-      return TRUE;
-    }
-    return FALSE;
-
-#if 0
-  /* Miscellaneous messages (don't really need to enumerate them,
-     but it's good to know what you're not getting sometimes). */
-  case WM_DISPLAYCHANGE:
-    break;
-  case WM_NCHITTEST:
-    /* This event is generated by every mouse move event. */
-    goto defproc;
-  case WM_NCMOUSEMOVE:
-    goto defproc;
-  case WM_NCACTIVATE:
-    goto defproc;
-  case WM_NCPAINT:
-    goto defproc;
-  case WM_NCCALCSIZE:
-    goto defproc;
-  case WM_NCCREATE:
-    goto defproc;
-  case WM_NCDESTROY:
-    goto defproc;
-  case WM_NCLBUTTONDOWN:
-    goto defproc;
-  case WM_SETTEXT:
-    goto defproc;
-  case WM_GETTEXT:
-    goto defproc;
-  case WM_ACTIVATEAPP:
-    goto defproc;
-  case WM_GETICON:
-    goto defproc;
-  case WM_ERASEBKGND:
-    goto defproc;
-  case WM_WINDOWPOSCHANGING:
-    goto defproc;
-  case WM_WINDOWPOSCHANGED:
-    goto defproc;
-  case WM_MOUSEACTIVATE:
-    goto defproc;
-  case WM_SHOWWINDOW:
-    goto defproc;
-  case WM_MOVING:
-    goto defproc;
-  case WM_MOVE:
-    goto defproc;
-  case WM_KEYUP:
-    goto defproc;
-  case WM_CAPTURECHANGED:
-    goto defproc;
-  case WM_SYSCOMMAND:
-    goto defproc;
-  case WM_ENTERSIZEMOVE:
-    goto defproc;
-  case WM_ENTERIDLE:
-    goto defproc;
-#endif
-
-  default: 
-    goto defproc;
-  }
-
-defproc:    
-  return DefWindowProc(hwnd, msg, wParam, lParam); 
-} 
diff --git a/src/glut/glx/win32_x11.c b/src/glut/glx/win32_x11.c
deleted file mode 100644
index d00ccdb1218..00000000000
--- a/src/glut/glx/win32_x11.c
+++ /dev/null
@@ -1,399 +0,0 @@
-
-/* Copyright (c) Nate Robins, 1997. */
-/* portions Copyright (c) Mark Kilgard, 1998. */
-
-/* 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. */
-
-#include "glutint.h"
-
-/* global variable that must be set for some functions to operate
-   correctly. */
-HDC XHDC;
-
-XVisualInfo*
-XGetVisualInfo(Display* display, long mask, XVisualInfo* template, int* nitems)
-{
-  /* KLUDGE: this function needs XHDC to be set to the HDC currently
-     being operated on before it is invoked! */
-
-  PIXELFORMATDESCRIPTOR* pfds;
-  int i, n;
-
-  n = DescribePixelFormat(XHDC, 0, 0, NULL);
-  pfds = (PIXELFORMATDESCRIPTOR*)malloc(sizeof(PIXELFORMATDESCRIPTOR) * n);
-  memset(pfds, 0, sizeof(PIXELFORMATDESCRIPTOR) * n);
-  
-  for (i = 0; i < n; i++) {
-    DescribePixelFormat(XHDC, i + 1, sizeof(PIXELFORMATDESCRIPTOR), &pfds[i]);
-  }
-
-  *nitems = n;
-  return pfds;
-}
-
-Colormap
-XCreateColormap(Display* display, Window root, Visual* visual, int alloc)
-{
-  /* KLUDGE: this function needs XHDC to be set to the HDC currently
-     being operated on before it is invoked! */
-
-  PIXELFORMATDESCRIPTOR pfd;
-  LOGPALETTE *logical;
-  HPALETTE    palette;
-  int n;
-
-  /* grab the pixel format */
-  memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
-  DescribePixelFormat(XHDC, GetPixelFormat(XHDC), 
-		      sizeof(PIXELFORMATDESCRIPTOR), &pfd);
-
-  if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
-      pfd.iPixelType == PFD_TYPE_COLORINDEX))
-  {
-    return 0;
-  }
-
-  n = 1 << pfd.cColorBits;
-
-  /* allocate a bunch of memory for the logical palette (assume 256
-     colors in a Win32 palette */
-  logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
-				sizeof(PALETTEENTRY) * n);
-  memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
-
-  /* set the entries in the logical palette */
-  logical->palVersion = 0x300;
-  logical->palNumEntries = n;
-
-  /* start with a copy of the current system palette */
-  GetSystemPaletteEntries(XHDC, 0, 256, &logical->palPalEntry[0]);
-    
-  if (pfd.iPixelType == PFD_TYPE_RGBA) {
-    int redMask = (1 << pfd.cRedBits) - 1;
-    int greenMask = (1 << pfd.cGreenBits) - 1;
-    int blueMask = (1 << pfd.cBlueBits) - 1;
-    int i;
-
-    /* fill in an RGBA color palette */
-    for (i = 0; i < n; ++i) {
-      logical->palPalEntry[i].peRed = 
-	(((i >> pfd.cRedShift)   & redMask)   * 255) / redMask;
-      logical->palPalEntry[i].peGreen = 
-	(((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
-	logical->palPalEntry[i].peBlue = 
-	(((i >> pfd.cBlueShift)  & blueMask)  * 255) / blueMask;
-      logical->palPalEntry[i].peFlags = 0;
-    }
-  }
-
-  palette = CreatePalette(logical);
-  free(logical);
-
-  SelectPalette(XHDC, palette, FALSE);
-  RealizePalette(XHDC);
-
-  return palette;
-}
-
-void
-XAllocColorCells(Display* display, Colormap colormap, Bool contig, 
-		 unsigned long plane_masks_return[], unsigned int nplanes,
-		 unsigned long pixels_return[], unsigned int npixels)
-{
-  /* NOP -- we did all the allocating in XCreateColormap! */
-}
-
-void
-XStoreColor(Display* display, Colormap colormap, XColor* color)
-{
-  /* KLUDGE: set XHDC to 0 if the palette should NOT be realized after
-     setting the color.  set XHDC to the correct HDC if it should. */
-
-  PALETTEENTRY pe;
-
-  /* X11 stores color from 0-65535, Win32 expects them to be 0-256, so
-     twiddle the bits ( / 256). */
-  pe.peRed = color->red / 256;
-  pe.peGreen = color->green / 256;
-  pe.peBlue = color->blue / 256;
-
-  /* make sure we use this flag, otherwise the colors might get mapped
-     to another place in the colormap, and when we glIndex() that
-     color, it may have moved (argh!!) */
-  pe.peFlags = PC_NOCOLLAPSE;
-
-  /* the pixel field of the XColor structure is the index into the
-     colormap */
-  SetPaletteEntries(colormap, color->pixel, 1, &pe);
-
-  if (XHDC) {
-    UnrealizeObject(colormap);
-    SelectPalette(XHDC, colormap, FALSE);
-    RealizePalette(XHDC);
-  }
-}
-
-void
-XSetWindowColormap(Display* display, Window window, Colormap colormap)
-{
-  HDC hdc = GetDC(window);
-
-  /* if the third parameter is FALSE, the logical colormap is copied
-     into the device palette when the application is in the
-     foreground, if it is TRUE, the colors are mapped into the current
-     palette in the best possible way. */
-  SelectPalette(hdc, colormap, FALSE);
-  RealizePalette(hdc);
-
-  /* note that we don't have to release the DC, since our window class
-     uses the WC_OWNDC flag! */
-}
-
-Bool
-XTranslateCoordinates(Display *display, Window src, Window dst, 
-		      int src_x, int src_y, 
-		      int* dest_x_return, int* dest_y_return,
-		      Window* child_return)
-{
-  /* KLUDGE: this isn't really a translate coordinates into some other
-  windows coordinate system...it only translates coordinates into the
-  root window (screen) coordinate system. */
-
-  POINT point;
-
-  point.x = src_x;
-  point.y = src_y;
-
-  ClientToScreen(src, &point);
-
-  *dest_x_return = point.x;
-  *dest_y_return = point.y;
-
-  /* just to make compilers happy...we don't use the return value. */
-  return True;
-}
-
-Status
-XGetGeometry(Display* display, Window window, Window* root_return, 
-	     int* x_return, int* y_return, 
-	     unsigned int* width_return, unsigned int* height_return,
-	     unsigned int *border_width_return, unsigned int* depth_return)
-{
-  /* KLUDGE: doesn't return the border_width or depth or root, x & y
-     are in screen coordinates. */
-
-  RECT rect;
-  POINT point;
-
-  GetClientRect(window, &rect);
-
-  point.x = 0;
-  point.y = 0;
-  ClientToScreen(window, &point);
-
-  *x_return = point.x;
-  *y_return = point.y;
-  *width_return = rect.right;
-  *height_return = rect.bottom;
-
-  /* just to make compilers happy...we don't use the return value. */
-  return 1;  
-}
-
-int
-DisplayWidthMM(Display* display, int screen)
-{
-  int width;
-  HWND hwnd = GetDesktopWindow();
-  HDC hdc = GetDC(hwnd);
-  
-  width = GetDeviceCaps(hdc, HORZSIZE);
-
-  /* make sure to release this DC (it's the desktops, not ours) */
-  ReleaseDC(hwnd, hdc);
-
-  return width;
-}
-
-int
-DisplayHeightMM(Display* display, int screen)
-{
-  int height;
-  HWND hwnd = GetDesktopWindow();
-  HDC hdc = GetDC(hwnd);
-  
-  height = GetDeviceCaps(hdc, VERTSIZE);
-
-  /* make sure to release this DC (it's the desktops, not ours) */
-  ReleaseDC(hwnd, hdc);
-
-  return height;
-}
-
-void
-XWarpPointer(Display* display, Window src, Window dst, 
-	     int src_x, int src_y, int src_width, int src_height,
-	     int dst_x, int dst_y)
-{
-  /* KLUDGE: this isn't really a warp pointer into some other windows
-  coordinate system...it only warps the pointer into the root window
-  (screen) coordinate system. */
-
-  POINT point;
-
-  point.x = dst_x;
-  point.y = dst_y;
-  ClientToScreen(dst, &point);
-
-  SetCursorPos(point.x, point.y);
-}
-
-int
-XPending(Display* display)
-{
-  /* similar functionality...I don't think that it is exact, but this
-     will have to do. */
-  MSG msg;
-
-  return PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
-}
-
-/* the following function was stolen from the X sources as indicated. */
-
-/* Copyright 	Massachusetts Institute of Technology  1985, 1986, 1987 */
-
-/*
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation, and that the name of M.I.T. not be used in advertising or
-publicity pertaining to distribution of the software without specific,
-written prior permission.  M.I.T. makes no representations about the
-suitability of this software for any purpose.  It is provided "as is"
-without express or implied warranty.
-*/
-
-/*
- *    XParseGeometry parses strings of the form
- *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
- *   width, height, xoffset, and yoffset are unsigned integers.
- *   Example:  "=80x24+300-49"
- *   The equal sign is optional.
- *   It returns a bitmask that indicates which of the four values
- *   were actually found in the string.  For each value found,
- *   the corresponding argument is updated;  for each value
- *   not found, the corresponding argument is left unchanged. 
- */
-
-static int
-ReadInteger(char *string, char **NextString)
-{
-    register int Result = 0;
-    int Sign = 1;
-    
-    if (*string == '+')
-	string++;
-    else if (*string == '-')
-    {
-	string++;
-	Sign = -1;
-    }
-    for (; (*string >= '0') && (*string <= '9'); string++)
-    {
-	Result = (Result * 10) + (*string - '0');
-    }
-    *NextString = string;
-    if (Sign >= 0)
-	return (Result);
-    else
-	return (-Result);
-}
-
-int XParseGeometry(char *string, int *x, int *y, unsigned int *width, unsigned int *height)
-{
-	int mask = NoValue;
-	register char *strind;
-	unsigned int tempWidth, tempHeight;
-	int tempX, tempY;
-	char *nextCharacter;
-
-	if ( (string == NULL) || (*string == '\0')) return(mask);
-	if (*string == '=')
-		string++;  /* ignore possible '=' at beg of geometry spec */
-
-	strind = (char *)string;
-	if (*strind != '+' && *strind != '-' && *strind != 'x') {
-		tempWidth = ReadInteger(strind, &nextCharacter);
-		if (strind == nextCharacter) 
-		    return (0);
-		strind = nextCharacter;
-		mask |= WidthValue;
-	}
-
-	if (*strind == 'x' || *strind == 'X') {	
-		strind++;
-		tempHeight = ReadInteger(strind, &nextCharacter);
-		if (strind == nextCharacter)
-		    return (0);
-		strind = nextCharacter;
-		mask |= HeightValue;
-	}
-
-	if ((*strind == '+') || (*strind == '-')) {
-		if (*strind == '-') {
-  			strind++;
-			tempX = -ReadInteger(strind, &nextCharacter);
-			if (strind == nextCharacter)
-			    return (0);
-			strind = nextCharacter;
-			mask |= XNegative;
-
-		}
-		else
-		{	strind++;
-			tempX = ReadInteger(strind, &nextCharacter);
-			if (strind == nextCharacter)
-			    return(0);
-			strind = nextCharacter;
-		}
-		mask |= XValue;
-		if ((*strind == '+') || (*strind == '-')) {
-			if (*strind == '-') {
-				strind++;
-				tempY = -ReadInteger(strind, &nextCharacter);
-				if (strind == nextCharacter)
-			    	    return(0);
-				strind = nextCharacter;
-				mask |= YNegative;
-
-			}
-			else
-			{
-				strind++;
-				tempY = ReadInteger(strind, &nextCharacter);
-				if (strind == nextCharacter)
-			    	    return(0);
-				strind = nextCharacter;
-			}
-			mask |= YValue;
-		}
-	}
-	
-	/* If strind isn't at the end of the string the it's an invalid
-		geometry specification. */
-
-	if (*strind != '\0') return (0);
-
-	if (mask & XValue)
-	    *x = tempX;
- 	if (mask & YValue)
-	    *y = tempY;
-	if (mask & WidthValue)
-            *width = tempWidth;
-	if (mask & HeightValue)
-            *height = tempHeight;
-	return (mask);
-}
diff --git a/src/glut/glx/win32_x11.h b/src/glut/glx/win32_x11.h
deleted file mode 100644
index daf065e27b8..00000000000
--- a/src/glut/glx/win32_x11.h
+++ /dev/null
@@ -1,324 +0,0 @@
-#ifndef __win32_x11_h__
-#define __win32_x11_h__
-
-/* Copyright (c) Nate Robins, 1997. */
-
-/* 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. */
-#ifdef __MINGW32__
-#include <GL/gl.h>
-#endif
-#include <stdlib.h>
-#include <windows.h>
-
-/* These definitions are missing from windows.h */
-
-
-/* Type definitions (conversions) */
-typedef int Visual;			/* Win32 equivalent of X11 type */
-typedef HWND Window;
-typedef HPALETTE Colormap;
-typedef PIXELFORMATDESCRIPTOR XVisualInfo;
-typedef BOOL Bool;
-typedef MSG XEvent;
-typedef HDC Display;
-typedef HCURSOR Cursor;
-
-typedef int Atom;			/* dummies */
-typedef int XDevice;
-typedef int Status;
-
-#define True  TRUE			/* Win32 equivalents of X11 booleans */
-#define False FALSE
-
-#define None                 0L	/* universal null resource or null atom */
-
-/* Input Event Masks. Used as event-mask window attribute and as arguments
-   to Grab requests.  Not to be confused with event names.  */
-
-#define NoEventMask			0L
-#define KeyPressMask			(1L<<0)  
-#define KeyReleaseMask			(1L<<1)  
-#define ButtonPressMask			(1L<<2)  
-#define ButtonReleaseMask		(1L<<3)  
-#define EnterWindowMask			(1L<<4)  
-#define LeaveWindowMask			(1L<<5)  
-#define PointerMotionMask		(1L<<6)  
-#define PointerMotionHintMask		(1L<<7)  
-#define Button1MotionMask		(1L<<8)  
-#define Button2MotionMask		(1L<<9)  
-#define Button3MotionMask		(1L<<10) 
-#define Button4MotionMask		(1L<<11) 
-#define Button5MotionMask		(1L<<12) 
-#define ButtonMotionMask		(1L<<13) 
-#define KeymapStateMask			(1L<<14)
-#define ExposureMask			(1L<<15) 
-#define VisibilityChangeMask		(1L<<16) 
-#define StructureNotifyMask		(1L<<17) 
-#define ResizeRedirectMask		(1L<<18) 
-#define SubstructureNotifyMask		(1L<<19) 
-#define SubstructureRedirectMask	(1L<<20) 
-#define FocusChangeMask			(1L<<21) 
-#define PropertyChangeMask		(1L<<22) 
-#define ColormapChangeMask		(1L<<23) 
-#define OwnerGrabButtonMask		(1L<<24) 
-
-/* Key masks. Used as modifiers to GrabButton and GrabKey, results of
-   QueryPointer, state in various key-, mouse-, and button-related
-   events. */
-
-#define ShiftMask		(1<<0)
-#define LockMask		(1<<1)
-#define ControlMask		(1<<2)
-#define Mod1Mask		(1<<3)
-#define Mod2Mask		(1<<4)
-#define Mod3Mask		(1<<5)
-#define Mod4Mask		(1<<6)
-#define Mod5Mask		(1<<7)
-
-/* Window classes used by CreateWindow */
-/* Note that CopyFromParent is already defined as 0 above */
-
-#define InputOutput		1
-#define InputOnly		2
-
-/* Window attributes for CreateWindow and ChangeWindowAttributes */
-
-#define CWBackPixmap		(1L<<0)
-#define CWBackPixel		(1L<<1)
-#define CWBorderPixmap		(1L<<2)
-#define CWBorderPixel           (1L<<3)
-#define CWBitGravity		(1L<<4)
-#define CWWinGravity		(1L<<5)
-#define CWBackingStore          (1L<<6)
-#define CWBackingPlanes	        (1L<<7)
-#define CWBackingPixel	        (1L<<8)
-#define CWOverrideRedirect	(1L<<9)
-#define CWSaveUnder		(1L<<10)
-#define CWEventMask		(1L<<11)
-#define CWDontPropagate	        (1L<<12)
-#define CWColormap		(1L<<13)
-#define CWCursor	        (1L<<14)
-
-/* ConfigureWindow structure */
-
-#define CWX			(1<<0)
-#define CWY			(1<<1)
-#define CWWidth			(1<<2)
-#define CWHeight		(1<<3)
-#define CWBorderWidth		(1<<4)
-#define CWSibling		(1<<5)
-#define CWStackMode		(1<<6)
-
-
-/* Used in GetWindowAttributes reply */
-
-#define IsUnmapped		0
-#define IsUnviewable		1
-#define IsViewable		2
-
-/* Window stacking method (in configureWindow) */
-
-#define Above                   0
-#define Below                   1
-#define TopIf                   2
-#define BottomIf                3
-#define Opposite                4
-
-/* For CreateColormap */
-
-#define AllocNone		0	/* create map with no entries */
-#define AllocAll		1	/* allocate entire map writeable */
-
-
-/* Flags used in StoreNamedColor, StoreColors */
-
-#define DoRed			(1<<0)
-#define DoGreen			(1<<1)
-#define DoBlue			(1<<2)
-
-/* 
- * Bitmask returned by XParseGeometry().  Each bit tells if the corresponding
- * value (x, y, width, height) was found in the parsed string.
- */
-#define NoValue		0x0000
-#define XValue  	0x0001
-#define YValue		0x0002
-#define WidthValue  	0x0004
-#define HeightValue  	0x0008
-#define AllValues 	0x000F
-#define XNegative 	0x0010
-#define YNegative 	0x0020
-
-/* flags argument in size hints */
-#define USPosition	(1L << 0) /* user specified x, y */
-#define USSize		(1L << 1) /* user specified width, height */
-
-/* definitions for initial window state */
-#define WithdrawnState 0	/* for windows that are not mapped */
-#define NormalState 1	/* most applications want to start this way */
-#define IconicState 3	/* application wants to start as an icon */
-#define GameModeState 4  /* Win32 GLUT only (not in Xlib!). */
-
-/* Type definitions */
-
-typedef struct {
-    unsigned int background_pixmap;	/* background pixmap */
-    unsigned long background_pixel;	/* background pixel */
-    unsigned long border_pixel;	/* border pixel value */
-    long event_mask;		/* set of events that should be saved */
-    long do_not_propagate_mask;	/* set of events that should not propagate */
-    Bool override_redirect;	   /* boolean value for override-redirect */
-    Colormap colormap;		   /* color map to be associated with window */
-} XSetWindowAttributes;
-
-typedef struct {
-  unsigned long pixel;
-  unsigned short red, green, blue;
-  char flags;  /* do_red, do_green, do_blue */
-} XColor;
-
-typedef struct {
-  unsigned char *value;	   /* same as Property routines */
-  Atom encoding;	   /* prop type */
-  int format;		   /* prop data format: 8, 16, or 32 */
-  unsigned long nitems;	   /* number of data items in value */
-} XTextProperty;
-
-typedef struct {
-  long flags;	        /* marks which fields in this structure are defined */
-  int x, y;		/* obsolete for new window mgrs, but clients */
-  int width, height;	/* should set so old wm's don't mess up */
-} XSizeHints;
-
-/* Functions emulated by macros. */
-
-#define XFreeColormap(display, colormap) \
-  DeleteObject(colormap)
-
-#define XCreateFontCursor(display, shape) \
-  LoadCursor(NULL, shape)
-
-#define XDefineCursor(display, window, cursor) \
-  SetCursor(cursor)
-
-#define XFlush(display) \
-  /* Nothing. */
-
-#define DisplayWidth(display, screen) \
-  GetSystemMetrics(SM_CXSCREEN)
-
-#define DisplayHeight(display, screen) \
-  GetSystemMetrics(SM_CYSCREEN)
-
-#define XMapWindow(display, window) \
-  ShowWindow(window, SW_SHOWNORMAL)
-
-#define XUnmapWindow(display, window) \
-  ShowWindow(window, SW_HIDE)
-
-#define XIconifyWindow(display, window, screen) \
-  ShowWindow(window, SW_MINIMIZE)
-
-#define XWithdrawWindow(display, window, screen) \
-  ShowWindow(window, SW_HIDE)
-
-#define XLowerWindow(display, window) \
-  SetWindowPos(window, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE)
-
-#define XSetWMName(display, window, tp) \
-  SetWindowText(window, (const char *)(tp)->value)
-
-/* There really isn't a way to set the icon name separate from the
-   windows name in Win32, so, just set the windows name. */
-#define XSetWMIconName(display, window, tp) \
-  XSetWMName(display, window, tp)
-
-#define XDestroyWindow(display, window) \
-  DestroyWindow(window)
-
-/* Anything that needs to be freed was allocated with malloc in our
-   fake X windows library for Win32, so free it with plain old
-   free(). */
-#define XFree(data) \
-  free(data)
-
-/* Nothing to be done for this...the pointer is always 'ungrabbed'
-   in Win32. */
-#define XUngrabPointer(display, time) \
-  /* Nothing. */
-
-/* Function prototypes. */
-
-extern XVisualInfo* XGetVisualInfo(
-  Display* display,
-  long mask,
-  XVisualInfo* ttemplate,  /* Avoid class with C++ keyword. */
-  int*nitems);
-
-extern Colormap XCreateColormap(
-  Display* display,
-  Window root,
-  Visual* visual,
-  int alloc);
-
-extern void XAllocColorCells(
-  Display* display,
-  Colormap colormap,
-  Bool contig, 
-  unsigned long plane_masks_return[],
-  unsigned int nplanes,
-  unsigned long pixels_return[],
-  unsigned int npixels);
-
-extern void XStoreColor(
-  Display* display,
-  Colormap colormap,
-  XColor* color);
-
-extern void XSetWindowColormap(
-  Display* display,
-  Window window,
-  Colormap colormap);
-
-extern Bool XTranslateCoordinates(
-  Display *display,
-  Window src, Window dst, 
-  int src_x, int src_y, 
-  int* dest_x_return, int* dest_y_return,
-  Window* child_return);
-
-extern Status XGetGeometry(
-  Display* display,
-  Window window,
-  Window* root_return, 
-  int* x_return, int* y_return, 
-  unsigned int* width_return, unsigned int* height_return,
-  unsigned int *border_width_return,
-  unsigned int* depth_return);
-
-extern int DisplayWidthMM(
-  Display* display,
-  int screen);
-
-extern int DisplayHeightMM(
-  Display* display,
-  int screen);
-
-extern void XWarpPointer(
-  Display* display,
-  Window src, Window dst, 
-  int src_x, int src_y,
-  int src_width, int src_height, 
-  int dst_x, int dst_y);
-
-extern int XParseGeometry(
-  char* string,
-  int* x, int* y, 
-  unsigned int* width, unsigned int* height);
-
-extern int XPending(
-  Display* display);
-
-#endif /* __win32_x11_h__ */