From 880653d31a8f1ff8384fdbc75b84934bceecfdb8 Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Sat, 18 Nov 2000 06:43:49 +0000 Subject: Initial revision --- gl4java/utils/Test.java | 359 +++ gl4java/utils/Tool.java | 158 ++ gl4java/utils/glut/GLUTEnum.java | 40 + gl4java/utils/glut/GLUTFunc.java | 54 + gl4java/utils/glut/GLUTFuncLightImpl.java | 847 +++++++ gl4java/utils/glut/fonts/BitmapCharRec.java | 28 + gl4java/utils/glut/fonts/BitmapFontRec.java | 24 + gl4java/utils/glut/fonts/CoordRec.java | 19 + gl4java/utils/glut/fonts/GLUTBitmapFont.java | 12 + .../glut/fonts/GLUTFuncLightImplWithFonts.java | 300 +++ gl4java/utils/glut/fonts/GLUTStrokeFont.java | 5 + gl4java/utils/glut/fonts/LICENSE.txt | 28 + gl4java/utils/glut/fonts/Makefile | 110 + gl4java/utils/glut/fonts/MonoRoman.stroke | 503 ++++ gl4java/utils/glut/fonts/Roman.stroke | 604 +++++ gl4java/utils/glut/fonts/StrokeCharRec.java | 24 + gl4java/utils/glut/fonts/StrokeFontRec.java | 25 + gl4java/utils/glut/fonts/StrokeRec.java | 20 + gl4java/utils/glut/fonts/capturexfont.c | 371 +++ gl4java/utils/glut/fonts/data/glutBitmap8By13.java | 2048 ++++++++++++++++ gl4java/utils/glut/fonts/data/glutBitmap9By15.java | 2050 ++++++++++++++++ .../glut/fonts/data/glutBitmapHelvetica10.java | 1769 ++++++++++++++ .../glut/fonts/data/glutBitmapHelvetica12.java | 1779 ++++++++++++++ .../glut/fonts/data/glutBitmapHelvetica18.java | 1888 +++++++++++++++ .../glut/fonts/data/glutBitmapTimesRoman10.java | 1768 ++++++++++++++ .../glut/fonts/data/glutBitmapTimesRoman24.java | 2051 ++++++++++++++++ .../utils/glut/fonts/data/glutStrokeMonoRoman.java | 2458 ++++++++++++++++++++ gl4java/utils/glut/fonts/data/glutStrokeRoman.java | 2458 ++++++++++++++++++++ gl4java/utils/glut/fonts/stroke.h | 134 ++ gl4java/utils/glut/fonts/strokegen.y | 658 ++++++ gl4java/utils/glut/fonts/strokelex.l | 134 ++ gl4java/utils/textures/AWTTextureLoader.java | 169 ++ gl4java/utils/textures/IOTextureLoader.java | 67 + gl4java/utils/textures/PPMAsciiTextureLoader.java | 88 + gl4java/utils/textures/PngTextureLoader.java | 160 ++ gl4java/utils/textures/TGATextureGrabber.java | 61 + gl4java/utils/textures/TGATextureLoader.java | 111 + gl4java/utils/textures/TextureGrabber.java | 116 + gl4java/utils/textures/TextureLoader.java | 41 + gl4java/utils/textures/TextureTool.java | 610 +++++ 40 files changed, 24149 insertions(+) create mode 100644 gl4java/utils/Test.java create mode 100644 gl4java/utils/Tool.java create mode 100644 gl4java/utils/glut/GLUTEnum.java create mode 100644 gl4java/utils/glut/GLUTFunc.java create mode 100644 gl4java/utils/glut/GLUTFuncLightImpl.java create mode 100644 gl4java/utils/glut/fonts/BitmapCharRec.java create mode 100644 gl4java/utils/glut/fonts/BitmapFontRec.java create mode 100644 gl4java/utils/glut/fonts/CoordRec.java create mode 100644 gl4java/utils/glut/fonts/GLUTBitmapFont.java create mode 100644 gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java create mode 100644 gl4java/utils/glut/fonts/GLUTStrokeFont.java create mode 100644 gl4java/utils/glut/fonts/LICENSE.txt create mode 100644 gl4java/utils/glut/fonts/Makefile create mode 100644 gl4java/utils/glut/fonts/MonoRoman.stroke create mode 100644 gl4java/utils/glut/fonts/Roman.stroke create mode 100644 gl4java/utils/glut/fonts/StrokeCharRec.java create mode 100644 gl4java/utils/glut/fonts/StrokeFontRec.java create mode 100644 gl4java/utils/glut/fonts/StrokeRec.java create mode 100644 gl4java/utils/glut/fonts/capturexfont.c create mode 100644 gl4java/utils/glut/fonts/data/glutBitmap8By13.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmap9By15.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java create mode 100644 gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java create mode 100644 gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java create mode 100644 gl4java/utils/glut/fonts/data/glutStrokeRoman.java create mode 100644 gl4java/utils/glut/fonts/stroke.h create mode 100644 gl4java/utils/glut/fonts/strokegen.y create mode 100644 gl4java/utils/glut/fonts/strokelex.l create mode 100644 gl4java/utils/textures/AWTTextureLoader.java create mode 100644 gl4java/utils/textures/IOTextureLoader.java create mode 100644 gl4java/utils/textures/PPMAsciiTextureLoader.java create mode 100644 gl4java/utils/textures/PngTextureLoader.java create mode 100644 gl4java/utils/textures/TGATextureGrabber.java create mode 100644 gl4java/utils/textures/TGATextureLoader.java create mode 100644 gl4java/utils/textures/TextureGrabber.java create mode 100644 gl4java/utils/textures/TextureLoader.java create mode 100755 gl4java/utils/textures/TextureTool.java (limited to 'gl4java/utils') diff --git a/gl4java/utils/Test.java b/gl4java/utils/Test.java new file mode 100644 index 0000000..addc706 --- /dev/null +++ b/gl4java/utils/Test.java @@ -0,0 +1,359 @@ +/** + * @(#) Test.java + * @(#) author: Sven Goethel + */ + +package gl4java.utils; + + +/* This program is free software under the license of LGPL */ + +import java.applet.*; +import java.awt.*; +import java.awt.event.*; +import java.lang.*; +import java.util.*; +import java.io.*; +import java.util.*; +import gl4java.GLContext; +import gl4java.awt.GLCanvas; +import gl4java.awt.GLAnimCanvas; +import gl4java.applet.SimpleGLAnimApplet1; + +public class Test +{ + + public Test(String name, Object tstObj, int width, int height) + { + if(tstObj instanceof SimpleGLAnimApplet1) + { + SimpleGLAnimApplet1 glSAnimApplet = (SimpleGLAnimApplet1)tstObj; + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + + glSAnimApplet.setSize(width, height); + glSAnimApplet.init(); + glSAnimApplet.start(); + + f.add(glSAnimApplet); + + Dimension ps = glSAnimApplet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + + } else if(tstObj instanceof GLAnimCanvas) + { + GLAnimCanvas glAnimCvsTest = (GLAnimCanvas)tstObj; + + GLAnimCanvasTest applet = new GLAnimCanvasTest(); + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + f.add("Center", applet); + applet.setSize(width,height); + applet.init(glAnimCvsTest); + applet.start(); + Dimension ps = applet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + + } else { + GLCanvas glCvsTest = (GLCanvas)tstObj; + + GLCanvasTest applet = new GLCanvasTest(); + + Frame f = new Frame(name); + + f.addWindowListener( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + System.exit(0); + } + public void windowClosing(WindowEvent e) + { + windowClosed(e); + } + } + ); + + f.setLayout(new BorderLayout()); + f.add("Center", applet); + applet.setSize(width,height); + applet.init(); + applet.start(); + Dimension ps = applet.getPreferredSize(); + f.setBounds(-100,-100,99,99); + f.setVisible(true); + f.setVisible(false); + Insets i = f.getInsets(); + f.setBounds(0,0, + ps.width+i.left+i.right, + ps.height+i.top+i.bottom); + f.setVisible(true); + } + } + + /** + * Test to load the native library, GLFunc and GLUFunc implementation ! + * If succesfull, a Frame will created and the GL-Infos (vendor, ...) + * are shown in it ! + * + * @param args, a list of args, + * + * -gljlib gl4java-glj-lib native library + * -gllib gl4java-gl-lib native library + * -glulib gl4java-glu-lib native library + * -glclass gl4java-gl-class java GLFunc implementation + * -gluclass gl4java-glu-class java GLUFunc implementation + * -testclass A derivation of GLCanvas (GLAnimCanvas also) or SimpleGLAnimApplet1 can be started here for testing purposes ! + * -w the testclass window width (default 400) + * -h the testclass window height (default 250) + * -perftest if a derivation of GLAnimCanvas is used as the testclass (see above), the fps-sleep and the use-repaint flags are set to false! + * + * without any arguments, a help screen is shown + */ + public static void main( String args[] ) + { + String gljLibName = null; + String glLibName = null; + String gluLibName = null; + String glName = GLContext.defGLFuncClass; + String gluName = GLContext.defGLUFuncClass; + String testClazzName = GLContext.defGLUFuncClass; + boolean perftest=false; + int width=400, height=250; + int i = 0; + boolean ok=true; + + if(args.length==0) + { + System.out.println("usage: java gl4java.GLContext , where options can be: "); + System.out.println(" -gljlib \t\t\t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib \t\t\t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib \t\t\t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass \t\t\t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass \t\t\t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)"); + System.out.println(" -testclass \t\t\t a derivation of GLCanvas (GLCanvas or GLAnimCanvas) can be started here for testing purposes !"); + System.out.println(" -w \t\t\t the testclass window width (default 800) !"); + System.out.println(" -h \t\t\t the testclass window height (default 600) !"); + System.out.println(" -perftest \t\t\t if a derivation of GLAnimCanvas is used as the testclass (see above), the fps-sleep and the use-repaint flags are set to false!"); + System.exit(0); + } + + while(args.length>i) + { + if(args[i].equals("-gljlib")) { + if(args.length>++i) gljLibName=args[i]; + } else if(args[i].equals("-gllib")) { + if(args.length>++i) glLibName=args[i]; + } else if(args[i].equals("-glulib")) { + if(args.length>++i) gluLibName=args[i]; + } else if(args[i].equals("-glclass")) { + if(args.length>++i) glName=args[i]; + } else if(args[i].equals("-gluclass")) { + if(args.length>++i) gluName=args[i]; + } else if(args[i].equals("-testclass")) { + if(args.length>++i) testClazzName=args[i]; + } else if(args[i].equals("-w")) { + if(args.length>++i) { + try { + width = Integer.valueOf(args[i]).intValue(); + } catch (Exception ex) { + System.out.println("invalid width, please insert an integer value !"); + ok=false; + } + } + } else if(args[i].equals("-h")) { + if(args.length>++i) { + try { + height = Integer.valueOf(args[i]).intValue(); + } catch (Exception ex) { + System.out.println("invalid height, please insert an integer value !"); + ok=false; + } + } + } else if(args[i].equals("-perftest")) { + perftest=true; + } else { + System.out.println("illegal arg "+i+": "+args[i]); + ok=false; + } + i++; + } + + if(!perftest) + { + GLContext.gljNativeDebug = true; + GLContext.gljClassDebug = true; + } else { + GLContext.gljNativeDebug = false; + GLContext.gljClassDebug = false; + } + + if(GLContext.loadNativeLibraries(gljLibName, glLibName, gluLibName)) + System.out.println("native Libraries loaded succesfull"); + else { + System.out.println("native library NOT loaded complete"); + ok=false; + } + + Object tstObj = null; + + if(ok==true) + { + try { + Class canvasClazz = + Class.forName("gl4java.awt.GLCanvas"); + Class animCanvasClazz = + Class.forName("gl4java.awt.GLAnimCanvas"); + Class animAppletCanvasClazz = + Class.forName("gl4java.applet.SimpleGLAnimApplet1"); + + Class tstClazz = + Class.forName(testClazzName); + + if( ! canvasClazz.isAssignableFrom(tstClazz) && + ! animAppletCanvasClazz.isAssignableFrom(tstClazz) ) + { + System.out.println("Your test-clazz is neither derived from gl4java.awt.GLCanvas nor from gl4java.applet.SimpleGLAnimApplet1!"); + ok=false; + throw new Exception(); + } + + /** + * Std. conversion from Integer -> int + */ + Class[] parameterTypes = new Class[4]; + parameterTypes[0] = Class.forName("java.lang.Integer"); + parameterTypes[1] = Class.forName("java.lang.Integer"); + parameterTypes[2] = Class.forName("java.lang.String"); + parameterTypes[3] = Class.forName("java.lang.String"); + + Object[] parameters = null; + java.lang.reflect.Constructor tstObjConstr = null; + + try { + tstObjConstr = tstClazz.getConstructor(parameterTypes); + + parameters = new Object[4]; + parameters[0] = new java.lang.Integer(width); + parameters[1] = new java.lang.Integer(height); + parameters[2] = glName; + parameters[3] = gluName; + + } catch (java.lang.NoSuchMethodException nsme) { + + try { + parameterTypes = new Class[4]; + parameterTypes[0] = Class.forName("java.lang.Integer"); + parameterTypes[1] = Class.forName("java.lang.Integer"); + + tstObjConstr = tstClazz.getConstructor(parameterTypes); + + parameters = new Object[4]; + parameters[0] = new java.lang.Integer(width); + parameters[1] = new java.lang.Integer(height); + + } catch (java.lang.NoSuchMethodException nsme2) { + tstObj = tstClazz.newInstance(); + } + } + + if(tstObj==null && parameters!=null) + tstObj = tstObjConstr.newInstance(parameters); + + } catch (Exception ex) { + System.out.println("Instantiation of: "+testClazzName+" failed !"); + System.out.println(ex); + ok =false; + } + + ok = tstObj!=null ; + } + + if(ok) { + // let's do it ... + Test test = new Test(testClazzName, tstObj, width, height); + } + } + + private class GLAnimCanvasTest extends SimpleGLAnimApplet1 + { + public void init(GLAnimCanvas glAnimCanvas) + { + super.init(); + Dimension d = getSize(); + canvas = glAnimCanvas; + add("Center", canvas); + } + } + + private class GLCanvasTest extends Applet + { + GLCanvas canvas = null; + + /* Initialize the applet */ + + public void init(GLCanvas glCanvas) + { + Dimension d = getSize(); + setLayout(new BorderLayout()); + canvas = glCanvas; + add("Center", canvas); + } + + /* Start the applet */ + + public void start() + { + } + + /* Stop the applet */ + + public void stop() + { + } + } +} diff --git a/gl4java/utils/Tool.java b/gl4java/utils/Tool.java new file mode 100644 index 0000000..e4ef7dc --- /dev/null +++ b/gl4java/utils/Tool.java @@ -0,0 +1,158 @@ +/* + * @(#) Tool.java + * + * @author Sven Goethel + */ + +package gl4java.utils; + +import java.util.*; +import java.lang.*; +import java.net.*; +import java.io.*; +import java.awt.*; +import java.applet.*; + +public class Tool { + +/** + * A few Component methods for Java-VM access + */ + + public static String getVersion() + { + String version = null; + + try { + version = java.lang.System.getProperty("java.version"); + } + catch ( SecurityException s) + { + version=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(version); + } + + return version; + } + + public static String getVendor() + { + String vendor = null; + + try { + vendor = java.lang.System.getProperty("java.vendor"); + } + catch ( SecurityException s) + { + vendor=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(vendor); + } + + return vendor; + + } + + public static String getOSName() + { + String osname = null; + + try { + osname = java.lang.System.getProperty("os.name"); + } + catch ( SecurityException s) + { + osname=(s.getMessage()==null)?s.toString():s.getMessage(); + System.out.println(osname); + } + + return osname; + + } + + public static boolean isNetscapesVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Netscape")>=0; } + + public static boolean isSunsVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Sun")>=0; } + + public static boolean isMicrosoftsVM() + { String vendor=getVendor(); + return vendor!=null && vendor.indexOf("Microsoft")>=0; } + +/****************************************************************************/ +/****************************************************************************/ +/****************************************************************************/ + +/** + * A few Component methods for easy awt-hierarchy querys + */ + + public static Point getAbsoluteCoord(Component co) + { + Object obj = co; + Point absCoord = co.getLocation(); + Point p = null; + + while (obj instanceof Component) { + Container cont = ((Component)obj).getParent(); + if( cont != null ) { + p = cont.getLocation(); + absCoord.x+=p.x; + absCoord.y+=p.y; + } + if( cont instanceof Window) { + obj=null; + } else obj=cont; + } + return absCoord; + } + + public static Window getWindow(Component co) + { + Window f = null; + Object obj = co; + + while (obj instanceof Component) { + Container cont = ((Component)obj).getParent(); + if( cont instanceof Window) { + f=(Window)cont; + obj=cont; // continue seeking for frame or dialog + } else if( cont instanceof Frame) { + f=(Window)cont; + obj=null; + } else if( cont instanceof Dialog) { + f=(Window)cont; + obj=null; + } else obj=cont; + } + return f; + } + +/***************************************************************************/ +/***************************************************************************/ +/***************************************************************************/ + +/** + * A few find methods to seek for Component(Shadow)s + */ + + + public static boolean isInSameWindow(Component co1, Component co2) + { + if(co1==null || co2==null ) return false; + + Window f1 = getWindow(co1); + Window f2 = getWindow(co2); + + if(f1!=null && f2!=null && f1.equals(f2)) + return true; + + return false; + } + +} + + + diff --git a/gl4java/utils/glut/GLUTEnum.java b/gl4java/utils/glut/GLUTEnum.java new file mode 100644 index 0000000..fb28a88 --- /dev/null +++ b/gl4java/utils/glut/GLUTEnum.java @@ -0,0 +1,40 @@ + +package gl4java.utils.glut; + +public abstract interface GLUTEnum +{ + + static final int GLUT_XLIB_IMPLEMENTATION = 15; + + /* Color index component selection values. */ + static final int GLUT_RED = 0; + static final int GLUT_GREEN = 1; + static final int GLUT_BLUE = 2; + + /* Stroke font constants (use these in GLUT program). */ + static final int GLUT_STROKE_ROMAN = 0; + static final int GLUT_STROKE_MONO_ROMAN = 1; + + /* Bitmap font constants (use these in GLUT program). */ + static final int GLUT_BITMAP_9_BY_15 = 2; + static final int GLUT_BITMAP_8_BY_13 = 3; + static final int GLUT_BITMAP_TIMES_ROMAN_10 = 4; + static final int GLUT_BITMAP_TIMES_ROMAN_24 = 5; + static final int GLUT_BITMAP_HELVETICA_10 = 6; + static final int GLUT_BITMAP_HELVETICA_12 = 7; + static final int GLUT_BITMAP_HELVETICA_18 = 8; + + /* glutVideoResizeGet parameters. */ + static final int GLUT_VIDEO_RESIZE_POSSIBLE = 900; + static final int GLUT_VIDEO_RESIZE_IN_USE = 901; + static final int GLUT_VIDEO_RESIZE_X_DELTA = 902; + static final int GLUT_VIDEO_RESIZE_Y_DELTA = 903; + static final int GLUT_VIDEO_RESIZE_WIDTH_DELTA = 904; + static final int GLUT_VIDEO_RESIZE_HEIGHT_DELTA = 905; + static final int GLUT_VIDEO_RESIZE_X = 906; + static final int GLUT_VIDEO_RESIZE_Y = 907; + static final int GLUT_VIDEO_RESIZE_WIDTH = 908; + static final int GLUT_VIDEO_RESIZE_HEIGHT = 909; +} + + diff --git a/gl4java/utils/glut/GLUTFunc.java b/gl4java/utils/glut/GLUTFunc.java new file mode 100644 index 0000000..fc69d30 --- /dev/null +++ b/gl4java/utils/glut/GLUTFunc.java @@ -0,0 +1,54 @@ + +package gl4java.utils.glut; + +import gl4java.GLFunc; +import gl4java.GLUFunc; + +public interface GLUTFunc +extends GLUTEnum +{ + public void init(GLFunc gl, GLUFunc glu); + + public String glutGetFontDescription(int font); + public void glutBitmapString(int font, String s); + public int glutBitmapWidth(int font, int character); + public void glutStrokeString(int font, String s); + public int glutStrokeWidth(int font, int character); + + public int glutBitmapLength(int font, String string); + public int glutStrokeLength(int font, String string); + + public void glutWireSphere(double radius, int slices, int stacks); + public void glutSolidSphere(double radius, int slices, int stacks); + public void glutWireCone(double base, double height, int slices, int stacks); + public void glutSolidCone(double base, double height, int slices, int stacks); + public void glutWireCube(double size); + public void glutSolidCube(double size); + public void glutWireTorus(double innerRadius, double outerRadius, int sides, int rings); + public void glutSolidTorus(double innerRadius, double outerRadius, int sides, int rings); + public void glutWireDodecahedron(); + public void glutSolidDodecahedron(); + public void glutWireTeapot(double size); + public void glutSolidTeapot(double size); + public void glutWireOctahedron(); + public void glutSolidOctahedron(); + public void glutWireTetrahedron(); + public void glutSolidTetrahedron(); + public void glutWireIcosahedron(); + public void glutSolidIcosahedron(); + + + + public int glutVideoResizeGet(int param); + public void glutSetupVideoResizing(); + public void glutStopVideoResizing(); + public void glutVideoResize(int x, int y, int width, int height); + public void glutVideoPan(int x, int y, int width, int height); + + + public void glutReportErrors(); +} + + + + diff --git a/gl4java/utils/glut/GLUTFuncLightImpl.java b/gl4java/utils/glut/GLUTFuncLightImpl.java new file mode 100644 index 0000000..0d75311 --- /dev/null +++ b/gl4java/utils/glut/GLUTFuncLightImpl.java @@ -0,0 +1,847 @@ +/* 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 adverti(float)Math.sing 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.227f.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227f-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. +*/ + + +package gl4java.utils.glut; + +import gl4java.GLFunc; +import gl4java.GLEnum; +import gl4java.GLUFunc; +import gl4java.GLUEnum; + +import java.lang.*; + +public class GLUTFuncLightImpl +implements GLUTFunc, GLEnum, GLUEnum +{ + public GLUTFuncLightImpl(GLFunc gl, GLUFunc glu) + { + init(gl, glu); + } + + public void init(GLFunc gl, GLUFunc glu) + { + this.gl = gl; + this.glu = glu; + initQuadObj(); + dodec = new float[20][3]; + initDodecahedron(); + initTeapot(); + } + + public String glutGetFontDescription(int font) + { + return "GLUTFuncLightImpl: no font support avaiable !"; + } + + public void glutBitmapString(int font, String s) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + } + + public int glutBitmapWidth(int font, int character) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public void glutStrokeString(int font, String s) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + } + + + public int glutStrokeWidth(int font, int character) + + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public int glutBitmapLength(int font, String string) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public int glutStrokeLength(int font, String string) + { + System.out.println("GLUTFuncLightImpl: no font support avaiable !"); + return 0; + } + + public final void glutWireSphere + (double radius, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_LINE); + glu.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. */ + glu.gluSphere(quadObj, radius, slices, stacks); + } + + public final void glutSolidSphere + (double radius, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_FILL); + glu.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. */ + glu.gluSphere(quadObj, radius, slices, stacks); + } + + public final void glutWireCone + (double base, double height, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_LINE); + glu.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. */ + glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks); + } + + public final void glutSolidCone + (double base, double height, int slices, int stacks) + { + glu.gluQuadricDrawStyle(quadObj, GLU_FILL); + glu.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. */ + glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks); + } + + public final void glutWireCube(double size) + { + drawBox(size, GL_LINE_LOOP); + } + + public final void glutSolidCube(double size) + { + drawBox(size, GL_QUADS); + } + + public final void glutWireTorus + (double innerRadius, double outerRadius, + int sides, int rings) + { + gl.glPushAttrib(GL_POLYGON_BIT); + gl.glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + doughnut((float)innerRadius, (float)outerRadius, sides, rings); + gl.glPopAttrib(); + } + + public final void glutSolidTorus + (double innerRadius, double outerRadius, + int sides, int rings) + { + doughnut((float)innerRadius, (float)outerRadius, sides, rings); + } + + public final void glutWireDodecahedron() + { + dodecahedron(GL_LINE_LOOP); + } + + public final void glutSolidDodecahedron() + { + dodecahedron(GL_TRIANGLE_FAN); + } + + public final void glutWireOctahedron() + { + octahedron(GL_LINE_LOOP); + } + + public final void glutSolidOctahedron() + { + octahedron(GL_TRIANGLES); + } + + public final void glutWireIcosahedron() + { + icosahedron(GL_LINE_LOOP); + } + + public final void glutSolidIcosahedron() + { + icosahedron(GL_TRIANGLES); + } + + public final void glutWireTetrahedron() + { + tetrahedron(GL_LINE_LOOP); + } + + public final void glutSolidTetrahedron() + { + tetrahedron(GL_TRIANGLES); + } + + public final void glutWireTeapot(double size) + { + teapot(10, size, GL_LINE); + } + + public final void glutSolidTeapot(double size) + { + teapot(14, size, GL_FILL); + } + + public final int glutVideoResizeGet(int param) + { System.out.println("Not implemented in GLUT light implementation !"); + return 0; + } + + public final void glutSetupVideoResizing() + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutStopVideoResizing() + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutVideoResize(int x, int y, int width, int height) + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutVideoPan(int x, int y, int width, int height) + { System.out.println("Not implemented in GLUT light implementation !"); + } + + public final void glutReportErrors() + { + int error; + + while ((error = gl.glGetError()) != GL_NO_ERROR) + __glutWarning("GL error: "+glu.gluErrorString(error)); + } + + /***************************************************************/ + + protected GLFunc gl = null; + protected GLUFunc glu = null; + + protected int quadObj=0; + + protected final void initQuadObj() + { + if(0==quadObj) quadObj = glu.gluNewQuadric(); + if (0==quadObj) + __glutFatalError("out of memory."); + } + + protected static final float n[/*6*/][/*3*/] = + { + {-1.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {1.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 0.0f, 1.0f}, + {0.0f, 0.0f, -1.0f} + }; + protected static final int 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} + }; + + protected final void drawBox(double size, int type) + { + float v[][] = new float[8][3]; + float sz = (float)size; + int i; + + v[0][0] = v[1][0] = v[2][0] = v[3][0] = -sz / 2.0f; + v[4][0] = v[5][0] = v[6][0] = v[7][0] = sz / 2.0f; + v[0][1] = v[1][1] = v[4][1] = v[5][1] = -sz / 2.0f; + v[2][1] = v[3][1] = v[6][1] = v[7][1] = sz / 2.0f; + v[0][2] = v[3][2] = v[4][2] = v[7][2] = -sz / 2.0f; + v[1][2] = v[2][2] = v[5][2] = v[6][2] = sz / 2.0f; + + for (i = 5; i >= 0; i--) { + gl.glBegin(type); + gl.glNormal3fv( n[i] ); + gl.glVertex3fv( v[ faces[i][0] ] ); + gl.glVertex3fv( v[ faces[i][1] ] ); + gl.glVertex3fv( v[ faces[i][2] ] ); + gl.glVertex3fv( v[ faces[i][3] ] ); + gl.glEnd(); + } + } + + protected static final float M_PI = 3.14159265358979323846f ; + + protected final void doughnut(float r, float R, int nsides, int rings) + { + int i, j; + float theta, phi, theta1; + float cosTheta, sinTheta; + float cosTheta1, sinTheta1; + float ringDelta, sideDelta; + + ringDelta = 2.0f * M_PI / rings; + sideDelta = 2.0f * M_PI / nsides; + + theta = 0.0f; + cosTheta = 1.0f; + sinTheta = 0.0f; + for (i = rings - 1; i >= 0; i--) + { + theta1 = theta + ringDelta; + cosTheta1 = (float)Math.cos(theta1); + sinTheta1 = (float)Math.sin(theta1); + gl.glBegin(GL_QUAD_STRIP); + phi = 0.0f; + for (j = nsides; j >= 0; j--) { + float cosPhi, sinPhi, dist; + + phi += sideDelta; + cosPhi = (float)Math.cos(phi); + sinPhi = (float)Math.sin(phi); + dist = R + r * cosPhi; + + gl.glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi); + gl.glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi); + gl.glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi); + gl.glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi); + } + gl.glEnd(); + theta = theta1; + cosTheta = cosTheta1; + sinTheta = sinTheta1; + } + } + + protected static float dodec[/*20*/][/*3*/] = null; + + protected static int dodec_inited = 0; + + protected static final void initDodecahedron() + { + if (dodec_inited != 0) { + return; + } + + dodec_inited = 1; + dodec = new float [20][3]; + + float alpha, beta; + + alpha = (float)Math.sqrt(2.0f / (3.0f + (float)Math.sqrt(5.0f))); + beta = 1.0f + (float)Math.sqrt(6.0f / (3.0f + (float)Math.sqrt(5.0f)) + - + 2.0f + 2.0f * (float)Math.sqrt(2.0f / (3.0f + (float)Math.sqrt(5.0f)))); + /* *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* */ + + } + + protected static final void DIFF3f(float[] _a, float[] _b, float[] _c) + { + (_c)[0] = (_a)[0] - (_b)[0]; + (_c)[1] = (_a)[1] - (_b)[1]; + (_c)[2] = (_a)[2] - (_b)[2]; + } + + protected static final void crossprod + (float v1[/*3*/], float v2[/*3*/], float prod[/*3*/]) + { + float p[] = new float[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]; + } + + protected static final void normalize(float v[/*3*/]) + { + float d; + + d = (float)Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); + if (d == 0.0f) { + __glutWarning("normalize: zero length vector"); + v[0] = d = 1.0f; + } + d = 1 / d; + v[0] *= d; + v[1] *= d; + v[2] *= d; + } + + protected final void + pentagon(int a, int b, int c, int d, int e, int shadeType) + { + float n0[] = new float[3]; + float d1[] = new float[3]; + float d2[] = new float[3]; + + DIFF3f(dodec[a], dodec[b], d1); + DIFF3f(dodec[b], dodec[c], d2); + crossprod(d1, d2, n0); + normalize(n0); + + gl.glBegin(shadeType); + gl.glNormal3fv(n0); + gl.glVertex3fv(dodec[a]); + gl.glVertex3fv(dodec[b]); + gl.glVertex3fv(dodec[c]); + gl.glVertex3fv(dodec[d]); + gl.glVertex3fv(dodec[e]); + gl.glEnd(); + } + + protected final void dodecahedron(int type) + { + + 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); + } + + protected final void + recorditem(float[] n1, float[] n2, float[] n3, int shadeType) + { + float q0[] = new float[3]; + float q1[] = new float[3]; + + DIFF3f(n1, n2, q0); + DIFF3f(n2, n3, q1); + crossprod(q0, q1, q1); + normalize(q1); + + gl.glBegin(shadeType); + gl.glNormal3fv(q1); + gl.glVertex3fv(n1); + gl.glVertex3fv(n2); + gl.glVertex3fv(n3); + gl.glEnd(); + } + + protected final void + subdivide(float[] v0, float[] v1, float[] v2, int shadeType) + { + int depth; + float w0[] = new float[3]; + float w1[] = new float[3]; + float w2[] = new float[3]; + float 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 = (float)Math.sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]); + w0[0] /= l; + w0[1] /= l; + w0[2] /= l; + l = (float)Math.sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]); + w1[0] /= l; + w1[1] /= l; + w1[2] /= l; + l = (float)Math.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); + } + } + } + + protected final void + drawtriangle(int i, float data[][/*3*/], int ndx[][/*3*/], + int shadeType) + { + float 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.0f */ + protected static final float odata[/*6*/][/*3*/] = + { + {1.0f, 0.0f, 0.0f}, + {-1.0f, 0.0f, 0.0f}, + {0.0f, 1.0f, 0.0f}, + {0.0f, -1.0f, 0.0f}, + {0.0f, 0.0f, 1.0f}, + {0.0f, 0.0f, -1.0f} + }; + + protected static final 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} + }; + + protected final void + octahedron(int shadeType) + { + int i; + + for (i = 7; i >= 0; i--) { + drawtriangle(i, odata, ondex, shadeType); + } + } + + protected static final float X = .525731112119133606f; + protected static final float Z = .850650808352039932f; + + protected static final float 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} + }; + + protected static final 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}, + }; + + protected final void icosahedron(int shadeType) + { + int i; + + for (i = 19; i >= 0; i--) { + drawtriangle(i, idata, index, shadeType); + } + } + + protected static final float T = 1.73205080756887729f; + + protected static final float tdata[/*4*/][/*3*/] = + { + {T, T, T}, + {T, -T, -T}, + {-T, T, -T}, + {-T, -T, T} + }; + + protected static final int tndex[/*4*/][/*3*/] = + { + {0, 1, 3}, + {2, 1, 0}, + {3, 2, 0}, + {1, 2, 3} + }; + + protected final void tetrahedron(int shadeType) + { + int i; + + for (i = 3; i >= 0; i--) + drawtriangle(i, tdata, tndex, shadeType); + } + + /** + * The Teapot + */ + + /* Rim, body, lid, and bottom data must be reflected in x and + y; handle and spout data across the y axis only. */ + private static final int patchdata[][] = + { + /* 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} + }; + private static final float cpdata[][] = + { + {0.2f, 0.0f, 2.7f}, {0.2f, -0.112f, 2.7f}, {0.112f, -0.2f, 2.7f}, {0.0f, + -0.2f, 2.7f}, {1.3375f, 0.0f, 2.53125f}, {1.3375f, -0.749f, 2.53125f}, + {0.749f, -1.3375f, 2.53125f}, {0.0f, -1.3375f, 2.53125f}, {1.4375f, + 0.0f, 2.53125f}, {1.4375f, -0.805f, 2.53125f}, {0.805f, -1.4375f, + 2.53125f}, {0.0f, -1.4375f, 2.53125f}, {1.5f, 0.0f, 2.4f}, {1.5f, -0.84f, + 2.4f}, {0.84f, -1.5f, 2.4f}, {0.0f, -1.5f, 2.4f}, {1.75f, 0.0f, 1.875f}, + {1.75f, -0.98f, 1.875f}, {0.98f, -1.75f, 1.875f}, {0.0f, -1.75f, + 1.875f}, {2f, 0.0f, 1.35f}, {2f, -1.12f, 1.35f}, {1.12f, -2f, 1.35f}, + {0.0f, -2f, 1.35f}, {2f, 0.0f, 0.9f}, {2f, -1.12f, 0.9f}, {1.12f, -2f, + 0.9f}, {0.0f, -2f, 0.9f}, {-2f, 0.0f, 0.9f}, {2f, 0.0f, 0.45f}, {2f, -1.12f, + 0.45f}, {1.12f, -2f, 0.45f}, {0.0f, -2f, 0.45f}, {1.5f, 0.0f, 0.225f}, + {1.5f, -0.84f, 0.225f}, {0.84f, -1.5f, 0.225f}, {0.0f, -1.5f, 0.225f}, + {1.5f, 0.0f, 0.15f}, {1.5f, -0.84f, 0.15f}, {0.84f, -1.5f, 0.15f}, {0.0f, + -1.5f, 0.15f}, {-1.6f, 0.0f, 2.025f}, {-1.6f, -0.3f, 2.025f}, {-1.5f, + -0.3f, 2.25f}, {-1.5f, 0.0f, 2.25f}, {-2.3f, 0.0f, 2.025f}, {-2.3f, -0.3f, + 2.025f}, {-2.5f, -0.3f, 2.25f}, {-2.5f, 0.0f, 2.25f}, {-2.7f, 0.0f, + 2.025f}, {-2.7f, -0.3f, 2.025f}, {-3f, -0.3f, 2.25f}, {-3f, 0.0f, + 2.25f}, {-2.7f, 0.0f, 1.8f}, {-2.7f, -0.3f, 1.8f}, {-3f, -0.3f, 1.8f}, + {-3f, 0.0f, 1.8f}, {-2.7f, 0.0f, 1.575f}, {-2.7f, -0.3f, 1.575f}, {-3f, + -0.3f, 1.35f}, {-3f, 0.0f, 1.35f}, {-2.5f, 0.0f, 1.125f}, {-2.5f, -0.3f, + 1.125f}, {-2.65f, -0.3f, 0.9375f}, {-2.65f, 0.0f, 0.9375f}, {-2f, + -0.3f, 0.9f}, {-1.9f, -0.3f, 0.6f}, {-1.9f, 0.0f, 0.6f}, {1.7f, 0.0f, + 1.425f}, {1.7f, -0.66f, 1.425f}, {1.7f, -0.66f, 0.6f}, {1.7f, 0.0f, + 0.6f}, {2.6f, 0.0f, 1.425f}, {2.6f, -0.66f, 1.425f}, {3.1f, -0.66f, + 0.825f}, {3.1f, 0.0f, 0.825f}, {2.3f, 0.0f, 2.1f}, {2.3f, -0.25f, 2.1f}, + {2.4f, -0.25f, 2.025f}, {2.4f, 0.0f, 2.025f}, {2.7f, 0.0f, 2.4f}, {2.7f, + -0.25f, 2.4f}, {3.3f, -0.25f, 2.4f}, {3.3f, 0.0f, 2.4f}, {2.8f, 0.0f, + 2.475f}, {2.8f, -0.25f, 2.475f}, {3.525f, -0.25f, 2.49375f}, + {3.525f, 0.0f, 2.49375f}, {2.9f, 0.0f, 2.475f}, {2.9f, -0.15f, 2.475f}, + {3.45f, -0.15f, 2.5125f}, {3.45f, 0.0f, 2.5125f}, {2.8f, 0.0f, 2.4f}, + {2.8f, -0.15f, 2.4f}, {3.2f, -0.15f, 2.4f}, {3.2f, 0.0f, 2.4f}, {0.0f, 0.0f, + 3.15f}, {0.8f, 0.0f, 3.15f}, {0.8f, -0.45f, 3.15f}, {0.45f, -0.8f, + 3.15f}, {0.0f, -0.8f, 3.15f}, {0.0f, 0.0f, 2.85f}, {1.4f, 0.0f, 2.4f}, {1.4f, + -0.784f, 2.4f}, {0.784f, -1.4f, 2.4f}, {0.0f, -1.4f, 2.4f}, {0.4f, 0.0f, + 2.55f}, {0.4f, -0.224f, 2.55f}, {0.224f, -0.4f, 2.55f}, {0.0f, -0.4f, + 2.55f}, {1.3f, 0.0f, 2.55f}, {1.3f, -0.728f, 2.55f}, {0.728f, -1.3f, + 2.55f}, {0.0f, -1.3f, 2.55f}, {1.3f, 0.0f, 2.4f}, {1.3f, -0.728f, 2.4f}, + {0.728f, -1.3f, 2.4f}, {0.0f, -1.3f, 2.4f}, {0.0f, 0.0f, 0.0f}, {1.425f, + -0.798f, 0.0f}, {1.5f, 0.0f, 0.075f}, {1.425f, 0.0f, 0.0f}, {0.798f, -1.425f, + 0.0f}, {0.0f, -1.5f, 0.075f}, {0.0f, -1.425f, 0.0f}, {1.5f, -0.84f, 0.075f}, + {0.84f, -1.5f, 0.075f} + }; + private static final float tex[] = + { + 0.0f, 0.0f, + 1.0f, 0.0f, + 0.0f, 1.0f, + 1.0f, 1.0f + }; + + boolean _tp_init = false; + float _tp_p[] = null; + float _tp_q[] = null; + float _tp_r[] = null; + float _tp_s[] = null; + + private final void initTeapot() + { + if(_tp_init==true) + return; + + _tp_p = new float[4*4*3]; + _tp_q = new float[4*4*3]; + _tp_r = new float[4*4*3]; + _tp_s = new float[4*4*3]; + } + + // Imported from glut. + private final void teapot(int grid, double scale, int type) + { + float sc = (float)(0.5*scale); + + gl.glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT); + gl.glEnable(GL_AUTO_NORMAL); + gl.glEnable(GL_NORMALIZE); + gl.glEnable(GL_MAP2_VERTEX_3); + gl.glEnable(GL_MAP2_TEXTURE_COORD_2); + gl.glPushMatrix(); + gl.glRotatef(270.0f, 1.0f, 0.0f, 0.0f); + gl.glScalef(sc, sc, sc); + gl.glTranslatef(0.0f, 0.0f, -1.5f); + for (int i = 0; i < 10; i++) + { + for (int j = 0; j < 4; j++) + { + for (int k = 0; k < 4; k++) + { + for (int l = 0; l < 3; l++) + { + _tp_p[(j*12)+(k*3)+l] = cpdata[patchdata[i][j * 4 + k]][l]; + _tp_q[(j*12)+(k*3)+l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 1) + _tp_q[(j*12)+(k*3)+l] *= -1.0f; + if (i < 6) + { + _tp_r[(j*12)+(k*3)+l] = + cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 0) + _tp_r[(j*12)+(k*3)+l] *= -1.0f; + _tp_s[(j*12)+(k*3)+l] = + cpdata[patchdata[i][j * 4 + k]][l]; + if (l == 0) + _tp_s[(j*12)+(k*3)+l] *= -1.0f; + if (l == 1) + _tp_s[(j*12)+(k*3)+l] *= -1.0f; + } + } + } + } + gl.glMap2f + (GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, tex); + gl.glMap2f + (GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_p); + gl.glMapGrid2f(grid, 0.0f, 1.0f, grid, 0.0f, 1.0f); + gl.glEvalMesh2(type, 0, grid, 0, grid); + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_q); + gl.glEvalMesh2(type, 0, grid, 0, grid); + if (i < 6) + { + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_r); + gl.glEvalMesh2(type, 0, grid, 0, grid); + gl.glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, _tp_s); + gl.glEvalMesh2(type, 0, grid, 0, grid); + } + } + gl.glPopMatrix(); + gl.glPopAttrib(); + } + + protected static final void __glutWarning(String str) + { + System.out.println("GLUT: Warning in (unamed): "+str+"\n"); + } + + protected static final void __glutFatalError(String str) + { + System.out.println("GLUT: Fatal Error in (unamed): "+str+"\n"); + Exception ex = new Exception(); + ex.printStackTrace(); + System.exit(1); + } + +} + + + + diff --git a/gl4java/utils/glut/fonts/BitmapCharRec.java b/gl4java/utils/glut/fonts/BitmapCharRec.java new file mode 100644 index 0000000..b23cd23 --- /dev/null +++ b/gl4java/utils/glut/fonts/BitmapCharRec.java @@ -0,0 +1,28 @@ +// Bitmap Character Record +// by Pontus Lidman +// based on GLUT 3.7 glutbitmap.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class BitmapCharRec { + public int width=0; + public int height=0; + public float xorig=0; + public float yorig=0; + public float advance=0; + public byte[] bitmap=null; + + public BitmapCharRec(int w,int h, float xo, float yo, float adv, byte[] bm) { + width=w; + height=h; + xorig=xo; + yorig=yo; + advance=adv; + bitmap=bm; + } +} diff --git a/gl4java/utils/glut/fonts/BitmapFontRec.java b/gl4java/utils/glut/fonts/BitmapFontRec.java new file mode 100644 index 0000000..f4db5d1 --- /dev/null +++ b/gl4java/utils/glut/fonts/BitmapFontRec.java @@ -0,0 +1,24 @@ +// Bitmap Font Record +// by Pontus Lidman +// based on GLUT 3.7 glutbitmap.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class BitmapFontRec { + public String name=null; + public int num_chars=0; + public int first=0; + public BitmapCharRec[] ch=null; + + public BitmapFontRec(String n,int num,int f,BitmapCharRec[] recs) { + name=n; + num_chars=num; + first=f; + ch=recs; + } +} diff --git a/gl4java/utils/glut/fonts/CoordRec.java b/gl4java/utils/glut/fonts/CoordRec.java new file mode 100644 index 0000000..cadd5c0 --- /dev/null +++ b/gl4java/utils/glut/fonts/CoordRec.java @@ -0,0 +1,19 @@ +// Coordinate Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class CoordRec { + public float x; + public float y; + public CoordRec(float x, float y) { + this.x=x; + this.y=y; + } +} diff --git a/gl4java/utils/glut/fonts/GLUTBitmapFont.java b/gl4java/utils/glut/fonts/GLUTBitmapFont.java new file mode 100644 index 0000000..37922be --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTBitmapFont.java @@ -0,0 +1,12 @@ +// Intended to be an interface for GLUT font structures +// by Pontus Lidman +// Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public interface GLUTBitmapFont { +} diff --git a/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java b/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java new file mode 100644 index 0000000..ce9ca5e --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTFuncLightImplWithFonts.java @@ -0,0 +1,300 @@ +/* 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 adverti(float)Math.sing 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.227f.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227f-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. +*/ + + +package gl4java.utils.glut.fonts; + +import gl4java.utils.glut.*; +import gl4java.utils.glut.fonts.data.*; + +import gl4java.GLFunc; +import gl4java.GLEnum; +import gl4java.GLUFunc; +import gl4java.GLUEnum; + +import java.lang.*; + +public class GLUTFuncLightImplWithFonts extends GLUTFuncLightImpl +implements GLEnum, GLUEnum +{ + public GLUTFuncLightImplWithFonts(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + public final String glutGetFontDescription(int font) + { + switch(font) { + case GLUT_STROKE_ROMAN: + return "stroke roman"; + case GLUT_STROKE_MONO_ROMAN: + return "stroke roman mono"; + case GLUT_BITMAP_9_BY_15: + return "bitmap 9x15"; + case GLUT_BITMAP_8_BY_13: + return "bitmap 8x13"; + case GLUT_BITMAP_TIMES_ROMAN_10: + return "bitmap roman 10"; + case GLUT_BITMAP_TIMES_ROMAN_24: + return "bitmap roman 24"; + case GLUT_BITMAP_HELVETICA_10: + return "bitmap helvetica 10"; + case GLUT_BITMAP_HELVETICA_12: + return "bitmap helvetica 12"; + case GLUT_BITMAP_HELVETICA_18: + return "bitmap helvetica 18"; + } + return "unknown font enumeration: "+font; + } + + private final BitmapFontRec getFontInfo(int font) { + try { + switch(font) { + case GLUT_BITMAP_HELVETICA_10: + return glutBitmapHelvetica10.getBitmapFontRec(); + case GLUT_BITMAP_HELVETICA_12: + return glutBitmapHelvetica12.getBitmapFontRec(); + case GLUT_BITMAP_HELVETICA_18: + return glutBitmapHelvetica12.getBitmapFontRec(); + case GLUT_BITMAP_8_BY_13: + return glutBitmap8By13.getBitmapFontRec(); + case GLUT_BITMAP_9_BY_15: + return glutBitmap9By15.getBitmapFontRec(); + case GLUT_BITMAP_TIMES_ROMAN_10: + return glutBitmapTimesRoman10.getBitmapFontRec(); + case GLUT_BITMAP_TIMES_ROMAN_24: + return glutBitmapTimesRoman24.getBitmapFontRec(); + } + } catch (Exception ex) { + System.out.println("Font not supported: "+ glutGetFontDescription(font)); + } + return null; + } + + private final StrokeFontRec getStrokeFontInfo(int font) { + try { + switch(font) { + case GLUT_STROKE_MONO_ROMAN: + return glutStrokeMonoRoman.getStrokeFontRec(); + case GLUT_STROKE_ROMAN: + return glutStrokeRoman.getStrokeFontRec(); + } + } catch (Exception ex) { + System.out.println("Font not supported: "+ glutGetFontDescription(font)); + } + return null; + } + + public final void glutBitmapString(int font, String s) + { + BitmapCharRec ch; + BitmapFontRec fontinfo; + + int[] swapbytes=new int[1]; + int[] lsbfirst=new int[1]; + int[] rowlength=new int[1]; + int[] skiprows=new int[1]; + int[] skippixels=new int[1]; + int[] alignment=new int[1]; + + fontinfo=getFontInfo(font); + + byte[] bytes=s.getBytes(); + int character; + + /* Save current modes. */ + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, skippixels); + gl.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. */ + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); // GL_FALSE + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 0); // GL_FALSE + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + for (int i=0; i= fontinfo.first + fontinfo.num_chars) + continue; + ch = fontinfo.ch[character - fontinfo.first]; + if (ch == null) continue; + + gl.glBitmap(ch.width, ch.height, ch.xorig, ch.yorig, + ch.advance, 0, ch.bitmap); + } + /* Restore saved modes. */ + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, alignment[0]); + } + + public final int glutBitmapWidth(int font, int character) + { + + BitmapFontRec fontinfo; + BitmapCharRec ch; + + fontinfo = getFontInfo(font); + + if ((character < fontinfo.first) || (character >= fontinfo.first + fontinfo.num_chars)) + return 0; + ch = fontinfo.ch[character - fontinfo.first]; + if (ch != null) + return (int) ch.advance; + else + return 0; + } + + public final void glutStrokeString(int font, String s) + { + StrokeCharRec ch; + StrokeRec stroke; + CoordRec coord; + StrokeFontRec fontinfo; + int i, j, k, c; + byte[] bytes=s.getBytes(); + + fontinfo = getStrokeFontInfo(font); + + for (i=0; i= fontinfo.num_chars) + continue; + ch = fontinfo.ch[c]; + if (ch == null) continue; + for (j=0; j< ch.num_strokes; j++) { + stroke=ch.stroke[j]; + gl.glBegin(GL_LINE_STRIP); + for (k = 0; k< stroke.num_coords; k++) { + coord = stroke.coord[k]; + gl.glVertex2f(coord.x, coord.y); + } + gl.glEnd(); + } + gl.glTranslatef(ch.right, (float) 0.0, (float) 0.0); + } + } + + + public final int glutStrokeWidth(int font, int character) + + { + + StrokeFontRec fontinfo; + StrokeCharRec ch; + + fontinfo = getStrokeFontInfo(font); + + if (character < 0 || character >= fontinfo.num_chars) + return 0; + ch = fontinfo.ch[character]; + if (ch != null) + return (int) ch.right; + else + return 0; + } + + public final int glutBitmapLength(int font, String string) + { + int c; + int length; + int i; + BitmapFontRec fontinfo; + BitmapCharRec ch; + byte[] bytestring=string.getBytes(); + + fontinfo = getFontInfo(font); + + length = 0; + for (i=0; i= fontinfo.first) && (c < fontinfo.first + fontinfo.num_chars)) { + ch = fontinfo.ch[c - fontinfo.first]; + if (ch != null) + length += ch.advance; + } + } + return length; + } + + public final int glutStrokeLength(int font, String string) + { + int c, length; + StrokeFontRec fontinfo; + StrokeCharRec ch; + byte[] bytestring=string.getBytes(); + + fontinfo=getStrokeFontInfo(font); + + length = 0; + for (int i=0; i= 0 && c < fontinfo.num_chars) { + ch = fontinfo.ch[c]; + if (ch != null) + length += ch.right; + } + } + return length; + } +} + + + + diff --git a/gl4java/utils/glut/fonts/GLUTStrokeFont.java b/gl4java/utils/glut/fonts/GLUTStrokeFont.java new file mode 100644 index 0000000..a9c9691 --- /dev/null +++ b/gl4java/utils/glut/fonts/GLUTStrokeFont.java @@ -0,0 +1,5 @@ +package gl4java.utils.glut.fonts; + +public interface GLUTStrokeFont { +} + diff --git a/gl4java/utils/glut/fonts/LICENSE.txt b/gl4java/utils/glut/fonts/LICENSE.txt new file mode 100644 index 0000000..6287344 --- /dev/null +++ b/gl4java/utils/glut/fonts/LICENSE.txt @@ -0,0 +1,28 @@ +GLUT Font Support for GL4Java ! + +Author: Pontus Lidman / MathCore (creator and original author) + and + Sven Goethel / Jausoft (changes for GL4Java packaging and little changes) +Copyright 2000: MathCore AB & LGPL (see below) + +This file/package is licensed under the terms of the LPGL (see below) +with the permission of Pontus Lidman / Mathcore - THANXS ! + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with this library; if not, write to the +Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. + +You can also check the GNU Library General Public License +in the internet at http://www.gnu.org/copyleft/lgpl.html ! + diff --git a/gl4java/utils/glut/fonts/Makefile b/gl4java/utils/glut/fonts/Makefile new file mode 100644 index 0000000..07fe919 --- /dev/null +++ b/gl4java/utils/glut/fonts/Makefile @@ -0,0 +1,110 @@ +# Makefile to generate java classes from X fonts +# (including compilation of capturexfont.c) +# by Pontus Lidman +# Copyright 2000 MathCore AB +# +# This file/package is licensed under the terms of the LPGL +# with the permission of Pontus Lidman / Mathcore ! +# + +all: cxf strokegen fonts + +cxf: capturexfont.c + gcc -g -Wall capturexfont.c -o cxf -L/usr/X11/lib -lX11 + +strokegen : strokegen.o strokelex.o + $(CC) -o $@ $(CFLAGS) strokegen.o strokelex.o + +glut_roman.c : Roman.stroke strokegen + ./strokegen -s glutStrokeRoman < Roman.stroke > $@ + +glut_mroman.c : MonoRoman.stroke strokegen + ./strokegen -s glutStrokeMonoRoman < MonoRoman.stroke > $@ + +strokegen.h strokegen.c : strokegen.y + $(YACC) -d strokegen.y + mv y.tab.c strokegen.c + mv y.tab.h strokegen.h + +strokelex.c : strokelex.l + $(LEX) strokelex.l + mv lex.yy.c strokelex.c + +fonts: data/glutBitmapHelvetica10.java \ + data/glutBitmapHelvetica12.java \ + data/glutBitmapHelvetica18.java \ + data/glutBitmapTimesRoman10.java \ + data/glutBitmapTimesRoman24.java \ + data/glutBitmap8By13.java \ + data/glutBitmap9By15.java \ + data/glutStrokeRoman.java \ + data/glutStrokeMonoRoman.java + +data/glutBitmapHelvetica12.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--12-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica12 \ + >data/glutBitmapHelvetica12.java + +data/glutBitmapHelvetica10.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--10-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica10 \ + >data/glutBitmapHelvetica10.java + +data/glutBitmapHelvetica18.java: cxf + ./cxf \ + '-adobe-helvetica-medium-r-*--18-*-*-*-p-*-iso8859-1' \ + glutBitmapHelvetica18 \ + >data/glutBitmapHelvetica18.java + +data/glutBitmapTimesRoman10.java: cxf + ./cxf \ + '-adobe-times-medium-r-*--10-*-*-*-p-*-iso8859-1' \ + glutBitmapTimesRoman10 \ + >data/glutBitmapTimesRoman10.java + +data/glutBitmapTimesRoman24.java: cxf + ./cxf \ + '-adobe-times-medium-r-*--24-*-*-*-p-*-iso8859-1' \ + glutBitmapTimesRoman24 \ + >data/glutBitmapTimesRoman24.java + +data/glutBitmap8By13.java: cxf + ./cxf \ + 8x13 \ + glutBitmap8By13 \ + >data/glutBitmap8By13.java + +data/glutBitmap9By15.java: cxf + ./cxf \ + 9x15 \ + glutBitmap9By15 \ + >data/glutBitmap9By15.java + +data/glutStrokeMonoRoman.java: strokegen + ./strokegen -s glutStrokeMonoRoman data/glutStrokeMonoRoman.java + +data/glutStrokeRoman.java: strokegen + ./strokegen -s glutStrokeRoman data/glutStrokeRoman.java + +clean: + rm -f *.o cxf strokegen \ + glut_roman.c \ + glut_mroman.c \ + strokegen.h \ + strokegen.c \ + strokelex.c + +cleanall: clean + rm -f *.class \ + data/glutBitmapHelvetica10.java \ + data/glutBitmapHelvetica12.java \ + data/glutBitmapHelvetica18.java \ + data/glutBitmapTimesRoman10.java \ + data/glutBitmapTimesRoman24.java \ + data/glutBitmap8By13.java \ + data/glutBitmap9By15.java \ + data/glutStrokeRoman.java \ + data/glutStrokeMonoRoman.java + diff --git a/gl4java/utils/glut/fonts/MonoRoman.stroke b/gl4java/utils/glut/fonts/MonoRoman.stroke new file mode 100644 index 0000000..5bd84f7 --- /dev/null +++ b/gl4java/utils/glut/fonts/MonoRoman.stroke @@ -0,0 +1,503 @@ +## +# $XConsortium: Roman_M.src,v 5.2 91/07/21 16:42:40 rws Exp $ +## +## 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. + +# Mono-spaced version of Roman Simplex font. + + FONTNAME Roman + TOP 119.0476 + BOTTOM -33.3333 + NUM_CH 128 + PROPERTIES 3 + + (CHARSET_REGISTRY ISO8859) + (CHARSET_ENCODING "1") + (SPACING M) + +INDEX 32 STROKE 0 CENTER 52.3810 RIGHT 104.7619 +INDEX 33 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 33.3333) + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 34 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (33.3334 100.0000) (33.3334 66.6667) + OPEN 2 (71.4286 100.0000) (71.4286 66.6667) +INDEX 35 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (54.7619 119.0476) (21.4286 -33.3333) + OPEN 2 (83.3334 119.0476) (50.0000 -33.3333) + OPEN 2 (21.4286 57.1429) (88.0952 57.1429) + OPEN 2 (16.6667 28.5714) (83.3334 28.5714) +INDEX 36 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (42.8571 119.0476) (42.8571 -19.0476) + OPEN 2 (61.9047 119.0476) (61.9047 -19.0476) + OPEN 20 (85.7143 85.7143) (76.1905 95.2381) (61.9047 100.0000) + (42.8571 100.0000) (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.6190) + (76.1905 42.8571) (80.9524 38.0952) (85.7143 28.5714) (85.7143 14.2857) + (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (19.0476 14.2857) +INDEX 37 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (95.2381 100.0000) (9.5238 0.0000) + OPEN 16 (33.3333 100.0000) (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.0000) (33.3333 100.0000) + (42.8571 95.2381) (57.1428 90.4762) (71.4286 90.4762) (85.7143 95.2381) + (95.2381 100.0000) + OPEN 11 (76.1905 33.3333) (66.6667 28.5714) (61.9048 19.0476) + (61.9048 9.5238) (71.4286 0.0000) (80.9524 0.0000) (90.4762 4.7619) + (95.2381 14.2857) (95.2381 23.8095) (85.7143 33.3333) (76.1905 33.3333) +INDEX 38 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 34 (100.0000 57.1429) (100.0000 61.9048) (95.2381 66.6667) + (90.4762 66.6667) (85.7143 61.9048) (80.9524 52.3810) (71.4286 28.5714) + (61.9048 14.2857) (52.3809 4.7619) (42.8571 0.0000) (23.8095 0.0000) + (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.6190 61.9048) (52.3809 66.6667) + (57.1429 76.1905) (57.1429 85.7143) (52.3809 95.2381) (42.8571 100.0000) + (33.3333 95.2381) (28.5714 85.7143) (28.5714 76.1905) (33.3333 61.9048) + (42.8571 47.6190) (66.6667 14.2857) (76.1905 4.7619) (85.7143 0.0000) + (95.2381 0.0000) (100.0000 4.7619) (100.0000 9.5238) +INDEX 39 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 66.6667) +INDEX 40 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (69.0476 119.0476) (59.5238 109.5238) (50.0000 95.2381) + (40.4762 76.1905) (35.7143 52.3810) (35.7143 33.3333) (40.4762 9.5238) + (50.0000 -9.5238) (59.5238 -23.8095) (69.0476 -33.3333) +INDEX 41 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (35.7143 119.0476) (45.2381 109.5238) (54.7619 95.2381) + (64.2857 76.1905) (69.0476 52.3810) (69.0476 33.3333) (64.2857 9.5238) + (54.7619 -9.5238) (45.2381 -23.8095) (35.7143 -33.3333) +INDEX 42 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 71.4286) (52.3810 14.2857) + OPEN 2 (28.5715 57.1429) (76.1905 28.5714) + OPEN 2 (76.1905 57.1429) (28.5715 28.5714) +INDEX 43 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 85.7143) (52.3809 0.0000) + OPEN 2 (9.5238 42.8571) (95.2381 42.8571) +INDEX 44 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 8 (57.1429 4.7619) (52.3810 0.0000) (47.6191 4.7619) + (52.3810 9.5238) (57.1429 4.7619) (57.1429 -4.7619) (52.3810 -14.2857) + (47.6191 -19.0476) +INDEX 45 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (9.5238 42.8571) (95.2381 42.8571) +INDEX 46 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 47 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 -14.2857) (85.7143 100.0000) +INDEX 48 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (47.6190 100.0000) (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.6190 0.0000) (57.1428 0.0000) (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.0000) (47.6190 100.0000) +INDEX 49 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 4 (40.4762 80.9524) (50.0000 85.7143) (64.2857 100.0000) + (64.2857 0.0000) +INDEX 50 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (23.8095 76.1905) (23.8095 80.9524) (28.5714 90.4762) + (33.3333 95.2381) (42.8571 100.0000) (61.9047 100.0000) (71.4286 95.2381) + (76.1905 90.4762) (80.9524 80.9524) (80.9524 71.4286) (76.1905 61.9048) + (66.6666 47.6190) (19.0476 0.0000) (85.7143 0.0000) +INDEX 51 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 15 (28.5714 100.0000) (80.9524 100.0000) (52.3809 61.9048) + (66.6666 61.9048) (76.1905 57.1429) (80.9524 52.3810) (85.7143 38.0952) + (85.7143 28.5714) (80.9524 14.2857) (71.4286 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (28.5714 4.7619) (23.8095 9.5238) (19.0476 19.0476) +INDEX 52 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (64.2857 100.0000) (16.6667 33.3333) (88.0952 33.3333) + OPEN 2 (64.2857 100.0000) (64.2857 0.0000) +INDEX 53 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (76.1905 100.0000) (28.5714 100.0000) (23.8095 57.1429) + (28.5714 61.9048) (42.8571 66.6667) (57.1428 66.6667) (71.4286 61.9048) + (80.9524 52.3810) (85.7143 38.0952) (85.7143 28.5714) (80.9524 14.2857) + (71.4286 4.7619) (57.1428 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (23.8095 9.5238) (19.0476 19.0476) +INDEX 54 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 23 (78.5714 85.7143) (73.8096 95.2381) (59.5238 100.0000) + (50.0000 100.0000) (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.0000 0.0000) + (54.7619 0.0000) (69.0476 4.7619) (78.5714 14.2857) (83.3334 28.5714) + (83.3334 33.3333) (78.5714 47.6190) (69.0476 57.1429) (54.7619 61.9048) + (50.0000 61.9048) (35.7143 57.1429) (26.1905 47.6190) (21.4286 33.3333) +INDEX 55 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (85.7143 100.0000) (38.0952 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) +INDEX 56 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 29 (42.8571 100.0000) (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.3810) (80.9524 42.8571) (85.7143 33.3333) (85.7143 19.0476) + (80.9524 9.5238) (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) + (28.5714 4.7619) (23.8095 9.5238) (19.0476 19.0476) (19.0476 33.3333) + (23.8095 42.8571) (33.3333 52.3810) (47.6190 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.0000) (42.8571 100.0000) +INDEX 57 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 23 (83.3334 66.6667) (78.5714 52.3810) (69.0476 42.8571) + (54.7619 38.0952) (50.0000 38.0952) (35.7143 42.8571) (26.1905 52.3810) + (21.4286 66.6667) (21.4286 71.4286) (26.1905 85.7143) (35.7143 95.2381) + (50.0000 100.0000) (54.7619 100.0000) (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.0000) (45.2381 0.0000) (30.9524 4.7619) (26.1905 14.2857) +INDEX 58 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 66.6667) (47.6191 61.9048) (52.3810 57.1429) + (57.1429 61.9048) (52.3810 66.6667) + OPEN 5 (52.3810 9.5238) (47.6191 4.7619) (52.3810 0.0000) + (57.1429 4.7619) (52.3810 9.5238) +INDEX 59 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (52.3810 66.6667) (47.6191 61.9048) (52.3810 57.1429) + (57.1429 61.9048) (52.3810 66.6667) + OPEN 8 (57.1429 4.7619) (52.3810 0.0000) (47.6191 4.7619) + (52.3810 9.5238) (57.1429 4.7619) (57.1429 -4.7619) (52.3810 -14.2857) + (47.6191 -19.0476) +INDEX 60 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (90.4762 85.7143) (14.2857 42.8571) (90.4762 0.0000) +INDEX 61 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (9.5238 57.1429) (95.2381 57.1429) + OPEN 2 (9.5238 28.5714) (95.2381 28.5714) +INDEX 62 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (14.2857 85.7143) (90.4762 42.8571) (14.2857 0.0000) +INDEX 63 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (23.8095 76.1905) (23.8095 80.9524) (28.5714 90.4762) + (33.3333 95.2381) (42.8571 100.0000) (61.9047 100.0000) (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.6190) (52.3809 33.3333) + OPEN 5 (52.3809 9.5238) (47.6190 4.7619) (52.3809 0.0000) + (57.1428 4.7619) (52.3809 9.5238) +INDEX 64 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 8 (64.2857 52.3810) (54.7619 57.1429) (45.2381 57.1429) + (40.4762 47.6190) (40.4762 42.8571) (45.2381 33.3333) (54.7619 33.3333) + (64.2857 38.0952) + OPEN 19 (64.2857 57.1429) (64.2857 38.0952) (69.0476 33.3333) + (78.5714 33.3333) (83.3334 42.8571) (83.3334 47.6190) (78.5714 61.9048) + (69.0476 71.4286) (54.7619 76.1905) (50.0000 76.1905) (35.7143 71.4286) + (26.1905 61.9048) (21.4286 47.6190) (21.4286 42.8571) (26.1905 28.5714) + (35.7143 19.0476) (50.0000 14.2857) (54.7619 14.2857) (69.0476 19.0476) +INDEX 65 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 100.0000) (14.2857 0.0000) + OPEN 2 (52.3809 100.0000) (90.4762 0.0000) + OPEN 2 (28.5714 33.3333) (76.1905 33.3333) +INDEX 66 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 9 (19.0476 100.0000) (61.9047 100.0000) (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.3810) + OPEN 10 (19.0476 52.3810) (61.9047 52.3810) (76.1905 47.6190) + (80.9524 42.8571) (85.7143 33.3333) (85.7143 19.0476) (80.9524 9.5238) + (76.1905 4.7619) (61.9047 0.0000) (19.0476 0.0000) +INDEX 67 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 18 (88.0952 76.1905) (83.3334 85.7143) (73.8096 95.2381) + (64.2857 100.0000) (45.2381 100.0000) (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.0000) (64.2857 0.0000) + (73.8096 4.7619) (83.3334 14.2857) (88.0952 23.8095) +INDEX 68 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 12 (19.0476 100.0000) (52.3809 100.0000) (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.0000) + (19.0476 0.0000) +INDEX 69 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (21.4286 100.0000) (21.4286 0.0000) + OPEN 2 (21.4286 100.0000) (83.3334 100.0000) + OPEN 2 (21.4286 52.3810) (59.5238 52.3810) + OPEN 2 (21.4286 0.0000) (83.3334 0.0000) +INDEX 70 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (21.4286 100.0000) (21.4286 0.0000) + OPEN 2 (21.4286 100.0000) (83.3334 100.0000) + OPEN 2 (21.4286 52.3810) (59.5238 52.3810) +INDEX 71 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 19 (88.0952 76.1905) (83.3334 85.7143) (73.8096 95.2381) + (64.2857 100.0000) (45.2381 100.0000) (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.0000) (64.2857 0.0000) + (73.8096 4.7619) (83.3334 14.2857) (88.0952 23.8095) (88.0952 38.0952) + OPEN 2 (64.2857 38.0952) (88.0952 38.0952) +INDEX 72 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (85.7143 100.0000) (85.7143 0.0000) + OPEN 2 (19.0476 52.3810) (85.7143 52.3810) +INDEX 73 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 0.0000) +INDEX 74 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (76.1905 100.0000) (76.1905 23.8095) (71.4286 9.5238) + (66.6667 4.7619) (57.1429 0.0000) (47.6191 0.0000) (38.0953 4.7619) + (33.3334 9.5238) (28.5715 23.8095) (28.5715 33.3333) +INDEX 75 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (85.7143 100.0000) (19.0476 33.3333) + OPEN 2 (42.8571 57.1429) (85.7143 0.0000) +INDEX 76 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 100.0000) (23.8095 0.0000) + OPEN 2 (23.8095 0.0000) (80.9524 0.0000) +INDEX 77 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 100.0000) (14.2857 0.0000) + OPEN 2 (14.2857 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (90.4762 0.0000) +INDEX 78 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 0.0000) + OPEN 2 (85.7143 100.0000) (85.7143 0.0000) +INDEX 79 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 21 (42.8571 100.0000) (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.0000) (61.9047 0.0000) + (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.0000) (42.8571 100.0000) +INDEX 80 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 10 (19.0476 100.0000) (61.9047 100.0000) (76.1905 95.2381) + (80.9524 90.4762) (85.7143 80.9524) (85.7143 66.6667) (80.9524 57.1429) + (76.1905 52.3810) (61.9047 47.6190) (19.0476 47.6190) +INDEX 81 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 21 (42.8571 100.0000) (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.0000) (61.9047 0.0000) + (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.0000) (42.8571 100.0000) + OPEN 2 (57.1428 19.0476) (85.7143 -9.5238) +INDEX 82 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (19.0476 0.0000) + OPEN 10 (19.0476 100.0000) (61.9047 100.0000) (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.3810) (19.0476 52.3810) + OPEN 2 (52.3809 52.3810) (85.7143 0.0000) +INDEX 83 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 20 (85.7143 85.7143) (76.1905 95.2381) (61.9047 100.0000) + (42.8571 100.0000) (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.6190) + (76.1905 42.8571) (80.9524 38.0952) (85.7143 28.5714) (85.7143 14.2857) + (76.1905 4.7619) (61.9047 0.0000) (42.8571 0.0000) (28.5714 4.7619) + (19.0476 14.2857) +INDEX 84 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 100.0000) (52.3809 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) +INDEX 85 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (19.0476 100.0000) (19.0476 28.5714) (23.8095 14.2857) + (33.3333 4.7619) (47.6190 0.0000) (57.1428 0.0000) (71.4286 4.7619) + (80.9524 14.2857) (85.7143 28.5714) (85.7143 100.0000) +INDEX 86 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 100.0000) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 0.0000) +INDEX 87 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (4.7619 100.0000) (28.5714 0.0000) + OPEN 2 (52.3809 100.0000) (28.5714 0.0000) + OPEN 2 (52.3809 100.0000) (76.1905 0.0000) + OPEN 2 (100.0000 100.0000) (76.1905 0.0000) +INDEX 88 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (85.7143 0.0000) + OPEN 2 (85.7143 100.0000) (19.0476 0.0000) +INDEX 89 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 3 (14.2857 100.0000) (52.3809 52.3810) (52.3809 0.0000) + OPEN 2 (90.4762 100.0000) (52.3809 52.3810) +INDEX 90 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (85.7143 100.0000) (19.0476 0.0000) + OPEN 2 (19.0476 100.0000) (85.7143 100.0000) + OPEN 2 (19.0476 0.0000) (85.7143 0.0000) +INDEX 91 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (35.7143 119.0476) (35.7143 -33.3333) + OPEN 2 (40.4762 119.0476) (40.4762 -33.3333) + OPEN 2 (35.7143 119.0476) (69.0476 119.0476) + OPEN 2 (35.7143 -33.3333) (69.0476 -33.3333) +INDEX 92 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (19.0476 100.0000) (85.7143 -14.2857) +INDEX 93 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (64.2857 119.0476) (64.2857 -33.3333) + OPEN 2 (69.0476 119.0476) (69.0476 -33.3333) + OPEN 2 (35.7143 119.0476) (69.0476 119.0476) + OPEN 2 (35.7143 -33.3333) (69.0476 -33.3333) +INDEX 94 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3809 109.5238) (14.2857 42.8571) + OPEN 2 (52.3809 109.5238) (90.4762 42.8571) +INDEX 95 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (0.0000 -33.3333) (104.7619 -33.3333) (104.7619 -28.5714) + (0.0000 -28.5714) (0.0000 -33.3333) +INDEX 96 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (42.8572 100.0000) (66.6667 71.4286) + OPEN 3 (42.8572 100.0000) (38.0953 95.2381) (66.6667 71.4286) +INDEX 97 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 66.6667) (80.9524 0.0000) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 98 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 100.0000) (23.8095 0.0000) + OPEN 14 (23.8095 52.3810) (33.3333 61.9048) (42.8571 66.6667) + (57.1428 66.6667) (66.6666 61.9048) (76.1905 52.3810) (80.9524 38.0952) + (80.9524 28.5714) (76.1905 14.2857) (66.6666 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (33.3333 4.7619) (23.8095 14.2857) +INDEX 99 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 100 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 100.0000) (80.9524 0.0000) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 101 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (23.8095 38.0952) (80.9524 38.0952) (80.9524 47.6190) + (76.1905 57.1429) (71.4285 61.9048) (61.9047 66.6667) (47.6190 66.6667) + (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) (23.8095 28.5714) + (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) (61.9047 0.0000) + (71.4285 4.7619) (80.9524 14.2857) +INDEX 102 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (71.4286 100.0000) (61.9048 100.0000) (52.3810 95.2381) + (47.6191 80.9524) (47.6191 0.0000) + OPEN 2 (33.3334 66.6667) (66.6667 66.6667) +INDEX 103 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 7 (80.9524 66.6667) (80.9524 -9.5238) (76.1905 -23.8095) + (71.4285 -28.5714) (61.9047 -33.3333) (47.6190 -33.3333) (38.0952 -28.5714) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 104 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 100.0000) (26.1905 0.0000) + OPEN 7 (26.1905 47.6190) (40.4762 61.9048) (50.0000 66.6667) + (64.2857 66.6667) (73.8095 61.9048) (78.5715 47.6190) (78.5715 0.0000) +INDEX 105 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (47.6191 100.0000) (52.3810 95.2381) (57.1429 100.0000) + (52.3810 104.7619) (47.6191 100.0000) + OPEN 2 (52.3810 66.6667) (52.3810 0.0000) +INDEX 106 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (57.1429 100.0000) (61.9048 95.2381) (66.6667 100.0000) + (61.9048 104.7619) (57.1429 100.0000) + OPEN 5 (61.9048 66.6667) (61.9048 -14.2857) (57.1429 -28.5714) + (47.6191 -33.3333) (38.0953 -33.3333) +INDEX 107 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 100.0000) (26.1905 0.0000) + OPEN 2 (73.8095 66.6667) (26.1905 19.0476) + OPEN 2 (45.2381 38.0952) (78.5715 0.0000) +INDEX 108 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 100.0000) (52.3810 0.0000) +INDEX 109 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) + OPEN 7 (52.3810 47.6190) (66.6667 61.9048) (76.1905 66.6667) + (90.4762 66.6667) (100.0000 61.9048) (104.7619 47.6190) (104.7619 0.0000) +INDEX 110 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (26.1905 0.0000) + OPEN 7 (26.1905 47.6190) (40.4762 61.9048) (50.0000 66.6667) + (64.2857 66.6667) (73.8095 61.9048) (78.5715 47.6190) (78.5715 0.0000) +INDEX 111 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (45.2381 66.6667) (35.7143 61.9048) (26.1905 52.3810) + (21.4286 38.0952) (21.4286 28.5714) (26.1905 14.2857) (35.7143 4.7619) + (45.2381 0.0000) (59.5238 0.0000) (69.0476 4.7619) (78.5714 14.2857) + (83.3334 28.5714) (83.3334 38.0952) (78.5714 52.3810) (69.0476 61.9048) + (59.5238 66.6667) (45.2381 66.6667) +INDEX 112 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 66.6667) (23.8095 -33.3333) + OPEN 14 (23.8095 52.3810) (33.3333 61.9048) (42.8571 66.6667) + (57.1428 66.6667) (66.6666 61.9048) (76.1905 52.3810) (80.9524 38.0952) + (80.9524 28.5714) (76.1905 14.2857) (66.6666 4.7619) (57.1428 0.0000) + (42.8571 0.0000) (33.3333 4.7619) (23.8095 14.2857) +INDEX 113 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (80.9524 66.6667) (80.9524 -33.3333) + OPEN 14 (80.9524 52.3810) (71.4285 61.9048) (61.9047 66.6667) + (47.6190 66.6667) (38.0952 61.9048) (28.5714 52.3810) (23.8095 38.0952) + (23.8095 28.5714) (28.5714 14.2857) (38.0952 4.7619) (47.6190 0.0000) + (61.9047 0.0000) (71.4285 4.7619) (80.9524 14.2857) +INDEX 114 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (33.3334 66.6667) (33.3334 0.0000) + OPEN 5 (33.3334 38.0952) (38.0953 52.3810) (47.6191 61.9048) + (57.1429 66.6667) (71.4286 66.6667) +INDEX 115 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 17 (78.5715 52.3810) (73.8095 61.9048) (59.5238 66.6667) + (45.2381 66.6667) (30.9524 61.9048) (26.1905 52.3810) (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.0000) (45.2381 0.0000) + (30.9524 4.7619) (26.1905 14.2857) +INDEX 116 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (47.6191 100.0000) (47.6191 19.0476) (52.3810 4.7619) + (61.9048 0.0000) (71.4286 0.0000) + OPEN 2 (33.3334 66.6667) (66.6667 66.6667) +INDEX 117 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 7 (26.1905 66.6667) (26.1905 19.0476) (30.9524 4.7619) + (40.4762 0.0000) (54.7619 0.0000) (64.2857 4.7619) (78.5715 19.0476) + OPEN 2 (78.5715 66.6667) (78.5715 0.0000) +INDEX 118 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (23.8095 66.6667) (52.3809 0.0000) + OPEN 2 (80.9524 66.6667) (52.3809 0.0000) +INDEX 119 STROKE 4 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (14.2857 66.6667) (33.3333 0.0000) + OPEN 2 (52.3809 66.6667) (33.3333 0.0000) + OPEN 2 (52.3809 66.6667) (71.4286 0.0000) + OPEN 2 (90.4762 66.6667) (71.4286 0.0000) +INDEX 120 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (78.5715 0.0000) + OPEN 2 (78.5715 66.6667) (26.1905 0.0000) +INDEX 121 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (26.1905 66.6667) (54.7619 0.0000) + OPEN 6 (83.3334 66.6667) (54.7619 0.0000) (45.2381 -19.0476) + (35.7143 -28.5714) (26.1905 -33.3333) (21.4286 -33.3333) +INDEX 122 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (78.5715 66.6667) (26.1905 0.0000) + OPEN 2 (26.1905 66.6667) (78.5715 66.6667) + OPEN 2 (26.1905 0.0000) (78.5715 0.0000) +INDEX 123 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (64.2857 119.0476) (54.7619 114.2857) (50.0000 109.5238) + (45.2381 100.0000) (45.2381 90.4762) (50.0000 80.9524) (54.7619 76.1905) + (59.5238 66.6667) (59.5238 57.1429) (50.0000 47.6190) + OPEN 17 (54.7619 114.2857) (50.0000 104.7619) (50.0000 95.2381) + (54.7619 85.7143) (59.5238 80.9524) (64.2857 71.4286) (64.2857 61.9048) + (59.5238 52.3810) (40.4762 42.8571) (59.5238 33.3333) (64.2857 23.8095) + (64.2857 14.2857) (59.5238 4.7619) (54.7619 0.0000) (50.0000 -9.5238) + (50.0000 -19.0476) (54.7619 -28.5714) + OPEN 10 (50.0000 38.0952) (59.5238 28.5714) (59.5238 19.0476) + (54.7619 9.5238) (50.0000 4.7619) (45.2381 -4.7619) (45.2381 -14.2857) + (50.0000 -23.8095) (54.7619 -28.5714) (64.2857 -33.3333) +INDEX 124 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (52.3810 119.0476) (52.3810 -33.3333) +INDEX 125 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 10 (40.4762 119.0476) (50.0000 114.2857) (54.7619 109.5238) + (59.5238 100.0000) (59.5238 90.4762) (54.7619 80.9524) (50.0000 76.1905) + (45.2381 66.6667) (45.2381 57.1429) (54.7619 47.6190) + OPEN 17 (50.0000 114.2857) (54.7619 104.7619) (54.7619 95.2381) + (50.0000 85.7143) (45.2381 80.9524) (40.4762 71.4286) (40.4762 61.9048) + (45.2381 52.3810) (64.2857 42.8571) (45.2381 33.3333) (40.4762 23.8095) + (40.4762 14.2857) (45.2381 4.7619) (50.0000 0.0000) (54.7619 -9.5238) + (54.7619 -19.0476) (50.0000 -28.5714) + OPEN 10 (54.7619 38.0952) (45.2381 28.5714) (45.2381 19.0476) + (50.0000 9.5238) (54.7619 4.7619) (59.5238 -4.7619) (59.5238 -14.2857) + (54.7619 -23.8095) (50.0000 -28.5714) (40.4762 -33.3333) +INDEX 126 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 11 (9.5238 28.5714) (9.5238 38.0952) (14.2857 52.3810) + (23.8095 57.1429) (33.3333 57.1429) (42.8571 52.3810) (61.9048 38.0952) + (71.4286 33.3333) (80.9524 33.3333) (90.4762 38.0952) (95.2381 47.6190) + OPEN 11 (9.5238 38.0952) (14.2857 47.6190) (23.8095 52.3810) + (33.3333 52.3810) (42.8571 47.6190) (61.9048 33.3333) (71.4286 28.5714) + (80.9524 28.5714) (90.4762 33.3333) (95.2381 47.6190) (95.2381 57.1429) +INDEX 127 STROKE 2 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (71.4286 100.0000) (33.3333 -33.3333) + OPEN 17 (47.6190 66.6667) (33.3333 61.9048) (23.8095 52.3810) + (19.0476 38.0952) (19.0476 23.8095) (23.8095 14.2857) (33.3333 4.7619) + (47.6190 0.0000) (57.1428 0.0000) (71.4286 4.7619) (80.9524 14.2857) + (85.7143 28.5714) (85.7143 42.8571) (80.9524 52.3810) (71.4286 61.9048) + (57.1428 66.6667) (47.6190 66.6667) diff --git a/gl4java/utils/glut/fonts/Roman.stroke b/gl4java/utils/glut/fonts/Roman.stroke new file mode 100644 index 0000000..d04e957 --- /dev/null +++ b/gl4java/utils/glut/fonts/Roman.stroke @@ -0,0 +1,604 @@ +## +# $XConsortium: Roman.src,v 5.2 91/07/21 16:42:23 rws Exp $ +## +## 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. + +# Roman Simplex font. + + FONTNAME Roman + TOP 119.0476 + BOTTOM -33.3333 + NUM_CH 128 + PROPERTIES 3 + + (CHARSET_REGISTRY ISO8859) + (CHARSET_ENCODING "1") + (SPACING P) + +INDEX 32 STROKE 0 CENTER 52.3810 RIGHT 104.7619 +INDEX 33 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 2 (4.7619 100.0000) (4.7619 33.3333) + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 34 STROKE 2 CENTER 19.0476 RIGHT 38.0952 + OPEN 2 (0.0000 100.0000) (0.0000 66.6667) + OPEN 2 (38.0952 100.0000) (38.0952 66.6667) +INDEX 35 STROKE 4 CENTER 33.3333 RIGHT 71.4286 + OPEN 2 (38.0952 119.0476) (4.7619 -33.3333) + OPEN 2 (66.6667 119.0476) (33.3333 -33.3333) + OPEN 2 (4.7619 57.1429) (71.4286 57.1429) + OPEN 2 (0.0000 28.5714) (66.6667 28.5714) +INDEX 36 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (23.8095 119.0476) (23.8095 -19.0476) + OPEN 2 (42.8571 119.0476) (42.8571 -19.0476) + OPEN 20 (66.6667 85.7143) (57.1429 95.2381) (42.8571 100.0000) + (23.8095 100.0000) (9.5238 95.2381) (0.0000 85.7143) (0.0000 76.1905) + (4.7619 66.6667) (9.5238 61.9048) (19.0476 57.1429) (47.6190 47.6190) + (57.1429 42.8571) (61.9048 38.0952) (66.6667 28.5714) (66.6667 14.2857) + (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (0.0000 14.2857) +INDEX 37 STROKE 3 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (85.7143 100.0000) (0.0000 0.0000) + OPEN 16 (23.8095 100.0000) (33.3333 90.4762) (33.3333 80.9524) + (28.5714 71.4286) (19.0476 66.6667) (9.5238 66.6667) (0.0000 76.1905) + (0.0000 85.7143) (4.7619 95.2381) (14.2857 100.0000) (23.8095 100.0000) + (33.3333 95.2381) (47.6190 90.4762) (61.9048 90.4762) (76.1905 95.2381) + (85.7143 100.0000) + OPEN 11 (66.6667 33.3333) (57.1429 28.5714) (52.3810 19.0476) + (52.3810 9.5238) (61.9048 0.0000) (71.4286 0.0000) (80.9524 4.7619) + (85.7143 14.2857) (85.7143 23.8095) (76.1905 33.3333) (66.6667 33.3333) +INDEX 38 STROKE 1 CENTER 47.6190 RIGHT 95.2381 + OPEN 34 (95.2381 57.1429) (95.2381 61.9048) (90.4762 66.6667) + (85.7143 66.6667) (80.9524 61.9048) (76.1905 52.3810) (66.6667 28.5714) + (57.1429 14.2857) (47.6190 4.7619) (38.0952 0.0000) (19.0476 0.0000) + (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) (0.0000 28.5714) + (4.7619 38.0952) (9.5238 42.8571) (42.8571 61.9048) (47.6190 66.6667) + (52.3810 76.1905) (52.3810 85.7143) (47.6190 95.2381) (38.0952 100.0000) + (28.5714 95.2381) (23.8095 85.7143) (23.8095 76.1905) (28.5714 61.9048) + (38.0952 47.6190) (61.9048 14.2857) (71.4286 4.7619) (80.9524 0.0000) + (90.4762 0.0000) (95.2381 4.7619) (95.2381 9.5238) +INDEX 39 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 66.6667) +INDEX 40 STROKE 1 CENTER 14.2857 RIGHT 33.3333 + OPEN 10 (33.3333 119.0476) (23.8095 109.5238) (14.2857 95.2381) + (4.7619 76.1905) (0.0000 52.3810) (0.0000 33.3333) (4.7619 9.5238) + (14.2857 -9.5238) (23.8095 -23.8095) (33.3333 -33.3333) +INDEX 41 STROKE 1 CENTER 19.0476 RIGHT 33.3333 + OPEN 10 (0.0000 119.0476) (9.5238 109.5238) (19.0476 95.2381) + (28.5714 76.1905) (33.3333 52.3810) (33.3333 33.3333) (28.5714 9.5238) + (19.0476 -9.5238) (9.5238 -23.8095) (0.0000 -33.3333) +INDEX 42 STROKE 3 CENTER 23.8095 RIGHT 47.6190 + OPEN 2 (23.8095 71.4286) (23.8095 14.2857) + OPEN 2 (0.0000 57.1429) (47.6190 28.5714) + OPEN 2 (47.6190 57.1429) (0.0000 28.5714) +INDEX 43 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (42.8571 85.7143) (42.8571 0.0000) + OPEN 2 (0.0000 42.8571) (85.7143 42.8571) +INDEX 44 STROKE 1 CENTER 4.7619 RIGHT 9.5238 + OPEN 8 (9.5238 4.7619) (4.7619 0.0000) (0.0000 4.7619) + (4.7619 9.5238) (9.5238 4.7619) (9.5238 -4.7619) (4.7619 -14.2857) + (0.0000 -19.0476) +INDEX 45 STROKE 1 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (0.0000 42.8571) (85.7143 42.8571) +INDEX 46 STROKE 1 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 47 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 -14.2857) (66.6667 100.0000) +INDEX 48 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 17 (28.5714 100.0000) (14.2857 95.2381) (4.7619 80.9524) + (0.0000 57.1429) (0.0000 42.8571) (4.7619 19.0476) (14.2857 4.7619) + (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) (61.9048 19.0476) + (66.6667 42.8571) (66.6667 57.1429) (61.9048 80.9524) (52.3810 95.2381) + (38.0952 100.0000) (28.5714 100.0000) +INDEX 49 STROKE 1 CENTER 19.0476 RIGHT 23.8095 + OPEN 4 (0.0000 80.9524) (9.5238 85.7143) (23.8095 100.0000) + (23.8095 0.0000) +INDEX 50 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 14 (4.7619 76.1905) (4.7619 80.9524) (9.5238 90.4762) + (14.2857 95.2381) (23.8095 100.0000) (42.8571 100.0000) (52.3810 95.2381) + (57.1429 90.4762) (61.9048 80.9524) (61.9048 71.4286) (57.1429 61.9048) + (47.6190 47.6190) (0.0000 0.0000) (66.6667 0.0000) +INDEX 51 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 15 (9.5238 100.0000) (61.9048 100.0000) (33.3333 61.9048) + (47.6190 61.9048) (57.1429 57.1429) (61.9048 52.3810) (66.6667 38.0952) + (66.6667 28.5714) (61.9048 14.2857) (52.3810 4.7619) (38.0952 0.0000) + (23.8095 0.0000) (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) +INDEX 52 STROKE 2 CENTER 33.3333 RIGHT 71.4286 + OPEN 3 (47.6190 100.0000) (0.0000 33.3333) (71.4286 33.3333) + OPEN 2 (47.6190 100.0000) (47.6190 0.0000) +INDEX 53 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 17 (57.1429 100.0000) (9.5238 100.0000) (4.7619 57.1429) + (9.5238 61.9048) (23.8095 66.6667) (38.0952 66.6667) (52.3810 61.9048) + (61.9048 52.3810) (66.6667 38.0952) (66.6667 28.5714) (61.9048 14.2857) + (52.3810 4.7619) (38.0952 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (4.7619 9.5238) (0.0000 19.0476) +INDEX 54 STROKE 1 CENTER 28.5714 RIGHT 61.9048 + OPEN 23 (57.1429 85.7143) (52.3810 95.2381) (38.0952 100.0000) + (28.5714 100.0000) (14.2857 95.2381) (4.7619 80.9524) (0.0000 57.1429) + (0.0000 33.3333) (4.7619 14.2857) (14.2857 4.7619) (28.5714 0.0000) + (33.3333 0.0000) (47.6190 4.7619) (57.1429 14.2857) (61.9048 28.5714) + (61.9048 33.3333) (57.1429 47.6190) (47.6190 57.1429) (33.3333 61.9048) + (28.5714 61.9048) (14.2857 57.1429) (4.7619 47.6190) (0.0000 33.3333) +INDEX 55 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (66.6667 100.0000) (19.0476 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) +INDEX 56 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 29 (23.8095 100.0000) (9.5238 95.2381) (4.7619 85.7143) + (4.7619 76.1905) (9.5238 66.6667) (19.0476 61.9048) (38.0952 57.1429) + (52.3810 52.3810) (61.9048 42.8571) (66.6667 33.3333) (66.6667 19.0476) + (61.9048 9.5238) (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) + (9.5238 4.7619) (4.7619 9.5238) (0.0000 19.0476) (0.0000 33.3333) + (4.7619 42.8571) (14.2857 52.3810) (28.5714 57.1429) (47.6190 61.9048) + (57.1429 66.6667) (61.9048 76.1905) (61.9048 85.7143) (57.1429 95.2381) + (42.8571 100.0000) (23.8095 100.0000) +INDEX 57 STROKE 1 CENTER 33.3333 RIGHT 61.9048 + OPEN 23 (61.9048 66.6667) (57.1429 52.3810) (47.6190 42.8571) + (33.3333 38.0952) (28.5714 38.0952) (14.2857 42.8571) (4.7619 52.3810) + (0.0000 66.6667) (0.0000 71.4286) (4.7619 85.7143) (14.2857 95.2381) + (28.5714 100.0000) (33.3333 100.0000) (47.6190 95.2381) (57.1429 85.7143) + (61.9048 66.6667) (61.9048 42.8571) (57.1429 19.0476) (47.6190 4.7619) + (33.3333 0.0000) (23.8095 0.0000) (9.5238 4.7619) (4.7619 14.2857) +INDEX 58 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 66.6667) (0.0000 61.9048) (4.7619 57.1429) + (9.5238 61.9048) (4.7619 66.6667) + OPEN 5 (4.7619 9.5238) (0.0000 4.7619) (4.7619 0.0000) + (9.5238 4.7619) (4.7619 9.5238) +INDEX 59 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (4.7619 66.6667) (0.0000 61.9048) (4.7619 57.1429) + (9.5238 61.9048) (4.7619 66.6667) + OPEN 8 (9.5238 4.7619) (4.7619 0.0000) (0.0000 4.7619) + (4.7619 9.5238) (9.5238 4.7619) (9.5238 -4.7619) (4.7619 -14.2857) + (0.0000 -19.0476) +INDEX 60 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (76.1905 85.7143) (0.0000 42.8571) (76.1905 0.0000) +INDEX 61 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 2 (0.0000 57.1429) (85.7143 57.1429) + OPEN 2 (0.0000 28.5714) (85.7143 28.5714) +INDEX 62 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (0.0000 85.7143) (76.1905 42.8571) (0.0000 0.0000) +INDEX 63 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 14 (0.0000 76.1905) (0.0000 80.9524) (4.7619 90.4762) + (9.5238 95.2381) (19.0476 100.0000) (38.0952 100.0000) (47.6190 95.2381) + (52.3810 90.4762) (57.1429 80.9524) (57.1429 71.4286) (52.3810 61.9048) + (47.6190 57.1429) (28.5714 47.6190) (28.5714 33.3333) + OPEN 5 (28.5714 9.5238) (23.8095 4.7619) (28.5714 0.0000) + (33.3333 4.7619) (28.5714 9.5238) +INDEX 64 STROKE 2 CENTER 28.5714 RIGHT 61.9048 + OPEN 8 (42.8571 52.3810) (33.3333 57.1429) (23.8095 57.1429) + (19.0476 47.6190) (19.0476 42.8571) (23.8095 33.3333) (33.3333 33.3333) + (42.8571 38.0952) + OPEN 19 (42.8571 57.1429) (42.8571 38.0952) (47.6190 33.3333) + (57.1429 33.3333) (61.9048 42.8571) (61.9048 47.6190) (57.1429 61.9048) + (47.6190 71.4286) (33.3333 76.1905) (28.5714 76.1905) (14.2857 71.4286) + (4.7619 61.9048) (0.0000 47.6190) (0.0000 42.8571) (4.7619 28.5714) + (14.2857 19.0476) (28.5714 14.2857) (33.3333 14.2857) (47.6190 19.0476) +INDEX 65 STROKE 3 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (38.0952 100.0000) (0.0000 0.0000) + OPEN 2 (38.0952 100.0000) (76.1905 0.0000) + OPEN 2 (14.2857 33.3333) (61.9048 33.3333) +INDEX 66 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 9 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 71.4286) (61.9048 61.9048) + (57.1429 57.1429) (42.8571 52.3810) + OPEN 10 (0.0000 52.3810) (42.8571 52.3810) (57.1429 47.6190) + (61.9048 42.8571) (66.6667 33.3333) (66.6667 19.0476) (61.9048 9.5238) + (57.1429 4.7619) (42.8571 0.0000) (0.0000 0.0000) +INDEX 67 STROKE 1 CENTER 33.3333 RIGHT 71.4286 + OPEN 18 (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) +INDEX 68 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 12 (0.0000 100.0000) (33.3333 100.0000) (47.6190 95.2381) + (57.1429 85.7143) (61.9048 76.1905) (66.6667 61.9048) (66.6667 38.0952) + (61.9048 23.8095) (57.1429 14.2857) (47.6190 4.7619) (33.3333 0.0000) + (0.0000 0.0000) +INDEX 69 STROKE 4 CENTER 28.5714 RIGHT 61.9048 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (61.9048 100.0000) + OPEN 2 (0.0000 52.3810) (38.0952 52.3810) + OPEN 2 (0.0000 0.0000) (61.9048 0.0000) +INDEX 70 STROKE 3 CENTER 28.5714 RIGHT 61.9048 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (61.9048 100.0000) + OPEN 2 (0.0000 52.3810) (38.0952 52.3810) +INDEX 71 STROKE 2 CENTER 33.3333 RIGHT 71.4286 + OPEN 19 (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (71.4286 38.0952) + OPEN 2 (47.6190 38.0952) (71.4286 38.0952) +INDEX 72 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (66.6667 100.0000) (66.6667 0.0000) + OPEN 2 (0.0000 52.3810) (66.6667 52.3810) +INDEX 73 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) +INDEX 74 STROKE 1 CENTER 28.5714 RIGHT 47.6190 + OPEN 10 (47.6190 100.0000) (47.6190 23.8095) (42.8571 9.5238) + (38.0952 4.7619) (28.5714 0.0000) (19.0476 0.0000) (9.5238 4.7619) + (4.7619 9.5238) (0.0000 23.8095) (0.0000 33.3333) +INDEX 75 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (66.6667 100.0000) (0.0000 33.3333) + OPEN 2 (23.8095 57.1429) (66.6667 0.0000) +INDEX 76 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 0.0000) (57.1429 0.0000) +INDEX 77 STROKE 4 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (76.1905 0.0000) +INDEX 78 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 0.0000) + OPEN 2 (66.6667 100.0000) (66.6667 0.0000) +INDEX 79 STROKE 1 CENTER 38.0952 RIGHT 76.1905 + OPEN 21 (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (76.1905 38.0952) + (76.1905 61.9048) (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) +INDEX 80 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 10 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 66.6667) (61.9048 57.1429) + (57.1429 52.3810) (42.8571 47.6190) (0.0000 47.6190) +INDEX 81 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 21 (28.5714 100.0000) (19.0476 95.2381) (9.5238 85.7143) + (4.7619 76.1905) (0.0000 61.9048) (0.0000 38.0952) (4.7619 23.8095) + (9.5238 14.2857) (19.0476 4.7619) (28.5714 0.0000) (47.6190 0.0000) + (57.1429 4.7619) (66.6667 14.2857) (71.4286 23.8095) (76.1905 38.0952) + (76.1905 61.9048) (71.4286 76.1905) (66.6667 85.7143) (57.1429 95.2381) + (47.6190 100.0000) (28.5714 100.0000) + OPEN 2 (42.8571 19.0476) (71.4286 -9.5238) +INDEX 82 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 10 (0.0000 100.0000) (42.8571 100.0000) (57.1429 95.2381) + (61.9048 90.4762) (66.6667 80.9524) (66.6667 71.4286) (61.9048 61.9048) + (57.1429 57.1429) (42.8571 52.3810) (0.0000 52.3810) + OPEN 2 (33.3333 52.3810) (66.6667 0.0000) +INDEX 83 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 20 (66.6667 85.7143) (57.1429 95.2381) (42.8571 100.0000) + (23.8095 100.0000) (9.5238 95.2381) (0.0000 85.7143) (0.0000 76.1905) + (4.7619 66.6667) (9.5238 61.9048) (19.0476 57.1429) (47.6190 47.6190) + (57.1429 42.8571) (61.9048 38.0952) (66.6667 28.5714) (66.6667 14.2857) + (57.1429 4.7619) (42.8571 0.0000) (23.8095 0.0000) (9.5238 4.7619) + (0.0000 14.2857) +INDEX 84 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (33.3333 100.0000) (33.3333 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) +INDEX 85 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 10 (0.0000 100.0000) (0.0000 28.5714) (4.7619 14.2857) + (14.2857 4.7619) (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) + (61.9048 14.2857) (66.6667 28.5714) (66.6667 100.0000) +INDEX 86 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 100.0000) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 0.0000) +INDEX 87 STROKE 4 CENTER 47.6190 RIGHT 95.2381 + OPEN 2 (0.0000 100.0000) (23.8095 0.0000) + OPEN 2 (47.6190 100.0000) (23.8095 0.0000) + OPEN 2 (47.6190 100.0000) (71.4286 0.0000) + OPEN 2 (95.2381 100.0000) (71.4286 0.0000) +INDEX 88 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (66.6667 0.0000) + OPEN 2 (66.6667 100.0000) (0.0000 0.0000) +INDEX 89 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 3 (0.0000 100.0000) (38.0952 52.3810) (38.0952 0.0000) + OPEN 2 (76.1905 100.0000) (38.0952 52.3810) +INDEX 90 STROKE 3 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (66.6667 100.0000) (0.0000 0.0000) + OPEN 2 (0.0000 100.0000) (66.6667 100.0000) + OPEN 2 (0.0000 0.0000) (66.6667 0.0000) +INDEX 91 STROKE 4 CENTER 14.2857 RIGHT 33.3333 + OPEN 2 (0.0000 119.0476) (0.0000 -33.3333) + OPEN 2 (4.7619 119.0476) (4.7619 -33.3333) + OPEN 2 (0.0000 119.0476) (33.3333 119.0476) + OPEN 2 (0.0000 -33.3333) (33.3333 -33.3333) +INDEX 92 STROKE 1 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (0.0000 100.0000) (66.6667 -14.2857) +INDEX 93 STROKE 4 CENTER 19.0476 RIGHT 33.3333 + OPEN 2 (28.5714 119.0476) (28.5714 -33.3333) + OPEN 2 (33.3333 119.0476) (33.3333 -33.3333) + OPEN 2 (0.0000 119.0476) (33.3333 119.0476) + OPEN 2 (0.0000 -33.3333) (33.3333 -33.3333) +INDEX 94 STROKE 2 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (38.0952 109.5238) (0.0000 42.8571) + OPEN 2 (38.0952 109.5238) (76.1905 42.8571) +INDEX 95 STROKE 1 CENTER 52.3810 RIGHT 104.7619 + OPEN 5 (0.0000 -33.3333) (104.7619 -33.3333) (104.7619 -28.5714) + (0.0000 -28.5714) (0.0000 -33.3333) +INDEX 96 STROKE 2 CENTER 14.2857 RIGHT 28.5714 + OPEN 2 (4.7619 100.0000) (28.5714 71.4286) + OPEN 3 (4.7619 100.0000) (0.0000 95.2381) (28.5714 71.4286) +INDEX 97 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 66.6667) (57.1429 0.0000) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 98 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 14 (0.0000 52.3810) (9.5238 61.9048) (19.0476 66.6667) + (33.3333 66.6667) (42.8571 61.9048) (52.3810 52.3810) (57.1429 38.0952) + (57.1429 28.5714) (52.3810 14.2857) (42.8571 4.7619) (33.3333 0.0000) + (19.0476 0.0000) (9.5238 4.7619) (0.0000 14.2857) +INDEX 99 STROKE 1 CENTER 28.5714 RIGHT 57.1429 + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 100 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 100.0000) (57.1429 0.0000) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 101 STROKE 1 CENTER 28.5714 RIGHT 57.1429 + OPEN 17 (0.0000 38.0952) (57.1429 38.0952) (57.1429 47.6190) + (52.3810 57.1429) (47.6190 61.9048) (38.0952 66.6667) (23.8095 66.6667) + (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) (0.0000 28.5714) + (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) (38.0952 0.0000) + (47.6190 4.7619) (57.1429 14.2857) +INDEX 102 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 5 (38.0952 100.0000) (28.5714 100.0000) (19.0476 95.2381) + (14.2857 80.9524) (14.2857 0.0000) + OPEN 2 (0.0000 66.6667) (33.3333 66.6667) +INDEX 103 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 7 (57.1429 66.6667) (57.1429 -9.5238) (52.3810 -23.8095) + (47.6190 -28.5714) (38.0952 -33.3333) (23.8095 -33.3333) (14.2857 -28.5714) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 104 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) +INDEX 105 STROKE 2 CENTER 4.7619 RIGHT 9.5238 + OPEN 5 (0.0000 100.0000) (4.7619 95.2381) (9.5238 100.0000) + (4.7619 104.7619) (0.0000 100.0000) + OPEN 2 (4.7619 66.6667) (4.7619 0.0000) +INDEX 106 STROKE 2 CENTER 19.0476 RIGHT 28.5714 + OPEN 5 (19.0476 100.0000) (23.8095 95.2381) (28.5714 100.0000) + (23.8095 104.7619) (19.0476 100.0000) + OPEN 5 (23.8095 66.6667) (23.8095 -14.2857) (19.0476 -28.5714) + (9.5238 -33.3333) (0.0000 -33.3333) +INDEX 107 STROKE 3 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) + OPEN 2 (47.6190 66.6667) (0.0000 19.0476) + OPEN 2 (19.0476 38.0952) (52.3810 0.0000) +INDEX 108 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 100.0000) (0.0000 0.0000) +INDEX 109 STROKE 3 CENTER 52.3810 RIGHT 104.7619 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) + OPEN 7 (52.3810 47.6190) (66.6667 61.9048) (76.1905 66.6667) + (90.4762 66.6667) (100.0000 61.9048) (104.7619 47.6190) (104.7619 0.0000) +INDEX 110 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 7 (0.0000 47.6190) (14.2857 61.9048) (23.8095 66.6667) + (38.0952 66.6667) (47.6190 61.9048) (52.3810 47.6190) (52.3810 0.0000) +INDEX 111 STROKE 1 CENTER 28.5714 RIGHT 61.9048 + OPEN 17 (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) + (0.0000 38.0952) (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) + (23.8095 0.0000) (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) + (61.9048 28.5714) (61.9048 38.0952) (57.1429 52.3810) (47.6190 61.9048) + (38.0952 66.6667) (23.8095 66.6667) +INDEX 112 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 66.6667) (0.0000 -33.3333) + OPEN 14 (0.0000 52.3810) (9.5238 61.9048) (19.0476 66.6667) + (33.3333 66.6667) (42.8571 61.9048) (52.3810 52.3810) (57.1429 38.0952) + (57.1429 28.5714) (52.3810 14.2857) (42.8571 4.7619) (33.3333 0.0000) + (19.0476 0.0000) (9.5238 4.7619) (0.0000 14.2857) +INDEX 113 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (57.1429 66.6667) (57.1429 -33.3333) + OPEN 14 (57.1429 52.3810) (47.6190 61.9048) (38.0952 66.6667) + (23.8095 66.6667) (14.2857 61.9048) (4.7619 52.3810) (0.0000 38.0952) + (0.0000 28.5714) (4.7619 14.2857) (14.2857 4.7619) (23.8095 0.0000) + (38.0952 0.0000) (47.6190 4.7619) (57.1429 14.2857) +INDEX 114 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 2 (0.0000 66.6667) (0.0000 0.0000) + OPEN 5 (0.0000 38.0952) (4.7619 52.3810) (14.2857 61.9048) + (23.8095 66.6667) (38.0952 66.6667) +INDEX 115 STROKE 1 CENTER 23.8095 RIGHT 52.3810 + OPEN 17 (52.3810 52.3810) (47.6190 61.9048) (33.3333 66.6667) + (19.0476 66.6667) (4.7619 61.9048) (0.0000 52.3810) (4.7619 42.8571) + (14.2857 38.0952) (38.0952 33.3333) (47.6190 28.5714) (52.3810 19.0476) + (52.3810 14.2857) (47.6190 4.7619) (33.3333 0.0000) (19.0476 0.0000) + (4.7619 4.7619) (0.0000 14.2857) +INDEX 116 STROKE 2 CENTER 14.2857 RIGHT 38.0952 + OPEN 5 (14.2857 100.0000) (14.2857 19.0476) (19.0476 4.7619) + (28.5714 0.0000) (38.0952 0.0000) + OPEN 2 (0.0000 66.6667) (33.3333 66.6667) +INDEX 117 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 7 (0.0000 66.6667) (0.0000 19.0476) (4.7619 4.7619) + (14.2857 0.0000) (28.5714 0.0000) (38.0952 4.7619) (52.3810 19.0476) + OPEN 2 (52.3810 66.6667) (52.3810 0.0000) +INDEX 118 STROKE 2 CENTER 28.5714 RIGHT 57.1429 + OPEN 2 (0.0000 66.6667) (28.5714 0.0000) + OPEN 2 (57.1429 66.6667) (28.5714 0.0000) +INDEX 119 STROKE 4 CENTER 38.0952 RIGHT 76.1905 + OPEN 2 (0.0000 66.6667) (19.0476 0.0000) + OPEN 2 (38.0952 66.6667) (19.0476 0.0000) + OPEN 2 (38.0952 66.6667) (57.1429 0.0000) + OPEN 2 (76.1905 66.6667) (57.1429 0.0000) +INDEX 120 STROKE 2 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (0.0000 66.6667) (52.3810 0.0000) + OPEN 2 (52.3810 66.6667) (0.0000 0.0000) +INDEX 121 STROKE 2 CENTER 33.3333 RIGHT 61.9048 + OPEN 2 (4.7619 66.6667) (33.3333 0.0000) + OPEN 6 (61.9048 66.6667) (33.3333 0.0000) (23.8095 -19.0476) + (14.2857 -28.5714) (4.7619 -33.3333) (0.0000 -33.3333) +INDEX 122 STROKE 3 CENTER 23.8095 RIGHT 52.3810 + OPEN 2 (52.3810 66.6667) (0.0000 0.0000) + OPEN 2 (0.0000 66.6667) (52.3810 66.6667) + OPEN 2 (0.0000 0.0000) (52.3810 0.0000) +INDEX 123 STROKE 3 CENTER 14.2857 RIGHT 23.8095 + OPEN 10 (23.8095 119.0476) (14.2857 114.2857) (9.5238 109.5238) + (4.7619 100.0000) (4.7619 90.4762) (9.5238 80.9524) (14.2857 76.1905) + (19.0476 66.6667) (19.0476 57.1429) (9.5238 47.6190) + OPEN 17 (14.2857 114.2857) (9.5238 104.7619) (9.5238 95.2381) + (14.2857 85.7143) (19.0476 80.9524) (23.8095 71.4286) (23.8095 61.9048) + (19.0476 52.3810) (0.0000 42.8571) (19.0476 33.3333) (23.8095 23.8095) + (23.8095 14.2857) (19.0476 4.7619) (14.2857 0.0000) (9.5238 -9.5238) + (9.5238 -19.0476) (14.2857 -28.5714) + OPEN 10 (9.5238 38.0952) (19.0476 28.5714) (19.0476 19.0476) + (14.2857 9.5238) (9.5238 4.7619) (4.7619 -4.7619) (4.7619 -14.2857) + (9.5238 -23.8095) (14.2857 -28.5714) (23.8095 -33.3333) +INDEX 124 STROKE 1 CENTER 0.0000 RIGHT 0.0000 + OPEN 2 (0.0000 119.0476) (0.0000 -33.3333) +INDEX 125 STROKE 3 CENTER 9.5238 RIGHT 23.8095 + OPEN 10 (0.0000 119.0476) (9.5238 114.2857) (14.2857 109.5238) + (19.0476 100.0000) (19.0476 90.4762) (14.2857 80.9524) (9.5238 76.1905) + (4.7619 66.6667) (4.7619 57.1429) (14.2857 47.6190) + OPEN 17 (9.5238 114.2857) (14.2857 104.7619) (14.2857 95.2381) + (9.5238 85.7143) (4.7619 80.9524) (0.0000 71.4286) (0.0000 61.9048) + (4.7619 52.3810) (23.8095 42.8571) (4.7619 33.3333) (0.0000 23.8095) + (0.0000 14.2857) (4.7619 4.7619) (9.5238 0.0000) (14.2857 -9.5238) + (14.2857 -19.0476) (9.5238 -28.5714) + OPEN 10 (14.2857 38.0952) (4.7619 28.5714) (4.7619 19.0476) + (9.5238 9.5238) (14.2857 4.7619) (19.0476 -4.7619) (19.0476 -14.2857) + (14.2857 -23.8095) (9.5238 -28.5714) (0.0000 -33.3333) +INDEX 126 STROKE 2 CENTER 42.8571 RIGHT 85.7143 + OPEN 11 (0.0000 28.5714) (0.0000 38.0952) (4.7619 52.3810) + (14.2857 57.1429) (23.8095 57.1429) (33.3333 52.3810) (52.3810 38.0952) + (61.9048 33.3333) (71.4286 33.3333) (80.9524 38.0952) (85.7143 47.6190) + OPEN 11 (0.0000 38.0952) (4.7619 47.6190) (14.2857 52.3810) + (23.8095 52.3810) (33.3333 47.6190) (52.3810 33.3333) (61.9048 28.5714) + (71.4286 28.5714) (80.9524 33.3333) (85.7143 47.6190) (85.7143 57.1429) +INDEX 127 STROKE 2 CENTER 33.3333 RIGHT 66.6667 + OPEN 2 (52.3810 100.0000) (14.2857 -33.3333) + OPEN 17 (28.5714 66.6667) (14.2857 61.9048) (4.7619 52.3810) + (0.0000 38.0952) (0.0000 23.8095) (4.7619 14.2857) (14.2857 4.7619) + (28.5714 0.0000) (38.0952 0.0000) (52.3810 4.7619) (61.9048 14.2857) + (66.6667 28.5714) (66.6667 42.8571) (61.9048 52.3810) (52.3810 61.9048) + (38.0952 66.6667) (28.5714 66.6667) + + + +#/* NCGA GRAFNET:SANS-SERIF NORMAL*/ + +BEARING 32 L_SPACE 0.0 WIDTH 20.0 R_SPACE 0.0 +BEARING 33 L_SPACE 8.62 WIDTH 13.64 R_SPACE 8.48 +BEARING 34 L_SPACE 4.02 WIDTH 32.86 R_SPACE 9.32 +BEARING 35 L_SPACE 3.2 WIDTH 68.94 R_SPACE 4.86 +BEARING 36 L_SPACE 4.82 WIDTH 67.44 R_SPACE 4.72 +BEARING 37 L_SPACE 6.36 WIDTH 112.38 R_SPACE 4.5 +BEARING 38 L_SPACE 5.98 WIDTH 82.02 R_SPACE 0.54 +BEARING 39 L_SPACE 4.44 WIDTH 13.36 R_SPACE 9.18 +BEARING 40 L_SPACE 7.58 WIDTH 24.72 R_SPACE 6.26 +BEARING 41 L_SPACE 5.28 WIDTH 24.34 R_SPACE 8.92 +BEARING 42 L_SPACE 6.96 WIDTH 42.06 R_SPACE 4.86 +BEARING 43 L_SPACE 5.98 WIDTH 96.36 R_SPACE 5.56 +BEARING 44 L_SPACE 8.76 WIDTH 14.2 R_SPACE 7.78 +BEARING 45 L_SPACE 7.38 WIDTH 38.84 R_SPACE 7.66 +BEARING 46 L_SPACE 8.34 WIDTH 13.78 R_SPACE 8.62 +BEARING 47 L_SPACE 7.24 WIDTH 38.44 R_SPACE 8.2 +BEARING 48 L_SPACE 4.98 WIDTH 66.58 R_SPACE 5.42 +BEARING 49 L_SPACE 11.82 WIDTH 34.26 R_SPACE 30.9 +BEARING 50 L_SPACE 5.42 WIDTH 66.0 R_SPACE 5.56 +BEARING 51 L_SPACE 5.0 WIDTH 66.62 R_SPACE 5.38 +BEARING 52 L_SPACE 3.88 WIDTH 68.24 R_SPACE 4.86 +BEARING 53 L_SPACE 4.86 WIDTH 65.96 R_SPACE 6.16 +BEARING 54 L_SPACE 5.58 WIDTH 65.08 R_SPACE 6.32 +BEARING 55 L_SPACE 5.56 WIDTH 66.42 R_SPACE 5.0 +BEARING 56 L_SPACE 5.6 WIDTH 65.98 R_SPACE 5.4 +BEARING 57 L_SPACE 6.6 WIDTH 64.82 R_SPACE 5.56 +BEARING 58 L_SPACE 9.32 WIDTH 14.06 R_SPACE 7.38 +BEARING 59 L_SPACE 8.2 WIDTH 13.96 R_SPACE 8.58 +BEARING 60 L_SPACE 3.06 WIDTH 102.5 R_SPACE 2.36 +BEARING 61 L_SPACE 5.7 WIDTH 96.36 R_SPACE 5.84 +BEARING 62 L_SPACE 2.78 WIDTH 102.5 R_SPACE 2.64 +BEARING 63 L_SPACE 8.42 WIDTH 60.22 R_SPACE 8.34 +BEARING 64 L_SPACE 6.36 WIDTH 126.24 R_SPACE 6.1 +BEARING 65 L_SPACE 2.5 WIDTH 88.16 R_SPACE 1.8 +BEARING 66 L_SPACE 11.42 WIDTH 75.5 R_SPACE 5.54 +BEARING 67 L_SPACE 6.66 WIDTH 87.06 R_SPACE 6.4 +BEARING 68 L_SPACE 11.96 WIDTH 81.48 R_SPACE 6.66 +BEARING 69 L_SPACE 11.42 WIDTH 72.28 R_SPACE 4.86 +BEARING 70 L_SPACE 11.42 WIDTH 67.96 R_SPACE 5.42 +BEARING 71 L_SPACE 7.06 WIDTH 89.56 R_SPACE 11.28 +BEARING 72 L_SPACE 11.42 WIDTH 77.7 R_SPACE 11.0 +BEARING 73 L_SPACE 10.86 WIDTH 13.36 R_SPACE 10.44 +BEARING 74 L_SPACE 2.5 WIDTH 56.96 R_SPACE 9.88 +BEARING 75 L_SPACE 11.28 WIDTH 79.8 R_SPACE 1.38 +BEARING 76 L_SPACE 11.68 WIDTH 62.8 R_SPACE 2.5 +BEARING 77 L_SPACE 10.86 WIDTH 94.56 R_SPACE 10.16 +BEARING 78 L_SPACE 11.14 WIDTH 77.98 R_SPACE 11.0 +BEARING 79 L_SPACE 6.24 WIDTH 95.28 R_SPACE 6.4 +BEARING 80 L_SPACE 12.1 WIDTH 73.44 R_SPACE 6.9 +BEARING 81 L_SPACE 5.3 WIDTH 96.0 R_SPACE 6.6 +BEARING 82 L_SPACE 11.68 WIDTH 80.64 R_SPACE 4.02 +BEARING 83 L_SPACE 8.0 WIDTH 78.28 R_SPACE 6.16 +BEARING 84 L_SPACE 2.36 WIDTH 79.52 R_SPACE 2.92 +BEARING 85 L_SPACE 11.54 WIDTH 77.28 R_SPACE 11.28 +BEARING 86 L_SPACE 2.36 WIDTH 87.04 R_SPACE 3.06 +BEARING 87 L_SPACE 2.22 WIDTH 125.76 R_SPACE 3.06 +BEARING 88 L_SPACE 2.5 WIDTH 86.76 R_SPACE 3.2 +BEARING 89 L_SPACE 1.52 WIDTH 88.98 R_SPACE 1.94 +BEARING 90 L_SPACE 2.5 WIDTH 77.7 R_SPACE 4.58 +BEARING 91 L_SPACE 7.78 WIDTH 25.76 R_SPACE 5.0 +BEARING 92 L_SPACE 5.84 WIDTH 73.24 R_SPACE 5.7 +BEARING 93 L_SPACE 4.44 WIDTH 25.48 R_SPACE 8.62 +BEARING 94 L_SPACE 5.98 WIDTH 55.28 R_SPACE 8.06 +BEARING 95 L_SPACE -1.1 WIDTH 70.04 R_SPACE 0.4 +BEARING 96 L_SPACE 28.26 WIDTH 25.9 R_SPACE 26.74 +BEARING 97 L_SPACE 6.68 WIDTH 67.54 R_SPACE 2.78 +BEARING 98 L_SPACE 8.76 WIDTH 63.66 R_SPACE 4.56 +BEARING 99 L_SPACE 5.52 WIDTH 61.46 R_SPACE 6.26 +BEARING 100 L_SPACE 4.64 WIDTH 63.88 R_SPACE 8.48 +BEARING 101 L_SPACE 5.72 WIDTH 65.62 R_SPACE 5.66 +BEARING 102 L_SPACE 0.68 WIDTH 34.12 R_SPACE -0.12 +BEARING 103 L_SPACE 5.36 WIDTH 63.16 R_SPACE 8.48 +BEARING 104 L_SPACE 9.6 WIDTH 58.34 R_SPACE 9.04 +BEARING 105 L_SPACE 10.02 WIDTH 11.42 R_SPACE 9.32 +BEARING 106 L_SPACE -1.66 WIDTH 23.1 R_SPACE 9.32 +BEARING 107 L_SPACE 9.6 WIDTH 59.18 R_SPACE 0.54 +BEARING 108 L_SPACE 10.02 WIDTH 11.42 R_SPACE 9.32 +BEARING 109 L_SPACE 9.6 WIDTH 96.36 R_SPACE 9.6 +BEARING 110 L_SPACE 9.18 WIDTH 58.48 R_SPACE 9.32 +BEARING 111 L_SPACE 4.98 WIDTH 67.14 R_SPACE 4.86 +BEARING 112 L_SPACE 9.46 WIDTH 63.34 R_SPACE 4.2 +BEARING 113 L_SPACE 4.84 WIDTH 63.38 R_SPACE 8.76 +BEARING 114 L_SPACE 9.46 WIDTH 34.8 R_SPACE 1.94 +BEARING 115 L_SPACE 4.7 WIDTH 59.4 R_SPACE 5.24 +BEARING 116 L_SPACE 0.54 WIDTH 33.42 R_SPACE 0.68 +BEARING 117 L_SPACE 9.46 WIDTH 58.2 R_SPACE 9.32 +BEARING 118 L_SPACE 1.8 WIDTH 65.86 R_SPACE 1.66 +BEARING 119 L_SPACE 2.5 WIDTH 95.82 R_SPACE 1.8 +BEARING 120 L_SPACE 1.66 WIDTH 65.32 R_SPACE 2.36 +BEARING 121 L_SPACE 1.8 WIDTH 65.18 R_SPACE 2.36 +BEARING 122 L_SPACE 4.44 WIDTH 59.88 R_SPACE 5.0 +BEARING 123 L_SPACE 7.38 WIDTH 36.06 R_SPACE 10.44 +BEARING 124 L_SPACE 11.54 WIDTH 6.96 R_SPACE 12.24 +BEARING 125 L_SPACE 9.18 WIDTH 36.2 R_SPACE 8.48 +BEARING 126 L_SPACE 2.92 WIDTH 102.36 R_SPACE 2.64 + diff --git a/gl4java/utils/glut/fonts/StrokeCharRec.java b/gl4java/utils/glut/fonts/StrokeCharRec.java new file mode 100644 index 0000000..f0fdec2 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeCharRec.java @@ -0,0 +1,24 @@ +// Stroke Character Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeCharRec { + public int num_strokes; + public StrokeRec[] stroke; + public float center; + public float right; + + public StrokeCharRec(int n, StrokeRec[] strk, float c, float r) { + num_strokes=n; + stroke=strk; + center=c; + right=r; + } +} diff --git a/gl4java/utils/glut/fonts/StrokeFontRec.java b/gl4java/utils/glut/fonts/StrokeFontRec.java new file mode 100644 index 0000000..0985da9 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeFontRec.java @@ -0,0 +1,25 @@ +// Stroke Font Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeFontRec { + public String name; + public int num_chars; + public StrokeCharRec[] ch; + public float top; + public float bottom; + public StrokeFontRec(String n, int num, StrokeCharRec[] c,float t, float b) { + name=n; + num_chars=num; + ch=c; + top=t; + bottom=b; + } +} diff --git a/gl4java/utils/glut/fonts/StrokeRec.java b/gl4java/utils/glut/fonts/StrokeRec.java new file mode 100644 index 0000000..9bb4214 --- /dev/null +++ b/gl4java/utils/glut/fonts/StrokeRec.java @@ -0,0 +1,20 @@ +// Stroke Record +// by Pontus Lidman +// based on GLUT 3.7 glutstroke.h +// this file Copyright 2000 MathCore AB +// +// This file/package is licensed under the terms of the LPGL +// with the permission of Pontus Lidman / Mathcore ! +// + +package gl4java.utils.glut.fonts; + +public class StrokeRec { + public int num_coords; + public CoordRec[] coord; + + public StrokeRec(int num, CoordRec[] c) { + num_coords=num; + coord=c; + } +} diff --git a/gl4java/utils/glut/fonts/capturexfont.c b/gl4java/utils/glut/fonts/capturexfont.c new file mode 100644 index 0000000..4ce3fd4 --- /dev/null +++ b/gl4java/utils/glut/fonts/capturexfont.c @@ -0,0 +1,371 @@ + +/* 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 */ + +/* Adapted to produce Java output + portions copyright 2000 MathCore AB */ + +#include +#include +#include +#include +#include +#include +#include + +#define MAX_GLYPHS_PER_GRAB 512 /* This is big enough for 2^9 + glyph character sets */ + +/* TODO: add command line flag to turn on this (and test it of course) */ +static int win32_bugfix=0; + +static void +outputChar(int num, int width, int height, + int xoff, int yoff, int advance, int data) +{ + if ((width == 0 || height == 0) && win32_bugfix) { + printf(" static final byte[] ch%ddata = { (byte)0x0 };\n", num); + printf(" static final BitmapCharRec ch%d = new BitmapCharRec(", num); + printf("%d,", 0); + printf("%d,", 0); + printf("%d,", xoff); + printf("%d,", yoff); + printf("%d,", advance); + printf("ch%ddata", num); + printf(");\n"); + } else { + printf(" static final BitmapCharRec ch%d = new BitmapCharRec(", num); + printf("%d,", width); + printf("%d,", height); + printf("%d,", xoff); + printf("%d,", yoff); + printf("%d,", advance); + if (data) { + printf("ch%ddata", num); + } else { + printf("zerodata"); + } + printf(");\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("package gl4java.utils.glut.fonts.data;\n\n"); + printf("import gl4java.utils.glut.fonts.*;\n\n"); + /* printf("#include \"glutbitmap.h\"\n\n"); */ + + if (win32_bugfix) { + printf("// This file is generated with the WIN32 bug workaround:\n"); + printf("// 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("\npublic class %s implements GLUTBitmapFont {\n",name); + + printf(" private static byte[] zerodata={ 0 };\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 final byte[] 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("(byte) 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 final BitmapCharRec 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(" null,\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(" null,\n"); + continue; + } + } + } + printf(" ch%d,\n", i); + } + } + printf(" };\n\n"); + printf(" static final BitmapFontRec fontinfo = new BitmapFontRec(\n"); // %s , name + printf(" \"%s\",\n", xfont); + printf(" %d,\n", last - first + 1); + printf(" %d,\n", first); + printf(" chars\n"); + printf(" );\n\n"); + + printf(" public static BitmapFontRec getBitmapFontRec() {\n"); + printf(" return fontinfo;\n"); + printf(" }\n"); + XFreeFont(dpy, fontinfo); + + printf("} // end of class %s\n",name); +} + +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/gl4java/utils/glut/fonts/data/glutBitmap8By13.java b/gl4java/utils/glut/fonts/data/glutBitmap8By13.java new file mode 100644 index 0000000..5abf8c5 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmap8By13.java @@ -0,0 +1,2048 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmap8By13 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; + static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,8,zerodata); + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,8,zerodata); + +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(6,12,-1,2,8,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(6,10,-1,2,8,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(6,12,-1,2,8,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(6,10,-1,0,8,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(6,10,-1,0,8,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(6,10,-1,0,8,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(6,10,-1,0,8,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,8,-1,1,8,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,7,-1,-1,8,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(6,10,-1,0,8,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(6,10,-1,0,8,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(6,10,-1,0,8,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(6,10,-1,0,8,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(6,10,-1,0,8,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(6,10,-1,0,8,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(6,10,-1,0,8,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,10,-1,0,8,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(5,10,-1,0,8,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,10,-1,0,8,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,10,-1,0,8,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(6,10,-1,0,8,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(6,10,-1,0,8,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(6,10,-1,0,8,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(6,10,-1,0,8,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(6,8,-1,2,8,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x6c, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,8,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(6,10,-1,0,8,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,8,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,8,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,8,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,8,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(6,9,-1,1,8,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(5,10,-1,0,8,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,10,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,10,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,10,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(6,11,-1,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(6,6,-1,-1,8,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(7,10,0,0,8,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(7,10,0,0,8,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x24,(byte) 0x18, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(7,10,0,0,8,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(7,10,0,0,8,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x8,(byte) 0x10, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(7,10,0,0,8,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xe2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,9,0,0,8,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(5,10,-1,0,8,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(5,10,-1,0,8,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(5,10,-1,0,8,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(5,10,-1,0,8,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(6,10,-1,0,8,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(6,10,-1,0,8,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(6,10,-1,0,8,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(6,10,-1,0,8,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,11,-1,2,8,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0xf0,(byte) 0x9c,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(7,9,0,0,8,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(6,10,-1,0,8,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(6,10,-1,0,8,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(6,10,-1,0,8,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(6,10,-1,0,8,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(6,10,-1,0,8,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(6,10,-1,0,8,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(6,9,-1,0,8,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,10,0,0,8,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,10,0,0,8,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,10,0,0,8,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,7,0,-1,8,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(4,6,-1,-3,8,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,8,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(2,2,-3,2,8,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,1,-3,-4,8,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,9,-1,0,8,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0xb4,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(6,7,-1,1,8,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,-3,-8,8,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,8,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,8,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,-1,8,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-2,-5,8,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-8,8,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xaa,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,9,0,-1,8,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,8,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-1,8,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,7,0,-1,8,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x70, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-1,-2,8,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x92,(byte) 0xaa,(byte) 0xa2,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,9,0,-1,8,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xd8, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(5,1,-1,-8,8,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(4,10,-2,0,8,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,9,-3,0,8,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(7,9,0,0,8,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(6,6,-1,-1,8,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(7,9,0,0,8,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,8,-1,-1,8,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,9,-3,0,8,ch161data); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x90,(byte) 0xa8,(byte) 0x48, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(5,3,-1,-6,8,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(5,9,-1,0,8,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,9,-3,0,8,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(5,9,-2,0,8,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfc,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xfc, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(6,6,-1,0,8,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,8,-1,2,8,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(6,6,-1,0,8,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,6,-1,0,8,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(6,6,-1,0,8,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x38,(byte) 0x44,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(6,8,-1,0,8,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x78,(byte) 0x84,(byte) 0x18,(byte) 0x60,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(6,6,-1,0,8,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0xb8, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(6,6,-1,0,8,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x74, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(6,8,-1,2,8,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0xc4,(byte) 0xb8, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(6,8,-1,2,8,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(6,6,-1,0,8,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(6,6,-1,0,8,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(5,9,-1,0,8,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(6,9,-1,0,8,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x18,(byte) 0x0,(byte) 0x8, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(5,10,-1,2,8,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(5,8,-1,0,8,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(6,9,-1,0,8,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x78,(byte) 0x84,(byte) 0x78,(byte) 0x80,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x74, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(6,8,-1,2,8,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(6,9,-1,0,8,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(6,6,-1,0,8,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x74,(byte) 0x4,(byte) 0x4,(byte) 0x4, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(6,9,-1,0,8,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(6,6,-1,0,8,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(6,9,-1,0,8,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(6,6,-1,0,8,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x10,(byte) 0x60,(byte) 0xe0, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(4,3,-2,-6,8,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,1,8,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,3,-1,-6,8,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,9,-1,0,8,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x2,(byte) 0x2,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,9,0,0,8,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,9,-2,0,8,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(6,9,-1,0,8,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,9,0,0,8,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,9,0,0,8,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(7,9,0,0,8,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,9,0,0,8,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,8,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x4,(byte) 0x78,(byte) 0x94,(byte) 0xa4,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(6,10,-1,1,8,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,9,-1,0,8,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x94,(byte) 0xa4,(byte) 0xc4,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(6,9,-1,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,9,0,0,8,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(6,9,-1,0,8,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(6,9,-1,0,8,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3c, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(6,9,-1,0,8,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(5,9,-1,0,8,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(6,9,-1,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,9,-1,0,8,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,9,0,0,8,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,9,-1,0,8,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(7,9,0,0,8,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(6,9,-1,0,8,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x78,(byte) 0x80,(byte) 0x94,(byte) 0xac,(byte) 0xa4,(byte) 0x9c,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(6,9,-1,0,8,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(6,9,-1,0,8,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(5,9,-1,0,8,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xfc, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(6,4,-1,-2,8,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(5,9,-2,0,8,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(4,8,-1,1,8,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(3,8,-2,1,8,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(6,9,-1,0,8,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(6,9,-1,0,8,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(6,9,-1,0,8,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(6,9,-1,0,8,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(6,9,-1,0,8,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x18,(byte) 0x8, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(6,9,-1,0,8,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x38,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(6,9,-1,0,8,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(6,9,-1,0,8,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(5,9,-1,0,8,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x30,(byte) 0x48,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(6,9,-1,0,8,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(7,9,0,0,8,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(3,3,-2,1,8,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(6,1,-1,-4,8,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(4,3,-1,1,8,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-2,8,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x48,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(6,5,-1,-2,8,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,9,-2,0,8,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,9,-3,0,8,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x60,(byte) 0x70, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(4,3,-1,-6,8,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x74,(byte) 0x88,(byte) 0x94,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(6,7,-1,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x88,(byte) 0x54,(byte) 0x48,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0x44, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(6,9,-1,0,8,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0xf0,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0x78,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,7,-1,-1,8,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,7,-1,-1,8,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-2,-6,8,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-3,0,8,ch33data); + +// char: 0x1f + + static final byte[] ch31data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch31 = new BitmapCharRec(1,1,-3,-3,8,ch31data); + +// char: 0x1e + + static final byte[] ch30data = { + (byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch30 = new BitmapCharRec(7,9,0,0,8,ch30data); + +// char: 0x1d + + static final byte[] ch29data = { + (byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch29 = new BitmapCharRec(7,7,0,0,8,ch29data); + +// char: 0x1c + + static final byte[] ch28data = { + (byte) 0x88,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0xfc, + }; + + static final BitmapCharRec ch28 = new BitmapCharRec(6,6,-1,0,8,ch28data); + +// char: 0x1b + + static final byte[] ch27data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80, + }; + + static final BitmapCharRec ch27 = new BitmapCharRec(7,8,0,0,8,ch27data); + +// char: 0x1a + + static final byte[] ch26data = { + (byte) 0xfe,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2, + }; + + static final BitmapCharRec ch26 = new BitmapCharRec(7,8,0,0,8,ch26data); + +// char: 0x19 + + static final byte[] ch25data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch25 = new BitmapCharRec(1,13,-3,2,8,ch25data); + +// char: 0x18 + + static final byte[] ch24data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff, + }; + + static final BitmapCharRec ch24 = new BitmapCharRec(8,6,0,2,8,ch24data); + +// char: 0x17 + + static final byte[] ch23data = { + (byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch23 = new BitmapCharRec(8,8,0,-3,8,ch23data); + +// char: 0x16 + + static final byte[] ch22data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch22 = new BitmapCharRec(4,13,0,2,8,ch22data); + +// char: 0x15 + + static final byte[] ch21data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch21 = new BitmapCharRec(5,13,-3,2,8,ch21data); + +// char: 0x14 + + static final byte[] ch20data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch20 = new BitmapCharRec(8,1,0,1,8,ch20data); + +// char: 0x13 + + static final byte[] ch19data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch19 = new BitmapCharRec(8,1,0,-1,8,ch19data); + +// char: 0x12 + + static final byte[] ch18data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch18 = new BitmapCharRec(8,1,0,-3,8,ch18data); + +// char: 0x11 + + static final byte[] ch17data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch17 = new BitmapCharRec(8,1,0,-5,8,ch17data); + +// char: 0x10 + + static final byte[] ch16data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch16 = new BitmapCharRec(8,1,0,-7,8,ch16data); + +// char: 0xf + + static final byte[] ch15data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch15 = new BitmapCharRec(8,13,0,2,8,ch15data); + +// char: 0xe + + static final byte[] ch14data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch14 = new BitmapCharRec(5,8,-3,-3,8,ch14data); + +// char: 0xd + + static final byte[] ch13data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch13 = new BitmapCharRec(5,6,-3,2,8,ch13data); + +// char: 0xc + + static final byte[] ch12data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch12 = new BitmapCharRec(4,6,0,2,8,ch12data); + +// char: 0xb + + static final byte[] ch11data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch11 = new BitmapCharRec(4,8,0,-3,8,ch11data); + +// char: 0xa + + static final byte[] ch10data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch10 = new BitmapCharRec(7,9,0,2,8,ch10data); + +// char: 0x9 + + static final byte[] ch9data = { + (byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88, + }; + + static final BitmapCharRec ch9 = new BitmapCharRec(7,9,0,2,8,ch9data); + +// char: 0x8 + + static final byte[] ch8data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch8 = new BitmapCharRec(7,6,0,0,8,ch8data); + +// char: 0x7 + + static final byte[] ch7data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-1,-5,8,ch7data); + +// char: 0x6 + + static final byte[] ch6data = { + (byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch6 = new BitmapCharRec(7,9,0,2,8,ch6data); + +// char: 0x5 + + static final byte[] ch5data = { + (byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78, + }; + + static final BitmapCharRec ch5 = new BitmapCharRec(7,9,0,2,8,ch5data); + +// char: 0x4 + + static final byte[] ch4data = { + (byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x9e,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch4 = new BitmapCharRec(7,9,0,2,8,ch4data); + +// char: 0x3 + + static final byte[] ch3data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch3 = new BitmapCharRec(7,9,0,2,8,ch3data); + +// char: 0x2 + + static final byte[] ch2data = { + (byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa, + }; + + static final BitmapCharRec ch2 = new BitmapCharRec(8,12,0,2,8,ch2data); + +// char: 0x1 + + static final byte[] ch1data = { + (byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch1 = new BitmapCharRec(7,7,0,-1,8,ch1data); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "8x13", + 256, + 0, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmap8By13 diff --git a/gl4java/utils/glut/fonts/data/glutBitmap9By15.java b/gl4java/utils/glut/fonts/data/glutBitmap9By15.java new file mode 100644 index 0000000..4cddc0d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmap9By15.java @@ -0,0 +1,2050 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmap9By15 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; + static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,9,zerodata); + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,9,zerodata); + +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(6,14,-1,3,9,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(7,12,-1,3,9,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(6,14,-1,3,9,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(7,11,-1,0,9,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(7,11,-1,0,9,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(7,11,-1,0,9,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(7,11,-1,0,9,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x7c,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x7c,(byte) 0x2, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(7,9,-1,1,9,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x10,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(7,9,-1,0,9,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(7,11,-1,0,9,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(7,11,-1,0,9,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(7,11,-1,0,9,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(7,11,-1,0,9,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(7,11,-1,0,9,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(7,11,-1,0,9,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(7,11,-1,0,9,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,11,-2,0,9,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(5,11,-2,0,9,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60,(byte) 0x10, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,11,-2,0,9,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x40, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,11,-2,0,9,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(7,11,-1,0,9,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(7,11,-1,0,9,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(7,11,-1,0,9,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(7,11,-1,0,9,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(7,10,-1,3,9,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6e,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x92,(byte) 0x6c, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,7,-1,0,9,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x24,(byte) 0x18, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(7,11,-1,0,9,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(7,11,-1,0,9,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(7,11,-1,0,9,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(7,11,-1,0,9,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(7,11,-1,0,9,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(7,11,-1,0,9,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(7,9,-1,1,9,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(7,10,-1,0,9,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,11,-1,0,9,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(7,11,-1,0,9,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(7,11,-1,0,9,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(7,11,-1,0,9,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(7,11,-1,0,9,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x7c,(byte) 0xc2,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x86,(byte) 0x7c,(byte) 0x2, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(7,12,-1,1,9,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(7,7,-1,-1,9,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(7,11,-1,0,9,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(7,11,-1,0,9,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(7,11,-1,0,9,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(7,11,-1,0,9,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(7,11,-1,0,9,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,11,-1,0,9,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,10,-1,0,9,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(5,11,-2,0,9,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(5,11,-2,0,9,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x60,(byte) 0x10, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(5,11,-2,0,9,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x30,(byte) 0x40, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(5,11,-2,0,9,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(7,11,-1,0,9,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(7,11,-1,0,9,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(7,11,-1,0,9,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(7,11,-1,0,9,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(7,13,-1,3,9,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xfc,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(7,10,-1,0,9,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,11,-1,0,9,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,11,-1,0,9,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,11,-1,0,9,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x30,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,11,-1,0,9,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,11,-1,0,9,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(7,10,-1,0,9,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,10,-1,0,9,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,10,-1,0,9,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,10,-1,0,9,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(5,6,-1,-5,9,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,9,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0x60,(byte) 0x90,(byte) 0x30, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(4,3,-2,3,9,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-4,-4,9,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0x7a,(byte) 0x8a,(byte) 0x8a,(byte) 0x8a,(byte) 0x7e, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(7,10,-1,0,9,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xba,(byte) 0xc6,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(7,9,-1,2,9,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0xc0,(byte) 0x20, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(3,2,-3,-9,9,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,9,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,9,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(7,9,-1,-1,9,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-3,-6,9,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-9,9,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x3c,(byte) 0x42,(byte) 0xa5,(byte) 0xa9,(byte) 0xbd,(byte) 0xa5,(byte) 0xb9,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(8,9,0,-1,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,9,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,9,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x90,(byte) 0x70,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-3,-3,9,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x99,(byte) 0xa5,(byte) 0xa1,(byte) 0xa5,(byte) 0x99,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(8,9,0,-1,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,2,-3,-9,9,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,11,-2,1,9,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-4,1,9,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(7,10,-1,0,9,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x82, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(7,6,-1,-3,9,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(7,10,-1,0,9,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x78,(byte) 0xa4,(byte) 0xa0,(byte) 0x90,(byte) 0x94,(byte) 0x78,(byte) 0x8, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(6,8,-1,0,9,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,11,-4,0,9,ch161data); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x8c,(byte) 0x92,(byte) 0x62, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(7,3,-1,-7,9,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(5,12,-1,1,9,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-4,1,9,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x38, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(5,12,-3,1,9,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfe, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(7,7,-1,0,9,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,10,-1,3,9,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(7,7,-1,0,9,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,7,-1,0,9,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(7,7,-1,0,9,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(7,7,-1,0,9,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x1c,(byte) 0x22,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xfc,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(7,9,-1,0,9,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x7c,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(7,7,-1,0,9,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x42,(byte) 0x62,(byte) 0x9c, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(7,7,-1,0,9,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(7,10,-1,3,9,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(7,10,-1,3,9,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(7,7,-1,0,9,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(7,7,-1,0,9,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(5,10,-2,0,9,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x82,(byte) 0x8c,(byte) 0xb0,(byte) 0xc0,(byte) 0xb0,(byte) 0x8c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(7,10,-1,0,9,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1c,(byte) 0x0,(byte) 0x0,(byte) 0xc, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(6,13,-1,3,9,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(5,10,-2,0,9,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(7,10,-1,0,9,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x80,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x7a, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(7,10,-1,3,9,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(7,10,-1,0,9,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(7,7,-1,0,9,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a,(byte) 0x2,(byte) 0x2,(byte) 0x2, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(7,10,-1,0,9,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(7,7,-1,0,9,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(7,10,-1,0,9,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(7,7,-1,0,9,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(4,4,-3,-6,9,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(8,1,0,1,9,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(7,4,-1,-6,9,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,12,-2,1,9,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x2,(byte) 0x4,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,10,-1,0,9,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,12,-3,1,9,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(7,10,-1,0,9,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,10,-1,0,9,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,10,-1,0,9,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(7,10,-1,0,9,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,10,-1,0,9,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(7,10,-1,0,9,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,10,-1,0,9,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x2,(byte) 0xc,(byte) 0x70,(byte) 0x80,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(7,10,-1,0,9,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(7,10,-1,0,9,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x6,(byte) 0x8,(byte) 0x7c,(byte) 0x92,(byte) 0xa2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(7,12,-1,2,9,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(7,10,-1,0,9,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(7,10,-1,0,9,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,10,-1,0,9,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,10,-1,0,9,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(7,10,-1,0,9,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x84,(byte) 0x82, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(7,10,-1,0,9,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1e, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(7,10,-1,0,9,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(5,10,-2,0,9,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,10,-1,0,9,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(7,10,-1,0,9,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(7,10,-1,0,9,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(7,10,-1,0,9,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,10,-1,0,9,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(7,10,-1,0,9,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(7,10,-1,0,9,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,10,-1,0,9,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0x9a,(byte) 0xa6,(byte) 0xa2,(byte) 0x9e,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(7,10,-1,0,9,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(7,10,-1,0,9,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(5,10,-2,0,9,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(7,4,-1,-2,9,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(5,10,-2,0,9,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,10,-4,3,9,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,7,-4,0,9,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x78,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(7,10,-1,0,9,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(7,10,-1,0,9,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(7,10,-1,0,9,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x3c, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(7,10,-1,0,9,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0xfe, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(7,10,-1,0,9,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfe,(byte) 0x84,(byte) 0x44,(byte) 0x24,(byte) 0x14,(byte) 0xc,(byte) 0x4, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(7,10,-1,0,9,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x1c,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(7,10,-1,0,9,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(7,10,-1,0,9,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(7,10,-1,0,9,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(7,10,-1,0,9,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(7,10,-1,0,9,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-4,0,9,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(7,1,-1,-4,9,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-4,3,9,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(7,7,-1,-1,9,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x10,(byte) 0x92,(byte) 0x54,(byte) 0x38,(byte) 0x54,(byte) 0x92,(byte) 0x10, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(7,7,-1,-1,9,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,12,-3,1,9,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-3,1,9,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(4,4,-3,-6,9,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x62,(byte) 0x94,(byte) 0x88,(byte) 0x94,(byte) 0x62,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(7,10,-1,0,9,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x84,(byte) 0x4a,(byte) 0x4a,(byte) 0x24,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0xa4,(byte) 0x42, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(7,10,-1,0,9,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x10,(byte) 0x7c,(byte) 0x92,(byte) 0x12,(byte) 0x12,(byte) 0x14,(byte) 0x38,(byte) 0x50,(byte) 0x90,(byte) 0x92,(byte) 0x7c,(byte) 0x10, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(7,12,-1,1,9,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,8,-1,-1,9,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-3,-7,9,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,11,-4,0,9,ch33data); + +// char: 0x1f + + static final byte[] ch31data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch31 = new BitmapCharRec(2,2,-4,-2,9,ch31data); + +// char: 0x1e + + static final byte[] ch30data = { + (byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c, + }; + + static final BitmapCharRec ch30 = new BitmapCharRec(7,10,-1,0,9,ch30data); + +// char: 0x1d + + static final byte[] ch29data = { + (byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2, + }; + + static final BitmapCharRec ch29 = new BitmapCharRec(7,7,-1,0,9,ch29data); + +// char: 0x1c + + static final byte[] ch28data = { + (byte) 0x44,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0xfe, + }; + + static final BitmapCharRec ch28 = new BitmapCharRec(7,7,-1,0,9,ch28data); + +// char: 0x1b + + static final byte[] ch27data = { + (byte) 0xfe,(byte) 0x0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch27 = new BitmapCharRec(7,12,-1,2,9,ch27data); + +// char: 0x1a + + static final byte[] ch26data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch26 = new BitmapCharRec(6,12,-2,2,9,ch26data); + +// char: 0x19 + + static final byte[] ch25data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch25 = new BitmapCharRec(1,15,-4,3,9,ch25data); + +// char: 0x18 + + static final byte[] ch24data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch24 = new BitmapCharRec(9,7,0,3,9,ch24data); + +// char: 0x17 + + static final byte[] ch23data = { + (byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch23 = new BitmapCharRec(9,9,0,-3,9,ch23data); + +// char: 0x16 + + static final byte[] ch22data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch22 = new BitmapCharRec(5,15,0,3,9,ch22data); + +// char: 0x15 + + static final byte[] ch21data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch21 = new BitmapCharRec(5,15,-4,3,9,ch21data); + +// char: 0x14 + + static final byte[] ch20data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch20 = new BitmapCharRec(9,1,0,1,9,ch20data); + +// char: 0x13 + + static final byte[] ch19data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch19 = new BitmapCharRec(9,1,0,-1,9,ch19data); + +// char: 0x12 + + static final byte[] ch18data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch18 = new BitmapCharRec(9,1,0,-3,9,ch18data); + +// char: 0x11 + + static final byte[] ch17data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch17 = new BitmapCharRec(9,1,0,-5,9,ch17data); + +// char: 0x10 + + static final byte[] ch16data = { + (byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch16 = new BitmapCharRec(9,1,0,-7,9,ch16data); + +// char: 0xf + + static final byte[] ch15data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0, +(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch15 = new BitmapCharRec(9,15,0,3,9,ch15data); + +// char: 0xe + + static final byte[] ch14data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch14 = new BitmapCharRec(5,9,-4,-3,9,ch14data); + +// char: 0xd + + static final byte[] ch13data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch13 = new BitmapCharRec(5,7,-4,3,9,ch13data); + +// char: 0xc + + static final byte[] ch12data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch12 = new BitmapCharRec(5,7,0,3,9,ch12data); + +// char: 0xb + + static final byte[] ch11data = { + (byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch11 = new BitmapCharRec(5,9,0,-3,9,ch11data); + +// char: 0xa + + static final byte[] ch10data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch10 = new BitmapCharRec(7,10,-1,2,9,ch10data); + +// char: 0x9 + + static final byte[] ch9data = { + (byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88, + }; + + static final BitmapCharRec ch9 = new BitmapCharRec(7,10,-1,2,9,ch9data); + +// char: 0x8 + + static final byte[] ch8data = { + (byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch8 = new BitmapCharRec(7,6,-1,0,9,ch8data); + +// char: 0x7 + + static final byte[] ch7data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-2,-6,9,ch7data); + +// char: 0x6 + + static final byte[] ch6data = { + (byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0x0,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch6 = new BitmapCharRec(7,10,-1,2,9,ch6data); + +// char: 0x5 + + static final byte[] ch5data = { + (byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x0,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78, + }; + + static final BitmapCharRec ch5 = new BitmapCharRec(7,10,-1,2,9,ch5data); + +// char: 0x4 + + static final byte[] ch4data = { + (byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x1e,(byte) 0x80,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0, + }; + + static final BitmapCharRec ch4 = new BitmapCharRec(7,10,-1,2,9,ch4data); + +// char: 0x3 + + static final byte[] ch3data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch3 = new BitmapCharRec(7,10,-1,2,9,ch3data); + +// char: 0x2 + + static final byte[] ch2data = { + (byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa, + }; + + static final BitmapCharRec ch2 = new BitmapCharRec(8,14,0,3,9,ch2data); + +// char: 0x1 + + static final byte[] ch1data = { + (byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch1 = new BitmapCharRec(7,7,-1,0,9,ch1data); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "9x15", + 256, + 0, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmap9By15 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java new file mode 100644 index 0000000..a83f7b3 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica10.java @@ -0,0 +1,1769 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica10 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(4,10,0,2,5,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(5,10,0,2,6,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(4,11,0,2,5,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(4,8,0,0,5,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(4,9,0,0,5,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(4,9,0,0,5,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(4,9,0,0,5,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x70,(byte) 0x88,(byte) 0xc8,(byte) 0xa8,(byte) 0x98,(byte) 0x74, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,6,0,0,6,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,-1,6,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(5,8,0,0,6,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(5,9,0,0,6,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(5,9,0,0,6,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(5,9,0,0,6,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(5,9,0,0,6,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(4,9,0,0,5,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x90,(byte) 0x60,(byte) 0x50, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(5,9,0,0,6,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,8,0,0,2,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,9,1,0,2,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(2,9,0,0,2,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(2,9,1,0,2,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(4,8,0,0,5,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(4,9,0,0,5,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(4,9,0,0,5,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(4,9,0,0,5,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(4,8,0,2,5,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7e,(byte) 0x12,(byte) 0xec, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x20,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(5,9,0,0,5,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(5,8,0,0,5,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(5,9,0,0,5,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(5,9,0,0,5,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(5,9,0,0,5,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(5,9,0,0,5,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(4,8,0,0,5,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(5,8,-1,0,7,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,11,0,0,7,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,11,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,11,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,11,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(6,10,-1,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,-1,6,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(6,10,-1,0,8,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(6,11,-1,0,8,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(6,11,-1,0,8,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(6,11,-1,0,8,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(6,11,-1,0,8,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(6,11,-1,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x78,(byte) 0x44,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x44,(byte) 0x78, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(7,8,0,0,8,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,10,0,0,3,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,11,0,0,3,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(2,11,-1,0,3,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(2,11,0,0,3,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(5,10,-1,0,7,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(5,11,-1,0,7,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(5,11,-1,0,7,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(5,11,-1,0,7,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,10,-1,2,8,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x2f,(byte) 0x80,(byte) 0x28,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(9,8,0,0,10,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,11,0,0,7,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,10,0,0,7,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,11,0,0,7,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,11,0,0,7,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,11,0,0,7,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,11,0,0,7,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(4,8,-1,2,6,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xe2,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(9,8,0,0,9,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x27,(byte) 0x12,(byte) 0x15,(byte) 0xb,(byte) 0x48,(byte) 0x44,(byte) 0xc4,(byte) 0x42, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(8,8,0,0,9,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x42,(byte) 0x0, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(9,8,0,0,9,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(5,5,0,0,6,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-3,4,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(2,4,0,-3,3,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(2,2,0,2,3,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,1,0,-3,3,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,10,0,2,6,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(4,8,0,2,5,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-6,3,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-7,3,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-3,4,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-2,7,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(5,5,0,0,6,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-3,4,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-7,3,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x18,(byte) 0x70,(byte) 0xc8,(byte) 0x98,(byte) 0x70,(byte) 0xc0,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,10,0,2,6,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,10,-1,2,3,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,8,0,0,6,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(4,6,0,-1,5,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xb0,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,8,0,0,6,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,8,0,1,6,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,8,-1,2,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,3,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(3,10,0,2,3,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,10,-1,2,3,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(3,10,0,2,3,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,6,0,0,5,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(4,8,0,2,5,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(5,6,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x28,(byte) 0x28,(byte) 0x54,(byte) 0x54,(byte) 0x92,(byte) 0x92, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,6,0,0,6,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(4,6,0,0,5,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(3,8,0,0,4,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(4,6,0,0,5,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,6,0,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,8,0,2,6,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(5,8,0,2,6,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(5,6,0,0,6,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,6,0,0,6,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(1,8,0,0,2,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(4,8,0,0,5,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(1,9,0,1,2,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(1,8,0,0,2,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,8,0,0,6,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x70,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(5,8,0,2,6,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,8,0,0,4,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(4,6,0,0,5,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,8,0,0,6,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(4,6,0,0,5,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(5,8,0,0,6,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(5,6,0,0,5,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-5,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfc, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(6,1,0,2,6,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,5,0,-3,6,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,10,0,2,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(3,8,0,0,3,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,10,-1,2,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(5,8,-1,0,7,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,8,0,0,7,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(5,8,-1,0,7,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(9,8,0,0,9,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,8,0,0,7,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,8,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(5,8,0,0,5,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(5,8,-1,0,7,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(5,8,-1,0,7,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x2,(byte) 0x7c,(byte) 0x8c,(byte) 0x94,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(7,9,-1,1,8,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(5,8,-1,0,7,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,8,-1,0,8,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(6,8,-1,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0xc6,(byte) 0x82, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(7,8,-1,0,9,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(4,8,-1,0,6,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(5,8,-1,0,7,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(4,8,0,0,5,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(1,8,-1,0,3,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(6,8,-1,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,8,-1,0,8,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(5,8,-1,0,6,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(5,8,-1,0,7,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf0,(byte) 0x88,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(6,8,-1,0,8,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,8,-1,0,8,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(5,8,-1,0,7,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,8,0,0,7,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa4,(byte) 0x80,(byte) 0xa4,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40, +(byte) 0x20,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(10,10,0,2,11,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(4,8,-1,0,6,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(3,5,-1,-1,6,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf0,(byte) 0x0,(byte) 0xf0, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(4,3,0,-2,5,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,-1,6,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(5,8,0,0,6,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(5,8,0,0,6,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(5,8,0,0,6,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(5,8,0,0,6,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(5,8,0,0,6,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(5,8,0,0,6,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(5,8,0,0,6,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(5,8,0,0,6,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(2,8,-1,0,6,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(5,8,0,0,6,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(3,8,0,0,3,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,7,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,3,0,2,3,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,-1,6,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-5,4,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,10,-1,2,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,10,0,2,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-5,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x64,(byte) 0x98,(byte) 0x98,(byte) 0xa4,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(6,8,-1,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x26,(byte) 0x29,(byte) 0x16,(byte) 0x10,(byte) 0x8,(byte) 0x68,(byte) 0x94,(byte) 0x64, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(8,8,0,0,9,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,9,0,1,6,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x28,(byte) 0x7c,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,7,0,0,6,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,2,-1,-6,4,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,8,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,3,zerodata); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--10-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica10 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java new file mode 100644 index 0000000..0a24726 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica12.java @@ -0,0 +1,1779 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica12 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x50,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(5,12,-1,3,7,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(5,12,-1,3,7,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(5,13,-1,3,7,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(5,9,-1,0,7,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(5,10,-1,0,7,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(5,10,-1,0,7,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(5,10,-1,0,7,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xb8,(byte) 0x44,(byte) 0x64,(byte) 0x54,(byte) 0x4c,(byte) 0x44,(byte) 0x3a, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(7,7,0,0,7,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,-1,-1,7,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(5,9,-1,0,7,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(5,10,-1,0,7,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(5,10,-1,0,7,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(5,10,-1,0,7,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(5,10,-1,0,7,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(5,10,-1,0,7,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x68, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(5,10,-1,0,7,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,9,0,0,3,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,10,0,0,3,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(2,10,-1,0,3,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(2,10,0,0,3,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(5,9,-1,0,7,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(5,10,-1,0,7,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(5,10,-1,0,7,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(5,10,-1,0,7,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(5,10,-1,3,7,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x77,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x77,(byte) 0x0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(9,7,-1,0,11,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x30,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,7,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(6,9,-1,0,7,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,7,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,7,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,7,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,7,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(5,9,-1,0,7,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,12,-1,0,9,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(6,11,-1,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(6,12,-1,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(6,12,-1,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(6,12,-1,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x0,(byte) 0x5e,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x50,(byte) 0x80,(byte) 0x48,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x42,(byte) 0x80, +(byte) 0x21,(byte) 0x0,(byte) 0x1e,(byte) 0x80,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(10,11,0,1,10,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,-1,-1,7,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x24, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(8,11,-1,0,10,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(8,12,-1,0,10,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x14,(byte) 0x8, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(8,12,-1,0,10,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(8,12,-1,0,10,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x10, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(8,12,-1,0,10,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,12,-1,0,9,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7c,(byte) 0x42,(byte) 0x41,(byte) 0x41,(byte) 0xf1,(byte) 0x41,(byte) 0x41,(byte) 0x42,(byte) 0x7c, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(8,9,0,0,9,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,11,0,0,3,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,12,0,0,3,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(2,12,-1,0,3,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(2,12,0,0,3,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(6,11,-1,0,8,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(6,12,-1,0,8,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(6,12,-1,0,8,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(6,12,-1,0,8,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(7,12,-1,3,9,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x4f,(byte) 0x80,(byte) 0x48,(byte) 0x0,(byte) 0x28,(byte) 0x0,(byte) 0x28,(byte) 0x0, +(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(9,9,-1,0,11,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,12,-1,0,9,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,12,-1,0,9,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,12,-1,0,9,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,12,-1,0,9,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,12,-1,0,9,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(5,9,-1,3,7,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0xc9,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x22,(byte) 0x0, +(byte) 0xe1,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(9,9,0,0,10,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x47,(byte) 0x80,(byte) 0x22,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x4b,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0, +(byte) 0x41,(byte) 0x0, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(9,9,0,0,10,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x41,(byte) 0x0,(byte) 0x27,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0, +(byte) 0x41,(byte) 0x0, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(9,9,0,0,10,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(5,5,-1,-1,7,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,-1,-4,5,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(2,5,-1,-3,4,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(3,4,0,3,3,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(1,1,-1,-3,3,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x68,(byte) 0x3c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,12,0,3,7,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(5,10,-1,3,7,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-8,2,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,5,0,-3,4,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(4,5,0,-3,4,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,0,7,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-4,5,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(4,1,0,-8,4,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x98,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0, +(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(9,9,-1,0,11,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(4,1,0,-3,5,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,8,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(5,5,-1,-1,7,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,-1,-4,5,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x9c,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa0,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0, +(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(9,9,-1,0,11,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-8,3,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x30,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(5,12,0,3,6,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-1,2,3,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,9,-1,0,7,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(6,6,0,-1,7,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xb0,(byte) 0x48,(byte) 0x20,(byte) 0x20,(byte) 0xf0,(byte) 0x40,(byte) 0x40,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,9,-1,0,7,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x70,(byte) 0xc8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(5,9,-1,1,7,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,10,-1,3,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,4,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(4,12,0,3,4,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-1,3,3,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(4,12,0,3,4,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,7,-1,0,6,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(5,10,-1,3,7,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(6,7,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(9,7,0,0,9,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,7,-1,0,7,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(5,7,-1,0,7,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(3,9,0,0,3,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(4,7,-1,0,6,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,7,-1,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,10,-1,3,7,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(5,10,-1,3,7,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(5,7,-1,0,7,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,7,-1,0,7,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xda,(byte) 0xa4, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(1,9,-1,0,3,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(5,9,-1,0,6,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(2,12,0,3,3,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(1,9,-1,0,3,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,9,-1,0,7,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(5,10,-1,3,7,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,9,0,0,3,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(5,7,-1,0,7,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,9,-1,0,7,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(5,7,-1,0,7,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(5,9,-1,0,7,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(6,7,-1,0,7,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-6,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xfe, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,2,7,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(5,3,0,-5,6,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,12,0,3,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(4,9,0,0,4,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,12,-1,3,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(7,9,-1,0,9,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,9,-1,0,9,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0x82,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,9,-1,0,9,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80, +(byte) 0x88,(byte) 0x80, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(9,9,-1,0,11,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,9,-1,0,9,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,7,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x18,(byte) 0x60,(byte) 0x80,(byte) 0x84,(byte) 0x78, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x3d,(byte) 0x42,(byte) 0x85,(byte) 0x89,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(8,9,-1,0,10,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(8,9,-1,0,10,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,9,-1,0,9,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(9,9,-1,0,11,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(5,9,-1,0,7,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(7,9,-1,0,8,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(5,9,-1,0,7,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(1,9,-1,0,3,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,9,-1,0,9,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x3a,(byte) 0x46,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(7,9,-1,0,9,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf8,(byte) 0x84,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(7,9,-1,0,9,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(7,9,-1,0,9,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(6,9,-1,0,8,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,9,-1,0,9,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa6,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40, +(byte) 0x60,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(10,10,-1,1,12,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(5,9,-1,0,7,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(6,5,-1,-1,7,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf8,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(5,3,-1,-2,7,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0xc,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(6,5,0,-1,7,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x78,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(5,9,-1,0,7,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(5,9,-1,0,7,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(5,9,-1,0,7,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(5,9,-1,0,7,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(5,9,-1,0,7,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x28,(byte) 0x18,(byte) 0x8, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(6,9,0,0,7,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(5,9,-1,0,7,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(5,9,-1,0,7,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x20, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(3,9,-1,0,7,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(5,9,-1,0,7,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(4,9,0,0,4,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,8,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,3,-1,2,4,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-1,7,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,-1,-6,5,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,12,0,3,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-1,3,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-6,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x72,(byte) 0x8c,(byte) 0x84,(byte) 0x8a,(byte) 0x50,(byte) 0x30,(byte) 0x48,(byte) 0x48,(byte) 0x30, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(7,9,-1,0,9,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x23,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x14,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x68,(byte) 0x0,(byte) 0x94,(byte) 0x0,(byte) 0x94,(byte) 0x0, +(byte) 0x62,(byte) 0x0, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(9,9,-1,0,11,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(5,10,-1,1,7,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0x50,(byte) 0xfc,(byte) 0x28,(byte) 0xfc,(byte) 0x28,(byte) 0x28, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(6,8,0,0,7,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,3,-1,-6,5,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,4,zerodata); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--12-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica12 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java new file mode 100644 index 0000000..4f5ba1b --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapHelvetica18.java @@ -0,0 +1,1888 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapHelvetica18 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66, +(byte) 0x66, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(8,17,-1,4,10,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(9,18,-1,4,11,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18, +(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(8,18,-1,4,10,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x66, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(8,13,-1,0,10,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(8,14,-1,0,10,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(8,14,-1,0,10,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x30, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(8,14,-1,0,10,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xce,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x31,(byte) 0x80,(byte) 0x78,(byte) 0xc0,(byte) 0x6c,(byte) 0xc0,(byte) 0x66,(byte) 0xc0,(byte) 0x63,(byte) 0xc0,(byte) 0x31,(byte) 0x80, +(byte) 0x3f,(byte) 0xc0,(byte) 0xe,(byte) 0x60, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(11,10,0,0,11,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(8,8,-1,-1,10,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x36,(byte) 0x0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(9,13,-1,0,11,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x26,(byte) 0x0,(byte) 0x2d,(byte) 0x0,(byte) 0x19,(byte) 0x0, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(9,14,-1,0,11,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(9,14,-1,0,11,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(9,14,-1,0,11,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(9,14,-1,0,11,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(8,14,-1,0,10,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x4c,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(9,14,-1,0,11,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(5,13,0,0,4,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc,(byte) 0x78,(byte) 0x30, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(6,14,1,0,4,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(4,14,0,0,4,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(4,14,0,0,4,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x36,(byte) 0x36, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(8,13,-1,0,10,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(8,14,-1,0,10,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(8,14,-1,0,10,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(8,14,-1,0,10,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x78,(byte) 0x6c,(byte) 0xc,(byte) 0x38,(byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(8,14,-1,4,10,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x75,(byte) 0xe0,(byte) 0xef,(byte) 0xf8,(byte) 0xc7,(byte) 0x18,(byte) 0xc6,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0x7f,(byte) 0xf8,(byte) 0xe,(byte) 0x18,(byte) 0xc6,(byte) 0x18, +(byte) 0xef,(byte) 0xf0,(byte) 0x7d,(byte) 0xe0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(13,10,-1,0,15,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x38,(byte) 0x6c,(byte) 0x6c,(byte) 0x38, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(7,14,-1,0,9,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x6c,(byte) 0x6c, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(7,13,-1,0,9,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(7,14,-1,0,9,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(7,14,-1,0,9,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x18,(byte) 0xc, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(7,14,-1,0,9,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(7,14,-1,0,9,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xdc,(byte) 0xde,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xdc,(byte) 0xdc,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0x7c,(byte) 0x38, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(7,14,-1,0,9,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(10,14,-1,0,12,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(12,18,-1,0,14,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(11,17,-1,0,13,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(11,18,-1,0,13,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(11,18,-1,0,13,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(11,18,-1,0,13,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0xc7,(byte) 0xc0,(byte) 0xff,(byte) 0xf0,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x18,(byte) 0x6c,(byte) 0x1c,(byte) 0x6e,(byte) 0xc,(byte) 0x67,(byte) 0xc,(byte) 0x63,(byte) 0x8c, +(byte) 0x61,(byte) 0xcc,(byte) 0x70,(byte) 0xdc,(byte) 0x30,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x1f,(byte) 0xfc,(byte) 0x7,(byte) 0xcc, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(14,14,0,0,15,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80, +(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(10,9,0,0,10,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xd,(byte) 0x80, +(byte) 0xd,(byte) 0x80, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(13,17,-1,0,15,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x9,(byte) 0x80, +(byte) 0xb,(byte) 0x40,(byte) 0x6,(byte) 0x40, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(13,18,-1,0,15,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0xc0, +(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(13,18,-1,0,15,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(13,18,-1,0,15,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(13,18,-1,0,15,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60, +(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0, +(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(11,18,-1,0,13,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7f,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0xfc,(byte) 0x30, +(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0x80, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(12,14,0,0,13,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc, +(byte) 0xcc, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(6,17,0,0,6,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc, +(byte) 0x78,(byte) 0x30, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(6,18,0,0,6,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, +(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(4,18,-2,0,6,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x30, +(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(4,18,0,0,6,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(9,17,-1,0,11,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(9,18,-1,0,11,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(9,18,-1,0,11,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(9,18,-1,0,11,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30, +(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70, +(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(12,18,-1,4,14,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xc1,(byte) 0xff,(byte) 0xc1,(byte) 0xff,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3f,(byte) 0x80,(byte) 0x31,(byte) 0xfe,(byte) 0x31,(byte) 0xfe, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0x7,(byte) 0xff,(byte) 0x7,(byte) 0xff, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(16,14,-1,0,18,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(12,18,0,0,12,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(12,17,0,0,12,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0, +(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(12,18,0,0,12,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(12,18,0,0,12,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(12,18,0,0,12,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(12,18,0,0,12,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0xc6,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(7,14,-1,4,10,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xfc,(byte) 0x6,(byte) 0xd8,(byte) 0x6,(byte) 0x78,(byte) 0x73,(byte) 0x38,(byte) 0xf9,(byte) 0x18,(byte) 0x99,(byte) 0x88, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x98,(byte) 0x60,(byte) 0xf8,(byte) 0x30,(byte) 0x70,(byte) 0x30, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(14,13,0,0,15,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x30,(byte) 0xf8,(byte) 0x30,(byte) 0xf8,(byte) 0x18,(byte) 0x60,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x18,(byte) 0x66,(byte) 0x98,(byte) 0x62,(byte) 0xf8,(byte) 0x63,(byte) 0x70, +(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(13,13,-1,0,15,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x19,(byte) 0xf8,(byte) 0xd,(byte) 0xb0,(byte) 0xc,(byte) 0xf0,(byte) 0x66,(byte) 0x70,(byte) 0x62,(byte) 0x30,(byte) 0x63,(byte) 0x10, +(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(13,13,-1,0,15,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x90,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0x90, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0x88,(byte) 0xd8,(byte) 0x70, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(5,8,-1,-6,7,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,8,-1,-5,6,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xf0,(byte) 0xd8,(byte) 0x18,(byte) 0x70,(byte) 0x60, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(5,5,0,4,5,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-1,-4,4,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x32,(byte) 0x72,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2, +(byte) 0x72,(byte) 0x3f, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(8,18,-1,4,10,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xdb,(byte) 0xff,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(8,14,-1,4,10,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x30, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(4,3,0,-11,4,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x70,(byte) 0xf8,(byte) 0x98,(byte) 0x30,(byte) 0x30,(byte) 0x98,(byte) 0xf8,(byte) 0x70, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(5,8,0,-5,6,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xf8,(byte) 0xf8,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0x98,(byte) 0xf8,(byte) 0x70, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(5,8,0,-5,6,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(8,11,-1,0,10,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0xd8,(byte) 0x70, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(5,5,-1,-8,7,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(5,1,0,-12,5,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x48,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x89,(byte) 0x8,(byte) 0x8f,(byte) 0x88,(byte) 0x88,(byte) 0x48, +(byte) 0x88,(byte) 0x48,(byte) 0x4f,(byte) 0x90,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(13,13,-1,0,14,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xf8,(byte) 0xf8, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(5,2,-1,-4,7,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(9,5,-1,-3,11,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x12,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x12, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x68,(byte) 0xd8,(byte) 0x48,(byte) 0x38,(byte) 0xc8,(byte) 0x70, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(5,8,-1,-6,7,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x47,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8, +(byte) 0x88,(byte) 0x88,(byte) 0x47,(byte) 0x10,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(13,13,-1,0,15,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(5,2,0,-11,6,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xc3,(byte) 0xc3,(byte) 0x7,(byte) 0xe,(byte) 0x3e,(byte) 0x73,(byte) 0xe3,(byte) 0xc3,(byte) 0xc7,(byte) 0x6e,(byte) 0x7c,(byte) 0xf0,(byte) 0xc3,(byte) 0xc3, +(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(8,18,-1,4,10,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-1,3,4,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0x18,(byte) 0xff,(byte) 0x3c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(8,13,-1,0,10,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0xc3,(byte) 0xff,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xff,(byte) 0xc3, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(8,7,-1,-3,10,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xdf,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x60,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x3f,(byte) 0x0,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(9,13,0,0,10,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x10,(byte) 0x10,(byte) 0x3e,(byte) 0x7f,(byte) 0x6b,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0x6b,(byte) 0x7f,(byte) 0x3e,(byte) 0x4,(byte) 0x4, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(8,14,-1,2,10,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(2,14,-2,4,6,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,5,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0xcc,(byte) 0x7e,(byte) 0x33, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(8,3,-1,-4,10,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x60,(byte) 0xc0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(6,18,0,4,6,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(2,18,-1,4,4,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x18,(byte) 0xc, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(6,18,0,4,6,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xfe,(byte) 0xfe,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x6,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(7,10,-1,0,9,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(8,14,-1,4,10,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xc3,(byte) 0xe7,(byte) 0x66,(byte) 0x3c,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x66,(byte) 0xe7,(byte) 0xc3, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(8,10,-1,0,10,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x39,(byte) 0xc0,(byte) 0x29,(byte) 0x40,(byte) 0x69,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0xc6,(byte) 0x30, +(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(12,10,-1,0,14,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(8,10,-1,0,10,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(8,10,-1,0,10,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x18,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(6,13,0,0,6,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0x78,(byte) 0xfc,(byte) 0xc6,(byte) 0x6,(byte) 0x3e,(byte) 0xfc,(byte) 0xc0,(byte) 0xc6,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(7,10,-1,0,9,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(5,10,-1,0,6,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(9,14,-1,4,11,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(9,14,-1,4,11,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0, +(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(9,10,-1,0,11,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(8,10,-1,0,10,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xe7,(byte) 0x30, +(byte) 0xde,(byte) 0xf0,(byte) 0xcc,(byte) 0x60, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(12,10,-1,0,14,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(2,14,-1,0,4,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0xc7,(byte) 0xc6,(byte) 0xce,(byte) 0xcc,(byte) 0xd8,(byte) 0xf8,(byte) 0xf0,(byte) 0xd8,(byte) 0xcc,(byte) 0xc6,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(8,14,-1,0,9,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0xe0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0, +(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(4,18,1,4,4,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(2,14,-1,0,4,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(8,14,-1,0,10,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x1c,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(9,14,-1,4,11,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x3c,(byte) 0x1c, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(6,14,0,0,6,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(8,10,-1,0,10,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80, +(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(9,14,-1,0,11,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(8,10,-1,0,10,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0, +(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(9,14,-1,0,11,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(7,10,-1,0,9,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,5,-1,-9,4,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(10,2,0,4,10,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x82,(byte) 0xc6,(byte) 0x6c,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(7,5,-1,-8,9,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xf0,(byte) 0xf0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(4,18,0,4,5,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(5,14,0,0,5,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf0,(byte) 0xf0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xf0,(byte) 0xf0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(4,18,-1,4,5,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(10,14,-1,0,12,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80, +(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(12,14,-1,0,14,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1b,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(11,14,-1,0,13,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x1c,(byte) 0x38,(byte) 0x34,(byte) 0x2c,(byte) 0x36,(byte) 0x6c,(byte) 0x36,(byte) 0x6c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0x66, +(byte) 0x62,(byte) 0x46,(byte) 0x63,(byte) 0xc6,(byte) 0xc3,(byte) 0xc3,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(16,14,-1,0,18,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(12,14,-1,0,14,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(11,14,-1,0,13,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0, +(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(10,14,-1,0,12,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x3f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0,(byte) 0x1f,(byte) 0x0, +(byte) 0x7c,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(11,14,-1,0,13,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(10,14,-1,0,12,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x0,(byte) 0x30,(byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0xf0,(byte) 0x61,(byte) 0xb0,(byte) 0xe1,(byte) 0xb8,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(13,15,-1,1,15,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(10,14,-1,0,12,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18, +(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(13,14,-1,0,15,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60, +(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(11,14,-1,0,13,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xc3,(byte) 0xc,(byte) 0xc3,(byte) 0xc,(byte) 0xc7,(byte) 0x8c,(byte) 0xc4,(byte) 0x8c,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xd8,(byte) 0x6c,(byte) 0xd8,(byte) 0x6c, +(byte) 0xf0,(byte) 0x3c,(byte) 0xf0,(byte) 0x3c,(byte) 0xe0,(byte) 0x1c,(byte) 0xe0,(byte) 0x1c,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(14,14,-1,0,16,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(8,14,-1,0,10,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xc0,(byte) 0x70,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc7,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0xf8,(byte) 0x0, +(byte) 0xdc,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(12,14,-1,0,13,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(8,14,-1,0,10,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(2,14,-2,0,6,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xff,(byte) 0xe0,(byte) 0xff,(byte) 0xe0, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(11,14,-1,0,13,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xf0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x30,(byte) 0xc1,(byte) 0xf0,(byte) 0xc1,(byte) 0xf0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(12,14,-1,0,14,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(9,14,-1,0,11,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(9,14,-1,0,11,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60, +(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(11,14,-1,0,13,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(12,14,-1,0,14,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(11,14,-1,0,13,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0, +(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(12,14,0,0,12,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1f,(byte) 0xf0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x67,(byte) 0x70,(byte) 0xcf,(byte) 0xf8,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x66, +(byte) 0xcc,(byte) 0x66,(byte) 0xcc,(byte) 0x63,(byte) 0xc6,(byte) 0x33,(byte) 0x67,(byte) 0x73,(byte) 0x63,(byte) 0xb3,(byte) 0x30,(byte) 0x6,(byte) 0x1c,(byte) 0xe,(byte) 0xf,(byte) 0xfc, +(byte) 0x3,(byte) 0xf0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(16,17,-1,3,18,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0xc6,(byte) 0xc6,(byte) 0xfe,(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(7,14,-1,0,10,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0xf0,(byte) 0x3c,(byte) 0xe,(byte) 0x3,(byte) 0xe,(byte) 0x3c,(byte) 0xf0,(byte) 0xc0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(8,9,-1,0,10,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xfe,(byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(7,6,-2,-2,11,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x3,(byte) 0xf,(byte) 0x3c,(byte) 0x70,(byte) 0xc0,(byte) 0x70,(byte) 0x3c,(byte) 0xf,(byte) 0x3, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(8,9,-1,0,10,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(2,13,-1,3,5,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,10,-1,0,5,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0x3,(byte) 0x3,(byte) 0x3b,(byte) 0x7f,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc7,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(8,13,-1,0,10,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xe7,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(8,13,-1,0,10,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0x6,(byte) 0x3,(byte) 0xff,(byte) 0xff, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(8,13,-1,0,10,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xe3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xfe,(byte) 0xdc,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3c, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(8,13,-1,0,10,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7c,(byte) 0xfe,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0xc7,(byte) 0xfe,(byte) 0xfc,(byte) 0xc0,(byte) 0xc0,(byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(8,13,-1,0,10,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x33,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(9,13,-1,0,10,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x1c,(byte) 0x6,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(8,13,-1,0,10,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0x7,(byte) 0x3,(byte) 0xc3,(byte) 0xfe,(byte) 0x3c, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(8,13,-1,0,10,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8,(byte) 0xf8,(byte) 0x18, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(5,13,-2,0,10,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x3c,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x3c, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(8,13,-1,0,10,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(5,14,0,0,5,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-1,0,5,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xff,(byte) 0xff, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(8,2,-1,-4,11,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-1,3,5,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(8,10,-1,0,10,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x88,(byte) 0x70,(byte) 0x70,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(5,6,-1,-8,7,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0x60, +(byte) 0xc0,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(4,18,-1,4,6,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60, +(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(4,18,-1,4,6,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,5,-1,-9,4,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x3c,(byte) 0x70,(byte) 0x7e,(byte) 0xe0,(byte) 0xe7,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc3,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0xee,(byte) 0xc0,(byte) 0x7c,(byte) 0x0, +(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x3c,(byte) 0x0, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(12,13,-1,0,13,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x18,(byte) 0x78,(byte) 0x18,(byte) 0xfc,(byte) 0xc,(byte) 0xcc,(byte) 0xc,(byte) 0xcc,(byte) 0x6,(byte) 0xfc,(byte) 0x6,(byte) 0x78,(byte) 0x3,(byte) 0x0,(byte) 0x7b,(byte) 0x0, +(byte) 0xfd,(byte) 0x80,(byte) 0xcd,(byte) 0x80,(byte) 0xcc,(byte) 0xc0,(byte) 0xfc,(byte) 0xc0,(byte) 0x78,(byte) 0x60, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(14,13,-1,0,16,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x9,(byte) 0x80,(byte) 0xf,(byte) 0x0, +(byte) 0x3e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe8,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xcb,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(9,16,-1,2,10,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0, +(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0xc0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(10,13,0,0,10,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x90,(byte) 0x90,(byte) 0xd8,(byte) 0xd8,(byte) 0xd8, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(5,5,0,-9,5,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(2,14,-2,0,6,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,5,zerodata); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-helvetica-medium-r-*--18-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapHelvetica18 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java new file mode 100644 index 0000000..4c69b9d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman10.java @@ -0,0 +1,1768 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapTimesRoman10 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(5,9,0,2,5,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(4,9,0,2,5,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(5,10,0,2,5,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(5,7,0,0,5,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(5,8,0,0,5,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(5,8,0,0,5,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(5,8,0,0,5,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0x80,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x38,(byte) 0x4, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(6,7,1,1,5,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,0,6,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(4,7,0,0,5,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(4,8,0,0,5,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(4,8,0,0,5,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(4,8,0,0,5,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(4,8,0,0,5,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(5,8,0,0,5,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0xa0,(byte) 0x70,(byte) 0x40, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(4,8,0,0,5,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(3,7,0,0,4,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(3,8,0,0,4,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(3,8,0,0,4,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(3,8,0,0,4,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(3,7,0,0,4,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(3,8,0,0,4,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(3,8,0,0,4,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(3,8,0,0,4,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(3,8,0,3,4,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0xd8,(byte) 0xa0,(byte) 0x70,(byte) 0x28,(byte) 0xd8, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(5,5,0,0,6,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x40,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(3,8,0,0,4,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(3,7,0,0,4,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(4,8,0,0,4,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(3,8,0,0,4,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(3,8,0,0,4,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(3,8,0,0,4,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xe0,(byte) 0x50,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(4,7,0,0,5,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x70,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(5,7,0,0,6,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(7,10,0,0,8,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(7,9,0,0,8,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(7,10,0,0,8,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(7,10,0,0,8,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(7,10,0,0,8,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x80,(byte) 0x7c,(byte) 0x66,(byte) 0x52,(byte) 0x52,(byte) 0x4a,(byte) 0x66,(byte) 0x3e,(byte) 0x1, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(8,9,0,1,8,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,0,6,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(6,9,0,0,7,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(6,10,0,0,7,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(6,10,0,0,7,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(6,10,0,0,7,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(6,10,0,0,7,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee,(byte) 0x0,(byte) 0x50,(byte) 0x28, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0xe4,(byte) 0x44,(byte) 0x4c,(byte) 0xf8, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(6,7,0,0,7,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(3,9,0,0,4,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(3,10,0,0,4,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(3,10,0,0,4,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(3,10,0,0,4,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(5,9,0,0,6,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(5,10,0,0,6,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(5,10,0,0,6,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(5,10,0,0,6,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(6,10,0,3,7,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xef,(byte) 0x49,(byte) 0x78,(byte) 0x2e,(byte) 0x28,(byte) 0x39,(byte) 0x1f, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(8,7,0,0,9,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(7,10,0,0,8,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(7,9,0,0,8,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(7,10,0,0,8,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(7,10,0,0,8,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(7,10,0,0,8,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(7,10,0,0,8,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(3,7,0,2,4,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xd4,(byte) 0x28,(byte) 0x48,(byte) 0xe4, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(7,7,0,0,8,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x4e,(byte) 0x24,(byte) 0x2a,(byte) 0xf6,(byte) 0x48,(byte) 0xc8,(byte) 0x44, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(7,7,0,0,8,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xf4,(byte) 0x48,(byte) 0xc8,(byte) 0x44, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(7,7,0,0,8,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0xa0,(byte) 0x50,(byte) 0x50,(byte) 0xa0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(4,4,0,-1,5,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-2,4,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(3,4,0,-3,3,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(3,3,0,3,4,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(1,1,0,-2,2,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(6,9,0,2,6,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(5,7,0,2,5,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-5,3,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-6,4,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xe0, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-2,4,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x8,(byte) 0x8,(byte) 0xf8, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-1,7,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x50,(byte) 0xa0,(byte) 0xa0,(byte) 0x50, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(4,4,0,-1,5,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-2,4,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xa0, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(3,1,-1,-6,5,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x20,(byte) 0x50,(byte) 0x90,(byte) 0xa0,(byte) 0x40,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(4,9,0,1,5,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(1,7,0,0,2,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0x70,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xd8,(byte) 0x50,(byte) 0x88, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(5,7,0,0,5,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0x88,(byte) 0x70,(byte) 0x50,(byte) 0x50,(byte) 0x70,(byte) 0x88, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(5,6,0,-1,5,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xf0,(byte) 0xc8,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x50,(byte) 0x30, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(5,7,0,0,5,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x10, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(4,7,0,1,5,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(1,7,-1,2,3,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,2,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x98,(byte) 0x64, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-2,7,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(3,9,0,2,4,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(1,9,0,2,2,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(3,9,0,2,4,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xf0,(byte) 0x90,(byte) 0x40,(byte) 0x20,(byte) 0xf0, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(4,5,0,0,5,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x48,(byte) 0xdc, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(6,7,1,2,5,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xd8,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0xd8, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(5,5,0,0,6,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x28,(byte) 0x6c,(byte) 0x54,(byte) 0x92,(byte) 0xdb, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(8,5,0,0,8,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x20,(byte) 0x60,(byte) 0x50,(byte) 0x90,(byte) 0xd8, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(5,5,0,0,5,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(5,5,0,0,5,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(4,6,0,0,4,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0xe0,(byte) 0x20,(byte) 0x60,(byte) 0x80,(byte) 0xe0, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(3,5,0,0,4,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(3,5,0,0,4,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x38,(byte) 0x10,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(5,7,0,2,5,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(4,7,0,2,5,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(4,5,0,0,5,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(5,5,0,0,5,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xdb,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(8,5,0,0,8,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(3,7,0,0,4,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0x98,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(5,7,0,0,5,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(2,9,0,2,3,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(2,7,0,0,3,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(5,7,0,0,5,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x60,(byte) 0x40,(byte) 0xa0,(byte) 0xa0,(byte) 0x70, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(4,7,0,2,5,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(4,7,0,0,4,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(3,5,0,0,4,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0x30, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(5,7,0,0,5,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(3,5,0,0,4,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(4,7,0,0,5,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(3,5,0,0,4,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0xc0,(byte) 0x80, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(2,2,0,-5,3,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xf8, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(5,1,0,3,5,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0xa0,(byte) 0xa0,(byte) 0x40, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(3,3,-1,-4,5,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(2,9,0,2,3,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(3,7,0,0,3,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(2,9,0,2,3,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xf8,(byte) 0x88,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x88,(byte) 0xf8, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(5,7,0,0,6,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(7,7,0,0,8,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xee,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(7,7,0,0,8,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0xdd,(byte) 0xc0, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(10,7,0,0,10,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x6c,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(7,7,0,0,8,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(7,7,0,0,8,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0x70,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa8,(byte) 0xf8, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(5,7,0,0,6,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0xc0,(byte) 0x90,(byte) 0x70, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(4,7,0,0,5,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(6,7,0,0,7,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0xc,(byte) 0x18,(byte) 0x70,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(6,9,0,2,7,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(5,7,0,0,6,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(6,7,0,0,7,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(7,7,0,0,8,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xeb,(byte) 0x80,(byte) 0x49,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xe3,(byte) 0x80, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(9,7,0,0,10,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(5,7,0,0,6,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x48,(byte) 0xec, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(6,7,0,0,7,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0xc0,(byte) 0xa0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(4,7,0,0,4,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(3,7,0,0,4,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xee,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0xee, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(7,7,0,0,8,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x78,(byte) 0xc4,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(6,7,0,0,7,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(5,7,0,0,6,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(5,7,0,0,6,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x4c,(byte) 0xf8, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(6,7,0,0,7,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(6,7,0,0,7,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xf0,(byte) 0x48,(byte) 0x48,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(5,7,0,0,6,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(7,7,0,0,8,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3e,(byte) 0x40,(byte) 0x92,(byte) 0xad,(byte) 0xa5,(byte) 0xa5,(byte) 0x9d,(byte) 0x42,(byte) 0x3c, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(8,9,0,2,9,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xa0,(byte) 0xe0, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(3,7,0,0,4,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(3,5,0,0,5,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xf8,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(5,3,0,-1,6,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,0,5,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(1,7,-1,2,3,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(1,5,-1,0,3,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0xc0,(byte) 0x20,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(4,7,0,0,5,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(4,7,0,0,5,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x90,(byte) 0xf0, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(4,7,0,0,5,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x40,(byte) 0x30, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(4,7,0,0,5,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0xe0,(byte) 0x40,(byte) 0x70, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(4,7,0,0,5,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(5,7,0,0,5,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(4,7,0,0,5,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(4,7,0,0,5,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(3,7,-1,0,5,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(4,7,0,0,5,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(3,7,0,0,3,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0x80, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xf0, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(4,1,-1,-2,7,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(1,3,-1,2,3,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,0,6,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0xa0,(byte) 0x40,(byte) 0xa0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-4,5,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(3,9,0,2,4,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(3,9,0,2,4,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0x40,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(2,2,0,-5,3,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x76,(byte) 0x8d,(byte) 0x98,(byte) 0x74,(byte) 0x6e,(byte) 0x50,(byte) 0x30, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(8,7,0,0,8,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x44,(byte) 0x2a,(byte) 0x2a,(byte) 0x56,(byte) 0xa8,(byte) 0xa4,(byte) 0x7e, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(7,7,0,0,8,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x20,(byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x20, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(4,9,0,1,5,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0x50, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(5,7,0,0,5,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0xa0,(byte) 0xa0, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(3,2,0,-5,4,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(1,7,-1,0,3,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,2,zerodata); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-times-medium-r-*--10-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapTimesRoman10 diff --git a/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java new file mode 100644 index 0000000..2a00176 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutBitmapTimesRoman24.java @@ -0,0 +1,2051 @@ + +// GENERATED FILE -- DO NOT MODIFY + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + + +public class glutBitmapTimesRoman24 implements GLUTBitmapFont { + private static byte[] zerodata={ 0 }; +// char: 0xff + + static final byte[] ch255data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch255 = new BitmapCharRec(11,21,0,5,11,ch255data); + +// char: 0xfe + + static final byte[] ch254data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch254 = new BitmapCharRec(10,22,-1,5,12,ch254data); + +// char: 0xfd + + static final byte[] ch253data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch253 = new BitmapCharRec(11,22,0,5,11,ch253data); + +// char: 0xfc + + static final byte[] ch252data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch252 = new BitmapCharRec(11,16,-1,0,13,ch252data); + +// char: 0xfb + + static final byte[] ch251data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch251 = new BitmapCharRec(11,17,-1,0,13,ch251data); + +// char: 0xfa + + static final byte[] ch250data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80, +(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch250 = new BitmapCharRec(11,17,-1,0,13,ch250data); + +// char: 0xf9 + + static final byte[] ch249data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch249 = new BitmapCharRec(11,17,-1,0,13,ch249data); + +// char: 0xf8 + + static final byte[] ch248data = { + (byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x71,(byte) 0x80,(byte) 0xd0,(byte) 0xc0,(byte) 0xd8,(byte) 0xc0,(byte) 0xc8,(byte) 0xc0,(byte) 0xcc,(byte) 0xc0, +(byte) 0xc4,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch248 = new BitmapCharRec(10,14,-1,1,12,ch248data); + +// char: 0xf7 + + static final byte[] ch247data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch247 = new BitmapCharRec(12,10,-1,-2,14,ch247data); + +// char: 0xf6 + + static final byte[] ch246data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch246 = new BitmapCharRec(10,16,-1,0,12,ch246data); + +// char: 0xf5 + + static final byte[] ch245data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80, + }; + + static final BitmapCharRec ch245 = new BitmapCharRec(10,16,-1,0,12,ch245data); + +// char: 0xf4 + + static final byte[] ch244data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch244 = new BitmapCharRec(10,17,-1,0,12,ch244data); + +// char: 0xf3 + + static final byte[] ch243data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80, +(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch243 = new BitmapCharRec(10,17,-1,0,12,ch243data); + +// char: 0xf2 + + static final byte[] ch242data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch242 = new BitmapCharRec(10,17,-1,0,12,ch242data); + +// char: 0xf1 + + static final byte[] ch241data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80, + }; + + static final BitmapCharRec ch241 = new BitmapCharRec(11,16,-1,0,13,ch241data); + +// char: 0xf0 + + static final byte[] ch240data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x71,(byte) 0x80, +(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch240 = new BitmapCharRec(10,17,-1,0,12,ch240data); + +// char: 0xef + + static final byte[] ch239data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch239 = new BitmapCharRec(6,16,0,0,6,ch239data); + +// char: 0xee + + static final byte[] ch238data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x84,(byte) 0x48,(byte) 0x78, +(byte) 0x30, + }; + + static final BitmapCharRec ch238 = new BitmapCharRec(6,17,0,0,6,ch238data); + +// char: 0xed + + static final byte[] ch237data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x80,(byte) 0x60,(byte) 0x38, +(byte) 0x18, + }; + + static final BitmapCharRec ch237 = new BitmapCharRec(5,17,-1,0,6,ch237data); + +// char: 0xec + + static final byte[] ch236data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch236 = new BitmapCharRec(5,17,0,0,6,ch236data); + +// char: 0xeb + + static final byte[] ch235data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0, + }; + + static final BitmapCharRec ch235 = new BitmapCharRec(9,16,-1,0,11,ch235data); + +// char: 0xea + + static final byte[] ch234data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0, +(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch234 = new BitmapCharRec(9,17,-1,0,11,ch234data); + +// char: 0xe9 + + static final byte[] ch233data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch233 = new BitmapCharRec(9,17,-1,0,11,ch233data); + +// char: 0xe8 + + static final byte[] ch232data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0, +(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch232 = new BitmapCharRec(9,17,-1,0,11,ch232data); + +// char: 0xe7 + + static final byte[] ch231data = { + (byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0, +(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80, +(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch231 = new BitmapCharRec(9,18,-1,6,11,ch231data); + +// char: 0xe6 + + static final byte[] ch230data = { + (byte) 0x70,(byte) 0xf0,(byte) 0xfb,(byte) 0xf8,(byte) 0xc7,(byte) 0x84,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0xfc, +(byte) 0x3,(byte) 0xc,(byte) 0x63,(byte) 0xc,(byte) 0x67,(byte) 0x98,(byte) 0x3c,(byte) 0xf0, + }; + + static final BitmapCharRec ch230 = new BitmapCharRec(14,12,-1,0,16,ch230data); + +// char: 0xe5 + + static final byte[] ch229data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch229 = new BitmapCharRec(9,17,-1,0,11,ch229data); + +// char: 0xe4 + + static final byte[] ch228data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0, + }; + + static final BitmapCharRec ch228 = new BitmapCharRec(9,16,-1,0,11,ch228data); + +// char: 0xe3 + + static final byte[] ch227data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x5c,(byte) 0x0,(byte) 0x3a,(byte) 0x0, + }; + + static final BitmapCharRec ch227 = new BitmapCharRec(9,16,-1,0,11,ch227data); + +// char: 0xe2 + + static final byte[] ch226data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x42,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x3c,(byte) 0x0, +(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch226 = new BitmapCharRec(9,17,-1,0,11,ch226data); + +// char: 0xe1 + + static final byte[] ch225data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch225 = new BitmapCharRec(9,17,-1,0,11,ch225data); + +// char: 0xe0 + + static final byte[] ch224data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0, +(byte) 0x60,(byte) 0x0, + }; + + static final BitmapCharRec ch224 = new BitmapCharRec(9,17,-1,0,11,ch224data); + +// char: 0xdf + + static final byte[] ch223data = { + (byte) 0xe7,(byte) 0x0,(byte) 0x6c,(byte) 0x80,(byte) 0x6c,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x63,(byte) 0x80, +(byte) 0x67,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch223 = new BitmapCharRec(10,17,-1,0,12,ch223data); + +// char: 0xde + + static final byte[] ch222data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18, +(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0xfc,(byte) 0x0, + }; + + static final BitmapCharRec ch222 = new BitmapCharRec(13,17,-1,0,15,ch222data); + +// char: 0xdd + + static final byte[] ch221data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0, +(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc, +(byte) 0xfc,(byte) 0x3f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch221 = new BitmapCharRec(16,22,0,0,16,ch221data); + +// char: 0xdc + + static final byte[] ch220data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30, + }; + + static final BitmapCharRec ch220 = new BitmapCharRec(16,21,-1,0,18,ch220data); + +// char: 0xdb + + static final byte[] ch219data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch219 = new BitmapCharRec(16,22,-1,0,18,ch219data); + +// char: 0xda + + static final byte[] ch218data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch218 = new BitmapCharRec(16,22,-1,0,18,ch218data); + +// char: 0xd9 + + static final byte[] ch217data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch217 = new BitmapCharRec(16,22,-1,0,18,ch217data); + +// char: 0xd8 + + static final byte[] ch216data = { + (byte) 0x20,(byte) 0x0,(byte) 0x27,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x68,(byte) 0x6,(byte) 0x64,(byte) 0x6,(byte) 0xc2,(byte) 0x3,(byte) 0xc2,(byte) 0x3, +(byte) 0xc1,(byte) 0x3,(byte) 0xc1,(byte) 0x3,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x43,(byte) 0x60,(byte) 0x46,(byte) 0x60,(byte) 0x26,(byte) 0x38,(byte) 0x1c, +(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe4,(byte) 0x0,(byte) 0x4, + }; + + static final BitmapCharRec ch216 = new BitmapCharRec(16,19,-1,1,18,ch216data); + +// char: 0xd7 + + static final byte[] ch215data = { + (byte) 0x80,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x40, + }; + + static final BitmapCharRec ch215 = new BitmapCharRec(10,11,-2,-1,14,ch215data); + +// char: 0xd6 + + static final byte[] ch214data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x60, + }; + + static final BitmapCharRec ch214 = new BitmapCharRec(16,21,-1,0,18,ch214data); + +// char: 0xd5 + + static final byte[] ch213data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90, + }; + + static final BitmapCharRec ch213 = new BitmapCharRec(16,21,-1,0,18,ch213data); + +// char: 0xd4 + + static final byte[] ch212data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80, + }; + + static final BitmapCharRec ch212 = new BitmapCharRec(16,22,-1,0,18,ch212data); + +// char: 0xd3 + + static final byte[] ch211data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30, + }; + + static final BitmapCharRec ch211 = new BitmapCharRec(16,22,-1,0,18,ch211data); + +// char: 0xd2 + + static final byte[] ch210data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch210 = new BitmapCharRec(16,22,-1,0,18,ch210data); + +// char: 0xd1 + + static final byte[] ch209data = { + (byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84, +(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xf0,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90, + }; + + static final BitmapCharRec ch209 = new BitmapCharRec(16,21,-1,0,18,ch209data); + +// char: 0xd0 + + static final byte[] ch208data = { + (byte) 0x7f,(byte) 0xe0,(byte) 0x18,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3, +(byte) 0xff,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x38, +(byte) 0x7f,(byte) 0xe0, + }; + + static final BitmapCharRec ch208 = new BitmapCharRec(16,17,0,0,17,ch208data); + +// char: 0xcf + + static final byte[] ch207data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch207 = new BitmapCharRec(6,21,-1,0,8,ch207data); + +// char: 0xce + + static final byte[] ch206data = { + (byte) 0x7e,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, +(byte) 0x7e,(byte) 0x0,(byte) 0x81,(byte) 0x66,(byte) 0x3c,(byte) 0x18, + }; + + static final BitmapCharRec ch206 = new BitmapCharRec(8,22,-1,0,8,ch206data); + +// char: 0xcd + + static final byte[] ch205data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x40,(byte) 0x30,(byte) 0x1c,(byte) 0xc, + }; + + static final BitmapCharRec ch205 = new BitmapCharRec(6,22,-1,0,8,ch205data); + +// char: 0xcc + + static final byte[] ch204data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch204 = new BitmapCharRec(6,22,-1,0,8,ch204data); + +// char: 0xcb + + static final byte[] ch203data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80, + }; + + static final BitmapCharRec ch203 = new BitmapCharRec(13,21,-1,0,15,ch203data); + +// char: 0xca + + static final byte[] ch202data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,(byte) 0xc,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch202 = new BitmapCharRec(13,22,-1,0,15,ch202data); + +// char: 0xc9 + + static final byte[] ch201data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0xc0, + }; + + static final BitmapCharRec ch201 = new BitmapCharRec(13,22,-1,0,15,ch201data); + +// char: 0xc8 + + static final byte[] ch200data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x18,(byte) 0x0, + }; + + static final BitmapCharRec ch200 = new BitmapCharRec(13,22,-1,0,15,ch200data); + +// char: 0xc7 + + static final byte[] ch199data = { + (byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38, +(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c,(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch199 = new BitmapCharRec(14,23,-1,6,16,ch199data); + +// char: 0xc6 + + static final byte[] ch198data = { + (byte) 0xf9,(byte) 0xff,(byte) 0xf0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x18,(byte) 0x60,(byte) 0x0,(byte) 0x8, +(byte) 0x60,(byte) 0x0,(byte) 0xf,(byte) 0xe0,(byte) 0x80,(byte) 0xc,(byte) 0x60,(byte) 0x80,(byte) 0x4,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60, +(byte) 0x80,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0xe0,(byte) 0x60, +(byte) 0x3,(byte) 0xff,(byte) 0xe0, + }; + + static final BitmapCharRec ch198 = new BitmapCharRec(20,17,0,0,21,ch198data); + +// char: 0xc5 + + static final byte[] ch197data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch197 = new BitmapCharRec(17,21,0,0,17,ch197data); + +// char: 0xc4 + + static final byte[] ch196data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch196 = new BitmapCharRec(17,21,0,0,17,ch196data); + +// char: 0xc3 + + static final byte[] ch195data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x7,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x0,(byte) 0x3,(byte) 0x90,(byte) 0x0, + }; + + static final BitmapCharRec ch195 = new BitmapCharRec(17,21,0,0,17,ch195data); + +// char: 0xc2 + + static final byte[] ch194data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x1, +(byte) 0x80,(byte) 0x0, + }; + + static final BitmapCharRec ch194 = new BitmapCharRec(17,22,0,0,17,ch194data); + +// char: 0xc1 + + static final byte[] ch193data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x0, +(byte) 0x30,(byte) 0x0, + }; + + static final BitmapCharRec ch193 = new BitmapCharRec(17,22,0,0,17,ch193data); + +// char: 0xc0 + + static final byte[] ch192data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x0,(byte) 0x3, +(byte) 0x0,(byte) 0x0, + }; + + static final BitmapCharRec ch192 = new BitmapCharRec(17,22,0,0,17,ch192data); + +// char: 0xbf + + static final byte[] ch191data = { + (byte) 0x3e,(byte) 0x63,(byte) 0xc1,(byte) 0xc3,(byte) 0xc3,(byte) 0xe0,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0x8,(byte) 0x0,(byte) 0x0,(byte) 0xc, +(byte) 0xc, + }; + + static final BitmapCharRec ch191 = new BitmapCharRec(8,17,-1,5,11,ch191data); + +// char: 0xbe + + static final byte[] ch190data = { + (byte) 0x18,(byte) 0x2,(byte) 0x0,(byte) 0x8,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x22,(byte) 0x0,(byte) 0x6,(byte) 0x32,(byte) 0x0,(byte) 0x3, +(byte) 0x12,(byte) 0x0,(byte) 0x1,(byte) 0xa,(byte) 0x0,(byte) 0x71,(byte) 0x8e,(byte) 0x0,(byte) 0x88,(byte) 0x86,(byte) 0x0,(byte) 0x8c,(byte) 0xc2,(byte) 0x0,(byte) 0xc,(byte) 0x60, +(byte) 0x0,(byte) 0x8,(byte) 0x20,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x8c,(byte) 0x18,(byte) 0x0,(byte) 0x4c,(byte) 0xc,(byte) 0x0, +(byte) 0x38,(byte) 0x4,(byte) 0x0, + }; + + static final BitmapCharRec ch190 = new BitmapCharRec(17,17,0,0,18,ch190data); + +// char: 0xbd + + static final byte[] ch189data = { + (byte) 0x30,(byte) 0x7e,(byte) 0x10,(byte) 0x22,(byte) 0x18,(byte) 0x10,(byte) 0x8,(byte) 0x18,(byte) 0xc,(byte) 0x8,(byte) 0x6,(byte) 0x4,(byte) 0x2,(byte) 0x6,(byte) 0xfb,(byte) 0x46, +(byte) 0x21,(byte) 0x26,(byte) 0x21,(byte) 0x9c,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18, +(byte) 0x20,(byte) 0x8, + }; + + static final BitmapCharRec ch189 = new BitmapCharRec(15,17,-1,0,18,ch189data); + +// char: 0xbc + + static final byte[] ch188data = { + (byte) 0x30,(byte) 0x4,(byte) 0x10,(byte) 0x4,(byte) 0x18,(byte) 0xff,(byte) 0x8,(byte) 0x44,(byte) 0xc,(byte) 0x64,(byte) 0x6,(byte) 0x24,(byte) 0x2,(byte) 0x14,(byte) 0xfb,(byte) 0x1c, +(byte) 0x21,(byte) 0xc,(byte) 0x21,(byte) 0x84,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18, +(byte) 0x20,(byte) 0x8, + }; + + static final BitmapCharRec ch188 = new BitmapCharRec(16,17,-1,0,18,ch188data); + +// char: 0xbb + + static final byte[] ch187data = { + (byte) 0x88,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0, +(byte) 0xcc,(byte) 0x0,(byte) 0x88,(byte) 0x0, + }; + + static final BitmapCharRec ch187 = new BitmapCharRec(9,10,-2,-1,12,ch187data); + +// char: 0xba + + static final byte[] ch186data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x78,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch186 = new BitmapCharRec(6,9,-1,-8,8,ch186data); + +// char: 0xb9 + + static final byte[] ch185data = { + (byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20, + }; + + static final BitmapCharRec ch185 = new BitmapCharRec(5,10,-1,-7,7,ch185data); + +// char: 0xb8 + + static final byte[] ch184data = { + (byte) 0x78,(byte) 0xcc,(byte) 0xc,(byte) 0x3c,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch184 = new BitmapCharRec(6,6,-1,6,8,ch184data); + +// char: 0xb7 + + static final byte[] ch183data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-2,-6,6,ch183data); + +// char: 0xb6 + + static final byte[] ch182data = { + (byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0, +(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0xf9,(byte) 0x0, +(byte) 0xf9,(byte) 0x0,(byte) 0xf9,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch182 = new BitmapCharRec(9,22,-1,5,11,ch182data); + +// char: 0xb5 + + static final byte[] ch181data = { + (byte) 0x40,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x5c,(byte) 0xe0,(byte) 0x7e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0xe1,(byte) 0xc0, + }; + + static final BitmapCharRec ch181 = new BitmapCharRec(11,17,-1,5,13,ch181data); + +// char: 0xb4 + + static final byte[] ch180data = { + (byte) 0x80,(byte) 0x60,(byte) 0x38,(byte) 0x18, + }; + + static final BitmapCharRec ch180 = new BitmapCharRec(5,4,-2,-13,8,ch180data); + +// char: 0xb3 + + static final byte[] ch179data = { + (byte) 0x70,(byte) 0x88,(byte) 0x8c,(byte) 0xc,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x8c,(byte) 0x4c,(byte) 0x38, + }; + + static final BitmapCharRec ch179 = new BitmapCharRec(6,10,0,-7,7,ch179data); + +// char: 0xb2 + + static final byte[] ch178data = { + (byte) 0xfc,(byte) 0x44,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0xc,(byte) 0x8c,(byte) 0x4c,(byte) 0x38, + }; + + static final BitmapCharRec ch178 = new BitmapCharRec(6,10,0,-7,7,ch178data); + +// char: 0xb1 + + static final byte[] ch177data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch177 = new BitmapCharRec(12,15,-1,0,14,ch177data); + +// char: 0xb0 + + static final byte[] ch176data = { + (byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38, + }; + + static final BitmapCharRec ch176 = new BitmapCharRec(7,7,-1,-10,9,ch176data); + +// char: 0xaf + + static final byte[] ch175data = { + (byte) 0xfc,(byte) 0xfc, + }; + + static final BitmapCharRec ch175 = new BitmapCharRec(6,2,-1,-14,8,ch175data); + +// char: 0xae + + static final byte[] ch174data = { + (byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x60,(byte) 0x3,(byte) 0x0,(byte) 0x47,(byte) 0x19,(byte) 0x0,(byte) 0xc2, +(byte) 0x31,(byte) 0x80,(byte) 0x82,(byte) 0x20,(byte) 0x80,(byte) 0x82,(byte) 0x40,(byte) 0x80,(byte) 0x83,(byte) 0xe0,(byte) 0x80,(byte) 0x82,(byte) 0x30,(byte) 0x80,(byte) 0x82,(byte) 0x10, +(byte) 0x80,(byte) 0xc2,(byte) 0x11,(byte) 0x80,(byte) 0x42,(byte) 0x31,(byte) 0x0,(byte) 0x67,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0xf0,(byte) 0x0, + }; + + static final BitmapCharRec ch174 = new BitmapCharRec(17,17,-1,0,19,ch174data); + +// char: 0xad + + static final byte[] ch173data = { + (byte) 0xfe,(byte) 0xfe, + }; + + static final BitmapCharRec ch173 = new BitmapCharRec(7,2,-1,-5,9,ch173data); + +// char: 0xac + + static final byte[] ch172data = { + (byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch172 = new BitmapCharRec(12,7,-1,-3,14,ch172data); + +// char: 0xab + + static final byte[] ch171data = { + (byte) 0x8,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0, +(byte) 0x19,(byte) 0x80,(byte) 0x8,(byte) 0x80, + }; + + static final BitmapCharRec ch171 = new BitmapCharRec(9,10,-2,-1,13,ch171data); + +// char: 0xaa + + static final byte[] ch170data = { + (byte) 0x7e,(byte) 0x0,(byte) 0x76,(byte) 0xcc,(byte) 0xcc,(byte) 0x7c,(byte) 0xc,(byte) 0xcc,(byte) 0x78, + }; + + static final BitmapCharRec ch170 = new BitmapCharRec(7,9,0,-8,8,ch170data); + +// char: 0xa9 + + static final byte[] ch169data = { + (byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x61,(byte) 0xc3,(byte) 0x0,(byte) 0x47,(byte) 0x71,(byte) 0x0,(byte) 0xc4, +(byte) 0x19,(byte) 0x80,(byte) 0x8c,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x8c,(byte) 0x0, +(byte) 0x80,(byte) 0xc4,(byte) 0x19,(byte) 0x80,(byte) 0x47,(byte) 0x31,(byte) 0x0,(byte) 0x61,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0xf0,(byte) 0x0, + }; + + static final BitmapCharRec ch169 = new BitmapCharRec(17,17,-1,0,19,ch169data); + +// char: 0xa8 + + static final byte[] ch168data = { + (byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch168 = new BitmapCharRec(6,2,-1,-14,8,ch168data); + +// char: 0xa7 + + static final byte[] ch167data = { + (byte) 0x38,(byte) 0x64,(byte) 0x62,(byte) 0x6,(byte) 0xe,(byte) 0x1c,(byte) 0x38,(byte) 0x74,(byte) 0xe2,(byte) 0xc3,(byte) 0x83,(byte) 0x87,(byte) 0x4e,(byte) 0x3c,(byte) 0x38,(byte) 0x70, +(byte) 0x60,(byte) 0x46,(byte) 0x26,(byte) 0x1c, + }; + + static final BitmapCharRec ch167 = new BitmapCharRec(8,20,-2,2,12,ch167data); + +// char: 0xa6 + + static final byte[] ch166data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-2,0,6,ch166data); + +// char: 0xa5 + + static final byte[] ch165data = { + (byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0, +(byte) 0x3,(byte) 0x0,(byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x60,(byte) 0x30,(byte) 0x20,(byte) 0x70,(byte) 0x30, +(byte) 0xf8,(byte) 0x7c, + }; + + static final BitmapCharRec ch165 = new BitmapCharRec(14,17,0,0,14,ch165data); + +// char: 0xa4 + + static final byte[] ch164data = { + (byte) 0xc0,(byte) 0x60,(byte) 0xee,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x31,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0xee,(byte) 0xe0,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch164 = new BitmapCharRec(11,12,-1,-3,13,ch164data); + +// char: 0xa3 + + static final byte[] ch163data = { + (byte) 0xe7,(byte) 0x80,(byte) 0xbe,(byte) 0xc0,(byte) 0x78,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x19,(byte) 0x80, +(byte) 0xf,(byte) 0x0, + }; + + static final BitmapCharRec ch163 = new BitmapCharRec(10,17,-1,0,12,ch163data); + +// char: 0xa2 + + static final byte[] ch162data = { + (byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xd0,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xc8,(byte) 0x0, +(byte) 0xc8,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x43,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x0, + }; + + static final BitmapCharRec ch162 = new BitmapCharRec(9,16,-1,2,12,ch162data); + +// char: 0xa1 + + static final byte[] ch161data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch161 = new BitmapCharRec(2,17,-4,5,8,ch161data); + +// char: 0xa0 + + static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,6,zerodata); + +// char: 0x7e '~' + + static final byte[] ch126data = { + (byte) 0x83,(byte) 0x80,(byte) 0xc7,(byte) 0xc0,(byte) 0x7c,(byte) 0x60,(byte) 0x38,(byte) 0x20, + }; + + static final BitmapCharRec ch126 = new BitmapCharRec(11,4,-1,-5,13,ch126data); + +// char: 0x7d '}' + + static final byte[] ch125data = { + (byte) 0xe0,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0x4,(byte) 0x3,(byte) 0x4,(byte) 0xc,(byte) 0x8,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0xe0, + }; + + static final BitmapCharRec ch125 = new BitmapCharRec(8,22,-1,5,10,ch125data); + +// char: 0x7c '|' + + static final byte[] ch124data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch124 = new BitmapCharRec(2,17,-2,0,6,ch124data); + +// char: 0x7b '{' + + static final byte[] ch123data = { + (byte) 0x7,(byte) 0xc,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0x7, + }; + + static final BitmapCharRec ch123 = new BitmapCharRec(8,22,-1,5,10,ch123data); + +// char: 0x7a 'z' + + static final byte[] ch122data = { + (byte) 0xff,(byte) 0xc3,(byte) 0x61,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0xe,(byte) 0x86,(byte) 0xc3,(byte) 0xff, + }; + + static final BitmapCharRec ch122 = new BitmapCharRec(8,12,-1,0,10,ch122data); + +// char: 0x79 'y' + + static final byte[] ch121data = { + (byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0, +(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch121 = new BitmapCharRec(11,17,0,5,11,ch121data); + +// char: 0x78 'x' + + static final byte[] ch120data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x21,(byte) 0x80,(byte) 0x33,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1a,(byte) 0x0, +(byte) 0x39,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch120 = new BitmapCharRec(11,12,-1,0,13,ch120data); + +// char: 0x77 'w' + + static final byte[] ch119data = { + (byte) 0x4,(byte) 0x10,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0x1a,(byte) 0x28,(byte) 0x0,(byte) 0x1a,(byte) 0x64,(byte) 0x0,(byte) 0x19, +(byte) 0x64,(byte) 0x0,(byte) 0x31,(byte) 0x64,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc3, +(byte) 0x0,(byte) 0xf1,(byte) 0xe7,(byte) 0x80, + }; + + static final BitmapCharRec ch119 = new BitmapCharRec(17,12,0,0,17,ch119data); + +// char: 0x76 'v' + + static final byte[] ch118data = { + (byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80, +(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0, + }; + + static final BitmapCharRec ch118 = new BitmapCharRec(11,12,0,0,11,ch118data); + +// char: 0x75 'u' + + static final byte[] ch117data = { + (byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0, + }; + + static final BitmapCharRec ch117 = new BitmapCharRec(11,12,-1,0,13,ch117data); + +// char: 0x74 't' + + static final byte[] ch116data = { + (byte) 0x1c,(byte) 0x32,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x70,(byte) 0x30,(byte) 0x10, + }; + + static final BitmapCharRec ch116 = new BitmapCharRec(7,15,0,0,7,ch116data); + +// char: 0x73 's' + + static final byte[] ch115data = { + (byte) 0xf8,(byte) 0xc6,(byte) 0x83,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x7c,(byte) 0x70,(byte) 0xe0,(byte) 0xc2,(byte) 0x66,(byte) 0x3e, + }; + + static final BitmapCharRec ch115 = new BitmapCharRec(8,12,-1,0,10,ch115data); + +// char: 0x72 'r' + + static final byte[] ch114data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x76,(byte) 0x6e,(byte) 0xe6, + }; + + static final BitmapCharRec ch114 = new BitmapCharRec(7,12,-1,0,8,ch114data); + +// char: 0x71 'q' + + static final byte[] ch113data = { + (byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0x1d,(byte) 0x80, + }; + + static final BitmapCharRec ch113 = new BitmapCharRec(10,17,-1,5,12,ch113data); + +// char: 0x70 'p' + + static final byte[] ch112data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80, +(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80, +(byte) 0xee,(byte) 0x0, + }; + + static final BitmapCharRec ch112 = new BitmapCharRec(10,17,-1,5,12,ch112data); + +// char: 0x6f 'o' + + static final byte[] ch111data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch111 = new BitmapCharRec(10,12,-1,0,12,ch111data); + +// char: 0x6e 'n' + + static final byte[] ch110data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0, + }; + + static final BitmapCharRec ch110 = new BitmapCharRec(11,12,-1,0,13,ch110data); + +// char: 0x6d 'm' + + static final byte[] ch109data = { + (byte) 0xf1,(byte) 0xe3,(byte) 0xc0,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60, +(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x71,(byte) 0xe3,(byte) 0x80,(byte) 0x6f,(byte) 0x9f, +(byte) 0x0,(byte) 0xe7,(byte) 0xe,(byte) 0x0, + }; + + static final BitmapCharRec ch109 = new BitmapCharRec(18,12,-1,0,20,ch109data); + +// char: 0x6c 'l' + + static final byte[] ch108data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60, +(byte) 0xe0, + }; + + static final BitmapCharRec ch108 = new BitmapCharRec(4,17,-1,0,6,ch108data); + +// char: 0x6b 'k' + + static final byte[] ch107data = { + (byte) 0xf3,(byte) 0xe0,(byte) 0x61,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x68,(byte) 0x0, +(byte) 0x64,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch107 = new BitmapCharRec(11,17,-1,0,12,ch107data); + +// char: 0x6a 'j' + + static final byte[] ch106data = { + (byte) 0xc0,(byte) 0xe0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30, + }; + + static final BitmapCharRec ch106 = new BitmapCharRec(4,22,0,5,6,ch106data); + +// char: 0x69 'i' + + static final byte[] ch105data = { + (byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x60, +(byte) 0x60, + }; + + static final BitmapCharRec ch105 = new BitmapCharRec(4,17,-1,0,6,ch105data); + +// char: 0x68 'h' + + static final byte[] ch104data = { + (byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch104 = new BitmapCharRec(11,17,-1,0,13,ch104data); + +// char: 0x67 'g' + + static final byte[] ch103data = { + (byte) 0x3f,(byte) 0x0,(byte) 0xf1,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x3f,(byte) 0xc0,(byte) 0x7f,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1f,(byte) 0xc0, + }; + + static final BitmapCharRec ch103 = new BitmapCharRec(11,17,-1,5,12,ch103data); + +// char: 0x66 'f' + + static final byte[] ch102data = { + (byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x16, +(byte) 0xe, + }; + + static final BitmapCharRec ch102 = new BitmapCharRec(7,17,0,0,7,ch102data); + +// char: 0x65 'e' + + static final byte[] ch101data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch101 = new BitmapCharRec(9,12,-1,0,11,ch101data); + +// char: 0x64 'd' + + static final byte[] ch100data = { + (byte) 0x1e,(byte) 0xc0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80, +(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80, +(byte) 0x3,(byte) 0x80, + }; + + static final BitmapCharRec ch100 = new BitmapCharRec(10,17,-1,0,12,ch100data); + +// char: 0x63 'c' + + static final byte[] ch99data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0, + }; + + static final BitmapCharRec ch99 = new BitmapCharRec(9,12,-1,0,11,ch99data); + +// char: 0x62 'b' + + static final byte[] ch98data = { + (byte) 0x5e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0, +(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0, +(byte) 0xe0,(byte) 0x0, + }; + + static final BitmapCharRec ch98 = new BitmapCharRec(10,17,-1,0,12,ch98data); + +// char: 0x61 'a' + + static final byte[] ch97data = { + (byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0, + }; + + static final BitmapCharRec ch97 = new BitmapCharRec(9,12,-1,0,11,ch97data); + +// char: 0x60 '`' + + static final byte[] ch96data = { + (byte) 0x60,(byte) 0xe0,(byte) 0x80,(byte) 0xc0,(byte) 0x60, + }; + + static final BitmapCharRec ch96 = new BitmapCharRec(3,5,-2,-12,7,ch96data); + +// char: 0x5f '_' + + static final byte[] ch95data = { + (byte) 0xff,(byte) 0xf8,(byte) 0xff,(byte) 0xf8, + }; + + static final BitmapCharRec ch95 = new BitmapCharRec(13,2,0,5,13,ch95data); + +// char: 0x5e '^' + + static final byte[] ch94data = { + (byte) 0x80,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x14,(byte) 0x0,(byte) 0x1c,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch94 = new BitmapCharRec(9,9,-1,-8,11,ch94data); + +// char: 0x5d ']' + + static final byte[] ch93data = { + (byte) 0xf8,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18, +(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8, + }; + + static final BitmapCharRec ch93 = new BitmapCharRec(5,21,-1,4,8,ch93data); + +// char: 0x5c '\' + + static final byte[] ch92data = { + (byte) 0x6,(byte) 0x6,(byte) 0x4,(byte) 0xc,(byte) 0xc,(byte) 0x8,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch92 = new BitmapCharRec(7,17,0,0,7,ch92data); + +// char: 0x5b '[' + + static final byte[] ch91data = { + (byte) 0xf8,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xf8, + }; + + static final BitmapCharRec ch91 = new BitmapCharRec(5,21,-2,4,8,ch91data); + +// char: 0x5a 'Z' + + static final byte[] ch90data = { + (byte) 0xff,(byte) 0xf8,(byte) 0xe0,(byte) 0x18,(byte) 0x70,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0xc0,(byte) 0x80,(byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0x70, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch90 = new BitmapCharRec(13,17,-1,0,15,ch90data); + +// char: 0x59 'Y' + + static final byte[] ch89data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0, +(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc, +(byte) 0xfc,(byte) 0x3f, + }; + + static final BitmapCharRec ch89 = new BitmapCharRec(16,17,0,0,16,ch89data); + +// char: 0x58 'X' + + static final byte[] ch88data = { + (byte) 0xfc,(byte) 0xf,(byte) 0xc0,(byte) 0x30,(byte) 0x3,(byte) 0x80,(byte) 0x18,(byte) 0x7,(byte) 0x0,(byte) 0x8,(byte) 0xe,(byte) 0x0,(byte) 0x4,(byte) 0xc,(byte) 0x0,(byte) 0x6, +(byte) 0x18,(byte) 0x0,(byte) 0x2,(byte) 0x38,(byte) 0x0,(byte) 0x1,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0, +(byte) 0x0,(byte) 0x3,(byte) 0xa0,(byte) 0x0,(byte) 0x3,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x8,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x1c,(byte) 0x6,(byte) 0x0, +(byte) 0x7e,(byte) 0xf,(byte) 0x80, + }; + + static final BitmapCharRec ch88 = new BitmapCharRec(18,17,0,0,18,ch88data); + +// char: 0x57 'W' + + static final byte[] ch87data = { + (byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x80,(byte) 0x3,(byte) 0x87,(byte) 0x80,(byte) 0x3,(byte) 0x46,(byte) 0x80,(byte) 0x3, +(byte) 0x46,(byte) 0xc0,(byte) 0x6,(byte) 0x46,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x60,(byte) 0xc,(byte) 0x2c,(byte) 0x60,(byte) 0xc,(byte) 0x2c, +(byte) 0x20,(byte) 0x18,(byte) 0x2c,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x18, +(byte) 0xfc,(byte) 0x7e,(byte) 0x7e, + }; + + static final BitmapCharRec ch87 = new BitmapCharRec(23,17,0,0,23,ch87data); + +// char: 0x56 'V' + + static final byte[] ch86data = { + (byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x40,(byte) 0x0,(byte) 0x3, +(byte) 0x60,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0xc,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x18, +(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x30,(byte) 0x4,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0, +(byte) 0xfc,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch86 = new BitmapCharRec(17,17,0,0,17,ch86data); + +// char: 0x55 'U' + + static final byte[] ch85data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xfc,(byte) 0x1f, + }; + + static final BitmapCharRec ch85 = new BitmapCharRec(16,17,-1,0,18,ch85data); + +// char: 0x54 'T' + + static final byte[] ch84data = { + (byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x83,(byte) 0x4,(byte) 0x83,(byte) 0x4,(byte) 0xc3,(byte) 0xc, +(byte) 0xff,(byte) 0xfc, + }; + + static final BitmapCharRec ch84 = new BitmapCharRec(14,17,-1,0,16,ch84data); + +// char: 0x53 'S' + + static final byte[] ch83data = { + (byte) 0x9e,(byte) 0x0,(byte) 0xf1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0, +(byte) 0xf,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0xc0, +(byte) 0x1e,(byte) 0x40, + }; + + static final BitmapCharRec ch83 = new BitmapCharRec(11,17,-1,0,13,ch83data); + +// char: 0x52 'R' + + static final byte[] ch82data = { + (byte) 0xfc,(byte) 0x1e,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xc0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch82 = new BitmapCharRec(15,17,-1,0,16,ch82data); + +// char: 0x51 'Q' + + static final byte[] ch81data = { + (byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xe0,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c, +(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe0, + }; + + static final BitmapCharRec ch81 = new BitmapCharRec(16,22,-1,5,18,ch81data); + +// char: 0x50 'P' + + static final byte[] ch80data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch80 = new BitmapCharRec(13,17,-1,0,15,ch80data); + +// char: 0x4f 'O' + + static final byte[] ch79data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3, +(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38, +(byte) 0x7,(byte) 0xe0, + }; + + static final BitmapCharRec ch79 = new BitmapCharRec(16,17,-1,0,18,ch79data); + +// char: 0x4e 'N' + + static final byte[] ch78data = { + (byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84, +(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4, +(byte) 0xf0,(byte) 0x1f, + }; + + static final BitmapCharRec ch78 = new BitmapCharRec(16,17,-1,0,18,ch78data); + +// char: 0x4d 'M' + + static final byte[] ch77data = { + (byte) 0xf8,(byte) 0x21,(byte) 0xf8,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x21, +(byte) 0x88,(byte) 0x60,(byte) 0x21,(byte) 0x88,(byte) 0x60,(byte) 0x23,(byte) 0x8,(byte) 0x60,(byte) 0x23,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x2, +(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x30,(byte) 0x0,(byte) 0xe0, +(byte) 0xf0,(byte) 0x0,(byte) 0xf8, + }; + + static final BitmapCharRec ch77 = new BitmapCharRec(21,17,-1,0,22,ch77data); + +// char: 0x4c 'L' + + static final byte[] ch76data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0, +(byte) 0xfc,(byte) 0x0, + }; + + static final BitmapCharRec ch76 = new BitmapCharRec(13,17,-1,0,14,ch76data); + +// char: 0x4b 'K' + + static final byte[] ch75data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x30,(byte) 0xe,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0xe0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80, +(byte) 0x3f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18, +(byte) 0xfc,(byte) 0x7e, + }; + + static final BitmapCharRec ch75 = new BitmapCharRec(16,17,-1,0,17,ch75data); + +// char: 0x4a 'J' + + static final byte[] ch74data = { + (byte) 0x78,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch74 = new BitmapCharRec(9,17,-1,0,11,ch74data); + +// char: 0x49 'I' + + static final byte[] ch73data = { + (byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30, +(byte) 0xfc, + }; + + static final BitmapCharRec ch73 = new BitmapCharRec(6,17,-1,0,8,ch73data); + +// char: 0x48 'H' + + static final byte[] ch72data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30, +(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x3f,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6, +(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0, +(byte) 0xfc,(byte) 0x1f,(byte) 0x80, + }; + + static final BitmapCharRec ch72 = new BitmapCharRec(17,17,-1,0,19,ch72data); + +// char: 0x47 'G' + + static final byte[] ch71data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0xc,(byte) 0x60,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0x3f, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c, +(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch71 = new BitmapCharRec(16,17,-1,0,18,ch71data); + +// char: 0x46 'F' + + static final byte[] ch70data = { + (byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20, +(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch70 = new BitmapCharRec(12,17,-1,0,14,ch70data); + +// char: 0x45 'E' + + static final byte[] ch69data = { + (byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40, +(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30, +(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch69 = new BitmapCharRec(13,17,-1,0,15,ch69data); + +// char: 0x44 'D' + + static final byte[] ch68data = { + (byte) 0xff,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6, +(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch68 = new BitmapCharRec(15,17,-1,0,17,ch68data); + +// char: 0x43 'C' + + static final byte[] ch67data = { + (byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0, +(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c, +(byte) 0x7,(byte) 0xe4, + }; + + static final BitmapCharRec ch67 = new BitmapCharRec(14,17,-1,0,16,ch67data); + +// char: 0x42 'B' + + static final byte[] ch66data = { + (byte) 0xff,(byte) 0xe0,(byte) 0x30,(byte) 0x78,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38, +(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70, +(byte) 0xff,(byte) 0xc0, + }; + + static final BitmapCharRec ch66 = new BitmapCharRec(14,17,-1,0,16,ch66data); + +// char: 0x41 'A' + + static final byte[] ch65data = { + (byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8, +(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30, +(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0, +(byte) 0x0,(byte) 0x80,(byte) 0x0, + }; + + static final BitmapCharRec ch65 = new BitmapCharRec(17,17,0,0,17,ch65data); + +// char: 0x40 '@' + + static final byte[] ch64data = { + (byte) 0x3,(byte) 0xf0,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x61,(byte) 0xde,(byte) 0x0,(byte) 0x63, +(byte) 0x7b,(byte) 0x0,(byte) 0xc6,(byte) 0x39,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0xc0,(byte) 0xc6,(byte) 0x18,(byte) 0x40,(byte) 0xc6,(byte) 0xc, +(byte) 0x40,(byte) 0xc3,(byte) 0xc,(byte) 0x40,(byte) 0xc3,(byte) 0x8c,(byte) 0x40,(byte) 0xe1,(byte) 0xfc,(byte) 0x40,(byte) 0x60,(byte) 0xec,(byte) 0xc0,(byte) 0x70,(byte) 0x0,(byte) 0x80, +(byte) 0x38,(byte) 0x1,(byte) 0x80,(byte) 0x1c,(byte) 0x3,(byte) 0x0,(byte) 0xf,(byte) 0xe,(byte) 0x0,(byte) 0x3,(byte) 0xf8,(byte) 0x0, + }; + + static final BitmapCharRec ch64 = new BitmapCharRec(18,20,-2,3,22,ch64data); + +// char: 0x3f '?' + + static final byte[] ch63data = { + (byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xe,(byte) 0x7,(byte) 0xc3,(byte) 0xc3,(byte) 0x83,(byte) 0xc6, +(byte) 0x7c, + }; + + static final BitmapCharRec ch63 = new BitmapCharRec(8,17,-2,0,11,ch63data); + +// char: 0x3e '>' + + static final byte[] ch62data = { + (byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0, +(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0, + }; + + static final BitmapCharRec ch62 = new BitmapCharRec(11,11,-1,-1,13,ch62data); + +// char: 0x3d '=' + + static final byte[] ch61data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch61 = new BitmapCharRec(12,6,-1,-4,14,ch61data); + +// char: 0x3c '<' + + static final byte[] ch60data = { + (byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0, +(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60, + }; + + static final BitmapCharRec ch60 = new BitmapCharRec(11,11,-1,-1,13,ch60data); + +// char: 0x3b ';' + + static final byte[] ch59data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch59 = new BitmapCharRec(3,14,-2,3,7,ch59data); + +// char: 0x3a ':' + + static final byte[] ch58data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch58 = new BitmapCharRec(2,11,-2,0,6,ch58data); + +// char: 0x39 '9' + + static final byte[] ch57data = { + (byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0xc0, +(byte) 0x61,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x77,(byte) 0x80, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch57 = new BitmapCharRec(10,17,-1,0,12,ch57data); + +// char: 0x38 '8' + + static final byte[] ch56data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0xe1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x41,(byte) 0xc0,(byte) 0x61,(byte) 0x80, +(byte) 0x37,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch56 = new BitmapCharRec(10,17,-1,0,12,ch56data); + +// char: 0x37 '7' + + static final byte[] ch55data = { + (byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x2,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0, +(byte) 0x7f,(byte) 0xc0, + }; + + static final BitmapCharRec ch55 = new BitmapCharRec(10,17,-1,0,12,ch55data); + +// char: 0x36 '6' + + static final byte[] ch54data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x7b,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc1,(byte) 0x80,(byte) 0xf3,(byte) 0x80,(byte) 0xee,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xe,(byte) 0x0, +(byte) 0x3,(byte) 0xc0, + }; + + static final BitmapCharRec ch54 = new BitmapCharRec(10,17,-1,0,12,ch54data); + +// char: 0x35 '5' + + static final byte[] ch53data = { + (byte) 0x7e,(byte) 0x0,(byte) 0xe3,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x1,(byte) 0xc0, +(byte) 0x3,(byte) 0x80,(byte) 0xf,(byte) 0x80,(byte) 0x7e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x1f,(byte) 0x80, +(byte) 0x1f,(byte) 0xc0, + }; + + static final BitmapCharRec ch53 = new BitmapCharRec(10,17,-1,0,12,ch53data); + +// char: 0x34 '4' + + static final byte[] ch52data = { + (byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc3,(byte) 0x0,(byte) 0x43,(byte) 0x0, +(byte) 0x63,(byte) 0x0,(byte) 0x23,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x7,(byte) 0x0, +(byte) 0x3,(byte) 0x0, + }; + + static final BitmapCharRec ch52 = new BitmapCharRec(10,17,-1,0,12,ch52data); + +// char: 0x33 '3' + + static final byte[] ch51data = { + (byte) 0x78,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0x80, +(byte) 0x7,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x47,(byte) 0x0,(byte) 0x7e,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch51 = new BitmapCharRec(9,17,-1,0,12,ch51data); + +// char: 0x32 '2' + + static final byte[] ch50data = { + (byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0x60,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0, +(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x43,(byte) 0x80,(byte) 0x7f,(byte) 0x0, +(byte) 0x1c,(byte) 0x0, + }; + + static final BitmapCharRec ch50 = new BitmapCharRec(10,17,-1,0,12,ch50data); + +// char: 0x31 '1' + + static final byte[] ch49data = { + (byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x78,(byte) 0x18, +(byte) 0x8, + }; + + static final BitmapCharRec ch49 = new BitmapCharRec(8,17,-2,0,12,ch49data); + +// char: 0x30 '0' + + static final byte[] ch48data = { + (byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0, +(byte) 0x1e,(byte) 0x0, + }; + + static final BitmapCharRec ch48 = new BitmapCharRec(10,17,-1,0,12,ch48data); + +// char: 0x2f '/' + + static final byte[] ch47data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0xc,(byte) 0x4,(byte) 0x6, +(byte) 0x6,(byte) 0x3,(byte) 0x3,(byte) 0x3, + }; + + static final BitmapCharRec ch47 = new BitmapCharRec(8,20,1,3,7,ch47data); + +// char: 0x2e '.' + + static final byte[] ch46data = { + (byte) 0xc0,(byte) 0xc0, + }; + + static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-2,0,6,ch46data); + +// char: 0x2d '-' + + static final byte[] ch45data = { + (byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0, + }; + + static final BitmapCharRec ch45 = new BitmapCharRec(12,2,-1,-6,14,ch45data); + +// char: 0x2c ',' + + static final byte[] ch44data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch44 = new BitmapCharRec(3,5,-2,3,7,ch44data); + +// char: 0x2b '+' + + static final byte[] ch43data = { + (byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0, +(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0, + }; + + static final BitmapCharRec ch43 = new BitmapCharRec(12,12,-1,-1,14,ch43data); + +// char: 0x2a '*' + + static final byte[] ch42data = { + (byte) 0x8,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0xeb,(byte) 0x80,(byte) 0x1c,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x1c,(byte) 0x0, +(byte) 0x8,(byte) 0x0, + }; + + static final BitmapCharRec ch42 = new BitmapCharRec(9,9,-2,-8,12,ch42data); + +// char: 0x29 ')' + + static final byte[] ch41data = { + (byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0x18, +(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x40,(byte) 0x80, + }; + + static final BitmapCharRec ch41 = new BitmapCharRec(6,22,-1,5,8,ch41data); + +// char: 0x28 '(' + + static final byte[] ch40data = { + (byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60, +(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0x4, + }; + + static final BitmapCharRec ch40 = new BitmapCharRec(6,22,-1,5,8,ch40data); + +// char: 0x27 ''' + + static final byte[] ch39data = { + (byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0, + }; + + static final BitmapCharRec ch39 = new BitmapCharRec(3,5,-3,-12,8,ch39data); + +// char: 0x26 '&' + + static final byte[] ch38data = { + (byte) 0x3c,(byte) 0x3c,(byte) 0x7f,(byte) 0x7e,(byte) 0xe1,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc1,(byte) 0xa0,(byte) 0x63,(byte) 0x20,(byte) 0x37,(byte) 0x10, +(byte) 0x1e,(byte) 0x18,(byte) 0xe,(byte) 0x3e,(byte) 0xf,(byte) 0x0,(byte) 0x1d,(byte) 0x80,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x40,(byte) 0xc,(byte) 0xc0, +(byte) 0x7,(byte) 0x80, + }; + + static final BitmapCharRec ch38 = new BitmapCharRec(16,17,-1,0,18,ch38data); + +// char: 0x25 '%' + + static final byte[] ch37data = { + (byte) 0x30,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x72,(byte) 0x0,(byte) 0xc,(byte) 0x61,(byte) 0x0,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60,(byte) 0x80,(byte) 0x3, +(byte) 0x30,(byte) 0x80,(byte) 0x1,(byte) 0x19,(byte) 0x80,(byte) 0x1,(byte) 0x8f,(byte) 0x0,(byte) 0x78,(byte) 0xc0,(byte) 0x0,(byte) 0xe4,(byte) 0x40,(byte) 0x0,(byte) 0xc2,(byte) 0x60, +(byte) 0x0,(byte) 0xc1,(byte) 0x30,(byte) 0x0,(byte) 0xc1,(byte) 0x10,(byte) 0x0,(byte) 0x61,(byte) 0x18,(byte) 0x0,(byte) 0x33,(byte) 0xfc,(byte) 0x0,(byte) 0x1e,(byte) 0xc,(byte) 0x0, + }; + + static final BitmapCharRec ch37 = new BitmapCharRec(17,16,-1,0,19,ch37data); + +// char: 0x24 '$' + + static final byte[] ch36data = { + (byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3f,(byte) 0x0,(byte) 0xe5,(byte) 0xc0,(byte) 0xc4,(byte) 0xc0,(byte) 0x84,(byte) 0x60,(byte) 0x84,(byte) 0x60,(byte) 0x4,(byte) 0x60, +(byte) 0x4,(byte) 0xe0,(byte) 0x7,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x74,(byte) 0x0,(byte) 0x64,(byte) 0x0,(byte) 0x64,(byte) 0x20, +(byte) 0x64,(byte) 0x60,(byte) 0x34,(byte) 0xe0,(byte) 0x1f,(byte) 0x80,(byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0, + }; + + static final BitmapCharRec ch36 = new BitmapCharRec(11,21,0,2,12,ch36data); + +// char: 0x23 '#' + + static final byte[] ch35data = { + (byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0x11,(byte) 0x0, +(byte) 0x11,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x7f,(byte) 0xe0,(byte) 0x7f,(byte) 0xe0,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80, +(byte) 0x8,(byte) 0x80, + }; + + static final BitmapCharRec ch35 = new BitmapCharRec(11,17,-1,0,13,ch35data); + +// char: 0x22 '"' + + static final byte[] ch34data = { + (byte) 0x88,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc, + }; + + static final BitmapCharRec ch34 = new BitmapCharRec(6,5,-1,-12,10,ch34data); + +// char: 0x21 '!' + + static final byte[] ch33data = { + (byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0, +(byte) 0xc0, + }; + + static final BitmapCharRec ch33 = new BitmapCharRec(2,17,-3,0,8,ch33data); + +// char: 0x20 ' ' + + static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,6,zerodata); + + static final BitmapCharRec 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, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + 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, + }; + + static final BitmapFontRec fontinfo = new BitmapFontRec( + "-adobe-times-medium-r-*--24-*-*-*-p-*-iso8859-1", + 224, + 32, + chars + ); + + public static BitmapFontRec getBitmapFontRec() { + return fontinfo; + } +} // end of class glutBitmapTimesRoman24 diff --git a/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java b/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java new file mode 100644 index 0000000..3f8b511 --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutStrokeMonoRoman.java @@ -0,0 +1,2458 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + +public class glutStrokeMonoRoman implements GLUTStrokeFont { +/* char: 33 '!' */ + +static final CoordRec[] char33_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 33.3333 ), +}; + +static final CoordRec[] char33_stroke1 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char33[] = { + new StrokeRec(2, char33_stroke0), + new StrokeRec(5, char33_stroke1), +}; + +/* char: 34 '"' */ + +static final CoordRec[] char34_stroke0 = { + new CoordRec( (float) 33.3334, (float) 100 ), + new CoordRec( (float) 33.3334, (float) 66.6667 ), +}; + +static final CoordRec[] char34_stroke1 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 71.4286, (float) 66.6667 ), +}; + +static final StrokeRec char34[] = { + new StrokeRec(2, char34_stroke0), + new StrokeRec(2, char34_stroke1), +}; + +/* char: 35 '#' */ + +static final CoordRec[] char35_stroke0 = { + new CoordRec( (float) 54.7619, (float) 119.048 ), + new CoordRec( (float) 21.4286, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke1 = { + new CoordRec( (float) 83.3334, (float) 119.048 ), + new CoordRec( (float) 50, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke2 = { + new CoordRec( (float) 21.4286, (float) 57.1429 ), + new CoordRec( (float) 88.0952, (float) 57.1429 ), +}; + +static final CoordRec[] char35_stroke3 = { + new CoordRec( (float) 16.6667, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), +}; + +static final StrokeRec char35[] = { + new StrokeRec(2, char35_stroke0), + new StrokeRec(2, char35_stroke1), + new StrokeRec(2, char35_stroke2), + new StrokeRec(2, char35_stroke3), +}; + +/* char: 36 '$' */ + +static final CoordRec[] char36_stroke0 = { + new CoordRec( (float) 42.8571, (float) 119.048 ), + new CoordRec( (float) 42.8571, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke1 = { + new CoordRec( (float) 61.9047, (float) 119.048 ), + new CoordRec( (float) 61.9047, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke2 = { + new CoordRec( (float) 85.7143, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 19.0476, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 19.0476, (float) 14.2857 ), +}; + +static final StrokeRec char36[] = { + new StrokeRec(2, char36_stroke0), + new StrokeRec(2, char36_stroke1), + new StrokeRec(20, char36_stroke2), +}; + +/* char: 37 '%' */ + +static final CoordRec[] char37_stroke0 = { + new CoordRec( (float) 95.2381, (float) 100 ), + new CoordRec( (float) 9.5238, (float) 0 ), +}; + +static final CoordRec[] char37_stroke1 = { + new CoordRec( (float) 33.3333, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 90.4762 ), + new CoordRec( (float) 42.8571, (float) 80.9524 ), + new CoordRec( (float) 38.0952, (float) 71.4286 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 19.0476, (float) 66.6667 ), + new CoordRec( (float) 9.5238, (float) 76.1905 ), + new CoordRec( (float) 9.5238, (float) 85.7143 ), + new CoordRec( (float) 14.2857, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 95.2381 ), + new CoordRec( (float) 57.1428, (float) 90.4762 ), + new CoordRec( (float) 71.4286, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 95.2381 ), + new CoordRec( (float) 95.2381, (float) 100 ), +}; + +static final CoordRec[] char37_stroke2 = { + new CoordRec( (float) 76.1905, (float) 33.3333 ), + new CoordRec( (float) 66.6667, (float) 28.5714 ), + new CoordRec( (float) 61.9048, (float) 19.0476 ), + new CoordRec( (float) 61.9048, (float) 9.5238 ), + new CoordRec( (float) 71.4286, (float) 0 ), + new CoordRec( (float) 80.9524, (float) 0 ), + new CoordRec( (float) 90.4762, (float) 4.7619 ), + new CoordRec( (float) 95.2381, (float) 14.2857 ), + new CoordRec( (float) 95.2381, (float) 23.8095 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 76.1905, (float) 33.3333 ), +}; + +static final StrokeRec char37[] = { + new StrokeRec(2, char37_stroke0), + new StrokeRec(16, char37_stroke1), + new StrokeRec(11, char37_stroke2), +}; + +/* char: 38 '&' */ + +static final CoordRec[] char38_stroke0 = { + new CoordRec( (float) 100, (float) 57.1429 ), + new CoordRec( (float) 100, (float) 61.9048 ), + new CoordRec( (float) 95.2381, (float) 66.6667 ), + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 85.7143, (float) 61.9048 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4286, (float) 28.5714 ), + new CoordRec( (float) 61.9048, (float) 14.2857 ), + new CoordRec( (float) 52.3809, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 23.8095, (float) 0 ), + new CoordRec( (float) 14.2857, (float) 4.7619 ), + new CoordRec( (float) 9.5238, (float) 9.5238 ), + new CoordRec( (float) 4.7619, (float) 19.0476 ), + new CoordRec( (float) 4.7619, (float) 28.5714 ), + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), + new CoordRec( (float) 47.619, (float) 61.9048 ), + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 57.1429, (float) 76.1905 ), + new CoordRec( (float) 57.1429, (float) 85.7143 ), + new CoordRec( (float) 52.3809, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 28.5714, (float) 85.7143 ), + new CoordRec( (float) 28.5714, (float) 76.1905 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 47.619 ), + new CoordRec( (float) 66.6667, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 85.7143, (float) 0 ), + new CoordRec( (float) 95.2381, (float) 0 ), + new CoordRec( (float) 100, (float) 4.7619 ), + new CoordRec( (float) 100, (float) 9.5238 ), +}; + +static final StrokeRec char38[] = { + new StrokeRec(34, char38_stroke0), +}; + +/* char: 39 ''' */ + +static final CoordRec[] char39_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final StrokeRec char39[] = { + new StrokeRec(2, char39_stroke0), +}; + +/* char: 40 '(' */ + +static final CoordRec[] char40_stroke0 = { + new CoordRec( (float) 69.0476, (float) 119.048 ), + new CoordRec( (float) 59.5238, (float) 109.524 ), + new CoordRec( (float) 50, (float) 95.2381 ), + new CoordRec( (float) 40.4762, (float) 76.1905 ), + new CoordRec( (float) 35.7143, (float) 52.381 ), + new CoordRec( (float) 35.7143, (float) 33.3333 ), + new CoordRec( (float) 40.4762, (float) 9.5238 ), + new CoordRec( (float) 50, (float) -9.5238 ), + new CoordRec( (float) 59.5238, (float) -23.8095 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char40[] = { + new StrokeRec(10, char40_stroke0), +}; + +/* char: 41 ')' */ + +static final CoordRec[] char41_stroke0 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 45.2381, (float) 109.524 ), + new CoordRec( (float) 54.7619, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 76.1905 ), + new CoordRec( (float) 69.0476, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 9.5238 ), + new CoordRec( (float) 54.7619, (float) -9.5238 ), + new CoordRec( (float) 45.2381, (float) -23.8095 ), + new CoordRec( (float) 35.7143, (float) -33.3333 ), +}; + +static final StrokeRec char41[] = { + new StrokeRec(10, char41_stroke0), +}; + +/* char: 42 '*' */ + +static final CoordRec[] char42_stroke0 = { + new CoordRec( (float) 52.381, (float) 71.4286 ), + new CoordRec( (float) 52.381, (float) 14.2857 ), +}; + +static final CoordRec[] char42_stroke1 = { + new CoordRec( (float) 28.5715, (float) 57.1429 ), + new CoordRec( (float) 76.1905, (float) 28.5714 ), +}; + +static final CoordRec[] char42_stroke2 = { + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 28.5715, (float) 28.5714 ), +}; + +static final StrokeRec char42[] = { + new StrokeRec(2, char42_stroke0), + new StrokeRec(2, char42_stroke1), + new StrokeRec(2, char42_stroke2), +}; + +/* char: 43 '+' */ + +static final CoordRec[] char43_stroke0 = { + new CoordRec( (float) 52.3809, (float) 85.7143 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char43_stroke1 = { + new CoordRec( (float) 9.5238, (float) 42.8571 ), + new CoordRec( (float) 95.2381, (float) 42.8571 ), +}; + +static final StrokeRec char43[] = { + new StrokeRec(2, char43_stroke0), + new StrokeRec(2, char43_stroke1), +}; + +/* char: 44 ',' */ + +static final CoordRec[] char44_stroke0 = { + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) -4.7619 ), + new CoordRec( (float) 52.381, (float) -14.2857 ), + new CoordRec( (float) 47.6191, (float) -19.0476 ), +}; + +static final StrokeRec char44[] = { + new StrokeRec(8, char44_stroke0), +}; + +/* char: 45 '-' */ + +static final CoordRec[] char45_stroke0 = { + new CoordRec( (float) 9.5238, (float) 42.8571 ), + new CoordRec( (float) 95.2381, (float) 42.8571 ), +}; + +static final StrokeRec char45[] = { + new StrokeRec(2, char45_stroke0), +}; + +/* char: 46 '.' */ + +static final CoordRec[] char46_stroke0 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char46[] = { + new StrokeRec(5, char46_stroke0), +}; + +/* char: 47 '/' */ + +static final CoordRec[] char47_stroke0 = { + new CoordRec( (float) 19.0476, (float) -14.2857 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char47[] = { + new StrokeRec(2, char47_stroke0), +}; + +/* char: 48 '0' */ + +static final CoordRec[] char48_stroke0 = { + new CoordRec( (float) 47.619, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 19.0476, (float) 57.1429 ), + new CoordRec( (float) 19.0476, (float) 42.8571 ), + new CoordRec( (float) 23.8095, (float) 19.0476 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 19.0476 ), + new CoordRec( (float) 85.7143, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 57.1429 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 57.1428, (float) 100 ), + new CoordRec( (float) 47.619, (float) 100 ), +}; + +static final StrokeRec char48[] = { + new StrokeRec(17, char48_stroke0), +}; + +/* char: 49 '1' */ + +static final CoordRec[] char49_stroke0 = { + new CoordRec( (float) 40.4762, (float) 80.9524 ), + new CoordRec( (float) 50, (float) 85.7143 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 64.2857, (float) 0 ), +}; + +static final StrokeRec char49[] = { + new StrokeRec(4, char49_stroke0), +}; + +/* char: 50 '2' */ + +static final CoordRec[] char50_stroke0 = { + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 28.5714, (float) 90.4762 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 90.4762 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 80.9524, (float) 71.4286 ), + new CoordRec( (float) 76.1905, (float) 61.9048 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 19.0476, (float) 0 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char50[] = { + new StrokeRec(14, char50_stroke0), +}; + +/* char: 51 '3' */ + +static final CoordRec[] char51_stroke0 = { + new CoordRec( (float) 28.5714, (float) 100 ), + new CoordRec( (float) 80.9524, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 61.9048 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), +}; + +static final StrokeRec char51[] = { + new StrokeRec(15, char51_stroke0), +}; + +/* char: 52 '4' */ + +static final CoordRec[] char52_stroke0 = { + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 16.6667, (float) 33.3333 ), + new CoordRec( (float) 88.0952, (float) 33.3333 ), +}; + +static final CoordRec[] char52_stroke1 = { + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 64.2857, (float) 0 ), +}; + +static final StrokeRec char52[] = { + new StrokeRec(3, char52_stroke0), + new StrokeRec(2, char52_stroke1), +}; + +/* char: 53 '5' */ + +static final CoordRec[] char53_stroke0 = { + new CoordRec( (float) 76.1905, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 57.1429 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 61.9048 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), +}; + +static final StrokeRec char53[] = { + new StrokeRec(17, char53_stroke0), +}; + +/* char: 54 '6' */ + +static final CoordRec[] char54_stroke0 = { + new CoordRec( (float) 78.5714, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 59.5238, (float) 100 ), + new CoordRec( (float) 50, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 80.9524 ), + new CoordRec( (float) 21.4286, (float) 57.1429 ), + new CoordRec( (float) 21.4286, (float) 33.3333 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 50, (float) 0 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 78.5714, (float) 14.2857 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 33.3333 ), + new CoordRec( (float) 78.5714, (float) 47.619 ), + new CoordRec( (float) 69.0476, (float) 57.1429 ), + new CoordRec( (float) 54.7619, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 61.9048 ), + new CoordRec( (float) 35.7143, (float) 57.1429 ), + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 21.4286, (float) 33.3333 ), +}; + +static final StrokeRec char54[] = { + new StrokeRec(23, char54_stroke0), +}; + +/* char: 55 '7' */ + +static final CoordRec[] char55_stroke0 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 38.0952, (float) 0 ), +}; + +static final CoordRec[] char55_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char55[] = { + new StrokeRec(2, char55_stroke0), + new StrokeRec(2, char55_stroke1), +}; + +/* char: 56 '8' */ + +static final CoordRec[] char56_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 57.1428, (float) 57.1429 ), + new CoordRec( (float) 71.4286, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 85.7143, (float) 19.0476 ), + new CoordRec( (float) 80.9524, (float) 9.5238 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 9.5238 ), + new CoordRec( (float) 19.0476, (float) 19.0476 ), + new CoordRec( (float) 19.0476, (float) 33.3333 ), + new CoordRec( (float) 23.8095, (float) 42.8571 ), + new CoordRec( (float) 33.3333, (float) 52.381 ), + new CoordRec( (float) 47.619, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final StrokeRec char56[] = { + new StrokeRec(29, char56_stroke0), +}; + +/* char: 57 '9' */ + +static final CoordRec[] char57_stroke0 = { + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 78.5714, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 42.8571 ), + new CoordRec( (float) 54.7619, (float) 38.0952 ), + new CoordRec( (float) 50, (float) 38.0952 ), + new CoordRec( (float) 35.7143, (float) 42.8571 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 21.4286, (float) 66.6667 ), + new CoordRec( (float) 21.4286, (float) 71.4286 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 50, (float) 100 ), + new CoordRec( (float) 54.7619, (float) 100 ), + new CoordRec( (float) 69.0476, (float) 95.2381 ), + new CoordRec( (float) 78.5714, (float) 85.7143 ), + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 83.3334, (float) 42.8571 ), + new CoordRec( (float) 78.5714, (float) 19.0476 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), +}; + +static final StrokeRec char57[] = { + new StrokeRec(23, char57_stroke0), +}; + +/* char: 58 ':' */ + +static final CoordRec[] char58_stroke0 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 57.1429 ), + new CoordRec( (float) 57.1429, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final CoordRec[] char58_stroke1 = { + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), +}; + +static final StrokeRec char58[] = { + new StrokeRec(5, char58_stroke0), + new StrokeRec(5, char58_stroke1), +}; + +/* char: 59 ';' */ + +static final CoordRec[] char59_stroke0 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 57.1429 ), + new CoordRec( (float) 57.1429, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 66.6667 ), +}; + +static final CoordRec[] char59_stroke1 = { + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 4.7619 ), + new CoordRec( (float) 52.381, (float) 9.5238 ), + new CoordRec( (float) 57.1429, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) -4.7619 ), + new CoordRec( (float) 52.381, (float) -14.2857 ), + new CoordRec( (float) 47.6191, (float) -19.0476 ), +}; + +static final StrokeRec char59[] = { + new StrokeRec(5, char59_stroke0), + new StrokeRec(8, char59_stroke1), +}; + +/* char: 60 '<' */ + +static final CoordRec[] char60_stroke0 = { + new CoordRec( (float) 90.4762, (float) 85.7143 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final StrokeRec char60[] = { + new StrokeRec(3, char60_stroke0), +}; + +/* char: 61 '=' */ + +static final CoordRec[] char61_stroke0 = { + new CoordRec( (float) 9.5238, (float) 57.1429 ), + new CoordRec( (float) 95.2381, (float) 57.1429 ), +}; + +static final CoordRec[] char61_stroke1 = { + new CoordRec( (float) 9.5238, (float) 28.5714 ), + new CoordRec( (float) 95.2381, (float) 28.5714 ), +}; + +static final StrokeRec char61[] = { + new StrokeRec(2, char61_stroke0), + new StrokeRec(2, char61_stroke1), +}; + +/* char: 62 '>' */ + +static final CoordRec[] char62_stroke0 = { + new CoordRec( (float) 14.2857, (float) 85.7143 ), + new CoordRec( (float) 90.4762, (float) 42.8571 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final StrokeRec char62[] = { + new StrokeRec(3, char62_stroke0), +}; + +/* char: 63 '?' */ + +static final CoordRec[] char63_stroke0 = { + new CoordRec( (float) 23.8095, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 80.9524 ), + new CoordRec( (float) 28.5714, (float) 90.4762 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 71.4285, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 90.4762 ), + new CoordRec( (float) 80.9524, (float) 80.9524 ), + new CoordRec( (float) 80.9524, (float) 71.4286 ), + new CoordRec( (float) 76.1905, (float) 61.9048 ), + new CoordRec( (float) 71.4285, (float) 57.1429 ), + new CoordRec( (float) 52.3809, (float) 47.619 ), + new CoordRec( (float) 52.3809, (float) 33.3333 ), +}; + +static final CoordRec[] char63_stroke1 = { + new CoordRec( (float) 52.3809, (float) 9.5238 ), + new CoordRec( (float) 47.619, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 9.5238 ), +}; + +static final StrokeRec char63[] = { + new StrokeRec(14, char63_stroke0), + new StrokeRec(5, char63_stroke1), +}; + +/* char: 64 '@' */ + +static final CoordRec[] char64_stroke0 = { + new CoordRec( (float) 64.2857, (float) 52.381 ), + new CoordRec( (float) 54.7619, (float) 57.1429 ), + new CoordRec( (float) 45.2381, (float) 57.1429 ), + new CoordRec( (float) 40.4762, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 42.8571 ), + new CoordRec( (float) 45.2381, (float) 33.3333 ), + new CoordRec( (float) 54.7619, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 38.0952 ), +}; + +static final CoordRec[] char64_stroke1 = { + new CoordRec( (float) 64.2857, (float) 57.1429 ), + new CoordRec( (float) 64.2857, (float) 38.0952 ), + new CoordRec( (float) 69.0476, (float) 33.3333 ), + new CoordRec( (float) 78.5714, (float) 33.3333 ), + new CoordRec( (float) 83.3334, (float) 42.8571 ), + new CoordRec( (float) 83.3334, (float) 47.619 ), + new CoordRec( (float) 78.5714, (float) 61.9048 ), + new CoordRec( (float) 69.0476, (float) 71.4286 ), + new CoordRec( (float) 54.7619, (float) 76.1905 ), + new CoordRec( (float) 50, (float) 76.1905 ), + new CoordRec( (float) 35.7143, (float) 71.4286 ), + new CoordRec( (float) 26.1905, (float) 61.9048 ), + new CoordRec( (float) 21.4286, (float) 47.619 ), + new CoordRec( (float) 21.4286, (float) 42.8571 ), + new CoordRec( (float) 26.1905, (float) 28.5714 ), + new CoordRec( (float) 35.7143, (float) 19.0476 ), + new CoordRec( (float) 50, (float) 14.2857 ), + new CoordRec( (float) 54.7619, (float) 14.2857 ), + new CoordRec( (float) 69.0476, (float) 19.0476 ), +}; + +static final StrokeRec char64[] = { + new StrokeRec(8, char64_stroke0), + new StrokeRec(19, char64_stroke1), +}; + +/* char: 65 'A' */ + +static final CoordRec[] char65_stroke0 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final CoordRec[] char65_stroke1 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final CoordRec[] char65_stroke2 = { + new CoordRec( (float) 28.5714, (float) 33.3333 ), + new CoordRec( (float) 76.1905, (float) 33.3333 ), +}; + +static final StrokeRec char65[] = { + new StrokeRec(2, char65_stroke0), + new StrokeRec(2, char65_stroke1), + new StrokeRec(2, char65_stroke2), +}; + +/* char: 66 'B' */ + +static final CoordRec[] char66_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char66_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 71.4286 ), + new CoordRec( (float) 80.9524, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), +}; + +static final CoordRec[] char66_stroke2 = { + new CoordRec( (float) 19.0476, (float) 52.381 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), + new CoordRec( (float) 76.1905, (float) 47.619 ), + new CoordRec( (float) 80.9524, (float) 42.8571 ), + new CoordRec( (float) 85.7143, (float) 33.3333 ), + new CoordRec( (float) 85.7143, (float) 19.0476 ), + new CoordRec( (float) 80.9524, (float) 9.5238 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char66[] = { + new StrokeRec(2, char66_stroke0), + new StrokeRec(9, char66_stroke1), + new StrokeRec(10, char66_stroke2), +}; + +/* char: 67 'C' */ + +static final CoordRec[] char67_stroke0 = { + new CoordRec( (float) 88.0952, (float) 76.1905 ), + new CoordRec( (float) 83.3334, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 21.4286, (float) 76.1905 ), + new CoordRec( (float) 16.6667, (float) 61.9048 ), + new CoordRec( (float) 16.6667, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 23.8095 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 0 ), + new CoordRec( (float) 73.8096, (float) 4.7619 ), + new CoordRec( (float) 83.3334, (float) 14.2857 ), + new CoordRec( (float) 88.0952, (float) 23.8095 ), +}; + +static final StrokeRec char67[] = { + new StrokeRec(18, char67_stroke0), +}; + +/* char: 68 'D' */ + +static final CoordRec[] char68_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char68_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 66.6666, (float) 95.2381 ), + new CoordRec( (float) 76.1905, (float) 85.7143 ), + new CoordRec( (float) 80.9524, (float) 76.1905 ), + new CoordRec( (float) 85.7143, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 23.8095 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 52.3809, (float) 0 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char68[] = { + new StrokeRec(2, char68_stroke0), + new StrokeRec(12, char68_stroke1), +}; + +/* char: 69 'E' */ + +static final CoordRec[] char69_stroke0 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 21.4286, (float) 0 ), +}; + +static final CoordRec[] char69_stroke1 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 83.3334, (float) 100 ), +}; + +static final CoordRec[] char69_stroke2 = { + new CoordRec( (float) 21.4286, (float) 52.381 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), +}; + +static final CoordRec[] char69_stroke3 = { + new CoordRec( (float) 21.4286, (float) 0 ), + new CoordRec( (float) 83.3334, (float) 0 ), +}; + +static final StrokeRec char69[] = { + new StrokeRec(2, char69_stroke0), + new StrokeRec(2, char69_stroke1), + new StrokeRec(2, char69_stroke2), + new StrokeRec(2, char69_stroke3), +}; + +/* char: 70 'F' */ + +static final CoordRec[] char70_stroke0 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 21.4286, (float) 0 ), +}; + +static final CoordRec[] char70_stroke1 = { + new CoordRec( (float) 21.4286, (float) 100 ), + new CoordRec( (float) 83.3334, (float) 100 ), +}; + +static final CoordRec[] char70_stroke2 = { + new CoordRec( (float) 21.4286, (float) 52.381 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), +}; + +static final StrokeRec char70[] = { + new StrokeRec(2, char70_stroke0), + new StrokeRec(2, char70_stroke1), + new StrokeRec(2, char70_stroke2), +}; + +/* char: 71 'G' */ + +static final CoordRec[] char71_stroke0 = { + new CoordRec( (float) 88.0952, (float) 76.1905 ), + new CoordRec( (float) 83.3334, (float) 85.7143 ), + new CoordRec( (float) 73.8096, (float) 95.2381 ), + new CoordRec( (float) 64.2857, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 35.7143, (float) 95.2381 ), + new CoordRec( (float) 26.1905, (float) 85.7143 ), + new CoordRec( (float) 21.4286, (float) 76.1905 ), + new CoordRec( (float) 16.6667, (float) 61.9048 ), + new CoordRec( (float) 16.6667, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 23.8095 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 0 ), + new CoordRec( (float) 73.8096, (float) 4.7619 ), + new CoordRec( (float) 83.3334, (float) 14.2857 ), + new CoordRec( (float) 88.0952, (float) 23.8095 ), + new CoordRec( (float) 88.0952, (float) 38.0952 ), +}; + +static final CoordRec[] char71_stroke1 = { + new CoordRec( (float) 64.2857, (float) 38.0952 ), + new CoordRec( (float) 88.0952, (float) 38.0952 ), +}; + +static final StrokeRec char71[] = { + new StrokeRec(19, char71_stroke0), + new StrokeRec(2, char71_stroke1), +}; + +/* char: 72 'H' */ + +static final CoordRec[] char72_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char72_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char72_stroke2 = { + new CoordRec( (float) 19.0476, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 52.381 ), +}; + +static final StrokeRec char72[] = { + new StrokeRec(2, char72_stroke0), + new StrokeRec(2, char72_stroke1), + new StrokeRec(2, char72_stroke2), +}; + +/* char: 73 'I' */ + +static final CoordRec[] char73_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char73[] = { + new StrokeRec(2, char73_stroke0), +}; + +/* char: 74 'J' */ + +static final CoordRec[] char74_stroke0 = { + new CoordRec( (float) 76.1905, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 23.8095 ), + new CoordRec( (float) 71.4286, (float) 9.5238 ), + new CoordRec( (float) 66.6667, (float) 4.7619 ), + new CoordRec( (float) 57.1429, (float) 0 ), + new CoordRec( (float) 47.6191, (float) 0 ), + new CoordRec( (float) 38.0953, (float) 4.7619 ), + new CoordRec( (float) 33.3334, (float) 9.5238 ), + new CoordRec( (float) 28.5715, (float) 23.8095 ), + new CoordRec( (float) 28.5715, (float) 33.3333 ), +}; + +static final StrokeRec char74[] = { + new StrokeRec(10, char74_stroke0), +}; + +/* char: 75 'K' */ + +static final CoordRec[] char75_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char75_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 33.3333 ), +}; + +static final CoordRec[] char75_stroke2 = { + new CoordRec( (float) 42.8571, (float) 57.1429 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char75[] = { + new StrokeRec(2, char75_stroke0), + new StrokeRec(2, char75_stroke1), + new StrokeRec(2, char75_stroke2), +}; + +/* char: 76 'L' */ + +static final CoordRec[] char76_stroke0 = { + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 0 ), +}; + +static final CoordRec[] char76_stroke1 = { + new CoordRec( (float) 23.8095, (float) 0 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final StrokeRec char76[] = { + new StrokeRec(2, char76_stroke0), + new StrokeRec(2, char76_stroke1), +}; + +/* char: 77 'M' */ + +static final CoordRec[] char77_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 14.2857, (float) 0 ), +}; + +static final CoordRec[] char77_stroke1 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char77_stroke2 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char77_stroke3 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 90.4762, (float) 0 ), +}; + +static final StrokeRec char77[] = { + new StrokeRec(2, char77_stroke0), + new StrokeRec(2, char77_stroke1), + new StrokeRec(2, char77_stroke2), + new StrokeRec(2, char77_stroke3), +}; + +/* char: 78 'N' */ + +static final CoordRec[] char78_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char78_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char78_stroke2 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char78[] = { + new StrokeRec(2, char78_stroke0), + new StrokeRec(2, char78_stroke1), + new StrokeRec(2, char78_stroke2), +}; + +/* char: 79 'O' */ + +static final CoordRec[] char79_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 14.2857, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 23.8095 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 90.4762, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final StrokeRec char79[] = { + new StrokeRec(21, char79_stroke0), +}; + +/* char: 80 'P' */ + +static final CoordRec[] char80_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char80_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 57.1429 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 61.9047, (float) 47.619 ), + new CoordRec( (float) 19.0476, (float) 47.619 ), +}; + +static final StrokeRec char80[] = { + new StrokeRec(2, char80_stroke0), + new StrokeRec(10, char80_stroke1), +}; + +/* char: 81 'Q' */ + +static final CoordRec[] char81_stroke0 = { + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 33.3333, (float) 95.2381 ), + new CoordRec( (float) 23.8095, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 14.2857, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 23.8095 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 90.4762, (float) 61.9048 ), + new CoordRec( (float) 85.7143, (float) 76.1905 ), + new CoordRec( (float) 80.9524, (float) 85.7143 ), + new CoordRec( (float) 71.4286, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), +}; + +static final CoordRec[] char81_stroke1 = { + new CoordRec( (float) 57.1428, (float) 19.0476 ), + new CoordRec( (float) 85.7143, (float) -9.5238 ), +}; + +static final StrokeRec char81[] = { + new StrokeRec(21, char81_stroke0), + new StrokeRec(2, char81_stroke1), +}; + +/* char: 82 'R' */ + +static final CoordRec[] char82_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char82_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 80.9524, (float) 90.4762 ), + new CoordRec( (float) 85.7143, (float) 80.9524 ), + new CoordRec( (float) 85.7143, (float) 71.4286 ), + new CoordRec( (float) 80.9524, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 61.9047, (float) 52.381 ), + new CoordRec( (float) 19.0476, (float) 52.381 ), +}; + +static final CoordRec[] char82_stroke2 = { + new CoordRec( (float) 52.3809, (float) 52.381 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char82[] = { + new StrokeRec(2, char82_stroke0), + new StrokeRec(10, char82_stroke1), + new StrokeRec(2, char82_stroke2), +}; + +/* char: 83 'S' */ + +static final CoordRec[] char83_stroke0 = { + new CoordRec( (float) 85.7143, (float) 85.7143 ), + new CoordRec( (float) 76.1905, (float) 95.2381 ), + new CoordRec( (float) 61.9047, (float) 100 ), + new CoordRec( (float) 42.8571, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 95.2381 ), + new CoordRec( (float) 19.0476, (float) 85.7143 ), + new CoordRec( (float) 19.0476, (float) 76.1905 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 57.1429 ), + new CoordRec( (float) 66.6666, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 14.2857 ), + new CoordRec( (float) 76.1905, (float) 4.7619 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 28.5714, (float) 4.7619 ), + new CoordRec( (float) 19.0476, (float) 14.2857 ), +}; + +static final StrokeRec char83[] = { + new StrokeRec(20, char83_stroke0), +}; + +/* char: 84 'T' */ + +static final CoordRec[] char84_stroke0 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char84_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char84[] = { + new StrokeRec(2, char84_stroke0), + new StrokeRec(2, char84_stroke1), +}; + +/* char: 85 'U' */ + +static final CoordRec[] char85_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 28.5714 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final StrokeRec char85[] = { + new StrokeRec(10, char85_stroke0), +}; + +/* char: 86 'V' */ + +static final CoordRec[] char86_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char86_stroke1 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final StrokeRec char86[] = { + new StrokeRec(2, char86_stroke0), + new StrokeRec(2, char86_stroke1), +}; + +/* char: 87 'W' */ + +static final CoordRec[] char87_stroke0 = { + new CoordRec( (float) 4.7619, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 0 ), +}; + +static final CoordRec[] char87_stroke1 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 28.5714, (float) 0 ), +}; + +static final CoordRec[] char87_stroke2 = { + new CoordRec( (float) 52.3809, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 0 ), +}; + +static final CoordRec[] char87_stroke3 = { + new CoordRec( (float) 100, (float) 100 ), + new CoordRec( (float) 76.1905, (float) 0 ), +}; + +static final StrokeRec char87[] = { + new StrokeRec(2, char87_stroke0), + new StrokeRec(2, char87_stroke1), + new StrokeRec(2, char87_stroke2), + new StrokeRec(2, char87_stroke3), +}; + +/* char: 88 'X' */ + +static final CoordRec[] char88_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final CoordRec[] char88_stroke1 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final StrokeRec char88[] = { + new StrokeRec(2, char88_stroke0), + new StrokeRec(2, char88_stroke1), +}; + +/* char: 89 'Y' */ + +static final CoordRec[] char89_stroke0 = { + new CoordRec( (float) 14.2857, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 52.381 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char89_stroke1 = { + new CoordRec( (float) 90.4762, (float) 100 ), + new CoordRec( (float) 52.3809, (float) 52.381 ), +}; + +static final StrokeRec char89[] = { + new StrokeRec(3, char89_stroke0), + new StrokeRec(2, char89_stroke1), +}; + +/* char: 90 'Z' */ + +static final CoordRec[] char90_stroke0 = { + new CoordRec( (float) 85.7143, (float) 100 ), + new CoordRec( (float) 19.0476, (float) 0 ), +}; + +static final CoordRec[] char90_stroke1 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) 100 ), +}; + +static final CoordRec[] char90_stroke2 = { + new CoordRec( (float) 19.0476, (float) 0 ), + new CoordRec( (float) 85.7143, (float) 0 ), +}; + +static final StrokeRec char90[] = { + new StrokeRec(2, char90_stroke0), + new StrokeRec(2, char90_stroke1), + new StrokeRec(2, char90_stroke2), +}; + +/* char: 91 '[' */ + +static final CoordRec[] char91_stroke0 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 35.7143, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke1 = { + new CoordRec( (float) 40.4762, (float) 119.048 ), + new CoordRec( (float) 40.4762, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke2 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) 119.048 ), +}; + +static final CoordRec[] char91_stroke3 = { + new CoordRec( (float) 35.7143, (float) -33.3333 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char91[] = { + new StrokeRec(2, char91_stroke0), + new StrokeRec(2, char91_stroke1), + new StrokeRec(2, char91_stroke2), + new StrokeRec(2, char91_stroke3), +}; + +/* char: 92 '\' */ + +static final CoordRec[] char92_stroke0 = { + new CoordRec( (float) 19.0476, (float) 100 ), + new CoordRec( (float) 85.7143, (float) -14.2857 ), +}; + +static final StrokeRec char92[] = { + new StrokeRec(2, char92_stroke0), +}; + +/* char: 93 ']' */ + +static final CoordRec[] char93_stroke0 = { + new CoordRec( (float) 64.2857, (float) 119.048 ), + new CoordRec( (float) 64.2857, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke1 = { + new CoordRec( (float) 69.0476, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke2 = { + new CoordRec( (float) 35.7143, (float) 119.048 ), + new CoordRec( (float) 69.0476, (float) 119.048 ), +}; + +static final CoordRec[] char93_stroke3 = { + new CoordRec( (float) 35.7143, (float) -33.3333 ), + new CoordRec( (float) 69.0476, (float) -33.3333 ), +}; + +static final StrokeRec char93[] = { + new StrokeRec(2, char93_stroke0), + new StrokeRec(2, char93_stroke1), + new StrokeRec(2, char93_stroke2), + new StrokeRec(2, char93_stroke3), +}; + +/* char: 94 '^' */ + +static final CoordRec[] char94_stroke0 = { + new CoordRec( (float) 52.3809, (float) 109.524 ), + new CoordRec( (float) 14.2857, (float) 42.8571 ), +}; + +static final CoordRec[] char94_stroke1 = { + new CoordRec( (float) 52.3809, (float) 109.524 ), + new CoordRec( (float) 90.4762, (float) 42.8571 ), +}; + +static final StrokeRec char94[] = { + new StrokeRec(2, char94_stroke0), + new StrokeRec(2, char94_stroke1), +}; + +/* char: 95 '_' */ + +static final CoordRec[] char95_stroke0 = { + new CoordRec( (float) 0, (float) -33.3333 ), + new CoordRec( (float) 104.762, (float) -33.3333 ), + new CoordRec( (float) 104.762, (float) -28.5714 ), + new CoordRec( (float) 0, (float) -28.5714 ), + new CoordRec( (float) 0, (float) -33.3333 ), +}; + +static final StrokeRec char95[] = { + new StrokeRec(5, char95_stroke0), +}; + +/* char: 96 '`' */ + +static final CoordRec[] char96_stroke0 = { + new CoordRec( (float) 42.8572, (float) 100 ), + new CoordRec( (float) 66.6667, (float) 71.4286 ), +}; + +static final CoordRec[] char96_stroke1 = { + new CoordRec( (float) 42.8572, (float) 100 ), + new CoordRec( (float) 38.0953, (float) 95.2381 ), + new CoordRec( (float) 66.6667, (float) 71.4286 ), +}; + +static final StrokeRec char96[] = { + new StrokeRec(2, char96_stroke0), + new StrokeRec(3, char96_stroke1), +}; + +/* char: 97 'a' */ + +static final CoordRec[] char97_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final CoordRec[] char97_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char97[] = { + new StrokeRec(2, char97_stroke0), + new StrokeRec(14, char97_stroke1), +}; + +/* char: 98 'b' */ + +static final CoordRec[] char98_stroke0 = { + new CoordRec( (float) 23.8095, (float) 100 ), + new CoordRec( (float) 23.8095, (float) 0 ), +}; + +static final CoordRec[] char98_stroke1 = { + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), +}; + +static final StrokeRec char98[] = { + new StrokeRec(2, char98_stroke0), + new StrokeRec(14, char98_stroke1), +}; + +/* char: 99 'c' */ + +static final CoordRec[] char99_stroke0 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char99[] = { + new StrokeRec(14, char99_stroke0), +}; + +/* char: 100 'd' */ + +static final CoordRec[] char100_stroke0 = { + new CoordRec( (float) 80.9524, (float) 100 ), + new CoordRec( (float) 80.9524, (float) 0 ), +}; + +static final CoordRec[] char100_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char100[] = { + new StrokeRec(2, char100_stroke0), + new StrokeRec(14, char100_stroke1), +}; + +/* char: 101 'e' */ + +static final CoordRec[] char101_stroke0 = { + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 47.619 ), + new CoordRec( (float) 76.1905, (float) 57.1429 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char101[] = { + new StrokeRec(17, char101_stroke0), +}; + +/* char: 102 'f' */ + +static final CoordRec[] char102_stroke0 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 100 ), + new CoordRec( (float) 52.381, (float) 95.2381 ), + new CoordRec( (float) 47.6191, (float) 80.9524 ), + new CoordRec( (float) 47.6191, (float) 0 ), +}; + +static final CoordRec[] char102_stroke1 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 66.6667, (float) 66.6667 ), +}; + +static final StrokeRec char102[] = { + new StrokeRec(5, char102_stroke0), + new StrokeRec(2, char102_stroke1), +}; + +/* char: 103 'g' */ + +static final CoordRec[] char103_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) -9.5238 ), + new CoordRec( (float) 76.1905, (float) -23.8095 ), + new CoordRec( (float) 71.4285, (float) -28.5714 ), + new CoordRec( (float) 61.9047, (float) -33.3333 ), + new CoordRec( (float) 47.619, (float) -33.3333 ), + new CoordRec( (float) 38.0952, (float) -28.5714 ), +}; + +static final CoordRec[] char103_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char103[] = { + new StrokeRec(7, char103_stroke0), + new StrokeRec(14, char103_stroke1), +}; + +/* char: 104 'h' */ + +static final CoordRec[] char104_stroke0 = { + new CoordRec( (float) 26.1905, (float) 100 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char104_stroke1 = { + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 66.6667 ), + new CoordRec( (float) 64.2857, (float) 66.6667 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 78.5715, (float) 47.619 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char104[] = { + new StrokeRec(2, char104_stroke0), + new StrokeRec(7, char104_stroke1), +}; + +/* char: 105 'i' */ + +static final CoordRec[] char105_stroke0 = { + new CoordRec( (float) 47.6191, (float) 100 ), + new CoordRec( (float) 52.381, (float) 95.2381 ), + new CoordRec( (float) 57.1429, (float) 100 ), + new CoordRec( (float) 52.381, (float) 104.762 ), + new CoordRec( (float) 47.6191, (float) 100 ), +}; + +static final CoordRec[] char105_stroke1 = { + new CoordRec( (float) 52.381, (float) 66.6667 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char105[] = { + new StrokeRec(5, char105_stroke0), + new StrokeRec(2, char105_stroke1), +}; + +/* char: 106 'j' */ + +static final CoordRec[] char106_stroke0 = { + new CoordRec( (float) 57.1429, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 95.2381 ), + new CoordRec( (float) 66.6667, (float) 100 ), + new CoordRec( (float) 61.9048, (float) 104.762 ), + new CoordRec( (float) 57.1429, (float) 100 ), +}; + +static final CoordRec[] char106_stroke1 = { + new CoordRec( (float) 61.9048, (float) 66.6667 ), + new CoordRec( (float) 61.9048, (float) -14.2857 ), + new CoordRec( (float) 57.1429, (float) -28.5714 ), + new CoordRec( (float) 47.6191, (float) -33.3333 ), + new CoordRec( (float) 38.0953, (float) -33.3333 ), +}; + +static final StrokeRec char106[] = { + new StrokeRec(5, char106_stroke0), + new StrokeRec(5, char106_stroke1), +}; + +/* char: 107 'k' */ + +static final CoordRec[] char107_stroke0 = { + new CoordRec( (float) 26.1905, (float) 100 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char107_stroke1 = { + new CoordRec( (float) 73.8095, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 19.0476 ), +}; + +static final CoordRec[] char107_stroke2 = { + new CoordRec( (float) 45.2381, (float) 38.0952 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char107[] = { + new StrokeRec(2, char107_stroke0), + new StrokeRec(2, char107_stroke1), + new StrokeRec(2, char107_stroke2), +}; + +/* char: 108 'l' */ + +static final CoordRec[] char108_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final StrokeRec char108[] = { + new StrokeRec(2, char108_stroke0), +}; + +/* char: 109 'm' */ + +static final CoordRec[] char109_stroke0 = { + new CoordRec( (float) 0, (float) 66.6667 ), + new CoordRec( (float) 0, (float) 0 ), +}; + +static final CoordRec[] char109_stroke1 = { + new CoordRec( (float) 0, (float) 47.619 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 61.9048 ), + new CoordRec( (float) 52.381, (float) 47.619 ), + new CoordRec( (float) 52.381, (float) 0 ), +}; + +static final CoordRec[] char109_stroke2 = { + new CoordRec( (float) 52.381, (float) 47.619 ), + new CoordRec( (float) 66.6667, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 66.6667 ), + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 100, (float) 61.9048 ), + new CoordRec( (float) 104.762, (float) 47.619 ), + new CoordRec( (float) 104.762, (float) 0 ), +}; + +static final StrokeRec char109[] = { + new StrokeRec(2, char109_stroke0), + new StrokeRec(7, char109_stroke1), + new StrokeRec(7, char109_stroke2), +}; + +/* char: 110 'n' */ + +static final CoordRec[] char110_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char110_stroke1 = { + new CoordRec( (float) 26.1905, (float) 47.619 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 50, (float) 66.6667 ), + new CoordRec( (float) 64.2857, (float) 66.6667 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 78.5715, (float) 47.619 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char110[] = { + new StrokeRec(2, char110_stroke0), + new StrokeRec(7, char110_stroke1), +}; + +/* char: 111 'o' */ + +static final CoordRec[] char111_stroke0 = { + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 35.7143, (float) 61.9048 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 21.4286, (float) 38.0952 ), + new CoordRec( (float) 21.4286, (float) 28.5714 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), + new CoordRec( (float) 35.7143, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 59.5238, (float) 0 ), + new CoordRec( (float) 69.0476, (float) 4.7619 ), + new CoordRec( (float) 78.5714, (float) 14.2857 ), + new CoordRec( (float) 83.3334, (float) 28.5714 ), + new CoordRec( (float) 83.3334, (float) 38.0952 ), + new CoordRec( (float) 78.5714, (float) 52.381 ), + new CoordRec( (float) 69.0476, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), +}; + +static final StrokeRec char111[] = { + new StrokeRec(17, char111_stroke0), +}; + +/* char: 112 'p' */ + +static final CoordRec[] char112_stroke0 = { + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 23.8095, (float) -33.3333 ), +}; + +static final CoordRec[] char112_stroke1 = { + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 42.8571, (float) 66.6667 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 66.6666, (float) 61.9048 ), + new CoordRec( (float) 76.1905, (float) 52.381 ), + new CoordRec( (float) 80.9524, (float) 38.0952 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 76.1905, (float) 14.2857 ), + new CoordRec( (float) 66.6666, (float) 4.7619 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 42.8571, (float) 0 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), +}; + +static final StrokeRec char112[] = { + new StrokeRec(2, char112_stroke0), + new StrokeRec(14, char112_stroke1), +}; + +/* char: 113 'q' */ + +static final CoordRec[] char113_stroke0 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 80.9524, (float) -33.3333 ), +}; + +static final CoordRec[] char113_stroke1 = { + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4285, (float) 61.9048 ), + new CoordRec( (float) 61.9047, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 38.0952, (float) 61.9048 ), + new CoordRec( (float) 28.5714, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 38.0952 ), + new CoordRec( (float) 23.8095, (float) 28.5714 ), + new CoordRec( (float) 28.5714, (float) 14.2857 ), + new CoordRec( (float) 38.0952, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 61.9047, (float) 0 ), + new CoordRec( (float) 71.4285, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), +}; + +static final StrokeRec char113[] = { + new StrokeRec(2, char113_stroke0), + new StrokeRec(14, char113_stroke1), +}; + +/* char: 114 'r' */ + +static final CoordRec[] char114_stroke0 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 33.3334, (float) 0 ), +}; + +static final CoordRec[] char114_stroke1 = { + new CoordRec( (float) 33.3334, (float) 38.0952 ), + new CoordRec( (float) 38.0953, (float) 52.381 ), + new CoordRec( (float) 47.6191, (float) 61.9048 ), + new CoordRec( (float) 57.1429, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 66.6667 ), +}; + +static final StrokeRec char114[] = { + new StrokeRec(2, char114_stroke0), + new StrokeRec(5, char114_stroke1), +}; + +/* char: 115 's' */ + +static final CoordRec[] char115_stroke0 = { + new CoordRec( (float) 78.5715, (float) 52.381 ), + new CoordRec( (float) 73.8095, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 30.9524, (float) 61.9048 ), + new CoordRec( (float) 26.1905, (float) 52.381 ), + new CoordRec( (float) 30.9524, (float) 42.8571 ), + new CoordRec( (float) 40.4762, (float) 38.0952 ), + new CoordRec( (float) 64.2857, (float) 33.3333 ), + new CoordRec( (float) 73.8095, (float) 28.5714 ), + new CoordRec( (float) 78.5715, (float) 19.0476 ), + new CoordRec( (float) 78.5715, (float) 14.2857 ), + new CoordRec( (float) 73.8095, (float) 4.7619 ), + new CoordRec( (float) 59.5238, (float) 0 ), + new CoordRec( (float) 45.2381, (float) 0 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 26.1905, (float) 14.2857 ), +}; + +static final StrokeRec char115[] = { + new StrokeRec(17, char115_stroke0), +}; + +/* char: 116 't' */ + +static final CoordRec[] char116_stroke0 = { + new CoordRec( (float) 47.6191, (float) 100 ), + new CoordRec( (float) 47.6191, (float) 19.0476 ), + new CoordRec( (float) 52.381, (float) 4.7619 ), + new CoordRec( (float) 61.9048, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final CoordRec[] char116_stroke1 = { + new CoordRec( (float) 33.3334, (float) 66.6667 ), + new CoordRec( (float) 66.6667, (float) 66.6667 ), +}; + +static final StrokeRec char116[] = { + new StrokeRec(5, char116_stroke0), + new StrokeRec(2, char116_stroke1), +}; + +/* char: 117 'u' */ + +static final CoordRec[] char117_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 19.0476 ), + new CoordRec( (float) 30.9524, (float) 4.7619 ), + new CoordRec( (float) 40.4762, (float) 0 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 64.2857, (float) 4.7619 ), + new CoordRec( (float) 78.5715, (float) 19.0476 ), +}; + +static final CoordRec[] char117_stroke1 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char117[] = { + new StrokeRec(7, char117_stroke0), + new StrokeRec(2, char117_stroke1), +}; + +/* char: 118 'v' */ + +static final CoordRec[] char118_stroke0 = { + new CoordRec( (float) 23.8095, (float) 66.6667 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final CoordRec[] char118_stroke1 = { + new CoordRec( (float) 80.9524, (float) 66.6667 ), + new CoordRec( (float) 52.3809, (float) 0 ), +}; + +static final StrokeRec char118[] = { + new StrokeRec(2, char118_stroke0), + new StrokeRec(2, char118_stroke1), +}; + +/* char: 119 'w' */ + +static final CoordRec[] char119_stroke0 = { + new CoordRec( (float) 14.2857, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 0 ), +}; + +static final CoordRec[] char119_stroke1 = { + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 0 ), +}; + +static final CoordRec[] char119_stroke2 = { + new CoordRec( (float) 52.3809, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final CoordRec[] char119_stroke3 = { + new CoordRec( (float) 90.4762, (float) 66.6667 ), + new CoordRec( (float) 71.4286, (float) 0 ), +}; + +static final StrokeRec char119[] = { + new StrokeRec(2, char119_stroke0), + new StrokeRec(2, char119_stroke1), + new StrokeRec(2, char119_stroke2), + new StrokeRec(2, char119_stroke3), +}; + +/* char: 120 'x' */ + +static final CoordRec[] char120_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final CoordRec[] char120_stroke1 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final StrokeRec char120[] = { + new StrokeRec(2, char120_stroke0), + new StrokeRec(2, char120_stroke1), +}; + +/* char: 121 'y' */ + +static final CoordRec[] char121_stroke0 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 54.7619, (float) 0 ), +}; + +static final CoordRec[] char121_stroke1 = { + new CoordRec( (float) 83.3334, (float) 66.6667 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 45.2381, (float) -19.0476 ), + new CoordRec( (float) 35.7143, (float) -28.5714 ), + new CoordRec( (float) 26.1905, (float) -33.3333 ), + new CoordRec( (float) 21.4286, (float) -33.3333 ), +}; + +static final StrokeRec char121[] = { + new StrokeRec(2, char121_stroke0), + new StrokeRec(6, char121_stroke1), +}; + +/* char: 122 'z' */ + +static final CoordRec[] char122_stroke0 = { + new CoordRec( (float) 78.5715, (float) 66.6667 ), + new CoordRec( (float) 26.1905, (float) 0 ), +}; + +static final CoordRec[] char122_stroke1 = { + new CoordRec( (float) 26.1905, (float) 66.6667 ), + new CoordRec( (float) 78.5715, (float) 66.6667 ), +}; + +static final CoordRec[] char122_stroke2 = { + new CoordRec( (float) 26.1905, (float) 0 ), + new CoordRec( (float) 78.5715, (float) 0 ), +}; + +static final StrokeRec char122[] = { + new StrokeRec(2, char122_stroke0), + new StrokeRec(2, char122_stroke1), + new StrokeRec(2, char122_stroke2), +}; + +/* char: 123 '{' */ + +static final CoordRec[] char123_stroke0 = { + new CoordRec( (float) 64.2857, (float) 119.048 ), + new CoordRec( (float) 54.7619, (float) 114.286 ), + new CoordRec( (float) 50, (float) 109.524 ), + new CoordRec( (float) 45.2381, (float) 100 ), + new CoordRec( (float) 45.2381, (float) 90.4762 ), + new CoordRec( (float) 50, (float) 80.9524 ), + new CoordRec( (float) 54.7619, (float) 76.1905 ), + new CoordRec( (float) 59.5238, (float) 66.6667 ), + new CoordRec( (float) 59.5238, (float) 57.1429 ), + new CoordRec( (float) 50, (float) 47.619 ), +}; + +static final CoordRec[] char123_stroke1 = { + new CoordRec( (float) 54.7619, (float) 114.286 ), + new CoordRec( (float) 50, (float) 104.762 ), + new CoordRec( (float) 50, (float) 95.2381 ), + new CoordRec( (float) 54.7619, (float) 85.7143 ), + new CoordRec( (float) 59.5238, (float) 80.9524 ), + new CoordRec( (float) 64.2857, (float) 71.4286 ), + new CoordRec( (float) 64.2857, (float) 61.9048 ), + new CoordRec( (float) 59.5238, (float) 52.381 ), + new CoordRec( (float) 40.4762, (float) 42.8571 ), + new CoordRec( (float) 59.5238, (float) 33.3333 ), + new CoordRec( (float) 64.2857, (float) 23.8095 ), + new CoordRec( (float) 64.2857, (float) 14.2857 ), + new CoordRec( (float) 59.5238, (float) 4.7619 ), + new CoordRec( (float) 54.7619, (float) 0 ), + new CoordRec( (float) 50, (float) -9.5238 ), + new CoordRec( (float) 50, (float) -19.0476 ), + new CoordRec( (float) 54.7619, (float) -28.5714 ), +}; + +static final CoordRec[] char123_stroke2 = { + new CoordRec( (float) 50, (float) 38.0952 ), + new CoordRec( (float) 59.5238, (float) 28.5714 ), + new CoordRec( (float) 59.5238, (float) 19.0476 ), + new CoordRec( (float) 54.7619, (float) 9.5238 ), + new CoordRec( (float) 50, (float) 4.7619 ), + new CoordRec( (float) 45.2381, (float) -4.7619 ), + new CoordRec( (float) 45.2381, (float) -14.2857 ), + new CoordRec( (float) 50, (float) -23.8095 ), + new CoordRec( (float) 54.7619, (float) -28.5714 ), + new CoordRec( (float) 64.2857, (float) -33.3333 ), +}; + +static final StrokeRec char123[] = { + new StrokeRec(10, char123_stroke0), + new StrokeRec(17, char123_stroke1), + new StrokeRec(10, char123_stroke2), +}; + +/* char: 124 '|' */ + +static final CoordRec[] char124_stroke0 = { + new CoordRec( (float) 52.381, (float) 119.048 ), + new CoordRec( (float) 52.381, (float) -33.3333 ), +}; + +static final StrokeRec char124[] = { + new StrokeRec(2, char124_stroke0), +}; + +/* char: 125 '}' */ + +static final CoordRec[] char125_stroke0 = { + new CoordRec( (float) 40.4762, (float) 119.048 ), + new CoordRec( (float) 50, (float) 114.286 ), + new CoordRec( (float) 54.7619, (float) 109.524 ), + new CoordRec( (float) 59.5238, (float) 100 ), + new CoordRec( (float) 59.5238, (float) 90.4762 ), + new CoordRec( (float) 54.7619, (float) 80.9524 ), + new CoordRec( (float) 50, (float) 76.1905 ), + new CoordRec( (float) 45.2381, (float) 66.6667 ), + new CoordRec( (float) 45.2381, (float) 57.1429 ), + new CoordRec( (float) 54.7619, (float) 47.619 ), +}; + +static final CoordRec[] char125_stroke1 = { + new CoordRec( (float) 50, (float) 114.286 ), + new CoordRec( (float) 54.7619, (float) 104.762 ), + new CoordRec( (float) 54.7619, (float) 95.2381 ), + new CoordRec( (float) 50, (float) 85.7143 ), + new CoordRec( (float) 45.2381, (float) 80.9524 ), + new CoordRec( (float) 40.4762, (float) 71.4286 ), + new CoordRec( (float) 40.4762, (float) 61.9048 ), + new CoordRec( (float) 45.2381, (float) 52.381 ), + new CoordRec( (float) 64.2857, (float) 42.8571 ), + new CoordRec( (float) 45.2381, (float) 33.3333 ), + new CoordRec( (float) 40.4762, (float) 23.8095 ), + new CoordRec( (float) 40.4762, (float) 14.2857 ), + new CoordRec( (float) 45.2381, (float) 4.7619 ), + new CoordRec( (float) 50, (float) 0 ), + new CoordRec( (float) 54.7619, (float) -9.5238 ), + new CoordRec( (float) 54.7619, (float) -19.0476 ), + new CoordRec( (float) 50, (float) -28.5714 ), +}; + +static final CoordRec[] char125_stroke2 = { + new CoordRec( (float) 54.7619, (float) 38.0952 ), + new CoordRec( (float) 45.2381, (float) 28.5714 ), + new CoordRec( (float) 45.2381, (float) 19.0476 ), + new CoordRec( (float) 50, (float) 9.5238 ), + new CoordRec( (float) 54.7619, (float) 4.7619 ), + new CoordRec( (float) 59.5238, (float) -4.7619 ), + new CoordRec( (float) 59.5238, (float) -14.2857 ), + new CoordRec( (float) 54.7619, (float) -23.8095 ), + new CoordRec( (float) 50, (float) -28.5714 ), + new CoordRec( (float) 40.4762, (float) -33.3333 ), +}; + +static final StrokeRec char125[] = { + new StrokeRec(10, char125_stroke0), + new StrokeRec(17, char125_stroke1), + new StrokeRec(10, char125_stroke2), +}; + +/* char: 126 '~' */ + +static final CoordRec[] char126_stroke0 = { + new CoordRec( (float) 9.5238, (float) 28.5714 ), + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 52.381 ), + new CoordRec( (float) 23.8095, (float) 57.1429 ), + new CoordRec( (float) 33.3333, (float) 57.1429 ), + new CoordRec( (float) 42.8571, (float) 52.381 ), + new CoordRec( (float) 61.9048, (float) 38.0952 ), + new CoordRec( (float) 71.4286, (float) 33.3333 ), + new CoordRec( (float) 80.9524, (float) 33.3333 ), + new CoordRec( (float) 90.4762, (float) 38.0952 ), + new CoordRec( (float) 95.2381, (float) 47.619 ), +}; + +static final CoordRec[] char126_stroke1 = { + new CoordRec( (float) 9.5238, (float) 38.0952 ), + new CoordRec( (float) 14.2857, (float) 47.619 ), + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 33.3333, (float) 52.381 ), + new CoordRec( (float) 42.8571, (float) 47.619 ), + new CoordRec( (float) 61.9048, (float) 33.3333 ), + new CoordRec( (float) 71.4286, (float) 28.5714 ), + new CoordRec( (float) 80.9524, (float) 28.5714 ), + new CoordRec( (float) 90.4762, (float) 33.3333 ), + new CoordRec( (float) 95.2381, (float) 47.619 ), + new CoordRec( (float) 95.2381, (float) 57.1429 ), +}; + +static final StrokeRec char126[] = { + new StrokeRec(11, char126_stroke0), + new StrokeRec(11, char126_stroke1), +}; + +/* char: 127 */ + +static final CoordRec[] char127_stroke0 = { + new CoordRec( (float) 71.4286, (float) 100 ), + new CoordRec( (float) 33.3333, (float) -33.3333 ), +}; + +static final CoordRec[] char127_stroke1 = { + new CoordRec( (float) 47.619, (float) 66.6667 ), + new CoordRec( (float) 33.3333, (float) 61.9048 ), + new CoordRec( (float) 23.8095, (float) 52.381 ), + new CoordRec( (float) 19.0476, (float) 38.0952 ), + new CoordRec( (float) 19.0476, (float) 23.8095 ), + new CoordRec( (float) 23.8095, (float) 14.2857 ), + new CoordRec( (float) 33.3333, (float) 4.7619 ), + new CoordRec( (float) 47.619, (float) 0 ), + new CoordRec( (float) 57.1428, (float) 0 ), + new CoordRec( (float) 71.4286, (float) 4.7619 ), + new CoordRec( (float) 80.9524, (float) 14.2857 ), + new CoordRec( (float) 85.7143, (float) 28.5714 ), + new CoordRec( (float) 85.7143, (float) 42.8571 ), + new CoordRec( (float) 80.9524, (float) 52.381 ), + new CoordRec( (float) 71.4286, (float) 61.9048 ), + new CoordRec( (float) 57.1428, (float) 66.6667 ), + new CoordRec( (float) 47.619, (float) 66.6667 ), +}; + +static final StrokeRec char127[] = { + new StrokeRec(2, char127_stroke0), + new StrokeRec(17, char127_stroke1), +}; + +static final StrokeCharRec chars[] = { + new StrokeCharRec( 0, /* char0 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char1 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char2 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char3 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char4 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char5 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char6 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char7 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char8 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char9 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char10 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char11 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char12 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char13 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char14 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char15 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char16 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char17 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char18 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char19 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char20 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char21 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char22 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char23 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char24 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char25 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char26 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char27 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char28 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char29 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char30 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char31 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char32 */ null, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char33, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char34, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char35, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char36, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char37, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char38, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char39, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char40, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char41, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char42, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char43, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char44, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char45, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char46, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char47, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char48, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char49, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char50, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char51, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char52, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char53, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char54, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char55, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char56, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char57, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char58, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char59, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char60, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char61, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char62, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char63, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char64, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char65, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char66, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char67, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char68, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char69, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char70, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char71, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char72, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char73, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char74, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char75, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char76, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char77, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char78, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char79, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char80, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char81, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char82, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char83, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char84, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char85, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char86, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char87, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char88, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char89, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char90, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char91, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char92, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char93, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char94, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char95, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char96, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char97, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char98, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char99, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char100, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char101, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char102, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char103, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char104, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char105, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char106, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char107, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char108, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char109, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char110, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char111, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char112, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char113, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char114, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char115, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char116, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char117, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char118, (float)52.381, (float)104.762 ), + new StrokeCharRec( 4, char119, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char120, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char121, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char122, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char123, (float)52.381, (float)104.762 ), + new StrokeCharRec( 1, char124, (float)52.381, (float)104.762 ), + new StrokeCharRec( 3, char125, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char126, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char127, (float)52.381, (float)104.762 ), +}; + +final static StrokeFontRec fontinfo = new StrokeFontRec( "Roman", 128, chars, (float)119.048, (float)-33.3333 ); + + static public StrokeFontRec getStrokeFontRec() { + return fontinfo; + } +} diff --git a/gl4java/utils/glut/fonts/data/glutStrokeRoman.java b/gl4java/utils/glut/fonts/data/glutStrokeRoman.java new file mode 100644 index 0000000..614454d --- /dev/null +++ b/gl4java/utils/glut/fonts/data/glutStrokeRoman.java @@ -0,0 +1,2458 @@ + +/* GENERATED FILE -- DO NOT MODIFY */ + +package gl4java.utils.glut.fonts.data; + +import gl4java.utils.glut.fonts.*; + +public class glutStrokeRoman implements GLUTStrokeFont { +/* char: 33 '!' */ + +static final CoordRec[] char33_stroke0 = { + new CoordRec( (float) 13.3819, (float) 100 ), + new CoordRec( (float) 13.3819, (float) 33.3333 ), +}; + +static final CoordRec[] char33_stroke1 = { + new CoordRec( (float) 13.3819, (float) 9.5238 ), + new CoordRec( (float) 8.62, (float) 4.7619 ), + new CoordRec( (float) 13.3819, (float) 0 ), + new CoordRec( (float) 18.1438, (float) 4.7619 ), + new CoordRec( (float) 13.3819, (float) 9.5238 ), +}; + +static final StrokeRec char33[] = { + new StrokeRec(2, char33_stroke0), + new StrokeRec(5, char33_stroke1), +}; + +/* char: 34 '"' */ + +static final CoordRec[] char34_stroke0 = { + new CoordRec( (float) 4.02, (float) 100 ), + new CoordRec( (float) 4.02, (float) 66.6667 ), +}; + +static final CoordRec[] char34_stroke1 = { + new CoordRec( (float) 42.1152, (float) 100 ), + new CoordRec( (float) 42.1152, (float) 66.6667 ), +}; + +static final StrokeRec char34[] = { + new StrokeRec(2, char34_stroke0), + new StrokeRec(2, char34_stroke1), +}; + +/* char: 35 '#' */ + +static final CoordRec[] char35_stroke0 = { + new CoordRec( (float) 41.2952, (float) 119.048 ), + new CoordRec( (float) 7.9619, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke1 = { + new CoordRec( (float) 69.8667, (float) 119.048 ), + new CoordRec( (float) 36.5333, (float) -33.3333 ), +}; + +static final CoordRec[] char35_stroke2 = { + new CoordRec( (float) 7.9619, (float) 57.1429 ), + new CoordRec( (float) 74.6286, (float) 57.1429 ), +}; + +static final CoordRec[] char35_stroke3 = { + new CoordRec( (float) 3.2, (float) 28.5714 ), + new CoordRec( (float) 69.8667, (float) 28.5714 ), +}; + +static final StrokeRec char35[] = { + new StrokeRec(2, char35_stroke0), + new StrokeRec(2, char35_stroke1), + new StrokeRec(2, char35_stroke2), + new StrokeRec(2, char35_stroke3), +}; + +/* char: 36 '$' */ + +static final CoordRec[] char36_stroke0 = { + new CoordRec( (float) 28.6295, (float) 119.048 ), + new CoordRec( (float) 28.6295, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke1 = { + new CoordRec( (float) 47.6771, (float) 119.048 ), + new CoordRec( (float) 47.6771, (float) -19.0476 ), +}; + +static final CoordRec[] char36_stroke2 = { + new CoordRec( (float) 71.4867, (float) 85.7143 ), + new CoordRec( (float) 61.9629, (float) 95.2381 ), + new CoordRec( (float) 47.6771, (float) 100 ), + new CoordRec( (float) 28.6295, (float) 100 ), + new CoordRec( (float) 14.3438, (float) 95.2381 ), + new CoordRec( (float) 4.82, (float) 85.7143 ), + new CoordRec( (float) 4.82, (float) 76.1905 ), + new CoordRec( (float) 9.5819, (float) 66.6667 ), + new CoordRec( (float) 14.3438, (float) 61.9048 ), + new CoordRec( (float) 23.8676, (float) 57.1429 ), + new CoordRec( (float) 52.439, (float) 47.619 ), + new CoordRec( (float) 61.9629, (float) 42.8571 ), + new CoordRec( (float) 66.7248, (float) 38.0952 ), + new CoordRec( (float) 71.4867, (float) 28.5714 ), + new CoordRec( (float) 71.4867, (float) 14.2857 ), + new CoordRec( (float) 61.9629, (float) 4.7619 ), + new CoordRec( (float) 47.6771, (float) 0 ), + new CoordRec( (float) 28.6295, (float) 0 ), + new CoordRec( (float) 14.3438, (float) 4.7619 ), + new CoordRec( (float) 4.82, (float) 14.2857 ), +}; + +static final StrokeRec char36[] = { + new StrokeRec(2, char36_stroke0), + new StrokeRec(2, char36_stroke1), + new StrokeRec(20, char36_stroke2), +}; + +/* char: 37 '%' */ + +static final CoordRec[] char37_stroke0 = { + new CoordRec( (float) 92.0743, (float) 100 ), + new CoordRec( (float) 6.36, (float) 0 ), +}; + +static final CoordRec[] char37_stroke1 = { + new CoordRec( (float) 30.1695, (float) 100 ), + new CoordRec( (float) 39.6933, (float) 90.4762 ), + new CoordRec( (float) 39.6933, (float) 80.9524 ), + new CoordRec( (float) 34.9314, (float) 71.4286 ), + new CoordRec( (float) 25.4076, (float) 66.6667 ), + new CoordRec( (float) 15.8838, (float) 66.6667 ), + new CoordRec( (float) 6.36, (float) 76.1905 ), + new CoordRec( (float) 6.36, (float) 85.7143 ), + new CoordRec( (float) 11.1219, (float) 95.2381 ), + new CoordRec( (float) 20.6457, (float) 100 ), + new CoordRec( (float) 30.1695, (float) 100 ), + new CoordRec( (float) 39.6933, (float) 95.2381 ), + new CoordRec( (float) 53.979, (float) 90.4762 ), + new CoordRec( (float) 68.2648, (float) 90.4762 ), + new CoordRec( (float) 82.5505, (float) 95.2381 ), + new CoordRec( (float) 92.0743, (float) 100 ), +}; + +static final CoordRec[] char37_stroke2 = { + new CoordRec( (float) 73.0267, (float) 33.3333 ), + new CoordRec( (float) 63.5029, (float) 28.5714 ), + new CoordRec( (float) 58.741, (float) 19.0476 ), + new CoordRec( (float) 58.741, (float) 9.5238 ), + new CoordRec( (float) 68.2648, (float) 0 ), + new CoordRec( (float) 77.7886, (float) 0 ), + new CoordRec( (float) 87.3124, (float) 4.7619 ), + new CoordRec( (float) 92.0743, (float) 14.2857 ), + new CoordRec( (float) 92.0743, (float) 23.8095 ), + new CoordRec( (float) 82.5505, (float) 33.3333 ), + new CoordRec( (float) 73.0267, (float) 33.3333 ), +}; + +static final StrokeRec char37[] = { + new StrokeRec(2, char37_stroke0), + new StrokeRec(16, char37_stroke1), + new StrokeRec(11, char37_stroke2), +}; + +/* char: 38 '&' */ + +static final CoordRec[] char38_stroke0 = { + new CoordRec( (float) 101.218, (float) 57.1429 ), + new CoordRec( (float) 101.218, (float) 61.9048 ), + new CoordRec( (float) 96.4562, (float) 66.6667 ), + new CoordRec( (float) 91.6943, (float) 66.6667 ), + new CoordRec( (float) 86.9324, (float) 61.9048 ), + new CoordRec( (float) 82.1705, (float) 52.381 ), + new CoordRec( (float) 72.6467, (float) 28.5714 ), + new CoordRec( (float) 63.1229, (float) 14.2857 ), + new CoordRec( (float) 53.599, (float) 4.7619 ), + new CoordRec( (float) 44.0752, (float) 0 ), + new CoordRec( (float) 25.0276, (float) 0 ), + new CoordRec( (float) 15.5038, (float) 4.7619 ), + new CoordRec( (float) 10.7419, (float) 9.5238 ), + new CoordRec( (float) 5.98, (float) 19.0476 ), + new CoordRec( (float) 5.98, (float) 28.5714 ), + new CoordRec( (float) 10.7419, (float) 38.0952 ), + new CoordRec( (float) 15.5038, (float) 42.8571 ), + new CoordRec( (float) 48.8371, (float) 61.9048 ), + new CoordRec( (float) 53.599, (float) 66.6667 ), + new CoordRec( (float) 58.361, (float) 76.1905 ), + new CoordRec( (float) 58.361, (float) 85.7143 ), + new CoordRec( (float) 53.599, (float) 95.2381 ), + new CoordRec( (float) 44.0752, (float) 100 ), + new CoordRec( (float) 34.5514, (float) 95.2381 ), + new CoordRec( (float) 29.7895, (float) 85.7143 ), + new CoordRec( (float) 29.7895, (float) 76.1905 ), + new CoordRec( (float) 34.5514, (float) 61.9048 ), + new CoordRec( (float) 44.0752, (float) 47.619 ), + new CoordRec( (float) 67.8848, (float) 14.2857 ), + new CoordRec( (float) 77.4086, (float) 4.7619 ), + new CoordRec( (float) 86.9324, (float) 0 ), + new CoordRec( (float) 96.4562, (float) 0 ), + new CoordRec( (float) 101.218, (float) 4.7619 ), + new CoordRec( (float) 101.218, (float) 9.5238 ), +}; + +static final StrokeRec char38[] = { + new StrokeRec(34, char38_stroke0), +}; + +/* char: 39 ''' */ + +static final CoordRec[] char39_stroke0 = { + new CoordRec( (float) 4.44, (float) 100 ), + new CoordRec( (float) 4.44, (float) 66.6667 ), +}; + +static final StrokeRec char39[] = { + new StrokeRec(2, char39_stroke0), +}; + +/* char: 40 '(' */ + +static final CoordRec[] char40_stroke0 = { + new CoordRec( (float) 40.9133, (float) 119.048 ), + new CoordRec( (float) 31.3895, (float) 109.524 ), + new CoordRec( (float) 21.8657, (float) 95.2381 ), + new CoordRec( (float) 12.3419, (float) 76.1905 ), + new CoordRec( (float) 7.58, (float) 52.381 ), + new CoordRec( (float) 7.58, (float) 33.3333 ), + new CoordRec( (float) 12.3419, (float) 9.5238 ), + new CoordRec( (float) 21.8657, (float) -9.5238 ), + new CoordRec( (float) 31.3895, (float) -23.8095 ), + new CoordRec( (float) 40.9133, (float) -33.3333 ), +}; + +static final StrokeRec char40[] = { + new StrokeRec(10, char40_stroke0), +}; + +/* char: 41 ')' */ + +static final CoordRec[] char41_stroke0 = { + new CoordRec( (float) 5.28, (float) 119.048 ), + new CoordRec( (float) 14.8038, (float) 109.524 ), + new CoordRec( (float) 24.3276, (float) 95.2381 ), + new CoordRec( (float) 33.8514, (float) 76.1905 ), + new CoordRec( (float) 38.6133, (float) 52.381 ), + new CoordRec( (float) 38.6133, (float) 33.3333 ), + new CoordRec( (float) 33.8514, (float) 9.5238 ), + new CoordRec( (float) 24.3276, (float) -9.5238 ), + new CoordRec( (float) 14.8038, (float) -23.8095 ), + new CoordRec( (float) 5.28, (float) -33.3333 ), +}; + +static final StrokeRec char41[] = { + new StrokeRec(10, char41_stroke0), +}; + +/* char: 42 '*' */ + +static final CoordRec[] char42_stroke0 = { + new CoordRec( (float) 30.7695, (float) 71.4286 ), + new CoordRec( (float) 30.7695, (float) 14.2857 ), +}; + +static final CoordRec[] char42_stroke1 = { + new CoordRec( (float) 6.96, (float) 57.1429 ), + new CoordRec( (float) 54.579, (float) 28.5714 ), +}; + +static final CoordRec[] char42_stroke2 = { + new CoordRec( (float) 54.579, (float) 57.1429 ), + new CoordRec( (float) 6.96, (float) 28.5714 ), +}; + +static final StrokeRec char42[] = { + new StrokeRec(2, char42_stroke0), + new StrokeRec(2, char42_stroke1), + new StrokeRec(2, char42_stroke2), +}; + +/* char: 43 '+' */ + +static final CoordRec[] char43_stroke0 = { + new CoordRec( (float) 48.8371, (float) 85.7143 ), + new CoordRec( (float) 48.8371, (float) 0 ), +}; + +static final CoordRec[] char43_stroke1 = { + new CoordRec( (float) 5.98, (float) 42.8571 ), + new CoordRec( (float) 91.6943, (float) 42.8571 ), +}; + +static final StrokeRec char43[] = { + new StrokeRec(2, char43_stroke0), + new StrokeRec(2, char43_stroke1), +}; + +/* char: 44 ',' */ + +static final CoordRec[] char44_stroke0 = { + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 13.5219, (float) 0 ), + new CoordRec( (float) 8.76, (float) 4.7619 ), + new CoordRec( (float) 13.5219, (float) 9.5238 ), + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 18.2838, (float) -4.7619 ), + new CoordRec( (float) 13.5219, (float) -14.2857 ), + new CoordRec( (float) 8.76, (float) -19.0476 ), +}; + +static final StrokeRec char44[] = { + new StrokeRec(8, char44_stroke0), +}; + +/* char: 45 '-' */ + +static final CoordRec[] char45_stroke0 = { + new CoordRec( (float) 7.38, (float) 42.8571 ), + new CoordRec( (float) 93.0943, (float) 42.8571 ), +}; + +static final StrokeRec char45[] = { + new StrokeRec(2, char45_stroke0), +}; + +/* char: 46 '.' */ + +static final CoordRec[] char46_stroke0 = { + new CoordRec( (float) 13.1019, (float) 9.5238 ), + new CoordRec( (float) 8.34, (float) 4.7619 ), + new CoordRec( (float) 13.1019, (float) 0 ), + new CoordRec( (float) 17.8638, (float) 4.7619 ), + new CoordRec( (float) 13.1019, (float) 9.5238 ), +}; + +static final StrokeRec char46[] = { + new StrokeRec(5, char46_stroke0), +}; + +/* char: 47 '/' */ + +static final CoordRec[] char47_stroke0 = { + new CoordRec( (float) 7.24, (float) -14.2857 ), + new CoordRec( (float) 73.9067, (float) 100 ), +}; + +static final StrokeRec char47[] = { + new StrokeRec(2, char47_stroke0), +}; + +/* char: 48 '0' */ + +static final CoordRec[] char48_stroke0 = { + new CoordRec( (float) 33.5514, (float) 100 ), + new CoordRec( (float) 19.2657, (float) 95.2381 ), + new CoordRec( (float) 9.7419, (float) 80.9524 ), + new CoordRec( (float) 4.98, (float) 57.1429 ), + new CoordRec( (float) 4.98, (float) 42.8571 ), + new CoordRec( (float) 9.7419, (float) 19.0476 ), + new CoordRec( (float) 19.2657, (float) 4.7619 ), + new CoordRec( (float) 33.5514, (float) 0 ), + new CoordRec( (float) 43.0752, (float) 0 ), + new CoordRec( (float) 57.361, (float) 4.7619 ), + new CoordRec( (float) 66.8848, (float) 19.0476 ), + new CoordRec( (float) 71.6467, (float) 42.8571 ), + new CoordRec( (float) 71.6467, (float) 57.1429 ), + new CoordRec( (float) 66.8848, (float) 80.9524 ), + new CoordRec( (float) 57.361, (float) 95.2381 ), + new CoordRec( (float) 43.0752, (float) 100 ), + new CoordRec( (float) 33.5514, (float) 100 ), +}; + +static final StrokeRec char48[] = { + new StrokeRec(17, char48_stroke0), +}; + +/* char: 49 '1' */ + +static final CoordRec[] char49_stroke0 = { + new CoordRec( (float) 11.82, (float) 80.9524 ), + new CoordRec( (float) 21.3438, (float) 85.7143 ), + new CoordRec( (float) 35.6295, (float) 100 ), + new CoordRec( (float) 35.6295, (float) 0 ), +}; + +static final StrokeRec char49[] = { + new StrokeRec(4, char49_stroke0), +}; + +/* char: 50 '2' */ + +static final CoordRec[] char50_stroke0 = { + new CoordRec( (float) 10.1819, (float) 76.1905 ), + new CoordRec( (float) 10.1819, (float) 80.9524 ), + new CoordRec( (float) 14.9438, (float) 90.4762 ), + new CoordRec( (float) 19.7057, (float) 95.2381 ), + new CoordRec( (float) 29.2295, (float) 100 ), + new CoordRec( (float) 48.2771, (float) 100 ), + new CoordRec( (float) 57.801, (float) 95.2381 ), + new CoordRec( (float) 62.5629, (float) 90.4762 ), + new CoordRec( (float) 67.3248, (float) 80.9524 ), + new CoordRec( (float) 67.3248, (float) 71.4286 ), + new CoordRec( (float) 62.5629, (float) 61.9048 ), + new CoordRec( (float) 53.039, (float) 47.619 ), + new CoordRec( (float) 5.42, (float) 0 ), + new CoordRec( (float) 72.0867, (float) 0 ), +}; + +static final StrokeRec char50[] = { + new StrokeRec(14, char50_stroke0), +}; + +/* char: 51 '3' */ + +static final CoordRec[] char51_stroke0 = { + new CoordRec( (float) 14.5238, (float) 100 ), + new CoordRec( (float) 66.9048, (float) 100 ), + new CoordRec( (float) 38.3333, (float) 61.9048 ), + new CoordRec( (float) 52.619, (float) 61.9048 ), + new CoordRec( (float) 62.1429, (float) 57.1429 ), + new CoordRec( (float) 66.9048, (float) 52.381 ), + new CoordRec( (float) 71.6667, (float) 38.0952 ), + new CoordRec( (float) 71.6667, (float) 28.5714 ), + new CoordRec( (float) 66.9048, (float) 14.2857 ), + new CoordRec( (float) 57.381, (float) 4.7619 ), + new CoordRec( (float) 43.0952, (float) 0 ), + new CoordRec( (float) 28.8095, (float) 0 ), + new CoordRec( (float) 14.5238, (float) 4.7619 ), + new CoordRec( (float) 9.7619, (float) 9.5238 ), + new CoordRec( (float) 5, (float) 19.0476 ), +}; + +static final StrokeRec char51[] = { + new StrokeRec(15, char51_stroke0), +}; + +/* char: 52 '4' */ + +static final CoordRec[] char52_stroke0 = { + new CoordRec( (float) 51.499, (float) 100 ), + new CoordRec( (float) 3.88, (float) 33.3333 ), + new CoordRec( (float) 75.3086, (float) 33.3333 ), +}; + +static final CoordRec[] char52_stroke1 = { + new CoordRec( (float) 51.499, (float) 100 ), + new CoordRec( (float) 51.499, (float) 0 ), +}; + +static final StrokeRec char52[] = { + new StrokeRec(3, char52_stroke0), + new StrokeRec(2, char52_stroke1), +}; + +/* char: 53 '5' */ + +static final CoordRec[] char53_stroke0 = { + new CoordRec( (float) 62.0029, (float) 100 ), + new CoordRec( (float) 14.3838, (float) 100 ), + new CoordRec( (float) 9.6219, (float) 57.1429 ), + new CoordRec( (float) 14.3838, (float) 61.9048 ), + new CoordRec( (float) 28.6695, (float) 66.6667 ), + new CoordRec( (float) 42.9552, (float) 66.6667 ), + new CoordRec( (float) 57.241, (float) 61.9048 ), + new CoordRec( (float) 66.7648, (float) 52.381 ), + new CoordRec( (float) 71.5267, (float) 38.0952 ), + new CoordRec( (float) 71.5267, (float) 28.5714 ), + new CoordRec( (float) 66.7648, (float) 14.2857 ), + new CoordRec( (float) 57.241, (float) 4.7619 ), + new CoordRec( (float) 42.9552, (float) 0 ), + new CoordRec( (float) 28.6695, (float) 0 ), + new CoordRec( (float) 14.3838, (float) 4.7619 ), + new CoordRec( (float) 9.6219, (float) 9.5238 ), + new CoordRec( (float) 4.86, (float) 19.0476 ), +}; + +static final StrokeRec char53[] = { + new StrokeRec(17, char53_stroke0), +}; + +/* char: 54 '6' */ + +static final CoordRec[] char54_stroke0 = { + new CoordRec( (float) 62.7229, (float) 85.7143 ), + new CoordRec( (float) 57.961, (float) 95.2381 ), + new CoordRec( (float) 43.6752, (float) 100 ), + new CoordRec( (float) 34.1514, (float) 100 ), + new CoordRec( (float) 19.8657, (float) 95.2381 ), + new CoordRec( (float) 10.3419, (float) 80.9524 ), + new CoordRec( (float) 5.58, (float) 57.1429 ), + new CoordRec( (float) 5.58, (float) 33.3333 ), + new CoordRec( (float) 10.3419, (float) 14.2857 ), + new CoordRec( (float) 19.8657, (float) 4.7619 ), + new CoordRec( (float) 34.1514, (float) 0 ), + new CoordRec( (float) 38.9133, (float) 0 ), + new CoordRec( (float) 53.199, (float) 4.7619 ), + new CoordRec( (float) 62.7229, (float) 14.2857 ), + new CoordRec( (float) 67.4848, (float) 28.5714 ), + new CoordRec( (float) 67.4848, (float) 33.3333 ), + new CoordRec( (float) 62.7229, (float) 47.619 ), + new CoordRec( (float) 53.199, (float) 57.1429 ), + new CoordRec( (float) 38.9133, (float) 61.9048 ), + new CoordRec( (float) 34.1514, (float) 61.9048 ), + new CoordRec( (float) 19.8657, (float) 57.1429 ), + new CoordRec( (float) 10.3419, (float) 47.619 ), + new CoordRec( (float) 5.58, (float) 33.3333 ), +}; + +static final StrokeRec char54[] = { + new StrokeRec(23, char54_stroke0), +}; + +/* char: 55 '7' */ + +static final CoordRec[] char55_stroke0 = { + new CoordRec( (float) 72.2267, (float) 100 ), + new CoordRec( (float) 24.6076, (float) 0 ), +}; + +static final CoordRec[] char55_stroke1 = { + new CoordRec( (float) 5.56, (float) 100 ), + new CoordRec( (float) 72.2267, (float) 100 ), +}; + +static final StrokeRec char55[] = { + new StrokeRec(2, char55_stroke0), + new StrokeRec(2, char55_stroke1), +}; + +/* char: 56 '8' */ + +static final CoordRec[] char56_stroke0 = { + new CoordRec( (float) 29.4095, (float) 100 ), + new CoordRec( (float) 15.1238, (float) 95.2381 ), + new CoordRec( (float) 10.3619, (float) 85.7143 ), + new CoordRec( (float) 10.3619, (float) 76.1905 ), + new CoordRec( (float) 15.1238, (float) 66.6667 ), + new CoordRec( (float) 24.6476, (float) 61.9048 ), + new CoordRec( (float) 43.6952, (float) 57.1429 ), + new CoordRec( (float) 57.981, (float) 52.381 ), + new CoordRec( (float) 67.5048, (float) 42.8571 ), + new CoordRec( (float) 72.2667, (float) 33.3333 ), + new CoordRec( (float) 72.2667, (float) 19.0476 ), + new CoordRec( (float) 67.5048, (float) 9.5238 ), + new CoordRec( (float) 62.7429, (float) 4.7619 ), + new CoordRec( (float) 48.4571, (float) 0 ), + new CoordRec( (float) 29.4095, (float) 0 ), + new CoordRec( (float) 15.1238, (float) 4.7619 ), + new CoordRec( (float) 10.3619, (float) 9.5238 ), + new CoordRec( (float) 5.6, (float) 19.0476 ), + new CoordRec( (float) 5.6, (float) 33.3333 ), + new CoordRec( (float) 10.3619, (float) 42.8571 ), + new CoordRec( (float) 19.8857, (float) 52.381 ), + new CoordRec( (float) 34.1714, (float) 57.1429 ), + new CoordRec( (float) 53.219, (float) 61.9048 ), + new CoordRec( (float) 62.7429, (float) 66.6667 ), + new CoordRec( (float) 67.5048, (float) 76.1905 ), + new CoordRec( (float) 67.5048, (float) 85.7143 ), + new CoordRec( (float) 62.7429, (float) 95.2381 ), + new CoordRec( (float) 48.4571, (float) 100 ), + new CoordRec( (float) 29.4095, (float) 100 ), +}; + +static final StrokeRec char56[] = { + new StrokeRec(29, char56_stroke0), +}; + +/* char: 57 '9' */ + +static final CoordRec[] char57_stroke0 = { + new CoordRec( (float) 68.5048, (float) 66.6667 ), + new CoordRec( (float) 63.7429, (float) 52.381 ), + new CoordRec( (float) 54.219, (float) 42.8571 ), + new CoordRec( (float) 39.9333, (float) 38.0952 ), + new CoordRec( (float) 35.1714, (float) 38.0952 ), + new CoordRec( (float) 20.8857, (float) 42.8571 ), + new CoordRec( (float) 11.3619, (float) 52.381 ), + new CoordRec( (float) 6.6, (float) 66.6667 ), + new CoordRec( (float) 6.6, (float) 71.4286 ), + new CoordRec( (float) 11.3619, (float) 85.7143 ), + new CoordRec( (float) 20.8857, (float) 95.2381 ), + new CoordRec( (float) 35.1714, (float) 100 ), + new CoordRec( (float) 39.9333, (float) 100 ), + new CoordRec( (float) 54.219, (float) 95.2381 ), + new CoordRec( (float) 63.7429, (float) 85.7143 ), + new CoordRec( (float) 68.5048, (float) 66.6667 ), + new CoordRec( (float) 68.5048, (float) 42.8571 ), + new CoordRec( (float) 63.7429, (float) 19.0476 ), + new CoordRec( (float) 54.219, (float) 4.7619 ), + new CoordRec( (float) 39.9333, (float) 0 ), + new CoordRec( (float) 30.4095, (float) 0 ), + new CoordRec( (float) 16.1238, (float) 4.7619 ), + new CoordRec( (float) 11.3619, (float) 14.2857 ), +}; + +static final StrokeRec char57[] = { + new StrokeRec(23, char57_stroke0), +}; + +/* char: 58 ':' */ + +static final CoordRec[] char58_stroke0 = { + new CoordRec( (float) 14.0819, (float) 66.6667 ), + new CoordRec( (float) 9.32, (float) 61.9048 ), + new CoordRec( (float) 14.0819, (float) 57.1429 ), + new CoordRec( (float) 18.8438, (float) 61.9048 ), + new CoordRec( (float) 14.0819, (float) 66.6667 ), +}; + +static final CoordRec[] char58_stroke1 = { + new CoordRec( (float) 14.0819, (float) 9.5238 ), + new CoordRec( (float) 9.32, (float) 4.7619 ), + new CoordRec( (float) 14.0819, (float) 0 ), + new CoordRec( (float) 18.8438, (float) 4.7619 ), + new CoordRec( (float) 14.0819, (float) 9.5238 ), +}; + +static final StrokeRec char58[] = { + new StrokeRec(5, char58_stroke0), + new StrokeRec(5, char58_stroke1), +}; + +/* char: 59 ';' */ + +static final CoordRec[] char59_stroke0 = { + new CoordRec( (float) 12.9619, (float) 66.6667 ), + new CoordRec( (float) 8.2, (float) 61.9048 ), + new CoordRec( (float) 12.9619, (float) 57.1429 ), + new CoordRec( (float) 17.7238, (float) 61.9048 ), + new CoordRec( (float) 12.9619, (float) 66.6667 ), +}; + +static final CoordRec[] char59_stroke1 = { + new CoordRec( (float) 17.7238, (float) 4.7619 ), + new CoordRec( (float) 12.9619, (float) 0 ), + new CoordRec( (float) 8.2, (float) 4.7619 ), + new CoordRec( (float) 12.9619, (float) 9.5238 ), + new CoordRec( (float) 17.7238, (float) 4.7619 ), + new CoordRec( (float) 17.7238, (float) -4.7619 ), + new CoordRec( (float) 12.9619, (float) -14.2857 ), + new CoordRec( (float) 8.2, (float) -19.0476 ), +}; + +static final StrokeRec char59[] = { + new StrokeRec(5, char59_stroke0), + new StrokeRec(8, char59_stroke1), +}; + +/* char: 60 '<' */ + +static final CoordRec[] char60_stroke0 = { + new CoordRec( (float) 79.2505, (float) 85.7143 ), + new CoordRec( (float) 3.06, (float) 42.8571 ), + new CoordRec( (float) 79.2505, (float) 0 ), +}; + +static final StrokeRec char60[] = { + new StrokeRec(3, char60_stroke0), +}; + +/* char: 61 '=' */ + +static final CoordRec[] char61_stroke0 = { + new CoordRec( (float) 5.7, (float) 57.1429 ), + new CoordRec( (float) 91.4143, (float) 57.1429 ), +}; + +static final CoordRec[] char61_stroke1 = { + new CoordRec( (float) 5.7, (float) 28.5714 ), + new CoordRec( (float) 91.4143, (float) 28.5714 ), +}; + +static final StrokeRec char61[] = { + new StrokeRec(2, char61_stroke0), + new StrokeRec(2, char61_stroke1), +}; + +/* char: 62 '>' */ + +static final CoordRec[] char62_stroke0 = { + new CoordRec( (float) 2.78, (float) 85.7143 ), + new CoordRec( (float) 78.9705, (float) 42.8571 ), + new CoordRec( (float) 2.78, (float) 0 ), +}; + +static final StrokeRec char62[] = { + new StrokeRec(3, char62_stroke0), +}; + +/* char: 63 '?' */ + +static final CoordRec[] char63_stroke0 = { + new CoordRec( (float) 8.42, (float) 76.1905 ), + new CoordRec( (float) 8.42, (float) 80.9524 ), + new CoordRec( (float) 13.1819, (float) 90.4762 ), + new CoordRec( (float) 17.9438, (float) 95.2381 ), + new CoordRec( (float) 27.4676, (float) 100 ), + new CoordRec( (float) 46.5152, (float) 100 ), + new CoordRec( (float) 56.039, (float) 95.2381 ), + new CoordRec( (float) 60.801, (float) 90.4762 ), + new CoordRec( (float) 65.5629, (float) 80.9524 ), + new CoordRec( (float) 65.5629, (float) 71.4286 ), + new CoordRec( (float) 60.801, (float) 61.9048 ), + new CoordRec( (float) 56.039, (float) 57.1429 ), + new CoordRec( (float) 36.9914, (float) 47.619 ), + new CoordRec( (float) 36.9914, (float) 33.3333 ), +}; + +static final CoordRec[] char63_stroke1 = { + new CoordRec( (float) 36.9914, (float) 9.5238 ), + new CoordRec( (float) 32.2295, (float) 4.7619 ), + new CoordRec( (float) 36.9914, (float) 0 ), + new CoordRec( (float) 41.7533, (float) 4.7619 ), + new CoordRec( (float) 36.9914, (float) 9.5238 ), +}; + +static final StrokeRec char63[] = { + new StrokeRec(14, char63_stroke0), + new StrokeRec(5, char63_stroke1), +}; + +/* char: 64 '@' */ + +static final CoordRec[] char64_stroke0 = { + new CoordRec( (float) 49.2171, (float) 52.381 ), + new CoordRec( (float) 39.6933, (float) 57.1429 ), + new CoordRec( (float) 30.1695, (float) 57.1429 ), + new CoordRec( (float) 25.4076, (float) 47.619 ), + new CoordRec( (float) 25.4076, (float) 42.8571 ), + new CoordRec( (float) 30.1695, (float) 33.3333 ), + new CoordRec( (float) 39.6933, (float) 33.3333 ), + new CoordRec( (float) 49.2171, (float) 38.0952 ), +}; + +static final CoordRec[] char64_stroke1 = { + new CoordRec( (float) 49.2171, (float) 57.1429 ), + new CoordRec( (float) 49.2171, (float) 38.0952 ), + new CoordRec( (float) 53.979, (float) 33.3333 ), + new CoordRec( (float) 63.5029, (float) 33.3333 ), + new CoordRec( (float) 68.2648, (float) 42.8571 ), + new CoordRec( (float) 68.2648, (float) 47.619 ), + new CoordRec( (float) 63.5029, (float) 61.9048 ), + new CoordRec( (float) 53.979, (float) 71.4286 ), + new CoordRec( (float) 39.6933, (float) 76.1905 ), + new CoordRec( (float) 34.9314, (float) 76.1905 ), + new CoordRec( (float) 20.6457, (float) 71.4286 ), + new CoordRec( (float) 11.1219, (float) 61.9048 ), + new CoordRec( (float) 6.36, (float) 47.619 ), + new CoordRec( (float) 6.36, (float) 42.8571 ), + new CoordRec( (float) 11.1219, (float) 28.5714 ), + new CoordRec( (float) 20.6457, (float) 19.0476 ), + new CoordRec( (float) 34.9314, (float) 14.2857 ), + new CoordRec( (float) 39.6933, (float) 14.2857 ), + new CoordRec( (float) 53.979, (float) 19.0476 ), +}; + +static final StrokeRec char64[] = { + new StrokeRec(8, char64_stroke0), + new StrokeRec(19, char64_stroke1), +}; + +/* char: 65 'A' */ + +static final CoordRec[] char65_stroke0 = { + new CoordRec( (float) 40.5952, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final CoordRec[] char65_stroke1 = { + new CoordRec( (float) 40.5952, (float) 100 ), + new CoordRec( (float) 78.6905, (float) 0 ), +}; + +static final CoordRec[] char65_stroke2 = { + new CoordRec( (float) 16.7857, (float) 33.3333 ), + new CoordRec( (float) 64.4048, (float) 33.3333 ), +}; + +static final StrokeRec char65[] = { + new StrokeRec(2, char65_stroke0), + new StrokeRec(2, char65_stroke1), + new StrokeRec(2, char65_stroke2), +}; + +/* char: 66 'B' */ + +static final CoordRec[] char66_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char66_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 54.2771, (float) 100 ), + new CoordRec( (float) 68.5629, (float) 95.2381 ), + new CoordRec( (float) 73.3248, (float) 90.4762 ), + new CoordRec( (float) 78.0867, (float) 80.9524 ), + new CoordRec( (float) 78.0867, (float) 71.4286 ), + new CoordRec( (float) 73.3248, (float) 61.9048 ), + new CoordRec( (float) 68.5629, (float) 57.1429 ), + new CoordRec( (float) 54.2771, (float) 52.381 ), +}; + +static final CoordRec[] char66_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 54.2771, (float) 52.381 ), + new CoordRec( (float) 68.5629, (float) 47.619 ), + new CoordRec( (float) 73.3248, (float) 42.8571 ), + new CoordRec( (float) 78.0867, (float) 33.3333 ), + new CoordRec( (float) 78.0867, (float) 19.0476 ), + new CoordRec( (float) 73.3248, (float) 9.5238 ), + new CoordRec( (float) 68.5629, (float) 4.7619 ), + new CoordRec( (float) 54.2771, (float) 0 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final StrokeRec char66[] = { + new StrokeRec(2, char66_stroke0), + new StrokeRec(9, char66_stroke1), + new StrokeRec(10, char66_stroke2), +}; + +/* char: 67 'C' */ + +static final CoordRec[] char67_stroke0 = { + new CoordRec( (float) 78.0886, (float) 76.1905 ), + new CoordRec( (float) 73.3267, (float) 85.7143 ), + new CoordRec( (float) 63.8029, (float) 95.2381 ), + new CoordRec( (float) 54.279, (float) 100 ), + new CoordRec( (float) 35.2314, (float) 100 ), + new CoordRec( (float) 25.7076, (float) 95.2381 ), + new CoordRec( (float) 16.1838, (float) 85.7143 ), + new CoordRec( (float) 11.4219, (float) 76.1905 ), + new CoordRec( (float) 6.66, (float) 61.9048 ), + new CoordRec( (float) 6.66, (float) 38.0952 ), + new CoordRec( (float) 11.4219, (float) 23.8095 ), + new CoordRec( (float) 16.1838, (float) 14.2857 ), + new CoordRec( (float) 25.7076, (float) 4.7619 ), + new CoordRec( (float) 35.2314, (float) 0 ), + new CoordRec( (float) 54.279, (float) 0 ), + new CoordRec( (float) 63.8029, (float) 4.7619 ), + new CoordRec( (float) 73.3267, (float) 14.2857 ), + new CoordRec( (float) 78.0886, (float) 23.8095 ), +}; + +static final StrokeRec char67[] = { + new StrokeRec(18, char67_stroke0), +}; + +/* char: 68 'D' */ + +static final CoordRec[] char68_stroke0 = { + new CoordRec( (float) 11.96, (float) 100 ), + new CoordRec( (float) 11.96, (float) 0 ), +}; + +static final CoordRec[] char68_stroke1 = { + new CoordRec( (float) 11.96, (float) 100 ), + new CoordRec( (float) 45.2933, (float) 100 ), + new CoordRec( (float) 59.579, (float) 95.2381 ), + new CoordRec( (float) 69.1029, (float) 85.7143 ), + new CoordRec( (float) 73.8648, (float) 76.1905 ), + new CoordRec( (float) 78.6267, (float) 61.9048 ), + new CoordRec( (float) 78.6267, (float) 38.0952 ), + new CoordRec( (float) 73.8648, (float) 23.8095 ), + new CoordRec( (float) 69.1029, (float) 14.2857 ), + new CoordRec( (float) 59.579, (float) 4.7619 ), + new CoordRec( (float) 45.2933, (float) 0 ), + new CoordRec( (float) 11.96, (float) 0 ), +}; + +static final StrokeRec char68[] = { + new StrokeRec(2, char68_stroke0), + new StrokeRec(12, char68_stroke1), +}; + +/* char: 69 'E' */ + +static final CoordRec[] char69_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char69_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 73.3248, (float) 100 ), +}; + +static final CoordRec[] char69_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 49.5152, (float) 52.381 ), +}; + +static final CoordRec[] char69_stroke3 = { + new CoordRec( (float) 11.42, (float) 0 ), + new CoordRec( (float) 73.3248, (float) 0 ), +}; + +static final StrokeRec char69[] = { + new StrokeRec(2, char69_stroke0), + new StrokeRec(2, char69_stroke1), + new StrokeRec(2, char69_stroke2), + new StrokeRec(2, char69_stroke3), +}; + +/* char: 70 'F' */ + +static final CoordRec[] char70_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char70_stroke1 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 73.3248, (float) 100 ), +}; + +static final CoordRec[] char70_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 49.5152, (float) 52.381 ), +}; + +static final StrokeRec char70[] = { + new StrokeRec(2, char70_stroke0), + new StrokeRec(2, char70_stroke1), + new StrokeRec(2, char70_stroke2), +}; + +/* char: 71 'G' */ + +static final CoordRec[] char71_stroke0 = { + new CoordRec( (float) 78.4886, (float) 76.1905 ), + new CoordRec( (float) 73.7267, (float) 85.7143 ), + new CoordRec( (float) 64.2029, (float) 95.2381 ), + new CoordRec( (float) 54.679, (float) 100 ), + new CoordRec( (float) 35.6314, (float) 100 ), + new CoordRec( (float) 26.1076, (float) 95.2381 ), + new CoordRec( (float) 16.5838, (float) 85.7143 ), + new CoordRec( (float) 11.8219, (float) 76.1905 ), + new CoordRec( (float) 7.06, (float) 61.9048 ), + new CoordRec( (float) 7.06, (float) 38.0952 ), + new CoordRec( (float) 11.8219, (float) 23.8095 ), + new CoordRec( (float) 16.5838, (float) 14.2857 ), + new CoordRec( (float) 26.1076, (float) 4.7619 ), + new CoordRec( (float) 35.6314, (float) 0 ), + new CoordRec( (float) 54.679, (float) 0 ), + new CoordRec( (float) 64.2029, (float) 4.7619 ), + new CoordRec( (float) 73.7267, (float) 14.2857 ), + new CoordRec( (float) 78.4886, (float) 23.8095 ), + new CoordRec( (float) 78.4886, (float) 38.0952 ), +}; + +static final CoordRec[] char71_stroke1 = { + new CoordRec( (float) 54.679, (float) 38.0952 ), + new CoordRec( (float) 78.4886, (float) 38.0952 ), +}; + +static final StrokeRec char71[] = { + new StrokeRec(19, char71_stroke0), + new StrokeRec(2, char71_stroke1), +}; + +/* char: 72 'H' */ + +static final CoordRec[] char72_stroke0 = { + new CoordRec( (float) 11.42, (float) 100 ), + new CoordRec( (float) 11.42, (float) 0 ), +}; + +static final CoordRec[] char72_stroke1 = { + new CoordRec( (float) 78.0867, (float) 100 ), + new CoordRec( (float) 78.0867, (float) 0 ), +}; + +static final CoordRec[] char72_stroke2 = { + new CoordRec( (float) 11.42, (float) 52.381 ), + new CoordRec( (float) 78.0867, (float) 52.381 ), +}; + +static final StrokeRec char72[] = { + new StrokeRec(2, char72_stroke0), + new StrokeRec(2, char72_stroke1), + new StrokeRec(2, char72_stroke2), +}; + +/* char: 73 'I' */ + +static final CoordRec[] char73_stroke0 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 10.86, (float) 0 ), +}; + +static final StrokeRec char73[] = { + new StrokeRec(2, char73_stroke0), +}; + +/* char: 74 'J' */ + +static final CoordRec[] char74_stroke0 = { + new CoordRec( (float) 50.119, (float) 100 ), + new CoordRec( (float) 50.119, (float) 23.8095 ), + new CoordRec( (float) 45.3571, (float) 9.5238 ), + new CoordRec( (float) 40.5952, (float) 4.7619 ), + new CoordRec( (float) 31.0714, (float) 0 ), + new CoordRec( (float) 21.5476, (float) 0 ), + new CoordRec( (float) 12.0238, (float) 4.7619 ), + new CoordRec( (float) 7.2619, (float) 9.5238 ), + new CoordRec( (float) 2.5, (float) 23.8095 ), + new CoordRec( (float) 2.5, (float) 33.3333 ), +}; + +static final StrokeRec char74[] = { + new StrokeRec(10, char74_stroke0), +}; + +/* char: 75 'K' */ + +static final CoordRec[] char75_stroke0 = { + new CoordRec( (float) 11.28, (float) 100 ), + new CoordRec( (float) 11.28, (float) 0 ), +}; + +static final CoordRec[] char75_stroke1 = { + new CoordRec( (float) 77.9467, (float) 100 ), + new CoordRec( (float) 11.28, (float) 33.3333 ), +}; + +static final CoordRec[] char75_stroke2 = { + new CoordRec( (float) 35.0895, (float) 57.1429 ), + new CoordRec( (float) 77.9467, (float) 0 ), +}; + +static final StrokeRec char75[] = { + new StrokeRec(2, char75_stroke0), + new StrokeRec(2, char75_stroke1), + new StrokeRec(2, char75_stroke2), +}; + +/* char: 76 'L' */ + +static final CoordRec[] char76_stroke0 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 11.68, (float) 0 ), +}; + +static final CoordRec[] char76_stroke1 = { + new CoordRec( (float) 11.68, (float) 0 ), + new CoordRec( (float) 68.8229, (float) 0 ), +}; + +static final StrokeRec char76[] = { + new StrokeRec(2, char76_stroke0), + new StrokeRec(2, char76_stroke1), +}; + +/* char: 77 'M' */ + +static final CoordRec[] char77_stroke0 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 10.86, (float) 0 ), +}; + +static final CoordRec[] char77_stroke1 = { + new CoordRec( (float) 10.86, (float) 100 ), + new CoordRec( (float) 48.9552, (float) 0 ), +}; + +static final CoordRec[] char77_stroke2 = { + new CoordRec( (float) 87.0505, (float) 100 ), + new CoordRec( (float) 48.9552, (float) 0 ), +}; + +static final CoordRec[] char77_stroke3 = { + new CoordRec( (float) 87.0505, (float) 100 ), + new CoordRec( (float) 87.0505, (float) 0 ), +}; + +static final StrokeRec char77[] = { + new StrokeRec(2, char77_stroke0), + new StrokeRec(2, char77_stroke1), + new StrokeRec(2, char77_stroke2), + new StrokeRec(2, char77_stroke3), +}; + +/* char: 78 'N' */ + +static final CoordRec[] char78_stroke0 = { + new CoordRec( (float) 11.14, (float) 100 ), + new CoordRec( (float) 11.14, (float) 0 ), +}; + +static final CoordRec[] char78_stroke1 = { + new CoordRec( (float) 11.14, (float) 100 ), + new CoordRec( (float) 77.8067, (float) 0 ), +}; + +static final CoordRec[] char78_stroke2 = { + new CoordRec( (float) 77.8067, (float) 100 ), + new CoordRec( (float) 77.8067, (float) 0 ), +}; + +static final StrokeRec char78[] = { + new StrokeRec(2, char78_stroke0), + new StrokeRec(2, char78_stroke1), + new StrokeRec(2, char78_stroke2), +}; + +/* char: 79 'O' */ + +static final CoordRec[] char79_stroke0 = { + new CoordRec( (float) 34.8114, (float) 100 ), + new CoordRec( (float) 25.2876, (float) 95.2381 ), + new CoordRec( (float) 15.7638, (float) 85.7143 ), + new CoordRec( (float) 11.0019, (float) 76.1905 ), + new CoordRec( (float) 6.24, (float) 61.9048 ), + new CoordRec( (float) 6.24, (float) 38.0952 ), + new CoordRec( (float) 11.0019, (float) 23.8095 ), + new CoordRec( (float) 15.7638, (float) 14.2857 ), + new CoordRec( (float) 25.2876, (float) 4.7619 ), + new CoordRec( (float) 34.8114, (float) 0 ), + new CoordRec( (float) 53.859, (float) 0 ), + new CoordRec( (float) 63.3829, (float) 4.7619 ), + new CoordRec( (float) 72.9067, (float) 14.2857 ), + new CoordRec( (float) 77.6686, (float) 23.8095 ), + new CoordRec( (float) 82.4305, (float) 38.0952 ), + new CoordRec( (float) 82.4305, (float) 61.9048 ), + new CoordRec( (float) 77.6686, (float) 76.1905 ), + new CoordRec( (float) 72.9067, (float) 85.7143 ), + new CoordRec( (float) 63.3829, (float) 95.2381 ), + new CoordRec( (float) 53.859, (float) 100 ), + new CoordRec( (float) 34.8114, (float) 100 ), +}; + +static final StrokeRec char79[] = { + new StrokeRec(21, char79_stroke0), +}; + +/* char: 80 'P' */ + +static final CoordRec[] char80_stroke0 = { + new CoordRec( (float) 12.1, (float) 100 ), + new CoordRec( (float) 12.1, (float) 0 ), +}; + +static final CoordRec[] char80_stroke1 = { + new CoordRec( (float) 12.1, (float) 100 ), + new CoordRec( (float) 54.9571, (float) 100 ), + new CoordRec( (float) 69.2429, (float) 95.2381 ), + new CoordRec( (float) 74.0048, (float) 90.4762 ), + new CoordRec( (float) 78.7667, (float) 80.9524 ), + new CoordRec( (float) 78.7667, (float) 66.6667 ), + new CoordRec( (float) 74.0048, (float) 57.1429 ), + new CoordRec( (float) 69.2429, (float) 52.381 ), + new CoordRec( (float) 54.9571, (float) 47.619 ), + new CoordRec( (float) 12.1, (float) 47.619 ), +}; + +static final StrokeRec char80[] = { + new StrokeRec(2, char80_stroke0), + new StrokeRec(10, char80_stroke1), +}; + +/* char: 81 'Q' */ + +static final CoordRec[] char81_stroke0 = { + new CoordRec( (float) 33.8714, (float) 100 ), + new CoordRec( (float) 24.3476, (float) 95.2381 ), + new CoordRec( (float) 14.8238, (float) 85.7143 ), + new CoordRec( (float) 10.0619, (float) 76.1905 ), + new CoordRec( (float) 5.3, (float) 61.9048 ), + new CoordRec( (float) 5.3, (float) 38.0952 ), + new CoordRec( (float) 10.0619, (float) 23.8095 ), + new CoordRec( (float) 14.8238, (float) 14.2857 ), + new CoordRec( (float) 24.3476, (float) 4.7619 ), + new CoordRec( (float) 33.8714, (float) 0 ), + new CoordRec( (float) 52.919, (float) 0 ), + new CoordRec( (float) 62.4429, (float) 4.7619 ), + new CoordRec( (float) 71.9667, (float) 14.2857 ), + new CoordRec( (float) 76.7286, (float) 23.8095 ), + new CoordRec( (float) 81.4905, (float) 38.0952 ), + new CoordRec( (float) 81.4905, (float) 61.9048 ), + new CoordRec( (float) 76.7286, (float) 76.1905 ), + new CoordRec( (float) 71.9667, (float) 85.7143 ), + new CoordRec( (float) 62.4429, (float) 95.2381 ), + new CoordRec( (float) 52.919, (float) 100 ), + new CoordRec( (float) 33.8714, (float) 100 ), +}; + +static final CoordRec[] char81_stroke1 = { + new CoordRec( (float) 48.1571, (float) 19.0476 ), + new CoordRec( (float) 76.7286, (float) -9.5238 ), +}; + +static final StrokeRec char81[] = { + new StrokeRec(21, char81_stroke0), + new StrokeRec(2, char81_stroke1), +}; + +/* char: 82 'R' */ + +static final CoordRec[] char82_stroke0 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 11.68, (float) 0 ), +}; + +static final CoordRec[] char82_stroke1 = { + new CoordRec( (float) 11.68, (float) 100 ), + new CoordRec( (float) 54.5371, (float) 100 ), + new CoordRec( (float) 68.8229, (float) 95.2381 ), + new CoordRec( (float) 73.5848, (float) 90.4762 ), + new CoordRec( (float) 78.3467, (float) 80.9524 ), + new CoordRec( (float) 78.3467, (float) 71.4286 ), + new CoordRec( (float) 73.5848, (float) 61.9048 ), + new CoordRec( (float) 68.8229, (float) 57.1429 ), + new CoordRec( (float) 54.5371, (float) 52.381 ), + new CoordRec( (float) 11.68, (float) 52.381 ), +}; + +static final CoordRec[] char82_stroke2 = { + new CoordRec( (float) 45.0133, (float) 52.381 ), + new CoordRec( (float) 78.3467, (float) 0 ), +}; + +static final StrokeRec char82[] = { + new StrokeRec(2, char82_stroke0), + new StrokeRec(10, char82_stroke1), + new StrokeRec(2, char82_stroke2), +}; + +/* char: 83 'S' */ + +static final CoordRec[] char83_stroke0 = { + new CoordRec( (float) 74.6667, (float) 85.7143 ), + new CoordRec( (float) 65.1429, (float) 95.2381 ), + new CoordRec( (float) 50.8571, (float) 100 ), + new CoordRec( (float) 31.8095, (float) 100 ), + new CoordRec( (float) 17.5238, (float) 95.2381 ), + new CoordRec( (float) 8, (float) 85.7143 ), + new CoordRec( (float) 8, (float) 76.1905 ), + new CoordRec( (float) 12.7619, (float) 66.6667 ), + new CoordRec( (float) 17.5238, (float) 61.9048 ), + new CoordRec( (float) 27.0476, (float) 57.1429 ), + new CoordRec( (float) 55.619, (float) 47.619 ), + new CoordRec( (float) 65.1429, (float) 42.8571 ), + new CoordRec( (float) 69.9048, (float) 38.0952 ), + new CoordRec( (float) 74.6667, (float) 28.5714 ), + new CoordRec( (float) 74.6667, (float) 14.2857 ), + new CoordRec( (float) 65.1429, (float) 4.7619 ), + new CoordRec( (float) 50.8571, (float) 0 ), + new CoordRec( (float) 31.8095, (float) 0 ), + new CoordRec( (float) 17.5238, (float) 4.7619 ), + new CoordRec( (float) 8, (float) 14.2857 ), +}; + +static final StrokeRec char83[] = { + new StrokeRec(20, char83_stroke0), +}; + +/* char: 84 'T' */ + +static final CoordRec[] char84_stroke0 = { + new CoordRec( (float) 35.6933, (float) 100 ), + new CoordRec( (float) 35.6933, (float) 0 ), +}; + +static final CoordRec[] char84_stroke1 = { + new CoordRec( (float) 2.36, (float) 100 ), + new CoordRec( (float) 69.0267, (float) 100 ), +}; + +static final StrokeRec char84[] = { + new StrokeRec(2, char84_stroke0), + new StrokeRec(2, char84_stroke1), +}; + +/* char: 85 'U' */ + +static final CoordRec[] char85_stroke0 = { + new CoordRec( (float) 11.54, (float) 100 ), + new CoordRec( (float) 11.54, (float) 28.5714 ), + new CoordRec( (float) 16.3019, (float) 14.2857 ), + new CoordRec( (float) 25.8257, (float) 4.7619 ), + new CoordRec( (float) 40.1114, (float) 0 ), + new CoordRec( (float) 49.6352, (float) 0 ), + new CoordRec( (float) 63.921, (float) 4.7619 ), + new CoordRec( (float) 73.4448, (float) 14.2857 ), + new CoordRec( (float) 78.2067, (float) 28.5714 ), + new CoordRec( (float) 78.2067, (float) 100 ), +}; + +static final StrokeRec char85[] = { + new StrokeRec(10, char85_stroke0), +}; + +/* char: 86 'V' */ + +static final CoordRec[] char86_stroke0 = { + new CoordRec( (float) 2.36, (float) 100 ), + new CoordRec( (float) 40.4552, (float) 0 ), +}; + +static final CoordRec[] char86_stroke1 = { + new CoordRec( (float) 78.5505, (float) 100 ), + new CoordRec( (float) 40.4552, (float) 0 ), +}; + +static final StrokeRec char86[] = { + new StrokeRec(2, char86_stroke0), + new StrokeRec(2, char86_stroke1), +}; + +/* char: 87 'W' */ + +static final CoordRec[] char87_stroke0 = { + new CoordRec( (float) 2.22, (float) 100 ), + new CoordRec( (float) 26.0295, (float) 0 ), +}; + +static final CoordRec[] char87_stroke1 = { + new CoordRec( (float) 49.839, (float) 100 ), + new CoordRec( (float) 26.0295, (float) 0 ), +}; + +static final CoordRec[] char87_stroke2 = { + new CoordRec( (float) 49.839, (float) 100 ), + new CoordRec( (float) 73.6486, (float) 0 ), +}; + +static final CoordRec[] char87_stroke3 = { + new CoordRec( (float) 97.4581, (float) 100 ), + new CoordRec( (float) 73.6486, (float) 0 ), +}; + +static final StrokeRec char87[] = { + new StrokeRec(2, char87_stroke0), + new StrokeRec(2, char87_stroke1), + new StrokeRec(2, char87_stroke2), + new StrokeRec(2, char87_stroke3), +}; + +/* char: 88 'X' */ + +static final CoordRec[] char88_stroke0 = { + new CoordRec( (float) 2.5, (float) 100 ), + new CoordRec( (float) 69.1667, (float) 0 ), +}; + +static final CoordRec[] char88_stroke1 = { + new CoordRec( (float) 69.1667, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final StrokeRec char88[] = { + new StrokeRec(2, char88_stroke0), + new StrokeRec(2, char88_stroke1), +}; + +/* char: 89 'Y' */ + +static final CoordRec[] char89_stroke0 = { + new CoordRec( (float) 1.52, (float) 100 ), + new CoordRec( (float) 39.6152, (float) 52.381 ), + new CoordRec( (float) 39.6152, (float) 0 ), +}; + +static final CoordRec[] char89_stroke1 = { + new CoordRec( (float) 77.7105, (float) 100 ), + new CoordRec( (float) 39.6152, (float) 52.381 ), +}; + +static final StrokeRec char89[] = { + new StrokeRec(3, char89_stroke0), + new StrokeRec(2, char89_stroke1), +}; + +/* char: 90 'Z' */ + +static final CoordRec[] char90_stroke0 = { + new CoordRec( (float) 69.1667, (float) 100 ), + new CoordRec( (float) 2.5, (float) 0 ), +}; + +static final CoordRec[] char90_stroke1 = { + new CoordRec( (float) 2.5, (float) 100 ), + new CoordRec( (float) 69.1667, (float) 100 ), +}; + +static final CoordRec[] char90_stroke2 = { + new CoordRec( (float) 2.5, (float) 0 ), + new CoordRec( (float) 69.1667, (float) 0 ), +}; + +static final StrokeRec char90[] = { + new StrokeRec(2, char90_stroke0), + new StrokeRec(2, char90_stroke1), + new StrokeRec(2, char90_stroke2), +}; + +/* char: 91 '[' */ + +static final CoordRec[] char91_stroke0 = { + new CoordRec( (float) 7.78, (float) 119.048 ), + new CoordRec( (float) 7.78, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke1 = { + new CoordRec( (float) 12.5419, (float) 119.048 ), + new CoordRec( (float) 12.5419, (float) -33.3333 ), +}; + +static final CoordRec[] char91_stroke2 = { + new CoordRec( (float) 7.78, (float) 119.048 ), + new CoordRec( (float) 41.1133, (float) 119.048 ), +}; + +static final CoordRec[] char91_stroke3 = { + new CoordRec( (float) 7.78, (float) -33.3333 ), + new CoordRec( (float) 41.1133, (float) -33.3333 ), +}; + +static final StrokeRec char91[] = { + new StrokeRec(2, char91_stroke0), + new StrokeRec(2, char91_stroke1), + new StrokeRec(2, char91_stroke2), + new StrokeRec(2, char91_stroke3), +}; + +/* char: 92 '\' */ + +static final CoordRec[] char92_stroke0 = { + new CoordRec( (float) 5.84, (float) 100 ), + new CoordRec( (float) 72.5067, (float) -14.2857 ), +}; + +static final StrokeRec char92[] = { + new StrokeRec(2, char92_stroke0), +}; + +/* char: 93 ']' */ + +static final CoordRec[] char93_stroke0 = { + new CoordRec( (float) 33.0114, (float) 119.048 ), + new CoordRec( (float) 33.0114, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke1 = { + new CoordRec( (float) 37.7733, (float) 119.048 ), + new CoordRec( (float) 37.7733, (float) -33.3333 ), +}; + +static final CoordRec[] char93_stroke2 = { + new CoordRec( (float) 4.44, (float) 119.048 ), + new CoordRec( (float) 37.7733, (float) 119.048 ), +}; + +static final CoordRec[] char93_stroke3 = { + new CoordRec( (float) 4.44, (float) -33.3333 ), + new CoordRec( (float) 37.7733, (float) -33.3333 ), +}; + +static final StrokeRec char93[] = { + new StrokeRec(2, char93_stroke0), + new StrokeRec(2, char93_stroke1), + new StrokeRec(2, char93_stroke2), + new StrokeRec(2, char93_stroke3), +}; + +/* char: 94 '^' */ + +static final CoordRec[] char94_stroke0 = { + new CoordRec( (float) 44.0752, (float) 109.524 ), + new CoordRec( (float) 5.98, (float) 42.8571 ), +}; + +static final CoordRec[] char94_stroke1 = { + new CoordRec( (float) 44.0752, (float) 109.524 ), + new CoordRec( (float) 82.1705, (float) 42.8571 ), +}; + +static final StrokeRec char94[] = { + new StrokeRec(2, char94_stroke0), + new StrokeRec(2, char94_stroke1), +}; + +/* char: 95 '_' */ + +static final CoordRec[] char95_stroke0 = { + new CoordRec( (float) -1.1, (float) -33.3333 ), + new CoordRec( (float) 103.662, (float) -33.3333 ), + new CoordRec( (float) 103.662, (float) -28.5714 ), + new CoordRec( (float) -1.1, (float) -28.5714 ), + new CoordRec( (float) -1.1, (float) -33.3333 ), +}; + +static final StrokeRec char95[] = { + new StrokeRec(5, char95_stroke0), +}; + +/* char: 96 '`' */ + +static final CoordRec[] char96_stroke0 = { + new CoordRec( (float) 33.0219, (float) 100 ), + new CoordRec( (float) 56.8314, (float) 71.4286 ), +}; + +static final CoordRec[] char96_stroke1 = { + new CoordRec( (float) 33.0219, (float) 100 ), + new CoordRec( (float) 28.26, (float) 95.2381 ), + new CoordRec( (float) 56.8314, (float) 71.4286 ), +}; + +static final StrokeRec char96[] = { + new StrokeRec(2, char96_stroke0), + new StrokeRec(3, char96_stroke1), +}; + +/* char: 97 'a' */ + +static final CoordRec[] char97_stroke0 = { + new CoordRec( (float) 63.8229, (float) 66.6667 ), + new CoordRec( (float) 63.8229, (float) 0 ), +}; + +static final CoordRec[] char97_stroke1 = { + new CoordRec( (float) 63.8229, (float) 52.381 ), + new CoordRec( (float) 54.299, (float) 61.9048 ), + new CoordRec( (float) 44.7752, (float) 66.6667 ), + new CoordRec( (float) 30.4895, (float) 66.6667 ), + new CoordRec( (float) 20.9657, (float) 61.9048 ), + new CoordRec( (float) 11.4419, (float) 52.381 ), + new CoordRec( (float) 6.68, (float) 38.0952 ), + new CoordRec( (float) 6.68, (float) 28.5714 ), + new CoordRec( (float) 11.4419, (float) 14.2857 ), + new CoordRec( (float) 20.9657, (float) 4.7619 ), + new CoordRec( (float) 30.4895, (float) 0 ), + new CoordRec( (float) 44.7752, (float) 0 ), + new CoordRec( (float) 54.299, (float) 4.7619 ), + new CoordRec( (float) 63.8229, (float) 14.2857 ), +}; + +static final StrokeRec char97[] = { + new StrokeRec(2, char97_stroke0), + new StrokeRec(14, char97_stroke1), +}; + +/* char: 98 'b' */ + +static final CoordRec[] char98_stroke0 = { + new CoordRec( (float) 8.76, (float) 100 ), + new CoordRec( (float) 8.76, (float) 0 ), +}; + +static final CoordRec[] char98_stroke1 = { + new CoordRec( (float) 8.76, (float) 52.381 ), + new CoordRec( (float) 18.2838, (float) 61.9048 ), + new CoordRec( (float) 27.8076, (float) 66.6667 ), + new CoordRec( (float) 42.0933, (float) 66.6667 ), + new CoordRec( (float) 51.6171, (float) 61.9048 ), + new CoordRec( (float) 61.141, (float) 52.381 ), + new CoordRec( (float) 65.9029, (float) 38.0952 ), + new CoordRec( (float) 65.9029, (float) 28.5714 ), + new CoordRec( (float) 61.141, (float) 14.2857 ), + new CoordRec( (float) 51.6171, (float) 4.7619 ), + new CoordRec( (float) 42.0933, (float) 0 ), + new CoordRec( (float) 27.8076, (float) 0 ), + new CoordRec( (float) 18.2838, (float) 4.7619 ), + new CoordRec( (float) 8.76, (float) 14.2857 ), +}; + +static final StrokeRec char98[] = { + new StrokeRec(2, char98_stroke0), + new StrokeRec(14, char98_stroke1), +}; + +/* char: 99 'c' */ + +static final CoordRec[] char99_stroke0 = { + new CoordRec( (float) 62.6629, (float) 52.381 ), + new CoordRec( (float) 53.139, (float) 61.9048 ), + new CoordRec( (float) 43.6152, (float) 66.6667 ), + new CoordRec( (float) 29.3295, (float) 66.6667 ), + new CoordRec( (float) 19.8057, (float) 61.9048 ), + new CoordRec( (float) 10.2819, (float) 52.381 ), + new CoordRec( (float) 5.52, (float) 38.0952 ), + new CoordRec( (float) 5.52, (float) 28.5714 ), + new CoordRec( (float) 10.2819, (float) 14.2857 ), + new CoordRec( (float) 19.8057, (float) 4.7619 ), + new CoordRec( (float) 29.3295, (float) 0 ), + new CoordRec( (float) 43.6152, (float) 0 ), + new CoordRec( (float) 53.139, (float) 4.7619 ), + new CoordRec( (float) 62.6629, (float) 14.2857 ), +}; + +static final StrokeRec char99[] = { + new StrokeRec(14, char99_stroke0), +}; + +/* char: 100 'd' */ + +static final CoordRec[] char100_stroke0 = { + new CoordRec( (float) 61.7829, (float) 100 ), + new CoordRec( (float) 61.7829, (float) 0 ), +}; + +static final CoordRec[] char100_stroke1 = { + new CoordRec( (float) 61.7829, (float) 52.381 ), + new CoordRec( (float) 52.259, (float) 61.9048 ), + new CoordRec( (float) 42.7352, (float) 66.6667 ), + new CoordRec( (float) 28.4495, (float) 66.6667 ), + new CoordRec( (float) 18.9257, (float) 61.9048 ), + new CoordRec( (float) 9.4019, (float) 52.381 ), + new CoordRec( (float) 4.64, (float) 38.0952 ), + new CoordRec( (float) 4.64, (float) 28.5714 ), + new CoordRec( (float) 9.4019, (float) 14.2857 ), + new CoordRec( (float) 18.9257, (float) 4.7619 ), + new CoordRec( (float) 28.4495, (float) 0 ), + new CoordRec( (float) 42.7352, (float) 0 ), + new CoordRec( (float) 52.259, (float) 4.7619 ), + new CoordRec( (float) 61.7829, (float) 14.2857 ), +}; + +static final StrokeRec char100[] = { + new StrokeRec(2, char100_stroke0), + new StrokeRec(14, char100_stroke1), +}; + +/* char: 101 'e' */ + +static final CoordRec[] char101_stroke0 = { + new CoordRec( (float) 5.72, (float) 38.0952 ), + new CoordRec( (float) 62.8629, (float) 38.0952 ), + new CoordRec( (float) 62.8629, (float) 47.619 ), + new CoordRec( (float) 58.101, (float) 57.1429 ), + new CoordRec( (float) 53.339, (float) 61.9048 ), + new CoordRec( (float) 43.8152, (float) 66.6667 ), + new CoordRec( (float) 29.5295, (float) 66.6667 ), + new CoordRec( (float) 20.0057, (float) 61.9048 ), + new CoordRec( (float) 10.4819, (float) 52.381 ), + new CoordRec( (float) 5.72, (float) 38.0952 ), + new CoordRec( (float) 5.72, (float) 28.5714 ), + new CoordRec( (float) 10.4819, (float) 14.2857 ), + new CoordRec( (float) 20.0057, (float) 4.7619 ), + new CoordRec( (float) 29.5295, (float) 0 ), + new CoordRec( (float) 43.8152, (float) 0 ), + new CoordRec( (float) 53.339, (float) 4.7619 ), + new CoordRec( (float) 62.8629, (float) 14.2857 ), +}; + +static final StrokeRec char101[] = { + new StrokeRec(17, char101_stroke0), +}; + +/* char: 102 'f' */ + +static final CoordRec[] char102_stroke0 = { + new CoordRec( (float) 38.7752, (float) 100 ), + new CoordRec( (float) 29.2514, (float) 100 ), + new CoordRec( (float) 19.7276, (float) 95.2381 ), + new CoordRec( (float) 14.9657, (float) 80.9524 ), + new CoordRec( (float) 14.9657, (float) 0 ), +}; + +static final CoordRec[] char102_stroke1 = { + new CoordRec( (float) 0.68, (float) 66.6667 ), + new CoordRec( (float) 34.0133, (float) 66.6667 ), +}; + +static final StrokeRec char102[] = { + new StrokeRec(5, char102_stroke0), + new StrokeRec(2, char102_stroke1), +}; + +/* char: 103 'g' */ + +static final CoordRec[] char103_stroke0 = { + new CoordRec( (float) 62.5029, (float) 66.6667 ), + new CoordRec( (float) 62.5029, (float) -9.5238 ), + new CoordRec( (float) 57.741, (float) -23.8095 ), + new CoordRec( (float) 52.979, (float) -28.5714 ), + new CoordRec( (float) 43.4552, (float) -33.3333 ), + new CoordRec( (float) 29.1695, (float) -33.3333 ), + new CoordRec( (float) 19.6457, (float) -28.5714 ), +}; + +static final CoordRec[] char103_stroke1 = { + new CoordRec( (float) 62.5029, (float) 52.381 ), + new CoordRec( (float) 52.979, (float) 61.9048 ), + new CoordRec( (float) 43.4552, (float) 66.6667 ), + new CoordRec( (float) 29.1695, (float) 66.6667 ), + new CoordRec( (float) 19.6457, (float) 61.9048 ), + new CoordRec( (float) 10.1219, (float) 52.381 ), + new CoordRec( (float) 5.36, (float) 38.0952 ), + new CoordRec( (float) 5.36, (float) 28.5714 ), + new CoordRec( (float) 10.1219, (float) 14.2857 ), + new CoordRec( (float) 19.6457, (float) 4.7619 ), + new CoordRec( (float) 29.1695, (float) 0 ), + new CoordRec( (float) 43.4552, (float) 0 ), + new CoordRec( (float) 52.979, (float) 4.7619 ), + new CoordRec( (float) 62.5029, (float) 14.2857 ), +}; + +static final StrokeRec char103[] = { + new StrokeRec(7, char103_stroke0), + new StrokeRec(14, char103_stroke1), +}; + +/* char: 104 'h' */ + +static final CoordRec[] char104_stroke0 = { + new CoordRec( (float) 9.6, (float) 100 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char104_stroke1 = { + new CoordRec( (float) 9.6, (float) 47.619 ), + new CoordRec( (float) 23.8857, (float) 61.9048 ), + new CoordRec( (float) 33.4095, (float) 66.6667 ), + new CoordRec( (float) 47.6952, (float) 66.6667 ), + new CoordRec( (float) 57.219, (float) 61.9048 ), + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final StrokeRec char104[] = { + new StrokeRec(2, char104_stroke0), + new StrokeRec(7, char104_stroke1), +}; + +/* char: 105 'i' */ + +static final CoordRec[] char105_stroke0 = { + new CoordRec( (float) 10.02, (float) 100 ), + new CoordRec( (float) 14.7819, (float) 95.2381 ), + new CoordRec( (float) 19.5438, (float) 100 ), + new CoordRec( (float) 14.7819, (float) 104.762 ), + new CoordRec( (float) 10.02, (float) 100 ), +}; + +static final CoordRec[] char105_stroke1 = { + new CoordRec( (float) 14.7819, (float) 66.6667 ), + new CoordRec( (float) 14.7819, (float) 0 ), +}; + +static final StrokeRec char105[] = { + new StrokeRec(5, char105_stroke0), + new StrokeRec(2, char105_stroke1), +}; + +/* char: 106 'j' */ + +static final CoordRec[] char106_stroke0 = { + new CoordRec( (float) 17.3876, (float) 100 ), + new CoordRec( (float) 22.1495, (float) 95.2381 ), + new CoordRec( (float) 26.9114, (float) 100 ), + new CoordRec( (float) 22.1495, (float) 104.762 ), + new CoordRec( (float) 17.3876, (float) 100 ), +}; + +static final CoordRec[] char106_stroke1 = { + new CoordRec( (float) 22.1495, (float) 66.6667 ), + new CoordRec( (float) 22.1495, (float) -14.2857 ), + new CoordRec( (float) 17.3876, (float) -28.5714 ), + new CoordRec( (float) 7.8638, (float) -33.3333 ), + new CoordRec( (float) -1.66, (float) -33.3333 ), +}; + +static final StrokeRec char106[] = { + new StrokeRec(5, char106_stroke0), + new StrokeRec(5, char106_stroke1), +}; + +/* char: 107 'k' */ + +static final CoordRec[] char107_stroke0 = { + new CoordRec( (float) 9.6, (float) 100 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char107_stroke1 = { + new CoordRec( (float) 57.219, (float) 66.6667 ), + new CoordRec( (float) 9.6, (float) 19.0476 ), +}; + +static final CoordRec[] char107_stroke2 = { + new CoordRec( (float) 28.6476, (float) 38.0952 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final StrokeRec char107[] = { + new StrokeRec(2, char107_stroke0), + new StrokeRec(2, char107_stroke1), + new StrokeRec(2, char107_stroke2), +}; + +/* char: 108 'l' */ + +static final CoordRec[] char108_stroke0 = { + new CoordRec( (float) 10.02, (float) 100 ), + new CoordRec( (float) 10.02, (float) 0 ), +}; + +static final StrokeRec char108[] = { + new StrokeRec(2, char108_stroke0), +}; + +/* char: 109 'm' */ + +static final CoordRec[] char109_stroke0 = { + new CoordRec( (float) 9.6, (float) 66.6667 ), + new CoordRec( (float) 9.6, (float) 0 ), +}; + +static final CoordRec[] char109_stroke1 = { + new CoordRec( (float) 9.6, (float) 47.619 ), + new CoordRec( (float) 23.8857, (float) 61.9048 ), + new CoordRec( (float) 33.4095, (float) 66.6667 ), + new CoordRec( (float) 47.6952, (float) 66.6667 ), + new CoordRec( (float) 57.219, (float) 61.9048 ), + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 61.981, (float) 0 ), +}; + +static final CoordRec[] char109_stroke2 = { + new CoordRec( (float) 61.981, (float) 47.619 ), + new CoordRec( (float) 76.2667, (float) 61.9048 ), + new CoordRec( (float) 85.7905, (float) 66.6667 ), + new CoordRec( (float) 100.076, (float) 66.6667 ), + new CoordRec( (float) 109.6, (float) 61.9048 ), + new CoordRec( (float) 114.362, (float) 47.619 ), + new CoordRec( (float) 114.362, (float) 0 ), +}; + +static final StrokeRec char109[] = { + new StrokeRec(2, char109_stroke0), + new StrokeRec(7, char109_stroke1), + new StrokeRec(7, char109_stroke2), +}; + +/* char: 110 'n' */ + +static final CoordRec[] char110_stroke0 = { + new CoordRec( (float) 9.18, (float) 66.6667 ), + new CoordRec( (float) 9.18, (float) 0 ), +}; + +static final CoordRec[] char110_stroke1 = { + new CoordRec( (float) 9.18, (float) 47.619 ), + new CoordRec( (float) 23.4657, (float) 61.9048 ), + new CoordRec( (float) 32.9895, (float) 66.6667 ), + new CoordRec( (float) 47.2752, (float) 66.6667 ), + new CoordRec( (float) 56.799, (float) 61.9048 ), + new CoordRec( (float) 61.561, (float) 47.619 ), + new CoordRec( (float) 61.561, (float) 0 ), +}; + +static final StrokeRec char110[] = { + new StrokeRec(2, char110_stroke0), + new StrokeRec(7, char110_stroke1), +}; + +/* char: 111 'o' */ + +static final CoordRec[] char111_stroke0 = { + new CoordRec( (float) 28.7895, (float) 66.6667 ), + new CoordRec( (float) 19.2657, (float) 61.9048 ), + new CoordRec( (float) 9.7419, (float) 52.381 ), + new CoordRec( (float) 4.98, (float) 38.0952 ), + new CoordRec( (float) 4.98, (float) 28.5714 ), + new CoordRec( (float) 9.7419, (float) 14.2857 ), + new CoordRec( (float) 19.2657, (float) 4.7619 ), + new CoordRec( (float) 28.7895, (float) 0 ), + new CoordRec( (float) 43.0752, (float) 0 ), + new CoordRec( (float) 52.599, (float) 4.7619 ), + new CoordRec( (float) 62.1229, (float) 14.2857 ), + new CoordRec( (float) 66.8848, (float) 28.5714 ), + new CoordRec( (float) 66.8848, (float) 38.0952 ), + new CoordRec( (float) 62.1229, (float) 52.381 ), + new CoordRec( (float) 52.599, (float) 61.9048 ), + new CoordRec( (float) 43.0752, (float) 66.6667 ), + new CoordRec( (float) 28.7895, (float) 66.6667 ), +}; + +static final StrokeRec char111[] = { + new StrokeRec(17, char111_stroke0), +}; + +/* char: 112 'p' */ + +static final CoordRec[] char112_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) -33.3333 ), +}; + +static final CoordRec[] char112_stroke1 = { + new CoordRec( (float) 9.46, (float) 52.381 ), + new CoordRec( (float) 18.9838, (float) 61.9048 ), + new CoordRec( (float) 28.5076, (float) 66.6667 ), + new CoordRec( (float) 42.7933, (float) 66.6667 ), + new CoordRec( (float) 52.3171, (float) 61.9048 ), + new CoordRec( (float) 61.841, (float) 52.381 ), + new CoordRec( (float) 66.6029, (float) 38.0952 ), + new CoordRec( (float) 66.6029, (float) 28.5714 ), + new CoordRec( (float) 61.841, (float) 14.2857 ), + new CoordRec( (float) 52.3171, (float) 4.7619 ), + new CoordRec( (float) 42.7933, (float) 0 ), + new CoordRec( (float) 28.5076, (float) 0 ), + new CoordRec( (float) 18.9838, (float) 4.7619 ), + new CoordRec( (float) 9.46, (float) 14.2857 ), +}; + +static final StrokeRec char112[] = { + new StrokeRec(2, char112_stroke0), + new StrokeRec(14, char112_stroke1), +}; + +/* char: 113 'q' */ + +static final CoordRec[] char113_stroke0 = { + new CoordRec( (float) 61.9829, (float) 66.6667 ), + new CoordRec( (float) 61.9829, (float) -33.3333 ), +}; + +static final CoordRec[] char113_stroke1 = { + new CoordRec( (float) 61.9829, (float) 52.381 ), + new CoordRec( (float) 52.459, (float) 61.9048 ), + new CoordRec( (float) 42.9352, (float) 66.6667 ), + new CoordRec( (float) 28.6495, (float) 66.6667 ), + new CoordRec( (float) 19.1257, (float) 61.9048 ), + new CoordRec( (float) 9.6019, (float) 52.381 ), + new CoordRec( (float) 4.84, (float) 38.0952 ), + new CoordRec( (float) 4.84, (float) 28.5714 ), + new CoordRec( (float) 9.6019, (float) 14.2857 ), + new CoordRec( (float) 19.1257, (float) 4.7619 ), + new CoordRec( (float) 28.6495, (float) 0 ), + new CoordRec( (float) 42.9352, (float) 0 ), + new CoordRec( (float) 52.459, (float) 4.7619 ), + new CoordRec( (float) 61.9829, (float) 14.2857 ), +}; + +static final StrokeRec char113[] = { + new StrokeRec(2, char113_stroke0), + new StrokeRec(14, char113_stroke1), +}; + +/* char: 114 'r' */ + +static final CoordRec[] char114_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) 0 ), +}; + +static final CoordRec[] char114_stroke1 = { + new CoordRec( (float) 9.46, (float) 38.0952 ), + new CoordRec( (float) 14.2219, (float) 52.381 ), + new CoordRec( (float) 23.7457, (float) 61.9048 ), + new CoordRec( (float) 33.2695, (float) 66.6667 ), + new CoordRec( (float) 47.5552, (float) 66.6667 ), +}; + +static final StrokeRec char114[] = { + new StrokeRec(2, char114_stroke0), + new StrokeRec(5, char114_stroke1), +}; + +/* char: 115 's' */ + +static final CoordRec[] char115_stroke0 = { + new CoordRec( (float) 57.081, (float) 52.381 ), + new CoordRec( (float) 52.319, (float) 61.9048 ), + new CoordRec( (float) 38.0333, (float) 66.6667 ), + new CoordRec( (float) 23.7476, (float) 66.6667 ), + new CoordRec( (float) 9.4619, (float) 61.9048 ), + new CoordRec( (float) 4.7, (float) 52.381 ), + new CoordRec( (float) 9.4619, (float) 42.8571 ), + new CoordRec( (float) 18.9857, (float) 38.0952 ), + new CoordRec( (float) 42.7952, (float) 33.3333 ), + new CoordRec( (float) 52.319, (float) 28.5714 ), + new CoordRec( (float) 57.081, (float) 19.0476 ), + new CoordRec( (float) 57.081, (float) 14.2857 ), + new CoordRec( (float) 52.319, (float) 4.7619 ), + new CoordRec( (float) 38.0333, (float) 0 ), + new CoordRec( (float) 23.7476, (float) 0 ), + new CoordRec( (float) 9.4619, (float) 4.7619 ), + new CoordRec( (float) 4.7, (float) 14.2857 ), +}; + +static final StrokeRec char115[] = { + new StrokeRec(17, char115_stroke0), +}; + +/* char: 116 't' */ + +static final CoordRec[] char116_stroke0 = { + new CoordRec( (float) 14.8257, (float) 100 ), + new CoordRec( (float) 14.8257, (float) 19.0476 ), + new CoordRec( (float) 19.5876, (float) 4.7619 ), + new CoordRec( (float) 29.1114, (float) 0 ), + new CoordRec( (float) 38.6352, (float) 0 ), +}; + +static final CoordRec[] char116_stroke1 = { + new CoordRec( (float) 0.54, (float) 66.6667 ), + new CoordRec( (float) 33.8733, (float) 66.6667 ), +}; + +static final StrokeRec char116[] = { + new StrokeRec(5, char116_stroke0), + new StrokeRec(2, char116_stroke1), +}; + +/* char: 117 'u' */ + +static final CoordRec[] char117_stroke0 = { + new CoordRec( (float) 9.46, (float) 66.6667 ), + new CoordRec( (float) 9.46, (float) 19.0476 ), + new CoordRec( (float) 14.2219, (float) 4.7619 ), + new CoordRec( (float) 23.7457, (float) 0 ), + new CoordRec( (float) 38.0314, (float) 0 ), + new CoordRec( (float) 47.5552, (float) 4.7619 ), + new CoordRec( (float) 61.841, (float) 19.0476 ), +}; + +static final CoordRec[] char117_stroke1 = { + new CoordRec( (float) 61.841, (float) 66.6667 ), + new CoordRec( (float) 61.841, (float) 0 ), +}; + +static final StrokeRec char117[] = { + new StrokeRec(7, char117_stroke0), + new StrokeRec(2, char117_stroke1), +}; + +/* char: 118 'v' */ + +static final CoordRec[] char118_stroke0 = { + new CoordRec( (float) 1.8, (float) 66.6667 ), + new CoordRec( (float) 30.3714, (float) 0 ), +}; + +static final CoordRec[] char118_stroke1 = { + new CoordRec( (float) 58.9429, (float) 66.6667 ), + new CoordRec( (float) 30.3714, (float) 0 ), +}; + +static final StrokeRec char118[] = { + new StrokeRec(2, char118_stroke0), + new StrokeRec(2, char118_stroke1), +}; + +/* char: 119 'w' */ + +static final CoordRec[] char119_stroke0 = { + new CoordRec( (float) 2.5, (float) 66.6667 ), + new CoordRec( (float) 21.5476, (float) 0 ), +}; + +static final CoordRec[] char119_stroke1 = { + new CoordRec( (float) 40.5952, (float) 66.6667 ), + new CoordRec( (float) 21.5476, (float) 0 ), +}; + +static final CoordRec[] char119_stroke2 = { + new CoordRec( (float) 40.5952, (float) 66.6667 ), + new CoordRec( (float) 59.6429, (float) 0 ), +}; + +static final CoordRec[] char119_stroke3 = { + new CoordRec( (float) 78.6905, (float) 66.6667 ), + new CoordRec( (float) 59.6429, (float) 0 ), +}; + +static final StrokeRec char119[] = { + new StrokeRec(2, char119_stroke0), + new StrokeRec(2, char119_stroke1), + new StrokeRec(2, char119_stroke2), + new StrokeRec(2, char119_stroke3), +}; + +/* char: 120 'x' */ + +static final CoordRec[] char120_stroke0 = { + new CoordRec( (float) 1.66, (float) 66.6667 ), + new CoordRec( (float) 54.041, (float) 0 ), +}; + +static final CoordRec[] char120_stroke1 = { + new CoordRec( (float) 54.041, (float) 66.6667 ), + new CoordRec( (float) 1.66, (float) 0 ), +}; + +static final StrokeRec char120[] = { + new StrokeRec(2, char120_stroke0), + new StrokeRec(2, char120_stroke1), +}; + +/* char: 121 'y' */ + +static final CoordRec[] char121_stroke0 = { + new CoordRec( (float) 6.5619, (float) 66.6667 ), + new CoordRec( (float) 35.1333, (float) 0 ), +}; + +static final CoordRec[] char121_stroke1 = { + new CoordRec( (float) 63.7048, (float) 66.6667 ), + new CoordRec( (float) 35.1333, (float) 0 ), + new CoordRec( (float) 25.6095, (float) -19.0476 ), + new CoordRec( (float) 16.0857, (float) -28.5714 ), + new CoordRec( (float) 6.5619, (float) -33.3333 ), + new CoordRec( (float) 1.8, (float) -33.3333 ), +}; + +static final StrokeRec char121[] = { + new StrokeRec(2, char121_stroke0), + new StrokeRec(6, char121_stroke1), +}; + +/* char: 122 'z' */ + +static final CoordRec[] char122_stroke0 = { + new CoordRec( (float) 56.821, (float) 66.6667 ), + new CoordRec( (float) 4.44, (float) 0 ), +}; + +static final CoordRec[] char122_stroke1 = { + new CoordRec( (float) 4.44, (float) 66.6667 ), + new CoordRec( (float) 56.821, (float) 66.6667 ), +}; + +static final CoordRec[] char122_stroke2 = { + new CoordRec( (float) 4.44, (float) 0 ), + new CoordRec( (float) 56.821, (float) 0 ), +}; + +static final StrokeRec char122[] = { + new StrokeRec(2, char122_stroke0), + new StrokeRec(2, char122_stroke1), + new StrokeRec(2, char122_stroke2), +}; + +/* char: 123 '{' */ + +static final CoordRec[] char123_stroke0 = { + new CoordRec( (float) 31.1895, (float) 119.048 ), + new CoordRec( (float) 21.6657, (float) 114.286 ), + new CoordRec( (float) 16.9038, (float) 109.524 ), + new CoordRec( (float) 12.1419, (float) 100 ), + new CoordRec( (float) 12.1419, (float) 90.4762 ), + new CoordRec( (float) 16.9038, (float) 80.9524 ), + new CoordRec( (float) 21.6657, (float) 76.1905 ), + new CoordRec( (float) 26.4276, (float) 66.6667 ), + new CoordRec( (float) 26.4276, (float) 57.1429 ), + new CoordRec( (float) 16.9038, (float) 47.619 ), +}; + +static final CoordRec[] char123_stroke1 = { + new CoordRec( (float) 21.6657, (float) 114.286 ), + new CoordRec( (float) 16.9038, (float) 104.762 ), + new CoordRec( (float) 16.9038, (float) 95.2381 ), + new CoordRec( (float) 21.6657, (float) 85.7143 ), + new CoordRec( (float) 26.4276, (float) 80.9524 ), + new CoordRec( (float) 31.1895, (float) 71.4286 ), + new CoordRec( (float) 31.1895, (float) 61.9048 ), + new CoordRec( (float) 26.4276, (float) 52.381 ), + new CoordRec( (float) 7.38, (float) 42.8571 ), + new CoordRec( (float) 26.4276, (float) 33.3333 ), + new CoordRec( (float) 31.1895, (float) 23.8095 ), + new CoordRec( (float) 31.1895, (float) 14.2857 ), + new CoordRec( (float) 26.4276, (float) 4.7619 ), + new CoordRec( (float) 21.6657, (float) 0 ), + new CoordRec( (float) 16.9038, (float) -9.5238 ), + new CoordRec( (float) 16.9038, (float) -19.0476 ), + new CoordRec( (float) 21.6657, (float) -28.5714 ), +}; + +static final CoordRec[] char123_stroke2 = { + new CoordRec( (float) 16.9038, (float) 38.0952 ), + new CoordRec( (float) 26.4276, (float) 28.5714 ), + new CoordRec( (float) 26.4276, (float) 19.0476 ), + new CoordRec( (float) 21.6657, (float) 9.5238 ), + new CoordRec( (float) 16.9038, (float) 4.7619 ), + new CoordRec( (float) 12.1419, (float) -4.7619 ), + new CoordRec( (float) 12.1419, (float) -14.2857 ), + new CoordRec( (float) 16.9038, (float) -23.8095 ), + new CoordRec( (float) 21.6657, (float) -28.5714 ), + new CoordRec( (float) 31.1895, (float) -33.3333 ), +}; + +static final StrokeRec char123[] = { + new StrokeRec(10, char123_stroke0), + new StrokeRec(17, char123_stroke1), + new StrokeRec(10, char123_stroke2), +}; + +/* char: 124 '|' */ + +static final CoordRec[] char124_stroke0 = { + new CoordRec( (float) 11.54, (float) 119.048 ), + new CoordRec( (float) 11.54, (float) -33.3333 ), +}; + +static final StrokeRec char124[] = { + new StrokeRec(2, char124_stroke0), +}; + +/* char: 125 '}' */ + +static final CoordRec[] char125_stroke0 = { + new CoordRec( (float) 9.18, (float) 119.048 ), + new CoordRec( (float) 18.7038, (float) 114.286 ), + new CoordRec( (float) 23.4657, (float) 109.524 ), + new CoordRec( (float) 28.2276, (float) 100 ), + new CoordRec( (float) 28.2276, (float) 90.4762 ), + new CoordRec( (float) 23.4657, (float) 80.9524 ), + new CoordRec( (float) 18.7038, (float) 76.1905 ), + new CoordRec( (float) 13.9419, (float) 66.6667 ), + new CoordRec( (float) 13.9419, (float) 57.1429 ), + new CoordRec( (float) 23.4657, (float) 47.619 ), +}; + +static final CoordRec[] char125_stroke1 = { + new CoordRec( (float) 18.7038, (float) 114.286 ), + new CoordRec( (float) 23.4657, (float) 104.762 ), + new CoordRec( (float) 23.4657, (float) 95.2381 ), + new CoordRec( (float) 18.7038, (float) 85.7143 ), + new CoordRec( (float) 13.9419, (float) 80.9524 ), + new CoordRec( (float) 9.18, (float) 71.4286 ), + new CoordRec( (float) 9.18, (float) 61.9048 ), + new CoordRec( (float) 13.9419, (float) 52.381 ), + new CoordRec( (float) 32.9895, (float) 42.8571 ), + new CoordRec( (float) 13.9419, (float) 33.3333 ), + new CoordRec( (float) 9.18, (float) 23.8095 ), + new CoordRec( (float) 9.18, (float) 14.2857 ), + new CoordRec( (float) 13.9419, (float) 4.7619 ), + new CoordRec( (float) 18.7038, (float) 0 ), + new CoordRec( (float) 23.4657, (float) -9.5238 ), + new CoordRec( (float) 23.4657, (float) -19.0476 ), + new CoordRec( (float) 18.7038, (float) -28.5714 ), +}; + +static final CoordRec[] char125_stroke2 = { + new CoordRec( (float) 23.4657, (float) 38.0952 ), + new CoordRec( (float) 13.9419, (float) 28.5714 ), + new CoordRec( (float) 13.9419, (float) 19.0476 ), + new CoordRec( (float) 18.7038, (float) 9.5238 ), + new CoordRec( (float) 23.4657, (float) 4.7619 ), + new CoordRec( (float) 28.2276, (float) -4.7619 ), + new CoordRec( (float) 28.2276, (float) -14.2857 ), + new CoordRec( (float) 23.4657, (float) -23.8095 ), + new CoordRec( (float) 18.7038, (float) -28.5714 ), + new CoordRec( (float) 9.18, (float) -33.3333 ), +}; + +static final StrokeRec char125[] = { + new StrokeRec(10, char125_stroke0), + new StrokeRec(17, char125_stroke1), + new StrokeRec(10, char125_stroke2), +}; + +/* char: 126 '~' */ + +static final CoordRec[] char126_stroke0 = { + new CoordRec( (float) 2.92, (float) 28.5714 ), + new CoordRec( (float) 2.92, (float) 38.0952 ), + new CoordRec( (float) 7.6819, (float) 52.381 ), + new CoordRec( (float) 17.2057, (float) 57.1429 ), + new CoordRec( (float) 26.7295, (float) 57.1429 ), + new CoordRec( (float) 36.2533, (float) 52.381 ), + new CoordRec( (float) 55.301, (float) 38.0952 ), + new CoordRec( (float) 64.8248, (float) 33.3333 ), + new CoordRec( (float) 74.3486, (float) 33.3333 ), + new CoordRec( (float) 83.8724, (float) 38.0952 ), + new CoordRec( (float) 88.6343, (float) 47.619 ), +}; + +static final CoordRec[] char126_stroke1 = { + new CoordRec( (float) 2.92, (float) 38.0952 ), + new CoordRec( (float) 7.6819, (float) 47.619 ), + new CoordRec( (float) 17.2057, (float) 52.381 ), + new CoordRec( (float) 26.7295, (float) 52.381 ), + new CoordRec( (float) 36.2533, (float) 47.619 ), + new CoordRec( (float) 55.301, (float) 33.3333 ), + new CoordRec( (float) 64.8248, (float) 28.5714 ), + new CoordRec( (float) 74.3486, (float) 28.5714 ), + new CoordRec( (float) 83.8724, (float) 33.3333 ), + new CoordRec( (float) 88.6343, (float) 47.619 ), + new CoordRec( (float) 88.6343, (float) 57.1429 ), +}; + +static final StrokeRec char126[] = { + new StrokeRec(11, char126_stroke0), + new StrokeRec(11, char126_stroke1), +}; + +/* char: 127 */ + +static final CoordRec[] char127_stroke0 = { + new CoordRec( (float) 52.381, (float) 100 ), + new CoordRec( (float) 14.2857, (float) -33.3333 ), +}; + +static final CoordRec[] char127_stroke1 = { + new CoordRec( (float) 28.5714, (float) 66.6667 ), + new CoordRec( (float) 14.2857, (float) 61.9048 ), + new CoordRec( (float) 4.7619, (float) 52.381 ), + new CoordRec( (float) 0, (float) 38.0952 ), + new CoordRec( (float) 0, (float) 23.8095 ), + new CoordRec( (float) 4.7619, (float) 14.2857 ), + new CoordRec( (float) 14.2857, (float) 4.7619 ), + new CoordRec( (float) 28.5714, (float) 0 ), + new CoordRec( (float) 38.0952, (float) 0 ), + new CoordRec( (float) 52.381, (float) 4.7619 ), + new CoordRec( (float) 61.9048, (float) 14.2857 ), + new CoordRec( (float) 66.6667, (float) 28.5714 ), + new CoordRec( (float) 66.6667, (float) 42.8571 ), + new CoordRec( (float) 61.9048, (float) 52.381 ), + new CoordRec( (float) 52.381, (float) 61.9048 ), + new CoordRec( (float) 38.0952, (float) 66.6667 ), + new CoordRec( (float) 28.5714, (float) 66.6667 ), +}; + +static final StrokeRec char127[] = { + new StrokeRec(2, char127_stroke0), + new StrokeRec(17, char127_stroke1), +}; + +static final StrokeCharRec chars[] = { + new StrokeCharRec( 0, /* char0 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char1 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char2 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char3 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char4 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char5 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char6 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char7 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char8 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char9 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char10 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char11 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char12 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char13 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char14 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char15 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char16 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char17 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char18 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char19 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char20 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char21 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char22 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char23 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char24 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char25 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char26 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char27 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char28 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char29 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char30 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char31 */ null, (float)0, (float)0 ), + new StrokeCharRec( 0, /* char32 */ null, (float)52.381, (float)104.762 ), + new StrokeCharRec( 2, char33, (float)13.3819, (float)26.6238 ), + new StrokeCharRec( 2, char34, (float)23.0676, (float)51.4352 ), + new StrokeCharRec( 4, char35, (float)36.5333, (float)79.4886 ), + new StrokeCharRec( 3, char36, (float)38.1533, (float)76.2067 ), + new StrokeCharRec( 3, char37, (float)49.2171, (float)96.5743 ), + new StrokeCharRec( 1, char38, (float)53.599, (float)101.758 ), + new StrokeCharRec( 1, char39, (float)4.44, (float)13.62 ), + new StrokeCharRec( 1, char40, (float)21.8657, (float)47.1733 ), + new StrokeCharRec( 1, char41, (float)24.3276, (float)47.5333 ), + new StrokeCharRec( 3, char42, (float)30.7695, (float)59.439 ), + new StrokeCharRec( 2, char43, (float)48.8371, (float)97.2543 ), + new StrokeCharRec( 1, char44, (float)13.5219, (float)26.0638 ), + new StrokeCharRec( 1, char45, (float)50.2371, (float)100.754 ), + new StrokeCharRec( 1, char46, (float)13.1019, (float)26.4838 ), + new StrokeCharRec( 1, char47, (float)40.5733, (float)82.1067 ), + new StrokeCharRec( 1, char48, (float)38.3133, (float)77.0667 ), + new StrokeCharRec( 1, char49, (float)30.8676, (float)66.5295 ), + new StrokeCharRec( 1, char50, (float)38.7533, (float)77.6467 ), + new StrokeCharRec( 1, char51, (float)38.3333, (float)77.0467 ), + new StrokeCharRec( 2, char52, (float)37.2133, (float)80.1686 ), + new StrokeCharRec( 1, char53, (float)38.1933, (float)77.6867 ), + new StrokeCharRec( 1, char54, (float)34.1514, (float)73.8048 ), + new StrokeCharRec( 2, char55, (float)38.8933, (float)77.2267 ), + new StrokeCharRec( 1, char56, (float)38.9333, (float)77.6667 ), + new StrokeCharRec( 1, char57, (float)39.9333, (float)74.0648 ), + new StrokeCharRec( 2, char58, (float)14.0819, (float)26.2238 ), + new StrokeCharRec( 2, char59, (float)12.9619, (float)26.3038 ), + new StrokeCharRec( 1, char60, (float)41.1552, (float)81.6105 ), + new StrokeCharRec( 2, char61, (float)48.5571, (float)97.2543 ), + new StrokeCharRec( 1, char62, (float)40.8752, (float)81.6105 ), + new StrokeCharRec( 2, char63, (float)36.9914, (float)73.9029 ), + new StrokeCharRec( 2, char64, (float)34.9314, (float)74.3648 ), + new StrokeCharRec( 3, char65, (float)40.5952, (float)80.4905 ), + new StrokeCharRec( 3, char66, (float)44.7533, (float)83.6267 ), + new StrokeCharRec( 1, char67, (float)39.9933, (float)84.4886 ), + new StrokeCharRec( 2, char68, (float)45.2933, (float)85.2867 ), + new StrokeCharRec( 4, char69, (float)39.9914, (float)78.1848 ), + new StrokeCharRec( 3, char70, (float)39.9914, (float)78.7448 ), + new StrokeCharRec( 2, char71, (float)40.3933, (float)89.7686 ), + new StrokeCharRec( 3, char72, (float)44.7533, (float)89.0867 ), + new StrokeCharRec( 1, char73, (float)10.86, (float)21.3 ), + new StrokeCharRec( 1, char74, (float)31.0714, (float)59.999 ), + new StrokeCharRec( 3, char75, (float)44.6133, (float)79.3267 ), + new StrokeCharRec( 2, char76, (float)40.2514, (float)71.3229 ), + new StrokeCharRec( 4, char77, (float)48.9552, (float)97.2105 ), + new StrokeCharRec( 3, char78, (float)44.4733, (float)88.8067 ), + new StrokeCharRec( 1, char79, (float)44.3352, (float)88.8305 ), + new StrokeCharRec( 2, char80, (float)45.4333, (float)85.6667 ), + new StrokeCharRec( 2, char81, (float)43.3952, (float)88.0905 ), + new StrokeCharRec( 3, char82, (float)45.0133, (float)82.3667 ), + new StrokeCharRec( 1, char83, (float)41.3333, (float)80.8267 ), + new StrokeCharRec( 2, char84, (float)35.6933, (float)71.9467 ), + new StrokeCharRec( 1, char85, (float)44.8733, (float)89.4867 ), + new StrokeCharRec( 2, char86, (float)40.4552, (float)81.6105 ), + new StrokeCharRec( 4, char87, (float)49.839, (float)100.518 ), + new StrokeCharRec( 2, char88, (float)35.8333, (float)72.3667 ), + new StrokeCharRec( 2, char89, (float)39.6152, (float)79.6505 ), + new StrokeCharRec( 3, char90, (float)35.8333, (float)73.7467 ), + new StrokeCharRec( 4, char91, (float)22.0657, (float)46.1133 ), + new StrokeCharRec( 1, char92, (float)39.1733, (float)78.2067 ), + new StrokeCharRec( 4, char93, (float)23.4876, (float)46.3933 ), + new StrokeCharRec( 2, char94, (float)44.0752, (float)90.2305 ), + new StrokeCharRec( 1, char95, (float)51.281, (float)104.062 ), + new StrokeCharRec( 2, char96, (float)42.5457, (float)83.5714 ), + new StrokeCharRec( 2, char97, (float)35.2514, (float)66.6029 ), + new StrokeCharRec( 2, char98, (float)37.3314, (float)70.4629 ), + new StrokeCharRec( 1, char99, (float)34.0914, (float)68.9229 ), + new StrokeCharRec( 2, char100, (float)33.2114, (float)70.2629 ), + new StrokeCharRec( 1, char101, (float)34.2914, (float)68.5229 ), + new StrokeCharRec( 2, char102, (float)14.9657, (float)38.6552 ), + new StrokeCharRec( 2, char103, (float)33.9314, (float)70.9829 ), + new StrokeCharRec( 2, char104, (float)33.4095, (float)71.021 ), + new StrokeCharRec( 2, char105, (float)14.7819, (float)28.8638 ), + new StrokeCharRec( 2, char106, (float)17.3876, (float)36.2314 ), + new StrokeCharRec( 3, char107, (float)33.4095, (float)62.521 ), + new StrokeCharRec( 1, char108, (float)10.02, (float)19.34 ), + new StrokeCharRec( 3, char109, (float)61.981, (float)123.962 ), + new StrokeCharRec( 2, char110, (float)32.9895, (float)70.881 ), + new StrokeCharRec( 1, char111, (float)33.5514, (float)71.7448 ), + new StrokeCharRec( 2, char112, (float)38.0314, (float)70.8029 ), + new StrokeCharRec( 2, char113, (float)33.4114, (float)70.7429 ), + new StrokeCharRec( 2, char114, (float)23.7457, (float)49.4952 ), + new StrokeCharRec( 1, char115, (float)28.5095, (float)62.321 ), + new StrokeCharRec( 2, char116, (float)14.8257, (float)39.3152 ), + new StrokeCharRec( 2, char117, (float)33.2695, (float)71.161 ), + new StrokeCharRec( 2, char118, (float)30.3714, (float)60.6029 ), + new StrokeCharRec( 4, char119, (float)40.5952, (float)80.4905 ), + new StrokeCharRec( 2, char120, (float)25.4695, (float)56.401 ), + new StrokeCharRec( 2, char121, (float)35.1333, (float)66.0648 ), + new StrokeCharRec( 3, char122, (float)28.2495, (float)61.821 ), + new StrokeCharRec( 3, char123, (float)21.6657, (float)41.6295 ), + new StrokeCharRec( 1, char124, (float)11.54, (float)23.78 ), + new StrokeCharRec( 3, char125, (float)18.7038, (float)41.4695 ), + new StrokeCharRec( 2, char126, (float)45.7771, (float)91.2743 ), + new StrokeCharRec( 2, char127, (float)33.3333, (float)66.6667 ), +}; + +final static StrokeFontRec fontinfo = new StrokeFontRec( "Roman", 128, chars, (float)119.048, (float)-33.3333 ); + + static public StrokeFontRec getStrokeFontRec() { + return fontinfo; + } +} diff --git a/gl4java/utils/glut/fonts/stroke.h b/gl4java/utils/glut/fonts/stroke.h new file mode 100644 index 0000000..fc29680 --- /dev/null +++ b/gl4java/utils/glut/fonts/stroke.h @@ -0,0 +1,134 @@ +/* $XConsortium: wfont.h,v 5.1 91/02/16 09:46:37 rws Exp $ */ + +/***************************************************************** +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/gl4java/utils/glut/fonts/strokegen.y b/gl4java/utils/glut/fonts/strokegen.y new file mode 100644 index 0000000..83614fc --- /dev/null +++ b/gl4java/utils/glut/fonts/strokegen.y @@ -0,0 +1,658 @@ +%{ +/* $XConsortium: to_wfont.y,v 5.7 94/04/17 20:10:08 rws Exp $ */ + +/***************************************************************** + +Copyright (c) 1989,1990, 1991 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM 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. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +Copyright (c) 1989,1990, 1991 by Sun Microsystems, Inc. + + 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, +and the X Consortium, 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. + +******************************************************************/ + +/* Adapted to produce Java output by Pontus Lidman + portions copyright 2000 MathCore AB */ + +#define YYMAXDEPTH 10000 + +#include +#include +#include +#ifndef L_SET +#define L_SET SEEK_SET +#endif +#include "stroke.h" + +#ifdef X_NOT_STDC_ENV +FILE *fopen(); +#endif + +typedef struct { + + float std_left, /* NCGA standard left spacing */ + std_wide, /* character width */ + std_rght; /* Right spacing */ +} Standard; + + +char fname[80]; +char symname[80] = "FONT"; +Dispatch *Table; /* dispatch table */ +Standard *sp_table; /* NCGA font spacings */ +Path *strokes; /* strokes of each character */ +Property *property; /* property list */ + +struct { + int path, point, props; +} count, expect; + +Path_subpath *current_path; + +Font_header head; /* font header */ +int tableindex; /* which character */ +int yyerrno; /* error number */ + +%} + +%union { + int nil; /* void is reserved */ + int ival; + float dval; + char *cval; +} + +%start font + +%token REAL +%token INTEGER +%token STRING + +%token BOTTOM +%token CENTER +%token CLOSE +%token FONTNAME +%token PROPERTIES +%token NUM_CH +%token INDEX +%token L_SPACE +%token MAGIC +%token OPEN +%token RIGHT +%token R_SPACE +%token STROKE +%token TOP +%token VERTICES +%token BEARING +%token WIDTH + +%type fontname +%type properties +%type top bottom center right +%type nstroke nvertice n_pts index num_ch +%type closeflag +%type counter +%type sp_left wide sp_right + +%% + +font : fontheader num_ch fontprops fontbody spacing { fini(); }| + fontheader fontbody { fini(); }; + +fontheader : fontname top bottom + { wf_header($1, $2, $3); }; + +fontname : FONTNAME STRING + { $$ = $2; }; + +top : TOP REAL { $$ = $2;}; + +bottom : BOTTOM REAL { $$ = $2;}; + +num_ch: NUM_CH INTEGER { set_num_ch($2);}; + +fontprops : /* empty */ | properties { } ; + +properties : PROPERTIES INTEGER { init_properties ($2); } property_list + { check_num_props (); } + +property_list : /* empty */ | single_property property_list + +single_property : STRING STRING { add_property($1, $2); }; + +fontbody : /* empty */ + | glyph fontbody; + +glyph : glyph_header strokes + { check_nstroke(); }; + +glyph_header : index { tableindex = $1; } sym_headinfo; + +sym_headinfo : nstroke center right nvertice + { glyph_header($1, $2, $3, $4); }; + +index : INDEX INTEGER { check_num_ch(); $$ = $2; }; + +nstroke : STROKE INTEGER { $$ = $2; expect.path = $2; }; + +nvertice: {$$ = 0;} | VERTICES INTEGER { $$ = $2; } ; + +center : CENTER REAL{ $$ = $2; }; + +right : RIGHT REAL{ $$ = $2; }; + +strokes : /* empty */ | path strokes; + +path : closeflag n_pts { init_path($1, $2); } points + { check_npts(); } + +points : /* empty */ | coord points; + +closeflag : CLOSE { $$ = $1 == CLOSE; } | OPEN { $$ = $1 == CLOSE; } ; + +n_pts : INTEGER { $$ = $1; }; + +coord : REAL REAL { add_point($1, $2); }; + +spacing : /* empty */ + | item spacing; + +item : counter {tableindex = $1;} sp_left wide sp_right + { std_space($3, $4, $5); }; + +counter : BEARING INTEGER {$$ = $2;}; + +sp_left: L_SPACE REAL {$$ = $2;}; + +wide : WIDTH REAL {$$ = $2;}; + +sp_right: R_SPACE REAL {$$ = $2;}; + +%% + +#define BYE(err) yyerrno = (err), yyerror() + +#define ERR_BASE 1000 +#define OPEN_ERROR 1001 +#define WRITE_ERROR 1002 +#define WRONG_NAME 1003 +#define NO_MEMORY 1004 +#define EXCEED_PATH 1005 +#define EXCEED_POINT 1006 +#define PATH_MISMATCH 1007 +#define POINT_MISMATCH 1008 +#define PROP_MISMATCH 1009 +#define EXCEED_PROPS 1010 + +char *prog; + +main(argc, argv) + int argc; + char *argv[]; + +{ + /* Usage : to_wfont [-o outfile] [infile] */ + char *s; + + fname[0] = 0; + tableindex = 0; + head.num_ch = -1; + + prog = *argv; + while (--argc > 0 && *++argv != NULL) { + s = *argv; + if (*s++ == '-') + switch (*s) { + case 's': + if (*++argv != NULL) + { + --argc; + (void) strcpy(symname, *argv); + } + break; + case 'o': + if (*++argv != NULL) + { + --argc; + (void) strcpy(fname, *argv); + } + break; + default: /* ignore other options */ + ; + } + else { + FILE *fp; + + /* standard input redirection */ + fp = fopen(*argv, "r"); + if (fp != NULL) { + if (close(fileno(stdin)) < 0) + { + perror(prog); + return; + } + if (dup(fileno(fp)) < 0) + { + perror(prog); + return; + } + (void) fclose(fp); + } + } + } + return (yyparse()); +} + +/* set number of characters */ +set_num_ch(num_ch) +int num_ch; +{ + yyerrno = 0; + head.num_ch = num_ch; + if (num_ch > 0) { + Table = (Dispatch *) malloc(num_ch * sizeof(Dispatch)); + sp_table = (Standard *) malloc(num_ch * sizeof(Standard)); + strokes = (Path *) malloc(num_ch * sizeof(Path)); + } + + for (tableindex = 0; tableindex < num_ch; tableindex++) { + Table[tableindex].center = 0.0; + Table[tableindex].right = 0.0; + Table[tableindex].offset = 0; + + sp_table[tableindex].std_left = 0.0; + sp_table[tableindex].std_wide = 0.0; + sp_table[tableindex].std_rght = 0.0; + + strokes[tableindex].n_subpaths = 0; + strokes[tableindex].n_vertices = 0; + strokes[tableindex].subpaths = NULL; + } +} + +/* initialize the property info in the header */ +init_properties(num_props) + int num_props; +{ + if (num_props > 0) { + head.properties = (Property *) + malloc (num_props * sizeof (Property)); + head.num_props = expect.props = num_props; + } + else { + head.properties = NULL; + head.num_props = expect.props = 0; + } + count.props = -1; + property = head.properties; /* initialize the list pointer */ +} + +check_num_props() +{ + count.props++; + if (count.props != expect.props) + BYE (PROP_MISMATCH); +} + +/* add individual property info into the buffer */ +add_property(name, value) + char *name, + *value; +{ + /* check if the property exceeds allocated space */ + + if (++count.props >= head.num_props) + BYE(EXCEED_PROPS); + + /* copy the strings into the buffer */ + + (void) strcpy (property->propname, name); + (void) strcpy (property->propvalue, value); + + /* increment the property pointer */ + + property++; +} + +check_num_ch() +{ + + if (head.num_ch == -1) + set_num_ch(128); + +} + +yyerror() +{ +#ifndef __bsdi__ + extern int yylineno; +#endif +# define ERR_SIZE (sizeof(err_string) / sizeof(char *)) + static char *err_string[] = { + "Cannot open file", + "Write fails", + "Illegal font name", + "Memory allocation failure", + "Specified number of strokes exceeded", + "Specified number of points exceeded", + "Number of strokes do not match", + "Number of points do not match", + "Number of properties do not match", + "Specified number of properties exceeded", + 0}; + char *str; + + yyerrno -= ERR_BASE; + if (yyerrno > 0 && yyerrno < ERR_SIZE) + str = err_string[yyerrno-1]; + else + str = "Syntax error"; +#ifdef __bsdi__ + fprintf(stderr, "%s.\n", str); +#else + fprintf(stderr, "line %d: %s.\n", yylineno, str); +#endif + freeall(); + (void) unlink(fname); + exit(1); +} + +/* create wfont header */ +wf_header(name, top, bottom) + char *name; + float top, + bottom; +{ + + if (name == NULL) + BYE(WRONG_NAME); + head.top = (float) top; + head.bottom = (float) bottom; + head.magic = WFONT_MAGIC_PEX; + (void) strcpy(head.name, name); + free(name); +} + +/* create header for each glyph */ +glyph_header(npath, center, right, npts) + int npath, + npts; + float center, + right; +{ + { + register Path *strk = strokes + tableindex; + + if (npath > 0) /* Don't allocate space unless the character + has strokes associated with it. */ + { + strk->subpaths = (Path_subpath *) + malloc(npath * sizeof (Path_subpath)); + + if (strk->subpaths == NULL) + BYE(NO_MEMORY); + + strk->type = PATH_2DF; + strk->n_subpaths = npath; + strk->n_vertices = npts; + } + else { /* Just initialize the entry */ + strk->subpaths = NULL; + strk->type = PATH_2DF; + strk->n_subpaths = 0; + strk->n_vertices = 0; + } + } + { + register Dispatch *tbl = Table + tableindex; + + tbl->offset = 0; + tbl->center = center; + tbl->right = right; + } + count.path = -1; /* initialize path counter, not to + * exceed n_subpath */ +} + +/* create standard spacing info for each glyph */ +std_space(l_bear, wide, r_bear) + + float l_bear, + wide, + r_bear; +{ + register Standard *tbl = sp_table +tableindex; + tbl->std_left = l_bear; + tbl->std_wide = wide; + tbl->std_rght = r_bear; +} + +/* initialize each sub_path */ +init_path(close, n) + int close, + n; +{ + register Path_subpath *path; + + if (++count.path >= strokes[tableindex].n_subpaths) + BYE(EXCEED_PATH); + path = current_path = strokes[tableindex].subpaths + count.path; + path->n_pts = n; + path->closed = close; + if (n > 0) + path->pts.pt2df = (Path_point2df *) + malloc(n * sizeof (Path_point2df)); + if (path->pts.pt2df == NULL) + BYE(NO_MEMORY); + expect.point = path->n_pts; + count.point = -1; /* initialize point counter, not to + * exceed n_pts */ +} + +/* accumulating points for each sub_path */ +add_point(x, y) + float x, + y; +{ + register Path_subpath *path; + register Path_point2df *pt_ptr; + + path = current_path; + if (++count.point >= path->n_pts) + BYE(EXCEED_POINT); + pt_ptr = path->pts.pt2df + count.point; + pt_ptr->x = x; + pt_ptr->y = y; +} + +/* Path_type + n_subpaths + n_vertices */ +#define STROKE_HEAD (sizeof (Path_type) + sizeof (int) + sizeof (int)) + +/* write out file, close everything, free everything */ +fini() +{ + static long zero = 0; + + /* pointers used to walk the arrays */ + register Path_subpath *spath; + register Dispatch *tbl_ptr; + register Path *strptr; + register Property *prop_ptr; + + FILE *fp; + int npath; + register int i, + j, + k; + Standard *sp_ptr; + Path_point2df *pt; + + printf("\n/* GENERATED FILE -- DO NOT MODIFY */\n\n"); +/* printf("#include \"glutstroke.h\"\n\n"); */ + + printf("package gl4java.utils.glut.fonts.data;\n\n"); + printf("import gl4java.utils.glut.fonts.*;\n\n"); + printf("public class %s implements GLUTStrokeFont {\n",symname); + +# define BY_BYE(err) fclose(fp), BYE(err) + + /* adjust the characters for spacing, note max char width */ + head.max_width = 0.0; + for (i = 0, tbl_ptr = Table, strptr = strokes, sp_ptr = sp_table; + i < head.num_ch; i++, tbl_ptr++, strptr++, sp_ptr++) { + tbl_ptr->center += sp_ptr->std_left; + tbl_ptr->right += sp_ptr->std_left + sp_ptr->std_rght; + if (tbl_ptr->right > head.max_width) + head.max_width = tbl_ptr->right; + npath = strptr->n_subpaths; + if (npath > 0 || tbl_ptr->center != 0.0 || + tbl_ptr->right != 0.0) { + for (j = 0, spath = strptr->subpaths; + j < npath; j++, spath++) { + for(k=0, pt = spath->pts.pt2df; + kn_pts; k++, pt++) { + pt->x += sp_ptr->std_left; + } + } + } + } + + /* write the stroke table */ + for (i = 0, tbl_ptr = Table, strptr = strokes; + i < head.num_ch; i++, tbl_ptr++, strptr++) { + if (strptr->n_subpaths > 0 && + tbl_ptr->center != 0.0 && + tbl_ptr->right != 0.0) { + if(isprint(i)) { + printf("/* char: %d '%c' */\n\n", i, i); + } else { + printf("/* char: %d */\n\n", i); + } + + for (j = 0, spath = strptr->subpaths; + j < strptr->n_subpaths; j++, spath++) { + int z; + + printf("static final CoordRec[] char%d_stroke%d = {\n", i, j); + for(z = 0; z < spath->n_pts; z++) { + printf(" new CoordRec( (float) %g, (float) %g ),\n", + spath->pts.pt2df[z].x, spath->pts.pt2df[z].y); + } + printf("};\n\n"); + } + + printf("static final StrokeRec char%d[] = {\n", i); + for (j = 0, spath = strptr->subpaths; + j < strptr->n_subpaths; j++, spath++) { + printf(" new StrokeRec(%d, char%d_stroke%d),\n", + spath->n_pts, i, j); + } + printf("};\n\n"); + } + } + printf("static final StrokeCharRec chars[] = {\n"); + for (i = 0, tbl_ptr = Table, strptr = strokes; + i < head.num_ch; i++, tbl_ptr++, strptr++) { + if (strptr->n_subpaths > 0 && + tbl_ptr->center != 0.0 && + tbl_ptr->right != 0.0) { + printf(" new StrokeCharRec( %d, char%d, (float)%g, (float)%g ),\n", + strptr->n_subpaths, i, tbl_ptr->center, tbl_ptr->right); + } else { + printf(" new StrokeCharRec( 0, /* char%d */ null, (float)%g, (float)%g ),\n", + i, tbl_ptr->center, tbl_ptr->right); + } + } + printf("};\n\n"); + + printf("final static StrokeFontRec fontinfo = new StrokeFontRec( \"%s\", %d, chars, (float)%.6g, (float)%.6g );\n\n", + head.name, head.num_ch, + (double) head.top, (double) head.bottom); + printf(" static public StrokeFontRec getStrokeFontRec() {\n"); + printf(" return fontinfo;\n"); + printf(" }\n"); + printf("}\n"); // end of class + fflush(stdout); + + freeall(); +# undef BY_BYE +} + +freeall() +{ + register Path *path; + register Path_subpath *spath; + register int i, + j, + n; + + path = strokes; + for (i = 0; i < head.num_ch; i++, path++) { + n = path->n_subpaths; + if (n <= 0) + continue; + spath = path->subpaths; + for (j = 0; j < n; j++, spath++) + if (spath->pts.pt2df != NULL) + free((char *) spath->pts.pt2df); + if (path->subpaths != NULL) + free((char *) path->subpaths); + } + free(Table); + free(sp_table); + free(strokes); + if (head.properties != NULL) + free((char *) head.properties); +} + +check_nstroke() +{ + count.path++; + if (expect.path != count.path) + BYE(PATH_MISMATCH); +} + +check_npts() +{ + count.point++; + if (expect.point != count.point) + BYE(POINT_MISMATCH); +} diff --git a/gl4java/utils/glut/fonts/strokelex.l b/gl4java/utils/glut/fonts/strokelex.l new file mode 100644 index 0000000..bfde066 --- /dev/null +++ b/gl4java/utils/glut/fonts/strokelex.l @@ -0,0 +1,134 @@ +%option noyywrap + +%{ +/* $XConsortium: lex.l,v 5.4 91/08/26 10:55:26 gildea Exp $ */ + +/***************************************************************** +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. + +******************************************************************/ + + +#include +#include +#include +#include "strokegen.h" + +#if defined(ISC) && defined(SYSV) && defined(SYSV386) && __STDC__ +extern double atof(char *); +#endif + +#ifdef FLEX_SCANNER +int yylineno; +#endif + +%} +%% +\'[^']*\' | +\"[^"]*\" return string(yytext, yyleng); +#.* ; +[ ,;\t\n]* /* natural dilimters */ ; + +[a-zA-Z][a-zA-Z0-9_.]* { + int token; + if (token = res_words(yytext)) + return token; + return string(yytext, yyleng); + } + +[+-]?[0-9]+\.?[0-9]*[eE][+-]?[0-9]+ | +[+-]?[0-9]+\.[0-9]* | +\.[0-9]+ { + yylval.dval = atof(yytext); + return REAL; + } +[+-]?[0-9]+#[0-9]+ { + return INTEGER; + } +[+-]?[0-9]+ { + yylval.ival = atoi(yytext); + return INTEGER; + } +[()] ; +[\r] ; +%% + +int +res_words(str) +char str[]; +{ + static struct res_strct { + char *word; + int token; + } res_table[] = { + {"BOTTOM", BOTTOM}, + {"CENTER", CENTER}, + {"PROPERTIES", PROPERTIES}, + {"CLOSE", CLOSE}, + {"FONTNAME", FONTNAME}, + {"INDEX", INDEX}, + {"MAGIC", MAGIC}, + {"OPEN", OPEN}, + {"RIGHT", RIGHT}, + {"STROKE", STROKE}, + {"TOP", TOP}, + {"VERTICES", VERTICES}, + {"BEARING", BEARING}, + {"L_SPACE", L_SPACE}, + {"WIDTH", WIDTH}, + {"R_SPACE", R_SPACE}, + {"NUM_CH", NUM_CH}, + {0, 0} + }; + + { + register struct res_strct *reserved; + + reserved = res_table; + + do + if (!strcmp(str, reserved->word)) + break; + while ((++reserved)->word != 0); + return reserved->token; + } +} + +int +string(str, n) +char *str; +int n; +{ + if (*str == '\"' || *str == '\'') + { + str++; + n -= 2; /* one for EOL, one for end quote */ + } + if ((yylval.cval = (char *)malloc(n+1)) != NULL) + { + strncpy(yylval.cval, str, n); + yylval.cval[n] = '\0'; + return STRING; + } + else + return 0; +} diff --git a/gl4java/utils/textures/AWTTextureLoader.java b/gl4java/utils/textures/AWTTextureLoader.java new file mode 100644 index 0000000..2df3145 --- /dev/null +++ b/gl4java/utils/textures/AWTTextureLoader.java @@ -0,0 +1,169 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +// import java.awt.Color.*; +// import java.awt.color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This Class implements the universal + * texture-loader using the AWT's standard interface ! + * + * The number of image-types depends + * on the JDK version you use ! + * + * @see TextureLoader + */ +public class AWTTextureLoader +extends TextureLoader +{ + Component comp; + + public AWTTextureLoader(Component comp, GLFunc gl, GLUFunc glu) + { + super(gl, glu); + this.comp=comp; + } + + public boolean readTexture(String fname) + { + Image img = comp.getToolkit().getImage(fname); + return readTexture(comp, img); + } + + public boolean readTexture(URL base, String uri) + { + try { + URL url = new URL (base, uri); + Image img = comp.getToolkit().getImage(url); + return readTexture(comp, img); + } catch (Exception ex) { + System.out.println("AWTTextureLoader.readTexture <"+ + base+" / "+uri+"> failed !\n"+ex); + } + return false; + } + + private boolean readTexture(Component comp, Image img) + { + try { + try { + MediaTracker tracker = new MediaTracker(comp); + tracker.addImage(img, 0); + tracker.waitForID(0); + } + catch ( Exception e ) {} + + imageWidth = img.getWidth(comp); + imageHeight = img.getHeight(comp); + /* This is Java2 only code :-( + BufferedImage image = + new BufferedImage(imageWidth, imageHeight, + BufferedImage.TYPE_INT_RGB); + + Graphics g = image.createGraphics(); + g.drawImage(img,0,0,comp); + + imageWidth = image.getWidth(); + imageHeight = image.getHeight(); + */ + + // Read entire PNG image (doesn't throw exceptions) + int[] iPixels = new int[imageWidth * imageHeight]; + + PixelGrabber pp=new PixelGrabber(img, + 0,0, + imageWidth, imageHeight, + iPixels, + 0, + imageWidth); + try + { + pp.grabPixels(); + } + catch (InterruptedException e) + { + System.err.println("interrupted waiting for pixel!"); + error=true; + return false; + } + if ((pp.getStatus() & ImageObserver.ABORT) != 0) + { + System.err.println("image fetch aborted or errored"); + error=true; + return false; + } + + /* This is Java2 only code :-( + int imagetype = image.getType(); + switch(imagetype) + { + case BufferedImage.TYPE_INT_RGB: + glFormat=GL_RGB; + break; + case BufferedImage.TYPE_INT_ARGB: + case BufferedImage.TYPE_INT_ARGB_PRE: + glFormat=GL_RGBA; + break; + default: + error=true; + System.err.println("unsupported format: "+imagetype); + return false; + }; + */ + // + // we are guessing the RGB type, + // because fetching the true type + // is Java2 only code :-( + // + glFormat=GL_RGB; + + setTextureSize(); + pixel=new byte[imageWidth * imageHeight * getComponents()]; + + int offset=0; + int aPixel; + int y_desc; + for(y_desc=imageHeight-1; y_desc>=0; y_desc--) + { + for(int x=0;x> 16) & 0xff ).byteValue(); + + // green + pixel[offset++]= + new Integer( (aPixel >> 8) & 0xff ).byteValue(); + + // blue + pixel[offset++]= + new Integer( (aPixel ) & 0xff ).byteValue(); + + // alpha + if(glFormat==GL_RGBA) + pixel[offset++]= + new Integer( (aPixel >> 24) & 0xff ).byteValue(); + } + } + + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a AWTTexture"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/IOTextureLoader.java b/gl4java/utils/textures/IOTextureLoader.java new file mode 100644 index 0000000..4b06b93 --- /dev/null +++ b/gl4java/utils/textures/IOTextureLoader.java @@ -0,0 +1,67 @@ +package gl4java.utils.textures; + +import gl4java.*; +import gl4java.utils.glut.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This abstract Class implements the + * file and url based methods "readTexture", + * to call the specialised implementation + * of the stream based "readTexture" method ! + * + * @see TextureLoader + */ +public abstract class IOTextureLoader +extends TextureLoader +{ + protected IOTextureLoader(GLFunc gl, GLUFunc glu) + { super(gl, glu); } + + public boolean readTexture(String fname) + { + boolean result = false; + InputStream is= null; + try { + is= new java.io.FileInputStream(fname); + result = readTexture(is); + } catch (Exception ex) { + System.out.println("IOTextureLoader.readTexture <"+ + fname+"> failed !\n"+ex); + } + try { + if(is!=null) is.close(); + } catch (Exception ex) {} + return result; + } + + public boolean readTexture(URL base, String uri) + { + boolean result = false; + InputStream is= null; + try { + URL url = new URL (base, uri); + URLConnection urlcon = url.openConnection(); + urlcon.setDoOutput(false); + urlcon.setDoInput(true); + is = urlcon.getInputStream(); + result = readTexture(is); + } catch (Exception ex) { + System.out.println("IOTextureLoader.readTexture <"+ + base+" / "+uri+"> failed !\n"+ex); + } + try { + if(is!=null) is.close(); + } catch (Exception ex) {} + return result; + } + + protected abstract boolean readTexture(InputStream is); +} + diff --git a/gl4java/utils/textures/PPMAsciiTextureLoader.java b/gl4java/utils/textures/PPMAsciiTextureLoader.java new file mode 100644 index 0000000..b8d1610 --- /dev/null +++ b/gl4java/utils/textures/PPMAsciiTextureLoader.java @@ -0,0 +1,88 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This is Class implements the PPM-Ascii + * texture-loader ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class PPMAsciiTextureLoader +extends IOTextureLoader +{ + public PPMAsciiTextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + protected boolean readTexture(InputStream is) + { + try { + glFormat=GL_RGB; + + DataInputStream reader = new DataInputStream ( is ); + + String lin=reader.readLine(); //P6 + String subLin=lin.substring(0,1); + + lin=reader.readLine(); + subLin=lin.substring(0,1); + + while (subLin.compareTo("#")==0) + { + lin=reader.readLine(); + subLin=lin.substring(0,1); + } + + char[] dim=lin.toCharArray(); + + int i=0; + char car=lin.charAt(i); + String blanco=new String(" "); + Character C=new Character(car); + car=C.charValue(); + while (C.isDigit(car)) + { + i++; + car=lin.charAt(i); + C=new Character(car); + } + + String alto=lin.substring(0,i); + String ancho=lin.substring(i+1,lin.length()); + + Integer hh=new Integer(alto); + imageWidth=hh.intValue(); + hh=new Integer(ancho); + imageHeight=hh.intValue(); + + pixel=new byte[imageWidth * imageHeight * getComponents()]; + + lin=reader.readLine(); //255 + + reader.read(pixel, 0, pixel.length); + + reader.close(); + setTextureSize(); + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a PPMAsciiTextureLoader"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/PngTextureLoader.java b/gl4java/utils/textures/PngTextureLoader.java new file mode 100644 index 0000000..6cc9bb2 --- /dev/null +++ b/gl4java/utils/textures/PngTextureLoader.java @@ -0,0 +1,160 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.image.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +import com.sixlegs.image.png.*; + +/** + * This is Class implements the PNG texture-loader + * while using the png-library in package + * "com.sixlegs.image.png" ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class PngTextureLoader +extends IOTextureLoader +{ + protected boolean grayToAlpha = false; + + public PngTextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + /** + * Set to 'true' to load grayscale images as alpha images + * (in other words, GL_ALPHA instead of GL_LUMINANCE) + */ + public void setGrayToAlpha(boolean b) + { + this.grayToAlpha = b; + } + + protected boolean readTexture(InputStream is) + { + try { + int len; + PngImage png = new PngImage(is); + + imageWidth = png.getWidth(); + imageHeight = png.getHeight(); + + // Read entire PNG image (doesn't throw exceptions) + int[] iPixels = new int[imageWidth * imageHeight]; + + PixelGrabber pp=new PixelGrabber(png, + 0,0, + imageWidth, imageHeight, + iPixels, + 0, + imageWidth); + try + { + pp.grabPixels(); + } + catch (InterruptedException e) + { + System.err.println("interrupted waiting for pixel!"); + error=true; + return false; + } + if ((pp.getStatus() & ImageObserver.ABORT) != 0) + { + System.err.println("image fetch aborted or errored"); + error=true; + return false; + } + + // bitDepth beachten + switch(png.getColorType()) + { + case PngImage.COLOR_TYPE_GRAY: + glFormat= grayToAlpha ? GL_ALPHA : GL_LUMINANCE; + break; + case PngImage.COLOR_TYPE_GRAY_ALPHA: + glFormat=GL_LUMINANCE_ALPHA; + break; + case PngImage.COLOR_TYPE_RGB: + glFormat=GL_RGB; + break; + case PngImage.COLOR_TYPE_RGB_ALPHA: + glFormat=GL_RGBA; + break; + case PngImage.COLOR_TYPE_PALETTE: + // todo: support COLOR_TYPE_INDEXED? + glFormat=GL_RGB; + break; + default: + error=true; + System.err.println("unsupported png color type: "+ + png.getColorType()); + return false; + }; + + int ncmpts = getComponents(); + pixel=new byte[imageWidth * imageHeight * ncmpts]; + + byte alpha=0; + byte red=0; + byte green=0; + byte blue=0; + int offset=0; + int aPixel; + for(int y=imageHeight-1; y>=0; y--) + { + for(int x=0;x>16); + pixel[offset+1] = (byte)(aPixel>>8); + pixel[offset+2] = (byte)(aPixel>>0); + pixel[offset+3] = (byte)(aPixel>>24); + offset += 4; + break; + case GL_RGB: + pixel[offset] = (byte)(aPixel>>16); + pixel[offset+1] = (byte)(aPixel>>8); + pixel[offset+2] = (byte)(aPixel>>0); + offset += 3; + break; + case GL_LUMINANCE: + case GL_COLOR_INDEX: + pixel[offset] = (byte)(aPixel); + offset += 1; + break; + case GL_LUMINANCE_ALPHA: // todo: untested + pixel[offset] = (byte)(aPixel); + pixel[offset+1] = (byte)(aPixel>>24); + offset += 2; + break; + } + + } + } + + setTextureSize(); + return true; + + } catch (Exception e) { + System.out.println("An exception occured, while loading a PngTexture"); + System.out.println(e); + error=true; + } + return false; + } + +} + diff --git a/gl4java/utils/textures/TGATextureGrabber.java b/gl4java/utils/textures/TGATextureGrabber.java new file mode 100644 index 0000000..2d1c432 --- /dev/null +++ b/gl4java/utils/textures/TGATextureGrabber.java @@ -0,0 +1,61 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.io.*; +import java.net.*; + +public class TGATextureGrabber +extends TextureGrabber +{ + public TGATextureGrabber(GLFunc gl) + { + super(gl); + } + + public boolean write2File(OutputStream os) + { + try { + DataOutputStream fout= new DataOutputStream(os); + + //write TGA header + fout.writeByte(0); //ID length, 0 because no image id field + fout.writeByte(0); //no color map + fout.writeByte(2); //image type (24 bit RGB, uncompressed) + fout.writeShort(0); //color map origin, ignore because no color map + fout.writeShort(0); //color map length, ignore because no color map + fout.writeByte(0); //color map entry size, ignore because no color map + fout.writeShort(0); //x origin + fout.writeShort(0); //y origin + short s = (short)width; + fout.writeByte((byte)(s & 0x00ff)); //image width low byte + fout.writeByte((byte)((s & 0xff00)>>8)); //image width high byte + s = (short)height; + fout.writeByte((byte)(s & 0x00ff)); //image height low byte + fout.writeByte((byte)((s & 0xff00)>>8)); //image height high byte + fout.writeByte(24); //bpp + fout.writeByte(0); //description bits + + //process image data: + // TGA pixels should be written in BGR format, + // so R en B should be switched + byte tmp; + for (int i=0; i<(width*height*3); i+=3) { + tmp=pixels[i]; + pixels[i]=pixels[i+2]; + pixels[i+2]=tmp; + } + + //write TGA image data + fout.write(pixels, 0, pixels.length); + + fout.flush(); + fout.close(); + } catch (Exception ex) { + System.out.println("TGATextureGrabber.write2File failed !\n"+ex); + return false; + } + return true; + } +} + diff --git a/gl4java/utils/textures/TGATextureLoader.java b/gl4java/utils/textures/TGATextureLoader.java new file mode 100644 index 0000000..b0c915f --- /dev/null +++ b/gl4java/utils/textures/TGATextureLoader.java @@ -0,0 +1,111 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.io.*; +import java.net.*; + +/** + * This is Class implements a TGA texture-loader ! + * At this time, this loader only supports + * loading files, which are saved with + * the TGATextureGrabber ! + * This means: 24 bpp, RGB, uncompressed, no-colormap, + * no image id-field ! + * + * @see IOTextureLoader + * @see TextureLoader + */ +public class TGATextureLoader +extends IOTextureLoader +{ + public TGATextureLoader(GLFunc gl, GLUFunc glu) + { + super(gl, glu); + } + + protected boolean readTexture(InputStream is) + { + try { + int cc; + + glFormat=GL_RGB; + + DataInputStream reader = new DataInputStream ( is ); + + //write TGA header + reader.readByte(); //ID length, 0 because no image id field + reader.readByte(); //no color map + cc = reader.readByte(); //image type (24 bit RGB, uncompressed) + if(cc!=2) + { + reader.close(); + System.out.println("TGATextureLoader: File is not 24bit RGB Data !"); + error=true; + return false; + } + reader.readShort(); //color map origin, ignore because no color map + reader.readShort(); //color map length, ignore because no color map + reader.readByte(); //color map entry size, ignore because no color map + reader.readShort(); //x origin + reader.readShort(); //y origin + + cc = reader.readByte(); // image width low byte + short s = (short)((short)cc & 0x00ff); + cc = reader.readByte(); // image width high byte + s = (short) ( (short)( ((short)cc & 0x00ff)<<8 ) | s ); + imageWidth = (int)s; + + cc = reader.readByte(); // image height low byte + s = (short)((short)cc & 0x00ff); + cc = reader.readByte(); // image height high byte + s = (short) ( (short)( ((short)cc & 0x00ff)<<8 ) | s ); + imageHeight = (int)s; + + cc=reader.readByte(); // 24bpp + if(cc!=24) + { + reader.close(); + System.out.println("TGATextureLoader: File is not 24bpp Data !"); + error=true; + return false; + } + reader.readByte(); //description bits + + if(3!=getComponents()) + { + reader.close(); + System.out.println("TGATextureLoader: Currenly only RGB (24bit) data is supported !"); + error=true; + return false; + } + + pixel=new byte[imageWidth * imageHeight * 3]; + + //read TGA image data + reader.read(pixel, 0, pixel.length); + + //process image data: + // TGA pixels should be written in BGR format, + // so R en B should be switched + byte tmp; + for (int i=0; i failed !\n"+ex); + } + return false; + } + + public boolean write2File(URL base, String uri) + { + try { + URL url = new URL (base, uri); + URLConnection urlcon = url.openConnection(); + urlcon.setDoOutput(true); + OutputStream os = urlcon.getOutputStream(); + return write2File(os); + } catch (Exception ex) { + System.out.println("TGATextureGrabber.write2File <"+ + base+" / "+uri+"> failed !\n"+ex); + } + return false; + } + + public abstract boolean write2File(OutputStream os); +} + diff --git a/gl4java/utils/textures/TextureLoader.java b/gl4java/utils/textures/TextureLoader.java new file mode 100644 index 0000000..36a8cfe --- /dev/null +++ b/gl4java/utils/textures/TextureLoader.java @@ -0,0 +1,41 @@ +package gl4java.utils.textures; + +import gl4java.*; +import gl4java.utils.glut.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This abstract Class defines the interface + * for ALL texture loaders ! + * + * @see TextureTool + * @see GLImageCanvas + */ +public abstract class TextureLoader +extends TextureTool +{ + protected TextureLoader(GLFunc gl, GLUFunc glu) + { super(gl, glu); } + + /** + * Loads an Texture + * + * @param fname The filename + */ + public abstract boolean readTexture(String fname); + + /** + * Loads an Texture + * + * @param base The base URL + * @param uri The additional uri for the base URL + */ + public abstract boolean readTexture(URL base, String uri); +} + diff --git a/gl4java/utils/textures/TextureTool.java b/gl4java/utils/textures/TextureTool.java new file mode 100755 index 0000000..a842d1f --- /dev/null +++ b/gl4java/utils/textures/TextureTool.java @@ -0,0 +1,610 @@ +package gl4java.utils.textures; + +import gl4java.*; + +import java.awt.*; +import java.awt.Color.*; +import java.awt.event.*; +import java.applet.*; +import java.io.*; +import java.net.*; + +/** + * This Class implements basic functions, + * which are used by all TextureLoader implementations ! + * + * @see TextureLoader + */ +public abstract class TextureTool +implements GLEnum, GLUEnum +{ + protected GLFunc gl; + protected GLUFunc glu; + + /** + * just a default type ... + */ + protected byte[] pixel; + protected boolean pixelScaled; + + protected int imageWidth; + protected int imageHeight; + protected int textWidth; + protected int textHeight; + + protected int glFormat; + protected boolean error; + + public String toString() + { + return "Texture "+textWidth+"x"+textHeight+ + "[image "+imageWidth+"x"+imageHeight+ + "[bpc "+getComponents()+"]"+ + "]"; + } + + protected TextureTool(GLFunc gl, GLUFunc glu) + { + this.gl=gl; + this.glu=glu; + error=false; + pixelScaled = false; + } + + public final boolean isOk() { return !error; } + + public final int getGLFormat() { return glFormat; } + public int getGLBytesPerComponent() { return 1; } + public int getGLComponentFormat() { return GL_UNSIGNED_BYTE; } + + /** + * just a default for byte sized component's + */ + public int getComponents() + { + switch (glFormat) + { + case GL_RGBA: + return 4; + case GL_RGB: + return 3; + case GL_LUMINANCE_ALPHA: + return 2; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_COLOR_INDEX: + return 1; + default: + return 0; + } + } + + /** + * Dimension + */ + public final int getImageWidth() { return imageWidth; } + public final int getImageHeight() { return imageHeight; } + + public final int getTextureWidth() { return textWidth; } + public final int getTextureHeight() { return textHeight; } + + + public static final int getMaxTextureSize(GLFunc gl) + { + int[] maxSize=new int[1]; + gl.glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxSize); + return maxSize[0]; + } + + /** + * This method is called directly after loading + * the texture ! + * You normally do not need to call this method ! + * + * The textWidth/textHeight data is set correctly + * to a power of 2 ! + */ + public void setTextureSize() + { + int e_x, e_y, i; + + /* achieve the 2**e_x>=imageWidth, 2**e_y>=imageHeight */ + e_x=0; textWidth=1; + + while (textWidth "+w+"/"+h); + System.out.println("scale4Best: aspect (w/h) "+ + iaspect+" -> "+(double)w/(double)h); + */ + + /* Save current modes. */ + gl.glGetIntegerv(GL_PACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_PACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_PACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_PACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_PACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL_PACK_ALIGNMENT, alignment); + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, unswapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, unlsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, unrowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, unskiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, unskippixels); + gl.glGetIntegerv(GL_UNPACK_ALIGNMENT, unalignment); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_PACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, textWidth); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, imageWidth); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + if( glu.gluScaleImage(glFormat, + imageWidth, imageHeight, + GL_UNSIGNED_BYTE, + pixel, + w, h, + GL_UNSIGNED_BYTE, + buffer)!=0 ) + { + // glu failure + error=true; + } else { + pixel = buffer; + imageWidth=w; + imageHeight=h; + } + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_PACK_ALIGNMENT, alignment[0]); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment[0]); + } + if(!error) + pixelScaled = true; + return pixelScaled; + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method calls scaleTexture2Pow2() to + * make the image of the normal texture size := pow2 ! + * Then glTexImage2D is called with the texture properties ! + * + * The Ascpect-Ratio is dropped ! + * + * @see TextureTool#scaleTexture2Pow2 + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glPixelStorei + */ + public boolean texImage2DScaled2Pow2() + { + // The Scaled Way + if(!scaleTexture2Pow2()) + return false; + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + getTexture()); // The Scaled Way + + return glutReportErrors(); + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method calls scaleTexture4BestSize() to + * make the image of the best fitting size + * relative to the texture-size! + * Then glTexImage2D is called with the texture properties ! + * + * The Ascpect-Ratio is not changed ! + * + * A fine example exists in "demos/MiscDemos/GLImageViewerWorld" ! + * + * @see TextureTool#scaleTexture4BestSize + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glPixelStorei + */ + public boolean texImage2DScaled4BestSize() + { + // The Scaled Way + if(!scaleTexture4BestSize()) + return false; + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + getTexture()); // The Scaled Way + + return glutReportErrors(); + } + + /** + * This method loads the image into + * the current bind GL_TEXTURE_2D texture ! + * + * Be sure to have the GL-Context being current ! + * + * Be sure to have the GL_TEXTURE_2D bind to + * a textureName ! + * + * This method creates a target texture (glTexImage2D) + * without data, + * and substitutes only the unscaled image data (glTexSubImage2D) ! + * + * The benefits of this functions is, + * that the image/texture is not scaled ! + * A fine example exists in "demos/MiscDemos/GLImageViewerCanvas" ! + * + * The pixel store mode GL_UNPACK_ALIGNMENT, + * is set temporary to byte alignment, then back to default (4) ! + * + * The pixel store mode GL_UNPACK_ROW_LENGTH, + * is set temporary to imageWidth, then back to default (0) ! + * + * @param clear if true, the texture will be initially loaded with + * a dummy blank (black) array + * + * @see GLFunc#glGenTextures + * @see GLFunc#glBindTexture + * @see GLFunc#glTexImage2D + * @see GLFunc#glTexSubImage2D + * @see GLFunc#glPixelStorei + * @see GLImageCanvas + */ + public boolean texImage2DNonScaled(boolean clear) + { + int swapbytes[]={0}, lsbfirst[]={0}, rowlength[]={0}; + int skiprows[]={0}, skippixels[]={0}, alignment[]={0}; + int unswapbytes[]={0}, unlsbfirst[]={0}, unrowlength[]={0}; + int unskiprows[]={0}, unskippixels[]={0}, unalignment[]={0}; + + /* Save current modes. */ + gl.glGetIntegerv(GL_PACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL_PACK_LSB_FIRST, lsbfirst); + gl.glGetIntegerv(GL_PACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL_PACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL_PACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL_PACK_ALIGNMENT, alignment); + gl.glGetIntegerv(GL_UNPACK_SWAP_BYTES, unswapbytes); + gl.glGetIntegerv(GL_UNPACK_LSB_FIRST, unlsbfirst); + gl.glGetIntegerv(GL_UNPACK_ROW_LENGTH, unrowlength); + gl.glGetIntegerv(GL_UNPACK_SKIP_ROWS, unskiprows); + gl.glGetIntegerv(GL_UNPACK_SKIP_PIXELS, unskippixels); + gl.glGetIntegerv(GL_UNPACK_ALIGNMENT, unalignment); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_PACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, 0); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, 1); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, imageWidth); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + byte[] clrPixel = null; + + if(clear) + { + clrPixel= + new byte[textWidth * textHeight * getComponents()]; + } + + gl.glTexImage2D(GL_TEXTURE_2D, + 0, + getComponents(), + getTextureWidth(), + getTextureHeight(), + 0, + getGLFormat(), + getGLComponentFormat(), + clrPixel); + + // The unscaled way + /* + System.out.println("******* width "+getImageWidth()); + System.out.println("******* height "+getImageHeight()); + System.out.println("******* format "+getGLFormat()); + System.out.println("******* comps "+getGLComponentFormat()); + System.out.println("******* text "+getTexture()); + System.out.println("******* text.length "+getTexture().length); + */ + + gl.glTexSubImage2D(GL_TEXTURE_2D, + 0, + 0, 0, + getImageWidth(), + getImageHeight(), + getGLFormat(), + getGLComponentFormat(), + getTexture()); + + // System.out.println("+++++++++"); + + gl.glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL_PACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL_PACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL_PACK_ALIGNMENT, alignment[0]); + gl.glPixelStorei(GL_UNPACK_SWAP_BYTES, unswapbytes[0]); + gl.glPixelStorei(GL_UNPACK_LSB_FIRST, unlsbfirst[0]); + gl.glPixelStorei(GL_UNPACK_ROW_LENGTH, unrowlength[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_ROWS, unskiprows[0]); + gl.glPixelStorei(GL_UNPACK_SKIP_PIXELS, unskippixels[0]); + gl.glPixelStorei(GL_UNPACK_ALIGNMENT, unalignment[0]); + return glutReportErrors(); + } + + protected final boolean glutReportErrors() + { + int error; + + while ((error = gl.glGetError()) != GL_NO_ERROR) + __glutWarning("GL error: "+glu.gluErrorString(error)); + return error==GL_NO_ERROR; + } + + protected static final void __glutWarning(String str) + { + System.out.println("GLUT: Warning in (unamed): "+str+"\n"); + } +} + -- cgit v1.2.3