PHP_ARG_WITH(gd, for GD support,
[ --with-gd[=DIR] Include GD support (DIR is GD's install dir).])
-if test "$PHP_GD" != "no"; then
+if test "$PHP_GD" == "php"; then
+ GD_MODULE_TYPE=builtin
+ sources="libgd/gd.c libgd/gd_gd.c libgd/gd_gd2.c libgd/gd_io.c libgd/gd_io_dp.c \
+ libgd/gd_io_file.c libgd/gd_ss.c libgd/gd_io_ss.c libgd/gd_png.c libgd/gd_jpeg.c \
+ libgd/gdxpm.c libgd/gdfontt.c libgd/gdfonts.c libgd/gdfontmb.c libgd/gdfontl.c \
+ libgd/gdfontg.o libgd/gdtables.c libgd/gdft.c libgd/gdcache.c libgd/gdkanji.c \
+ libgd/wbmp.c libgd/gd_wbmp.c libgd/gdhelpers.c libgd/gd_topal.c"
+ PHP_NEW_EXTENSION(mysql, gd.c gdcache.c gdttf.c gdt1.c $sources, $ext_shared,,-I@ext_srcdir@/libgd)
+ PHP_ADD_BUILD_DIR($ext_builddir/libgd)
+else
+ if test "$PHP_GD" != "no"; then
PHP_NEW_EXTENSION(gd, gd.c gdcache.c gdttf.c gdt1.c, $ext_shared)
PHP_SUBST(GD_SHARED_LIBADD)
PHP_EXPAND_PATH($GD_INCLUDE, GD_INCLUDE)
PHP_ADD_INCLUDE($GD_INCLUDE)
+ fi
fi
--- /dev/null
+This directory contains the GD library available from
+http://www.boutell.com/gd/
+
+The inclusion of this library with PHP is in response to the
+popularity of the GD extension and the GD library itself. We felt
+it would be worthwhile to make sure everyone had access to the
+features of GD and by bundling GD with PHP we have a known target to
+work against.
+
+In addition to the above, a number of motivated PHP hackers have
+expressed an interest in extending the functionality of the PHP-GD
+combination. By putting a version of GD into PHP CVS we have provided
+a sandbox for them to throw sand at each other in. Any and all
+improvements we make to the GD library will be contributed back to the
+original maintainers of this library at boutell.com.
+
+The following statement is from the original GD package:
+
+ Credits and license terms
+
+ In order to resolve any possible confusion regarding the authorship of
+ gd, the following copyright statement covers all of the authors who
+ have required such a statement. _If you are aware of any oversights in
+ this copyright notice, please contact Thomas Boutell who will be
+ pleased to correct them._
+
+COPYRIGHT STATEMENT FOLLOWS THIS LINE
+
+ Portions copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+ by Cold Spring Harbor Laboratory. Funded under Grant P41-RR02188 by
+ the National Institutes of Health.
+
+ Portions copyright 1996, 1997, 1998, 1999, 2000, 2001 by
+ Boutell.Com, Inc.
+
+ Portions relating to GD2 format copyright 1999, 2000 Philip Warner.
+
+ Portions relating to PNG copyright 1999, 2000 Greg Roelofs.
+
+ Portions relating to libttf copyright 1999, 2000 John Ellson
+ (ellson@lucent.com).
+
+ Portions relating to JPEG and to color quantization copyright 2000,
+ Doug Becker and copyright (C) 1994-1998, Thomas G. Lane. This
+ software is based in part on the work of the Independent JPEG
+ Group. See the file README-JPEG.TXT for more information.
+
+ Portions relating to WBMP copyright 2000 Maurice Szmurlo and Johan
+ Van den Brande.
+
+ _Permission has been granted to copy, distribute and modify gd in
+ any context without fee, including a commercial application,
+ provided that this notice is present in user-accessible supporting
+ documentation._
+
+ This does not affect your ownership of the derived work itself, and
+ the intent is to assure proper credit for the authors of gd, not to
+ interfere with your productive use of gd. If you have questions,
+ ask. "Derived works" includes all programs that utilize the
+ library. Credit must be given in user-accessible documentation.
+
+ _This software is provided "AS IS."_ The copyright holders disclaim
+ all warranties, either express or implied, including but not
+ limited to implied warranties of merchantability and fitness for a
+ particular purpose, with respect to this code and accompanying
+ documentation.
+
+ Although their code does not appear in gd 2.0.1, the authors wish
+ to thank David Koblas, David Rowley, and Hutchison Avenue Software
+ Corporation for their prior contributions.
+
+END OF COPYRIGHT STATEMENT
--- /dev/null
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include <zlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */
+#define CHARSET_EBCDIC
+#define __attribute__(any) /*nothing */
+#endif
+/*_OSD_POSIX*/
+
+#ifndef CHARSET_EBCDIC
+#define ASC(ch) ch
+#else /*CHARSET_EBCDIC */
+#define ASC(ch) gd_toascii[(unsigned char)ch]
+static const unsigned char gd_toascii[256] =
+{
+/*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f,
+ 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */
+/*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97,
+ 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */
+/*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */
+/*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
+ 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */
+/*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5,
+ 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */
+/*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef,
+ 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */
+/*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5,
+ 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
+/*-/........^,%_>?*/
+/*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
+ 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */
+/*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */
+/*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
+ 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */
+/*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */
+/*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc,
+ 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */
+/*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */
+/*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
+ 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */
+/*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+ 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */
+/*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */
+};
+#endif /*CHARSET_EBCDIC */
+
+extern int gdCosT[];
+extern int gdSinT[];
+
+static void gdImageBrushApply (gdImagePtr im, int x, int y);
+static void gdImageTileApply (gdImagePtr im, int x, int y);
+
+gdImagePtr
+gdImageCreate (int sx, int sy)
+{
+ int i;
+ gdImagePtr im;
+ im = (gdImage *) gdMalloc (sizeof (gdImage));
+ memset (im, 0, sizeof (gdImage));
+ /* Row-major ever since gd 1.3 */
+ im->pixels = (unsigned char **) gdMalloc (sizeof (unsigned char *) * sy);
+ im->polyInts = 0;
+ im->polyAllocated = 0;
+ im->brush = 0;
+ im->tile = 0;
+ im->style = 0;
+ for (i = 0; (i < sy); i++)
+ {
+ /* Row-major ever since gd 1.3 */
+ im->pixels[i] = (unsigned char *) gdCalloc (
+ sx, sizeof (unsigned char));
+ }
+ im->sx = sx;
+ im->sy = sy;
+ im->colorsTotal = 0;
+ im->transparent = (-1);
+ im->interlace = 0;
+ im->thick = 1;
+ for (i = 0; (i < gdMaxColors); i++)
+ {
+ im->open[i] = 1;
+ im->red[i] = 0;
+ im->green[i] = 0;
+ im->blue[i] = 0;
+ };
+ im->trueColor = 0;
+ im->tpixels = 0;
+ return im;
+}
+
+gdImagePtr
+gdImageCreateTrueColor (int sx, int sy)
+{
+ int i;
+ gdImagePtr im;
+ im = (gdImage *) gdMalloc (sizeof (gdImage));
+ memset (im, 0, sizeof (gdImage));
+ im->tpixels = (int **) gdMalloc (sizeof (int *) * sy);
+ im->polyInts = 0;
+ im->polyAllocated = 0;
+ im->brush = 0;
+ im->tile = 0;
+ im->style = 0;
+ for (i = 0; (i < sy); i++)
+ {
+ im->tpixels[i] = (int *) gdCalloc (
+ sx, sizeof (int));
+ }
+ im->sx = sx;
+ im->sy = sy;
+ im->transparent = (-1);
+ im->interlace = 0;
+ im->trueColor = 1;
+ im->saveAlphaFlag = 1;
+ im->alphaBlendingFlag = 0;
+ im->thick = 1;
+ return im;
+}
+
+void
+gdImageDestroy (gdImagePtr im)
+{
+ int i;
+ if (im->pixels)
+ {
+ for (i = 0; (i < im->sy); i++)
+ {
+ gdFree (im->pixels[i]);
+ }
+ gdFree (im->pixels);
+ }
+ if (im->tpixels)
+ {
+ for (i = 0; (i < im->sy); i++)
+ {
+ gdFree (im->tpixels[i]);
+ }
+ gdFree (im->tpixels);
+ }
+ if (im->polyInts)
+ {
+ gdFree (im->polyInts);
+ }
+ if (im->style)
+ {
+ gdFree (im->style);
+ }
+ gdFree (im);
+}
+
+int
+gdImageColorClosest (gdImagePtr im, int r, int g, int b)
+{
+ return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+ int i;
+ long rd, gd, bd, ad;
+ int ct = (-1);
+ int first = 1;
+ long mindist = 0;
+ if (im->trueColor)
+ {
+ return gdTrueColorAlpha (r, g, b, a);
+ }
+ for (i = 0; (i < (im->colorsTotal)); i++)
+ {
+ long dist;
+ if (im->open[i])
+ {
+ continue;
+ }
+ rd = (im->red[i] - r);
+ gd = (im->green[i] - g);
+ bd = (im->blue[i] - b);
+ ad = (im->blue[i] - b);
+ dist = rd * rd + gd * gd + bd * bd + ad * ad;
+ if (first || (dist < mindist))
+ {
+ mindist = dist;
+ ct = i;
+ first = 0;
+ }
+ }
+ return ct;
+}
+
+/* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article
+ * on colour conversion to/from RBG and HWB colour systems.
+ * It has been modified to return the converted value as a * parameter.
+ */
+
+#define RETURN_HWB(h, w, b) {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}
+#define RETURN_RGB(r, g, b) {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}
+#define HWB_UNDEFINED -1
+#define SETUP_RGB(s, r, g, b) {s.R = r/255.0; s.G = g/255.0; s.B = b/255.0;}
+
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c)))
+#define MAX(a,b) ((a)<(b)?(b):(a))
+#define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c)))
+
+
+/*
+ * Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure
+ * red always maps to 6 in this implementation. Therefore UNDEFINED can be
+ * defined as 0 in situations where only unsigned numbers are desired.
+ */
+typedef struct
+{
+ float R, G, B;
+}
+RGBType;
+typedef struct
+ {
+ float H, W, B;
+ }
+HWBType;
+
+static HWBType *
+RGB_to_HWB (RGBType RGB, HWBType * HWB)
+{
+
+ /*
+ * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is
+ * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.
+ */
+
+ float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
+ int i;
+
+ w = MIN3 (R, G, B);
+ v = MAX3 (R, G, B);
+ b = 1 - v;
+ if (v == w)
+ RETURN_HWB (HWB_UNDEFINED, w, b);
+ f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
+ i = (R == w) ? 3 : ((G == w) ? 5 : 1);
+ RETURN_HWB (i - f / (v - w), w, b);
+
+}
+
+static float
+HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2)
+{
+ RGBType RGB1, RGB2;
+ HWBType HWB1, HWB2;
+ float diff;
+
+ SETUP_RGB (RGB1, r1, g1, b1);
+ SETUP_RGB (RGB2, r2, g2, b2);
+
+ RGB_to_HWB (RGB1, &HWB1);
+ RGB_to_HWB (RGB2, &HWB2);
+
+ /*
+ * I made this bit up; it seems to produce OK results, and it is certainly
+ * more visually correct than the current RGB metric. (PJW)
+ */
+
+ if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED))
+ {
+ diff = 0; /* Undefined hues always match... */
+ }
+ else
+ {
+ diff = abs (HWB1.H - HWB2.H);
+ if (diff > 3)
+ {
+ diff = 6 - diff; /* Remember, it's a colour circle */
+ }
+ }
+
+ diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B);
+
+ return diff;
+}
+
+
+/*
+ * This is not actually used, but is here for completeness, in case someone wants to
+ * use the HWB stuff for anything else...
+ */
+static RGBType *
+HWB_to_RGB (HWBType HWB, RGBType * RGB)
+{
+
+ /*
+ * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1].
+ * RGB are each returned on [0, 1].
+ */
+
+ float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f;
+ int i;
+
+ v = 1 - b;
+ if (h == HWB_UNDEFINED)
+ RETURN_RGB (v, v, v);
+ i = floor (h);
+ f = h - i;
+ if (i & 1)
+ f = 1 - f; /* if i is odd */
+ n = w + f * (v - w); /* linear interpolation between w and v */
+ switch (i)
+ {
+ case 6:
+ case 0:
+ RETURN_RGB (v, n, w);
+ case 1:
+ RETURN_RGB (n, v, w);
+ case 2:
+ RETURN_RGB (w, v, n);
+ case 3:
+ RETURN_RGB (w, n, v);
+ case 4:
+ RETURN_RGB (n, w, v);
+ case 5:
+ RETURN_RGB (v, w, n);
+ }
+
+ return RGB;
+
+}
+
+int
+gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
+{
+ int i;
+ /* long rd, gd, bd; */
+ int ct = (-1);
+ int first = 1;
+ float mindist = 0;
+ if (im->trueColor)
+ {
+ return gdTrueColor (r, g, b);
+ }
+ for (i = 0; (i < (im->colorsTotal)); i++)
+ {
+ float dist;
+ if (im->open[i])
+ {
+ continue;
+ }
+ dist = HWB_Diff (im->red[i], im->green[i], im->blue[i], r, g, b);
+ if (first || (dist < mindist))
+ {
+ mindist = dist;
+ ct = i;
+ first = 0;
+ }
+ }
+ return ct;
+}
+
+int
+gdImageColorExact (gdImagePtr im, int r, int g, int b)
+{
+ return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+ int i;
+ if (im->trueColor)
+ {
+ return gdTrueColorAlpha (r, g, b, a);
+ }
+ for (i = 0; (i < (im->colorsTotal)); i++)
+ {
+ if (im->open[i])
+ {
+ continue;
+ }
+ if ((im->red[i] == r) &&
+ (im->green[i] == g) &&
+ (im->blue[i] == b) &&
+ (im->alpha[i] == a))
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+
+int
+gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
+{
+ return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+ int i;
+ int ct = (-1);
+ if (im->trueColor)
+ {
+ return gdTrueColorAlpha (r, g, b, a);
+ }
+ for (i = 0; (i < (im->colorsTotal)); i++)
+ {
+ if (im->open[i])
+ {
+ ct = i;
+ break;
+ }
+ }
+ if (ct == (-1))
+ {
+ ct = im->colorsTotal;
+ if (ct == gdMaxColors)
+ {
+ return -1;
+ }
+ im->colorsTotal++;
+ }
+ im->red[ct] = r;
+ im->green[ct] = g;
+ im->blue[ct] = b;
+ im->alpha[ct] = a;
+ im->open[ct] = 0;
+ return ct;
+}
+
+/*
+ * gdImageColorResolve is an alternative for the code fragment:
+ *
+ * if ((color=gdImageColorExact(im,R,G,B)) < 0)
+ * if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
+ * color=gdImageColorClosest(im,R,G,B);
+ *
+ * in a single function. Its advantage is that it is guaranteed to
+ * return a color index in one search over the color table.
+ */
+
+int
+gdImageColorResolve (gdImagePtr im, int r, int g, int b)
+{
+ return gdImageColorResolveAlpha (im, r, g, b, gdAlphaOpaque);
+}
+
+int
+gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
+{
+ int c;
+ int ct = -1;
+ int op = -1;
+ long rd, gd, bd, ad, dist;
+ long mindist = 4 * 255 * 255; /* init to max poss dist */
+ if (im->trueColor)
+ {
+ return gdTrueColorAlpha (r, g, b, a);
+ }
+
+ for (c = 0; c < im->colorsTotal; c++)
+ {
+ if (im->open[c])
+ {
+ op = c; /* Save open slot */
+ continue; /* Color not in use */
+ }
+ rd = (long) (im->red[c] - r);
+ gd = (long) (im->green[c] - g);
+ bd = (long) (im->blue[c] - b);
+ ad = (long) (im->alpha[c] - a);
+ dist = rd * rd + gd * gd + bd * bd + ad * ad;
+ if (dist < mindist)
+ {
+ if (dist == 0)
+ {
+ return c; /* Return exact match color */
+ }
+ mindist = dist;
+ ct = c;
+ }
+ }
+ /* no exact match. We now know closest, but first try to allocate exact */
+ if (op == -1)
+ {
+ op = im->colorsTotal;
+ if (op == gdMaxColors)
+ { /* No room for more colors */
+ return ct; /* Return closest available color */
+ }
+ im->colorsTotal++;
+ }
+ im->red[op] = r;
+ im->green[op] = g;
+ im->blue[op] = b;
+ im->alpha[op] = a;
+ im->open[op] = 0;
+ return op; /* Return newly allocated color */
+}
+
+void
+gdImageColorDeallocate (gdImagePtr im, int color)
+{
+ if (im->trueColor)
+ {
+ return;
+ }
+ /* Mark it open. */
+ im->open[color] = 1;
+}
+
+void
+gdImageColorTransparent (gdImagePtr im, int color)
+{
+ if (!im->trueColor)
+ {
+ if (im->transparent != -1)
+ {
+ im->alpha[im->transparent] = gdAlphaOpaque;
+ }
+ if (color != -1)
+ {
+ im->alpha[color] = gdAlphaTransparent;
+ }
+ }
+ im->transparent = color;
+}
+
+void
+gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
+{
+ int i;
+ int x, y, p;
+ int xlate[256];
+ if (to->trueColor)
+ {
+ return;
+ }
+ if (from->trueColor)
+ {
+ return;
+ }
+
+ for (i = 0; i < 256; i++)
+ {
+ xlate[i] = -1;
+ };
+
+ for (x = 0; x < (to->sx); x++)
+ {
+ for (y = 0; y < (to->sy); y++)
+ {
+ p = gdImageGetPixel (to, x, y);
+ if (xlate[p] == -1)
+ {
+ /* This ought to use HWB, but we don't have an alpha-aware
+ version of that yet. */
+ xlate[p] = gdImageColorClosestAlpha (from, to->red[p], to->green[p], to->blue[p], to->alpha[p]);
+ /*printf("Mapping %d (%d, %d, %d, %d) to %d (%d, %d, %d, %d)\n", */
+ /* p, to->red[p], to->green[p], to->blue[p], to->alpha[p], */
+ /* xlate[p], from->red[xlate[p]], from->green[xlate[p]], from->blue[xlate[p]], from->alpha[xlate[p]]); */
+ };
+ gdImageSetPixel (to, x, y, xlate[p]);
+ };
+ };
+
+ for (i = 0; (i < (from->colorsTotal)); i++)
+ {
+ /*printf("Copying color %d (%d, %d, %d, %d)\n", i, from->red[i], from->blue[i], from->green[i], from->alpha[i]); */
+ to->red[i] = from->red[i];
+ to->blue[i] = from->blue[i];
+ to->green[i] = from->green[i];
+ to->alpha[i] = from->alpha[i];
+ to->open[i] = 0;
+ };
+
+ for (i = from->colorsTotal; (i < to->colorsTotal); i++)
+ {
+ to->open[i] = 1;
+ };
+
+ to->colorsTotal = from->colorsTotal;
+
+}
+
+void
+gdImageSetPixel (gdImagePtr im, int x, int y, int color)
+{
+ int p;
+ switch (color)
+ {
+ case gdStyled:
+ if (!im->style)
+ {
+ /* Refuse to draw if no style is set. */
+ return;
+ }
+ else
+ {
+ p = im->style[im->stylePos++];
+ }
+ if (p != (gdTransparent))
+ {
+ gdImageSetPixel (im, x, y, p);
+ }
+ im->stylePos = im->stylePos % im->styleLength;
+ break;
+ case gdStyledBrushed:
+ if (!im->style)
+ {
+ /* Refuse to draw if no style is set. */
+ return;
+ }
+ p = im->style[im->stylePos++];
+ if ((p != gdTransparent) && (p != 0))
+ {
+ gdImageSetPixel (im, x, y, gdBrushed);
+ }
+ im->stylePos = im->stylePos % im->styleLength;
+ break;
+ case gdBrushed:
+ gdImageBrushApply (im, x, y);
+ break;
+ case gdTiled:
+ gdImageTileApply (im, x, y);
+ break;
+ default:
+ if (gdImageBoundsSafe (im, x, y))
+ {
+ if (im->trueColor)
+ {
+ if (im->alphaBlendingFlag)
+ {
+ im->tpixels[y][x] =
+ gdAlphaBlend (im->tpixels[y][x],
+ color);
+ }
+ else
+ {
+ im->tpixels[y][x] = color;
+ }
+ }
+ else
+ {
+ im->pixels[y][x] = color;
+ }
+ }
+ break;
+ }
+}
+
+static void
+gdImageBrushApply (gdImagePtr im, int x, int y)
+{
+ int lx, ly;
+ int hy;
+ int hx;
+ int x1, y1, x2, y2;
+ int srcx, srcy;
+ if (!im->brush)
+ {
+ return;
+ }
+ hy = gdImageSY (im->brush) / 2;
+ y1 = y - hy;
+ y2 = y1 + gdImageSY (im->brush);
+ hx = gdImageSX (im->brush) / 2;
+ x1 = x - hx;
+ x2 = x1 + gdImageSX (im->brush);
+ srcy = 0;
+ if (im->trueColor)
+ {
+ for (ly = y1; (ly < y2); ly++)
+ {
+ srcx = 0;
+ for (lx = x1; (lx < x2); lx++)
+ {
+ int p;
+ p = gdImageGetTrueColorPixel (
+ im->brush, srcx, srcy);
+ gdImageSetPixel (im, lx, ly,
+ p);
+ srcx++;
+ }
+ srcy++;
+ }
+ }
+ else
+ {
+ for (ly = y1; (ly < y2); ly++)
+ {
+ srcx = 0;
+ for (lx = x1; (lx < x2); lx++)
+ {
+ int p;
+ p = gdImageGetPixel (im->brush, srcx, srcy);
+ /* Allow for non-square brushes! */
+ if (p != gdImageGetTransparent (im->brush))
+ {
+ /* Truecolor brush. Very slow
+ on a palette destination. */
+ if (im->brush->trueColor)
+ {
+ gdImageSetPixel (im, lx, ly,
+ gdImageColorResolveAlpha (
+ im,
+ gdTrueColorGetRed (p),
+ gdTrueColorGetGreen (p),
+ gdTrueColorGetBlue (p),
+ gdTrueColorGetAlpha (p)));
+ }
+ else
+ {
+ gdImageSetPixel (im, lx, ly,
+ im->brushColorMap[p]);
+ }
+ }
+ srcx++;
+ }
+ srcy++;
+ }
+ }
+}
+
+static void
+gdImageTileApply (gdImagePtr im, int x, int y)
+{
+ int srcx, srcy;
+ int p;
+ if (!im->tile)
+ {
+ return;
+ }
+ srcx = x % gdImageSX (im->tile);
+ srcy = y % gdImageSY (im->tile);
+ if (im->trueColor)
+ {
+ p = gdImageGetTrueColorPixel (im->tile, srcx, srcy);
+ gdImageSetPixel (im, x, y, p);
+ }
+ else
+ {
+ /* Allow for transparency */
+ if (p != gdImageGetTransparent (im->tile))
+ {
+ if (im->tile->trueColor)
+ {
+ /* Truecolor tile. Very slow
+ on a palette destination. */
+ gdImageSetPixel (im, x, y,
+ gdImageColorResolveAlpha (
+ im,
+ gdTrueColorGetRed (p),
+ gdTrueColorGetGreen (p),
+ gdTrueColorGetBlue (p),
+ gdTrueColorGetAlpha (p)));
+ }
+ else
+ {
+ gdImageSetPixel (im, x, y,
+ im->tileColorMap[p]);
+ }
+ }
+ }
+}
+
+int
+gdImageGetPixel (gdImagePtr im, int x, int y)
+{
+ if (gdImageBoundsSafe (im, x, y))
+ {
+ if (im->trueColor)
+ {
+ return im->tpixels[y][x];
+ }
+ else
+ {
+ return im->pixels[y][x];
+ }
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+int
+gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
+{
+ int p = gdImageGetPixel (im, x, y);
+ if (!im->trueColor)
+ {
+ return gdTrueColorAlpha (im->red[p], im->green[p], im->blue[p],
+ (im->transparent == p) ? gdAlphaTransparent :
+ gdAlphaOpaque);
+ }
+ else
+ {
+ return p;
+ }
+}
+
+/* Bresenham as presented in Foley & Van Dam */
+void
+gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+ int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
+ int wid;
+ int w, wstart;
+ int thick = im->thick;
+ dx = abs (x2 - x1);
+ dy = abs (y2 - y1);
+ if (dy <= dx)
+ {
+ /* More-or-less horizontal. use wid for vertical stroke */
+ wid = thick * cos (atan2 (dy, dx));
+ if (wid == 0)
+ wid = 1;
+
+ d = 2 * dy - dx;
+ incr1 = 2 * dy;
+ incr2 = 2 * (dy - dx);
+ if (x1 > x2)
+ {
+ x = x2;
+ y = y2;
+ ydirflag = (-1);
+ xend = x1;
+ }
+ else
+ {
+ x = x1;
+ y = y1;
+ ydirflag = 1;
+ xend = x2;
+ }
+
+ /* Set up line thickness */
+ wstart = y - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, x, w, color);
+
+ if (((y2 - y1) * ydirflag) > 0)
+ {
+ while (x < xend)
+ {
+ x++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ y++;
+ d += incr2;
+ }
+ wstart = y - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, x, w, color);
+ }
+ }
+ else
+ {
+ while (x < xend)
+ {
+ x++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ y--;
+ d += incr2;
+ }
+ wstart = y - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, x, w, color);
+ }
+ }
+ }
+ else
+ {
+ /* More-or-less vertical. use wid for horizontal stroke */
+ wid = thick * sin (atan2 (dy, dx));
+ if (wid == 0)
+ wid = 1;
+
+ d = 2 * dx - dy;
+ incr1 = 2 * dx;
+ incr2 = 2 * (dx - dy);
+ if (y1 > y2)
+ {
+ y = y2;
+ x = x2;
+ yend = y1;
+ xdirflag = (-1);
+ }
+ else
+ {
+ y = y1;
+ x = x1;
+ yend = y2;
+ xdirflag = 1;
+ }
+
+ /* Set up line thickness */
+ wstart = x - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, w, y, color);
+
+ if (((x2 - x1) * xdirflag) > 0)
+ {
+ while (y < yend)
+ {
+ y++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ x++;
+ d += incr2;
+ }
+ wstart = x - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, w, y, color);
+ }
+ }
+ else
+ {
+ while (y < yend)
+ {
+ y++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ x--;
+ d += incr2;
+ }
+ wstart = x - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, w, y, color);
+ }
+ }
+ }
+}
+static void dashedSet (gdImagePtr im, int x, int y, int color,
+ int *onP, int *dashStepP, int wid, int vert);
+
+void
+gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+ int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
+ int dashStep = 0;
+ int on = 1;
+ int wid;
+ int w, wstart, vert;
+ int thick = im->thick;
+
+ dx = abs (x2 - x1);
+ dy = abs (y2 - y1);
+ if (dy <= dx)
+ {
+ /* More-or-less horizontal. use wid for vertical stroke */
+ wid = thick * sin (atan2 (dy, dx));
+ vert = 1;
+
+ d = 2 * dy - dx;
+ incr1 = 2 * dy;
+ incr2 = 2 * (dy - dx);
+ if (x1 > x2)
+ {
+ x = x2;
+ y = y2;
+ ydirflag = (-1);
+ xend = x1;
+ }
+ else
+ {
+ x = x1;
+ y = y1;
+ ydirflag = 1;
+ xend = x2;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ if (((y2 - y1) * ydirflag) > 0)
+ {
+ while (x < xend)
+ {
+ x++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ y++;
+ d += incr2;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ }
+ }
+ else
+ {
+ while (x < xend)
+ {
+ x++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ y--;
+ d += incr2;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ }
+ }
+ }
+ else
+ {
+ /* More-or-less vertical. use wid for horizontal stroke */
+ wid = thick * sin (atan2 (dy, dx));
+ vert = 0;
+
+ d = 2 * dx - dy;
+ incr1 = 2 * dx;
+ incr2 = 2 * (dx - dy);
+ if (y1 > y2)
+ {
+ y = y2;
+ x = x2;
+ yend = y1;
+ xdirflag = (-1);
+ }
+ else
+ {
+ y = y1;
+ x = x1;
+ yend = y2;
+ xdirflag = 1;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ if (((x2 - x1) * xdirflag) > 0)
+ {
+ while (y < yend)
+ {
+ y++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ x++;
+ d += incr2;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ }
+ }
+ else
+ {
+ while (y < yend)
+ {
+ y++;
+ if (d < 0)
+ {
+ d += incr1;
+ }
+ else
+ {
+ x--;
+ d += incr2;
+ }
+ dashedSet (im, x, y, color, &on, &dashStep, wid, vert);
+ }
+ }
+ }
+}
+
+static void
+dashedSet (gdImagePtr im, int x, int y, int color,
+ int *onP, int *dashStepP, int wid, int vert)
+{
+ int dashStep = *dashStepP;
+ int on = *onP;
+ int w, wstart;
+
+ dashStep++;
+ if (dashStep == gdDashSize)
+ {
+ dashStep = 0;
+ on = !on;
+ }
+ if (on)
+ {
+ if (vert)
+ {
+ wstart = y - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, x, w, color);
+ }
+ else
+ {
+ wstart = x - wid / 2;
+ for (w = wstart; w < wstart + wid; w++)
+ gdImageSetPixel (im, w, y, color);
+ }
+ }
+ *dashStepP = dashStep;
+ *onP = on;
+}
+
+int
+gdImageBoundsSafe (gdImagePtr im, int x, int y)
+{
+ return (!(((y < 0) || (y >= im->sy)) ||
+ ((x < 0) || (x >= im->sx))));
+}
+
+void
+gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y,
+ int c, int color)
+{
+ int cx, cy;
+ int px, py;
+ int fline;
+ cx = 0;
+ cy = 0;
+#ifdef CHARSET_EBCDIC
+ c = ASC (c);
+#endif /*CHARSET_EBCDIC */
+ if ((c < f->offset) || (c >= (f->offset + f->nchars)))
+ {
+ return;
+ }
+ fline = (c - f->offset) * f->h * f->w;
+ for (py = y; (py < (y + f->h)); py++)
+ {
+ for (px = x; (px < (x + f->w)); px++)
+ {
+ if (f->data[fline + cy * f->w + cx])
+ {
+ gdImageSetPixel (im, px, py, color);
+ }
+ cx++;
+ }
+ cx = 0;
+ cy++;
+ }
+}
+
+void
+gdImageCharUp (gdImagePtr im, gdFontPtr f,
+ int x, int y, int c, int color)
+{
+ int cx, cy;
+ int px, py;
+ int fline;
+ cx = 0;
+ cy = 0;
+#ifdef CHARSET_EBCDIC
+ c = ASC (c);
+#endif /*CHARSET_EBCDIC */
+ if ((c < f->offset) || (c >= (f->offset + f->nchars)))
+ {
+ return;
+ }
+ fline = (c - f->offset) * f->h * f->w;
+ for (py = y; (py > (y - f->w)); py--)
+ {
+ for (px = x; (px < (x + f->h)); px++)
+ {
+ if (f->data[fline + cy * f->w + cx])
+ {
+ gdImageSetPixel (im, px, py, color);
+ }
+ cy++;
+ }
+ cy = 0;
+ cx++;
+ }
+}
+
+void
+gdImageString (gdImagePtr im, gdFontPtr f,
+ int x, int y, unsigned char *s, int color)
+{
+ int i;
+ int l;
+ l = strlen ((char *) s);
+ for (i = 0; (i < l); i++)
+ {
+ gdImageChar (im, f, x, y, s[i], color);
+ x += f->w;
+ }
+}
+
+void
+gdImageStringUp (gdImagePtr im, gdFontPtr f,
+ int x, int y, unsigned char *s, int color)
+{
+ int i;
+ int l;
+ l = strlen ((char *) s);
+ for (i = 0; (i < l); i++)
+ {
+ gdImageCharUp (im, f, x, y, s[i], color);
+ y -= f->w;
+ }
+}
+
+static int strlen16 (unsigned short *s);
+
+void
+gdImageString16 (gdImagePtr im, gdFontPtr f,
+ int x, int y, unsigned short *s, int color)
+{
+ int i;
+ int l;
+ l = strlen16 (s);
+ for (i = 0; (i < l); i++)
+ {
+ gdImageChar (im, f, x, y, s[i], color);
+ x += f->w;
+ }
+}
+
+void
+gdImageStringUp16 (gdImagePtr im, gdFontPtr f,
+ int x, int y, unsigned short *s, int color)
+{
+ int i;
+ int l;
+ l = strlen16 (s);
+ for (i = 0; (i < l); i++)
+ {
+ gdImageCharUp (im, f, x, y, s[i], color);
+ y -= f->w;
+ }
+}
+
+static int
+strlen16 (unsigned short *s)
+{
+ int len = 0;
+ while (*s)
+ {
+ s++;
+ len++;
+ }
+ return len;
+}
+
+#ifndef HAVE_LSQRT
+/* If you don't have a nice square root function for longs, you can use
+ ** this hack
+ */
+long
+lsqrt (long n)
+{
+ long result = (long) sqrt ((double) n);
+ return result;
+}
+#endif
+
+/* s and e are integers modulo 360 (degrees), with 0 degrees
+ being the rightmost extreme and degrees changing clockwise.
+ cx and cy are the center in pixels; w and h are the horizontal
+ and vertical diameter in pixels. Nice interface, but slow.
+ See gd_arc_f_buggy.c for a better version that doesn't
+ seem to be bug-free yet. */
+
+void
+gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color)
+{
+ gdImageFilledArc (im, cx, cy, w, h, s, e, color, gdNoFill);
+}
+
+void
+gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style)
+{
+ gdPoint pts[3];
+ int i;
+ int lx = 0, ly = 0;
+ int fx, fy;
+ int w2, h2;
+ w2 = w / 2;
+ h2 = h / 2;
+ while (e < s)
+ {
+ e += 360;
+ }
+ for (i = s; (i <= e); i++)
+ {
+ int x, y;
+ x = ((long) gdCosT[i % 360] * (long) w2 / 1024) + cx;
+ y = ((long) gdSinT[i % 360] * (long) h2 / 1024) + cy;
+ if (i != s)
+ {
+ if (!(style & gdChord))
+ {
+ if (style & gdNoFill)
+ {
+ gdImageLine (im, lx, ly, x, y, color);
+ }
+ else
+ {
+ /* This is expensive! */
+ pts[0].x = lx;
+ pts[0].y = ly;
+ pts[1].x = x;
+ pts[1].y = y;
+ pts[2].x = cx;
+ pts[2].y = cy;
+ gdImageFilledPolygon (im, pts, 3, color);
+ }
+ }
+ }
+ else
+ {
+ fx = x;
+ fy = y;
+ }
+ lx = x;
+ ly = y;
+ }
+ if (style & gdChord)
+ {
+ if (style & gdNoFill)
+ {
+ if (style & gdEdged)
+ {
+ gdImageLine (im, cx, cy, lx, ly, color);
+ gdImageLine (im, cx, cy, fx, fy, color);
+ }
+ gdImageLine (im, fx, fy, lx, ly, color);
+ }
+ else
+ {
+ pts[0].x = fx;
+ pts[0].y = fy;
+ pts[1].x = lx;
+ pts[1].y = ly;
+ pts[2].x = cx;
+ pts[2].y = cy;
+ gdImageFilledPolygon (im, pts, 3, color);
+ }
+ }
+ else
+ {
+ if (style & gdNoFill)
+ {
+ if (style & gdEdged)
+ {
+ gdImageLine (im, cx, cy, lx, ly, color);
+ gdImageLine (im, cx, cy, fx, fy, color);
+ }
+ }
+ }
+}
+
+void
+gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int w, int h, int color)
+{
+ gdImageFilledArc (im, cx, cy, w, h, 0, 360, color, gdPie);
+}
+
+void
+gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
+{
+ int lastBorder;
+ /* Seek left */
+ int leftLimit, rightLimit;
+ int i;
+ leftLimit = (-1);
+ if (border < 0)
+ {
+ /* Refuse to fill to a non-solid border */
+ return;
+ }
+ for (i = x; (i >= 0); i--)
+ {
+ if (gdImageGetPixel (im, i, y) == border)
+ {
+ break;
+ }
+ gdImageSetPixel (im, i, y, color);
+ leftLimit = i;
+ }
+ if (leftLimit == (-1))
+ {
+ return;
+ }
+ /* Seek right */
+ rightLimit = x;
+ for (i = (x + 1); (i < im->sx); i++)
+ {
+ if (gdImageGetPixel (im, i, y) == border)
+ {
+ break;
+ }
+ gdImageSetPixel (im, i, y, color);
+ rightLimit = i;
+ }
+ /* Look at lines above and below and start paints */
+ /* Above */
+ if (y > 0)
+ {
+ lastBorder = 1;
+ for (i = leftLimit; (i <= rightLimit); i++)
+ {
+ int c;
+ c = gdImageGetPixel (im, i, y - 1);
+ if (lastBorder)
+ {
+ if ((c != border) && (c != color))
+ {
+ gdImageFillToBorder (im, i, y - 1,
+ border, color);
+ lastBorder = 0;
+ }
+ }
+ else if ((c == border) || (c == color))
+ {
+ lastBorder = 1;
+ }
+ }
+ }
+ /* Below */
+ if (y < ((im->sy) - 1))
+ {
+ lastBorder = 1;
+ for (i = leftLimit; (i <= rightLimit); i++)
+ {
+ int c;
+ c = gdImageGetPixel (im, i, y + 1);
+ if (lastBorder)
+ {
+ if ((c != border) && (c != color))
+ {
+ gdImageFillToBorder (im, i, y + 1,
+ border, color);
+ lastBorder = 0;
+ }
+ }
+ else if ((c == border) || (c == color))
+ {
+ lastBorder = 1;
+ }
+ }
+ }
+}
+
+void
+gdImageFill (gdImagePtr im, int x, int y, int color)
+{
+ int lastBorder;
+ int old;
+ int leftLimit, rightLimit;
+ int i;
+ old = gdImageGetPixel (im, x, y);
+ if (color == gdTiled)
+ {
+ /* Tile fill -- got to watch out! */
+ int p, tileColor;
+ int srcx, srcy;
+ if (!im->tile)
+ {
+ return;
+ }
+ /* Refuse to flood-fill with a transparent pattern --
+ I can't do it without allocating another image */
+ if (gdImageGetTransparent (im->tile) != (-1))
+ {
+ return;
+ }
+ srcx = x % gdImageSX (im->tile);
+ srcy = y % gdImageSY (im->tile);
+ p = gdImageGetPixel (im->tile, srcx, srcy);
+ if (im->trueColor)
+ {
+ tileColor = p;
+ }
+ else
+ {
+ if (im->tile->trueColor)
+ {
+ tileColor = gdImageColorResolveAlpha (im,
+ gdTrueColorGetRed (p),
+ gdTrueColorGetGreen (p),
+ gdTrueColorGetBlue (p),
+ gdTrueColorGetAlpha (p));
+ }
+ else
+ {
+ tileColor = im->tileColorMap[p];
+ }
+ }
+ if (old == tileColor)
+ {
+ /* Nothing to be done */
+ return;
+ }
+ }
+ else
+ {
+ if (old == color)
+ {
+ /* Nothing to be done */
+ return;
+ }
+ }
+ /* Seek left */
+ leftLimit = (-1);
+ for (i = x; (i >= 0); i--)
+ {
+ if (gdImageGetPixel (im, i, y) != old)
+ {
+ break;
+ }
+ gdImageSetPixel (im, i, y, color);
+ leftLimit = i;
+ }
+ if (leftLimit == (-1))
+ {
+ return;
+ }
+ /* Seek right */
+ rightLimit = x;
+ for (i = (x + 1); (i < im->sx); i++)
+ {
+ if (gdImageGetPixel (im, i, y) != old)
+ {
+ break;
+ }
+ gdImageSetPixel (im, i, y, color);
+ rightLimit = i;
+ }
+ /* Look at lines above and below and start paints */
+ /* Above */
+ if (y > 0)
+ {
+ lastBorder = 1;
+ for (i = leftLimit; (i <= rightLimit); i++)
+ {
+ int c;
+ c = gdImageGetPixel (im, i, y - 1);
+ if (lastBorder)
+ {
+ if (c == old)
+ {
+ gdImageFill (im, i, y - 1, color);
+ lastBorder = 0;
+ }
+ }
+ else if (c != old)
+ {
+ lastBorder = 1;
+ }
+ }
+ }
+ /* Below */
+ if (y < ((im->sy) - 1))
+ {
+ lastBorder = 1;
+ for (i = leftLimit; (i <= rightLimit); i++)
+ {
+ int c;
+ c = gdImageGetPixel (im, i, y + 1);
+ if (lastBorder)
+ {
+ if (c == old)
+ {
+ gdImageFill (im, i, y + 1, color);
+ lastBorder = 0;
+ }
+ }
+ else if (c != old)
+ {
+ lastBorder = 1;
+ }
+ }
+ }
+}
+
+void
+gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+ int x1h = x1, x1v = x1, y1h = y1, y1v = y1, x2h = x2, x2v = x2, y2h = y2,
+ y2v = y2;
+ int thick = im->thick;
+ if (thick > 1)
+ {
+ int half = thick / 2;
+ int half1 = thick - half;
+
+ if (y1 < y2)
+ {
+ y1v = y1h - half;
+ y2v = y2h + half1 - 1;
+ }
+ else
+ {
+ y1v = y1h + half1 - 1;
+ y2v = y2h - half;
+ }
+ }
+
+ gdImageLine (im, x1h, y1h, x2h, y1h, color);
+ gdImageLine (im, x1h, y2h, x2h, y2h, color);
+ gdImageLine (im, x1v, y1v, x1v, y2v, color);
+ gdImageLine (im, x2v, y1v, x2v, y2v, color);
+}
+
+void
+gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
+{
+ int x, y;
+ for (y = y1; (y <= y2); y++)
+ {
+ for (x = x1; (x <= x2); x++)
+ {
+ gdImageSetPixel (im, x, y, color);
+ }
+ }
+}
+
+void
+gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
+{
+ int c;
+ int x, y;
+ int tox, toy;
+ int i;
+ int colorMap[gdMaxColors];
+ if (dst->trueColor)
+ {
+ /* 2.0: much easier when the destination is truecolor. */
+ for (y = 0; (y < h); y++)
+ {
+ for (x = 0; (x < w); x++)
+ {
+ int c = gdImageGetTrueColorPixel (src, srcX + x,
+ srcY + y);
+ if (c != src->transparent)
+ {
+ gdImageSetPixel (dst,
+ dstX + x,
+ dstY + y,
+ c);
+ }
+ }
+ }
+ return;
+ }
+ for (i = 0; (i < gdMaxColors); i++)
+ {
+ colorMap[i] = (-1);
+ }
+ toy = dstY;
+ for (y = srcY; (y < (srcY + h)); y++)
+ {
+ tox = dstX;
+ for (x = srcX; (x < (srcX + w)); x++)
+ {
+ int nc;
+ c = gdImageGetPixel (src, x, y);
+ /* Added 7/24/95: support transparent copies */
+ if (gdImageGetTransparent (src) == c)
+ {
+ tox++;
+ continue;
+ }
+ /* Have we established a mapping for this color? */
+ if (colorMap[c] == (-1))
+ {
+ /* If it's the same image, mapping is trivial */
+ if (dst == src)
+ {
+ nc = c;
+ }
+ else
+ {
+ /* Get best match possible. This
+ function never returns error. */
+ nc = gdImageColorResolveAlpha (
+ dst,
+ src->red[c], src->green[c],
+ src->blue[c], src->alpha[c]);
+ }
+ colorMap[c] = nc;
+ }
+ gdImageSetPixel (dst, tox, toy, colorMap[c]);
+ tox++;
+ }
+ toy++;
+ }
+}
+
+/* This function is a substitute for real alpha channel operations,
+ so it doesn't pay attention to the alpha channel. */
+void
+gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
+{
+
+ int c, dc;
+ int x, y;
+ int tox, toy;
+ int ncR, ncG, ncB;
+ toy = dstY;
+ for (y = srcY; (y < (srcY + h)); y++)
+ {
+ tox = dstX;
+ for (x = srcX; (x < (srcX + w)); x++)
+ {
+ int nc;
+ c = gdImageGetPixel (src, x, y);
+ /* Added 7/24/95: support transparent copies */
+ if (gdImageGetTransparent (src) == c)
+ {
+ tox++;
+ continue;
+ }
+ /* If it's the same image, mapping is trivial */
+ if (dst == src)
+ {
+ nc = c;
+ }
+ else
+ {
+ dc = gdImageGetPixel (dst, tox, toy);
+
+ ncR = gdImageRed (src, c) * (pct / 100.0)
+ + gdImageRed (dst, dc) * ((100 - pct) / 100.0);
+ ncG = gdImageGreen (src, c) * (pct / 100.0)
+ + gdImageGreen (dst, dc) * ((100 - pct) / 100.0);
+ ncB = gdImageBlue (src, c) * (pct / 100.0)
+ + gdImageBlue (dst, dc) * ((100 - pct) / 100.0);
+
+ /* Find a reasonable color */
+ nc = gdImageColorResolve (dst, ncR, ncG, ncB);
+ }
+ gdImageSetPixel (dst, tox, toy, nc);
+ tox++;
+ }
+ toy++;
+ }
+}
+
+/* This function is a substitute for real alpha channel operations,
+ so it doesn't pay attention to the alpha channel. */
+void
+gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
+{
+
+ int c, dc;
+ int x, y;
+ int tox, toy;
+ int ncR, ncG, ncB;
+ float g;
+ toy = dstY;
+ for (y = srcY; (y < (srcY + h)); y++)
+ {
+ tox = dstX;
+ for (x = srcX; (x < (srcX + w)); x++)
+ {
+ int nc;
+ c = gdImageGetPixel (src, x, y);
+ /* Added 7/24/95: support transparent copies */
+ if (gdImageGetTransparent (src) == c)
+ {
+ tox++;
+ continue;
+ }
+ /* If it's the same image, mapping is trivial */
+ if (dst == src)
+ {
+ nc = c;
+ }
+ else
+ {
+ dc = gdImageGetPixel (dst, tox, toy);
+ g = 0.29900 * dst->red[dc]
+ + 0.58700 * dst->green[dc]
+ + 0.11400 * dst->blue[dc];
+
+ ncR = gdImageRed (src, c) * (pct / 100.0)
+ + gdImageRed (dst, dc) * g *
+ ((100 - pct) / 100.0);
+ ncG = gdImageGreen (src, c) * (pct / 100.0)
+ + gdImageGreen (dst, dc) * g *
+ ((100 - pct) / 100.0);
+ ncB = gdImageBlue (src, c) * (pct / 100.0)
+ + gdImageBlue (dst, dc) * g *
+ ((100 - pct) / 100.0);
+
+ /* First look for an exact match */
+ nc = gdImageColorExact (dst, ncR, ncG, ncB);
+ if (nc == (-1))
+ {
+ /* No, so try to allocate it */
+ nc = gdImageColorAllocate (dst, ncR, ncG, ncB);
+ /* If we're out of colors, go for the
+ closest color */
+ if (nc == (-1))
+ {
+ nc = gdImageColorClosest (dst, ncR, ncG, ncB);
+ }
+ }
+ }
+ gdImageSetPixel (dst, tox, toy, nc);
+ tox++;
+ }
+ toy++;
+ }
+}
+
+void
+gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
+{
+ int c;
+ int x, y;
+ int tox, toy;
+ int ydest;
+ int i;
+ int colorMap[gdMaxColors];
+ /* Stretch vectors */
+ int *stx;
+ int *sty;
+ /* We only need to use floating point to determine the correct
+ stretch vector for one line's worth. */
+ double accum;
+ stx = (int *) gdMalloc (sizeof (int) * srcW);
+ sty = (int *) gdMalloc (sizeof (int) * srcH);
+ accum = 0;
+ for (i = 0; (i < srcW); i++)
+ {
+ int got;
+ accum += (double) dstW / (double) srcW;
+ got = (int) floor (accum);
+ stx[i] = got;
+ accum -= got;
+ }
+ accum = 0;
+ for (i = 0; (i < srcH); i++)
+ {
+ int got;
+ accum += (double) dstH / (double) srcH;
+ got = (int) floor (accum);
+ sty[i] = got;
+ accum -= got;
+ }
+ for (i = 0; (i < gdMaxColors); i++)
+ {
+ colorMap[i] = (-1);
+ }
+ toy = dstY;
+ for (y = srcY; (y < (srcY + srcH)); y++)
+ {
+ for (ydest = 0; (ydest < sty[y - srcY]); ydest++)
+ {
+ tox = dstX;
+ for (x = srcX; (x < (srcX + srcW)); x++)
+ {
+ int nc;
+ int mapTo;
+ if (!stx[x - srcX])
+ {
+ continue;
+ }
+ if (dst->trueColor)
+ {
+ int d;
+ mapTo = gdImageGetTrueColorPixel (src, x, y);
+ /* Added 7/24/95: support transparent copies */
+ if (gdImageGetTransparent (src) == mapTo)
+ {
+ tox++;
+ continue;
+ }
+ }
+ else
+ {
+ c = gdImageGetPixel (src, x, y);
+ /* Added 7/24/95: support transparent copies */
+ if (gdImageGetTransparent (src) == c)
+ {
+ tox += stx[x - srcX];
+ continue;
+ }
+ if (src->trueColor)
+ {
+ /* Remap to the palette available in the
+ destination image. This is slow and
+ works badly. */
+ mapTo = gdImageColorResolveAlpha (dst,
+ gdTrueColorGetRed (c),
+ gdTrueColorGetGreen (c),
+ gdTrueColorGetBlue (c),
+ gdTrueColorGetAlpha (c));
+ }
+ else
+ {
+ /* Have we established a mapping for this color? */
+ if (colorMap[c] == (-1))
+ {
+ /* If it's the same image, mapping is trivial */
+ if (dst == src)
+ {
+ nc = c;
+ }
+ else
+ {
+ /* Find or create the best match */
+ mapTo = gdImageColorResolveAlpha (dst,
+ gdTrueColorGetRed (c),
+ gdTrueColorGetGreen (c),
+ gdTrueColorGetBlue (c),
+ gdTrueColorGetAlpha (c));
+ }
+ colorMap[c] = nc;
+ }
+ mapTo = colorMap[c];
+ }
+ }
+ for (i = 0; (i < stx[x - srcX]); i++)
+ {
+ gdImageSetPixel (dst, tox, toy, mapTo);
+ tox++;
+ }
+ }
+ toy++;
+ }
+ }
+ gdFree (stx);
+ gdFree (sty);
+}
+
+/* When gd 1.x was first created, floating point was to be avoided.
+ These days it is often faster than table lookups or integer
+ arithmetic. The routine below is shamelessly, gloriously
+ floating point. TBB */
+
+void
+gdImageCopyResampled (gdImagePtr dst,
+ gdImagePtr src,
+ int dstX, int dstY,
+ int srcX, int srcY,
+ int dstW, int dstH,
+ int srcW, int srcH)
+{
+ int x, y;
+ float sx, sy;
+ if (!dst->trueColor)
+ {
+ gdImageCopyResized (
+ dst, src, dstX, dstY, srcX, srcY, dstW, dstH,
+ srcW, srcH);
+ return;
+ }
+ for (y = dstY; (y < dstY + dstH); y++)
+ {
+ for (x = dstX; (x < dstX + dstW); x++)
+ {
+ int pd = gdImageGetPixel (dst, x, y);
+ float sy1, sy2, sx1, sx2;
+ float sx, sy;
+ float spixels = 0;
+ float red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
+ sy1 = ((float) y - (float) dstY) * (float) srcH /
+ (float) dstH;
+ sy2 = ((float) (y + 1) - (float) dstY) * (float) srcH /
+ (float) dstH;
+ sy = sy1;
+ do
+ {
+ float yportion;
+ if (floor (sy) == floor (sy1))
+ {
+ yportion = 1.0 - (sy - floor (sy));
+ if (yportion > sy2 - sy1)
+ {
+ yportion = sy2 - sy1;
+ }
+ sy = floor (sy);
+ }
+ else if (sy == floor (sy2))
+ {
+ yportion = sy2 - floor (sy2);
+ }
+ else
+ {
+ yportion = 1.0;
+ }
+ sx1 = ((float) x - (float) dstX) * (float) srcW /
+ dstW;
+ sx2 = ((float) (x + 1) - (float) dstX) * (float) srcW /
+ dstW;
+ sx = sx1;
+ do
+ {
+ float xportion;
+ float pcontribution;
+ int p;
+ if (floor (sx) == floor (sx1))
+ {
+ xportion = 1.0 - (sx - floor (sx));
+ if (xportion > sx2 - sx1)
+ {
+ xportion = sx2 - sx1;
+ }
+ sx = floor (sx);
+ }
+ else if (sx == floor (sx2))
+ {
+ xportion = sx2 - floor (sx2);
+ }
+ else
+ {
+ xportion = 1.0;
+ }
+ pcontribution = xportion * yportion;
+ p = gdImageGetTrueColorPixel (
+ src,
+ (int) sx,
+ (int) sy);
+ red += gdTrueColorGetRed (p) * pcontribution;
+ green += gdTrueColorGetGreen (p) * pcontribution;
+ blue += gdTrueColorGetBlue (p) * pcontribution;
+ alpha += gdTrueColorGetAlpha (p) * pcontribution;
+ spixels += xportion * yportion;
+ sx += 1.0;
+ }
+ while (sx < sx2);
+ sy += 1.0;
+ }
+ while (sy < sy2);
+ if (spixels != 0.0)
+ {
+ red /= spixels;
+ green /= spixels;
+ blue /= spixels;
+ alpha /= spixels;
+ }
+ /* Clamping to allow for rounding errors above */
+ if (red > 255.0)
+ {
+ red = 255.0;
+ }
+ if (green > 255.0)
+ {
+ green = 255.0;
+ }
+ if (blue > 255.0)
+ {
+ blue = 255.0;
+ }
+ if (alpha > gdAlphaMax)
+ {
+ alpha = gdAlphaMax;
+ }
+ gdImageSetPixel (dst,
+ x, y,
+ gdTrueColorAlpha ((int) red,
+ (int) green,
+ (int) blue,
+ (int) alpha));
+ }
+ }
+}
+
+gdImagePtr
+gdImageCreateFromXbm (FILE * fd)
+{
+ gdImagePtr im;
+ int bit;
+ int w, h;
+ int bytes;
+ int ch;
+ int i, x, y;
+ char *sp;
+ char s[161];
+ if (!fgets (s, 160, fd))
+ {
+ return 0;
+ }
+ sp = &s[0];
+ /* Skip #define */
+ sp = strchr (sp, ' ');
+ if (!sp)
+ {
+ return 0;
+ }
+ /* Skip width label */
+ sp++;
+ sp = strchr (sp, ' ');
+ if (!sp)
+ {
+ return 0;
+ }
+ /* Get width */
+ w = atoi (sp + 1);
+ if (!w)
+ {
+ return 0;
+ }
+ if (!fgets (s, 160, fd))
+ {
+ return 0;
+ }
+ sp = s;
+ /* Skip #define */
+ sp = strchr (sp, ' ');
+ if (!sp)
+ {
+ return 0;
+ }
+ /* Skip height label */
+ sp++;
+ sp = strchr (sp, ' ');
+ if (!sp)
+ {
+ return 0;
+ }
+ /* Get height */
+ h = atoi (sp + 1);
+ if (!h)
+ {
+ return 0;
+ }
+ /* Skip declaration line */
+ if (!fgets (s, 160, fd))
+ {
+ return 0;
+ }
+ bytes = (w * h / 8) + 1;
+ im = gdImageCreate (w, h);
+ gdImageColorAllocate (im, 255, 255, 255);
+ gdImageColorAllocate (im, 0, 0, 0);
+ x = 0;
+ y = 0;
+ for (i = 0; (i < bytes); i++)
+ {
+ char h[3];
+ int b;
+ /* Skip spaces, commas, CRs, 0x */
+ while (1)
+ {
+ ch = getc (fd);
+ if (ch == EOF)
+ {
+ goto fail;
+ }
+ if (ch == 'x')
+ {
+ break;
+ }
+ }
+ /* Get hex value */
+ ch = getc (fd);
+ if (ch == EOF)
+ {
+ goto fail;
+ }
+ h[0] = ch;
+ ch = getc (fd);
+ if (ch == EOF)
+ {
+ goto fail;
+ }
+ h[1] = ch;
+ h[2] = '\0';
+ sscanf (h, "%x", &b);
+ for (bit = 1; (bit <= 128); (bit = bit << 1))
+ {
+ gdImageSetPixel (im, x++, y, (b & bit) ? 1 : 0);
+ if (x == im->sx)
+ {
+ x = 0;
+ y++;
+ if (y == im->sy)
+ {
+ return im;
+ }
+ /* Fix 8/8/95 */
+ break;
+ }
+ }
+ }
+ /* Shouldn't happen */
+ fprintf (stderr, "Error: bug in gdImageCreateFromXbm!\n");
+ return 0;
+fail:
+ gdImageDestroy (im);
+ return 0;
+}
+
+void
+gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
+{
+ int i;
+ int lx, ly;
+ if (!n)
+ {
+ return;
+ }
+ lx = p->x;
+ ly = p->y;
+ gdImageLine (im, lx, ly, p[n - 1].x, p[n - 1].y, c);
+ for (i = 1; (i < n); i++)
+ {
+ p++;
+ gdImageLine (im, lx, ly, p->x, p->y, c);
+ lx = p->x;
+ ly = p->y;
+ }
+}
+
+int gdCompareInt (const void *a, const void *b);
+
+/* THANKS to Kirsten Schulz for the polygon fixes! */
+
+/* The intersection finding technique of this code could be improved */
+/* by remembering the previous intertersection, and by using the slope. */
+/* That could help to adjust intersections to produce a nice */
+/* interior_extrema. */
+
+void
+gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
+{
+ int i;
+ int y;
+ int miny, maxy;
+ int x1, y1;
+ int x2, y2;
+ int ind1, ind2;
+ int ints;
+ if (!n)
+ {
+ return;
+ }
+ if (!im->polyAllocated)
+ {
+ im->polyInts = (int *) gdMalloc (sizeof (int) * n);
+ im->polyAllocated = n;
+ }
+ if (im->polyAllocated < n)
+ {
+ while (im->polyAllocated < n)
+ {
+ im->polyAllocated *= 2;
+ }
+ im->polyInts = (int *) gdRealloc (im->polyInts,
+ sizeof (int) * im->polyAllocated);
+ }
+ miny = p[0].y;
+ maxy = p[0].y;
+ for (i = 1; (i < n); i++)
+ {
+ if (p[i].y < miny)
+ {
+ miny = p[i].y;
+ }
+ if (p[i].y > maxy)
+ {
+ maxy = p[i].y;
+ }
+ }
+ /* Fix in 1.3: count a vertex only once */
+ for (y = miny; (y <= maxy); y++)
+ {
+/*1.4 int interLast = 0; */
+/* int dirLast = 0; */
+/* int interFirst = 1; */
+ ints = 0;
+ for (i = 0; (i < n); i++)
+ {
+ if (!i)
+ {
+ ind1 = n - 1;
+ ind2 = 0;
+ }
+ else
+ {
+ ind1 = i - 1;
+ ind2 = i;
+ }
+ y1 = p[ind1].y;
+ y2 = p[ind2].y;
+ if (y1 < y2)
+ {
+ x1 = p[ind1].x;
+ x2 = p[ind2].x;
+ }
+ else if (y1 > y2)
+ {
+ y2 = p[ind1].y;
+ y1 = p[ind2].y;
+ x2 = p[ind1].x;
+ x1 = p[ind2].x;
+ }
+ else
+ {
+ continue;
+ }
+ if ((y >= y1) && (y < y2))
+ {
+ im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
+ }
+ else if ((y == maxy) && (y > y1) && (y <= y2))
+ {
+ im->polyInts[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;
+ }
+ }
+ qsort (im->polyInts, ints, sizeof (int), gdCompareInt);
+
+ for (i = 0; (i < (ints)); i += 2)
+ {
+ gdImageLine (im, im->polyInts[i], y,
+ im->polyInts[i + 1], y, c);
+ }
+ }
+}
+
+int
+gdCompareInt (const void *a, const void *b)
+{
+ return (*(const int *) a) - (*(const int *) b);
+}
+
+void
+gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
+{
+ if (im->style)
+ {
+ gdFree (im->style);
+ }
+ im->style = (int *)
+ gdMalloc (sizeof (int) * noOfPixels);
+ memcpy (im->style, style, sizeof (int) * noOfPixels);
+ im->styleLength = noOfPixels;
+ im->stylePos = 0;
+}
+
+void
+gdImageSetThickness (gdImagePtr im, int thickness)
+{
+ im->thick = thickness;
+}
+
+void
+gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
+{
+ int i;
+ im->brush = brush;
+ if ((!im->trueColor) && (!im->brush->trueColor))
+ {
+ for (i = 0; (i < gdImageColorsTotal (brush)); i++)
+ {
+ int index;
+ index = gdImageColorResolveAlpha (im,
+ gdImageRed (brush, i),
+ gdImageGreen (brush, i),
+ gdImageBlue (brush, i),
+ gdImageAlpha (brush, i));
+ im->brushColorMap[i] = index;
+ }
+ }
+}
+
+void
+gdImageSetTile (gdImagePtr im, gdImagePtr tile)
+{
+ int i;
+ im->tile = tile;
+ if ((!im->trueColor) && (!im->tile->trueColor))
+ {
+ for (i = 0; (i < gdImageColorsTotal (tile)); i++)
+ {
+ int index;
+ index = gdImageColorResolveAlpha (im,
+ gdImageRed (tile, i),
+ gdImageGreen (tile, i),
+ gdImageBlue (tile, i),
+ gdImageAlpha (tile, i));
+ im->tileColorMap[i] = index;
+ }
+ }
+}
+
+void
+gdImageInterlace (gdImagePtr im, int interlaceArg)
+{
+ im->interlace = interlaceArg;
+}
+
+int
+gdImageCompare (gdImagePtr im1, gdImagePtr im2)
+{
+ int x, y;
+ int p1, p2;
+ int cmpStatus = 0;
+ int sx, sy;
+
+ if (im1->interlace != im2->interlace)
+ {
+ cmpStatus |= GD_CMP_INTERLACE;
+ }
+
+ if (im1->transparent != im2->transparent)
+ {
+ cmpStatus |= GD_CMP_TRANSPARENT;
+ }
+
+ if (im1->trueColor != im2->trueColor)
+ {
+ cmpStatus |= GD_CMP_TRUECOLOR;
+ }
+
+ sx = im1->sx;
+ if (im1->sx != im2->sx)
+ {
+ cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE;
+ if (im2->sx < im1->sx)
+ {
+ sx = im2->sx;
+ }
+ }
+
+ sy = im1->sy;
+ if (im1->sy != im2->sy)
+ {
+ cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE;
+ if (im2->sy < im1->sy)
+ {
+ sy = im2->sy;
+ }
+ }
+
+ if (im1->colorsTotal != im2->colorsTotal)
+ {
+ cmpStatus |= GD_CMP_NUM_COLORS;
+ }
+
+ for (y = 0; (y < sy); y++)
+ {
+ for (x = 0; (x < sx); x++)
+ {
+ p1 = im1->pixels[y][x];
+ p2 = im2->pixels[y][x];
+ if (gdImageRed (im1, p1) != gdImageRed (im2, p2))
+ {
+ cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+ break;
+ }
+ if (gdImageGreen (im1, p1) != gdImageGreen (im2, p2))
+ {
+ cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+ break;
+ }
+ if (gdImageBlue (im1, p1) != gdImageBlue (im2, p2))
+ {
+ cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+ break;
+ }
+#if 0
+ /* Soon we'll add alpha channel to palettes */
+ if (gdImageAlpha (im1, p1) != gdImageAlpha (im2, p2))
+ {
+ cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
+ break;
+ }
+#endif
+ }
+ if (cmpStatus & GD_CMP_COLOR)
+ {
+ break;
+ };
+ }
+
+ return cmpStatus;
+}
+
+int
+gdAlphaBlend (int dst, int src)
+{
+ return (((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+ gdTrueColorGetRed (src) / gdAlphaMax) +
+ (gdTrueColorGetAlpha (src) *
+ gdTrueColorGetRed (dst)) / gdAlphaMax) << 16) +
+ ((((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+ gdTrueColorGetGreen (src) / gdAlphaMax) +
+ (gdTrueColorGetAlpha (src) *
+ gdTrueColorGetGreen (dst)) / gdAlphaMax) << 8) +
+ (((gdAlphaTransparent - gdTrueColorGetAlpha (src)) *
+ gdTrueColorGetBlue (src) / gdAlphaMax) +
+ (gdTrueColorGetAlpha (src) *
+ gdTrueColorGetBlue (dst)) / gdAlphaMax));
+}
+
+void
+gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
+{
+ im->alphaBlendingFlag = alphaBlendingArg;
+}
+
+void
+gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
+{
+ im->saveAlphaFlag = saveAlphaArg;
+}
--- /dev/null
+#ifndef GD_H
+#define GD_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* default fontpath for unix systems */
+#define DEFAULT_FONTPATH "/usr/share/fonts/truetype"
+#define PATHSEPARATOR ":"
+
+/* gd.h: declarations file for the graphic-draw module.
+ * 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. This software is provided "AS IS." Thomas Boutell and
+ * Boutell.Com, Inc. disclaim all warranties, either express or implied,
+ * including but not limited to implied warranties of merchantability and
+ * fitness for a particular purpose, with respect to this code and accompanying
+ * documentation. */
+
+/* stdio is needed for file I/O. */
+#include <stdio.h>
+#include "gd_io.h"
+
+/* The maximum number of palette entries in palette-based images.
+ In the wonderful new world of gd 2.0, you can of course have
+ many more colors when using truecolor mode. */
+
+#define gdMaxColors 256
+
+/* Image type. See functions below; you will not need to change
+ the elements directly. Use the provided macros to
+ access sx, sy, the color table, and colorsTotal for
+ read-only purposes. */
+
+/* If 'truecolor' is set true, the image is truecolor;
+ pixels are represented by integers, which
+ must be 32 bits wide or more.
+
+ True colors are repsented as follows:
+
+ ARGB
+
+ Where 'A' (alpha channel) occupies only the
+ LOWER 7 BITS of the MSB. This very small
+ loss of alpha channel resolution allows gd 2.x
+ to keep backwards compatibility by allowing
+ signed integers to be used to represent colors,
+ and negative numbers to represent special cases,
+ just as in gd 1.x. */
+
+#define gdAlphaMax 127
+#define gdAlphaOpaque 0
+#define gdAlphaTransparent 127
+#define gdRedMax 255
+#define gdGreenMax 255
+#define gdBlueMax 255
+#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)
+#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
+#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
+#define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
+
+/* This function accepts truecolor pixel values only. The
+ source color is composited with the destination color
+ based on the alpha channel value of the source color.
+ The resulting color is opaque. */
+
+int gdAlphaBlend(int dest, int src);
+
+typedef struct gdImageStruct {
+ /* Palette-based image pixels */
+ unsigned char ** pixels;
+ int sx;
+ int sy;
+ /* These are valid in palette images only. See also
+ 'alpha', which appears later in the structure to
+ preserve binary backwards compatibility */
+ int colorsTotal;
+ int red[gdMaxColors];
+ int green[gdMaxColors];
+ int blue[gdMaxColors];
+ int open[gdMaxColors];
+ /* For backwards compatibility, this is set to the
+ first palette entry with 100% transparency,
+ and is also set and reset by the
+ gdImageColorTransparent function. Newer
+ applications can allocate palette entries
+ with any desired level of transparency; however,
+ bear in mind that many viewers, notably
+ many web browsers, fail to implement
+ full alpha channel for PNG and provide
+ support for full opacity or transparency only. */
+ int transparent;
+ int *polyInts;
+ int polyAllocated;
+ struct gdImageStruct *brush;
+ struct gdImageStruct *tile;
+ int brushColorMap[gdMaxColors];
+ int tileColorMap[gdMaxColors];
+ int styleLength;
+ int stylePos;
+ int *style;
+ int interlace;
+ /* New in 2.0: thickness of line. Initialized to 1. */
+ int thick;
+ /* New in 2.0: alpha channel for palettes. Note that only
+ Macintosh Internet Explorer and (possibly) Netscape 6
+ really support multiple levels of transparency in
+ palettes, to my knowledge, as of 2/15/01. Most
+ common browsers will display 100% opaque and
+ 100% transparent correctly, and do something
+ unpredictable and/or undesirable for levels
+ in between. TBB */
+ int alpha[gdMaxColors];
+ /* Truecolor flag and pixels. New 2.0 fields appear here at the
+ end to minimize breakage of existing object code. */
+ int trueColor;
+ int ** tpixels;
+ /* Should alpha channel be copied, or applied, each time a
+ pixel is drawn? This applies to truecolor images only.
+ No attempt is made to alpha-blend in palette images,
+ even if semitransparent palette entries exist.
+ To do that, build your image as a truecolor image,
+ then quantize down to 8 bits. */
+ int alphaBlendingFlag;
+ /* Should the alpha channel of the image be saved? This affects
+ PNG at the moment; other future formats may also
+ have that capability. JPEG doesn't. */
+ int saveAlphaFlag;
+} gdImage;
+
+typedef gdImage * gdImagePtr;
+
+typedef struct {
+ /* # of characters in font */
+ int nchars;
+ /* First character is numbered... (usually 32 = space) */
+ int offset;
+ /* Character width and height */
+ int w;
+ int h;
+ /* Font data; array of characters, one row after another.
+ Easily included in code, also easily loaded from
+ data files. */
+ char *data;
+} gdFont;
+
+/* Text functions take these. */
+typedef gdFont *gdFontPtr;
+
+/* For backwards compatibility only. Use gdImageSetStyle()
+ for MUCH more flexible line drawing. Also see
+ gdImageSetBrush(). */
+#define gdDashSize 4
+
+/* Special colors. */
+
+#define gdStyled (-2)
+#define gdBrushed (-3)
+#define gdStyledBrushed (-4)
+#define gdTiled (-5)
+
+/* NOT the same as the transparent color index.
+ This is used in line styles only. */
+#define gdTransparent (-6)
+
+/* Functions to manipulate images. */
+
+/* Creates a palette-based image (up to 256 colors). */
+gdImagePtr gdImageCreate(int sx, int sy);
+
+/* An alternate name for the above (2.0). */
+#define gdImageCreatePalette gdImageCreate
+
+/* Creates a truecolor image (millions of colors). */
+gdImagePtr gdImageCreateTrueColor(int sx, int sy);
+
+/* Creates an image from various file types. These functions
+ return a palette or truecolor image based on the
+ nature of the file being loaded. Truecolor PNG
+ stays truecolor; palette PNG stays palette-based;
+ JPEG is always truecolor. */
+gdImagePtr gdImageCreateFromPng(FILE *fd);
+gdImagePtr gdImageCreateFromPngCtx(gdIOCtxPtr in);
+gdImagePtr gdImageCreateFromWBMP(FILE *inFile);
+gdImagePtr gdImageCreateFromWBMPCtx(gdIOCtx *infile);
+gdImagePtr gdImageCreateFromJpeg(FILE *infile);
+gdImagePtr gdImageCreateFromJpegCtx(gdIOCtx *infile);
+
+/* A custom data source. */
+/* The source function must return -1 on error, otherwise the number
+ of bytes fetched. 0 is EOF, not an error! */
+/* context will be passed to your source function. */
+
+typedef struct {
+ int (*source) (void *context, char *buffer, int len);
+ void *context;
+} gdSource, *gdSourcePtr;
+
+gdImagePtr gdImageCreateFromPngSource(gdSourcePtr in);
+
+gdImagePtr gdImageCreateFromGd(FILE *in);
+gdImagePtr gdImageCreateFromGdCtx(gdIOCtxPtr in);
+
+gdImagePtr gdImageCreateFromGd2(FILE *in);
+gdImagePtr gdImageCreateFromGd2Ctx(gdIOCtxPtr in);
+
+gdImagePtr gdImageCreateFromGd2Part(FILE *in, int srcx, int srcy, int w, int h);
+gdImagePtr gdImageCreateFromGd2PartCtx(gdIOCtxPtr in, int srcx, int srcy, int w, int h);
+
+gdImagePtr gdImageCreateFromXbm(FILE *fd);
+
+void gdImageDestroy(gdImagePtr im);
+
+/* Replaces or blends with the background depending on the
+ most recent call to gdImageAlphaBlending and the
+ alpha channel value of 'color'; default is to overwrite.
+ Tiling and line styling are also implemented
+ here. All other gd drawing functions pass through this call,
+ allowing for many useful effects. */
+
+void gdImageSetPixel(gdImagePtr im, int x, int y, int color);
+
+int gdImageGetPixel(gdImagePtr im, int x, int y);
+
+void gdImageLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+
+/* For backwards compatibility only. Use gdImageSetStyle()
+ for much more flexible line drawing. */
+void gdImageDashedLine(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+/* Corners specified (not width and height). Upper left first, lower right
+ second. */
+void gdImageRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+/* Solid bar. Upper left corner first, lower right corner second. */
+void gdImageFilledRectangle(gdImagePtr im, int x1, int y1, int x2, int y2, int color);
+int gdImageBoundsSafe(gdImagePtr im, int x, int y);
+void gdImageChar(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
+void gdImageCharUp(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color);
+void gdImageString(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
+void gdImageStringUp(gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color);
+void gdImageString16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
+void gdImageStringUp16(gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color);
+
+/* Calls gdImageStringFT. Provided for backwards compatibility only. */
+char *gdImageStringTTF(gdImage *im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y, char *string);
+
+/* FreeType 2 text output */
+char *gdImageStringFT(gdImage *im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y, char *string);
+
+/* Point type for use in polygon drawing. */
+typedef struct {
+ int x, y;
+} gdPoint, *gdPointPtr;
+
+void gdImagePolygon(gdImagePtr im, gdPointPtr p, int n, int c);
+void gdImageFilledPolygon(gdImagePtr im, gdPointPtr p, int n, int c);
+
+/* These functions still work with truecolor images,
+ for which they never return error. */
+int gdImageColorAllocate(gdImagePtr im, int r, int g, int b);
+/* gd 2.0: palette entries with non-opaque transparency are permitted. */
+int gdImageColorAllocateAlpha(gdImagePtr im, int r, int g, int b, int a);
+/* Assumes opaque is the preferred alpha channel value */
+int gdImageColorClosest(gdImagePtr im, int r, int g, int b);
+/* Closest match taking all four parameters into account.
+ A slightly different color with the same transparency
+ beats the exact same color with radically different
+ transparency */
+int gdImageColorClosestAlpha(gdImagePtr im, int r, int g, int b, int a);
+/* Returns exact, 100% opaque matches only */
+int gdImageColorExact(gdImagePtr im, int r, int g, int b);
+/* Returns an exact match only, including alpha */
+int gdImageColorExactAlpha(gdImagePtr im, int r, int g, int b, int a);
+/* Opaque only */
+int gdImageColorResolve(gdImagePtr im, int r, int g, int b);
+/* Based on gdImageColorExactAlpha and gdImageColorClosestAlpha */
+int gdImageColorResolveAlpha(gdImagePtr im, int r, int g, int b, int a);
+
+/* A simpler way to obtain an opaque truecolor value for drawing on a
+ truecolor image. Not for use with palette images! */
+
+#define gdTrueColor(r, g, b) (((r) << 16) + \
+ ((g) << 8) + \
+ (b))
+
+/* Returns a truecolor value with an alpha channel component.
+ gdAlphaMax (127, **NOT 255**) is transparent, 0 is completely
+ opaque. */
+
+#define gdTrueColorAlpha(r, g, b, a) (((a) << 24) + \
+ ((r) << 16) + \
+ ((g) << 8) + \
+ (b))
+
+void gdImageColorDeallocate(gdImagePtr im, int color);
+
+/* Converts a truecolor image to a palette-based image,
+ using a high-quality two-pass quantization routine
+ which attempts to preserve alpha channel information
+ as well as R/G/B color information when creating
+ a palette. If ditherFlag is set, the image will be
+ dithered to approximate colors better, at the expense
+ of some obvious "speckling." colorsWanted can be
+ anything up to 256. If the original source image
+ includes photographic information or anything that
+ came out of a JPEG, 256 is strongly recommended.
+
+ Better yet, don't use this function -- write real
+ truecolor PNGs and JPEGs. The disk space gain of
+ conversion to palette is not great (for small images
+ it can be negative) and the quality loss is ugly. */
+
+void gdImageTrueColorToPalette(gdImagePtr im, int ditherFlag, int colorsWanted);
+
+/* Specifies a color index (if a palette image) or an
+ RGB color (if a truecolor image) which should be
+ considered 100% transparent. FOR TRUECOLOR IMAGES,
+ THIS IS IGNORED IF AN ALPHA CHANNEL IS BEING
+ SAVED. Use gdImageSaveAlpha(im, 0); to
+ turn off the saving of a full alpha channel in
+ a truecolor image. Note that gdImageColorTransparent
+ is usually compatible with older browsers that
+ do not understand full alpha channels well. TBB */
+void gdImageColorTransparent(gdImagePtr im, int color);
+
+void gdImagePaletteCopy(gdImagePtr dst, gdImagePtr src);
+void gdImagePng(gdImagePtr im, FILE *out);
+void gdImagePngCtx(gdImagePtr im, gdIOCtx *out);
+
+void gdImageWBMP(gdImagePtr image, int fg, FILE *out);
+void gdImageWBMPCtx(gdImagePtr image, int fg, gdIOCtx *out);
+
+/* Guaranteed to correctly free memory returned
+ by the gdImage*Ptr functions */
+void gdFree(void *m);
+
+/* Best to free this memory with gdFree(), not free() */
+void *gdImageWBMPPtr(gdImagePtr im, int *size, int fg);
+
+void gdImageJpeg(gdImagePtr im, FILE *out, int quality);
+void gdImageJpegCtx(gdImagePtr im, gdIOCtx *out, int quality);
+
+/* Best to free this memory with gdFree(), not free() */
+void *gdImageJpegPtr(gdImagePtr im, int *size, int quality);
+
+/* A custom data sink. For backwards compatibility. Use
+ gdIOCtx instead. */
+/* The sink function must return -1 on error, otherwise the number
+ of bytes written, which must be equal to len. */
+/* context will be passed to your sink function. */
+typedef struct {
+ int (*sink) (void *context, const char *buffer, int len);
+ void *context;
+} gdSink, *gdSinkPtr;
+
+void gdImagePngToSink(gdImagePtr im, gdSinkPtr out);
+
+void gdImageGd(gdImagePtr im, FILE *out);
+void gdImageGd2(gdImagePtr im, FILE *out, int cs, int fmt);
+
+/* Best to free this memory with gdFree(), not free() */
+void* gdImagePngPtr(gdImagePtr im, int *size);
+
+/* Best to free this memory with gdFree(), not free() */
+void* gdImageGdPtr(gdImagePtr im, int *size);
+
+/* Best to free this memory with gdFree(), not free() */
+void* gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size);
+
+void gdImageEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
+
+/* Style is a bitwise OR ( | operator ) of these.
+ gdArc and gdChord are mutually exclusive;
+ gdChord just connects the starting and ending
+ angles with a straight line, while gdArc produces
+ a rounded edge. gdPie is a synonym for gdArc.
+ gdNoFill indicates that the arc or chord should be
+ outlined, not filled. gdEdged, used together with
+ gdNoFill, indicates that the beginning and ending
+ angles should be connected to the center; this is
+ a good way to outline (rather than fill) a
+ 'pie slice'. */
+#define gdArc 0
+#define gdPie gdArc
+#define gdChord 1
+#define gdNoFill 2
+#define gdEdged 4
+
+void gdImageFilledArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style);
+void gdImageArc(gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color);
+void gdImageFilledEllipse(gdImagePtr im, int cx, int cy, int w, int h, int color);
+void gdImageFillToBorder(gdImagePtr im, int x, int y, int border, int color);
+void gdImageFill(gdImagePtr im, int x, int y, int color);
+void gdImageCopy(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h);
+void gdImageCopyMerge(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
+ int srcX, int srcY, int w, int h, int pct);
+void gdImageCopyMergeGray(gdImagePtr dst, gdImagePtr src, int dstX, int dstY,
+ int srcX, int srcY, int w, int h, int pct);
+
+/* Stretches or shrinks to fit, as needed. Does NOT attempt
+ to average the entire set of source pixels that scale down onto the
+ destination pixel. */
+void gdImageCopyResized(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);
+
+/* gd 2.0: stretches or shrinks to fit, as needed. When called with a
+ truecolor destination image, this function averages the
+ entire set of source pixels that scale down onto the
+ destination pixel, taking into account what portion of the
+ destination pixel each source pixel represents. This is a
+ floating point operation, but this is not a performance issue
+ on modern hardware, except for some embedded devices. If the
+ destination is a palette image, gdImageCopyResized is
+ substituted automatically. */
+void gdImageCopyResampled(gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH);
+
+void gdImageSetBrush(gdImagePtr im, gdImagePtr brush);
+void gdImageSetTile(gdImagePtr im, gdImagePtr tile);
+void gdImageSetStyle(gdImagePtr im, int *style, int noOfPixels);
+/* Line thickness (defaults to 1). Affects lines, ellipses,
+ rectangles, polygons and so forth. */
+void gdImageSetThickness(gdImagePtr im, int thickness);
+/* On or off (1 or 0) for all three of these. */
+void gdImageInterlace(gdImagePtr im, int interlaceArg);
+void gdImageAlphaBlending(gdImagePtr im, int alphaBlendingArg);
+void gdImageSaveAlpha(gdImagePtr im, int saveAlphaArg);
+
+/* Macros to access information about images. */
+
+/* Returns nonzero if the image is a truecolor image,
+ zero for a palette image. */
+
+#define gdImageTrueColor(im) ((im)->trueColor)
+
+#define gdImageSX(im) ((im)->sx)
+#define gdImageSY(im) ((im)->sy)
+#define gdImageColorsTotal(im) ((im)->colorsTotal)
+#define gdImageRed(im, c) ((im)->trueColor ? gdTrueColorGetRed(c) : \
+ (im)->red[(c)])
+#define gdImageGreen(im, c) ((im)->trueColor ? gdTrueColorGetGreen(c) : \
+ (im)->green[(c)])
+#define gdImageBlue(im, c) ((im)->trueColor ? gdTrueColorGetBlue(c) : \
+ (im)->blue[(c)])
+#define gdImageAlpha(im, c) ((im)->trueColor ? gdTrueColorGetAlpha(c) : \
+ (im)->alpha[(c)])
+#define gdImageGetTransparent(im) ((im)->transparent)
+#define gdImageGetInterlaced(im) ((im)->interlace)
+
+/* These macros provide direct access to pixels in
+ palette-based and truecolor images, respectively.
+ If you use these macros, you must perform your own
+ bounds checking. Use of the macro for the correct type
+ of image is also your responsibility. */
+#define gdImagePalettePixel(im, x, y) (im)->pixels[(y)][(x)]
+#define gdImageTrueColorPixel(im, x, y) (im)->tpixels[(y)][(x)]
+
+/* I/O Support routines. */
+
+gdIOCtx* gdNewFileCtx(FILE*);
+gdIOCtx* gdNewDynamicCtx(int, void*);
+gdIOCtx* gdNewSSCtx(gdSourcePtr in, gdSinkPtr out);
+void* gdDPExtractData(struct gdIOCtx* ctx, int *size);
+
+#define GD2_CHUNKSIZE 128
+#define GD2_CHUNKSIZE_MIN 64
+#define GD2_CHUNKSIZE_MAX 4096
+
+#define GD2_VERS 2
+#define GD2_ID "gd2"
+#define GD2_FMT_RAW 1
+#define GD2_FMT_COMPRESSED 2
+
+/* Image comparison definitions */
+int gdImageCompare(gdImagePtr im1, gdImagePtr im2);
+
+#define GD_CMP_IMAGE 1 /* Actual image IS different */
+#define GD_CMP_NUM_COLORS 2 /* Number of Colours in pallette differ */
+#define GD_CMP_COLOR 4 /* Image colours differ */
+#define GD_CMP_SIZE_X 8 /* Image width differs */
+#define GD_CMP_SIZE_Y 16 /* Image heights differ */
+#define GD_CMP_TRANSPARENT 32 /* Transparent colour */
+#define GD_CMP_BACKGROUND 64 /* Background colour */
+#define GD_CMP_INTERLACE 128 /* Interlaced setting */
+#define GD_CMP_TRUECOLOR 256 /* Truecolor vs palette differs */
+
+/* resolution affects ttf font rendering, particularly hinting */
+#define GD_RESOLUTION 96 /* pixels per inch */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GD_H */
--- /dev/null
+
+#include <stdio.h>
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ gdImagePtr pal;
+ FILE *in, *out;
+ if (argc != 3)
+ {
+ fprintf (stderr, "Usage: gd2copypal palettefile.gd2 filename.gd2\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Palette file does not exist!\n");
+ exit (1);
+ }
+ pal = gdImageCreateFromGd2 (in);
+ fclose (in);
+ if (!pal)
+ {
+ fprintf (stderr, "Palette is not in GD2 format!\n");
+ exit (1);
+ }
+
+ in = fopen (argv[2], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromGd2 (in);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in GD2 format!\n");
+ exit (1);
+ }
+
+ gdImagePaletteCopy (im, pal);
+
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ gdImageGd2 (im, out, 128, 2);
+ fclose (out);
+ gdImageDestroy (pal);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h> /* for atoi */
+#include <time.h> /* For time */
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in;
+ int x, y, w, h;
+ int c;
+ int i;
+ int t0;
+
+ if (argc != 7)
+ {
+ fprintf (stderr, "Usage: gd2time filename.gd count x y w h\n");
+ exit (1);
+ }
+
+ c = atoi (argv[2]);
+ x = atoi (argv[3]);
+ y = atoi (argv[4]);
+ w = atoi (argv[5]);
+ h = atoi (argv[6]);
+
+ printf ("Extracting %d times from (%d, %d), size is %dx%d\n", c, x, y, w, h);
+
+ t0 = time (0);
+ for (i = 0; i < c; i++)
+ {
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+
+ im = gdImageCreateFromGd2Part (in, x, y, w, h);
+ fclose (in);
+
+ if (!im)
+ {
+ fprintf (stderr, "Error reading source file!\n");
+ exit (1);
+ }
+ gdImageDestroy (im);
+ };
+ t0 = time (0) - t0;
+ printf ("%d seconds to extract (& destroy) %d times\n", t0, c);
+
+ return 0;
+}
--- /dev/null
+
+#include <stdio.h>
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in, *out;
+ if (argc != 3)
+ {
+ fprintf (stderr, "Usage: gd2topng filename.gd2 filename.png\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromGd2 (in);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in GD2 format!\n");
+ exit (1);
+ }
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ gdImagePng (im, out);
+ fclose (out);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+/* This is potentially great stuff, but fails against the test
+ program at the end. This would probably be much more
+ efficent than the implementation currently in gd.c if the
+ errors in the output were corrected. TBB */
+
+#if 0
+
+#include "gd.h"
+#include <math.h>
+
+/* Courtesy of F J Franklin. */
+
+static gdPoint gdArcClosest (int width, int height, int angle);
+
+void
+gdImageFilledEllipse (gdImagePtr im, int cx, int cy, int width, int height, int color)
+{
+ gdImageFilledArc (im, cx, cy, width, height, 0, 360, color, gdChord);
+}
+
+void
+gdImageFilledArc (gdImagePtr im, int cx, int cy, int width, int height, int s, int e, int color, int style)
+{
+ gdPoint pt[7];
+ gdPoint axis_pt[4];
+
+ int angle;
+
+ int have_s = 0;
+ int have_e = 0;
+
+ int flip_x = 0;
+ int flip_y = 0;
+
+ int conquer = 0;
+
+ int i;
+
+ int a;
+ int b;
+
+ int x;
+ int y;
+
+ long s_sin = 0;
+ long s_cos = 0;
+ long e_sin = 0;
+ long e_cos = 0;
+
+ long w; /* a * 2 */
+ long h; /* b * 2 */
+
+ long x2; /* x * 2 */
+ long y2; /* y * 2 */
+ long lx2; /* x * 2 (line) */
+ long ly2; /* y * 2 (line) */
+
+ long ws; /* (a * 2)^2 */
+ long hs; /* (b * 2)^2 */
+
+ long whs; /* (a * 2)^2 * (b * 2)^2 */
+
+ long g; /* decision variable */
+ long lg; /* decision variable (line) */
+
+ width = (width & 1) ? (width + 1) : (width);
+ height = (height & 1) ? (height + 1) : (height);
+
+ a = width / 2;
+ b = height / 2;
+
+ axis_pt[0].x = a;
+ axis_pt[0].y = 0;
+ axis_pt[1].x = 0;
+ axis_pt[1].y = b;
+ axis_pt[2].x = -a;
+ axis_pt[2].y = 0;
+ axis_pt[3].x = 0;
+ axis_pt[3].y = -b;
+
+ if (s == e)
+ return;
+
+ if ((e - s) >= 360)
+ {
+ s = 0;
+ e = 0;
+ }
+
+ while (s < 0)
+ s += 360;
+ while (s >= 360)
+ s -= 360;
+ while (e < 0)
+ e += 360;
+ while (e >= 360)
+ e -= 360;
+
+ if (e <= s)
+ e += 360;
+
+ /* I'm assuming a chord-rule at the moment. Need to add origin to get a
+ * pie-rule, but will need to set chord-rule before recursion...
+ */
+
+ for (i = 0; i < 4; i++)
+ {
+ if ((s < (i + 1) * 90) && (e > (i + 1) * 90))
+ {
+ gdImageFilledArc (im, cx, cy, width, height, s, (i + 1) * 90, color, gdChord);
+ pt[0] = gdArcClosest (width, height, s);
+ pt[0].x += cx;
+ pt[0].y += cy;
+ pt[1].x = cx + axis_pt[(i + 1) & 3].x;
+ pt[1].y = cy + axis_pt[(i + 1) & 3].y;
+ if (e <= (i + 2) * 90)
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 1) * 90, e, color, gdChord);
+ pt[2] = gdArcClosest (width, height, e);
+ pt[2].x += cx;
+ pt[2].y += cy;
+ if (style == gdChord)
+ {
+ gdImageFilledPolygon (im, pt, 3, color);
+ gdImagePolygon (im, pt, 3, color);
+ }
+ else if (style == gdPie)
+ {
+ pt[3].x = cx;
+ pt[3].y = cy;
+ gdImageFilledPolygon (im, pt, 4, color);
+ gdImagePolygon (im, pt, 4, color);
+ }
+ }
+ else
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 1) * 90, (i + 2) * 90, color, gdChord);
+ pt[2].x = cx + axis_pt[(i + 2) & 3].x;
+ pt[2].y = cy + axis_pt[(i + 2) & 3].y;
+ if (e <= (i + 3) * 90)
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 2) * 90, e, color, gdChord);
+ pt[3] = gdArcClosest (width, height, e);
+ pt[3].x += cx;
+ pt[3].y += cy;
+ if (style == gdChord)
+ {
+ gdImageFilledPolygon (im, pt, 4, color);
+ gdImagePolygon (im, pt, 4, color);
+ }
+ else if (style == gdPie)
+ {
+ pt[4].x = cx;
+ pt[4].y = cy;
+ gdImageFilledPolygon (im, pt, 5, color);
+ gdImagePolygon (im, pt, 5, color);
+ }
+ }
+ else
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 2) * 90, (i + 3) * 90, color, gdChord);
+ pt[3].x = cx + axis_pt[(i + 3) & 3].x;
+ pt[3].y = cy + axis_pt[(i + 3) & 3].y;
+ if (e <= (i + 4) * 90)
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 3) * 90, e, color, gdChord);
+ pt[4] = gdArcClosest (width, height, e);
+ pt[4].x += cx;
+ pt[4].y += cy;
+ if (style == gdChord)
+ {
+ gdImageFilledPolygon (im, pt, 5, color);
+ gdImagePolygon (im, pt, 5, color);
+ }
+ else if (style == gdPie)
+ {
+ pt[5].x = cx;
+ pt[5].y = cy;
+ gdImageFilledPolygon (im, pt, 6, color);
+ gdImagePolygon (im, pt, 6, color);
+ }
+ }
+ else
+ {
+ gdImageFilledArc (im, cx, cy, width, height, (i + 3) * 90, (i + 4) * 90, color, gdChord);
+ pt[4].x = cx + axis_pt[(i + 4) & 3].x;
+ pt[4].y = cy + axis_pt[(i + 4) & 3].y;
+
+ gdImageFilledArc (im, cx, cy, width, height, (i + 4) * 90, e, color, gdChord);
+ pt[5] = gdArcClosest (width, height, e);
+ pt[5].x += cx;
+ pt[5].y += cy;
+ if (style == gdChord)
+ {
+ gdImageFilledPolygon (im, pt, 6, color);
+ gdImagePolygon (im, pt, 6, color);
+ }
+ else if (style == gdPie)
+ {
+ pt[6].x = cx;
+ pt[6].y = cy;
+ gdImageFilledPolygon (im, pt, 7, color);
+ gdImagePolygon (im, pt, 7, color);
+ }
+ }
+ }
+ }
+ return;
+ }
+ }
+
+ /* At this point we have only arcs that lies within a quadrant -
+ * map this to first quadrant...
+ */
+
+ if ((s >= 90) && (e <= 180))
+ {
+ angle = s;
+ s = 180 - e;
+ e = 180 - angle;
+ flip_x = 1;
+ }
+ if ((s >= 180) && (e <= 270))
+ {
+ s = s - 180;
+ e = e - 180;
+ flip_x = 1;
+ flip_y = 1;
+ }
+ if ((s >= 270) && (e <= 360))
+ {
+ angle = s;
+ s = 360 - e;
+ e = 360 - angle;
+ flip_y = 1;
+ }
+
+ if (s == 0)
+ {
+ s_sin = 0;
+ s_cos = (long) ((double) 32768);
+ }
+ else
+ {
+ s_sin = (long) ((double) 32768 * sin ((double) s * M_PI / (double) 180));
+ s_cos = (long) ((double) 32768 * cos ((double) s * M_PI / (double) 180));
+ }
+ if (e == 0)
+ {
+ e_sin = (long) ((double) 32768);
+ e_cos = 0;
+ }
+ else
+ {
+ e_sin = (long) ((double) 32768 * sin ((double) e * M_PI / (double) 180));
+ e_cos = (long) ((double) 32768 * cos ((double) e * M_PI / (double) 180));
+ }
+
+ w = (long) width;
+ h = (long) height;
+
+ ws = w * w;
+ hs = h * h;
+
+ whs = 1;
+ while ((ws > 32768) || (hs > 32768))
+ {
+ ws = (ws + 1) / 2; /* Unfortunate limitations on integers makes */
+ hs = (hs + 1) / 2; /* drawing large ellipses problematic... */
+ whs *= 2;
+ }
+ while ((ws * hs) > (0x04000000L / whs))
+ {
+ ws = (ws + 1) / 2;
+ hs = (hs + 1) / 2;
+ whs *= 2;
+ }
+ whs *= ws * hs;
+
+ pt[0].x = w / 2;
+ pt[0].y = 0;
+
+ pt[2].x = 0;
+ pt[2].y = h / 2;
+
+ have_s = 0;
+ have_e = 0;
+
+ if (s == 0)
+ have_s = 1;
+ if (e == 90)
+ have_e = 1;
+
+ x2 = w;
+ y2 = 0; /* Starting point is exactly on ellipse */
+
+ g = x2 - 1;
+ g = g * g * hs + 4 * ws - whs;
+
+ while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
+ {
+ y2 += 2;
+ g += ws * 4 * (y2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ x2 -= 2;
+ g -= hs * 4 * x2;
+ }
+
+ if ((have_s == 0) && ((s_sin * x2) <= (y2 * s_cos)))
+ {
+ pt[0].x = (int) (x2 / 2);
+ pt[0].y = (int) (y2 / 2);
+ have_s = 1;
+ }
+
+ if ((have_e == 0) && ((e_sin * x2) <= (y2 * e_cos)))
+ {
+ pt[2].x = (int) (x2 / 2);
+ pt[2].y = (int) (y2 / 2);
+ have_e = 1;
+ }
+ }
+ pt[1].x = (int) (x2 / 2);
+ pt[1].y = (int) (y2 / 2);
+
+ x2 = 0;
+ y2 = h; /* Starting point is exactly on ellipse */
+
+ g = y2 - 1;
+ g = g * g * ws + 4 * hs - whs;
+
+ while ((x2 * hs) < (y2 * ws))
+ {
+ x2 += 2;
+ g += hs * 4 * (x2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ y2 -= 2;
+ g -= ws * 4 * y2;
+ }
+
+ if ((have_s == 0) && ((s_sin * x2) >= (y2 * s_cos)))
+ {
+ pt[0].x = (int) (x2 / 2);
+ pt[0].y = (int) (y2 / 2);
+ have_s = 1;
+ }
+
+ if ((have_e == 0) && ((e_sin * x2) >= (y2 * e_cos)))
+ {
+ pt[2].x = (int) (x2 / 2);
+ pt[2].y = (int) (y2 / 2);
+ have_e = 1;
+ }
+ }
+
+ if ((have_s == 0) || (have_e == 0))
+ return; /* Bizarre case */
+
+ if (style == gdPie)
+ {
+ pt[3] = pt[0];
+ pt[4] = pt[1];
+ pt[5] = pt[2];
+
+ pt[0].x = cx + (flip_x ? (-pt[0].x) : pt[0].x);
+ pt[0].y = cy + (flip_y ? (-pt[0].y) : pt[0].y);
+ pt[1].x = cx;
+ pt[1].y = cy;
+ pt[2].x = cx + (flip_x ? (-pt[2].x) : pt[2].x);
+ pt[2].y = cy + (flip_y ? (-pt[2].y) : pt[2].y);
+ gdImageFilledPolygon (im, pt, 3, color);
+ gdImagePolygon (im, pt, 3, color);
+
+ pt[0] = pt[3];
+ pt[1] = pt[4];
+ pt[2] = pt[5];
+ }
+
+ if (((s_cos * hs) > (s_sin * ws)) && ((e_cos * hs) < (e_sin * ws)))
+ { /* the points are on different parts of the curve...
+ * this is too tricky to try to handle, so divide and conquer:
+ */
+ pt[3] = pt[0];
+ pt[4] = pt[1];
+ pt[5] = pt[2];
+
+ pt[0].x = cx + (flip_x ? (-pt[0].x) : pt[0].x);
+ pt[0].y = cy + (flip_y ? (-pt[0].y) : pt[0].y);
+ pt[1].x = cx + (flip_x ? (-pt[1].x) : pt[1].x);
+ pt[1].y = cy + (flip_y ? (-pt[1].y) : pt[1].y);
+ pt[2].x = cx + (flip_x ? (-pt[2].x) : pt[2].x);
+ pt[2].y = cy + (flip_y ? (-pt[2].y) : pt[2].y);
+ gdImageFilledPolygon (im, pt, 3, color);
+ gdImagePolygon (im, pt, 3, color);
+
+ pt[0] = pt[3];
+ pt[2] = pt[4];
+
+ conquer = 1;
+ }
+
+ if (conquer || (((s_cos * hs) > (s_sin * ws)) && ((e_cos * hs) > (e_sin * ws))))
+ { /* This is the best bit... */
+ /* steep line + ellipse */
+ /* go up & left from pt[0] to pt[2] */
+
+ x2 = w;
+ y2 = 0; /* Starting point is exactly on ellipse */
+
+ g = x2 - 1;
+ g = g * g * hs + 4 * ws - whs;
+
+ while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
+ {
+ if ((s_sin * x2) <= (y2 * s_cos))
+ break;
+
+ y2 += 2;
+ g += ws * 4 * (y2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ x2 -= 2;
+ g -= hs * 4 * x2;
+ }
+ }
+
+ lx2 = x2;
+ ly2 = y2;
+
+ lg = lx2 * (pt[0].y - pt[2].y) - ly2 * (pt[0].x - pt[2].x);
+ lg = (lx2 - 1) * (pt[0].y - pt[2].y) - (ly2 + 2) * (pt[0].x - pt[2].x) - lg;
+
+ while (y2 < (2 * pt[2].y))
+ {
+ y2 += 2;
+ g += ws * 4 * (y2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ x2 -= 2;
+ g -= hs * 4 * x2;
+ }
+
+ ly2 += 2;
+ lg -= 2 * (pt[0].x - pt[2].x);
+
+ if (lg < 0) /* Need to drop */
+ {
+ lx2 -= 2;
+ lg -= 2 * (pt[0].y - pt[2].y);
+ }
+
+ y = (int) (y2 / 2);
+ for (x = (int) (lx2 / 2); x <= (int) (x2 / 2); x++)
+ {
+ gdImageSetPixel (im, ((flip_x) ? (cx - x) : (cx + x)),
+ ((flip_y) ? (cy - y) : (cy + y)), color);
+ }
+ }
+ }
+ if (conquer)
+ {
+ pt[0] = pt[4];
+ pt[2] = pt[5];
+ }
+ if (conquer || (((s_cos * hs) < (s_sin * ws)) && ((e_cos * hs) < (e_sin * ws))))
+ { /* This is the best bit... */
+ /* gradual line + ellipse */
+ /* go down & right from pt[2] to pt[0] */
+
+ x2 = 0;
+ y2 = h; /* Starting point is exactly on ellipse */
+
+ g = y2 - 1;
+ g = g * g * ws + 4 * hs - whs;
+
+ while ((x2 * hs) < (y2 * ws))
+ {
+ x2 += 2;
+ g += hs * 4 * (x2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ y2 -= 2;
+ g -= ws * 4 * y2;
+ }
+
+ if ((e_sin * x2) >= (y2 * e_cos))
+ break;
+ }
+
+ lx2 = x2;
+ ly2 = y2;
+
+ lg = lx2 * (pt[0].y - pt[2].y) - ly2 * (pt[0].x - pt[2].x);
+ lg = (lx2 + 2) * (pt[0].y - pt[2].y) - (ly2 - 1) * (pt[0].x - pt[2].x) - lg;
+
+ while (x2 < (2 * pt[0].x))
+ {
+ x2 += 2;
+ g += hs * 4 * (x2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ y2 -= 2;
+ g -= ws * 4 * y2;
+ }
+
+ lx2 += 2;
+ lg += 2 * (pt[0].y - pt[2].y);
+
+ if (lg < 0) /* Need to drop */
+ {
+ ly2 -= 2;
+ lg += 2 * (pt[0].x - pt[2].x);
+ }
+
+ x = (int) (x2 / 2);
+ for (y = (int) (ly2 / 2); y <= (int) (y2 / 2); y++)
+ {
+ gdImageSetPixel (im, ((flip_x) ? (cx - x) : (cx + x)),
+ ((flip_y) ? (cy - y) : (cy + y)), color);
+ }
+ }
+ }
+}
+
+static gdPoint
+gdArcClosest (int width, int height, int angle)
+{
+ gdPoint pt;
+
+ int flip_x = 0;
+ int flip_y = 0;
+
+ long a_sin = 0;
+ long a_cos = 0;
+
+ long w; /* a * 2 */
+ long h; /* b * 2 */
+
+ long x2; /* x * 2 */
+ long y2; /* y * 2 */
+
+ long ws; /* (a * 2)^2 */
+ long hs; /* (b * 2)^2 */
+
+ long whs; /* (a * 2)^2 * (b * 2)^2 */
+
+ long g; /* decision variable */
+
+ w = (long) ((width & 1) ? (width + 1) : (width));
+ h = (long) ((height & 1) ? (height + 1) : (height));
+
+ while (angle < 0)
+ angle += 360;
+ while (angle >= 360)
+ angle -= 360;
+
+ if (angle == 0)
+ {
+ pt.x = w / 2;
+ pt.y = 0;
+ return (pt);
+ }
+ if (angle == 90)
+ {
+ pt.x = 0;
+ pt.y = h / 2;
+ return (pt);
+ }
+ if (angle == 180)
+ {
+ pt.x = -w / 2;
+ pt.y = 0;
+ return (pt);
+ }
+ if (angle == 270)
+ {
+ pt.x = 0;
+ pt.y = -h / 2;
+ return (pt);
+ }
+
+ pt.x = 0;
+ pt.y = 0;
+
+ if ((angle > 90) && (angle < 180))
+ {
+ angle = 180 - angle;
+ flip_x = 1;
+ }
+ if ((angle > 180) && (angle < 270))
+ {
+ angle = angle - 180;
+ flip_x = 1;
+ flip_y = 1;
+ }
+ if ((angle > 270) && (angle < 360))
+ {
+ angle = 360 - angle;
+ flip_y = 1;
+ }
+
+ a_sin = (long) ((double) 32768 * sin ((double) angle * M_PI / (double) 180));
+ a_cos = (long) ((double) 32768 * cos ((double) angle * M_PI / (double) 180));
+
+ ws = w * w;
+ hs = h * h;
+
+ whs = 1;
+ while ((ws > 32768) || (hs > 32768))
+ {
+ ws = (ws + 1) / 2; /* Unfortunate limitations on integers makes */
+ hs = (hs + 1) / 2; /* drawing large ellipses problematic... */
+ whs *= 2;
+ }
+ while ((ws * hs) > (0x04000000L / whs))
+ {
+ ws = (ws + 1) / 2;
+ hs = (hs + 1) / 2;
+ whs *= 2;
+ }
+ whs *= ws * hs;
+
+ if ((a_cos * hs) > (a_sin * ws))
+ {
+ x2 = w;
+ y2 = 0; /* Starting point is exactly on ellipse */
+
+ g = x2 - 1;
+ g = g * g * hs + 4 * ws - whs;
+
+ while ((x2 * hs) > (y2 * ws)) /* Keep |tangent| > 1 */
+ {
+ y2 += 2;
+ g += ws * 4 * (y2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ x2 -= 2;
+ g -= hs * 4 * x2;
+ }
+
+ if ((a_sin * x2) <= (y2 * a_cos))
+ {
+ pt.x = (int) (x2 / 2);
+ pt.y = (int) (y2 / 2);
+ break;
+ }
+ }
+ }
+ else
+ {
+ x2 = 0;
+ y2 = h; /* Starting point is exactly on ellipse */
+
+ g = y2 - 1;
+ g = g * g * ws + 4 * hs - whs;
+
+ while ((x2 * hs) < (y2 * ws))
+ {
+ x2 += 2;
+ g += hs * 4 * (x2 + 1);
+
+ if (g > 0) /* Need to drop */
+ {
+ y2 -= 2;
+ g -= ws * 4 * y2;
+ }
+
+ if ((a_sin * x2) >= (y2 * a_cos))
+ {
+ pt.x = (int) (x2 / 2);
+ pt.y = (int) (y2 / 2);
+ break;
+ }
+ }
+ }
+
+ if (flip_x)
+ pt.x = -pt.x;
+ if (flip_y)
+ pt.y = -pt.y;
+
+ return (pt);
+}
+
+#include "gd.h"
+#include <string.h>
+#include <math.h>
+
+#define WIDTH 500
+#define HEIGHT 300
+
+int
+main (int argc, char *argv[])
+{
+ gdImagePtr im = gdImageCreate (WIDTH, HEIGHT);
+ int white = gdImageColorResolve (im, 0xFF, 0xFF, 0xFF), black = gdImageColorResolve (im, 0, 0, 0),
+ red = gdImageColorResolve (im, 0xFF, 0xA0, 0xA0);
+ FILE *out;
+
+ /* filled arc - circle */
+ gdImageFilledArc (im, WIDTH / 5, HEIGHT / 4, 200, 200, 45, 90, red, gdPie);
+ gdImageArc (im, WIDTH / 5, HEIGHT / 4, 200, 200, 45, 90, black);
+
+ /* filled arc - ellipse */
+ gdImageFilledArc (im, WIDTH / 2, HEIGHT / 4, 200, 150, 45, 90, red, gdPie);
+ gdImageArc (im, WIDTH / 2, HEIGHT / 4, 200, 150, 45, 90, black);
+
+
+ /* reference lines */
+ gdImageLine (im, 0, HEIGHT / 4, WIDTH, HEIGHT / 4, black);
+ gdImageLine (im, WIDTH / 5, 0, WIDTH / 5, HEIGHT, black);
+ gdImageLine (im, WIDTH / 2, 0, WIDTH / 2, HEIGHT, black);
+ gdImageLine (im, WIDTH / 2, HEIGHT / 4, WIDTH / 2 + 300, HEIGHT / 4 + 300, black);
+ gdImageLine (im, WIDTH / 5, HEIGHT / 4, WIDTH / 5 + 300, HEIGHT / 4 + 300, black);
+
+ /* TBB: Write img to test/arctest.png */
+ out = fopen ("test/arctest.png", "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Can't create test/arctest.png\n");
+ exit (1);
+ }
+ gdImagePng (im, out);
+ fclose (out);
+ fprintf (stderr, "Test image written to test/arctest.png\n");
+ /* Destroy it */
+ gdImageDestroy (im);
+
+ return 0;
+}
+
+#endif
--- /dev/null
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/* Exported functions: */
+extern void gdImageGd (gdImagePtr im, FILE * out);
+
+
+/* Use this for commenting out debug-print statements. */
+/* Just use the first '#define' to allow all the prints... */
+/*#define GD2_DBG(s) (s) */
+#define GD2_DBG(s)
+
+/* */
+/* Shared code to read color tables from gd file. */
+/* */
+int
+_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
+{
+ int i;
+ if (gd2xFlag)
+ {
+ if (!gdGetByte (&im->trueColor, in))
+ {
+ goto fail1;
+ }
+ /* This should have been a word all along */
+ if (!im->trueColor)
+ {
+ if (!gdGetWord (&im->colorsTotal, in))
+ {
+ goto fail1;
+ }
+ }
+ /* Int to accommodate truecolor single-color transparency */
+ if (!gdGetInt (&im->transparent, in))
+ {
+ goto fail1;
+ }
+ }
+ else
+ {
+ if (!gdGetByte (&im->colorsTotal, in))
+ {
+ goto fail1;
+ }
+ if (!gdGetWord (&im->transparent, in))
+ {
+ goto fail1;
+ }
+ if (im->transparent == 257)
+ {
+ im->transparent = (-1);
+ }
+ }
+ GD2_DBG (printf ("Pallette had %d colours (T=%d)\n", im->colorsTotal, im->transparent));
+
+ for (i = 0; (i < gdMaxColors); i++)
+ {
+ if (!gdGetByte (&im->red[i], in))
+ {
+ goto fail1;
+ }
+ if (!gdGetByte (&im->green[i], in))
+ {
+ goto fail1;
+ }
+ if (!gdGetByte (&im->blue[i], in))
+ {
+ goto fail1;
+ }
+ if (gd2xFlag)
+ {
+ if (!gdGetByte (&im->alpha[i], in))
+ {
+ goto fail1;
+ }
+ }
+ }
+
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ im->open[i] = 0;
+ };
+
+ return TRUE;
+fail1:
+ return FALSE;
+}
+
+/* */
+/* Use the common basic header info to make the image object. */
+/* This is also called from _gd2CreateFromFile */
+/* */
+static
+ gdImagePtr
+_gdCreateFromFile (gdIOCtx * in, int *sx, int *sy)
+{
+ gdImagePtr im;
+ int gd2xFlag = 0;
+ if (!gdGetWord (sx, in))
+ {
+ goto fail1;
+ }
+ if (*sx == 65535)
+ {
+ /* This is a gd 2.0 .gd file */
+ gd2xFlag = 1;
+ if (!gdGetWord (sx, in))
+ {
+ goto fail1;
+ }
+ }
+ if (!gdGetWord (sy, in))
+ {
+ goto fail1;
+ }
+
+ GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
+
+ im = gdImageCreate (*sx, *sy);
+
+ if (!_gdGetColors (in, im, gd2xFlag))
+ {
+ goto fail2;
+ }
+
+ return im;
+fail2:
+ gdImageDestroy (im);
+fail1:
+ return 0;
+}
+
+gdImagePtr
+gdImageCreateFromGd (FILE * inFile)
+{
+ gdImagePtr im;
+ gdIOCtx *in;
+
+ in = gdNewFileCtx (inFile);
+ im = gdImageCreateFromGdCtx (in);
+
+ in->free (in);
+
+ return im;
+}
+
+gdImagePtr
+gdImageCreateFromGdCtx (gdIOCtxPtr in)
+{
+ int sx, sy;
+ int x, y;
+ gdImagePtr im;
+
+ /* Read the header */
+ im = _gdCreateFromFile (in, &sx, &sy);
+
+ if (im == NULL)
+ {
+ goto fail1;
+ };
+
+ /* Then the data... */
+ for (y = 0; (y < sy); y++)
+ {
+ for (x = 0; (x < sx); x++)
+ {
+ int ch;
+ ch = gdGetC (in);
+ if (ch == EOF)
+ {
+ goto fail2;
+ }
+ /* ROW-MAJOR IN GD 1.3 */
+ im->pixels[y][x] = ch;
+ }
+ }
+
+ return im;
+
+fail2:
+ gdImageDestroy (im);
+fail1:
+ return 0;
+}
+
+void
+_gdPutColors (gdImagePtr im, gdIOCtx * out)
+{
+ int i;
+ int trans;
+
+ gdPutC (im->trueColor, out);
+ if (!im->trueColor)
+ {
+ gdPutWord (im->colorsTotal, out);
+ }
+ gdPutInt (im->transparent, out);
+ if (!im->trueColor)
+ {
+ for (i = 0; (i < gdMaxColors); i++)
+ {
+ gdPutC ((unsigned char) im->red[i], out);
+ gdPutC ((unsigned char) im->green[i], out);
+ gdPutC ((unsigned char) im->blue[i], out);
+ gdPutC ((unsigned char) im->alpha[i], out);
+ }
+ }
+}
+
+static
+void
+_gdPutHeader (gdImagePtr im, gdIOCtx * out)
+{
+ /* 65535 indicates this is a gd 2.x .gd file. */
+ gdPutWord (65535, out);
+ gdPutWord (im->sx, out);
+ gdPutWord (im->sy, out);
+
+ _gdPutColors (im, out);
+
+}
+
+static void
+_gdImageGd (gdImagePtr im, gdIOCtx * out)
+{
+ int x, y;
+
+ _gdPutHeader (im, out);
+
+ for (y = 0; (y < im->sy); y++)
+ {
+ for (x = 0; (x < im->sx); x++)
+ {
+ /* ROW-MAJOR IN GD 1.3 */
+ if (im->trueColor)
+ {
+ gdPutInt (im->tpixels[y][x], out);
+ }
+ else
+ {
+ gdPutC ((unsigned char) im->pixels[y][x], out);
+ }
+ }
+ }
+}
+
+void
+gdImageGd (gdImagePtr im, FILE * outFile)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ _gdImageGd (im, out);
+ out->free (out);
+}
+
+void *
+gdImageGdPtr (gdImagePtr im, int *size)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ _gdImageGd (im, out);
+ rv = gdDPExtractData (out, size);
+ out->free (out);
+ return rv;
+}
--- /dev/null
+/*
+ * gd_gd2.c
+ *
+ * Implements the I/O and support for the GD2 format.
+ *
+ * Changing the definition of GD2_DBG (below) will cause copious messages
+ * to be displayed while it processes requests.
+ *
+ * Designed, Written & Copyright 1999, Philip Warner.
+ *
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include <zlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/* Use this for commenting out debug-print statements. */
+/* Just use the first '#define' to allow all the prints... */
+/*#define GD2_DBG(s) (s) */
+#define GD2_DBG(s)
+
+typedef struct
+ {
+ int offset;
+ int size;
+ }
+t_chunk_info;
+
+extern int _gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag);
+extern void _gdPutColors (gdImagePtr im, gdIOCtx * out);
+
+/* */
+/* Read the extra info in the gd2 header. */
+/* */
+static
+int
+_gd2GetHeader (gdIOCtxPtr in, int *sx, int *sy,
+ int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** chunkIdx)
+{
+ int i;
+ int ch;
+ char id[5];
+ t_chunk_info *cidx;
+ int sidx;
+ int nc;
+
+ GD2_DBG (printf ("Reading gd2 header info\n"));
+
+ for (i = 0; i < 4; i++)
+ {
+ ch = gdGetC (in);
+ if (ch == EOF)
+ {
+ goto fail1;
+ };
+ id[i] = ch;
+ };
+ id[4] = 0;
+
+ GD2_DBG (printf ("Got file code: %s\n", id));
+
+ /* Equiv. of 'magick'. */
+ if (strcmp (id, GD2_ID) != 0)
+ {
+ GD2_DBG (printf ("Not a valid gd2 file\n"));
+ goto fail1;
+ };
+
+ /* Version */
+ if (gdGetWord (vers, in) != 1)
+ {
+ goto fail1;
+ };
+ GD2_DBG (printf ("Version: %d\n", *vers));
+
+ if ((*vers != 1) && (*vers != 2))
+ {
+ GD2_DBG (printf ("Bad version: %d\n", *vers));
+ goto fail1;
+ };
+
+ /* Image Size */
+ if (!gdGetWord (sx, in))
+ {
+ GD2_DBG (printf ("Could not get x-size\n"));
+ goto fail1;
+ }
+ if (!gdGetWord (sy, in))
+ {
+ GD2_DBG (printf ("Could not get y-size\n"));
+ goto fail1;
+ }
+ GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
+
+ /* Chunk Size (pixels, not bytes!) */
+ if (gdGetWord (cs, in) != 1)
+ {
+ goto fail1;
+ };
+ GD2_DBG (printf ("ChunkSize: %d\n", *cs));
+
+ if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX))
+ {
+ GD2_DBG (printf ("Bad chunk size: %d\n", *cs));
+ goto fail1;
+ };
+
+ /* Data Format */
+ if (gdGetWord (fmt, in) != 1)
+ {
+ goto fail1;
+ };
+ GD2_DBG (printf ("Format: %d\n", *fmt));
+
+ if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED))
+ {
+ GD2_DBG (printf ("Bad data format: %d\n", *fmt));
+ goto fail1;
+ };
+
+
+ /* # of chunks wide */
+ if (gdGetWord (ncx, in) != 1)
+ {
+ goto fail1;
+ };
+ GD2_DBG (printf ("%d Chunks Wide\n", *ncx));
+
+ /* # of chunks high */
+ if (gdGetWord (ncy, in) != 1)
+ {
+ goto fail1;
+ };
+ GD2_DBG (printf ("%d Chunks vertically\n", *ncy));
+
+ if ((*fmt) == GD2_FMT_COMPRESSED)
+ {
+ nc = (*ncx) * (*ncy);
+ GD2_DBG (printf ("Reading %d chunk index entries\n", nc));
+ sidx = sizeof (t_chunk_info) * nc;
+ cidx = gdCalloc (sidx, 1);
+ for (i = 0; i < nc; i++)
+ {
+ if (gdGetInt (&cidx[i].offset, in) != 1)
+ {
+ goto fail1;
+ };
+ if (gdGetInt (&cidx[i].size, in) != 1)
+ {
+ goto fail1;
+ };
+ };
+ *chunkIdx = cidx;
+ };
+
+ GD2_DBG (printf ("gd2 header complete\n"));
+
+ return 1;
+
+fail1:
+ return 0;
+}
+
+static
+ gdImagePtr
+_gd2CreateFromFile (gdIOCtxPtr in, int *sx, int *sy,
+ int *cs, int *vers, int *fmt,
+ int *ncx, int *ncy, t_chunk_info ** cidx)
+{
+ gdImagePtr im;
+
+ if (_gd2GetHeader (in, sx, sy, cs, vers, fmt, ncx, ncy, cidx) != 1)
+ {
+ GD2_DBG (printf ("Bad GD2 header\n"));
+ goto fail1;
+ }
+
+ im = gdImageCreate (*sx, *sy);
+ if (im == NULL)
+ {
+ GD2_DBG (printf ("Could not create gdImage\n"));
+ goto fail1;
+ };
+
+ if (!_gdGetColors (in, im, (*vers) == 2))
+ {
+ GD2_DBG (printf ("Could not read color palette\n"));
+ goto fail2;
+ }
+ GD2_DBG (printf ("Image palette completed: %d colours\n", im->colorsTotal));
+
+ return im;
+
+fail2:
+ gdImageDestroy (im);
+ return 0;
+
+fail1:
+ return 0;
+
+}
+
+static
+int
+_gd2ReadChunk (int offset, char *compBuf, int compSize, char *chunkBuf, uLongf * chunkLen, gdIOCtx * in)
+{
+ int zerr;
+
+ if (gdTell (in) != offset)
+ {
+ GD2_DBG (printf ("Positioning in file to %d\n", offset));
+ gdSeek (in, offset);
+ }
+ else
+ {
+ GD2_DBG (printf ("Already Positioned in file to %d\n", offset));
+ };
+
+ /* Read and uncompress an entire chunk. */
+ GD2_DBG (printf ("Reading file\n"));
+ if (gdGetBuf (compBuf, compSize, in) != compSize)
+ {
+ return FALSE;
+ };
+ GD2_DBG (printf ("Got %d bytes. Uncompressing into buffer of %d bytes\n", compSize, *chunkLen));
+ zerr = uncompress ((unsigned char *) chunkBuf, chunkLen,
+ (unsigned char *) compBuf, compSize);
+ if (zerr != Z_OK)
+ {
+ GD2_DBG (printf ("Error %d from uncompress\n", zerr));
+ return FALSE;
+ };
+ GD2_DBG (printf ("Got chunk\n"));
+ return TRUE;
+}
+
+gdImagePtr
+gdImageCreateFromGd2 (FILE * inFile)
+{
+ gdIOCtx *in = gdNewFileCtx (inFile);
+ gdImagePtr im;
+
+ im = gdImageCreateFromGd2Ctx (in);
+
+ in->free (in);
+
+ return im;
+}
+
+gdImagePtr
+gdImageCreateFromGd2Ctx (gdIOCtxPtr in)
+{
+ int sx, sy;
+ int i;
+ int ncx, ncy, nc, cs, cx, cy;
+ int x, y, ylo, yhi, xlo, xhi;
+ int ch, vers, fmt;
+ t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */
+ unsigned char *chunkBuf = NULL; /* So we can gdFree it with impunity. */
+ int chunkNum = 0;
+ int chunkMax;
+ uLongf chunkLen;
+ int chunkPos;
+ int compMax;
+ int bytesPerPixel;
+ char *compBuf = NULL; /* So we can gdFree it with impunity. */
+
+ gdImagePtr im;
+
+ /* Get the header */
+ im = _gd2CreateFromFile (in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx);
+
+ if (im == NULL)
+ {
+ return 0;
+ };
+ bytesPerPixel = im->trueColor ? 4 : 1;
+ nc = ncx * ncy;
+
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ /* Find the maximum compressed chunk size. */
+ compMax = 0;
+ for (i = 0; (i < nc); i++)
+ {
+ if (chunkIdx[i].size > compMax)
+ {
+ compMax = chunkIdx[i].size;
+ };
+ };
+ compMax++;
+
+ /* Allocate buffers */
+ chunkMax = cs * bytesPerPixel * cs;
+ chunkBuf = gdCalloc (chunkMax, 1);
+ compBuf = gdCalloc (compMax, 1);
+ GD2_DBG (printf ("Largest compressed chunk is %d bytes\n", compMax));
+ };
+
+/* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */
+/* goto fail2; */
+/* }; */
+
+ /* Read the data... */
+ for (cy = 0; (cy < ncy); cy++)
+ {
+ for (cx = 0; (cx < ncx); cx++)
+ {
+
+ ylo = cy * cs;
+ yhi = ylo + cs;
+ if (yhi > im->sy)
+ {
+ yhi = im->sy;
+ };
+
+ GD2_DBG (printf ("Processing Chunk %d (%d, %d), y from %d to %d\n", chunkNum, cx, cy, ylo, yhi));
+
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+
+ chunkLen = chunkMax;
+
+ if (!_gd2ReadChunk (chunkIdx[chunkNum].offset,
+ compBuf,
+ chunkIdx[chunkNum].size,
+ chunkBuf, &chunkLen, in))
+ {
+ GD2_DBG (printf ("Error reading comproessed chunk\n"));
+ goto fail2;
+ };
+
+ chunkPos = 0;
+ };
+
+ for (y = ylo; (y < yhi); y++)
+ {
+
+ xlo = cx * cs;
+ xhi = xlo + cs;
+ if (xhi > im->sx)
+ {
+ xhi = im->sx;
+ };
+ /*GD2_DBG(printf("y=%d: ",y)); */
+ if (fmt == GD2_FMT_RAW)
+ {
+ for (x = xlo; x < xhi; x++)
+ {
+
+ if (im->trueColor)
+ {
+ if (!gdGetInt (&im->tpixels[y][x], in))
+ {
+ /*printf("EOF while reading\n"); */
+ /*gdImageDestroy(im); */
+ /*return 0; */
+ im->tpixels[y][x] = 0;
+ }
+ }
+ else
+ {
+ int ch;
+ if (!gdGetByte (&ch, in))
+ {
+ /*printf("EOF while reading\n"); */
+ /*gdImageDestroy(im); */
+ /*return 0; */
+ ch = 0;
+ }
+ im->pixels[y][x] = ch;
+ }
+ }
+ }
+ else
+ {
+ for (x = xlo; x < xhi; x++)
+ {
+ if (im->trueColor)
+ {
+ /* 2.0.1: work around a gcc bug by being verbose.
+ TBB */
+ int a = chunkBuf[chunkPos++] << 24;
+ int r = chunkBuf[chunkPos++] << 16;
+ int g = chunkBuf[chunkPos++] << 8;
+ int b = chunkBuf[chunkPos++];
+ im->pixels[y][x] = a + r + g + b;
+ }
+ else
+ {
+ im->pixels[y][x] = chunkBuf[chunkPos++];
+ }
+ };
+ };
+ /*GD2_DBG(printf("\n")); */
+ };
+ chunkNum++;
+ };
+ };
+
+ GD2_DBG (printf ("Freeing memory\n"));
+
+ gdFree (chunkBuf);
+ gdFree (compBuf);
+ gdFree (chunkIdx);
+
+ GD2_DBG (printf ("Done\n"));
+
+ return im;
+
+fail2:
+ gdImageDestroy (im);
+ gdFree (chunkBuf);
+ gdFree (compBuf);
+ gdFree (chunkIdx);
+ return 0;
+
+}
+
+gdImagePtr
+gdImageCreateFromGd2Part (FILE * inFile, int srcx, int srcy, int w, int h)
+{
+ gdImagePtr im;
+ gdIOCtx *in = gdNewFileCtx (inFile);
+
+ im = gdImageCreateFromGd2PartCtx (in, srcx, srcy, w, h);
+
+ in->free (in);
+
+ return im;
+}
+
+gdImagePtr
+gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w, int h)
+{
+ int scx, scy, ecx, ecy, fsx, fsy;
+ int nc, ncx, ncy, cs, cx, cy;
+ int x, y, ylo, yhi, xlo, xhi;
+ int dstart, dpos;
+ int i;
+ int ch, vers, fmt;
+ t_chunk_info *chunkIdx = NULL;
+ char *chunkBuf = NULL;
+ int chunkNum;
+ int chunkMax;
+ uLongf chunkLen;
+ int chunkPos;
+ int compMax;
+ char *compBuf = NULL;
+
+ gdImagePtr im;
+
+ /* */
+ /* The next few lines are basically copied from gd2CreateFromFile */
+ /* - we change the file size, so don't want to use the code directly. */
+ /* but we do need to know the file size. */
+ /* */
+ if (_gd2GetHeader (in, &fsx, &fsy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx) != 1)
+ {
+ goto fail1;
+ }
+
+ GD2_DBG (printf ("File size is %dx%d\n", fsx, fsy));
+
+ /* This is the difference - make a file based on size of chunks. */
+ im = gdImageCreate (w, h);
+ if (im == NULL)
+ {
+ goto fail1;
+ };
+
+ if (!_gdGetColors (in, im, vers == 2))
+ {
+ goto fail2;
+ }
+ GD2_DBG (printf ("Image palette completed: %d colours\n", im->colorsTotal));
+
+ /* Process the header info */
+ nc = ncx * ncy;
+
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ /* Find the maximum compressed chunk size. */
+ compMax = 0;
+ for (i = 0; (i < nc); i++)
+ {
+ if (chunkIdx[i].size > compMax)
+ {
+ compMax = chunkIdx[i].size;
+ };
+ };
+ compMax++;
+
+ if (im->trueColor)
+ {
+ chunkMax = cs * cs * 4;
+ }
+ else
+ {
+ chunkMax = cs * cs;
+ }
+ chunkBuf = gdCalloc (chunkMax, 1);
+ compBuf = gdCalloc (compMax, 1);
+ };
+
+/* Don't bother with this... */
+/* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */
+/* goto fail2; */
+/* }; */
+
+
+ /* Work out start/end chunks */
+ scx = srcx / cs;
+ scy = srcy / cs;
+ if (scx < 0)
+ {
+ scx = 0;
+ };
+ if (scy < 0)
+ {
+ scy = 0;
+ };
+
+ ecx = (srcx + w) / cs;
+ ecy = (srcy + h) / cs;
+ if (ecx >= ncx)
+ {
+ ecx = ncx - 1;
+ };
+ if (ecy >= ncy)
+ {
+ ecy = ncy - 1;
+ };
+
+ /* Remember file position of image data. */
+ dstart = gdTell (in);
+ GD2_DBG (printf ("Data starts at %d\n", dstart));
+
+ /* Loop through the chunks. */
+ for (cy = scy; (cy <= ecy); cy++)
+ {
+
+ ylo = cy * cs;
+ yhi = ylo + cs;
+ if (yhi > fsy)
+ {
+ yhi = fsy;
+ };
+
+ for (cx = scx; (cx <= ecx); cx++)
+ {
+
+ xlo = cx * cs;
+ xhi = xlo + cs;
+ if (xhi > fsx)
+ {
+ xhi = fsx;
+ };
+
+ GD2_DBG (printf ("Processing Chunk (%d, %d), from %d to %d\n", cx, cy, ylo, yhi));
+
+ if (fmt == GD2_FMT_RAW)
+ {
+ GD2_DBG (printf ("Using raw format data\n"));
+ if (im->trueColor)
+ {
+ dpos = (cy * (cs * fsx) + cx * cs * (yhi - ylo) * 4) + dstart;
+ }
+ else
+ {
+ dpos = cy * (cs * fsx) + cx * cs * (yhi - ylo) + dstart;
+ }
+
+ if (gdSeek (in, dpos) != 0)
+ {
+ printf ("Error from seek: %d\n", errno);
+ goto fail2;
+ };
+ GD2_DBG (printf ("Reading (%d, %d) from position %d\n", cx, cy, dpos - dstart));
+ }
+ else
+ {
+ chunkNum = cx + cy * ncx;
+
+ chunkLen = chunkMax;
+ if (!_gd2ReadChunk (chunkIdx[chunkNum].offset,
+ compBuf,
+ chunkIdx[chunkNum].size,
+ chunkBuf, &chunkLen, in))
+ {
+ printf ("Error reading comproessed chunk\n");
+ goto fail2;
+ };
+ chunkPos = 0;
+ GD2_DBG (printf ("Reading (%d, %d) from chunk %d\n", cx, cy, chunkNum));
+ };
+
+ GD2_DBG (printf (" into (%d, %d) - (%d, %d)\n", xlo, ylo, xhi, yhi));
+ for (y = ylo; (y < yhi); y++)
+ {
+
+ for (x = xlo; x < xhi; x++)
+ {
+ if (fmt == GD2_FMT_RAW)
+ {
+ if (im->trueColor)
+ {
+ if (!gdGetInt (&ch, in))
+ {
+ ch = 0;
+ /*printf("EOF while reading file\n"); */
+ /*goto fail2; */
+ }
+ }
+ else
+ {
+ ch = gdGetC (in);
+ if (ch == EOF)
+ {
+ ch = 0;
+ /*printf("EOF while reading file\n"); */
+ /*goto fail2; */
+ }
+ }
+ }
+ else
+ {
+ if (im->trueColor)
+ {
+ ch = chunkBuf[chunkPos++] << 24 +
+ chunkBuf[chunkPos++] << 16 +
+ chunkBuf[chunkPos++] << 8 +
+ chunkBuf[chunkPos++];
+ }
+ else
+ {
+ ch = chunkBuf[chunkPos++];
+ }
+ };
+
+ /* Only use a point that is in the image. */
+ if ((x >= srcx) && (x < (srcx + w)) && (x < fsx) && (x >= 0)
+ && (y >= srcy) && (y < (srcy + h)) && (y < fsy) && (y >= 0)
+ )
+ {
+ im->pixels[y - srcy][x - srcx] = ch;
+ }
+ };
+ };
+ };
+ };
+
+ gdFree (chunkBuf);
+ gdFree (compBuf);
+ gdFree (chunkIdx);
+
+ return im;
+
+fail2:
+ gdImageDestroy (im);
+fail1:
+ gdFree (chunkBuf);
+ gdFree (compBuf);
+ gdFree (chunkIdx);
+
+ return 0;
+
+}
+
+static
+void
+_gd2PutHeader (gdImagePtr im, gdIOCtx * out, int cs, int fmt, int cx, int cy)
+{
+ int i;
+
+ /* Send the gd2 id, to verify file format. */
+ for (i = 0; i < 4; i++)
+ {
+ gdPutC ((unsigned char) (GD2_ID[i]), out);
+ };
+
+ /* */
+ /* We put the version info first, so future versions can easily change header info. */
+ /* */
+ gdPutWord (GD2_VERS, out);
+ gdPutWord (im->sx, out);
+ gdPutWord (im->sy, out);
+ gdPutWord (cs, out);
+ gdPutWord (fmt, out);
+ gdPutWord (cx, out);
+ gdPutWord (cy, out);
+
+}
+
+static void
+_gdImageGd2 (gdImagePtr im, gdIOCtx * out, int cs, int fmt)
+{
+ int ncx, ncy, cx, cy;
+ int x, y, ylo, yhi, xlo, xhi;
+ int chunkLen;
+ int chunkNum = 0;
+ char *chunkData = NULL; /* So we can gdFree it with impunity. */
+ char *compData = NULL; /* So we can gdFree it with impunity. */
+ uLongf compLen;
+ int idxPos;
+ int idxSize;
+ t_chunk_info *chunkIdx = NULL;
+ int posSave;
+ int bytesPerPixel = im->trueColor ? 4 : 1;
+ int compMax;
+
+ /*printf("Trying to write GD2 file\n"); */
+
+ /* */
+ /* Force fmt to a valid value since we don't return anything. */
+ /* */
+ if ((fmt == 0) || ((fmt != GD2_FMT_RAW) && (fmt != GD2_FMT_COMPRESSED)))
+ {
+ fmt = GD2_FMT_COMPRESSED;
+ };
+
+ /* */
+ /* Make sure chunk size is valid. These are arbitrary values; 64 because it seems */
+ /* a little silly to expect performance improvements on a 64x64 bit scale, and */
+ /* 4096 because we buffer one chunk, and a 16MB buffer seems a little largei - it may be */
+ /* OK for one user, but for another to read it, they require the buffer. */
+ /* */
+ if (cs == 0)
+ {
+ cs = GD2_CHUNKSIZE;
+ }
+ else if (cs < GD2_CHUNKSIZE_MIN)
+ {
+ cs = GD2_CHUNKSIZE_MIN;
+ }
+ else if (cs > GD2_CHUNKSIZE_MAX)
+ {
+ cs = GD2_CHUNKSIZE_MAX;
+ };
+
+ /* Work out number of chunks. */
+ ncx = im->sx / cs + 1;
+ ncy = im->sy / cs + 1;
+
+ /* Write the standard header. */
+ _gd2PutHeader (im, out, cs, fmt, ncx, ncy);
+
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ /* */
+ /* Work out size of buffer for compressed data, If CHUNKSIZE is large, */
+ /* then these will be large! */
+ /* */
+ /* The zlib notes say output buffer size should be (input size) * 1.01 * 12 */
+ /* - we'll use 1.02 to be paranoid. */
+ /* */
+ compMax = cs * bytesPerPixel * cs * 1.02 + 12;
+
+ /* */
+ /* Allocate the buffers. */
+ /* */
+ chunkData = gdCalloc (cs * bytesPerPixel * cs, 1);
+ compData = gdCalloc (compMax, 1);
+
+ /* */
+ /* Save the file position of chunk index, and allocate enough space for */
+ /* each chunk_info block . */
+ /* */
+ idxPos = gdTell (out);
+ idxSize = ncx * ncy * sizeof (t_chunk_info);
+ GD2_DBG (printf ("Index size is %d\n", idxSize));
+ gdSeek (out, idxPos + idxSize);
+
+ chunkIdx = gdCalloc (idxSize * sizeof (t_chunk_info), 1);
+ };
+
+ _gdPutColors (im, out);
+
+ GD2_DBG (printf ("Size: %dx%d\n", im->sx, im->sy));
+ GD2_DBG (printf ("Chunks: %dx%d\n", ncx, ncy));
+
+ for (cy = 0; (cy < ncy); cy++)
+ {
+ for (cx = 0; (cx < ncx); cx++)
+ {
+
+ ylo = cy * cs;
+ yhi = ylo + cs;
+ if (yhi > im->sy)
+ {
+ yhi = im->sy;
+ };
+
+ GD2_DBG (printf ("Processing Chunk (%dx%d), y from %d to %d\n", cx, cy, ylo, yhi));
+ chunkLen = 0;
+ for (y = ylo; (y < yhi); y++)
+ {
+
+ /*GD2_DBG(printf("y=%d: ",y)); */
+
+ xlo = cx * cs;
+ xhi = xlo + cs;
+ if (xhi > im->sx)
+ {
+ xhi = im->sx;
+ };
+
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ for (x = xlo; x < xhi; x++)
+ {
+ int p = im->pixels[y][x];
+ /*GD2_DBG(printf("%d...",x)); */
+ if (im->trueColor)
+ {
+ chunkData[chunkLen++] = gdTrueColorGetAlpha (p);
+ chunkData[chunkLen++] = gdTrueColorGetRed (p);
+ chunkData[chunkLen++] = gdTrueColorGetGreen (p);
+ chunkData[chunkLen++] = gdTrueColorGetBlue (p);
+ }
+ else
+ {
+ chunkData[chunkLen++] = p;
+ }
+ };
+ }
+ else
+ {
+ for (x = xlo; x < xhi; x++)
+ {
+ /*GD2_DBG(printf("%d, ",x)); */
+
+ if (im->trueColor)
+ {
+ gdPutInt (im->tpixels[y][x], out);
+ }
+ else
+ {
+ gdPutC ((unsigned char) im->pixels[y][x], out);
+ }
+ };
+ };
+ /*GD2_DBG(printf("y=%d done.\n",y)); */
+ };
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ compLen = compMax;
+ if (compress ((unsigned char *)
+ &compData[0], &compLen,
+ (unsigned char *) &chunkData[0],
+ chunkLen) != Z_OK)
+ {
+ printf ("Error from compressing\n");
+ }
+ else
+ {
+ chunkIdx[chunkNum].offset = gdTell (out);
+ chunkIdx[chunkNum++].size = compLen;
+ GD2_DBG (printf ("Chunk %d size %d offset %d\n", chunkNum, chunkIdx[chunkNum - 1].size, chunkIdx[chunkNum - 1].offset));
+
+ if (gdPutBuf (compData, compLen, out) <= 0)
+ {
+ /* Any alternate suggestions for handling this? */
+ printf ("Error %d on write\n", errno);
+ };
+ };
+ };
+ };
+ };
+ if (fmt == GD2_FMT_COMPRESSED)
+ {
+ /* Save the position, write the index, restore position (paranoia). */
+ GD2_DBG (printf ("Seeking %d to write index\n", idxPos));
+ posSave = gdTell (out);
+ gdSeek (out, idxPos);
+ GD2_DBG (printf ("Writing index\n"));
+ for (x = 0; x < chunkNum; x++)
+ {
+ GD2_DBG (printf ("Chunk %d size %d offset %d\n", x, chunkIdx[x].size, chunkIdx[x].offset));
+ gdPutInt (chunkIdx[x].offset, out);
+ gdPutInt (chunkIdx[x].size, out);
+ };
+ /* We don't use fwrite for *endian reasons. */
+ /*fwrite(chunkIdx, sizeof(int)*2, chunkNum, out); */
+ gdSeek (out, posSave);
+ };
+
+ GD2_DBG (printf ("Freeing memory\n"));
+ gdFree (chunkData);
+ gdFree (compData);
+ gdFree (chunkIdx);
+ GD2_DBG (printf ("Done\n"));
+
+ /*printf("Memory block size is %d\n",gdTell(out)); */
+
+}
+
+void
+gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ _gdImageGd2 (im, out, cs, fmt);
+ out->free (out);
+}
+
+void *
+gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ _gdImageGd2 (im, out, cs, fmt);
+ rv = gdDPExtractData (out, size);
+ out->free (out);
+ return rv;
+}
--- /dev/null
+
+
+/*
+ * io.c
+ *
+ * Implements the imple I/O 'helper' routines.
+ *
+ * Not really essential, but these routines were used extensively in GD,
+ * so they were moved here. They also make IOCtx calls look better...
+ *
+ * Written (or, at least, moved) 1999, Philip Warner.
+ *
+ */
+
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+
+/* Use this for commenting out debug-print statements. */
+/* Just use the first '#define' to allow all the prints... */
+/*#define IO_DBG(s) (s) */
+#define IO_DBG(s)
+
+
+/*
+ * Write out a word to the I/O context pointer
+ */
+void
+Putword (int w, gdIOCtx * ctx)
+{
+ unsigned char buf[2];
+ buf[0] = w & 0xff;
+ buf[1] = (w / 256) & 0xff;
+ (ctx->putBuf) (ctx, (char *) buf, 2);
+}
+
+void
+Putchar (int c, gdIOCtx * ctx)
+{
+ (ctx->putC) (ctx, c & 0xff);
+}
+
+void
+gdPutC (const unsigned char c, gdIOCtx * ctx)
+{
+ (ctx->putC) (ctx, c);
+}
+
+void
+gdPutWord (int w, gdIOCtx * ctx)
+{
+ IO_DBG (printf ("Putting word...\n"));
+ (ctx->putC) (ctx, (unsigned char) (w >> 8));
+ (ctx->putC) (ctx, (unsigned char) (w & 0xFF));
+ IO_DBG (printf ("put.\n"));
+}
+
+void
+gdPutInt (int w, gdIOCtx * ctx)
+{
+ IO_DBG (printf ("Putting int...\n"));
+ (ctx->putC) (ctx, (unsigned char) (w >> 24));
+ (ctx->putC) (ctx, (unsigned char) ((w >> 16) & 0xFF));
+ (ctx->putC) (ctx, (unsigned char) ((w >> 8) & 0xFF));
+ (ctx->putC) (ctx, (unsigned char) (w & 0xFF));
+ IO_DBG (printf ("put.\n"));
+}
+
+int
+gdGetC (gdIOCtx * ctx)
+{
+ return ((ctx->getC) (ctx));
+}
+
+
+
+int
+gdGetByte (int *result, gdIOCtx * ctx)
+{
+ int r;
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result = r;
+ return 1;
+}
+
+int
+gdGetWord (int *result, gdIOCtx * ctx)
+{
+ int r;
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result = r << 8;
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result += r;
+ return 1;
+}
+
+
+int
+gdGetInt (int *result, gdIOCtx * ctx)
+{
+ int r;
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result = r << 24;
+
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result += r << 16;
+
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result += r << 8;
+
+ r = (ctx->getC) (ctx);
+ if (r == EOF)
+ {
+ return 0;
+ }
+ *result += r;
+
+ return 1;
+}
+
+int
+gdPutBuf (const void *buf, int size, gdIOCtx * ctx)
+{
+ IO_DBG (printf ("Putting buf...\n"));
+ return (ctx->putBuf) (ctx, buf, size);
+ IO_DBG (printf ("put.\n"));
+}
+
+int
+gdGetBuf (void *buf, int size, gdIOCtx * ctx)
+{
+ return (ctx->getBuf) (ctx, buf, size);
+}
+
+
+int
+gdSeek (gdIOCtx * ctx, const int pos)
+{
+ IO_DBG (printf ("Seeking...\n"));
+ return ((ctx->seek) (ctx, pos));
+ IO_DBG (printf ("Done.\n"));
+}
+
+long
+gdTell (gdIOCtx * ctx)
+{
+ IO_DBG (printf ("Telling...\n"));
+ return ((ctx->tell) (ctx));
+ IO_DBG (printf ("told.\n"));
+}
--- /dev/null
+#ifndef GD_IO_H
+#define GD_IO_H 1
+
+#include <stdio.h>
+
+typedef struct gdIOCtx {
+ int (*getC)(struct gdIOCtx*);
+ int (*getBuf)(struct gdIOCtx*, void*, int);
+
+ void (*putC)(struct gdIOCtx*, int);
+ int (*putBuf)(struct gdIOCtx*, const void*, int);
+
+ int (*seek)(struct gdIOCtx*, const int);
+ long (*tell)(struct gdIOCtx*);
+
+ void (*free)(struct gdIOCtx*);
+
+} gdIOCtx;
+
+typedef struct gdIOCtx *gdIOCtxPtr;
+
+void Putword(int w, gdIOCtx *ctx);
+void Putchar(int c, gdIOCtx *ctx);
+
+void gdPutC(const unsigned char c, gdIOCtx *ctx);
+int gdPutBuf(const void *, int, gdIOCtx*);
+void gdPutWord(int w, gdIOCtx *ctx);
+void gdPutInt(int w, gdIOCtx *ctx);
+
+int gdGetC(gdIOCtx *ctx);
+int gdGetBuf(void *, int, gdIOCtx*);
+int gdGetByte(int *result, gdIOCtx *ctx);
+int gdGetWord(int *result, gdIOCtx *ctx);
+int gdGetInt(int *result, gdIOCtx *ctx);
+
+int gdSeek(gdIOCtx *ctx, const int);
+long gdTell(gdIOCtx *ctx);
+
+#endif
--- /dev/null
+
+/*
+ * io_dp.c
+ *
+ * Implements the dynamic pointer interface.
+ *
+ * Based on GD.pm code by Lincoln Stein for interfacing to libgd.
+ * Added support for reading as well as support for 'tell' and 'seek'.
+ *
+ * As will all I/O modules, most functions are for local use only (called
+ * via function pointers in the I/O context).
+ *
+ * gdDPExtractData is the exception to this: it will return the pointer to
+ * the internal data, and reset the internal storage.
+ *
+ * Written/Modified 1999, Philip Warner.
+ *
+ */
+
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/* this is used for creating images in main memory */
+typedef struct dpStruct
+ {
+ void *data;
+ int logicalSize;
+ int realSize;
+ int dataGood;
+ int pos;
+ }
+dynamicPtr;
+
+typedef struct dpIOCtx
+ {
+ gdIOCtx ctx;
+ dynamicPtr *dp;
+ }
+dpIOCtx;
+
+typedef struct dpIOCtx *dpIOCtxPtr;
+
+
+/* these functions operate on in-memory dynamic pointers */
+static int allocDynamic (dynamicPtr * dp, int initialSize, void *data);
+static int appendDynamic (dynamicPtr * dp, const void *src, int size);
+static int gdReallocDynamic (dynamicPtr * dp, int required);
+static int trimDynamic (dynamicPtr * dp);
+static void gdFreeDynamicCtx (struct gdIOCtx *ctx);
+static dynamicPtr *newDynamic (int initialSize, void *data);
+
+static int dynamicPutbuf (struct gdIOCtx *, const void *, int);
+static void dynamicPutchar (struct gdIOCtx *, int a);
+
+static int dynamicGetbuf (gdIOCtxPtr ctx, void *buf, int len);
+static int dynamicGetchar (gdIOCtxPtr ctx);
+
+static int dynamicSeek (struct gdIOCtx *, const int);
+static long dynamicTell (struct gdIOCtx *);
+
+/* return data as a dynamic pointer */
+gdIOCtx *
+gdNewDynamicCtx (int initialSize, void *data)
+{
+ dpIOCtx *ctx;
+ dynamicPtr *dp;
+
+ ctx = (dpIOCtx *) gdMalloc (sizeof (dpIOCtx));
+ if (ctx == NULL)
+ {
+ return NULL;
+ }
+
+ dp = newDynamic (initialSize, data);
+ if (!dp)
+ {
+ gdFree (ctx);
+ return NULL;
+ };
+
+ ctx->dp = dp;
+
+ ctx->ctx.getC = dynamicGetchar;
+ ctx->ctx.putC = dynamicPutchar;
+
+ ctx->ctx.getBuf = dynamicGetbuf;
+ ctx->ctx.putBuf = dynamicPutbuf;
+
+ ctx->ctx.seek = dynamicSeek;
+ ctx->ctx.tell = dynamicTell;
+
+ ctx->ctx.free = gdFreeDynamicCtx;
+
+ return (gdIOCtx *) ctx;
+}
+
+void *
+gdDPExtractData (struct gdIOCtx *ctx, int *size)
+{
+ dynamicPtr *dp;
+ dpIOCtx *dctx;
+ void *data;
+
+ dctx = (dpIOCtx *) ctx;
+ dp = dctx->dp;
+
+ /* clean up the data block and return it */
+ if (dp->dataGood)
+ {
+ trimDynamic (dp);
+ *size = dp->logicalSize;
+ data = dp->data;
+ }
+ else
+ {
+ *size = 0;
+ data = NULL;
+ if (dp->data != NULL)
+ {
+ gdFree (dp->data);
+ }
+ }
+
+ dp->data = NULL;
+ dp->realSize = 0;
+ dp->logicalSize = 0;
+
+ return data;
+}
+
+static
+void
+gdFreeDynamicCtx (struct gdIOCtx *ctx)
+{
+ dynamicPtr *dp;
+ dpIOCtx *dctx;
+
+ dctx = (dpIOCtx *) ctx;
+ dp = dctx->dp;
+
+ gdFree (ctx);
+
+ /* clean up the data block and return it */
+ if (dp->data != NULL)
+ {
+ gdFree (dp->data);
+ dp->data = NULL;
+ }
+
+ dp->realSize = 0;
+ dp->logicalSize = 0;
+
+ gdFree (dp);
+
+}
+
+static long
+dynamicTell (struct gdIOCtx *ctx)
+{
+ dpIOCtx *dctx;
+
+ dctx = (dpIOCtx *) ctx;
+ return (dctx->dp->pos);
+}
+
+static int
+dynamicSeek (struct gdIOCtx *ctx, const int pos)
+{
+ int bytesNeeded;
+ dynamicPtr *dp;
+ dpIOCtx *dctx;
+
+ dctx = (dpIOCtx *) ctx;
+ dp = dctx->dp;
+
+ if (!dp->dataGood)
+ return FALSE;
+
+ bytesNeeded = pos;
+ if (bytesNeeded > dp->realSize)
+ {
+ if (!gdReallocDynamic (dp, dp->realSize * 2))
+ {
+ dp->dataGood = FALSE;
+ return FALSE;
+ }
+ }
+
+ /* if we get here, we can be sure that we have enough bytes
+ to copy safely */
+
+ /* Extend the logical size if we seek beyond EOF. */
+ if (pos > dp->logicalSize)
+ {
+ dp->logicalSize = pos;
+ };
+
+ dp->pos = pos;
+
+ return TRUE;
+}
+
+/* return data as a dynamic pointer */
+static dynamicPtr *
+newDynamic (int initialSize, void *data)
+{
+ dynamicPtr *dp;
+ dp = (dynamicPtr *) gdMalloc (sizeof (dynamicPtr));
+ if (dp == NULL)
+ {
+ return NULL;
+ }
+
+ if (!allocDynamic (dp, initialSize, data))
+ return NULL;
+
+ dp->pos = 0;
+
+ return dp;
+}
+
+static int
+dynamicPutbuf (struct gdIOCtx *ctx, const void *buf, int size)
+{
+ dpIOCtx *dctx;
+ dctx = (dpIOCtx *) ctx;
+
+ appendDynamic (dctx->dp, buf, size);
+
+ if (dctx->dp->dataGood)
+ {
+ return size;
+ }
+ else
+ {
+ return -1;
+ };
+
+}
+
+static void
+dynamicPutchar (struct gdIOCtx *ctx, int a)
+{
+ unsigned char b;
+ dpIOCtxPtr dctx;
+
+ b = a;
+ dctx = (dpIOCtxPtr) ctx;
+
+ appendDynamic (dctx->dp, &b, 1);
+}
+
+static int
+dynamicGetbuf (gdIOCtxPtr ctx, void *buf, int len)
+{
+ int rlen, remain;
+ dpIOCtxPtr dctx;
+ dynamicPtr *dp;
+
+ dctx = (dpIOCtxPtr) ctx;
+ dp = dctx->dp;
+
+ remain = dp->logicalSize - dp->pos;
+ if (remain >= len)
+ {
+ rlen = len;
+ }
+ else
+ {
+ if (remain == 0)
+ {
+ return EOF;
+ }
+ rlen = remain;
+ }
+
+ memcpy (buf, (void *) ((char *) dp->data + dp->pos), rlen);
+ dp->pos += rlen;
+
+ return rlen;
+}
+
+static int
+dynamicGetchar (gdIOCtxPtr ctx)
+{
+ unsigned char b;
+ int rv;
+
+ rv = dynamicGetbuf (ctx, &b, 1);
+
+ if (rv != 1)
+ {
+ return EOF;
+ }
+ else
+ {
+ return b; /* (b & 0xff); */
+ }
+}
+
+/* *********************************************************************
+
+ * InitDynamic - Return a dynamically resizable void*
+ *
+ * *********************************************************************
+ */
+static int
+allocDynamic (dynamicPtr * dp, int initialSize, void *data)
+{
+
+ if (data == NULL)
+ {
+ dp->logicalSize = 0;
+ dp->dataGood = FALSE;
+ dp->data = gdMalloc (initialSize);
+ }
+ else
+ {
+ dp->logicalSize = initialSize;
+ dp->dataGood = TRUE;
+ dp->data = data;
+ }
+
+ if (dp->data != NULL)
+ {
+ dp->realSize = initialSize;
+ dp->dataGood = TRUE;
+ dp->pos = 0;
+ return TRUE;
+ }
+ else
+ {
+ dp->realSize = 0;
+ return FALSE;
+ }
+}
+
+/* append bytes to the end of a dynamic pointer */
+static int
+appendDynamic (dynamicPtr * dp, const void *src, int size)
+{
+ int bytesNeeded;
+ char *tmp;
+
+ if (!dp->dataGood)
+ return FALSE;
+
+/* bytesNeeded = dp->logicalSize + size; */
+ bytesNeeded = dp->pos + size;
+
+ if (bytesNeeded > dp->realSize)
+ {
+ if (!gdReallocDynamic (dp, bytesNeeded * 2))
+ {
+ dp->dataGood = FALSE;
+ return FALSE;
+ }
+ }
+
+ /* if we get here, we can be sure that we have enough bytes
+ to copy safely */
+ /*printf("Mem OK Size: %d, Pos: %d\n", dp->realSize, dp->pos); */
+
+ tmp = (char *) dp->data;
+ memcpy ((void *) (tmp + (dp->pos)), src, size);
+ dp->pos += size;
+
+ if (dp->pos > dp->logicalSize)
+ {
+ dp->logicalSize = dp->pos;
+ };
+
+ return TRUE;
+}
+
+/* grow (or shrink) dynamic pointer */
+static int
+gdReallocDynamic (dynamicPtr * dp, int required)
+{
+ void *newPtr;
+
+ /* First try gdRealloc(). If that doesn't work, make a new
+ memory block and copy. */
+ if ((newPtr = gdRealloc (dp->data, required)))
+ {
+ dp->realSize = required;
+ dp->data = newPtr;
+ return TRUE;
+ }
+
+ /* create a new pointer */
+ newPtr = gdMalloc (required);
+ if (!newPtr)
+ {
+ dp->dataGood = FALSE;
+ return FALSE;
+ }
+
+ /* copy the old data into it */
+ memcpy (newPtr, dp->data, dp->logicalSize);
+ gdFree (dp->data);
+ dp->data = newPtr;
+
+ dp->realSize = required;
+ return TRUE;
+}
+
+/* trim pointer so that its real and logical sizes match */
+static int
+trimDynamic (dynamicPtr * dp)
+{
+ return gdReallocDynamic (dp, dp->logicalSize);
+}
--- /dev/null
+
+/*
+ * io_file.c
+ *
+ * Implements the file interface.
+ *
+ * As will all I/O modules, most functions are for local use only (called
+ * via function pointers in the I/O context).
+ *
+ * Most functions are just 'wrappers' for standard file functions.
+ *
+ * Written/Modified 1999, Philip Warner.
+ *
+ */
+
+/* For platforms with incomplete ANSI defines. Fortunately,
+ SEEK_SET is defined to be zero by the standard. */
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#endif /* SEEK_SET */
+
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+/* this is used for creating images in main memory */
+
+typedef struct fileIOCtx
+ {
+ gdIOCtx ctx;
+ FILE *f;
+ }
+fileIOCtx;
+
+struct fileIOCtx *fileIOCtxPtr;
+
+gdIOCtx *newFileCtx (FILE * f);
+
+static int fileGetbuf (gdIOCtx *, void *, int);
+static int filePutbuf (gdIOCtx *, const void *, int);
+static void filePutchar (gdIOCtx *, int);
+static int fileGetchar (gdIOCtx * ctx);
+
+static int fileSeek (struct gdIOCtx *, const int);
+static long fileTell (struct gdIOCtx *);
+static void gdFreeFileCtx (gdIOCtx * ctx);
+
+/* return data as a dynamic pointer */
+gdIOCtx *
+gdNewFileCtx (FILE * f)
+{
+ fileIOCtx *ctx;
+
+ ctx = (fileIOCtx *) gdMalloc (sizeof (fileIOCtx));
+ if (ctx == NULL)
+ {
+ return NULL;
+ }
+
+ ctx->f = f;
+
+ ctx->ctx.getC = fileGetchar;
+ ctx->ctx.putC = filePutchar;
+
+ ctx->ctx.getBuf = fileGetbuf;
+ ctx->ctx.putBuf = filePutbuf;
+
+ ctx->ctx.tell = fileTell;
+ ctx->ctx.seek = fileSeek;
+
+ ctx->ctx.free = gdFreeFileCtx;
+
+ return (gdIOCtx *) ctx;
+}
+
+static
+void
+gdFreeFileCtx (gdIOCtx * ctx)
+{
+ gdFree (ctx);
+}
+
+
+static int
+filePutbuf (gdIOCtx * ctx, const void *buf, int size)
+{
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ return fwrite (buf, 1, size, fctx->f);
+
+}
+
+static int
+fileGetbuf (gdIOCtx * ctx, void *buf, int size)
+{
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ return (fread (buf, 1, size, fctx->f));
+
+}
+
+static void
+filePutchar (gdIOCtx * ctx, int a)
+{
+ unsigned char b;
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ b = a;
+
+ putc (b, fctx->f);
+}
+
+static int
+fileGetchar (gdIOCtx * ctx)
+{
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ return getc (fctx->f);
+}
+
+
+static int
+fileSeek (struct gdIOCtx *ctx, const int pos)
+{
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ return (fseek (fctx->f, pos, SEEK_SET) == 0);
+}
+
+static long
+fileTell (struct gdIOCtx *ctx)
+{
+ fileIOCtx *fctx;
+ fctx = (fileIOCtx *) ctx;
+
+ return ftell (fctx->f);
+}
--- /dev/null
+
+/*
+ * io_ss.c
+ *
+ * Implements the Source/Sink interface.
+ *
+ * As will all I/O modules, most functions are for local use only (called
+ * via function pointers in the I/O context).
+ *
+ * The Source/Sink model is the primary 'user' interface for alternate data
+ * sources; the IOCtx interface is intended (at least in version 1.5) to be
+ * used internally until it settles down a bit.
+ *
+ * This module just layers the Source/Sink interface on top of the IOCtx; no
+ * support is provided for tell/seek, so GD2 writing is not possible, and
+ * retrieving parts of GD2 files is also not possible.
+ *
+ * A new SS context does not need to be created with both a Source and a Sink.
+ *
+ * Written/Modified 1999, Philip Warner.
+ *
+ */
+
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+/* this is used for creating images in main memory */
+
+typedef struct ssIOCtx
+ {
+ gdIOCtx ctx;
+ gdSourcePtr src;
+ gdSinkPtr snk;
+ }
+ssIOCtx;
+
+typedef struct ssIOCtx *ssIOCtxPtr;
+
+gdIOCtx *gdNewSSCtx (gdSourcePtr src, gdSinkPtr snk);
+
+static int sourceGetbuf (gdIOCtx *, void *, int);
+static int sourceGetchar (gdIOCtx * ctx);
+static int sinkPutbuf (gdIOCtx * ctx, const void *buf, int size);
+static void sinkPutchar (gdIOCtx * ctx, int a);
+static void gdFreeSsCtx (gdIOCtx * ctx);
+
+/* return data as a dynamic pointer */
+gdIOCtx *
+gdNewSSCtx (gdSourcePtr src, gdSinkPtr snk)
+{
+ ssIOCtxPtr ctx;
+
+ ctx = (ssIOCtxPtr) gdMalloc (sizeof (ssIOCtx));
+ if (ctx == NULL)
+ {
+ return NULL;
+ }
+
+ ctx->src = src;
+ ctx->snk = snk;
+
+ ctx->ctx.getC = sourceGetchar;
+ ctx->ctx.getBuf = sourceGetbuf;
+
+ ctx->ctx.putC = sinkPutchar;
+ ctx->ctx.putBuf = sinkPutbuf;
+
+ ctx->ctx.tell = NULL;
+ ctx->ctx.seek = NULL;
+
+ ctx->ctx.free = gdFreeSsCtx;
+
+ return (gdIOCtx *) ctx;
+}
+
+static
+void
+gdFreeSsCtx (gdIOCtx * ctx)
+{
+ gdFree (ctx);
+}
+
+
+static int
+sourceGetbuf (gdIOCtx * ctx, void *buf, int size)
+{
+ ssIOCtx *lctx;
+ int res;
+
+ lctx = (ssIOCtx *) ctx;
+
+ res = ((lctx->src->source) (lctx->src->context, buf, size));
+
+/*
+ ** Translate the return values from the Source object:
+ ** 0 is EOF, -1 is error
+ */
+
+ if (res == 0)
+ {
+ return EOF;
+ }
+ else if (res < 0)
+ {
+ return 0;
+ }
+ else
+ {
+ return res;
+ };
+
+}
+
+static int
+sourceGetchar (gdIOCtx * ctx)
+{
+ int res;
+ unsigned char buf;
+
+ res = sourceGetbuf (ctx, &buf, 1);
+
+ if (res == 1)
+ {
+ return buf;
+ }
+ else
+ {
+ return EOF;
+ };
+
+}
+
+static int
+sinkPutbuf (gdIOCtx * ctx, const void *buf, int size)
+{
+ ssIOCtxPtr lctx;
+ int res;
+
+ lctx = (ssIOCtx *) ctx;
+
+ res = (lctx->snk->sink) (lctx->snk->context, buf, size);
+
+ if (res <= 0)
+ {
+ return 0;
+ }
+ else
+ {
+ return res;
+ };
+
+}
+
+static void
+sinkPutchar (gdIOCtx * ctx, int a)
+{
+ unsigned char b;
+
+ b = a;
+ sinkPutbuf (ctx, &b, 1);
+
+}
--- /dev/null
+
+
+/*
+ * gd_jpeg.c: Read and write JPEG (JFIF) format image files using the
+ * gd graphics library (http://www.boutell.com/gd/).
+ *
+ * This software is based in part on the work of the Independent JPEG
+ * Group. For more information on the IJG JPEG software (and JPEG
+ * documentation, etc.), see ftp://ftp.uu.net/graphics/jpeg/.
+ *
+ * NOTE: IJG 12-bit JSAMPLE (BITS_IN_JSAMPLE == 12) mode is not
+ * supported at all on read in gd 2.0, and is not supported on write
+ * except for palette images, which is sort of pointless (TBB). Even that
+ * has never been tested according to DB.
+ *
+ * Copyright 2000 Doug Becker, mailto:thebeckers@home.com
+ *
+ * Modification 4/18/00 TBB: JPEG_DEBUG rather than just DEBUG,
+ * so VC++ builds don't spew to standard output, causing
+ * major CGI brain damage
+ */
+
+/* TBB: move this up so include files are not brought in */
+#ifdef HAVE_LIBJPEG
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <limits.h>
+#include <string.h>
+
+/* 1.8.1: remove dependency on jinclude.h */
+#include "jpeglib.h"
+#include "jerror.h"
+#include "gd.h"
+#include "gdhelpers.h"
+
+static const char *const GD_JPEG_VERSION = "1.0";
+
+typedef struct _jmpbuf_wrapper
+ {
+ jmp_buf jmpbuf;
+ }
+jmpbuf_wrapper;
+
+/* Called by the IJG JPEG library upon encountering a fatal error */
+static void
+fatal_jpeg_error (j_common_ptr cinfo)
+{
+ jmpbuf_wrapper *jmpbufw;
+
+ fprintf (stderr, "gd-jpeg: JPEG library reports unrecoverable error: ");
+ (*cinfo->err->output_message) (cinfo);
+ fflush (stderr);
+
+ jmpbufw = (jmpbuf_wrapper *) cinfo->client_data;
+ jpeg_destroy (cinfo);
+
+ if (jmpbufw != 0)
+ {
+ longjmp (jmpbufw->jmpbuf, 1);
+ fprintf (stderr, "gd-jpeg: EXTREMELY fatal error: longjmp"
+ " returned control; terminating\n");
+ }
+ else
+ {
+ fprintf (stderr, "gd-jpeg: EXTREMELY fatal error: jmpbuf"
+ " unrecoverable; terminating\n");
+ }
+
+ fflush (stderr);
+ exit (99);
+}
+
+/*
+ * Write IM to OUTFILE as a JFIF-formatted JPEG image, using quality
+ * QUALITY. If QUALITY is in the range 0-100, increasing values
+ * represent higher quality but also larger image size. If QUALITY is
+ * negative, the IJG JPEG library's default quality is used (which
+ * should be near optimal for many applications). See the IJG JPEG
+ * library documentation for more details. */
+
+void
+gdImageJpeg (gdImagePtr im, FILE * outFile, int quality)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ gdImageJpegCtx (im, out, quality);
+ out->free (out);
+}
+
+void *
+gdImageJpegPtr (gdImagePtr im, int *size, int quality)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ gdImageJpegCtx (im, out, quality);
+ rv = gdDPExtractData (out, size);
+ out->free (out);
+ return rv;
+}
+
+void jpeg_gdIOCtx_dest (j_compress_ptr cinfo, gdIOCtx * outfile);
+
+void
+gdImageJpegCtx (gdImagePtr im, gdIOCtx * outfile, int quality)
+{
+ struct jpeg_compress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ int i, j, jidx;
+ /* volatile so we can gdFree it on return from longjmp */
+ volatile JSAMPROW row = 0;
+ JSAMPROW rowptr[1];
+ jmpbuf_wrapper jmpbufw;
+ JDIMENSION nlines;
+ char comment[255];
+
+#ifdef JPEG_DEBUG
+ printf ("gd-jpeg: gd JPEG version %s\n", GD_JPEG_VERSION);
+ printf ("gd-jpeg: JPEG library version %d, %d-bit sample values\n",
+ JPEG_LIB_VERSION, BITS_IN_JSAMPLE);
+ if (!im->trueColor)
+ {
+ for (i = 0; i < im->colorsTotal; i++)
+ {
+ if (!im->open[i])
+ printf ("gd-jpeg: gd colormap index %d: (%d, %d, %d)\n", i,
+ im->red[i], im->green[i], im->blue[i]);
+ }
+ }
+#endif /* JPEG_DEBUG */
+
+ memset (&cinfo, 0, sizeof (cinfo));
+ memset (&jerr, 0, sizeof (jerr));
+
+ cinfo.err = jpeg_std_error (&jerr);
+ cinfo.client_data = &jmpbufw;
+ if (setjmp (jmpbufw.jmpbuf) != 0)
+ {
+ /* we're here courtesy of longjmp */
+ if (row)
+ gdFree (row);
+ return;
+ }
+
+ cinfo.err->error_exit = fatal_jpeg_error;
+
+ jpeg_create_compress (&cinfo);
+
+ cinfo.image_width = im->sx;
+ cinfo.image_height = im->sy;
+ cinfo.input_components = 3; /* # of color components per pixel */
+ cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
+ jpeg_set_defaults (&cinfo);
+ if (quality >= 0)
+ jpeg_set_quality (&cinfo, quality, TRUE);
+
+ /* If user requests interlace, translate that to progressive JPEG */
+ if (gdImageGetInterlaced (im))
+ {
+#ifdef JPEG_DEBUG
+ printf ("gd-jpeg: interlace set, outputting progressive"
+ " JPEG image\n");
+#endif
+ jpeg_simple_progression (&cinfo);
+ }
+
+ jpeg_gdIOCtx_dest (&cinfo, outfile);
+
+ row = (JSAMPROW) gdCalloc (1, cinfo.image_width * cinfo.input_components
+ * sizeof (JSAMPLE));
+ if (row == 0)
+ {
+ fprintf (stderr, "gd-jpeg: error: unable to allocate JPEG row "
+ "structure: gdCalloc returns NULL\n");
+ jpeg_destroy_compress (&cinfo);
+ return;
+ }
+
+ rowptr[0] = row;
+
+ jpeg_start_compress (&cinfo, TRUE);
+
+ sprintf (comment, "CREATOR: gd-jpeg v%s (using IJG JPEG v%d),",
+ GD_JPEG_VERSION, JPEG_LIB_VERSION);
+ if (quality >= 0)
+ sprintf (comment + strlen (comment), " quality = %d\n",
+ quality);
+ else
+ strcat (comment + strlen (comment), " default quality\n");
+ jpeg_write_marker (&cinfo, JPEG_COM, (unsigned char *) comment,
+ (unsigned int) strlen (comment));
+ if (im->trueColor)
+ {
+#if BITS_IN_JSAMPLE == 12
+ fprintf (stderr, "gd-jpeg: error: jpeg library was compiled for 12-bit\n"
+ "precision. This is mostly useless, because JPEGs on the web are\n"
+ "8-bit and such versions of the jpeg library won't read or write\n"
+ "them. GD doesn't support these unusual images. Edit your\n"
+ "jmorecfg.h file to specify the correct precision and completely\n"
+ "'make clean' and 'make install' libjpeg again. Sorry.\n");
+ goto error;
+#endif /* BITS_IN_JSAMPLE == 12 */
+ for (i = 0; i < im->sy; i++)
+ {
+ for (jidx = 0, j = 0; j < im->sx; j++)
+ {
+ int val = im->tpixels[i][j];
+ row[jidx++] = gdTrueColorGetRed (val);
+ row[jidx++] = gdTrueColorGetGreen (val);
+ row[jidx++] = gdTrueColorGetBlue (val);
+ }
+
+ nlines = jpeg_write_scanlines (&cinfo, rowptr, 1);
+ if (nlines != 1)
+ fprintf (stderr, "gd_jpeg: warning: jpeg_write_scanlines"
+ " returns %u -- expected 1\n", nlines);
+ }
+ }
+ else
+ {
+ for (i = 0; i < im->sy; i++)
+ {
+ for (jidx = 0, j = 0; j < im->sx; j++)
+ {
+ int idx = im->pixels[i][j];
+
+ /*
+ * NB: Although gd RGB values are ints, their max value is
+ * 255 (see the documentation for gdImageColorAllocate())
+ * -- perfect for 8-bit JPEG encoding (which is the norm)
+ */
+#if BITS_IN_JSAMPLE == 8
+ row[jidx++] = im->red[idx];
+ row[jidx++] = im->green[idx];
+ row[jidx++] = im->blue[idx];
+#elif BITS_IN_JSAMPLE == 12
+ row[jidx++] = im->red[idx] << 4;
+ row[jidx++] = im->green[idx] << 4;
+ row[jidx++] = im->blue[idx] << 4;
+#else
+#error IJG JPEG library BITS_IN_JSAMPLE value must be 8 or 12
+#endif
+ }
+
+ nlines = jpeg_write_scanlines (&cinfo, rowptr, 1);
+ if (nlines != 1)
+ fprintf (stderr, "gd_jpeg: warning: jpeg_write_scanlines"
+ " returns %u -- expected 1\n", nlines);
+ }
+ }
+ jpeg_finish_compress (&cinfo);
+error:
+ jpeg_destroy_compress (&cinfo);
+ gdFree (row);
+}
+
+gdImagePtr
+gdImageCreateFromJpeg (FILE * inFile)
+{
+ gdImagePtr im;
+ gdIOCtx *in = gdNewFileCtx (inFile);
+ im = gdImageCreateFromJpegCtx (in);
+ in->free (in);
+ return im;
+}
+
+void
+ jpeg_gdIOCtx_src (j_decompress_ptr cinfo,
+ gdIOCtx * infile);
+
+/*
+ * Create a gd-format image from the JPEG-format INFILE. Returns the
+ * image, or NULL upon error.
+ */
+gdImagePtr
+gdImageCreateFromJpegCtx (gdIOCtx * infile)
+{
+ struct jpeg_decompress_struct cinfo;
+ struct jpeg_error_mgr jerr;
+ jmpbuf_wrapper jmpbufw;
+ /* volatile so we can gdFree them after longjmp */
+ volatile JSAMPROW row = 0;
+ volatile gdImagePtr im = 0;
+ JSAMPROW rowptr[1];
+ int i, j, retval;
+ JDIMENSION nrows;
+
+#ifdef JPEG_DEBUG
+ printf ("gd-jpeg: gd JPEG version %s\n", GD_JPEG_VERSION);
+ printf ("gd-jpeg: JPEG library version %d, %d-bit sample values\n",
+ JPEG_LIB_VERSION, BITS_IN_JSAMPLE);
+#endif
+
+ memset (&cinfo, 0, sizeof (cinfo));
+ memset (&jerr, 0, sizeof (jerr));
+
+ cinfo.err = jpeg_std_error (&jerr);
+ cinfo.client_data = &jmpbufw;
+ if (setjmp (jmpbufw.jmpbuf) != 0)
+ {
+ /* we're here courtesy of longjmp */
+ if (row)
+ gdFree (row);
+ if (im)
+ gdImageDestroy (im);
+ return 0;
+ }
+
+ cinfo.err->error_exit = fatal_jpeg_error;
+
+ jpeg_create_decompress (&cinfo);
+
+ jpeg_gdIOCtx_src (&cinfo, infile);
+
+ retval = jpeg_read_header (&cinfo, TRUE);
+ if (retval != JPEG_HEADER_OK)
+ fprintf (stderr, "gd-jpeg: warning: jpeg_read_header returns"
+ " %d, expected %d\n", retval, JPEG_HEADER_OK);
+
+ if (cinfo.image_height > INT_MAX)
+ fprintf (stderr, "gd-jpeg: warning: JPEG image height (%u) is"
+ " greater than INT_MAX (%d) (and thus greater than"
+ " gd can handle)", cinfo.image_height,
+ INT_MAX);
+
+ if (cinfo.image_width > INT_MAX)
+ fprintf (stderr, "gd-jpeg: warning: JPEG image width (%u) is"
+ " greater than INT_MAX (%d) (and thus greater than"
+ " gd can handle)\n", cinfo.image_width, INT_MAX);
+
+ im = gdImageCreateTrueColor ((int) cinfo.image_width,
+ (int) cinfo.image_height);
+ if (im == 0)
+ {
+ fprintf (stderr, "gd-jpeg error: cannot allocate gdImage"
+ " struct\n");
+ goto error;
+ }
+
+ /*
+ * Force the image into RGB colorspace, but don't
+ * reduce the number of colors anymore (GD 2.0)
+ */
+ cinfo.out_color_space = JCS_RGB;
+
+ if (jpeg_start_decompress (&cinfo) != TRUE)
+ fprintf (stderr, "gd-jpeg: warning: jpeg_start_decompress"
+ " reports suspended data source\n");
+
+#ifdef JPEG_DEBUG
+ printf ("gd-jpeg: JPEG image information:");
+ if (cinfo.saw_JFIF_marker)
+ printf (" JFIF version %d.%.2d",
+ (int) cinfo.JFIF_major_version,
+ (int) cinfo.JFIF_minor_version);
+ else if (cinfo.saw_Adobe_marker)
+ printf (" Adobe format");
+ else
+ printf (" UNKNOWN format");
+
+ printf (" %ux%u (raw) / %ux%u (scaled) %d-bit", cinfo.image_width,
+ cinfo.image_height, cinfo.output_width,
+ cinfo.output_height, cinfo.data_precision);
+ printf (" %s", (cinfo.progressive_mode ? "progressive" :
+ "baseline"));
+ printf (" image, %d quantized colors, ",
+ cinfo.actual_number_of_colors);
+
+ switch (cinfo.jpeg_color_space)
+ {
+ case JCS_GRAYSCALE:
+ printf ("grayscale");
+ break;
+
+ case JCS_RGB:
+ printf ("RGB");
+ break;
+
+ case JCS_YCbCr:
+ printf ("YCbCr (a.k.a. YUV)");
+ break;
+
+ case JCS_CMYK:
+ printf ("CMYK");
+ break;
+
+ case JCS_YCCK:
+ printf ("YCbCrK");
+ break;
+
+ default:
+ printf ("UNKNOWN (value: %d)", (int) cinfo.jpeg_color_space);
+ break;
+ }
+ printf (" colorspace\n");
+ fflush (stdout);
+#endif /* JPEG_DEBUG */
+
+ /* REMOVED by TBB 2/12/01. This field of the structure is
+ documented as private, and sure enough it's gone in the
+ latest libjpeg, replaced by something else. Unfortunately
+ there is still no right way to find out if the file was
+ progressive or not; just declare your intent before you
+ write one by calling gdImageInterlace(im, 1) yourself.
+ After all, we're not really supposed to rework JPEGs and
+ write them out again anyway. Lossy compression, remember? */
+#if 0
+ gdImageInterlace (im, cinfo.progressive_mode != 0);
+#endif
+ if (cinfo.output_components != 3)
+ {
+ fprintf (stderr, "gd-jpeg: error: JPEG color quantization"
+ " request resulted in output_components == %d"
+ " (expected 3)\n", cinfo.output_components);
+ goto error;
+ }
+
+#if BITS_IN_JSAMPLE == 12
+ fprintf (stderr, "gd-jpeg: error: jpeg library was compiled for 12-bit\n"
+ "precision. This is mostly useless, because JPEGs on the web are\n"
+ "8-bit and such versions of the jpeg library won't read or write\n"
+ "them. GD doesn't support these unusual images. Edit your\n"
+ "jmorecfg.h file to specify the correct precision and completely\n"
+ "'make clean' and 'make install' libjpeg again. Sorry.\n");
+ goto error;
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+ row = gdCalloc (cinfo.output_width * 3, sizeof (JSAMPLE));
+ if (row == 0)
+ {
+ fprintf (stderr, "gd-jpeg: error: unable to allocate row for"
+ " JPEG scanline: gdCalloc returns NULL\n");
+ goto error;
+ }
+ rowptr[0] = row;
+
+ for (i = 0; i < cinfo.output_height; i++)
+ {
+ nrows = jpeg_read_scanlines (&cinfo, rowptr, 1);
+ if (nrows != 1)
+ {
+ fprintf (stderr, "gd-jpeg: error: jpeg_read_scanlines"
+ " returns %u, expected 1\n", nrows);
+ goto error;
+ }
+
+ for (j = 0; j < cinfo.output_width; j++)
+ im->tpixels[i][j] = gdTrueColor (row[j * 3], row[j * 3 + 1],
+ row[j * 3 + 2]);
+ }
+
+ if (jpeg_finish_decompress (&cinfo) != TRUE)
+ fprintf (stderr, "gd-jpeg: warning: jpeg_finish_decompress"
+ " reports suspended data source\n");
+
+
+ jpeg_destroy_decompress (&cinfo);
+ gdFree (row);
+ return im;
+
+error:
+ jpeg_destroy_decompress (&cinfo);
+ if (row)
+ gdFree (row);
+ if (im)
+ gdImageDestroy (im);
+ return 0;
+}
+
+/*
+
+ * gdIOCtx JPEG data sources and sinks, T. Boutell
+ * almost a simple global replace from T. Lane's stdio versions.
+ *
+ */
+
+/* Different versions of libjpeg use either 'jboolean' or 'boolean', and
+ some platforms define 'boolean', and so forth. Deal with this
+ madness by typedeffing 'safeboolean' to 'boolean' if HAVE_BOOLEAN
+ is already set, because this is the test that libjpeg uses.
+ Otherwise, typedef it to int, because that's what libjpeg does
+ if HAVE_BOOLEAN is not defined. -TBB */
+
+#ifdef HAVE_BOOLEAN
+typedef boolean safeboolean;
+#else
+typedef int safeboolean;
+#endif /* HAVE_BOOLEAN */
+
+/* Expanded data source object for gdIOCtx input */
+
+typedef struct
+ {
+ struct jpeg_source_mgr pub; /* public fields */
+
+ gdIOCtx *infile; /* source stream */
+ unsigned char *buffer; /* start of buffer */
+ safeboolean start_of_file; /* have we gotten any data yet? */
+
+ }
+my_source_mgr;
+
+typedef my_source_mgr *my_src_ptr;
+
+#define INPUT_BUF_SIZE 4096 /* choose an efficiently fread'able size */
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+void
+init_source (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* We reset the empty-input-file flag for each image,
+ * but we don't clear the input buffer.
+ * This is correct behavior for reading a series of images from one source.
+ */
+ src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded. It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return. If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer. In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there. However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later. In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any). The application should resume
+ * decompression after it has loaded more data into the input buffer. Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+#define END_JPEG_SEQUENCE "\r\n[*]--:END JPEG:--[*]\r\n"
+
+safeboolean
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+ size_t nbytes = 0;
+
+ /* size_t got; */
+ /* char *s; */
+ memset (src->buffer, 0, INPUT_BUF_SIZE);
+
+ while (nbytes < INPUT_BUF_SIZE)
+ {
+
+ int got = gdGetBuf (src->buffer + nbytes,
+ INPUT_BUF_SIZE - nbytes,
+ src->infile);
+
+ if ((got == EOF) || (got == 0))
+ {
+
+ /* EOF or error. If we got any data, don't worry about it.
+ If we didn't, then this is unexpected. */
+ if (!nbytes)
+ {
+
+ nbytes = -1;
+
+ }
+
+ break;
+
+ }
+
+ nbytes += got;
+
+ }
+
+ if (nbytes <= 0)
+ {
+ if (src->start_of_file) /* Treat empty input file as fatal error */
+ ERREXIT (cinfo, JERR_INPUT_EMPTY);
+ WARNMS (cinfo, JWRN_JPEG_EOF);
+ /* Insert a fake EOI marker */
+ src->buffer[0] = (unsigned char) 0xFF;
+ src->buffer[1] = (unsigned char) JPEG_EOI;
+ nbytes = 2;
+ }
+
+ src->pub.next_input_byte = src->buffer;
+ src->pub.bytes_in_buffer = nbytes;
+ src->start_of_file = FALSE;
+
+ return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return. If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+void
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+ /* Just a dumb implementation for now. Not clear that being smart is worth
+ * any trouble anyway --- large skips are infrequent.
+ */
+ if (num_bytes > 0)
+ {
+ while (num_bytes > (long) src->pub.bytes_in_buffer)
+ {
+ num_bytes -= (long) src->pub.bytes_in_buffer;
+ (void) fill_input_buffer (cinfo);
+ /* note we assume that fill_input_buffer will never return FALSE,
+ * so suspension need not be handled.
+ */
+ }
+ src->pub.next_input_byte += (size_t) num_bytes;
+ src->pub.bytes_in_buffer -= (size_t) num_bytes;
+ }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library. That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read. Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+void
+term_source (j_decompress_ptr cinfo)
+{
+
+#if 0
+/* never used */
+ my_src_ptr src = (my_src_ptr) cinfo->src;
+
+#endif
+}
+
+
+/*
+ * Prepare for input from a gdIOCtx stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+void
+jpeg_gdIOCtx_src (j_decompress_ptr cinfo,
+ gdIOCtx * infile)
+{
+ my_src_ptr src;
+
+ /* The source object and input buffer are made permanent so that a series
+ * of JPEG images can be read from the same file by calling jpeg_gdIOCtx_src
+ * only before the first one. (If we discarded the buffer at the end of
+ * one image, we'd likely lose the start of the next one.)
+ * This makes it unsafe to use this manager and a different source
+ * manager serially with the same JPEG object. Caveat programmer.
+ */
+ if (cinfo->src == NULL)
+ { /* first time for this JPEG object? */
+ cinfo->src = (struct jpeg_source_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ sizeof (my_source_mgr));
+ src = (my_src_ptr) cinfo->src;
+ src->buffer = (unsigned char *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ INPUT_BUF_SIZE * sizeof (unsigned char));
+
+ }
+
+ src = (my_src_ptr) cinfo->src;
+ src->pub.init_source = init_source;
+ src->pub.fill_input_buffer = fill_input_buffer;
+ src->pub.skip_input_data = skip_input_data;
+ src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+ src->pub.term_source = term_source;
+ src->infile = infile;
+ src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+ src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
+
+/* Expanded data destination object for stdio output */
+
+typedef struct
+{
+ struct jpeg_destination_mgr pub; /* public fields */
+ gdIOCtx *outfile; /* target stream */
+ unsigned char *buffer; /* start of buffer */
+}
+my_destination_mgr;
+
+typedef my_destination_mgr *my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE 4096 /* choose an efficiently fwrite'able size */
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+void
+init_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ /* Allocate the output buffer --- it will be released when done with image */
+ dest->buffer = (unsigned char *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+ OUTPUT_BUF_SIZE * sizeof (unsigned char));
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines). The
+ * application should resume compression after it has made more room in the
+ * output buffer. Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+safeboolean
+empty_output_buffer (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+ if (gdPutBuf (dest->buffer, OUTPUT_BUF_SIZE, dest->outfile) !=
+ (size_t) OUTPUT_BUF_SIZE)
+ ERREXIT (cinfo, JERR_FILE_WRITE);
+
+ dest->pub.next_output_byte = dest->buffer;
+ dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+ return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written. Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+void
+term_destination (j_compress_ptr cinfo)
+{
+ my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+ size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+ /* Write any data remaining in the buffer */
+ if (datacount > 0)
+ {
+ if (gdPutBuf (dest->buffer, datacount, dest->outfile) != datacount)
+ ERREXIT (cinfo, JERR_FILE_WRITE);
+ }
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+void
+jpeg_gdIOCtx_dest (j_compress_ptr cinfo, gdIOCtx * outfile)
+{
+ my_dest_ptr dest;
+
+ /* The destination object is made permanent so that multiple JPEG images
+ * can be written to the same file without re-executing jpeg_stdio_dest.
+ * This makes it dangerous to use this manager and a different destination
+ * manager serially with the same JPEG object, because their private object
+ * sizes may be different. Caveat programmer.
+ */
+ if (cinfo->dest == NULL)
+ { /* first time for this JPEG object? */
+ cinfo->dest = (struct jpeg_destination_mgr *)
+ (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+ sizeof (my_destination_mgr));
+ }
+
+ dest = (my_dest_ptr) cinfo->dest;
+ dest->pub.init_destination = init_destination;
+ dest->pub.empty_output_buffer = empty_output_buffer;
+ dest->pub.term_destination = term_destination;
+ dest->outfile = outfile;
+}
+
+#endif /* HAVE_JPEG */
--- /dev/null
+
+#ifdef HAVE_LIBPNG
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+#include "png.h" /* includes zlib.h and setjmp.h */
+
+#define TRUE 1
+#define FALSE 0
+
+/*---------------------------------------------------------------------------
+
+ gd_png.c Copyright 1999 Greg Roelofs and Thomas Boutell
+
+ The routines in this file, gdImagePng*() and gdImageCreateFromPng*(),
+ are drop-in replacements for gdImageGif*() and gdImageCreateFromGif*(),
+ except that these functions are noisier in the case of errors (comment
+ out all fprintf() statements to disable that).
+
+ GD 2.0 supports RGBA truecolor and will read and write truecolor PNGs.
+ GD 2.0 supports 8 bits of color resolution per channel and
+ 7 bits of alpha channel resolution. Images with more than 8 bits
+ per channel are reduced to 8 bits. Images with an alpha channel are
+ only able to resolve down to '1/128th opaque' instead of '1/256th',
+ and this conversion is also automatic. I very much doubt you can see it.
+ Both tRNS and true alpha are supported.
+
+ Gamma is ignored, and there is no support for text annotations.
+
+ Last updated: 9 February 2001
+
+ ---------------------------------------------------------------------------*/
+
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+typedef struct _jmpbuf_wrapper
+ {
+ jmp_buf jmpbuf;
+ }
+jmpbuf_wrapper;
+
+static jmpbuf_wrapper gdPngJmpbufStruct;
+
+static void
+gdPngErrorHandler (png_structp png_ptr, png_const_charp msg)
+{
+ jmpbuf_wrapper *jmpbuf_ptr;
+
+ /* This function, aside from the extra step of retrieving the "error
+ * pointer" (below) and the fact that it exists within the application
+ * rather than within libpng, is essentially identical to libpng's
+ * default error handler. The second point is critical: since both
+ * setjmp() and longjmp() are called from the same code, they are
+ * guaranteed to have compatible notions of how big a jmp_buf is,
+ * regardless of whether _BSD_SOURCE or anything else has (or has not)
+ * been defined. */
+
+ fprintf (stderr, "gd-png: fatal libpng error: %s\n", msg);
+ fflush (stderr);
+
+ jmpbuf_ptr = png_get_error_ptr (png_ptr);
+ if (jmpbuf_ptr == NULL)
+ { /* we are completely hosed now */
+ fprintf (stderr,
+ "gd-png: EXTREMELY fatal error: jmpbuf unrecoverable; terminating.\n");
+ fflush (stderr);
+ exit (99);
+ }
+
+ longjmp (jmpbuf_ptr->jmpbuf, 1);
+}
+#endif
+
+static void
+gdPngReadData (png_structp png_ptr,
+ png_bytep data, png_size_t length)
+{
+ gdGetBuf (data, length, (gdIOCtx *)
+ png_get_io_ptr (png_ptr));
+}
+
+static void
+gdPngWriteData (png_structp png_ptr,
+ png_bytep data, png_size_t length)
+{
+ gdPutBuf (data, length, (gdIOCtx *)
+ png_get_io_ptr (png_ptr));
+}
+
+static void
+gdPngFlushData (png_structp png_ptr)
+{
+}
+
+gdImagePtr
+gdImageCreateFromPng (FILE * inFile)
+{
+ gdImagePtr im;
+ gdIOCtx *in = gdNewFileCtx (inFile);
+ im = gdImageCreateFromPngCtx (in);
+ in->free (in);
+ return im;
+}
+
+
+/* This routine is based in part on the Chapter 13 demo code in "PNG: The
+ * Definitive Guide" (http://www.cdrom.com/pub/png/pngbook.html).
+ */
+gdImagePtr
+gdImageCreateFromPngCtx (gdIOCtx * infile)
+{
+ png_byte sig[8];
+ png_structp png_ptr;
+ png_infop info_ptr;
+ png_uint_32 width, height, rowbytes;
+ int bit_depth, color_type, interlace_type;
+ int num_palette, num_trans;
+ png_colorp palette;
+ png_color_16p trans_gray_rgb;
+ png_color_16p trans_color_rgb;
+ png_bytep trans;
+ png_bytep image_data = NULL;
+ png_bytepp row_pointers = NULL;
+ gdImagePtr im = NULL;
+ int i, j, *open;
+ volatile int transparent = -1;
+ volatile int palette_allocated = FALSE;
+
+ /* Make sure the signature can't match by dumb luck -- TBB */
+ /* GRR: isn't sizeof(infile) equal to the size of the pointer? */
+ memset (infile, 0, sizeof (infile));
+
+ /* first do a quick check that the file really is a PNG image; could
+ * have used slightly more general png_sig_cmp() function instead */
+ gdGetBuf (sig, 8, infile);
+ if (!png_check_sig (sig, 8))
+ return NULL; /* bad signature */
+
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+ png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, &gdPngJmpbufStruct,
+ gdPngErrorHandler, NULL);
+#else
+ png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+#endif
+ if (png_ptr == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate libpng main struct\n");
+ return NULL;
+ }
+
+ info_ptr = png_create_info_struct (png_ptr);
+ if (info_ptr == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate libpng info struct\n");
+ png_destroy_read_struct (&png_ptr, NULL, NULL);
+ return NULL;
+ }
+
+ /* we could create a second info struct here (end_info), but it's only
+ * useful if we want to keep pre- and post-IDAT chunk info separated
+ * (mainly for PNG-aware image editors and converters) */
+
+ /* setjmp() must be called in every non-callback function that calls a
+ * PNG-reading libpng function */
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+ if (setjmp (gdPngJmpbufStruct.jmpbuf))
+ {
+ fprintf (stderr, "gd-png error: setjmp returns error condition\n");
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ return NULL;
+ }
+#endif
+
+ png_set_sig_bytes (png_ptr, 8); /* we already read the 8 signature bytes */
+
+ png_set_read_fn (png_ptr, (void *) infile, gdPngReadData);
+ png_read_info (png_ptr, info_ptr); /* read all PNG info up to image data */
+
+ png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+ &interlace_type, NULL, NULL);
+ if ((color_type == PNG_COLOR_TYPE_RGB) ||
+ (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
+ {
+ im = gdImageCreateTrueColor ((int) width, (int) height);
+ }
+ else
+ {
+ im = gdImageCreate ((int) width, (int) height);
+ }
+ if (im == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate gdImage struct\n");
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ gdFree (image_data);
+ gdFree (row_pointers);
+ return NULL;
+ }
+
+ if (bit_depth == 16)
+ png_set_strip_16 (png_ptr);
+ else if (bit_depth < 8)
+ png_set_packing (png_ptr); /* expand to 1 byte per pixel */
+ switch (color_type)
+ {
+ case PNG_COLOR_TYPE_PALETTE:
+ png_get_PLTE (png_ptr, info_ptr, &palette, &num_palette);
+#ifdef DEBUG
+ fprintf (stderr, "gd-png color_type is palette, colors: %d\n",
+ num_palette);
+#endif /* DEBUG */
+ if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+ {
+ /* gd 2.0: we support this rather thoroughly now. Grab the
+ first fully transparent entry, if any, as the value of
+ the simple-transparency index, mostly for backwards
+ binary compatibility. The alpha channel is where it's
+ really at these days. */
+ int firstZero = 1;
+ png_get_tRNS (png_ptr, info_ptr, &trans, &num_trans, NULL);
+ for (i = 0; i < num_trans; ++i)
+ {
+ im->alpha[i] = gdAlphaMax - (trans[i] >> 1);
+ if ((trans[i] == 0) && (firstZero))
+ {
+ im->transparent = i;
+ firstZero = 0;
+ }
+ }
+ }
+ break;
+
+ case PNG_COLOR_TYPE_GRAY:
+ case PNG_COLOR_TYPE_GRAY_ALPHA:
+ /* create a fake palette and check for single-shade transparency */
+ if ((palette = (png_colorp) gdMalloc (256 * sizeof (png_color))) == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate gray palette\n");
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ return NULL;
+ }
+ palette_allocated = TRUE;
+ if (bit_depth < 8)
+ {
+ num_palette = 1 << bit_depth;
+ for (i = 0; i < 256; ++i)
+ {
+ j = (255 * i) / (num_palette - 1);
+ palette[i].red = palette[i].green = palette[i].blue = j;
+ }
+ }
+ else
+ {
+ num_palette = 256;
+ for (i = 0; i < 256; ++i)
+ {
+ palette[i].red = palette[i].green = palette[i].blue = i;
+ }
+ }
+ if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+ {
+ png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_gray_rgb);
+ if (bit_depth == 16) /* png_set_strip_16() not yet in effect */
+ transparent = trans_gray_rgb->gray >> 8;
+ else
+ transparent = trans_gray_rgb->gray;
+ /* Note slight error in 16-bit case: up to 256 16-bit shades
+ * may get mapped to a single 8-bit shade, and only one of them
+ * is supposed to be transparent. IOW, both opaque pixels and
+ * transparent pixels will be mapped into the transparent entry.
+ * There is no particularly good way around this in the case
+ * that all 256 8-bit shades are used, but one could write some
+ * custom 16-bit code to handle the case where there are gdFree
+ * palette entries. This error will be extremely rare in
+ * general, though. (Quite possibly there is only one such
+ * image in existence.) */
+ }
+ break;
+
+ case PNG_COLOR_TYPE_RGB:
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ /* gd 2.0: we now support truecolor. See the comment above
+ for a rare situation in which the transparent pixel may not
+ work properly with 16-bit channels. */
+ if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+ {
+ png_get_tRNS (png_ptr, info_ptr, NULL, NULL, &trans_color_rgb);
+ if (bit_depth == 16) /* png_set_strip_16() not yet in effect */
+ transparent = gdTrueColor (trans_color_rgb->red >> 8,
+ trans_color_rgb->green >> 8,
+ trans_color_rgb->blue >> 8);
+ else
+ transparent = gdTrueColor (trans_color_rgb->red,
+ trans_color_rgb->green,
+ trans_color_rgb->blue);
+ }
+ break;
+ }
+
+ png_read_update_info (png_ptr, info_ptr);
+
+ /* allocate space for the PNG image data */
+ rowbytes = png_get_rowbytes (png_ptr, info_ptr);
+ if ((image_data = (png_bytep) gdMalloc (rowbytes * height)) == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate image data\n");
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ return NULL;
+ }
+ if ((row_pointers = (png_bytepp) gdMalloc (height * sizeof (png_bytep))) == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate row pointers\n");
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ gdFree (image_data);
+ return NULL;
+ }
+
+ /* set the individual row_pointers to point at the correct offsets */
+ for (j = 0; j < height; ++j)
+ {
+ row_pointers[j] = image_data + j * rowbytes;
+ }
+
+ png_read_image (png_ptr, row_pointers); /* read whole image... */
+ png_read_end (png_ptr, NULL); /* ...done! */
+
+ if (!im->trueColor)
+ {
+ im->colorsTotal = num_palette;
+ im->transparent = transparent;
+ /* load the palette and mark all entries "open" (unused) for now */
+ open = im->open;
+ for (i = 0; i < num_palette; ++i)
+ {
+ im->red[i] = palette[i].red;
+ im->green[i] = palette[i].green;
+ im->blue[i] = palette[i].blue;
+ open[i] = 1;
+ }
+ for (i = num_palette; i < gdMaxColors; ++i)
+ {
+ open[i] = 1;
+ }
+ }
+ im->interlace = (interlace_type == PNG_INTERLACE_ADAM7);
+
+ /* can't nuke structs until done with palette */
+ png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+ switch (color_type)
+ {
+ case PNG_COLOR_TYPE_RGB:
+ for (j = 0; j < height; j++)
+ {
+ int boffset = 0;
+ for (i = 0; i < width; i++)
+ {
+ register png_byte r = row_pointers[j][boffset++];
+ register png_byte g = row_pointers[j][boffset++];
+ register png_byte b = row_pointers[j][boffset++];
+ im->tpixels[j][i] = gdTrueColor (r, g, b);
+ }
+ }
+ break;
+ case PNG_COLOR_TYPE_RGB_ALPHA:
+ for (j = 0; j < height; j++)
+ {
+ int boffset = 0;
+ for (i = 0; i < width; i++)
+ {
+ register png_byte r = row_pointers[j][boffset++];
+ register png_byte g = row_pointers[j][boffset++];
+ register png_byte b = row_pointers[j][boffset++];
+ /* gd has only 7 bits of alpha channel resolution, and
+ 127 is transparent, 0 opaque. A moment of convenience,
+ a lifetime of compatibility. */
+ register png_byte a = gdAlphaMax -
+ (row_pointers[j][boffset++] >> 1);
+ im->tpixels[j][i] = gdTrueColorAlpha (r, g, b, a);
+ }
+ }
+ break;
+ default:
+ /* Palette image, or something coerced to be one */
+ for (j = 0; j < height; ++j)
+ {
+ for (i = 0; i < width; ++i)
+ {
+ register png_byte idx = row_pointers[j][i];
+ im->pixels[j][i] = idx;
+ open[idx] = 0;
+ }
+ }
+ }
+#ifdef DEBUG
+ if (!im->trueColor)
+ {
+ for (i = num_palette; i < gdMaxColors; ++i)
+ {
+ if (!open[i])
+ {
+ fprintf (stderr, "gd-png warning: image data references out-of-range"
+ " color index (%d)\n", i);
+ }
+ }
+ }
+#endif
+
+ if (palette_allocated)
+ gdFree (palette);
+ gdFree (image_data);
+ gdFree (row_pointers);
+
+ return im;
+}
+
+
+void
+gdImagePng (gdImagePtr im, FILE * outFile)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ gdImagePngCtx (im, out);
+ out->free (out);
+}
+
+void *
+gdImagePngPtr (gdImagePtr im, int *size)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ gdImagePngCtx (im, out);
+ rv = gdDPExtractData (out, size);
+ out->free (out);
+ return rv;
+}
+
+/* This routine is based in part on code from Dale Lutz (Safe Software Inc.)
+ * and in part on demo code from Chapter 15 of "PNG: The Definitive Guide"
+ * (http://www.cdrom.com/pub/png/pngbook.html).
+ */
+void
+gdImagePngCtx (gdImagePtr im, gdIOCtx * outfile)
+{
+ int i, j, bit_depth, interlace_type;
+ int width = im->sx;
+ int height = im->sy;
+ int colors = im->colorsTotal;
+ int *open = im->open;
+ int mapping[gdMaxColors]; /* mapping[gd_index] == png_index */
+ png_byte trans_values[256];
+ png_color_16 trans_rgb_value;
+ png_color palette[gdMaxColors];
+ png_structp png_ptr;
+ png_infop info_ptr;
+ volatile int transparent = im->transparent;
+ volatile int remap = FALSE;
+
+
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+ png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING,
+ &gdPngJmpbufStruct, gdPngErrorHandler, NULL);
+#else
+ png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+#endif
+ if (png_ptr == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate libpng main struct\n");
+ return;
+ }
+
+ info_ptr = png_create_info_struct (png_ptr);
+ if (info_ptr == NULL)
+ {
+ fprintf (stderr, "gd-png error: cannot allocate libpng info struct\n");
+ png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+ return;
+ }
+
+#ifndef PNG_SETJMP_NOT_SUPPORTED
+ if (setjmp (gdPngJmpbufStruct.jmpbuf))
+ {
+ fprintf (stderr, "gd-png error: setjmp returns error condition\n");
+ png_destroy_write_struct (&png_ptr, &info_ptr);
+ return;
+ }
+#endif
+
+ png_set_write_fn (png_ptr, (void *) outfile, gdPngWriteData, gdPngFlushData);
+
+ /* This is best for palette images, and libpng defaults to it for
+ palette images anyway, so we don't need to do it explicitly.
+ What to ideally do for truecolor images depends, alas, on the image.
+ gd is intentionally imperfect and doesn't spend a lot of time
+ fussing with such things. */
+/* png_set_filter(png_ptr, 0, PNG_FILTER_NONE); */
+
+ /* may want to force maximum compression, but time penalty is large */
+/* png_set_compression_level(png_ptr, Z_BEST_COMPRESSION); */
+
+ /* can set this to a smaller value without compromising compression if all
+ * image data is 16K or less; will save some decoder memory [min == 8] */
+/* png_set_compression_window_bits(png_ptr, 15); */
+
+ if (!im->trueColor)
+ {
+ if (transparent >= im->colorsTotal ||
+ (transparent >= 0 && open[transparent]))
+ transparent = -1;
+ }
+ if (!im->trueColor)
+ {
+ for (i = 0; i < gdMaxColors; ++i)
+ mapping[i] = -1;
+ }
+ if (!im->trueColor)
+ {
+ /* count actual number of colors used (colorsTotal == high-water mark) */
+ colors = 0;
+ for (i = 0; i < im->colorsTotal; ++i)
+ {
+ if (!open[i])
+ {
+ mapping[i] = colors;
+ ++colors;
+ }
+ }
+ if (colors < im->colorsTotal)
+ {
+ remap = TRUE;
+ }
+ if (colors <= 2)
+ bit_depth = 1;
+ else if (colors <= 4)
+ bit_depth = 2;
+ else if (colors <= 16)
+ bit_depth = 4;
+ else
+ bit_depth = 8;
+ }
+ interlace_type = im->interlace ? PNG_INTERLACE_ADAM7 : PNG_INTERLACE_NONE;
+
+ if (im->trueColor)
+ {
+ if (im->saveAlphaFlag)
+ {
+ png_set_IHDR (png_ptr, info_ptr, width, height, 8,
+ PNG_COLOR_TYPE_RGB_ALPHA, interlace_type,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ }
+ else
+ {
+ png_set_IHDR (png_ptr, info_ptr, width, height, 8,
+ PNG_COLOR_TYPE_RGB, interlace_type,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ }
+ }
+ else
+ {
+ png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth,
+ PNG_COLOR_TYPE_PALETTE, interlace_type,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+ }
+ if (im->trueColor && (!im->saveAlphaFlag) && (transparent >= 0))
+ {
+ trans_rgb_value.red = gdTrueColorGetRed (im->trueColor);
+ trans_rgb_value.green = gdTrueColorGetGreen (im->trueColor);
+ trans_rgb_value.blue = gdTrueColorGetBlue (im->trueColor);
+ png_set_tRNS (png_ptr, info_ptr, 0, 0, &trans_rgb_value);
+ }
+ if (!im->trueColor)
+ {
+ /* Oy veh. Remap the PNG palette to put the
+ entries with interesting alpha channel
+ values first. This minimizes the size
+ of the tRNS chunk and thus the size
+ of the PNG file as a whole. */
+ int tc = 0;
+ int i;
+ int j;
+ int k;
+ int highTrans = -1;
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if ((!im->open[i]) &&
+ (im->alpha[i] != gdAlphaOpaque))
+ {
+ tc++;
+ }
+ }
+ if (tc)
+ {
+#if 0
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ trans_values[i] = 255 -
+ ((im->alpha[i] << 1) +
+ (im->alpha[i] >> 7));
+ }
+ png_set_tRNS (png_ptr, info_ptr, trans_values, 256, NULL);
+#endif
+ if (!remap)
+ {
+ remap = TRUE;
+ }
+ /* (Semi-)transparent indexes come up from the bottom
+ of the list of real colors; opaque
+ indexes come down from the top */
+ j = 0;
+ k = colors - 1;
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if (!im->open[i])
+ {
+ if (im->alpha[i] != gdAlphaOpaque)
+ {
+ trans_values[j] = 255 -
+ ((im->alpha[i] << 1) +
+ (im->alpha[i] >> 7));
+ mapping[i] = j++;
+ }
+ else
+ {
+ mapping[i] = k--;
+ }
+ }
+ }
+ png_set_tRNS (png_ptr, info_ptr, trans_values, tc, NULL);
+ }
+ }
+
+ /* convert palette to libpng layout */
+ if (!im->trueColor)
+ {
+ if (remap)
+ for (i = 0; i < im->colorsTotal; ++i)
+ {
+ if (mapping[i] < 0)
+ continue;
+ palette[mapping[i]].red = im->red[i];
+ palette[mapping[i]].green = im->green[i];
+ palette[mapping[i]].blue = im->blue[i];
+ }
+ else
+ for (i = 0; i < colors; ++i)
+ {
+ palette[i].red = im->red[i];
+ palette[i].green = im->green[i];
+ palette[i].blue = im->blue[i];
+ }
+ png_set_PLTE (png_ptr, info_ptr, palette, colors);
+ }
+
+ /* write out the PNG header info (everything up to first IDAT) */
+ png_write_info (png_ptr, info_ptr);
+
+ /* make sure < 8-bit images are packed into pixels as tightly as possible */
+ png_set_packing (png_ptr);
+
+ /* This code allocates a set of row buffers and copies the gd image data
+ * into them only in the case that remapping is necessary; in gd 1.3 and
+ * later, the im->pixels array is laid out identically to libpng's row
+ * pointers and can be passed to png_write_image() function directly.
+ * The remapping case could be accomplished with less memory for non-
+ * interlaced images, but interlacing causes some serious complications. */
+ if (im->trueColor)
+ {
+ int channels = im->saveAlphaFlag ? 4 : 3;
+ /* Our little 7-bit alpha channel trick costs us a bit here. */
+ png_bytep *row_pointers;
+ row_pointers = gdMalloc (sizeof (png_bytep) * height);
+ if (row_pointers == NULL)
+ {
+ fprintf (stderr, "gd-png error: unable to allocate row_pointers\n");
+ }
+ for (j = 0; j < height; ++j)
+ {
+ int bo = 0;
+ if ((row_pointers[j] = (png_bytep) gdMalloc (width * channels)) == NULL)
+ {
+ fprintf (stderr, "gd-png error: unable to allocate rows\n");
+ for (i = 0; i < j; ++i)
+ gdFree (row_pointers[i]);
+ return;
+ }
+ for (i = 0; i < width; ++i)
+ {
+ unsigned char a;
+ row_pointers[j][bo++] = gdTrueColorGetRed (im->tpixels[j][i]);
+ row_pointers[j][bo++] = gdTrueColorGetGreen (im->tpixels[j][i]);
+ row_pointers[j][bo++] = gdTrueColorGetBlue (im->tpixels[j][i]);
+ if (im->saveAlphaFlag)
+ {
+ /* convert the 7-bit alpha channel to an 8-bit alpha channel.
+ We do a little bit-flipping magic, repeating the MSB
+ as the LSB, to ensure that 0 maps to 0 and
+ 127 maps to 255. We also have to invert to match
+ PNG's convention in which 255 is opaque. */
+ a = gdTrueColorGetAlpha (im->tpixels[j][i]);
+ row_pointers[j][bo++] = 255 - ((a << 1) + (a >> 7));
+ }
+ }
+ }
+
+ png_write_image (png_ptr, row_pointers);
+ png_write_end (png_ptr, info_ptr);
+
+ for (j = 0; j < height; ++j)
+ gdFree (row_pointers[j]);
+ gdFree (row_pointers);
+ }
+ else
+ {
+ if (remap)
+ {
+ png_bytep *row_pointers;
+ row_pointers = gdMalloc (sizeof (png_bytep) * height);
+ if (row_pointers == NULL)
+ {
+ fprintf (stderr, "gd-png error: unable to allocate row_pointers\n");
+ }
+ for (j = 0; j < height; ++j)
+ {
+ if ((row_pointers[j] = (png_bytep) gdMalloc (width)) == NULL)
+ {
+ fprintf (stderr, "gd-png error: unable to allocate rows\n");
+ for (i = 0; i < j; ++i)
+ gdFree (row_pointers[i]);
+ return;
+ }
+ for (i = 0; i < width; ++i)
+ row_pointers[j][i] = mapping[im->pixels[j][i]];
+ }
+
+ png_write_image (png_ptr, row_pointers);
+ png_write_end (png_ptr, info_ptr);
+
+ for (j = 0; j < height; ++j)
+ gdFree (row_pointers[j]);
+ gdFree (row_pointers);
+ }
+ else
+ {
+ png_write_image (png_ptr, im->pixels);
+ png_write_end (png_ptr, info_ptr);
+ }
+ }
+ /* 1.6.3: maybe we should give that memory BACK! TBB */
+ png_destroy_write_struct (&png_ptr, &info_ptr);
+}
+
+
+#endif /* HAVE_LIBPNG */
--- /dev/null
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "gd.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/* Exported functions: */
+extern void gdImagePngToSink (gdImagePtr im, gdSinkPtr out);
+extern gdImagePtr gdImageCreateFromPngSource (gdSourcePtr inSource);
+
+/* Use this for commenting out debug-print statements. */
+/* Just use the first '#define' to allow all the prints... */
+/*#define GD_SS_DBG(s) (s) */
+#define GD_SS_DBG(s)
+
+void
+gdImagePngToSink (gdImagePtr im, gdSinkPtr outSink)
+{
+ gdIOCtx *out = gdNewSSCtx (NULL, outSink);
+ gdImagePngCtx (im, out);
+ out->free (out);
+}
+
+gdImagePtr
+gdImageCreateFromPngSource (gdSourcePtr inSource)
+{
+ gdIOCtx *in = gdNewSSCtx (inSource, NULL);
+ gdImagePtr im;
+
+ im = gdImageCreateFromPngCtx (in);
+
+ in->free (in);
+
+ return im;
+}
--- /dev/null
+
+
+/*
+ * gd_topal.c
+ *
+ * This code is adapted pretty much entirely from jquant2.c,
+ * Copyright (C) 1991-1996, Thomas G. Lane. That file is
+ * part of the Independent JPEG Group's software. Conditions of
+ * use are compatible with the gd license. See the gd license
+ * statement and README-JPEG.TXT for additional information.
+ *
+ * This file contains 2-pass color quantization (color mapping) routines.
+ * These routines provide selection of a custom color map for an image,
+ * followed by mapping of the image to that color map, with optional
+ * Floyd-Steinberg dithering.
+ *
+ * It is also possible to use just the second pass to map to an arbitrary
+ * externally-given color map.
+ *
+ * Note: ordered dithering is not supported, since there isn't any fast
+ * way to compute intercolor distances; it's unclear that ordered dither's
+ * fundamental assumptions even hold with an irregularly spaced color map.
+ *
+ * SUPPORT FOR ALPHA CHANNELS WAS HACKED IN BY THOMAS BOUTELL, who also
+ * adapted the code to work within gd rather than within libjpeg, and
+ * may not have done a great job of either. It's not Thomas G. Lane's fault.
+ */
+
+#include "gd.h"
+#include "gdhelpers.h"
+
+/*
+ * This module implements the well-known Heckbert paradigm for color
+ * quantization. Most of the ideas used here can be traced back to
+ * Heckbert's seminal paper
+ * Heckbert, Paul. "Color Image Quantization for Frame Buffer Display",
+ * Proc. SIGGRAPH '82, Computer Graphics v.16 #3 (July 1982), pp 297-304.
+ *
+ * In the first pass over the image, we accumulate a histogram showing the
+ * usage count of each possible color. To keep the histogram to a reasonable
+ * size, we reduce the precision of the input; typical practice is to retain
+ * 5 or 6 bits per color, so that 8 or 4 different input values are counted
+ * in the same histogram cell.
+ *
+ * Next, the color-selection step begins with a box representing the whole
+ * color space, and repeatedly splits the "largest" remaining box until we
+ * have as many boxes as desired colors. Then the mean color in each
+ * remaining box becomes one of the possible output colors.
+ *
+ * The second pass over the image maps each input pixel to the closest output
+ * color (optionally after applying a Floyd-Steinberg dithering correction).
+ * This mapping is logically trivial, but making it go fast enough requires
+ * considerable care.
+ *
+ * Heckbert-style quantizers vary a good deal in their policies for choosing
+ * the "largest" box and deciding where to cut it. The particular policies
+ * used here have proved out well in experimental comparisons, but better ones
+ * may yet be found.
+ *
+ * In earlier versions of the IJG code, this module quantized in YCbCr color
+ * space, processing the raw upsampled data without a color conversion step.
+ * This allowed the color conversion math to be done only once per colormap
+ * entry, not once per pixel. However, that optimization precluded other
+ * useful optimizations (such as merging color conversion with upsampling)
+ * and it also interfered with desired capabilities such as quantizing to an
+ * externally-supplied colormap. We have therefore abandoned that approach.
+ * The present code works in the post-conversion color space, typically RGB.
+ *
+ * To improve the visual quality of the results, we actually work in scaled
+ * RGBA space, giving G distances more weight than R, and R in turn more than
+ * B. Alpha is weighted least. To do everything in integer math, we must
+ * use integer scale factors. The 2/3/1 scale factors used here correspond
+ * loosely to the relative weights of the colors in the NTSC grayscale
+ * equation.
+ */
+
+#ifndef TRUE
+#define TRUE 1
+#endif /* TRUE */
+
+#ifndef FALSE
+#define FALSE 0
+#endif /* FALSE */
+
+#define R_SCALE 2 /* scale R distances by this much */
+#define G_SCALE 3 /* scale G distances by this much */
+#define B_SCALE 1 /* and B by this much */
+#define A_SCALE 4 /* and alpha by this much. This really
+ only scales by 1 because alpha
+ values are 7-bit to begin with. */
+
+/* Channel ordering (fixed in gd) */
+#define C0_SCALE R_SCALE
+#define C1_SCALE G_SCALE
+#define C2_SCALE B_SCALE
+#define C3_SCALE A_SCALE
+
+/*
+ * First we have the histogram data structure and routines for creating it.
+ *
+ * The number of bits of precision can be adjusted by changing these symbols.
+ * We recommend keeping 6 bits for G and 5 each for R and B.
+ * If you have plenty of memory and cycles, 6 bits all around gives marginally
+ * better results; if you are short of memory, 5 bits all around will save
+ * some space but degrade the results.
+ * To maintain a fully accurate histogram, we'd need to allocate a "long"
+ * (preferably unsigned long) for each cell. In practice this is overkill;
+ * we can get by with 16 bits per cell. Few of the cell counts will overflow,
+ * and clamping those that do overflow to the maximum value will give close-
+ * enough results. This reduces the recommended histogram size from 256Kb
+ * to 128Kb, which is a useful savings on PC-class machines.
+ * (In the second pass the histogram space is re-used for pixel mapping data;
+ * in that capacity, each cell must be able to store zero to the number of
+ * desired colors. 16 bits/cell is plenty for that too.)
+ * Since the JPEG code is intended to run in small memory model on 80x86
+ * machines, we can't just allocate the histogram in one chunk. Instead
+ * of a true 3-D array, we use a row of pointers to 2-D arrays. Each
+ * pointer corresponds to a C0 value (typically 2^5 = 32 pointers) and
+ * each 2-D array has 2^6*2^5 = 2048 or 2^6*2^6 = 4096 entries. Note that
+ * on 80x86 machines, the pointer row is in near memory but the actual
+ * arrays are in far memory (same arrangement as we use for image arrays).
+ */
+
+#define MAXNUMCOLORS (gdMaxColors) /* maximum size of colormap */
+
+#define HIST_C0_BITS 5 /* bits of precision in R histogram */
+#define HIST_C1_BITS 6 /* bits of precision in G histogram */
+#define HIST_C2_BITS 5 /* bits of precision in B histogram */
+#define HIST_C3_BITS 3 /* bits of precision in A histogram */
+
+/* Number of elements along histogram axes. */
+#define HIST_C0_ELEMS (1<<HIST_C0_BITS)
+#define HIST_C1_ELEMS (1<<HIST_C1_BITS)
+#define HIST_C2_ELEMS (1<<HIST_C2_BITS)
+#define HIST_C3_ELEMS (1<<HIST_C3_BITS)
+
+/* These are the amounts to shift an input value to get a histogram index. */
+#define C0_SHIFT (8-HIST_C0_BITS)
+#define C1_SHIFT (8-HIST_C1_BITS)
+#define C2_SHIFT (8-HIST_C2_BITS)
+/* Beware! Alpha is 7 bit to begin with */
+#define C3_SHIFT (7-HIST_C3_BITS)
+
+
+typedef unsigned short histcell; /* histogram cell; prefer an unsigned type */
+
+typedef histcell *histptr; /* for pointers to histogram cells */
+
+typedef histcell hist1d[HIST_C3_ELEMS]; /* typedefs for the array */
+typedef hist1d *hist2d; /* type for the 2nd-level pointers */
+typedef hist2d *hist3d; /* type for third-level pointer */
+typedef hist3d *hist4d; /* type for top-level pointer */
+
+
+/* Declarations for Floyd-Steinberg dithering.
+
+ * Errors are accumulated into the array fserrors[], at a resolution of
+ * 1/16th of a pixel count. The error at a given pixel is propagated
+ * to its not-yet-processed neighbors using the standard F-S fractions,
+ * ... (here) 7/16
+ * 3/16 5/16 1/16
+ * We work left-to-right on even rows, right-to-left on odd rows.
+ *
+ * We can get away with a single array (holding one row's worth of errors)
+ * by using it to store the current row's errors at pixel columns not yet
+ * processed, but the next row's errors at columns already processed. We
+ * need only a few extra variables to hold the errors immediately around the
+ * current column. (If we are lucky, those variables are in registers, but
+ * even if not, they're probably cheaper to access than array elements are.)
+ *
+ * The fserrors[] array has (#columns + 2) entries; the extra entry at
+ * each end saves us from special-casing the first and last pixels.
+ * Each entry is three values long, one value for each color component.
+ *
+ */
+
+typedef signed short FSERROR; /* 16 bits should be enough */
+typedef int LOCFSERROR; /* use 'int' for calculation temps */
+
+typedef FSERROR *FSERRPTR; /* pointer to error array */
+
+/* Private object */
+
+typedef struct
+ {
+ hist4d histogram; /* pointer to the histogram */
+ int needs_zeroed; /* TRUE if next pass must zero histogram */
+
+ /* Variables for Floyd-Steinberg dithering */
+ FSERRPTR fserrors; /* accumulated errors */
+ int on_odd_row; /* flag to remember which row we are on */
+ int *error_limiter; /* table for clamping the applied error */
+ int *error_limiter_storage; /* gdMalloc'd storage for the above */
+ int transparentIsPresent; /* TBB: for rescaling to ensure that */
+ int opaqueIsPresent; /* 100% opacity & transparency are preserved */
+ }
+my_cquantizer;
+
+typedef my_cquantizer *my_cquantize_ptr;
+
+/*
+ * Prescan the pixel array.
+ *
+ * The prescan simply updates the histogram, which has been
+ * initialized to zeroes by start_pass.
+ *
+ */
+
+static void
+prescan_quantize (gdImagePtr im, my_cquantize_ptr cquantize)
+{
+ register histptr histp;
+ register hist4d histogram = cquantize->histogram;
+ int row;
+ int col;
+ int *ptr;
+ int width = im->sx;
+
+ for (row = 0; row < im->sy; row++)
+ {
+ ptr = im->tpixels[row];
+ for (col = width; col > 0; col--)
+ {
+ /* get pixel value and index into the histogram */
+ int r, g, b, a;
+ r = gdTrueColorGetRed (*ptr) >> C0_SHIFT;
+ g = gdTrueColorGetGreen (*ptr) >> C1_SHIFT;
+ b = gdTrueColorGetBlue (*ptr) >> C2_SHIFT;
+ a = gdTrueColorGetAlpha (*ptr);
+ /* We must have 100% opacity and transparency available
+ in the color map to do an acceptable job with alpha
+ channel, if opacity and transparency are present in the
+ original, because of the visual properties of large
+ flat-color border areas (requiring 100% transparency)
+ and the behavior of poorly implemented browsers
+ (requiring 100% opacity). Test for the presence of
+ these here, and rescale the most opaque and transparent
+ palette entries at the end if so. This avoids the need
+ to develop a fuller understanding I have not been able
+ to reach so far in my study of this subject. TBB */
+ if (a == gdAlphaTransparent)
+ {
+ cquantize->transparentIsPresent = 1;
+ }
+ if (a == gdAlphaOpaque)
+ {
+ cquantize->opaqueIsPresent = 1;
+ }
+ a >>= C3_SHIFT;
+ histp = &histogram[r][g][b][a];
+ /* increment, check for overflow and undo increment if so. */
+ if (++(*histp) <= 0)
+ (*histp)--;
+ ptr++;
+ }
+ }
+}
+
+
+/*
+ * Next we have the really interesting routines: selection of a colormap
+ * given the completed histogram.
+ * These routines work with a list of "boxes", each representing a rectangular
+ * subset of the input color space (to histogram precision).
+ */
+
+typedef struct
+{
+ /* The bounds of the box (inclusive); expressed as histogram indexes */
+ int c0min, c0max;
+ int c1min, c1max;
+ int c2min, c2max;
+ int c3min, c3max;
+ /* The volume (actually 2-norm) of the box */
+ int volume;
+ /* The number of nonzero histogram cells within this box */
+ long colorcount;
+}
+box;
+
+typedef box *boxptr;
+
+static boxptr
+find_biggest_color_pop (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest color population */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register long maxc = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++)
+ {
+ if (boxp->colorcount > maxc && boxp->volume > 0)
+ {
+ which = boxp;
+ maxc = boxp->colorcount;
+ }
+ }
+ return which;
+}
+
+
+static boxptr
+find_biggest_volume (boxptr boxlist, int numboxes)
+/* Find the splittable box with the largest (scaled) volume */
+/* Returns NULL if no splittable boxes remain */
+{
+ register boxptr boxp;
+ register int i;
+ register int maxv = 0;
+ boxptr which = NULL;
+
+ for (i = 0, boxp = boxlist; i < numboxes; i++, boxp++)
+ {
+ if (boxp->volume > maxv)
+ {
+ which = boxp;
+ maxv = boxp->volume;
+ }
+ }
+ return which;
+}
+
+
+static void
+update_box (gdImagePtr im, my_cquantize_ptr cquantize, boxptr boxp)
+/* Shrink the min/max bounds of a box to enclose only nonzero elements, */
+/* and recompute its volume and population */
+{
+ hist4d histogram = cquantize->histogram;
+ histptr histp;
+ int c0, c1, c2, c3;
+ int c0min, c0max, c1min, c1max, c2min, c2max, c3min, c3max;
+ int dist0, dist1, dist2, dist3;
+ long ccount;
+
+ c0min = boxp->c0min;
+ c0max = boxp->c0max;
+ c1min = boxp->c1min;
+ c1max = boxp->c1max;
+ c2min = boxp->c2min;
+ c2max = boxp->c2max;
+ c3min = boxp->c3min;
+ c3max = boxp->c3max;
+
+ if (c0max > c0min)
+ {
+ for (c0 = c0min; c0 <= c0max; c0++)
+ {
+ for (c1 = c1min; c1 <= c1max; c1++)
+ {
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++)
+ {
+ if (*histp++ != 0)
+ {
+ boxp->c0min = c0min = c0;
+ goto have_c0min;
+ }
+ }
+ }
+ }
+ }
+ }
+have_c0min:
+ if (c0max > c0min)
+ {
+ for (c0 = c0max; c0 >= c0min; c0--)
+ {
+ for (c1 = c1min; c1 <= c1max; c1++)
+ {
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++)
+ {
+ if (*histp++ != 0)
+ {
+ boxp->c0max = c0max = c0;
+ goto have_c0max;
+ }
+ }
+ }
+ }
+ }
+ }
+have_c0max:
+ if (c1max > c1min)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ {
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++)
+ if (*histp++ != 0)
+ {
+ boxp->c1min = c1min = c1;
+ goto have_c1min;
+ }
+ }
+ }
+have_c1min:
+ if (c1max > c1min)
+ for (c1 = c1max; c1 >= c1min; c1--)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ {
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++)
+ if (*histp++ != 0)
+ {
+ boxp->c1max = c1max = c1;
+ goto have_c1max;
+ }
+ }
+ }
+have_c1max:
+ /* The original version hand-rolled the array lookup a little, but
+ with four dimensions, I don't even want to think about it. TBB */
+ if (c2max > c2min)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c3 = c3min; c3 <= c3max; c3++)
+ if (histogram[c0][c1][c2][c3] != 0)
+ {
+ boxp->c2min = c2min = c2;
+ goto have_c2min;
+ }
+have_c2min:
+ if (c2max > c2min)
+ for (c2 = c2max; c2 >= c2min; c2--)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c3 = c3min; c3 <= c3max; c3++)
+ if (histogram[c0][c1][c2][c3] != 0)
+ {
+ boxp->c2max = c2max = c2;
+ goto have_c2max;
+ }
+have_c2max:
+ if (c3max > c3min)
+ for (c3 = c3min; c3 <= c3max; c3++)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (histogram[c0][c1][c2][c3] != 0)
+ {
+ boxp->c3min = c3min = c3;
+ goto have_c3min;
+ }
+have_c3min:
+ if (c3max > c3min)
+ for (c3 = c3max; c3 >= c3min; c3--)
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ if (histogram[c0][c1][c2][c3] != 0)
+ {
+ boxp->c3max = c3max = c3;
+ goto have_c3max;
+ }
+have_c3max:
+ /* Update box volume.
+ * We use 2-norm rather than real volume here; this biases the method
+ * against making long narrow boxes, and it has the side benefit that
+ * a box is splittable iff norm > 0.
+ * Since the differences are expressed in histogram-cell units,
+ * we have to shift back to 8-bit units to get consistent distances;
+ * after which, we scale according to the selected distance scale factors.
+ * TBB: alpha shifts back to 7 bit units. That was accounted for in the
+ * alpha scale factor.
+ */
+ dist0 = ((c0max - c0min) << C0_SHIFT) * C0_SCALE;
+ dist1 = ((c1max - c1min) << C1_SHIFT) * C1_SCALE;
+ dist2 = ((c2max - c2min) << C2_SHIFT) * C2_SCALE;
+ dist3 = ((c3max - c3min) << C3_SHIFT) * C3_SCALE;
+ boxp->volume = dist0 * dist0 + dist1 * dist1 + dist2 * dist2 + dist3 * dist3;
+
+ /* Now scan remaining volume of box and compute population */
+ ccount = 0;
+ for (c0 = c0min; c0 <= c0max; c0++)
+ for (c1 = c1min; c1 <= c1max; c1++)
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++, histp++)
+ if (*histp != 0)
+ {
+ ccount++;
+ }
+ }
+ boxp->colorcount = ccount;
+}
+
+
+static int
+median_cut (gdImagePtr im, my_cquantize_ptr cquantize,
+ boxptr boxlist, int numboxes,
+ int desired_colors)
+/* Repeatedly select and split the largest box until we have enough boxes */
+{
+ int n, lb;
+ int c0, c1, c2, c3, cmax;
+ register boxptr b1, b2;
+
+ while (numboxes < desired_colors)
+ {
+ /* Select box to split.
+ * Current algorithm: by population for first half, then by volume.
+ */
+ if (numboxes * 2 <= desired_colors)
+ {
+ b1 = find_biggest_color_pop (boxlist, numboxes);
+ }
+ else
+ {
+ b1 = find_biggest_volume (boxlist, numboxes);
+ }
+ if (b1 == NULL) /* no splittable boxes left! */
+ break;
+ b2 = &boxlist[numboxes]; /* where new box will go */
+ /* Copy the color bounds to the new box. */
+ b2->c0max = b1->c0max;
+ b2->c1max = b1->c1max;
+ b2->c2max = b1->c2max;
+ b2->c3max = b1->c3max;
+ b2->c0min = b1->c0min;
+ b2->c1min = b1->c1min;
+ b2->c2min = b1->c2min;
+ b2->c3min = b1->c3min;
+ /* Choose which axis to split the box on.
+ * Current algorithm: longest scaled axis.
+ * See notes in update_box about scaling distances.
+ */
+ c0 = ((b1->c0max - b1->c0min) << C0_SHIFT) * C0_SCALE;
+ c1 = ((b1->c1max - b1->c1min) << C1_SHIFT) * C1_SCALE;
+ c2 = ((b1->c2max - b1->c2min) << C2_SHIFT) * C2_SCALE;
+ c3 = ((b1->c3max - b1->c3min) << C3_SHIFT) * C3_SCALE;
+ /* We want to break any ties in favor of green, then red, then blue,
+ with alpha last. */
+ cmax = c1;
+ n = 1;
+ if (c0 > cmax)
+ {
+ cmax = c0;
+ n = 0;
+ }
+ if (c2 > cmax)
+ {
+ cmax = c2;
+ n = 2;
+ }
+ if (c3 > cmax)
+ {
+ n = 3;
+ }
+ /* Choose split point along selected axis, and update box bounds.
+ * Current algorithm: split at halfway point.
+ * (Since the box has been shrunk to minimum volume,
+ * any split will produce two nonempty subboxes.)
+ * Note that lb value is max for lower box, so must be < old max.
+ */
+ switch (n)
+ {
+ case 0:
+ lb = (b1->c0max + b1->c0min) / 2;
+ b1->c0max = lb;
+ b2->c0min = lb + 1;
+ break;
+ case 1:
+ lb = (b1->c1max + b1->c1min) / 2;
+ b1->c1max = lb;
+ b2->c1min = lb + 1;
+ break;
+ case 2:
+ lb = (b1->c2max + b1->c2min) / 2;
+ b1->c2max = lb;
+ b2->c2min = lb + 1;
+ break;
+ case 3:
+ lb = (b1->c3max + b1->c3min) / 2;
+ b1->c3max = lb;
+ b2->c3min = lb + 1;
+ break;
+ }
+ /* Update stats for boxes */
+ update_box (im, cquantize, b1);
+ update_box (im, cquantize, b2);
+ numboxes++;
+ }
+ return numboxes;
+}
+
+
+static void
+compute_color (gdImagePtr im, my_cquantize_ptr cquantize,
+ boxptr boxp, int icolor)
+/*
+ Compute representative color for a box, put it in
+ palette index icolor */
+{
+ /* Current algorithm: mean weighted by pixels (not colors) */
+ /* Note it is important to get the rounding correct! */
+ hist4d histogram = cquantize->histogram;
+ histptr histp;
+ int c0, c1, c2, c3;
+ int c0min, c0max, c1min, c1max, c2min, c2max, c3min, c3max;
+ long count;
+ long total = 0;
+ long c0total = 0;
+ long c1total = 0;
+ long c2total = 0;
+ long c3total = 0;
+
+ c0min = boxp->c0min;
+ c0max = boxp->c0max;
+ c1min = boxp->c1min;
+ c1max = boxp->c1max;
+ c2min = boxp->c2min;
+ c2max = boxp->c2max;
+ c3min = boxp->c3min;
+ c3max = boxp->c3max;
+
+ for (c0 = c0min; c0 <= c0max; c0++)
+ {
+ for (c1 = c1min; c1 <= c1max; c1++)
+ {
+ for (c2 = c2min; c2 <= c2max; c2++)
+ {
+ histp = &histogram[c0][c1][c2][c3min];
+ for (c3 = c3min; c3 <= c3max; c3++)
+ {
+ if ((count = *histp++) != 0)
+ {
+ total += count;
+ c0total += ((c0 << C0_SHIFT) + ((1 << C0_SHIFT) >> 1)) * count;
+ c1total += ((c1 << C1_SHIFT) + ((1 << C1_SHIFT) >> 1)) * count;
+ c2total += ((c2 << C2_SHIFT) + ((1 << C2_SHIFT) >> 1)) * count;
+ c3total += ((c3 << C3_SHIFT) + ((1 << C3_SHIFT) >> 1)) * count;
+ }
+ }
+ }
+ }
+ }
+ im->red[icolor] = (int) ((c0total + (total >> 1)) / total);
+ im->green[icolor] = (int) ((c1total + (total >> 1)) / total);
+ im->blue[icolor] = (int) ((c2total + (total >> 1)) / total);
+ im->alpha[icolor] = (int) ((c3total + (total >> 1)) / total);
+ im->open[icolor] = 0;
+ if (im->colorsTotal <= icolor)
+ {
+ im->colorsTotal = icolor + 1;
+ }
+}
+
+static void
+select_colors (gdImagePtr im, my_cquantize_ptr cquantize, int desired_colors)
+/* Master routine for color selection */
+{
+ boxptr boxlist;
+ int numboxes;
+ int i;
+
+ /* Allocate workspace for box list */
+ boxlist = (boxptr) gdMalloc (desired_colors * sizeof (box));
+ /* Initialize one box containing whole space */
+ numboxes = 1;
+ /* Note maxval for alpha is different */
+ boxlist[0].c0min = 0;
+ boxlist[0].c0max = 255 >> C0_SHIFT;
+ boxlist[0].c1min = 0;
+ boxlist[0].c1max = 255 >> C1_SHIFT;
+ boxlist[0].c2min = 0;
+ boxlist[0].c2max = 255 >> C2_SHIFT;
+ boxlist[0].c3min = 0;
+ boxlist[0].c3max = gdAlphaMax >> C3_SHIFT;
+ /* Shrink it to actually-used volume and set its statistics */
+ update_box (im, cquantize, &boxlist[0]);
+ /* Perform median-cut to produce final box list */
+ numboxes = median_cut (im, cquantize, boxlist, numboxes, desired_colors);
+ /* Compute the representative color for each box, fill colormap */
+ for (i = 0; i < numboxes; i++)
+ compute_color (im, cquantize, &boxlist[i], i);
+ /* TBB: if the image contains colors at both scaled ends
+ of the alpha range, rescale slightly to make sure alpha
+ covers the full spectrum from 100% transparent to 100%
+ opaque. Even a faint distinct background color is
+ generally considered failure with regard to alpha. */
+
+ im->colorsTotal = numboxes;
+ gdFree (boxlist);
+}
+
+
+/*
+ * These routines are concerned with the time-critical task of mapping input
+ * colors to the nearest color in the selected colormap.
+ *
+ * We re-use the histogram space as an "inverse color map", essentially a
+ * cache for the results of nearest-color searches. All colors within a
+ * histogram cell will be mapped to the same colormap entry, namely the one
+ * closest to the cell's center. This may not be quite the closest entry to
+ * the actual input color, but it's almost as good. A zero in the cache
+ * indicates we haven't found the nearest color for that cell yet; the array
+ * is cleared to zeroes before starting the mapping pass. When we find the
+ * nearest color for a cell, its colormap index plus one is recorded in the
+ * cache for future use. The pass2 scanning routines call fill_inverse_cmap
+ * when they need to use an unfilled entry in the cache.
+ *
+ * Our method of efficiently finding nearest colors is based on the "locally
+ * sorted search" idea described by Heckbert and on the incremental distance
+ * calculation described by Spencer W. Thomas in chapter III.1 of Graphics
+ * Gems II (James Arvo, ed. Academic Press, 1991). Thomas points out that
+ * the distances from a given colormap entry to each cell of the histogram can
+ * be computed quickly using an incremental method: the differences between
+ * distances to adjacent cells themselves differ by a constant. This allows a
+ * fairly fast implementation of the "brute force" approach of computing the
+ * distance from every colormap entry to every histogram cell. Unfortunately,
+ * it needs a work array to hold the best-distance-so-far for each histogram
+ * cell (because the inner loop has to be over cells, not colormap entries).
+ * The work array elements have to be INT32s, so the work array would need
+ * 256Kb at our recommended precision. This is not feasible in DOS machines.
+ *
+ * To get around these problems, we apply Thomas' method to compute the
+ * nearest colors for only the cells within a small subbox of the histogram.
+ * The work array need be only as big as the subbox, so the memory usage
+ * problem is solved. Furthermore, we need not fill subboxes that are never
+ * referenced in pass2; many images use only part of the color gamut, so a
+ * fair amount of work is saved. An additional advantage of this
+ * approach is that we can apply Heckbert's locality criterion to quickly
+ * eliminate colormap entries that are far away from the subbox; typically
+ * three-fourths of the colormap entries are rejected by Heckbert's criterion,
+ * and we need not compute their distances to individual cells in the subbox.
+ * The speed of this approach is heavily influenced by the subbox size: too
+ * small means too much overhead, too big loses because Heckbert's criterion
+ * can't eliminate as many colormap entries. Empirically the best subbox
+ * size seems to be about 1/512th of the histogram (1/8th in each direction).
+ *
+ * Thomas' article also describes a refined method which is asymptotically
+ * faster than the brute-force method, but it is also far more complex and
+ * cannot efficiently be applied to small subboxes. It is therefore not
+ * useful for programs intended to be portable to DOS machines. On machines
+ * with plenty of memory, filling the whole histogram in one shot with Thomas'
+ * refined method might be faster than the present code --- but then again,
+ * it might not be any faster, and it's certainly more complicated.
+ */
+
+
+/* log2(histogram cells in update box) for each axis; this can be adjusted */
+#define BOX_C0_LOG (HIST_C0_BITS-3)
+#define BOX_C1_LOG (HIST_C1_BITS-3)
+#define BOX_C2_LOG (HIST_C2_BITS-3)
+#define BOX_C3_LOG (HIST_C3_BITS-3)
+
+#define BOX_C0_ELEMS (1<<BOX_C0_LOG) /* # of hist cells in update box */
+#define BOX_C1_ELEMS (1<<BOX_C1_LOG)
+#define BOX_C2_ELEMS (1<<BOX_C2_LOG)
+#define BOX_C3_ELEMS (1<<BOX_C3_LOG)
+
+#define BOX_C0_SHIFT (C0_SHIFT + BOX_C0_LOG)
+#define BOX_C1_SHIFT (C1_SHIFT + BOX_C1_LOG)
+#define BOX_C2_SHIFT (C2_SHIFT + BOX_C2_LOG)
+#define BOX_C3_SHIFT (C3_SHIFT + BOX_C3_LOG)
+
+
+/*
+ * The next three routines implement inverse colormap filling. They could
+ * all be folded into one big routine, but splitting them up this way saves
+ * some stack space (the mindist[] and bestdist[] arrays need not coexist)
+ * and may allow some compilers to produce better code by registerizing more
+ * inner-loop variables.
+ */
+
+static int
+find_nearby_colors (gdImagePtr im, my_cquantize_ptr cquantize,
+ int minc0, int minc1, int minc2, int minc3, int colorlist[])
+/* Locate the colormap entries close enough to an update box to be candidates
+ * for the nearest entry to some cell(s) in the update box. The update box
+ * is specified by the center coordinates of its first cell. The number of
+ * candidate colormap entries is returned, and their colormap indexes are
+ * placed in colorlist[].
+ * This routine uses Heckbert's "locally sorted search" criterion to select
+ * the colors that need further consideration.
+ */
+{
+ int numcolors = im->colorsTotal;
+ int maxc0, maxc1, maxc2, maxc3;
+ int centerc0, centerc1, centerc2, centerc3;
+ int i, x, ncolors;
+ int minmaxdist, min_dist, max_dist, tdist;
+ int mindist[MAXNUMCOLORS]; /* min distance to colormap entry i */
+
+ /* Compute true coordinates of update box's upper corner and center.
+ * Actually we compute the coordinates of the center of the upper-corner
+ * histogram cell, which are the upper bounds of the volume we care about.
+ * Note that since ">>" rounds down, the "center" values may be closer to
+ * min than to max; hence comparisons to them must be "<=", not "<".
+ */
+ maxc0 = minc0 + ((1 << BOX_C0_SHIFT) - (1 << C0_SHIFT));
+ centerc0 = (minc0 + maxc0) >> 1;
+ maxc1 = minc1 + ((1 << BOX_C1_SHIFT) - (1 << C1_SHIFT));
+ centerc1 = (minc1 + maxc1) >> 1;
+ maxc2 = minc2 + ((1 << BOX_C2_SHIFT) - (1 << C2_SHIFT));
+ centerc2 = (minc2 + maxc2) >> 1;
+ maxc3 = minc3 + ((1 << BOX_C3_SHIFT) - (1 << C3_SHIFT));
+ centerc3 = (minc3 + maxc3) >> 1;
+
+ /* For each color in colormap, find:
+ * 1. its minimum squared-distance to any point in the update box
+ * (zero if color is within update box);
+ * 2. its maximum squared-distance to any point in the update box.
+ * Both of these can be found by considering only the corners of the box.
+ * We save the minimum distance for each color in mindist[];
+ * only the smallest maximum distance is of interest.
+ */
+ minmaxdist = 0x7FFFFFFFL;
+
+ for (i = 0; i < numcolors; i++)
+ {
+ /* We compute the squared-c0-distance term, then add in the other three. */
+ x = im->red[i];
+ if (x < minc0)
+ {
+ tdist = (x - minc0) * C0_SCALE;
+ min_dist = tdist * tdist;
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist * tdist;
+ }
+ else if (x > maxc0)
+ {
+ tdist = (x - maxc0) * C0_SCALE;
+ min_dist = tdist * tdist;
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist * tdist;
+ }
+ else
+ {
+ /* within cell range so no contribution to min_dist */
+ min_dist = 0;
+ if (x <= centerc0)
+ {
+ tdist = (x - maxc0) * C0_SCALE;
+ max_dist = tdist * tdist;
+ }
+ else
+ {
+ tdist = (x - minc0) * C0_SCALE;
+ max_dist = tdist * tdist;
+ }
+ }
+
+ x = im->green[i];
+ if (x < minc1)
+ {
+ tdist = (x - minc1) * C1_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else if (x > maxc1)
+ {
+ tdist = (x - maxc1) * C1_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc1)
+ {
+ tdist = (x - maxc1) * C1_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ tdist = (x - minc1) * C1_SCALE;
+ max_dist += tdist * tdist;
+ }
+ }
+
+ x = im->blue[i];
+ if (x < minc2)
+ {
+ tdist = (x - minc2) * C2_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else if (x > maxc2)
+ {
+ tdist = (x - maxc2) * C2_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc2)
+ {
+ tdist = (x - maxc2) * C2_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ tdist = (x - minc2) * C2_SCALE;
+ max_dist += tdist * tdist;
+ }
+ }
+
+ x = im->alpha[i];
+ if (x < minc3)
+ {
+ tdist = (x - minc3) * C3_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - maxc3) * C3_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else if (x > maxc3)
+ {
+ tdist = (x - maxc3) * C3_SCALE;
+ min_dist += tdist * tdist;
+ tdist = (x - minc3) * C3_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ /* within cell range so no contribution to min_dist */
+ if (x <= centerc3)
+ {
+ tdist = (x - maxc3) * C3_SCALE;
+ max_dist += tdist * tdist;
+ }
+ else
+ {
+ tdist = (x - minc3) * C3_SCALE;
+ max_dist += tdist * tdist;
+ }
+ }
+
+ mindist[i] = min_dist; /* save away the results */
+ if (max_dist < minmaxdist)
+ minmaxdist = max_dist;
+ }
+
+ /* Now we know that no cell in the update box is more than minmaxdist
+ * away from some colormap entry. Therefore, only colors that are
+ * within minmaxdist of some part of the box need be considered.
+ */
+ ncolors = 0;
+ for (i = 0; i < numcolors; i++)
+ {
+ if (mindist[i] <= minmaxdist)
+ colorlist[ncolors++] = i;
+ }
+ return ncolors;
+}
+
+
+static void
+find_best_colors (gdImagePtr im, my_cquantize_ptr cquantize,
+ int minc0, int minc1, int minc2, int minc3,
+ int numcolors, int colorlist[], int bestcolor[])
+/* Find the closest colormap entry for each cell in the update box,
+ * given the list of candidate colors prepared by find_nearby_colors.
+ * Return the indexes of the closest entries in the bestcolor[] array.
+ * This routine uses Thomas' incremental distance calculation method to
+ * find the distance from a colormap entry to successive cells in the box.
+ */
+{
+ int ic0, ic1, ic2, ic3;
+ int i, icolor;
+ register int *bptr; /* pointer into bestdist[] array */
+ int *cptr; /* pointer into bestcolor[] array */
+ int dist0, dist1, dist2; /* initial distance values */
+ register int dist3; /* current distance in inner loop */
+ int xx0, xx1, xx2; /* distance increments */
+ register int xx3;
+ int inc0, inc1, inc2, inc3; /* initial values for increments */
+ /* This array holds the distance to the nearest-so-far color for each cell */
+ int bestdist[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS * BOX_C3_ELEMS];
+
+ /* Initialize best-distance for each cell of the update box */
+ bptr = bestdist;
+ for (i = BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS * BOX_C3_ELEMS - 1; i >= 0; i--)
+ *bptr++ = 0x7FFFFFFFL;
+
+ /* For each color selected by find_nearby_colors,
+ * compute its distance to the center of each cell in the box.
+ * If that's less than best-so-far, update best distance and color number.
+ */
+
+ /* Nominal steps between cell centers ("x" in Thomas article) */
+#define STEP_C0 ((1 << C0_SHIFT) * C0_SCALE)
+#define STEP_C1 ((1 << C1_SHIFT) * C1_SCALE)
+#define STEP_C2 ((1 << C2_SHIFT) * C2_SCALE)
+#define STEP_C3 ((1 << C3_SHIFT) * C3_SCALE)
+
+ for (i = 0; i < numcolors; i++)
+ {
+ icolor = colorlist[i];
+ /* Compute (square of) distance from minc0/c1/c2 to this color */
+ inc0 = (minc0 - (im->red[icolor])) * C0_SCALE;
+ dist0 = inc0 * inc0;
+ inc1 = (minc1 - (im->green[icolor])) * C1_SCALE;
+ dist0 += inc1 * inc1;
+ inc2 = (minc2 - (im->blue[icolor])) * C2_SCALE;
+ dist0 += inc2 * inc2;
+ inc3 = (minc3 - (im->alpha[icolor])) * C3_SCALE;
+ dist0 += inc3 * inc3;
+ /* Form the initial difference increments */
+ inc0 = inc0 * (2 * STEP_C0) + STEP_C0 * STEP_C0;
+ inc1 = inc1 * (2 * STEP_C1) + STEP_C1 * STEP_C1;
+ inc2 = inc2 * (2 * STEP_C2) + STEP_C2 * STEP_C2;
+ inc3 = inc3 * (2 * STEP_C3) + STEP_C3 * STEP_C3;
+ /* Now loop over all cells in box, updating distance per Thomas method */
+ bptr = bestdist;
+ cptr = bestcolor;
+ xx0 = inc0;
+ for (ic0 = BOX_C0_ELEMS - 1; ic0 >= 0; ic0--)
+ {
+ dist1 = dist0;
+ xx1 = inc1;
+ for (ic1 = BOX_C1_ELEMS - 1; ic1 >= 0; ic1--)
+ {
+ dist2 = dist1;
+ xx2 = inc2;
+ for (ic2 = BOX_C2_ELEMS - 1; ic2 >= 0; ic2--)
+ {
+ for (ic3 = BOX_C3_ELEMS - 1; ic3 >= 0; ic3--)
+ {
+ if (dist3 < *bptr)
+ {
+ *bptr = dist3;
+ *cptr = icolor;
+ }
+ dist3 += xx3;
+ xx3 += 2 * STEP_C3 * STEP_C3;
+ bptr++;
+ cptr++;
+ }
+ dist2 += xx2;
+ xx2 += 2 * STEP_C2 * STEP_C2;
+ }
+ dist1 += xx1;
+ xx1 += 2 * STEP_C1 * STEP_C1;
+ }
+ dist0 += xx0;
+ xx0 += 2 * STEP_C0 * STEP_C0;
+ }
+ }
+}
+
+
+static void
+fill_inverse_cmap (gdImagePtr im, my_cquantize_ptr cquantize,
+ int c0, int c1, int c2, int c3)
+/* Fill the inverse-colormap entries in the update box that contains */
+/* histogram cell c0/c1/c2/c3. (Only that one cell MUST be filled, but */
+/* we can fill as many others as we wish.) */
+{
+ hist4d histogram = cquantize->histogram;
+ int minc0, minc1, minc2, minc3; /* lower left corner of update box */
+ int ic0, ic1, ic2, ic3;
+ register int *cptr; /* pointer into bestcolor[] array */
+ register histptr cachep; /* pointer into main cache array */
+ /* This array lists the candidate colormap indexes. */
+ int colorlist[MAXNUMCOLORS];
+ int numcolors; /* number of candidate colors */
+ /* This array holds the actually closest colormap index for each cell. */
+ int bestcolor[BOX_C0_ELEMS * BOX_C1_ELEMS * BOX_C2_ELEMS * BOX_C3_ELEMS];
+
+ /* Convert cell coordinates to update box ID */
+ c0 >>= BOX_C0_LOG;
+ c1 >>= BOX_C1_LOG;
+ c2 >>= BOX_C2_LOG;
+ c3 >>= BOX_C3_LOG;
+
+ /* Compute true coordinates of update box's origin corner.
+ * Actually we compute the coordinates of the center of the corner
+ * histogram cell, which are the lower bounds of the volume we care about.
+ */
+ minc0 = (c0 << BOX_C0_SHIFT) + ((1 << C0_SHIFT) >> 1);
+ minc1 = (c1 << BOX_C1_SHIFT) + ((1 << C1_SHIFT) >> 1);
+ minc2 = (c2 << BOX_C2_SHIFT) + ((1 << C2_SHIFT) >> 1);
+ minc3 = (c3 << BOX_C3_SHIFT) + ((1 << C3_SHIFT) >> 1);
+ /* Determine which colormap entries are close enough to be candidates
+ * for the nearest entry to some cell in the update box.
+ */
+ numcolors = find_nearby_colors (im, cquantize, minc0, minc1, minc2, minc3, colorlist);
+
+ /* Determine the actually nearest colors. */
+ find_best_colors (im, cquantize, minc0, minc1, minc2, minc3, numcolors, colorlist,
+ bestcolor);
+
+ /* Save the best color numbers (plus 1) in the main cache array */
+ c0 <<= BOX_C0_LOG; /* convert ID back to base cell indexes */
+ c1 <<= BOX_C1_LOG;
+ c2 <<= BOX_C2_LOG;
+ c3 <<= BOX_C3_LOG;
+ cptr = bestcolor;
+ for (ic0 = 0; ic0 < BOX_C0_ELEMS; ic0++)
+ {
+ for (ic1 = 0; ic1 < BOX_C1_ELEMS; ic1++)
+ {
+ for (ic2 = 0; ic2 < BOX_C2_ELEMS; ic2++)
+ {
+ cachep = &histogram[c0 + ic0][c1 + ic1][c2 + ic2][c3];
+ for (ic3 = 0; ic3 < BOX_C3_ELEMS; ic3++)
+ {
+ *cachep++ = (histcell) ((*cptr++) + 1);
+ }
+ }
+ }
+ }
+}
+
+
+/*
+ * Map some rows of pixels to the output colormapped representation.
+ */
+
+void
+pass2_no_dither (gdImagePtr im, my_cquantize_ptr cquantize)
+/* This version performs no dithering */
+{
+ hist4d histogram = cquantize->histogram;
+ register int *inptr;
+ register unsigned char *outptr;
+ register histptr cachep;
+ register int c0, c1, c2, c3;
+ int row;
+ int col;
+ int width = im->sx;
+ int num_rows = im->sy;
+ for (row = 0; row < num_rows; row++)
+ {
+ inptr = im->tpixels[row];
+ outptr = im->pixels[row];
+ for (col = 0; col < width; col++)
+ {
+ int r, g, b, a;
+ /* get pixel value and index into the cache */
+ r = gdTrueColorGetRed (*inptr);
+ g = gdTrueColorGetGreen (*inptr);
+ b = gdTrueColorGetBlue (*inptr);
+ a = gdTrueColorGetAlpha (*inptr++);
+ c0 = r >> C0_SHIFT;
+ c1 = g >> C1_SHIFT;
+ c2 = b >> C2_SHIFT;
+ c3 = a >> C3_SHIFT;
+ cachep = &histogram[c0][c1][c2][c3];
+ /* If we have not seen this color before, find nearest colormap entry */
+ /* and update the cache */
+ if (*cachep == 0)
+ {
+#if 0
+ /* TBB: quick and dirty approach for use when testing
+ fill_inverse_cmap for errors */
+ int i;
+ int best = -1;
+ int mindist = 0x7FFFFFFF;
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ int rdist = (im->red[i] >> C0_SHIFT) - c0;
+ int gdist = (im->green[i] >> C1_SHIFT) - c1;
+ int bdist = (im->blue[i] >> C2_SHIFT) - c2;
+ int adist = (im->alpha[i] >> C3_SHIFT) - c3;
+ int dist = (rdist * rdist) * R_SCALE +
+ (gdist * gdist) * G_SCALE +
+ (bdist * bdist) * B_SCALE +
+ (adist * adist) * A_SCALE;
+ if (dist < mindist)
+ {
+ best = i;
+ mindist = dist;
+ }
+ }
+ *cachep = best + 1;
+#endif
+ fill_inverse_cmap (im, cquantize, c0, c1, c2, c3);
+ }
+ /* Now emit the colormap index for this cell */
+ *outptr++ = (*cachep - 1);
+ }
+ }
+}
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity. This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit. But some
+ * C compilers implement >> with an unsigned shift. For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts. SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft) \
+ ((shift_temp = (x)) < 0 ? \
+ (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+ (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+
+void
+pass2_fs_dither (gdImagePtr im, my_cquantize_ptr cquantize)
+
+/* This version performs Floyd-Steinberg dithering */
+{
+ hist4d histogram = cquantize->histogram;
+ register LOCFSERROR cur0, cur1, cur2, cur3; /* current error or pixel value */
+ LOCFSERROR belowerr0, belowerr1, belowerr2, belowerr3; /* error for pixel below cur */
+ LOCFSERROR bpreverr0, bpreverr1, bpreverr2, bpreverr3; /* error for below/prev col */
+ register FSERRPTR errorptr; /* => fserrors[] at column before current */
+ int *inptr; /* => current input pixel */
+ unsigned char *outptr; /* => current output pixel */
+ histptr cachep;
+ int dir; /* +1 or -1 depending on direction */
+ int dir4; /* 4*dir, for advancing errorptr */
+ int row;
+ int col;
+ int width = im->sx;
+ int num_rows = im->sy;
+ int *error_limit = cquantize->error_limiter;
+ int *colormap0 = im->red;
+ int *colormap1 = im->green;
+ int *colormap2 = im->blue;
+ int *colormap3 = im->alpha;
+ SHIFT_TEMPS
+
+ for (row = 0; row < num_rows; row++)
+ {
+ inptr = im->tpixels[row];
+ outptr = im->pixels[row];
+ if (cquantize->on_odd_row)
+ {
+ /* work right to left in this row */
+ inptr += (width - 1); /* so point to rightmost pixel */
+ outptr += width - 1;
+ dir = -1;
+ dir4 = -4;
+ errorptr = cquantize->fserrors + (width + 1) * 4; /* => entry after last column */
+ cquantize->on_odd_row = FALSE; /* flip for next time */
+ }
+ else
+ {
+ /* work left to right in this row */
+ dir = 1;
+ dir4 = 4;
+ errorptr = cquantize->fserrors; /* => entry before first real column */
+ cquantize->on_odd_row = TRUE; /* flip for next time */
+ }
+ /* Preset error values: no error propagated to first pixel from left */
+ cur0 = cur1 = cur2 = cur3 = 0;
+ /* and no error propagated to row below yet */
+ belowerr0 = belowerr1 = belowerr2 = belowerr3 = 0;
+ bpreverr0 = bpreverr1 = bpreverr2 = bpreverr3 = 0;
+
+ for (col = width; col > 0; col--)
+ {
+ int a;
+ /* curN holds the error propagated from the previous pixel on the
+ * current line. Add the error propagated from the previous line
+ * to form the complete error correction term for this pixel, and
+ * round the error term (which is expressed * 16) to an integer.
+ * RIGHT_SHIFT rounds towards minus infinity, so adding 8 is correct
+ * for either sign of the error value.
+ * Note: errorptr points to *previous* column's array entry.
+ */
+ cur0 = RIGHT_SHIFT (cur0 + errorptr[dir4 + 0] + 8, 4);
+ cur1 = RIGHT_SHIFT (cur1 + errorptr[dir4 + 1] + 8, 4);
+ cur2 = RIGHT_SHIFT (cur2 + errorptr[dir4 + 2] + 8, 4);
+ cur3 = RIGHT_SHIFT (cur3 + errorptr[dir4 + 3] + 8, 4);
+ /* Limit the error using transfer function set by init_error_limit.
+ * See comments with init_error_limit for rationale.
+ */
+ cur0 = error_limit[cur0];
+ cur1 = error_limit[cur1];
+ cur2 = error_limit[cur2];
+ cur3 = error_limit[cur3];
+ /* Form pixel value + error, and range-limit to 0..MAXJSAMPLE.
+ * The maximum error is +- MAXJSAMPLE (or less with error limiting);
+ * but we'll be lazy and just clamp this with an if test (TBB).
+ */
+ cur0 += gdTrueColorGetRed (*inptr);
+ cur1 += gdTrueColorGetGreen (*inptr);
+ cur2 += gdTrueColorGetBlue (*inptr);
+ /* Expand to 8 bits for consistency with dithering algorithm -- TBB */
+ a = gdTrueColorGetAlpha (*inptr);
+ cur3 += (a << 1) + (a >> 6);
+ if (cur0 < 0)
+ {
+ cur0 = 0;
+ }
+ if (cur0 > 255)
+ {
+ cur0 = 255;
+ }
+ if (cur1 < 0)
+ {
+ cur1 = 0;
+ }
+ if (cur1 > 255)
+ {
+ cur1 = 255;
+ }
+ if (cur2 < 0)
+ {
+ cur2 = 0;
+ }
+ if (cur2 > 255)
+ {
+ cur2 = 255;
+ }
+ if (cur3 < 0)
+ {
+ cur3 = 0;
+ }
+ if (cur3 > 255)
+ {
+ cur3 = 255;
+ }
+ /* Index into the cache with adjusted pixel value */
+ cachep = &histogram
+ [cur0 >> C0_SHIFT]
+ [cur1 >> C1_SHIFT]
+ [cur2 >> C2_SHIFT]
+ [cur3 >> (C3_SHIFT + 1)];
+ /* If we have not seen this color before, find nearest colormap */
+ /* entry and update the cache */
+ if (*cachep == 0)
+ fill_inverse_cmap (im, cquantize,
+ cur0 >> C0_SHIFT, cur1 >> C1_SHIFT, cur2 >> C2_SHIFT,
+ cur3 >> (C3_SHIFT + 1));
+ /* Now emit the colormap index for this cell */
+ {
+ register int pixcode = *cachep - 1;
+ *outptr = pixcode;
+ /* Compute representation error for this pixel */
+ cur0 -= colormap0[pixcode];
+ cur1 -= colormap1[pixcode];
+ cur2 -= colormap2[pixcode];
+ cur3 -= ((colormap3[pixcode] << 1) + (colormap3[pixcode] >> 6));
+ }
+ /* Compute error fractions to be propagated to adjacent pixels.
+ * Add these into the running sums, and simultaneously shift the
+ * next-line error sums left by 1 column.
+ */
+ {
+ register LOCFSERROR bnexterr, delta;
+
+ bnexterr = cur0; /* Process component 0 */
+ delta = cur0 * 2;
+ cur0 += delta; /* form error * 3 */
+ errorptr[0] = (FSERROR) (bpreverr0 + cur0);
+ cur0 += delta; /* form error * 5 */
+ bpreverr0 = belowerr0 + cur0;
+ belowerr0 = bnexterr;
+ cur0 += delta; /* form error * 7 */
+ bnexterr = cur1; /* Process component 1 */
+ delta = cur1 * 2;
+ cur1 += delta; /* form error * 3 */
+ errorptr[1] = (FSERROR) (bpreverr1 + cur1);
+ cur1 += delta; /* form error * 5 */
+ bpreverr1 = belowerr1 + cur1;
+ belowerr1 = bnexterr;
+ cur1 += delta; /* form error * 7 */
+ bnexterr = cur2; /* Process component 2 */
+ delta = cur2 * 2;
+ cur2 += delta; /* form error * 3 */
+ errorptr[2] = (FSERROR) (bpreverr2 + cur2);
+ cur2 += delta; /* form error * 5 */
+ bpreverr2 = belowerr2 + cur2;
+ belowerr2 = bnexterr;
+ cur2 += delta; /* form error * 7 */
+ bnexterr = cur3; /* Process component 3 */
+ delta = cur3 * 2;
+ cur3 += delta; /* form error * 3 */
+ errorptr[3] = (FSERROR) (bpreverr3 + cur3);
+ cur3 += delta; /* form error * 5 */
+ bpreverr3 = belowerr3 + cur3;
+ belowerr3 = bnexterr;
+ cur3 += delta; /* form error * 7 */
+ }
+ /* At this point curN contains the 7/16 error value to be propagated
+ * to the next pixel on the current line, and all the errors for the
+ * next line have been shifted over. We are therefore ready to move on.
+ */
+ inptr += dir; /* Advance pixel pointers to next column */
+ outptr += dir;
+ errorptr += dir4; /* advance errorptr to current column */
+ }
+ /* Post-loop cleanup: we must unload the final error values into the
+ * final fserrors[] entry. Note we need not unload belowerrN because
+ * it is for the dummy column before or after the actual array.
+ */
+ errorptr[0] = (FSERROR) bpreverr0; /* unload prev errs into array */
+ errorptr[1] = (FSERROR) bpreverr1;
+ errorptr[2] = (FSERROR) bpreverr2;
+ errorptr[3] = (FSERROR) bpreverr3;
+ }
+}
+
+
+/*
+ * Initialize the error-limiting transfer function (lookup table).
+ * The raw F-S error computation can potentially compute error values of up to
+ * +- MAXJSAMPLE. But we want the maximum correction applied to a pixel to be
+ * much less, otherwise obviously wrong pixels will be created. (Typical
+ * effects include weird fringes at color-area boundaries, isolated bright
+ * pixels in a dark area, etc.) The standard advice for avoiding this problem
+ * is to ensure that the "corners" of the color cube are allocated as output
+ * colors; then repeated errors in the same direction cannot cause cascading
+ * error buildup. However, that only prevents the error from getting
+ * completely out of hand; Aaron Giles reports that error limiting improves
+ * the results even with corner colors allocated.
+ * A simple clamping of the error values to about +- MAXJSAMPLE/8 works pretty
+ * well, but the smoother transfer function used below is even better. Thanks
+ * to Aaron Giles for this idea.
+ */
+
+static int
+init_error_limit (gdImagePtr im, my_cquantize_ptr cquantize)
+/* Allocate and fill in the error_limiter table */
+{
+ int *table;
+ int in, out;
+
+ cquantize->error_limiter_storage = (int *) gdMalloc ((255 * 2 + 1) * sizeof (int));
+ if (!cquantize->error_limiter_storage)
+ {
+ return 0;
+ }
+ /* so can index -MAXJSAMPLE .. +MAXJSAMPLE */
+ cquantize->error_limiter = cquantize->error_limiter_storage + 255;
+ table = cquantize->error_limiter;
+#define STEPSIZE ((255+1)/16)
+ /* Map errors 1:1 up to +- MAXJSAMPLE/16 */
+ out = 0;
+ for (in = 0; in < STEPSIZE; in++, out++)
+ {
+ table[in] = out;
+ table[-in] = -out;
+ }
+ /* Map errors 1:2 up to +- 3*MAXJSAMPLE/16 */
+ for (; in < STEPSIZE * 3; in++, out += (in & 1) ? 0 : 1)
+ {
+ table[in] = out;
+ table[-in] = -out;
+ }
+ /* Clamp the rest to final out value (which is (MAXJSAMPLE+1)/8) */
+ for (; in <= 255; in++)
+ {
+ table[in] = out;
+ table[-in] = -out;
+ }
+#undef STEPSIZE
+ return 1;
+}
+
+static void
+zeroHistogram (hist4d histogram)
+{
+ int i;
+ int j;
+ /* Zero the histogram or inverse color map */
+ for (i = 0; i < HIST_C0_ELEMS; i++)
+ {
+ for (j = 0; j < HIST_C1_ELEMS; j++)
+ {
+ memset (histogram[i][j],
+ 0,
+ HIST_C2_ELEMS * HIST_C3_ELEMS * sizeof (histcell));
+ }
+ }
+}
+
+/* Here we go at last. */
+void
+gdImageTrueColorToPalette (gdImagePtr im, int dither, int colorsWanted)
+{
+ my_cquantize_ptr cquantize = 0;
+ int i;
+ size_t arraysize;
+ if (!im->trueColor)
+ {
+ /* Nothing to do! */
+ return;
+ }
+ if (colorsWanted > gdMaxColors)
+ {
+ colorsWanted = gdMaxColors;
+ }
+ im->pixels = gdCalloc (sizeof (unsigned char *), im->sy);
+ if (!im->pixels)
+ {
+ /* No can do */
+ goto outOfMemory;
+ }
+ for (i = 0; (i < im->sy); i++)
+ {
+ im->pixels[i] = gdCalloc (sizeof (unsigned char *), im->sx);
+ if (!im->pixels[i])
+ {
+ goto outOfMemory;
+ }
+ }
+ cquantize = (my_cquantize_ptr) gdCalloc (sizeof (my_cquantizer), 1);
+ if (!cquantize)
+ {
+ /* No can do */
+ goto outOfMemory;
+ }
+ /* Allocate the histogram/inverse colormap storage */
+ cquantize->histogram = (hist4d) gdMalloc (HIST_C0_ELEMS * sizeof (hist3d));
+ for (i = 0; i < HIST_C0_ELEMS; i++)
+ {
+ int j;
+ cquantize->histogram[i] = (hist3d) gdCalloc (HIST_C1_ELEMS,
+ sizeof (hist2d));
+ if (!cquantize->histogram[i])
+ {
+ goto outOfMemory;
+ }
+ for (j = 0; (j < HIST_C1_ELEMS); j++)
+ {
+ cquantize->histogram[i][j] = (hist2d) gdCalloc (HIST_C2_ELEMS * HIST_C3_ELEMS,
+ sizeof (histcell));
+ if (!cquantize->histogram[i][j])
+ {
+ goto outOfMemory;
+ }
+ }
+ }
+ cquantize->fserrors = (FSERRPTR) gdMalloc (4 * sizeof (FSERROR));
+ init_error_limit (im, cquantize);
+ arraysize = (size_t) ((im->sx + 2) *
+ (4 * sizeof (FSERROR)));
+ /* Allocate Floyd-Steinberg workspace. */
+ cquantize->fserrors = gdCalloc (arraysize, 1);
+ if (!cquantize->fserrors)
+ {
+ goto outOfMemory;
+ }
+ cquantize->on_odd_row = FALSE;
+
+ /* Do the work! */
+ zeroHistogram (cquantize->histogram);
+ prescan_quantize (im, cquantize);
+ select_colors (im, cquantize, 256);
+ /* TBB HACK REMOVE */
+ {
+ FILE *out = fopen ("palettemap.png", "wb");
+ int i;
+ gdImagePtr im2 = gdImageCreateTrueColor (256, 256);
+ for (i = 0; (i < 256); i++)
+ {
+ gdImageFilledRectangle (im2, (i % 16) * 16, (i / 16) * 16,
+ (i % 16) * 16 + 15, (i / 16) * 16 + 15,
+ gdTrueColorAlpha (im->red[i], im->green[i],
+ im->blue[i], im->alpha[i]));
+ }
+ gdImagePng (im2, out);
+ fclose (out);
+ gdImageDestroy (im2);
+ }
+ zeroHistogram (cquantize->histogram);
+ if (dither)
+ {
+ pass2_fs_dither (im, cquantize);
+ }
+ else
+ {
+ pass2_no_dither (im, cquantize);
+ }
+ if (cquantize->transparentIsPresent)
+ {
+ int mt = -1;
+ int mtIndex = -1;
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if (im->alpha[i] > mt)
+ {
+ mtIndex = i;
+ mt = im->alpha[i];
+ }
+ }
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if (im->alpha[i] == mt)
+ {
+ im->alpha[i] = gdAlphaTransparent;
+ }
+ }
+ }
+ if (cquantize->opaqueIsPresent)
+ {
+ int mo = 128;
+ int moIndex = -1;
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if (im->alpha[i] < mo)
+ {
+ moIndex = i;
+ mo = im->alpha[i];
+ }
+ }
+ for (i = 0; (i < im->colorsTotal); i++)
+ {
+ if (im->alpha[i] == mo)
+ {
+ im->alpha[i] = gdAlphaOpaque;
+ }
+ }
+ }
+ /* Success! Get rid of the truecolor image data. */
+ im->trueColor = 0;
+ /* Junk the truecolor pixels */
+ for (i = 0; i < im->sy; i++)
+ {
+ gdFree (im->tpixels[i]);
+ }
+ gdFree (im->tpixels);
+ im->tpixels = 0;
+ /* Tediously free stuff. */
+outOfMemory:
+ if (im->trueColor)
+ {
+ /* On failure only */
+ for (i = 0; i < im->sy; i++)
+ {
+ if (im->pixels[i])
+ {
+ gdFree (im->pixels[i]);
+ }
+ }
+ if (im->pixels)
+ {
+ gdFree (im->pixels);
+ }
+ im->pixels = 0;
+ }
+ for (i = 0; i < HIST_C0_ELEMS; i++)
+ {
+ if (cquantize->histogram[i])
+ {
+ int j;
+ for (j = 0; j < HIST_C1_ELEMS; j++)
+ {
+ if (cquantize->histogram[i][j])
+ {
+ gdFree (cquantize->histogram[i][j]);
+ }
+ }
+ gdFree (cquantize->histogram[i]);
+ }
+ }
+ if (cquantize->histogram)
+ {
+ gdFree (cquantize->histogram);
+ }
+ if (cquantize->fserrors)
+ {
+ gdFree (cquantize->fserrors);
+ }
+ if (cquantize->error_limiter_storage)
+ {
+ gdFree (cquantize->error_limiter_storage);
+ }
+ if (cquantize)
+ {
+ gdFree (cquantize);
+ }
+}
--- /dev/null
+
+
+/*
+ WBMP: Wireless Bitmap Type 0: B/W, Uncompressed Bitmap
+ Specification of the WBMP format can be found in the file:
+ SPEC-WAESpec-19990524.pdf
+ You can download the WAP specification on: http://www.wapforum.com/
+
+ gd_wbmp.c
+
+ Copyright (C) Johan Van den Brande (johan@vandenbrande.com)
+
+ Fixed: gdImageWBMPPtr, gdImageWBMP
+
+ Recoded: gdImageWBMPCtx for use with my wbmp library
+ (wbmp library included, but you can find the latest distribution
+ at http://www.vandenbrande.com/wbmp)
+
+ Implemented: gdImageCreateFromWBMPCtx, gdImageCreateFromWBMP
+
+ ---------------------------------------------------------------------------
+
+ Parts of this code are from Maurice Smurlo.
+
+
+ ** Copyright (C) Maurice Szmurlo --- T-SIT --- January 2000
+ ** (Maurice.Szmurlo@info.unicaen.fr)
+
+ ** 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. This software is provided "as is" without express or
+ ** implied warranty.
+
+ ---------------------------------------------------------------------------
+ Parts od this code are inspired by 'pbmtowbmp.c' and 'wbmptopbm.c' by
+ Terje Sannum <terje@looplab.com>.
+ **
+ ** 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. This software is provided "as is" without express or
+ ** implied warranty.
+ **
+ ---------------------------------------------------------------------------
+
+ Todo:
+
+ gdCreateFromWBMP function for reading WBMP files
+
+ ----------------------------------------------------------------------------
+ */
+
+#include <gd.h>
+#include <gdfonts.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include "wbmp.h"
+
+
+/* gd_putout
+ ** ---------
+ ** Wrapper around gdPutC for use with writewbmp
+ **
+ */
+void
+gd_putout (int i, void *out)
+{
+ gdPutC (i, (gdIOCtx *) out);
+}
+
+
+/* gd_getin
+ ** --------
+ ** Wrapper around gdGetC for use with readwbmp
+ **
+ */
+int
+gd_getin (void *in)
+{
+ return (gdGetC ((gdIOCtx *) in));
+}
+
+
+/* gdImageWBMPCtx
+ ** --------------
+ ** Write the image as a wbmp file
+ ** Parameters are:
+ ** image: gd image structure;
+ ** fg: the index of the foreground color. any other value will be
+ ** considered as background and will not be written
+ ** out: the stream where to write
+ */
+void
+gdImageWBMPCtx (gdImagePtr image, int fg, gdIOCtx * out)
+{
+
+ int x, y, pos;
+ Wbmp *wbmp;
+
+
+ /* create the WBMP */
+ if ((wbmp = createwbmp (gdImageSX (image), gdImageSY (image), WBMP_WHITE)) == NULL)
+ fprintf (stderr, "Could not create WBMP\n");
+
+ /* fill up the WBMP structure */
+ pos = 0;
+ for (y = 0; y < gdImageSY (image); y++)
+ {
+ for (x = 0; x < gdImageSX (image); x++)
+ {
+ if (gdImageGetPixel (image, x, y) == fg)
+ {
+ wbmp->bitmap[pos] = WBMP_BLACK;
+ }
+ pos++;
+ }
+ }
+
+ /* write the WBMP to a gd file descriptor */
+ if (writewbmp (wbmp, &gd_putout, out))
+ fprintf (stderr, "Could not save WBMP\n");
+ /* des submitted this bugfix: gdFree the memory. */
+ freewbmp (wbmp);
+}
+
+
+/* gdImageCreateFromWBMPCtx
+ ** ------------------------
+ ** Create a gdImage from a WBMP file input from an gdIOCtx
+ */
+gdImagePtr
+gdImageCreateFromWBMPCtx (gdIOCtx * infile)
+{
+ /* FILE *wbmp_file; */
+ Wbmp *wbmp;
+ gdImagePtr im = NULL;
+ int black, white;
+ int col, row, pos;
+
+ if (readwbmp (&gd_getin, infile, &wbmp))
+ return (NULL);
+
+ if (!(im = gdImageCreate (wbmp->width, wbmp->height)))
+ {
+ freewbmp (wbmp);
+ return (NULL);
+ }
+
+ /* create the background color */
+ white = gdImageColorAllocate (im, 255, 255, 255);
+ /* create foreground color */
+ black = gdImageColorAllocate (im, 0, 0, 0);
+
+ /* fill in image (in a wbmp 1 = white/ 0 = black) */
+ pos = 0;
+ for (row = 0; row < wbmp->height; row++)
+ {
+ for (col = 0; col < wbmp->width; col++)
+ {
+ if (wbmp->bitmap[pos++] == WBMP_WHITE)
+ {
+ gdImageSetPixel (im, col, row, white);
+ }
+ else
+ {
+ gdImageSetPixel (im, col, row, black);
+ }
+ }
+ }
+
+ freewbmp (wbmp);
+
+ return (im);
+}
+
+
+/* gdImageCreateFromWBMP
+ ** ---------------------
+ */
+gdImagePtr
+gdImageCreateFromWBMP (FILE * inFile)
+{
+ gdImagePtr im;
+ gdIOCtx *in = gdNewFileCtx (inFile);
+ im = gdImageCreateFromWBMPCtx (in);
+ in->free (in);
+ return (im);
+}
+
+/* gdImageWBMP
+ ** -----------
+ */
+void
+gdImageWBMP (gdImagePtr im, int fg, FILE * outFile)
+{
+ gdIOCtx *out = gdNewFileCtx (outFile);
+ gdImageWBMPCtx (im, fg, out);
+ out->free (out);
+}
+
+/* gdImageWBMPPtr
+ ** --------------
+ */
+void *
+gdImageWBMPPtr (gdImagePtr im, int *size, int fg)
+{
+ void *rv;
+ gdIOCtx *out = gdNewDynamicCtx (2048, NULL);
+ gdImageWBMPCtx (im, fg, out);
+ rv = gdDPExtractData (out, size);
+ out->free (out);
+ return rv;
+}
--- /dev/null
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifdef HAVE_LIBTTF
+#define NEED_CACHE 1
+#else
+#ifdef HAVE_LIBFREETYPE
+#define NEED_CACHE 1
+#endif
+#endif
+
+#ifdef NEED_CACHE
+
+/*
+ * gdcache.c
+ *
+ * Caches of pointers to user structs in which the least-recently-used
+ * element is replaced in the event of a cache miss after the cache has
+ * reached a given size.
+ *
+ * John Ellson (ellson@lucent.com) Oct 31, 1997
+ *
+ * Test this with:
+ * gcc -o gdcache -g -Wall -DTEST gdcache.c
+ *
+ * The cache is implemented by a singly-linked list of elements
+ * each containing a pointer to a user struct that is being managed by
+ * the cache.
+ *
+ * The head structure has a pointer to the most-recently-used
+ * element, and elements are moved to this position in the list each
+ * time they are used. The head also contains pointers to three
+ * user defined functions:
+ * - a function to test if a cached userdata matches some keydata
+ * - a function to provide a new userdata struct to the cache
+ * if there has been a cache miss.
+ * - a function to release a userdata struct when it is
+ * no longer being managed by the cache
+ *
+ * In the event of a cache miss the cache is allowed to grow up to
+ * a specified maximum size. After the maximum size is reached then
+ * the least-recently-used element is discarded to make room for the
+ * new. The most-recently-returned value is always left at the
+ * beginning of the list after retrieval.
+ *
+ * In the current implementation the cache is traversed by a linear
+ * search from most-recent to least-recent. This linear search
+ * probably limits the usefulness of this implementation to cache
+ * sizes of a few tens of elements.
+ */
+
+#include "gdcache.h"
+
+/*********************************************************/
+/* implementation */
+/*********************************************************/
+
+
+/* create a new cache */
+gdCache_head_t *
+gdCacheCreate (
+ int size,
+ gdCacheTestFn_t gdCacheTest,
+ gdCacheFetchFn_t gdCacheFetch,
+ gdCacheReleaseFn_t gdCacheRelease)
+{
+ gdCache_head_t *head;
+
+ head = (gdCache_head_t *) gdMalloc (sizeof (gdCache_head_t));
+ head->mru = NULL;
+ head->size = size;
+ head->gdCacheTest = gdCacheTest;
+ head->gdCacheFetch = gdCacheFetch;
+ head->gdCacheRelease = gdCacheRelease;
+ return head;
+}
+
+void
+gdCacheDelete (gdCache_head_t * head)
+{
+ gdCache_element_t *elem, *prev;
+
+ elem = head->mru;
+ while (elem)
+ {
+ (*(head->gdCacheRelease)) (elem->userdata);
+ prev = elem;
+ elem = elem->next;
+ gdFree ((char *) prev);
+ }
+ gdFree ((char *) head);
+}
+
+void *
+gdCacheGet (gdCache_head_t * head, void *keydata)
+{
+ int i = 0;
+ gdCache_element_t *elem, *prev = NULL, *prevprev = NULL;
+ void *userdata;
+
+ elem = head->mru;
+ while (elem)
+ {
+ if ((*(head->gdCacheTest)) (elem->userdata, keydata))
+ {
+ if (i)
+ { /* if not already most-recently-used */
+ /* relink to top of list */
+ prev->next = elem->next;
+ elem->next = head->mru;
+ head->mru = elem;
+ }
+ return elem->userdata;
+ }
+ prevprev = prev;
+ prev = elem;
+ elem = elem->next;
+ i++;
+ }
+ userdata = (*(head->gdCacheFetch)) (&(head->error), keydata);
+ if (!userdata)
+ {
+ /* if there was an error in the fetch then don't cache */
+ return NULL;
+ }
+ if (i < head->size)
+ { /* cache still growing - add new elem */
+ elem = (gdCache_element_t *) gdMalloc (sizeof (gdCache_element_t));
+ }
+ else
+ { /* cache full - replace least-recently-used */
+ /* preveprev becomes new end of list */
+ prevprev->next = NULL;
+ elem = prev;
+ (*(head->gdCacheRelease)) (elem->userdata);
+ }
+ /* relink to top of list */
+ elem->next = head->mru;
+ head->mru = elem;
+ elem->userdata = userdata;
+ return userdata;
+}
+
+
+
+/*********************************************************/
+/* test stub */
+/*********************************************************/
+
+
+#ifdef TEST
+
+#include <stdio.h>
+
+typedef struct
+{
+ int key;
+ int value;
+}
+key_value_t;
+
+static int
+cacheTest (void *map, void *key)
+{
+ return (((key_value_t *) map)->key == *(int *) key);
+}
+
+static void *
+cacheFetch (char **error, void *key)
+{
+ key_value_t *map;
+
+ map = (key_value_t *) gdMalloc (sizeof (key_value_t));
+ map->key = *(int *) key;
+ map->value = 3;
+
+ *error = NULL;
+ return (void *) map;
+}
+
+static void
+cacheRelease (void *map)
+{
+ gdFree ((char *) map);
+}
+
+int
+main (char *argv[], int argc)
+{
+ gdCache_head_t *cacheTable;
+ int elem, key;
+
+ cacheTable = gdCacheCreate (3, cacheTest, cacheFetch, cacheRelease);
+
+ key = 20;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+ key = 30;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+ key = 40;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+ key = 50;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+ key = 30;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+ key = 30;
+ elem = *(int *) gdCacheGet (cacheTable, &key);
+
+ gdCacheDelete (cacheTable);
+
+ return 0;
+}
+
+#endif /* TEST */
+#endif /* HAVE_LIBTTF */
--- /dev/null
+/*
+ * gdcache.h
+ *
+ * Caches of pointers to user structs in which the least-recently-used
+ * element is replaced in the event of a cache miss after the cache has
+ * reached a given size.
+ *
+ * John Ellson (ellson@lucent.com) Oct 31, 1997
+ *
+ * Test this with:
+ * gcc -o gdcache -g -Wall -DTEST gdcache.c
+ *
+ * The cache is implemented by a singly-linked list of elements
+ * each containing a pointer to a user struct that is being managed by
+ * the cache.
+ *
+ * The head structure has a pointer to the most-recently-used
+ * element, and elements are moved to this position in the list each
+ * time they are used. The head also contains pointers to three
+ * user defined functions:
+ * - a function to test if a cached userdata matches some keydata
+ * - a function to provide a new userdata struct to the cache
+ * if there has been a cache miss.
+ * - a function to release a userdata struct when it is
+ * no longer being managed by the cache
+ *
+ * In the event of a cache miss the cache is allowed to grow up to
+ * a specified maximum size. After the maximum size is reached then
+ * the least-recently-used element is discarded to make room for the
+ * new. The most-recently-returned value is always left at the
+ * beginning of the list after retrieval.
+ *
+ * In the current implementation the cache is traversed by a linear
+ * search from most-recent to least-recent. This linear search
+ * probably limits the usefulness of this implementation to cache
+ * sizes of a few tens of elements.
+ */
+
+/*********************************************************/
+/* header */
+/*********************************************************/
+
+#include <malloc.h>
+#ifndef NULL
+#define NULL (void *)0
+#endif
+
+/* user defined function templates */
+typedef int (*gdCacheTestFn_t)(void *userdata, void *keydata);
+typedef void *(*gdCacheFetchFn_t)(char **error, void *keydata);
+typedef void (*gdCacheReleaseFn_t)(void *userdata);
+
+/* element structure */
+typedef struct gdCache_element_s gdCache_element_t;
+struct gdCache_element_s {
+ gdCache_element_t *next;
+ void *userdata;
+};
+
+/* head structure */
+typedef struct gdCache_head_s gdCache_head_t;
+struct gdCache_head_s {
+ gdCache_element_t *mru;
+ int size;
+ char *error;
+ gdCacheTestFn_t gdCacheTest;
+ gdCacheFetchFn_t gdCacheFetch;
+ gdCacheReleaseFn_t gdCacheRelease;
+};
+
+/* function templates */
+gdCache_head_t *
+gdCacheCreate(
+ int size,
+ gdCacheTestFn_t gdCacheTest,
+ gdCacheFetchFn_t gdCacheFetch,
+ gdCacheReleaseFn_t gdCacheRelease );
+
+void
+gdCacheDelete( gdCache_head_t *head );
+
+void *
+gdCacheGet( gdCache_head_t *head, void *keydata );
--- /dev/null
+#include <stdio.h>
+#include "gd.h"
+#include "gdfontg.h"
+#include "gdfonts.h"
+
+int
+main (void)
+{
+ /* Input and output files */
+ FILE *in;
+ FILE *out;
+
+ /* Input and output images */
+ gdImagePtr im_in = 0, im_out = 0;
+
+ /* Brush image */
+ gdImagePtr brush;
+
+ /* Color indexes */
+ int white;
+ int blue;
+ int red;
+ int green;
+
+ /* Points for polygon */
+ gdPoint points[3];
+
+ /* Create output image, 256 by 256 pixels, true color. */
+ im_out = gdImageCreateTrueColor (256, 256);
+ /* First color allocated is background. */
+ white = gdImageColorAllocate (im_out, 255, 255, 255);
+
+ /* Set transparent color. */
+ gdImageColorTransparent (im_out, white);
+
+ /* Try to load demoin.png and paste part of it into the
+ output image. */
+ in = fopen ("demoin.png", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Can't load source image; this demo\n");
+ fprintf (stderr, "is much more impressive if demoin.png\n");
+ fprintf (stderr, "is available.\n");
+ im_in = 0;
+ }
+ else
+ {
+ im_in = gdImageCreateFromPng (in);
+ fclose (in);
+ /* Now copy, and magnify as we do so */
+ gdImageCopyResized (im_out, im_in,
+ 32, 32, 0, 0, 192, 192, 255, 255);
+ }
+ red = gdImageColorAllocate (im_out, 255, 0, 0);
+ green = gdImageColorAllocate (im_out, 0, 255, 0);
+ blue = gdImageColorAllocate (im_out, 0, 0, 255);
+ /* Rectangle */
+ gdImageLine (im_out, 16, 16, 240, 16, green);
+ gdImageLine (im_out, 240, 16, 240, 240, green);
+ gdImageLine (im_out, 240, 240, 16, 240, green);
+ gdImageLine (im_out, 16, 240, 16, 16, green);
+ /* Circle */
+ gdImageArc (im_out, 128, 128, 60, 20, 0, 720, blue);
+ /* Arc */
+ gdImageArc (im_out, 128, 128, 40, 40, 90, 270, blue);
+ /* Flood fill: doesn't do much on a continuously
+ variable tone jpeg original. */
+ gdImageFill (im_out, 8, 8, blue);
+ /* Polygon */
+ points[0].x = 64;
+ points[0].y = 0;
+ points[1].x = 0;
+ points[1].y = 128;
+ points[2].x = 128;
+ points[2].y = 128;
+ gdImageFilledPolygon (im_out, points, 3, green);
+ /* Brush. A fairly wild example also involving a line style! */
+ if (im_in)
+ {
+ int style[8];
+ brush = gdImageCreateTrueColor (16, 16);
+ gdImageCopyResized (brush, im_in,
+ 0, 0, 0, 0,
+ gdImageSX (brush), gdImageSY (brush),
+ gdImageSX (im_in), gdImageSY (im_in));
+ gdImageSetBrush (im_out, brush);
+ /* With a style, so they won't overprint each other.
+ Normally, they would, yielding a fat-brush effect. */
+ style[0] = 0;
+ style[1] = 0;
+ style[2] = 0;
+ style[3] = 0;
+ style[4] = 0;
+ style[5] = 0;
+ style[6] = 0;
+ style[7] = 1;
+ gdImageSetStyle (im_out, style, 8);
+ /* Draw the styled, brushed line */
+ gdImageLine (im_out, 0, 255, 255, 0, gdStyledBrushed);
+ }
+ /* Text */
+ gdImageString (im_out, gdFontGiant, 32, 32,
+ (unsigned char *) "hi", red);
+ gdImageStringUp (im_out, gdFontSmall, 64, 64,
+ (unsigned char *) "hi", red);
+ /* Make output image interlaced (progressive, in the case of JPEG) */
+ gdImageInterlace (im_out, 1);
+ out = fopen ("demoout.png", "wb");
+ /* Write PNG */
+ gdImagePng (im_out, out);
+ fclose (out);
+ gdImageDestroy (im_out);
+ if (im_in)
+ {
+ gdImageDestroy (im_in);
+ }
+ return 0;
+}
--- /dev/null
+
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.51 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Bold-R-Normal-Sans-15-140-75-75-C-90-ISO8859-2
+ at Mon Jan 26 14:45:58 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gdfontg.h"
+
+char gdFontGiantData[] =
+{
+/* Char 0 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 1 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 2 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1, 0,
+
+/* Char 3 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 4 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 5 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 6 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 7 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 8 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 9 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 10 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 11 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 12 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 13 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 14 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 15 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 16 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 17 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 18 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 19 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 20 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 21 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 22 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 23 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 24 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 25 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 26 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 27 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 28 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 29 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 30 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 0, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 31 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 32 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 33 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 34 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 35 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 36 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 37 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 38 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 39 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 40 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 41 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 42 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 43 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 44 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 45 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 46 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 47 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 48 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 49 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 50 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 51 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 52 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 53 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 54 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 55 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 56 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 57 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 58 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 59 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 60 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 61 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 62 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 63 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 64 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 65 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 66 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 67 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 68 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 69 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 70 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 71 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 72 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 73 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 74 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 75 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 76 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 77 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 78 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 79 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 80 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 81 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 82 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 83 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 84 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 85 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 86 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 87 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 88 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 89 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 90 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 91 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 92 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 93 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 94 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 95 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 96 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 97 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 98 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 99 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 100 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 101 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 102 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 103 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+
+/* Char 104 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 105 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 106 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0, 0,
+
+/* Char 107 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 108 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 109 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 110 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 111 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 112 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 113 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 114 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 115 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 116 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 117 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 118 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 119 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 120 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 121 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+
+/* Char 122 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 123 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 124 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 125 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 126 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 127 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 128 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 129 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 130 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 131 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 132 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 133 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 134 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 135 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 136 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 137 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 138 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 139 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 140 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 141 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 142 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 143 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 144 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 145 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 146 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 147 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 148 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 149 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 150 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 151 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 152 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 153 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 154 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 155 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 156 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 157 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 158 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 159 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 160 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 161 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 162 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 163 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 164 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 165 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 166 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 167 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 168 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 169 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 170 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+
+/* Char 171 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 172 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 173 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 174 */
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 175 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 176 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 177 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 1,
+
+/* Char 178 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+
+/* Char 179 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 180 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 181 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 182 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 183 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 184 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+
+/* Char 185 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 186 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+
+/* Char 187 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 188 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 189 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 190 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 191 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 192 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 193 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 194 */
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 195 */
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 196 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 197 */
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 198 */
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 199 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+
+/* Char 200 */
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 201 */
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 202 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+
+/* Char 203 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 204 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 205 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 206 */
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 207 */
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 208 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 209 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 210 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 211 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 212 */
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 213 */
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 214 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 215 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 216 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 217 */
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 218 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 219 */
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 220 */
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 221 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 222 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+
+/* Char 223 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 224 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 225 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 226 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 227 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 228 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 229 */
+ 0, 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 230 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 231 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+
+/* Char 232 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 233 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 234 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+
+/* Char 235 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 236 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 237 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 238 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 239 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 240 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 241 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 242 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 243 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 244 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 245 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 246 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 247 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 248 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 249 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 250 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 251 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 252 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 253 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0, 0,
+
+/* Char 254 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0, 0,
+
+/* Char 255 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+
+};
+
+gdFont gdFontGiantRep =
+{
+ 256,
+ 0,
+ 9,
+ 15,
+ gdFontGiantData
+};
+
+gdFontPtr gdFontGiant = &gdFontGiantRep;
+
+/* This file has not been truncated. */
--- /dev/null
+
+#ifndef _GDFONTG_H_
+#define _GDFONTG_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.51 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Bold-R-Normal-Sans-15-140-75-75-C-90-ISO8859-2
+ at Mon Jan 26 14:45:58 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+extern gdFontPtr gdFontGiant;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-normal--16-140-75-75-c-80-iso8859-2
+ at Tue Jan 6 19:39:27 1998.
+
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gdfontl.h"
+
+char gdFontLargeData[] =
+{
+/* Char 0 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 1 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 2 */
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 1,
+
+/* Char 3 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 4 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 5 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 6 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 7 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 8 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 9 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 10 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 11 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 12 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 13 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 14 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 15 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 16 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 17 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 18 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 19 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 20 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 21 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 22 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 23 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 24 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 25 */
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 26 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 27 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 28 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 1, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 29 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 30 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 1, 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 31 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 32 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 33 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 34 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 35 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 36 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 37 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 1, 0, 0,
+ 0, 1, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 1, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 38 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0, 1, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 39 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 40 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 41 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 42 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 43 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 44 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 45 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 46 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 47 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 48 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 49 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 50 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 51 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 52 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 53 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 54 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 55 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 56 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 57 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 58 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 59 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 60 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 61 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 62 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 63 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 64 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 65 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 66 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 67 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 68 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 69 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 70 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 71 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 72 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 73 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 74 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 75 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 76 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 77 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 1, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 78 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 79 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 80 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 81 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 1, 0, 1, 0,
+ 0, 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 82 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 83 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 84 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 85 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 86 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 87 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 88 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 89 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 90 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 91 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 92 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 93 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 94 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 95 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 96 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 97 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 98 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 99 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 100 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 101 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 102 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 103 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+
+/* Char 104 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 105 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 106 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 107 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 108 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 109 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 110 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 111 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 112 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+
+/* Char 113 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+
+/* Char 114 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 115 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 116 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 117 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 118 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 119 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 120 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 121 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 122 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 123 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 124 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 125 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 126 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 127 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 128 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 129 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 130 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 131 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 132 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 133 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 134 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 135 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 136 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 137 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 138 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 139 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 140 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 141 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 142 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 143 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 144 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 145 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 146 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 147 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 148 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 149 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 150 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 151 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 152 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 153 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 154 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 155 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 156 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 157 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 158 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 159 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 160 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 161 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 162 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 163 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 164 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 165 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 166 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 167 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 168 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 169 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 170 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 171 */
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 172 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 173 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 174 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 175 */
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 176 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 177 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 178 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+
+/* Char 179 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 180 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 181 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 182 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 183 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 184 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 185 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 186 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 187 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 188 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 189 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 190 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 191 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 192 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 193 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 194 */
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 195 */
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 196 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 197 */
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 198 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 199 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 200 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 201 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 202 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 203 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 204 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 205 */
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 206 */
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 207 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 208 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 209 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 210 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 211 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 212 */
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 213 */
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 214 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 215 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 216 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 217 */
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 218 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 219 */
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 220 */
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 221 */
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 222 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 223 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 224 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 225 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 226 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 227 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 228 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 229 */
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 230 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 231 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 232 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 233 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 234 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+
+/* Char 235 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 236 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 237 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 238 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 239 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1, 0, 1,
+ 0, 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 240 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 241 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 242 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 243 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 244 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 245 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 1,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 246 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 247 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 248 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 249 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 250 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 251 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 1,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 252 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 253 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 254 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0, 0, 0,
+
+/* Char 255 */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+
+
+};
+
+gdFont gdFontLargeRep =
+{
+ 256,
+ 0,
+ 8,
+ 16,
+ gdFontLargeData
+};
+
+gdFontPtr gdFontLarge = &gdFontLargeRep;
+
+/* This file has not been truncated. */
--- /dev/null
+
+#ifndef _GDFONTL_H_
+#define _GDFONTL_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-normal--16-140-75-75-c-80-iso8859-2
+ at Tue Jan 6 19:39:27 1998.
+
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+extern gdFontPtr gdFontLarge;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-bold-r-normal-sans-13-94-100-100-c-70-iso8859-2
+ at Thu Jan 8 13:54:57 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gdfontmb.h"
+
+char gdFontMediumBoldData[] =
+{
+/* Char 0 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 1 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 2 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 3 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 4 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 5 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 6 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 7 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 8 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 9 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 10 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 11 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 12 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 13 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 14 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 15 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 16 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 17 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 18 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 19 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 20 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 21 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 22 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 23 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 24 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 25 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 26 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 27 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 28 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 29 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 30 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 1, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 31 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 32 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 33 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 34 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 35 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 36 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 1, 0,
+ 1, 0, 1, 1, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 37 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 38 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 0, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 39 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 40 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 41 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 42 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 43 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 44 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 45 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 46 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 47 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 48 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 49 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 50 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 51 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 52 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 53 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 54 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 55 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 56 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 57 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 58 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 59 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 60 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 61 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 62 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 63 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 64 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0,
+ 1, 0, 1, 1, 1, 1, 0,
+ 1, 0, 1, 0, 1, 1, 0,
+ 1, 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 65 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 66 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 67 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 68 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 69 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 70 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 71 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 72 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 73 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 74 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 75 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 76 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 77 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 78 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 79 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 80 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 81 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 82 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 83 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 84 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 85 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 86 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 87 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 88 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 89 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 90 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 91 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 92 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 93 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 94 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 95 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 96 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 97 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 98 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 99 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 100 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 101 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 102 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 103 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+
+/* Char 104 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 105 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 106 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+
+/* Char 107 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 108 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 109 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 110 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 111 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 112 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+
+/* Char 113 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 114 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 115 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 116 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 117 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 118 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 119 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 120 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 121 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+
+/* Char 122 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 123 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 124 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 125 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 126 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 127 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 128 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 129 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 130 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 131 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 132 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 133 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 134 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 135 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 136 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 137 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 138 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 139 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 140 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 141 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 142 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 143 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 144 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 145 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 146 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 147 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 148 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 149 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 150 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 151 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 152 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 153 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 154 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 155 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 156 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 157 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 158 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 159 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 160 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 161 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 162 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 163 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 164 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 165 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 166 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 167 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 168 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 169 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 170 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 171 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 172 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 173 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 174 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 175 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 176 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 177 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 178 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+
+/* Char 179 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 1, 0,
+ 0, 0, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 180 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 181 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 182 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 183 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 184 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+
+/* Char 185 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 186 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 187 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 188 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 189 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 190 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 191 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 192 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 193 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 194 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 195 */
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 196 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 197 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 198 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 199 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 200 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 201 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 202 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+
+/* Char 203 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 204 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 205 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 206 */
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 207 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 208 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 209 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 210 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 211 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 212 */
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 213 */
+ 0, 1, 1, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 214 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 215 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 216 */
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 217 */
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 218 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 219 */
+ 0, 1, 1, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 220 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 221 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 222 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+
+/* Char 223 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 1, 1, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 224 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 225 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 226 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 227 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 228 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 229 */
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 230 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 231 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 232 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 233 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 234 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+
+/* Char 235 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 236 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 237 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 238 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 239 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 1, 1, 0, 1,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 1, 1, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 240 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 241 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 242 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 243 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 244 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 245 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 246 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 247 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 248 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 249 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 250 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 251 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 252 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+/* Char 253 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 1, 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 1, 1, 0, 0,
+
+/* Char 254 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 1, 0,
+ 0, 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0, 0,
+
+/* Char 255 */
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0,
+
+
+};
+
+gdFont gdFontMediumBoldRep =
+{
+ 256,
+ 0,
+ 7,
+ 13,
+ gdFontMediumBoldData
+};
+
+gdFontPtr gdFontMediumBold = &gdFontMediumBoldRep;
+
+/* This file has not been truncated. */
--- /dev/null
+
+#ifndef _GDFONTMB_H_
+#define _GDFONTMB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-bold-r-normal-sans-13-94-100-100-c-70-iso8859-2
+ at Thu Jan 8 13:54:57 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gd.h"
+
+extern gdFontPtr gdFontMediumBold;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-semicondensed-sans-12-116-75-75-c-60-iso8859-2
+ at Thu Jan 8 14:13:20 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gdfonts.h"
+
+char gdFontSmallData[] =
+{
+/* Char 0 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 1 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 2 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1, 0,
+
+/* Char 3 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 4 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 5 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 6 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 7 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 8 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 9 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 10 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 11 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 12 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 13 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 14 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 15 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 16 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 17 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 18 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 19 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 20 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 21 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 22 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 23 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 24 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 25 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 26 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 27 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 28 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 29 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 30 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 31 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 32 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 33 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 34 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 35 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 36 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 37 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 38 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 39 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 40 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 41 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 42 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 43 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 44 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 45 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 46 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 47 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 48 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 49 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 50 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 51 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 52 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 53 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 54 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 55 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 56 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 57 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 58 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 59 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 60 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 61 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 62 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 63 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 64 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 65 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 66 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 67 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 68 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 69 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 70 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 71 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 72 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 73 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 74 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 75 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 76 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 77 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 1, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 78 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 79 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 80 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 81 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 82 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 83 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 84 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 85 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 86 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 87 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 88 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 89 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 90 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 91 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 92 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 93 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 94 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 95 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 96 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 97 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 98 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 99 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 100 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 101 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 102 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 103 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+
+/* Char 104 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 105 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 106 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+
+/* Char 107 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 108 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 109 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 110 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 111 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 112 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+
+/* Char 113 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+
+/* Char 114 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 115 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 116 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 117 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 118 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 119 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 120 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 121 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+
+/* Char 122 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 123 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 124 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 125 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 126 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 127 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 128 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 129 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 130 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 131 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 132 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 133 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 134 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 135 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 136 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 137 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 138 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 139 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 140 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 141 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 142 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 143 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 144 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 145 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 146 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 147 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 148 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 149 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 150 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 151 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 152 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 153 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 154 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 155 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 156 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 157 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 158 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 159 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 160 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 161 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1,
+
+/* Char 162 */
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 163 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 164 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 165 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 166 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 167 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 168 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 169 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 170 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+
+/* Char 171 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 172 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 173 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 174 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 175 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 176 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 177 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 1, 1,
+
+/* Char 178 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+
+/* Char 179 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 180 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 181 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1,
+ 0, 1, 1, 0, 0, 1,
+ 0, 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 182 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 183 */
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 184 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+
+/* Char 185 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 186 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+
+/* Char 187 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 188 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 189 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 1,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 190 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 191 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 192 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 193 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 194 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 195 */
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 196 */
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 197 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 198 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 199 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+
+/* Char 200 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 201 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 202 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+
+/* Char 203 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 204 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 205 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 206 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 207 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 208 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 209 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 210 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 211 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 212 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 213 */
+ 0, 0, 1, 0, 0, 1,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 214 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 215 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 216 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 217 */
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 218 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 219 */
+ 0, 0, 1, 0, 0, 1,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 220 */
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 221 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 222 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 223 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 224 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 225 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 226 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 227 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 228 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 229 */
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 230 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 231 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+
+/* Char 232 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 233 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 234 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+
+/* Char 235 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 236 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 237 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 238 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 239 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 240 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 241 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 242 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 243 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 244 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 245 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 246 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 247 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 248 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 249 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 250 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 251 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 252 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+/* Char 253 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 1, 0,
+ 0, 1, 1, 0, 1, 0,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0, 0,
+
+/* Char 254 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+
+/* Char 255 */
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0,
+
+
+};
+
+gdFont gdFontSmallRep =
+{
+ 256,
+ 0,
+ 6,
+ 13,
+ gdFontSmallData
+};
+
+gdFontPtr gdFontSmall = &gdFontSmallRep;
+
+/* This file has not been truncated. */
--- /dev/null
+
+#ifndef _GDFONTS_H_
+#define _GDFONTS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -misc-fixed-medium-r-semicondensed-sans-12-116-75-75-c-60-iso8859-2
+ at Thu Jan 8 14:13:20 1998.
+ No copyright info was found in the original bdf.
+ */
+
+
+#include "gd.h"
+
+extern gdFontPtr gdFontSmall;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-2
+ at Thu Jan 8 13:49:54 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gdfontt.h"
+
+char gdFontTinyData[] =
+{
+/* Char 0 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 1 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 1, 1, 1,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 2 */
+ 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+
+/* Char 3 */
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+
+/* Char 4 */
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 0, 0, 0,
+ 1, 0, 1, 1, 1,
+ 1, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 5 */
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 1,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 1,
+
+/* Char 6 */
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 7 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 8 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 9 */
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1,
+
+/* Char 10 */
+ 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+
+/* Char 11 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 12 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 13 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 14 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 15 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 16 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 17 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 18 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 19 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 20 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 21 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 22 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 23 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 24 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 25 */
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 26 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 27 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 28 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 29 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 30 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 1,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 1,
+ 1, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 31 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 32 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 33 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 34 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 35 */
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 1, 1, 1, 1, 1,
+ 0, 1, 0, 1, 0,
+ 1, 1, 1, 1, 1,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 36 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 1,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 37 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 0, 0, 1,
+ 1, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 1,
+ 1, 0, 0, 1, 1,
+ 0, 0, 0, 0, 0,
+
+/* Char 38 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 1,
+ 0, 0, 0, 0, 0,
+
+/* Char 39 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 40 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 41 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 42 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 43 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 44 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 45 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 46 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 47 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 1,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 48 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 49 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 50 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 51 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 52 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 53 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 54 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 55 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 56 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 57 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 58 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 59 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+
+/* Char 60 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 61 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 62 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 63 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 64 */
+ 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 1,
+ 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1,
+ 1, 0, 0, 1, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+
+/* Char 65 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 66 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 67 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 68 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 69 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 70 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 71 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 72 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 73 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 74 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 75 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 76 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 77 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 78 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 79 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 80 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 81 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+
+/* Char 82 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 83 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 84 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 85 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 86 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 87 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 88 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 89 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1,
+ 1, 0, 0, 0, 1,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 90 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 91 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 92 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0,
+
+/* Char 93 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 94 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 95 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+
+/* Char 96 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 97 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 98 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 99 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 100 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 101 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 102 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 103 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 104 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 105 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 106 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+
+/* Char 107 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 108 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 109 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1,
+ 1, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0,
+
+/* Char 110 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 111 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 112 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+
+/* Char 113 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0,
+
+/* Char 114 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 115 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 116 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 117 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 118 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 119 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1,
+ 1, 0, 1, 0, 1,
+ 1, 0, 1, 0, 1,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 120 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 121 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 122 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 123 */
+ 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 124 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 125 */
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 126 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 127 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 128 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 129 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 130 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 131 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 132 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 133 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 134 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 135 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 136 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 137 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 138 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 139 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 140 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 141 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 142 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 143 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 144 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 145 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 146 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 147 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 148 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 149 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 150 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 151 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 152 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 153 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 154 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 155 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 156 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 157 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 158 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 159 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 160 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 161 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 0, 0, 1, 1,
+
+/* Char 162 */
+ 1, 0, 0, 0, 1,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 163 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0,
+
+/* Char 164 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 1,
+ 0, 1, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 165 */
+ 0, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 166 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 167 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 1, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 168 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 169 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 170 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+
+/* Char 171 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 172 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 173 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 174 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 175 */
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 176 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 177 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 1, 1,
+
+/* Char 178 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 1,
+
+/* Char 179 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 180 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 181 */
+ 0, 0, 0, 1, 1,
+ 1, 1, 0, 0, 1,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 182 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 183 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 184 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 185 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 186 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 0, 1, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+
+/* Char 187 */
+ 0, 0, 0, 1, 1,
+ 0, 1, 0, 0, 1,
+ 0, 1, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 188 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 189 */
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 190 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 191 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 192 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 193 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 194 */
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 195 */
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 196 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 197 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 198 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 199 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 1, 0, 0, 0,
+
+/* Char 200 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 201 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 202 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1,
+
+/* Char 203 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 204 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 205 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 206 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 207 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 208 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 1, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 209 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 210 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 1, 1, 1, 0,
+ 1, 0, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 211 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 212 */
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 213 */
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 214 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 215 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 216 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 217 */
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 218 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 219 */
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 220 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 221 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 1, 0, 0, 0, 1,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 222 */
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+
+/* Char 223 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 0, 0, 0,
+
+/* Char 224 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 225 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 226 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 227 */
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 228 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 229 */
+ 0, 0, 0, 0, 1,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 230 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 231 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 1, 1, 0, 0,
+
+/* Char 232 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 233 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 234 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 1,
+
+/* Char 235 */
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 236 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 1, 0,
+ 1, 1, 0, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 237 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 238 */
+ 0, 0, 1, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 239 */
+ 0, 0, 0, 1, 1,
+ 0, 0, 1, 0, 1,
+ 0, 0, 1, 0, 1,
+ 0, 1, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 240 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 1, 1,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 241 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 242 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 243 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 244 */
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 245 */
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 246 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 247 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 248 */
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 1, 0, 0,
+ 1, 1, 0, 1, 0,
+ 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 249 */
+ 0, 1, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 250 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 251 */
+ 0, 1, 0, 0, 1,
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 252 */
+ 1, 0, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 1, 1, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 0, 0, 0,
+
+/* Char 253 */
+ 0, 0, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 1, 0, 0, 1, 0,
+ 1, 0, 0, 1, 0,
+ 0, 1, 1, 1, 0,
+ 0, 0, 0, 1, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 254 */
+ 0, 0, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0,
+ 1, 1, 1, 0, 0,
+ 0, 1, 0, 0, 0,
+ 0, 1, 0, 1, 0,
+ 0, 0, 1, 0, 0,
+ 0, 1, 1, 0, 0,
+
+/* Char 255 */
+ 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0,
+
+
+};
+
+gdFont gdFontTinyRep =
+{
+ 256,
+ 0,
+ 5,
+ 8,
+ gdFontTinyData
+};
+
+gdFontPtr gdFontTiny = &gdFontTinyRep;
+
+/* This file has not been truncated. */
--- /dev/null
+
+#ifndef _GDFONTT_H_
+#define _GDFONTT_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ This is a header file for gd font, generated using
+ bdftogd version 0.5 by Jan Pazdziora, adelton@fi.muni.cz
+ from bdf font
+ -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-2
+ at Thu Jan 8 13:49:54 1998.
+ The original bdf was holding following copyright:
+ "Libor Skarvada, libor@informatics.muni.cz"
+ */
+
+
+#include "gd.h"
+
+extern gdFontPtr gdFontTiny;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+
+/********************************************/
+/* gd interface to freetype library */
+/* */
+/* John Ellson ellson@lucent.com */
+/********************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifndef MSWIN32
+#include <unistd.h>
+#else
+#define R_OK 2
+#endif
+
+/* number of antialised colors for indexed bitmaps */
+#define NUMCOLORS 8
+
+char *
+gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y, char *string)
+{
+ gdImageStringFT (im, brect, fg, fontlist, ptsize,
+ angle, x, y, string);
+}
+
+#ifndef HAVE_LIBFREETYPE
+char *
+gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y, char *string)
+{
+ return "libgd was not built with FreeType font support\n";
+}
+#else
+
+#include "gdcache.h"
+#include "freetype/freetype.h"
+#include "freetype/ftglyph.h"
+
+/* number of fonts cached before least recently used is replaced */
+#define FONTCACHESIZE 6
+
+/* number of antialias color lookups cached */
+#define TWEENCOLORCACHESIZE 32
+
+/*
+ * Line separation as a factor of font height.
+ * No space between if LINESPACE = 1.00
+ * Line separation will be rounded up to next pixel row.
+ */
+#define LINESPACE 1.05
+
+/*
+ * The character (space) used to separate alternate fonts in the
+ * fontlist parameter to gdImageStringFT.
+ */
+#define LISTSEPARATOR " "
+
+/*
+ * DEFAULT_FONTPATH and PATHSEPARATOR are host type dependent and
+ * are normally set by configure in gvconfig.h. These are just
+ * some last resort values that might match some Un*x system
+ * if building this version of gd separate from graphviz.
+ */
+#ifndef DEFAULT_FONTPATH
+#define DEFAULT_FONTPATH "/usr/share/fonts/truetype"
+#endif
+#ifndef PATHSEPARATOR
+#define PATHSEPARATOR ":"
+#endif
+
+#ifndef TRUE
+#define FALSE 0
+#define TRUE !FALSE
+#endif
+
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#define MIN(a,b) ((a)<(b)?(a):(b))
+
+typedef struct
+{
+ char *fontlist; /* key */
+ FT_Library *library;
+ FT_Face face;
+ FT_Bool have_char_map_unicode, have_char_map_big5, have_char_map_sjis,
+ have_char_map_apple_roman;
+ gdCache_head_t *glyphCache;
+}
+font_t;
+
+typedef struct
+ {
+ char *fontlist; /* key */
+ FT_Library *library;
+ }
+fontkey_t;
+
+typedef struct
+ {
+ int pixel; /* key */
+ int bgcolor; /* key */
+ int fgcolor; /* key *//* -ve means no antialias */
+ gdImagePtr im; /* key */
+ int tweencolor;
+ }
+tweencolor_t;
+
+typedef struct
+ {
+ int pixel; /* key */
+ int bgcolor; /* key */
+ int fgcolor; /* key *//* -ve means no antialias */
+ gdImagePtr im; /* key */
+ }
+tweencolorkey_t;
+
+/********************************************************************
+ * gdTcl_UtfToUniChar is borrowed from Tcl ...
+ */
+/*
+ * tclUtf.c --
+ *
+ * Routines for manipulating UTF-8 strings.
+ *
+ * Copyright (c) 1997-1998 Sun Microsystems, Inc.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * SCCS: @(#) tclUtf.c 1.25 98/01/28 18:02:43
+ */
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * gdTcl_UtfToUniChar --
+ *
+ * Extract the Tcl_UniChar represented by the UTF-8 string. Bad
+ * UTF-8 sequences are converted to valid Tcl_UniChars and processing
+ * continues. Equivalent to Plan 9 chartorune().
+ *
+ * The caller must ensure that the source buffer is long enough that
+ * this routine does not run off the end and dereference non-existent
+ * memory looking for trail bytes. If the source buffer is known to
+ * be '\0' terminated, this cannot happen. Otherwise, the caller
+ * should call Tcl_UtfCharComplete() before calling this routine to
+ * ensure that enough bytes remain in the string.
+ *
+ * Results:
+ * *chPtr is filled with the Tcl_UniChar, and the return value is the
+ * number of bytes from the UTF-8 string that were consumed.
+ *
+ * Side effects:
+ * None.
+ *
+ *---------------------------------------------------------------------------
+ */
+
+#ifdef JISX0208
+#include "jisx0208.h"
+#endif
+
+#define Tcl_UniChar int
+#define TCL_UTF_MAX 3
+static int
+gdTcl_UtfToUniChar (char *str, Tcl_UniChar * chPtr)
+/* str is the UTF8 next character pointer */
+/* chPtr is the int for the result */
+{
+ int byte;
+
+ /* HTML4.0 entities in decimal form, e.g. Å */
+ byte = *((unsigned char *) str);
+ if (byte == '&')
+ {
+ int i, n = 0;
+
+ byte = *((unsigned char *) (str + 1));
+ if (byte == '#')
+ {
+ for (i = 2; i < 8; i++)
+ {
+ byte = *((unsigned char *) (str + i));
+ if (byte >= '0' && byte <= '9')
+ {
+ n = (n * 10) + (byte - '0');
+ }
+ else
+ break;
+ }
+ if (byte == ';')
+ {
+ *chPtr = (Tcl_UniChar) n;
+ return ++i;
+ }
+ }
+ }
+
+ /*
+ * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones.
+ */
+
+ byte = *((unsigned char *) str);
+#ifdef JISX0208
+ if (0xA1 <= byte && byte <= 0xFE)
+ {
+ int ku, ten;
+
+ ku = (byte & 0x7F) - 0x20;
+ ten = (str[1] & 0x7F) - 0x20;
+ if ((ku < 1 || ku > 92) || (ten < 1 || ten > 94))
+ {
+ *chPtr = (Tcl_UniChar) byte;
+ return 1;
+ }
+
+ *chPtr = (Tcl_UniChar) UnicodeTbl[ku - 1][ten - 1];
+ return 2;
+ }
+ else
+#endif /* JISX0208 */
+ if (byte < 0xC0)
+ {
+ /*
+ * Handles properly formed UTF-8 characters between
+ * 0x01 and 0x7F. Also treats \0 and naked trail
+ * bytes 0x80 to 0xBF as valid characters representing
+ * themselves.
+ */
+
+ *chPtr = (Tcl_UniChar) byte;
+ return 1;
+ }
+ else if (byte < 0xE0)
+ {
+ if ((str[1] & 0xC0) == 0x80)
+ {
+ /*
+ * Two-byte-character lead-byte followed
+ * by a trail-byte.
+ */
+
+ *chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6)
+ | (str[1] & 0x3F));
+ return 2;
+ }
+ /*
+ * A two-byte-character lead-byte not followed by trail-byte
+ * represents itself.
+ */
+
+ *chPtr = (Tcl_UniChar) byte;
+ return 1;
+ }
+ else if (byte < 0xF0)
+ {
+ if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80))
+ {
+ /*
+ * Three-byte-character lead byte followed by
+ * two trail bytes.
+ */
+
+ *chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12)
+ | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F));
+ return 3;
+ }
+ /*
+ * A three-byte-character lead-byte not followed by
+ * two trail-bytes represents itself.
+ */
+
+ *chPtr = (Tcl_UniChar) byte;
+ return 1;
+ }
+#if TCL_UTF_MAX > 3
+ else
+ {
+ int ch, total, trail;
+
+ total = totalBytes[byte];
+ trail = total - 1;
+ if (trail > 0)
+ {
+ ch = byte & (0x3F >> trail);
+ do
+ {
+ str++;
+ if ((*str & 0xC0) != 0x80)
+ {
+ *chPtr = byte;
+ return 1;
+ }
+ ch <<= 6;
+ ch |= (*str & 0x3F);
+ trail--;
+ }
+ while (trail > 0);
+ *chPtr = ch;
+ return total;
+ }
+ }
+#endif
+
+ *chPtr = (Tcl_UniChar) byte;
+ return 1;
+}
+
+/********************************************************************/
+/* font cache functions */
+
+static int
+fontTest (void *element, void *key)
+{
+ font_t *a = (font_t *) element;
+ fontkey_t *b = (fontkey_t *) key;
+
+ return (strcmp (a->fontlist, b->fontlist) == 0);
+}
+
+static void *
+fontFetch (char **error, void *key)
+{
+ font_t *a;
+ fontkey_t *b = (fontkey_t *) key;
+ int n;
+ int font_found = 0;
+ unsigned short platform, encoding;
+ char *fontsearchpath, *fontpath, *fontlist;
+ char *fullname = NULL;
+ char *name, *path, *dir;
+ char *strtok_ptr;
+ FT_Error err;
+ FT_CharMap found = 0;
+ FT_CharMap charmap;
+
+ a = (font_t *) gdMalloc (sizeof (font_t));
+ a->fontlist = strdup (b->fontlist);
+ a->library = b->library;
+
+ /*
+ * Search the pathlist for any of a list of font names.
+ */
+ fontsearchpath = getenv ("GDFONTPATH");
+ if (!fontsearchpath)
+ fontsearchpath = DEFAULT_FONTPATH;
+ path = strdup (fontsearchpath);
+ fontlist = strdup (a->fontlist);
+
+ /*
+ * Must use gd_strtok_r else pointer corrupted by strtok in nested loop.
+ */
+ for (name = gd_strtok_r (fontlist, LISTSEPARATOR, &strtok_ptr); name;
+ name = gd_strtok_r (0, LISTSEPARATOR, &strtok_ptr))
+ {
+
+ /*
+ * Allocate an oversized buffer that is guaranteed to be
+ * big enough for all paths to be tested.
+ */
+ fullname = gdRealloc (fullname,
+ strlen (fontsearchpath) + strlen (name) + 6);
+ /* if name is an absolute filename then test directly */
+ if (*name == '/')
+ {
+ sprintf (fullname, "%s", name);
+ if (access (fullname, R_OK) == 0)
+ {
+ font_found++;
+ break;
+ }
+ }
+ for (dir = strtok (path, PATHSEPARATOR); dir;
+ dir = strtok (0, PATHSEPARATOR))
+ {
+ sprintf (fullname, "%s/%s.ttf", dir, name);
+ if (access (fullname, R_OK) == 0)
+ {
+ font_found++;
+ break;
+ }
+ }
+ if (font_found)
+ break;
+ }
+ gdFree (path);
+ gdFree (fontlist);
+ if (!font_found)
+ {
+ *error = "Could not find/open font";
+ return NULL;
+ }
+
+ err = FT_New_Face (*b->library, fullname, 0, &a->face);
+ if (err)
+ {
+ *error = "Could not read font";
+ return NULL;
+ }
+ gdFree (fullname);
+
+/* FIXME - This mapping stuff is imcomplete - where is the spec? */
+
+ a->have_char_map_unicode = 0;
+ a->have_char_map_big5 = 0;
+ a->have_char_map_sjis = 0;
+ a->have_char_map_apple_roman = 0;
+ for (n = 0; n < a->face->num_charmaps; n++)
+ {
+ charmap = a->face->charmaps[n];
+ platform = charmap->platform_id;
+ encoding = charmap->encoding_id;
+ if ((platform == 3 && encoding == 1) /* Windows Unicode */
+ || (platform == 3 && encoding == 0) /* Windows Symbol */
+ || (platform == 2 && encoding == 1) /* ISO Unicode */
+ || (platform == 0))
+ { /* Apple Unicode */
+ a->have_char_map_unicode = 1;
+ found = charmap;
+ }
+ else if (platform == 3 && encoding == 4)
+ { /* Windows Big5 */
+ a->have_char_map_big5 = 1;
+ found = charmap;
+ }
+ else if (platform == 3 && encoding == 2)
+ { /* Windows Sjis */
+ a->have_char_map_sjis = 1;
+ found = charmap;
+ }
+ else if ((platform == 1 && encoding == 0) /* Apple Roman */
+ || (platform == 2 && encoding == 0))
+ { /* ISO ASCII */
+ a->have_char_map_apple_roman = 1;
+ found = charmap;
+ }
+ }
+ if (!found)
+ {
+ *error = "Unable to find a CharMap that I can handle";
+ return NULL;
+ }
+
+ return (void *) a;
+}
+
+static void
+fontRelease (void *element)
+{
+ font_t *a = (font_t *) element;
+
+ FT_Done_Face (a->face);
+ gdFree (a->fontlist);
+ gdFree ((char *) element);
+}
+
+/********************************************************************/
+/* tweencolor cache functions */
+
+static int
+tweenColorTest (void *element, void *key)
+{
+ tweencolor_t *a = (tweencolor_t *) element;
+ tweencolorkey_t *b = (tweencolorkey_t *) key;
+
+ return (a->pixel == b->pixel
+ && a->bgcolor == b->bgcolor
+ && a->fgcolor == b->fgcolor
+ && a->im == b->im);
+}
+
+/*
+ * Computes a color in im's color table that is part way between
+ * the background and foreground colors proportional to the gray
+ * pixel value in the range 0-NUMCOLORS. The fg and bg colors must already
+ * be in the color table.
+ */
+static void *
+tweenColorFetch (char **error, void *key)
+{
+ tweencolor_t *a;
+ tweencolorkey_t *b = (tweencolorkey_t *) key;
+ int pixel, npixel, bg, fg;
+ gdImagePtr im;
+
+ a = (tweencolor_t *) gdMalloc (sizeof (tweencolor_t));
+ pixel = a->pixel = b->pixel;
+ bg = a->bgcolor = b->bgcolor;
+ fg = a->fgcolor = b->fgcolor;
+ im = b->im;
+
+ /* if fg is specified by a negative color idx, then don't antialias */
+ if (fg < 0)
+ {
+ a->tweencolor = -fg;
+ }
+ else
+ {
+ npixel = NUMCOLORS - pixel;
+ if (im->trueColor)
+ {
+ /* 2.0.1: use gdImageSetPixel to do the alpha blending work,
+ or to just store the alpha level. All we have to do here
+ is incorporate our knowledge of the percentage of this
+ pixel that is really "lit" by pushing the alpha value
+ up toward transparency in edge regions. */
+ a->tweencolor = gdTrueColorAlpha (
+ gdTrueColorGetRed (fg),
+ gdTrueColorGetGreen (fg),
+ gdTrueColorGetBlue (fg),
+ gdAlphaMax - (gdTrueColorGetAlpha (fg) * pixel / NUMCOLORS));
+ }
+ else
+ {
+ a->tweencolor = gdImageColorResolve (im,
+ (pixel * im->red[fg] + npixel * im->red[bg]) / NUMCOLORS,
+ (pixel * im->green[fg] + npixel * im->green[bg]) / NUMCOLORS,
+ (pixel * im->blue[fg] + npixel * im->blue[bg]) / NUMCOLORS);
+ }
+ }
+ return (void *) a;
+}
+
+static void
+tweenColorRelease (void *element)
+{
+ gdFree ((char *) element);
+}
+
+/* draw_bitmap - transfers glyph bitmap to GD image */
+static char *
+gdft_draw_bitmap (gdImage * im, int fg, FT_Bitmap bitmap, int pen_x, int pen_y)
+{
+ unsigned char *pixel;
+ int *tpixel;
+ int x, y, row, col, pc;
+
+ tweencolor_t *tc_elem;
+ tweencolorkey_t tc_key;
+
+ /* initialize tweenColorCache on first call */
+ static gdCache_head_t *tc_cache;
+
+ if (!tc_cache)
+ {
+ tc_cache = gdCacheCreate (TWEENCOLORCACHESIZE,
+ tweenColorTest, tweenColorFetch, tweenColorRelease);
+ }
+
+ /* copy to image, mapping colors */
+ tc_key.fgcolor = fg;
+ tc_key.im = im;
+ for (row = 0; row < bitmap.rows; row++)
+ {
+ pc = row * bitmap.pitch;
+ y = pen_y + row;
+
+ /* clip if out of bounds */
+ if (y >= im->sy || y < 0)
+ continue;
+
+ for (col = 0; col < bitmap.width; col++, pc++)
+ {
+ if (bitmap.pixel_mode == ft_pixel_mode_grays)
+ {
+ /*
+ * Round to NUMCOLORS levels of antialiasing for
+ * index color images since only 256 colors are
+ * available.
+ */
+ tc_key.pixel = ((bitmap.buffer[pc] * NUMCOLORS)
+ + bitmap.num_grays / 2)
+ / (bitmap.num_grays - 1);
+ }
+ else if (bitmap.pixel_mode == ft_pixel_mode_mono)
+ {
+ tc_key.pixel = ((bitmap.buffer[pc / 8]
+ << (pc % 8)) & 128) ? NUMCOLORS : 0;
+ }
+ else
+ {
+ return "Unsupported ft_pixel_mode";
+ }
+
+ if (tc_key.pixel > 0)
+ { /* if not background */
+ x = pen_x + col;
+
+ /* clip if out of bounds */
+ if (x >= im->sx || x < 0)
+ continue;
+ /* get pixel location in gd buffer */
+ if (im->trueColor)
+ {
+ tpixel = &im->tpixels[y][x];
+ }
+ else
+ {
+ pixel = &im->pixels[y][x];
+ }
+ if (tc_key.pixel == NUMCOLORS)
+ {
+ /* use fg color directly */
+ if (im->trueColor)
+ {
+ *tpixel = fg;
+ }
+ else
+ {
+ *pixel = fg;
+ }
+ }
+ else
+ {
+ /* find antialised color */
+ if (im->trueColor)
+ {
+ tc_key.bgcolor = *tpixel;
+ }
+ else
+ {
+ tc_key.bgcolor = *pixel;
+ }
+ tc_elem = (tweencolor_t *) gdCacheGet (
+ tc_cache, &tc_key);
+ if (im->trueColor)
+ {
+ *tpixel = tc_elem->tweencolor;
+ }
+ else
+ {
+ *pixel = tc_elem->tweencolor;
+ }
+ }
+ }
+ }
+ }
+ return (char *) NULL;
+}
+
+extern int any2eucjp (char *, char *, unsigned int);
+
+/********************************************************************/
+/* gdImageStringFT - render a utf8 string onto a gd image */
+
+char *
+gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,
+ double ptsize, double angle, int x, int y, char *string)
+{
+ FT_BBox bbox, glyph_bbox;
+ FT_Matrix matrix;
+ FT_Vector pen, delta, penf;
+ FT_Face face;
+ FT_Glyph image;
+ FT_GlyphSlot slot;
+ FT_Error err;
+ FT_Bool use_kerning;
+ FT_UInt glyph_index, previous;
+ double sin_a = sin (angle);
+ double cos_a = cos (angle);
+ int len, i = 0, ch;
+ int x1 = 0, y1 = 0;
+ font_t *font;
+ fontkey_t fontkey;
+ char *next;
+ char *tmpstr = 0;
+ int render = (im && (im->trueColor || (fg <= 255 && fg >= -255)));
+ FT_BitmapGlyph bm;
+
+/***** initialize font library and font cache on first call ******/
+ static gdCache_head_t *fontCache;
+ static FT_Library library;
+
+ if (!fontCache)
+ {
+ if (FT_Init_FreeType (&library))
+ {
+ return "Failure to initialize font library";
+ }
+ fontCache = gdCacheCreate (FONTCACHESIZE,
+ fontTest, fontFetch, fontRelease);
+ }
+/*****/
+
+ /* get the font (via font cache) */
+ fontkey.fontlist = fontlist;
+ fontkey.library = &library;
+ font = (font_t *) gdCacheGet (fontCache, &fontkey);
+ if (!font)
+ {
+ return fontCache->error;
+ }
+ face = font->face; /* shortcut */
+ slot = face->glyph; /* shortcut */
+
+ if (FT_Set_Char_Size (face, 0, (FT_F26Dot6) (ptsize * 64),
+ GD_RESOLUTION, GD_RESOLUTION))
+ {
+ return "Could not set character size";
+ }
+
+ matrix.xx = (FT_Fixed) (cos_a * (1 << 16));
+ matrix.yx = (FT_Fixed) (sin_a * (1 << 16));
+ matrix.xy = -matrix.yx;
+ matrix.yy = matrix.xx;
+
+ penf.x = penf.y = 0; /* running position of non-rotated string */
+ pen.x = pen.y = 0; /* running position of rotated string */
+ bbox.xMin = bbox.xMax = bbox.yMin = bbox.yMax = 0;
+
+ use_kerning = FT_HAS_KERNING (face);
+ previous = 0;
+
+#ifndef JISX0208
+ if (font->have_char_map_sjis)
+ {
+#endif
+ if (tmpstr = (char *) gdMalloc (BUFSIZ))
+ {
+ any2eucjp (tmpstr, string, BUFSIZ);
+ next = tmpstr;
+ }
+ else
+ {
+ next = string;
+ }
+#ifndef JISX0208
+ }
+ else
+ {
+ next = string;
+ }
+#endif
+ while (*next)
+ {
+ ch = *next;
+
+ /* carriage returns */
+ if (ch == '\r')
+ {
+ penf.x = 0;
+ x1 = (penf.x * cos_a - penf.y * sin_a + 32) / 64;
+ y1 = (penf.x * sin_a + penf.y * cos_a + 32) / 64;
+ pen.x = pen.y = 0;
+ previous = 0; /* clear kerning flag */
+ next++;
+ continue;
+ }
+ /* newlines */
+ if (ch == '\n')
+ {
+ penf.y -= face->size->metrics.height * LINESPACE;
+ penf.y = (penf.y - 32) & -64; /* round to next pixel row */
+ x1 = (penf.x * cos_a - penf.y * sin_a + 32) / 64;
+ y1 = (penf.x * sin_a + penf.y * cos_a + 32) / 64;
+ pen.x = pen.y = 0;
+ previous = 0; /* clear kerning flag */
+ next++;
+ continue;
+ }
+
+ if (font->have_char_map_unicode)
+ {
+ /* use UTF-8 mapping from ASCII */
+ len = gdTcl_UtfToUniChar (next, &ch);
+ next += len;
+ }
+ else if (font->have_char_map_sjis)
+ {
+ unsigned char c;
+ int jiscode;
+
+ c = *next;
+ if (0xA1 <= c && c <= 0xFE)
+ {
+ next++;
+ jiscode = 0x100 * (c & 0x7F) + ((*next) & 0x7F);
+
+ ch = (jiscode >> 8) & 0xFF;
+ jiscode &= 0xFF;
+
+ if (ch & 1)
+ jiscode += 0x40 - 0x21;
+ else
+ jiscode += 0x9E - 0x21;
+
+ if (jiscode >= 0x7F)
+ jiscode++;
+ ch = (ch - 0x21) / 2 + 0x81;
+ if (ch >= 0xA0)
+ ch += 0x40;
+
+ ch = (ch << 8) + jiscode;
+ }
+ else
+ {
+ ch = c & 0xFF; /* don't extend sign */
+ }
+ next++;
+ }
+ else
+ {
+ /*
+ * Big 5 mapping:
+ * use "JIS-8 half-width katakana" coding from 8-bit characters. Ref:
+ * ftp://ftp.ora.com/pub/examples/nutshell/ujip/doc/japan.inf-032092.sjs
+ */
+ ch = (*next) & 0xFF; /* don't extend sign */
+ next++;
+ if (ch >= 161 /* first code of JIS-8 pair */
+ && *next)
+ { /* don't advance past '\0' */
+ /* TBB: Fix from Kwok Wah On: & 255 needed */
+ ch = (ch * 256) + ((*next) & 255);
+ next++;
+ }
+ }
+
+ /* Convert character code to glyph index */
+ glyph_index = FT_Get_Char_Index (face, ch);
+
+ /* retrieve kerning distance and move pen position */
+ if (use_kerning && previous && glyph_index)
+ {
+ FT_Get_Kerning (face, previous, glyph_index,
+ ft_kerning_default, &delta);
+ pen.x += delta.x;
+ }
+
+ /* load glyph image into the slot (erase previous one) */
+ err = FT_Load_Glyph (face, glyph_index, FT_LOAD_DEFAULT);
+ if (err)
+ return "Problem loading glyph";
+
+ /* transform glyph image */
+ FT_Get_Glyph (slot, &image);
+ if (brect)
+ { /* only if need brect */
+ FT_Glyph_Get_CBox (image, ft_glyph_bbox_gridfit, &glyph_bbox);
+ if (!i)
+ { /* if first character, init BB corner values */
+ bbox.xMin = bbox.yMin = (1 << 30) - 1;
+ bbox.xMax = bbox.yMax = -bbox.xMin;
+ }
+ glyph_bbox.xMin += penf.x;
+ glyph_bbox.yMin += penf.y;
+ glyph_bbox.xMax += penf.x;
+ glyph_bbox.yMax += penf.y;
+ if (bbox.xMin > glyph_bbox.xMin)
+ bbox.xMin = glyph_bbox.xMin;
+ if (bbox.yMin > glyph_bbox.yMin)
+ bbox.yMin = glyph_bbox.yMin;
+ if (bbox.xMax < glyph_bbox.xMax)
+ bbox.xMax = glyph_bbox.xMax;
+ if (bbox.yMax < glyph_bbox.yMax)
+ bbox.yMax = glyph_bbox.yMax;
+ i++;
+ }
+
+ /* transform glyph image */
+ FT_Glyph_Transform (image, &matrix, 0);
+
+ if (render)
+ {
+ if (image->format != ft_glyph_format_bitmap)
+ {
+ err = FT_Glyph_To_Bitmap (&image, ft_render_mode_normal, 0, 1);
+ if (err)
+ return "Problem rendering glyph";
+ }
+
+ /* now, draw to our target surface */
+ bm = (FT_BitmapGlyph) image;
+ gdft_draw_bitmap (im, fg, bm->bitmap,
+ x + x1 + ((pen.x + 31) >> 6) + bm->left,
+ y - y1 + ((pen.y + 31) >> 6) - bm->top);
+ }
+
+ /* record current glyph index for kerning */
+ previous = glyph_index;
+
+ /* increment pen position */
+ pen.x += image->advance.x >> 10;
+ pen.y -= image->advance.y >> 10;
+
+ penf.x += slot->metrics.horiAdvance;
+
+ FT_Done_Glyph (image);
+ }
+
+ if (brect)
+ { /* only if need brect */
+ /* For perfect rounding, must get sin(a + pi/4) and sin(a - pi/4). */
+ double d1 = sin (angle + 0.78539816339744830962);
+ double d2 = sin (angle - 0.78539816339744830962);
+
+ /* rotate bounding rectangle */
+ brect[0] = (int) (bbox.xMin * cos_a - bbox.yMin * sin_a);
+ brect[1] = (int) (bbox.xMin * sin_a + bbox.yMin * cos_a);
+ brect[2] = (int) (bbox.xMax * cos_a - bbox.yMin * sin_a);
+ brect[3] = (int) (bbox.xMax * sin_a + bbox.yMin * cos_a);
+ brect[4] = (int) (bbox.xMax * cos_a - bbox.yMax * sin_a);
+ brect[5] = (int) (bbox.xMax * sin_a + bbox.yMax * cos_a);
+ brect[6] = (int) (bbox.xMin * cos_a - bbox.yMax * sin_a);
+ brect[7] = (int) (bbox.xMin * sin_a + bbox.yMax * cos_a);
+
+ /* scale, round and offset brect */
+ brect[0] = x + gdroundupdown (brect[0], d2 > 0);
+ brect[1] = y - gdroundupdown (brect[1], d1 < 0);
+ brect[2] = x + gdroundupdown (brect[2], d1 > 0);
+ brect[3] = y - gdroundupdown (brect[3], d2 > 0);
+ brect[4] = x + gdroundupdown (brect[4], d2 < 0);
+ brect[5] = y - gdroundupdown (brect[5], d1 > 0);
+ brect[6] = x + gdroundupdown (brect[6], d1 < 0);
+ brect[7] = y - gdroundupdown (brect[7], d2 < 0);
+ }
+
+ if (tmpstr)
+ gdFree (tmpstr);
+ return (char *) NULL;
+}
+
+int
+gdroundupdown (FT_F26Dot6 v1, int updown)
+{
+ return (!updown)
+ ? (v1 < 0 ? ((v1 - 63) >> 6) : v1 >> 6)
+ : (v1 > 0 ? ((v1 + 63) >> 6) : v1 >> 6);
+}
+
+#endif /* HAVE_LIBFREETYPE */
--- /dev/null
+#include "gd.h"
+#include "gdhelpers.h"
+#include <stdlib.h>
+
+/* TBB: gd_strtok_r is not portable; provide an implementation */
+
+#define SEP_TEST (separators[*((unsigned char *) s)])
+
+char *
+gd_strtok_r (char *s, char *sep, char **state)
+{
+ char separators[256];
+ char *start;
+ char *result = 0;
+ memset (separators, 0, sizeof (separators));
+ while (*sep)
+ {
+ separators[*((unsigned char *) sep)] = 1;
+ sep++;
+ }
+ if (!s)
+ {
+ /* Pick up where we left off */
+ s = *state;
+ }
+ start = s;
+ /* 1. EOS */
+ if (!(*s))
+ {
+ *state = s;
+ return 0;
+ }
+ /* 2. Leading separators, if any */
+ if (SEP_TEST)
+ {
+ do
+ {
+ s++;
+ }
+ while (SEP_TEST);
+ /* 2a. EOS after separators only */
+ if (!(*s))
+ {
+ *state = s;
+ return 0;
+ }
+ }
+ /* 3. A token */
+ result = s;
+ do
+ {
+ /* 3a. Token at end of string */
+ if (!(*s))
+ {
+ *state = s;
+ return result;
+ }
+ s++;
+ }
+ while (!SEP_TEST);
+ /* 4. Terminate token and skip trailing separators */
+ *s = '\0';
+ do
+ {
+ s++;
+ }
+ while (SEP_TEST);
+ /* 5. Return token */
+ *state = s;
+ return result;
+}
+
+void *
+gdCalloc (size_t nmemb, size_t size)
+{
+ return calloc (nmemb, size);
+}
+
+void *
+gdMalloc (size_t size)
+{
+ return malloc (size);
+}
+
+void *
+gdRealloc (void *ptr, size_t size)
+{
+ return realloc (ptr, size);
+}
+
+void
+gdFree (void *ptr)
+{
+ free (ptr);
+}
--- /dev/null
+#ifndef GDHELPERS_H
+#define GDHELPERS_H 1
+
+/* TBB: strtok_r is not universal; provide an implementation of it. */
+
+extern char *gd_strtok_r(char *s, char *sep, char **state);
+
+/* These functions wrap memory management. gdFree is
+ in gd.h, where callers can utilize it to correctly
+ free memory allocated by these functions with the
+ right version of free(). */
+void *gdCalloc(size_t nmemb, size_t size);
+void *gdMalloc(size_t size);
+void *gdRealloc(void *ptr, size_t size);
+
+#endif /* GDHELPERS_H */
+
--- /dev/null
+
+/* gdkanji.c (Kanji code converter) */
+/* written by Masahito Yamaga (ma@yama-ga.com) */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#include <stdarg.h>
+#if defined(HAVE_ICONV_H) || defined(HAVE_ICONV)
+#include <iconv.h>
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#endif
+
+#if defined(HAVE_ICONV_H) && !defined(HAVE_ICONV)
+#define HAVE_ICONV 1
+#endif
+
+#define LIBNAME "any2eucjp()"
+
+#if defined(__MSC__) || defined(__BORLANDC__) || defined(__TURBOC__) || defined(_Windows) || defined(MSDOS)
+#ifndef SJISPRE
+#define SJISPRE 1
+#endif
+#endif
+
+#ifdef TRUE
+#undef TRUE
+#endif
+#ifdef FALSE
+#undef FALSE
+#endif
+
+#define TRUE 1
+#define FALSE 0
+
+#define NEW 1
+#define OLD 2
+#define ESCI 3
+#define NEC 4
+#define EUC 5
+#define SJIS 6
+#define EUCORSJIS 7
+#define ASCII 8
+
+#define NEWJISSTR "JIS7"
+#define OLDJISSTR "jis"
+#define EUCSTR "eucJP"
+#define SJISSTR "SJIS"
+
+#define ESC 27
+#define SS2 142
+
+static void
+debug (const char *format,...)
+{
+#ifdef DEBUG
+ va_list args;
+
+ va_start (args, format);
+ fprintf (stdout, "%s: ", LIBNAME);
+ vfprintf (stdout, format, args);
+ fprintf (stdout, "\n");
+ va_end (args);
+#endif
+}
+
+static void
+error (const char *format,...)
+{
+ va_list args;
+
+ va_start (args, format);
+ fprintf (stderr, "%s: ", LIBNAME);
+ vfprintf (stderr, format, args);
+ fprintf (stderr, "\n");
+ va_end (args);
+}
+
+/* DetectKanjiCode() derived from DetectCodeType() by Ken Lunde. */
+
+static int
+DetectKanjiCode (unsigned char *str)
+{
+ static int whatcode = ASCII;
+ int oldcode = ASCII;
+ int c, i;
+ char *lang = NULL;
+
+ c = '\1';
+ i = 0;
+
+ if (whatcode != EUCORSJIS && whatcode != ASCII)
+ {
+ oldcode = whatcode;
+ whatcode = ASCII;
+ }
+
+ while ((whatcode == EUCORSJIS || whatcode == ASCII) && c != '\0')
+ {
+ if ((c = str[i++]) != '\0')
+ {
+ if (c == ESC)
+ {
+ c = str[i++];
+ if (c == '$')
+ {
+ c = str[i++];
+ if (c == 'B')
+ whatcode = NEW;
+ else if (c == '@')
+ whatcode = OLD;
+ }
+ else if (c == '(')
+ {
+ c = str[i++];
+ if (c == 'I')
+ whatcode = ESCI;
+ }
+ else if (c == 'K')
+ whatcode = NEC;
+ }
+ else if ((c >= 129 && c <= 141) || (c >= 143 && c <= 159))
+ whatcode = SJIS;
+ else if (c == SS2)
+ {
+ c = str[i++];
+ if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160) || (c >= 224 && c <= 252))
+ whatcode = SJIS;
+ else if (c >= 161 && c <= 223)
+ whatcode = EUCORSJIS;
+ }
+ else if (c >= 161 && c <= 223)
+ {
+ c = str[i++];
+ if (c >= 240 && c <= 254)
+ whatcode = EUC;
+ else if (c >= 161 && c <= 223)
+ whatcode = EUCORSJIS;
+ else if (c >= 224 && c <= 239)
+ {
+ whatcode = EUCORSJIS;
+ while (c >= 64 && c != '\0' && whatcode == EUCORSJIS)
+ {
+ if (c >= 129)
+ {
+ if (c <= 141 || (c >= 143 && c <= 159))
+ whatcode = SJIS;
+ else if (c >= 253 && c <= 254)
+ whatcode = EUC;
+ }
+ c = str[i++];
+ }
+ }
+ else if (c <= 159)
+ whatcode = SJIS;
+ }
+ else if (c >= 240 && c <= 254)
+ whatcode = EUC;
+ else if (c >= 224 && c <= 239)
+ {
+ c = str[i++];
+ if ((c >= 64 && c <= 126) || (c >= 128 && c <= 160))
+ whatcode = SJIS;
+ else if (c >= 253 && c <= 254)
+ whatcode = EUC;
+ else if (c >= 161 && c <= 252)
+ whatcode = EUCORSJIS;
+ }
+ }
+ }
+
+#ifdef DEBUG
+ if (whatcode == ASCII)
+ debug ("Kanji code not included.");
+ else if (whatcode == EUCORSJIS)
+ debug ("Kanji code not detected.");
+ else
+ debug ("Kanji code detected at %d byte.", i);
+#endif
+
+ if (whatcode == EUCORSJIS && oldcode != ASCII)
+ whatcode = oldcode;
+
+ if (whatcode == EUCORSJIS)
+ {
+ if (getenv ("LC_ALL"))
+ lang = getenv ("LC_ALL");
+ else if (getenv ("LC_CTYPE"))
+ lang = getenv ("LC_CTYPE");
+ else if (getenv ("LANG"))
+ lang = getenv ("LANG");
+
+ if (lang)
+ {
+ if (strcmp (lang, "ja_JP.SJIS") == 0 ||
+#ifdef hpux
+ strcmp (lang, "japanese") == 0 ||
+#endif
+ strcmp (lang, "ja_JP.mscode") == 0 ||
+ strcmp (lang, "ja_JP.PCK") == 0)
+ whatcode = SJIS;
+ else if (strncmp (lang, "ja", 2) == 0)
+#ifdef SJISPRE
+ whatcode = SJIS;
+#else
+ whatcode = EUC;
+#endif
+ }
+ }
+
+ if (whatcode == EUCORSJIS)
+#ifdef SJISPRE
+ whatcode = SJIS;
+#else
+ whatcode = EUC;
+#endif
+
+ return whatcode;
+}
+
+/* SJIStoJIS() is sjis2jis() by Ken Lunde. */
+
+static void
+SJIStoJIS (int *p1, int *p2)
+{
+ register unsigned char c1 = *p1;
+ register unsigned char c2 = *p2;
+ register int adjust = c2 < 159;
+ register int rowOffset = c1 < 160 ? 112 : 176;
+ register int cellOffset = adjust ? (31 + (c2 > 127)) : 126;
+
+ *p1 = ((c1 - rowOffset) << 1) - adjust;
+ *p2 -= cellOffset;
+}
+
+/* han2zen() was derived from han2zen() written by Ken Lunde. */
+
+#define IS_DAKU(c) ((c >= 182 && c <= 196) || (c >= 202 && c <= 206) || (c == 179))
+#define IS_HANDAKU(c) (c >= 202 && c <= 206)
+
+static void
+han2zen (int *p1, int *p2)
+{
+ int c = *p1;
+ int daku = FALSE;
+ int handaku = FALSE;
+ int mtable[][2] =
+ {
+ {129, 66},
+ {129, 117},
+ {129, 118},
+ {129, 65},
+ {129, 69},
+ {131, 146},
+ {131, 64},
+ {131, 66},
+ {131, 68},
+ {131, 70},
+ {131, 72},
+ {131, 131},
+ {131, 133},
+ {131, 135},
+ {131, 98},
+ {129, 91},
+ {131, 65},
+ {131, 67},
+ {131, 69},
+ {131, 71},
+ {131, 73},
+ {131, 74},
+ {131, 76},
+ {131, 78},
+ {131, 80},
+ {131, 82},
+ {131, 84},
+ {131, 86},
+ {131, 88},
+ {131, 90},
+ {131, 92},
+ {131, 94},
+ {131, 96},
+ {131, 99},
+ {131, 101},
+ {131, 103},
+ {131, 105},
+ {131, 106},
+ {131, 107},
+ {131, 108},
+ {131, 109},
+ {131, 110},
+ {131, 113},
+ {131, 116},
+ {131, 119},
+ {131, 122},
+ {131, 125},
+ {131, 126},
+ {131, 128},
+ {131, 129},
+ {131, 130},
+ {131, 132},
+ {131, 134},
+ {131, 136},
+ {131, 137},
+ {131, 138},
+ {131, 139},
+ {131, 140},
+ {131, 141},
+ {131, 143},
+ {131, 147},
+ {129, 74},
+ {129, 75}
+ };
+
+ if (*p2 == 222 && IS_DAKU (*p1))
+ daku = TRUE; /* Daku-ten */
+ else if (*p2 == 223 && IS_HANDAKU (*p1))
+ handaku = TRUE; /* Han-daku-ten */
+
+ *p1 = mtable[c - 161][0];
+ *p2 = mtable[c - 161][1];
+
+ if (daku)
+ {
+ if ((*p2 >= 74 && *p2 <= 103) || (*p2 >= 110 && *p2 <= 122))
+ (*p2)++;
+ else if (*p2 == 131 && *p2 == 69)
+ *p2 = 148;
+ }
+ else if (handaku && *p2 >= 110 && *p2 <= 122)
+ (*p2) += 2;
+}
+
+/* Recast strcpy to handle unsigned chars used below. */
+#define ustrcpy(A,B) (strcpy((char*)(A),(const char*)(B)))
+
+static void
+do_convert (unsigned char *to, unsigned char *from, const char *code)
+{
+#ifdef HAVE_ICONV
+ iconv_t cd;
+ size_t from_len, to_len;
+
+ if ((cd = iconv_open (EUCSTR, code)) == (iconv_t) - 1)
+ {
+ error ("iconv_open() error");
+#ifdef HAVE_ERRNO_H
+ if (errno == EINVAL)
+ error ("invalid code specification: \"%s\" or \"%s\"",
+ EUCSTR, code);
+#endif
+ strcpy ((char *) to, (const char *) from);
+ return;
+ }
+
+ from_len = strlen ((const char *) from) + 1;
+ to_len = BUFSIZ;
+
+ if (iconv (cd, (const char **) &from, &from_len,
+ (char **) &to, &to_len) == -1)
+ {
+#ifdef HAVE_ERRNO_H
+ if (errno == EINVAL)
+ error ("invalid end of input string");
+ else if (errno == EILSEQ)
+ error ("invalid code in input string");
+ else if (errno == E2BIG)
+ error ("output buffer overflow at do_convert()");
+ else
+#endif
+ error ("something happen");
+ strcpy ((char *) to, (const char *) from);
+ return;
+ }
+
+ if (iconv_close (cd) != 0)
+ {
+ error ("iconv_close() error");
+ }
+#else
+ int p1, p2, i, j;
+ int jisx0208 = FALSE;
+ int hankaku = FALSE;
+
+ j = 0;
+ if (strcmp (code, NEWJISSTR) == 0 || strcmp (code, OLDJISSTR) == 0)
+ {
+ for (i = 0; from[i] != '\0' && j < BUFSIZ; i++)
+ {
+ if (from[i] == ESC)
+ {
+ i++;
+ if (from[i] == '$')
+ {
+ jisx0208 = TRUE;
+ hankaku = FALSE;
+ i++;
+ }
+ else if (from[i] == '(')
+ {
+ jisx0208 = FALSE;
+ i++;
+ if (from[i] == 'I') /* Hankaku Kana */
+ hankaku = TRUE;
+ else
+ hankaku = FALSE;
+ }
+ }
+ else
+ {
+ if (jisx0208)
+ to[j++] = from[i] + 128;
+ else if (hankaku)
+ {
+ to[j++] = SS2;
+ to[j++] = from[i] + 128;
+ }
+ else
+ to[j++] = from[i];
+ }
+ }
+ }
+ else if (strcmp (code, SJISSTR) == 0)
+ {
+ for (i = 0; from[i] != '\0' && j < BUFSIZ; i++)
+ {
+ p1 = from[i];
+ if (p1 < 127)
+ to[j++] = p1;
+ else if ((p1 >= 161) && (p1 <= 223))
+ { /* Hankaku Kana */
+ to[j++] = SS2;
+ to[j++] = p1;
+ }
+ else
+ {
+ p2 = from[++i];
+ SJIStoJIS (&p1, &p2);
+ to[j++] = p1 + 128;
+ to[j++] = p2 + 128;
+ }
+ }
+ }
+ else
+ {
+ error ("invalid code specification: \"%s\"", code);
+ return;
+ }
+
+ if (j >= BUFSIZ)
+ {
+ error ("output buffer overflow at do_convert()");
+ ustrcpy (to, from);
+ }
+ else
+ to[j] = '\0';
+#endif /* HAVE_ICONV */
+}
+
+static int
+do_check_and_conv (unsigned char *to, unsigned char *from)
+{
+ static unsigned char tmp[BUFSIZ];
+ int p1, p2, i, j;
+ int kanji = TRUE;
+
+ switch (DetectKanjiCode (from))
+ {
+ case NEW:
+ debug ("Kanji code is New JIS.");
+ do_convert (tmp, from, NEWJISSTR);
+ break;
+ case OLD:
+ debug ("Kanji code is Old JIS.");
+ do_convert (tmp, from, OLDJISSTR);
+ break;
+ case ESCI:
+ debug ("This string includes Hankaku-Kana (jisx0201) escape sequence [ESC] + ( + I.");
+ do_convert (tmp, from, NEWJISSTR);
+ break;
+ case NEC:
+ debug ("Kanji code is NEC Kanji.");
+ error ("cannot convert NEC Kanji.");
+ ustrcpy (tmp, from);
+ kanji = FALSE;
+ break;
+ case EUC:
+ debug ("Kanji code is EUC.");
+ ustrcpy (tmp, from);
+ break;
+ case SJIS:
+ debug ("Kanji code is SJIS.");
+ do_convert (tmp, from, SJISSTR);
+ break;
+ case EUCORSJIS:
+ debug ("Kanji code is EUC or SJIS.");
+ ustrcpy (tmp, from);
+ kanji = FALSE;
+ break;
+ case ASCII:
+ debug ("This is ASCII string.");
+ ustrcpy (tmp, from);
+ kanji = FALSE;
+ break;
+ default:
+ debug ("This string includes unknown code.");
+ ustrcpy (tmp, from);
+ kanji = FALSE;
+ break;
+ }
+
+ /* Hankaku Kana ---> Zenkaku Kana */
+ if (kanji)
+ {
+ j = 0;
+ for (i = 0; tmp[i] != '\0' && j < BUFSIZ; i++)
+ {
+ if (tmp[i] == SS2)
+ {
+ p1 = tmp[++i];
+ if (tmp[i + 1] == SS2)
+ {
+ p2 = tmp[i + 2];
+ if (p2 == 222 || p2 == 223)
+ i += 2;
+ else
+ p2 = 0;
+ }
+ else
+ p2 = 0;
+ han2zen (&p1, &p2);
+ SJIStoJIS (&p1, &p2);
+ to[j++] = p1 + 128;
+ to[j++] = p2 + 128;
+ }
+ else
+ to[j++] = tmp[i];
+ }
+
+ if (j >= BUFSIZ)
+ {
+ error ("output buffer overflow at Hankaku --> Zenkaku");
+ ustrcpy (to, tmp);
+ }
+ else
+ to[j] = '\0';
+ }
+ else
+ ustrcpy (to, tmp);
+
+ return kanji;
+}
+
+int
+any2eucjp (unsigned char *dest, unsigned char *src, unsigned int dest_max)
+{
+ static unsigned char tmp_dest[BUFSIZ];
+ int ret;
+
+ if (strlen ((const char *) src) >= BUFSIZ)
+ {
+ error ("input string too large");
+ return -1;
+ }
+ if (dest_max > BUFSIZ)
+ {
+ error ("invalid maximum size of destination\nit should be less than %d.", BUFSIZ);
+ return -1;
+ }
+ ret = do_check_and_conv (tmp_dest, src);
+ if (strlen ((const char *) tmp_dest) >= dest_max)
+ {
+ error ("output buffer overflow");
+ ustrcpy (dest, src);
+ return -1;
+ }
+ ustrcpy (dest, tmp_dest);
+ return ret;
+}
+
+#if 0
+unsigned int
+strwidth (unsigned char *s)
+{
+ unsigned char *t;
+ unsigned int i;
+
+ t = (unsigned char *) gdMalloc (BUFSIZ);
+ any2eucjp (t, s, BUFSIZ);
+ i = strlen (t);
+ gdFree (t);
+ return i;
+}
+
+#ifdef DEBUG
+int
+main ()
+{
+ unsigned char input[BUFSIZ];
+ unsigned char *output;
+ unsigned char *str;
+ int c, i = 0;
+
+ while ((c = fgetc (stdin)) != '\n' && i < BUFSIZ)
+ input[i++] = c;
+ input[i] = '\0';
+
+ printf ("input : %d bytes\n", strlen ((const char *) input));
+ printf ("output: %d bytes\n", strwidth (input));
+
+ output = (unsigned char *) gdMalloc (BUFSIZ);
+ any2eucjp (output, input, BUFSIZ);
+ str = output;
+ while (*str != '\0')
+ putchar (*(str++));
+ putchar ('\n');
+ gdFree (output);
+
+ return 0;
+}
+#endif
+#endif
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h> /* For atoi */
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in, *out;
+ int x, y, w, h;
+
+ if (argc != 7)
+ {
+ fprintf (stderr, "Usage: gdparttopng filename.gd filename.png x y w h\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+
+ x = atoi (argv[3]);
+ y = atoi (argv[4]);
+ w = atoi (argv[5]);
+ h = atoi (argv[6]);
+
+ printf ("Extracting from (%d, %d), size is %dx%d\n", x, y, w, h);
+
+ im = gdImageCreateFromGd2Part (in, x, y, w, h);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in PNG format!\n");
+ exit (1);
+ }
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ gdImagePng (im, out);
+ fclose (out);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+
+int gdCosT[] =
+{
+ 1024,
+ 1023,
+ 1023,
+ 1022,
+ 1021,
+ 1020,
+ 1018,
+ 1016,
+ 1014,
+ 1011,
+ 1008,
+ 1005,
+ 1001,
+ 997,
+ 993,
+ 989,
+ 984,
+ 979,
+ 973,
+ 968,
+ 962,
+ 955,
+ 949,
+ 942,
+ 935,
+ 928,
+ 920,
+ 912,
+ 904,
+ 895,
+ 886,
+ 877,
+ 868,
+ 858,
+ 848,
+ 838,
+ 828,
+ 817,
+ 806,
+ 795,
+ 784,
+ 772,
+ 760,
+ 748,
+ 736,
+ 724,
+ 711,
+ 698,
+ 685,
+ 671,
+ 658,
+ 644,
+ 630,
+ 616,
+ 601,
+ 587,
+ 572,
+ 557,
+ 542,
+ 527,
+ 512,
+ 496,
+ 480,
+ 464,
+ 448,
+ 432,
+ 416,
+ 400,
+ 383,
+ 366,
+ 350,
+ 333,
+ 316,
+ 299,
+ 282,
+ 265,
+ 247,
+ 230,
+ 212,
+ 195,
+ 177,
+ 160,
+ 142,
+ 124,
+ 107,
+ 89,
+ 71,
+ 53,
+ 35,
+ 17,
+ 0,
+ -17,
+ -35,
+ -53,
+ -71,
+ -89,
+ -107,
+ -124,
+ -142,
+ -160,
+ -177,
+ -195,
+ -212,
+ -230,
+ -247,
+ -265,
+ -282,
+ -299,
+ -316,
+ -333,
+ -350,
+ -366,
+ -383,
+ -400,
+ -416,
+ -432,
+ -448,
+ -464,
+ -480,
+ -496,
+ -512,
+ -527,
+ -542,
+ -557,
+ -572,
+ -587,
+ -601,
+ -616,
+ -630,
+ -644,
+ -658,
+ -671,
+ -685,
+ -698,
+ -711,
+ -724,
+ -736,
+ -748,
+ -760,
+ -772,
+ -784,
+ -795,
+ -806,
+ -817,
+ -828,
+ -838,
+ -848,
+ -858,
+ -868,
+ -877,
+ -886,
+ -895,
+ -904,
+ -912,
+ -920,
+ -928,
+ -935,
+ -942,
+ -949,
+ -955,
+ -962,
+ -968,
+ -973,
+ -979,
+ -984,
+ -989,
+ -993,
+ -997,
+ -1001,
+ -1005,
+ -1008,
+ -1011,
+ -1014,
+ -1016,
+ -1018,
+ -1020,
+ -1021,
+ -1022,
+ -1023,
+ -1023,
+ -1024,
+ -1023,
+ -1023,
+ -1022,
+ -1021,
+ -1020,
+ -1018,
+ -1016,
+ -1014,
+ -1011,
+ -1008,
+ -1005,
+ -1001,
+ -997,
+ -993,
+ -989,
+ -984,
+ -979,
+ -973,
+ -968,
+ -962,
+ -955,
+ -949,
+ -942,
+ -935,
+ -928,
+ -920,
+ -912,
+ -904,
+ -895,
+ -886,
+ -877,
+ -868,
+ -858,
+ -848,
+ -838,
+ -828,
+ -817,
+ -806,
+ -795,
+ -784,
+ -772,
+ -760,
+ -748,
+ -736,
+ -724,
+ -711,
+ -698,
+ -685,
+ -671,
+ -658,
+ -644,
+ -630,
+ -616,
+ -601,
+ -587,
+ -572,
+ -557,
+ -542,
+ -527,
+ -512,
+ -496,
+ -480,
+ -464,
+ -448,
+ -432,
+ -416,
+ -400,
+ -383,
+ -366,
+ -350,
+ -333,
+ -316,
+ -299,
+ -282,
+ -265,
+ -247,
+ -230,
+ -212,
+ -195,
+ -177,
+ -160,
+ -142,
+ -124,
+ -107,
+ -89,
+ -71,
+ -53,
+ -35,
+ -17,
+ 0,
+ 17,
+ 35,
+ 53,
+ 71,
+ 89,
+ 107,
+ 124,
+ 142,
+ 160,
+ 177,
+ 195,
+ 212,
+ 230,
+ 247,
+ 265,
+ 282,
+ 299,
+ 316,
+ 333,
+ 350,
+ 366,
+ 383,
+ 400,
+ 416,
+ 432,
+ 448,
+ 464,
+ 480,
+ 496,
+ 512,
+ 527,
+ 542,
+ 557,
+ 572,
+ 587,
+ 601,
+ 616,
+ 630,
+ 644,
+ 658,
+ 671,
+ 685,
+ 698,
+ 711,
+ 724,
+ 736,
+ 748,
+ 760,
+ 772,
+ 784,
+ 795,
+ 806,
+ 817,
+ 828,
+ 838,
+ 848,
+ 858,
+ 868,
+ 877,
+ 886,
+ 895,
+ 904,
+ 912,
+ 920,
+ 928,
+ 935,
+ 942,
+ 949,
+ 955,
+ 962,
+ 968,
+ 973,
+ 979,
+ 984,
+ 989,
+ 993,
+ 997,
+ 1001,
+ 1005,
+ 1008,
+ 1011,
+ 1014,
+ 1016,
+ 1018,
+ 1020,
+ 1021,
+ 1022,
+ 1023,
+ 1023
+};
+
+int gdSinT[] =
+{
+ 0,
+ 17,
+ 35,
+ 53,
+ 71,
+ 89,
+ 107,
+ 124,
+ 142,
+ 160,
+ 177,
+ 195,
+ 212,
+ 230,
+ 247,
+ 265,
+ 282,
+ 299,
+ 316,
+ 333,
+ 350,
+ 366,
+ 383,
+ 400,
+ 416,
+ 432,
+ 448,
+ 464,
+ 480,
+ 496,
+ 512,
+ 527,
+ 542,
+ 557,
+ 572,
+ 587,
+ 601,
+ 616,
+ 630,
+ 644,
+ 658,
+ 671,
+ 685,
+ 698,
+ 711,
+ 724,
+ 736,
+ 748,
+ 760,
+ 772,
+ 784,
+ 795,
+ 806,
+ 817,
+ 828,
+ 838,
+ 848,
+ 858,
+ 868,
+ 877,
+ 886,
+ 895,
+ 904,
+ 912,
+ 920,
+ 928,
+ 935,
+ 942,
+ 949,
+ 955,
+ 962,
+ 968,
+ 973,
+ 979,
+ 984,
+ 989,
+ 993,
+ 997,
+ 1001,
+ 1005,
+ 1008,
+ 1011,
+ 1014,
+ 1016,
+ 1018,
+ 1020,
+ 1021,
+ 1022,
+ 1023,
+ 1023,
+ 1024,
+ 1023,
+ 1023,
+ 1022,
+ 1021,
+ 1020,
+ 1018,
+ 1016,
+ 1014,
+ 1011,
+ 1008,
+ 1005,
+ 1001,
+ 997,
+ 993,
+ 989,
+ 984,
+ 979,
+ 973,
+ 968,
+ 962,
+ 955,
+ 949,
+ 942,
+ 935,
+ 928,
+ 920,
+ 912,
+ 904,
+ 895,
+ 886,
+ 877,
+ 868,
+ 858,
+ 848,
+ 838,
+ 828,
+ 817,
+ 806,
+ 795,
+ 784,
+ 772,
+ 760,
+ 748,
+ 736,
+ 724,
+ 711,
+ 698,
+ 685,
+ 671,
+ 658,
+ 644,
+ 630,
+ 616,
+ 601,
+ 587,
+ 572,
+ 557,
+ 542,
+ 527,
+ 512,
+ 496,
+ 480,
+ 464,
+ 448,
+ 432,
+ 416,
+ 400,
+ 383,
+ 366,
+ 350,
+ 333,
+ 316,
+ 299,
+ 282,
+ 265,
+ 247,
+ 230,
+ 212,
+ 195,
+ 177,
+ 160,
+ 142,
+ 124,
+ 107,
+ 89,
+ 71,
+ 53,
+ 35,
+ 17,
+ 0,
+ -17,
+ -35,
+ -53,
+ -71,
+ -89,
+ -107,
+ -124,
+ -142,
+ -160,
+ -177,
+ -195,
+ -212,
+ -230,
+ -247,
+ -265,
+ -282,
+ -299,
+ -316,
+ -333,
+ -350,
+ -366,
+ -383,
+ -400,
+ -416,
+ -432,
+ -448,
+ -464,
+ -480,
+ -496,
+ -512,
+ -527,
+ -542,
+ -557,
+ -572,
+ -587,
+ -601,
+ -616,
+ -630,
+ -644,
+ -658,
+ -671,
+ -685,
+ -698,
+ -711,
+ -724,
+ -736,
+ -748,
+ -760,
+ -772,
+ -784,
+ -795,
+ -806,
+ -817,
+ -828,
+ -838,
+ -848,
+ -858,
+ -868,
+ -877,
+ -886,
+ -895,
+ -904,
+ -912,
+ -920,
+ -928,
+ -935,
+ -942,
+ -949,
+ -955,
+ -962,
+ -968,
+ -973,
+ -979,
+ -984,
+ -989,
+ -993,
+ -997,
+ -1001,
+ -1005,
+ -1008,
+ -1011,
+ -1014,
+ -1016,
+ -1018,
+ -1020,
+ -1021,
+ -1022,
+ -1023,
+ -1023,
+ -1024,
+ -1023,
+ -1023,
+ -1022,
+ -1021,
+ -1020,
+ -1018,
+ -1016,
+ -1014,
+ -1011,
+ -1008,
+ -1005,
+ -1001,
+ -997,
+ -993,
+ -989,
+ -984,
+ -979,
+ -973,
+ -968,
+ -962,
+ -955,
+ -949,
+ -942,
+ -935,
+ -928,
+ -920,
+ -912,
+ -904,
+ -895,
+ -886,
+ -877,
+ -868,
+ -858,
+ -848,
+ -838,
+ -828,
+ -817,
+ -806,
+ -795,
+ -784,
+ -772,
+ -760,
+ -748,
+ -736,
+ -724,
+ -711,
+ -698,
+ -685,
+ -671,
+ -658,
+ -644,
+ -630,
+ -616,
+ -601,
+ -587,
+ -572,
+ -557,
+ -542,
+ -527,
+ -512,
+ -496,
+ -480,
+ -464,
+ -448,
+ -432,
+ -416,
+ -400,
+ -383,
+ -366,
+ -350,
+ -333,
+ -316,
+ -299,
+ -282,
+ -265,
+ -247,
+ -230,
+ -212,
+ -195,
+ -177,
+ -160,
+ -142,
+ -124,
+ -107,
+ -89,
+ -71,
+ -53,
+ -35,
+ -17
+};
--- /dev/null
+#include <stdio.h>
+#ifdef _WIN32
+#include <process.h>
+int
+unlink (const char *filename)
+{
+ return _unlink (filename);
+}
+#else
+#include <unistd.h> /* for getpid(), unlink() */
+#endif
+#include "gd.h"
+
+void CompareImages (char *msg, gdImagePtr im1, gdImagePtr im2);
+
+static int freadWrapper (void *context, char *buf, int len);
+static int fwriteWrapper (void *context, const char *buffer, int len);
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im, ref, im2, im3;
+ FILE *in, *out;
+ void *iptr;
+ int sz;
+ gdIOCtxPtr ctx;
+ char of[256];
+ int colRed, colBlu;
+ gdSource imgsrc;
+ gdSink imgsnk;
+ int foreground;
+ int i;
+ if (argc != 2)
+ {
+ fprintf (stderr, "Usage: gdtest filename.png\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromPng (in);
+
+ rewind (in);
+ ref = gdImageCreateFromPng (in);
+
+ fclose (in);
+
+ printf ("Reference File has %d Palette entries\n", ref->colorsTotal);
+
+ CompareImages ("Initial Versions", ref, im);
+
+
+ /* */
+ /* Send to PNG File then Ptr */
+ /* */
+ sprintf (of, "%s.png", argv[1]);
+ out = fopen (of, "wb");
+ gdImagePng (im, out);
+ fclose (out);
+
+ in = fopen (of, "rb");
+ if (!in)
+ {
+ fprintf (stderr, "PNG Output file does not exist!\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromPng (in);
+ fclose (in);
+
+ CompareImages ("GD->PNG File->GD", ref, im2);
+
+ unlink (of);
+ gdImageDestroy (im2);
+
+ iptr = gdImagePngPtr (im, &sz);
+ ctx = gdNewDynamicCtx (sz, iptr);
+ im2 = gdImageCreateFromPngCtx (ctx);
+
+ CompareImages ("GD->PNG ptr->GD", ref, im2);
+
+ gdImageDestroy (im2);
+ ctx->free (ctx);
+
+
+ /* */
+ /* Send to GD2 File then Ptr */
+ /* */
+ sprintf (of, "%s.gd2", argv[1]);
+ out = fopen (of, "wb");
+ gdImageGd2 (im, out, 128, 2);
+ fclose (out);
+
+ in = fopen (of, "rb");
+ if (!in)
+ {
+ fprintf (stderr, "GD2 Output file does not exist!\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromGd2 (in);
+ fclose (in);
+
+ CompareImages ("GD->GD2 File->GD", ref, im2);
+
+ unlink (of);
+ gdImageDestroy (im2);
+
+ iptr = gdImageGd2Ptr (im, 128, 2, &sz);
+ /*printf("Got ptr %d (size %d)\n",iptr, sz); */
+ ctx = gdNewDynamicCtx (sz, iptr);
+ /*printf("Got ctx %d\n",ctx); */
+ im2 = gdImageCreateFromGd2Ctx (ctx);
+ /*printf("Got img2 %d\n",im2); */
+
+ CompareImages ("GD->GD2 ptr->GD", ref, im2);
+
+ gdImageDestroy (im2);
+ ctx->free (ctx);
+
+
+ /* */
+ /* Send to GD File then Ptr */
+ /* */
+ sprintf (of, "%s.gd", argv[1]);
+ out = fopen (of, "wb");
+ gdImageGd (im, out);
+ fclose (out);
+
+ in = fopen (of, "rb");
+ if (!in)
+ {
+ fprintf (stderr, "GD Output file does not exist!\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromGd (in);
+ fclose (in);
+
+ CompareImages ("GD->GD File->GD", ref, im2);
+
+ unlink (of);
+ gdImageDestroy (im2);
+
+ iptr = gdImageGdPtr (im, &sz);
+ /*printf("Got ptr %d (size %d)\n",iptr, sz); */
+ ctx = gdNewDynamicCtx (sz, iptr);
+ /*printf("Got ctx %d\n",ctx); */
+ im2 = gdImageCreateFromGdCtx (ctx);
+ /*printf("Got img2 %d\n",im2); */
+
+ CompareImages ("GD->GD ptr->GD", ref, im2);
+
+ gdImageDestroy (im2);
+ ctx->free (ctx);
+
+ /*
+ ** Test gdImageCreateFromPngSource'
+ * */
+
+ in = fopen (argv[1], "rb");
+
+ imgsrc.source = freadWrapper;
+ imgsrc.context = in;
+ im2 = gdImageCreateFromPngSource (&imgsrc);
+ fclose (in);
+
+ if (im2 == NULL)
+ {
+ printf ("GD Source: ERROR Null returned by gdImageCreateFromPngSource\n");
+ }
+ else
+ {
+ CompareImages ("GD Source", ref, im2);
+ gdImageDestroy (im2);
+ };
+
+
+ /*
+ ** Test gdImagePngToSink'
+ * */
+
+ sprintf (of, "%s.snk", argv[1]);
+ out = fopen (of, "wb");
+ imgsnk.sink = fwriteWrapper;
+ imgsnk.context = out;
+ gdImagePngToSink (im, &imgsnk);
+ fclose (out);
+ in = fopen (of, "rb");
+ if (!in)
+ {
+ fprintf (stderr, "GD Sink: ERROR - GD Sink Output file does not exist!\n");
+ }
+ else
+ {
+ im2 = gdImageCreateFromPng (in);
+ fclose (in);
+
+ CompareImages ("GD Sink", ref, im2);
+ gdImageDestroy (im2);
+ };
+
+ unlink (of);
+
+ /* */
+ /* Test Extraction */
+ /* */
+ in = fopen ("test/gdtest_200_300_150_100.png", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "gdtest_200_300_150_100.png does not exist!\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromPng (in);
+ fclose (in);
+
+
+ in = fopen ("test/gdtest.gd2", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "gdtest.gd2 does not exist!\n");
+ exit (1);
+ }
+ im3 = gdImageCreateFromGd2Part (in, 200, 300, 150, 100);
+ fclose (in);
+
+ CompareImages ("GD2Part (gdtest_200_300_150_100.png, gdtest.gd2(part))", im2, im3);
+
+ gdImageDestroy (im2);
+ gdImageDestroy (im3);
+
+ /* */
+ /* Copy Blend */
+ /* */
+ in = fopen ("test/gdtest.png", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "gdtest.png does not exist!\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromPng (in);
+ fclose (in);
+
+ im3 = gdImageCreate (100, 60);
+ colRed = gdImageColorAllocate (im3, 255, 0, 0);
+ colBlu = gdImageColorAllocate (im3, 0, 0, 255);
+ gdImageFilledRectangle (im3, 0, 0, 49, 30, colRed);
+ gdImageFilledRectangle (im3, 50, 30, 99, 59, colBlu);
+
+ gdImageCopyMerge (im2, im3, 150, 200, 10, 10, 90, 50, 50);
+ gdImageCopyMerge (im2, im3, 180, 70, 10, 10, 90, 50, 50);
+
+ gdImageCopyMergeGray (im2, im3, 250, 160, 10, 10, 90, 50, 50);
+ gdImageCopyMergeGray (im2, im3, 80, 70, 10, 10, 90, 50, 50);
+
+ gdImageDestroy (im3);
+
+ in = fopen ("test/gdtest_merge.png", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "gdtest_merge.png does not exist!\n");
+ exit (1);
+ }
+ im3 = gdImageCreateFromPng (in);
+ fclose (in);
+
+ printf ("[Merged Image has %d colours]\n", im2->colorsTotal);
+ CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3);
+
+ gdImageDestroy (im2);
+ gdImageDestroy (im3);
+
+#ifdef HAVE_JPEG
+ out = fopen ("test/gdtest.jpg", "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Can't create file test/gdtest.jpg.\n");
+ exit (1);
+ }
+ gdImageJpeg (im, out, -1);
+ fclose (out);
+ in = fopen ("test/gdtest.jpg", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Can't open file test/gdtest.jpg.\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromJpeg (in);
+ fclose (in);
+ if (!im2)
+ {
+ fprintf (stderr, "gdImageCreateFromJpeg failed.\n");
+ exit (1);
+ }
+ gdImageDestroy (im2);
+ printf ("Created test/gdtest.jpg successfully. Compare this image\n"
+ "to the input image manually. Some difference must be\n"
+ "expected as JPEG is a lossy file format.\n");
+#endif /* HAVE_JPEG */
+ /* Assume the color closest to black is the foreground
+ color for the B&W wbmp image. */
+ fprintf (stderr, "NOTE: the WBMP output image will NOT match the original unless the original\n"
+ "is also black and white. This is OK!\n");
+ foreground = gdImageColorClosest (im, 0, 0, 0);
+ fprintf (stderr, "Foreground index is %d\n", foreground);
+ if (foreground == -1)
+ {
+ fprintf (stderr, "Source image has no colors, skipping wbmp test.\n");
+ }
+ else
+ {
+ out = fopen ("test/gdtest.wbmp", "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Can't create file test/gdtest.wbmp.\n");
+ exit (1);
+ }
+ gdImageWBMP (im, foreground, out);
+ fclose (out);
+ in = fopen ("test/gdtest.wbmp", "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Can't open file test/gdtest.wbmp.\n");
+ exit (1);
+ }
+ im2 = gdImageCreateFromWBMP (in);
+ fprintf (stderr, "WBMP has %d colors\n", gdImageColorsTotal (im2));
+ fprintf (stderr, "WBMP colors are:\n");
+ for (i = 0; (i < gdImageColorsTotal (im2)); i++)
+ {
+ fprintf (stderr, "%02X%02X%02X\n",
+ gdImageRed (im2, i),
+ gdImageGreen (im2, i),
+ gdImageBlue (im2, i));
+ }
+ fclose (in);
+ if (!im2)
+ {
+ fprintf (stderr, "gdImageCreateFromWBMP failed.\n");
+ exit (1);
+ }
+ CompareImages ("WBMP test (gdtest.png, gdtest.wbmp)", ref, im2);
+ out = fopen ("test/gdtest_wbmp_to_png.png", "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Can't create file test/gdtest_wbmp_to_png.png.\n");
+ exit (1);
+ }
+ gdImagePng (im2, out);
+ fclose (out);
+ gdImageDestroy (im2);
+ }
+ gdImageDestroy (im);
+ gdImageDestroy (ref);
+
+ return 0;
+}
+
+void
+CompareImages (char *msg, gdImagePtr im1, gdImagePtr im2)
+{
+ int cmpRes;
+
+ cmpRes = gdImageCompare (im1, im2);
+
+ if (cmpRes & GD_CMP_IMAGE)
+ {
+ printf ("%%%s: ERROR images differ: BAD\n", msg);
+ }
+ else if (cmpRes != 0)
+ {
+ printf ("%%%s: WARNING images differ: WARNING - Probably OK\n", msg);
+ }
+ else
+ {
+ printf ("%%%s: OK\n", msg);
+ return;
+ }
+
+ if (cmpRes & (GD_CMP_SIZE_X + GD_CMP_SIZE_Y))
+ {
+ printf ("-%s: INFO image sizes differ\n", msg);
+ }
+
+ if (cmpRes & GD_CMP_NUM_COLORS)
+ {
+ printf ("-%s: INFO number of pallette entries differ %d Vs. %d\n", msg,
+ im1->colorsTotal, im2->colorsTotal);
+ }
+
+ if (cmpRes & GD_CMP_COLOR)
+ {
+ printf ("-%s: INFO actual colours of pixels differ\n", msg);
+ }
+}
+
+
+static int
+freadWrapper (void *context, char *buf, int len)
+{
+ int got = fread (buf, 1, len, (FILE *) context);
+ return got;
+}
+
+static int
+fwriteWrapper (void *context, const char *buffer, int len)
+{
+ return fwrite (buffer, 1, len, (FILE *) context);
+}
--- /dev/null
+
+#include "gd.h"
+#include <string.h>
+
+#define PI 3.141592
+#define DEG2RAD(x) ((x)*PI/180.)
+
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+
+#define MAX4(x,y,z,w) \
+ ((MAX((x),(y))) > (MAX((z),(w))) ? (MAX((x),(y))) : (MAX((z),(w))))
+#define MIN4(x,y,z,w) \
+ ((MIN((x),(y))) < (MIN((z),(w))) ? (MIN((x),(y))) : (MIN((z),(w))))
+
+#define MAXX(x) MAX4(x[0],x[2],x[4],x[6])
+#define MINX(x) MIN4(x[0],x[2],x[4],x[6])
+#define MAXY(x) MAX4(x[1],x[3],x[5],x[7])
+#define MINY(x) MIN4(x[1],x[3],x[5],x[7])
+
+int
+main (int argc, char *argv[])
+{
+#ifndef HAVE_LIBFREETYPE
+ fprintf (stderr, "gd was not compiled with HAVE_LIBFREETYPE defined.\n");
+ fprintf (stderr, "Install the FreeType library, including the\n");
+ fprintf (stderr, "header files. Then edit the gd Makefile, type\n");
+ fprintf (stderr, "make clean, and type make again.\n");
+ return 1;
+#else
+ gdImagePtr im;
+ int black;
+ int white;
+ int brect[8];
+ int x, y;
+ char *err;
+ FILE *out;
+#ifdef JISX0208
+ char *s = "Hello. \82±\82ñ\82É\82¿\82Í Qyjpqg,"; /* String to draw. */
+#else
+ char *s = "Hello. Qyjpqg,"; /* String to draw. */
+#endif
+
+ double sz = 40.;
+
+#if 0
+ double angle = 0.;
+#else
+ double angle = DEG2RAD (-90);
+#endif
+
+#ifdef JISX0208
+ char *f = "/usr/openwin/lib/locale/ja/X11/fonts/TT/HG-MinchoL.ttf"; /* UNICODE */
+ /* char *f = "/usr/local/lib/fonts/truetype/DynaFont/dfpop1.ttf"; *//* SJIS */
+#else
+ char *f = "times"; /* TrueType font */
+#endif
+
+ /* obtain brect so that we can size the image */
+ err = gdImageStringFT ((gdImagePtr) NULL, &brect[0], 0, f, sz, angle, 0, 0, s);
+ if (err)
+ {
+ fprintf (stderr, err);
+ return 1;
+ }
+
+ /* create an image just big enough for the string */
+ x = MAXX (brect) - MINX (brect) + 6;
+ y = MAXY (brect) - MINY (brect) + 6;
+#if 0
+ im = gdImageCreate (500, 500);
+#else
+ /* gd 2.0: true color images can use freetype too */
+ im = gdImageCreateTrueColor (x, y);
+#endif
+
+ /* Background color. gd 2.0: fill the image with it; truecolor
+ images have a black background otherwise. */
+ white = gdImageColorResolve (im, 255, 255, 255);
+ gdImageFilledRectangle (im, 0, 0, x, y, white);
+ black = gdImageColorResolve (im, 0, 0, 0);
+
+ /* render the string, offset origin to center string */
+ x = 0 - MINX (brect) + 3;
+ y = 0 - MINY (brect) + 3;
+
+ err = gdImageStringFT (im, NULL, black, f, sz, angle, x, y, s);
+ if (err)
+ {
+ fprintf (stderr, err);
+ return 1;
+ }
+ /* TBB: Write img to test/fttest.png */
+ out = fopen ("test/fttest.png", "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Can't create test/fttest.png\n");
+ exit (1);
+ }
+ gdImagePng (im, out);
+ fclose (out);
+ fprintf (stderr, "Test image written to test/fttest.png\n");
+ /* Destroy it */
+ gdImageDestroy (im);
+
+ return 0;
+#endif /* HAVE_FREETYPE */
+}
--- /dev/null
+#include <stdio.h>
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in, *out;
+ if (argc != 3)
+ {
+ fprintf (stderr, "Usage: gdtopng filename.gd filename.png\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromGd (in);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in PNG format!\n");
+ exit (1);
+ }
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ gdImagePng (im, out);
+ fclose (out);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+
+/*
+ add ability to load xpm files to gd, requires the xpm
+ library.
+ Caolan.McNamara@ul.ie
+ http://www.csn.ul.ie/~caolan
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifndef HAVE_XPM
+gdImagePtr
+gdImageCreateFromXpm (char *filename)
+{
+ fprintf (stderr, "libgd was not built with xpm support\n");
+ return (NULL);
+}
+
+#else
+
+#include "xpm.h"
+
+gdImagePtr
+gdImageCreateFromXpm (char *filename)
+{
+ XpmInfo info;
+ XpmImage image;
+ int i, j, k, number;
+ char buf[5];
+ gdImagePtr im = 0;
+ char *apixel;
+ int *pointer;
+ int red = 0, green = 0, blue = 0, color = 0;
+ int *colors;
+ int ret;
+
+ ret = XpmReadFileToXpmImage (filename, &image, &info);
+ if (ret != XpmSuccess)
+ return 0;
+
+ if (!(im = gdImageCreate (image.width, image.height)))
+ return 0;
+
+ number = image.ncolors;
+ colors = (int *) gdMalloc (sizeof (int) * number);
+ if (colors == NULL)
+ return (0);
+ for (i = 0; i < number; i++)
+ {
+ switch (strlen (image.colorTable[i].c_color))
+ {
+ case 4:
+ buf[1] = '\0';
+ buf[0] = image.colorTable[i].c_color[1];
+ red = strtol (buf, NULL, 16);
+
+ buf[0] = image.colorTable[i].c_color[3];
+ green = strtol (buf, NULL, 16);
+
+ buf[0] = image.colorTable[i].c_color[5];
+ blue = strtol (buf, NULL, 16);
+ break;
+ case 7:
+ buf[2] = '\0';
+ buf[0] = image.colorTable[i].c_color[1];
+ buf[1] = image.colorTable[i].c_color[2];
+ red = strtol (buf, NULL, 16);
+
+ buf[0] = image.colorTable[i].c_color[3];
+ buf[1] = image.colorTable[i].c_color[4];
+ green = strtol (buf, NULL, 16);
+
+ buf[0] = image.colorTable[i].c_color[5];
+ buf[1] = image.colorTable[i].c_color[6];
+ blue = strtol (buf, NULL, 16);
+ break;
+ case 10:
+ buf[3] = '\0';
+ buf[0] = image.colorTable[i].c_color[1];
+ buf[1] = image.colorTable[i].c_color[2];
+ buf[2] = image.colorTable[i].c_color[3];
+ red = strtol (buf, NULL, 16);
+ red /= 64;
+
+ buf[0] = image.colorTable[i].c_color[4];
+ buf[1] = image.colorTable[i].c_color[5];
+ buf[2] = image.colorTable[i].c_color[6];
+ green = strtol (buf, NULL, 16);
+ green /= 64;
+
+ buf[0] = image.colorTable[i].c_color[7];
+ buf[1] = image.colorTable[i].c_color[8];
+ buf[2] = image.colorTable[i].c_color[9];
+ blue = strtol (buf, NULL, 16);
+ blue /= 64;
+ break;
+ case 13:
+ buf[4] = '\0';
+ buf[0] = image.colorTable[i].c_color[1];
+ buf[1] = image.colorTable[i].c_color[2];
+ buf[2] = image.colorTable[i].c_color[3];
+ buf[3] = image.colorTable[i].c_color[4];
+ red = strtol (buf, NULL, 16);
+ red /= 256;
+
+ buf[0] = image.colorTable[i].c_color[5];
+ buf[1] = image.colorTable[i].c_color[6];
+ buf[2] = image.colorTable[i].c_color[7];
+ buf[3] = image.colorTable[i].c_color[8];
+ green = strtol (buf, NULL, 16);
+ green /= 256;
+
+ buf[0] = image.colorTable[i].c_color[9];
+ buf[1] = image.colorTable[i].c_color[10];
+ buf[2] = image.colorTable[i].c_color[11];
+ buf[3] = image.colorTable[i].c_color[12];
+ blue = strtol (buf, NULL, 16);
+ blue /= 256;
+ break;
+ }
+
+
+ colors[i] = gdImageColorResolve (im, red, green, blue);
+ if (colors[i] == -1)
+ fprintf (stderr, "ARRRGH\n");
+ }
+
+ apixel = (char *) gdMalloc (image.cpp + 1);
+ if (apixel == NULL)
+ return (0);
+ apixel[image.cpp] = '\0';
+
+ pointer = image.data;
+ for (i = 0; i < image.height; i++)
+ {
+ for (j = 0; j < image.width; j++)
+ {
+ k = *pointer++;
+ gdImageSetPixel (im, j, i, colors[k]);
+ }
+ }
+ gdFree (apixel);
+ gdFree (colors);
+ return (im);
+}
+#endif
--- /dev/null
+#ifndef JISX0208_H
+#define JISX0208_H
+/* This file was derived from "src/VF_Ftype.c" in VFlib2-2.24.2
+ by Dr. Kakugawa */
+
+/* JIS -> Unicode mapping table */
+static unsigned short UnicodeTbl[][94] = {
+{ /* category 01 */
+0x0000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A, 0xFF1B,
+0xFF1F, 0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8, 0xFF3E,
+0xFFE3, 0xFF3F, 0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003, 0x4EDD,
+0x3005, 0x3006, 0x3007, 0x30FC, 0x2015, 0x2010, 0xFF0F, 0xFF3C,
+0xFF5E, 0x2225, 0xFF5C, 0x2026, 0x2025, 0x2018, 0x2019, 0x201C,
+0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015, 0xFF3B, 0xFF3D, 0xFF5B,
+0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D, 0x300E,
+0x300F, 0x3010, 0x3011, 0xFF0B, 0xFF0D, 0x00B1, 0x00D7, 0x00F7,
+0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E, 0x2234,
+0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5, 0xFF04,
+0xFFE0, 0xFFE1, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20, 0x00A7,
+0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7},
+{ /* category 02 */
+0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC, 0x203B,
+0x3012, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283, 0x222A,
+0x2229, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4, 0x2200, 0x2203,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x2220, 0x22A5, 0x2312, 0x2202, 0x2207,
+0x2261, 0x2252, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D, 0x2235,
+0x222B, 0x222C, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x212B, 0x2030, 0x266F, 0x266D, 0x266A, 0x2020, 0x2021, /**/
+0x00B6, 0x0000, 0x0000, 0x0000, 0x0000, 0x25EF},
+{ /* category 03 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFF10,
+0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18,
+0xFF19, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28,
+0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30,
+0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38,
+0xFF39, 0xFF3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48,
+0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50,
+0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58,
+0xFF59, 0xFF5A, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 04 */
+0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046, 0x3047, 0x3048,
+0x3049, 0x304A, 0x304B, 0x304C, 0x304D, 0x304E, 0x304F, 0x3050,
+0x3051, 0x3052, 0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058,
+0x3059, 0x305A, 0x305B, 0x305C, 0x305D, 0x305E, 0x305F, 0x3060,
+0x3061, 0x3062, 0x3063, 0x3064, 0x3065, 0x3066, 0x3067, 0x3068,
+0x3069, 0x306A, 0x306B, 0x306C, 0x306D, 0x306E, 0x306F, 0x3070,
+0x3071, 0x3072, 0x3073, 0x3074, 0x3075, 0x3076, 0x3077, 0x3078,
+0x3079, 0x307A, 0x307B, 0x307C, 0x307D, 0x307E, 0x307F, 0x3080,
+0x3081, 0x3082, 0x3083, 0x3084, 0x3085, 0x3086, 0x3087, 0x3088,
+0x3089, 0x308A, 0x308B, 0x308C, 0x308D, 0x308E, 0x308F, 0x3090,
+0x3091, 0x3092, 0x3093, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 05 */
+0x30A1, 0x30A2, 0x30A3, 0x30A4, 0x30A5, 0x30A6, 0x30A7, 0x30A8,
+0x30A9, 0x30AA, 0x30AB, 0x30AC, 0x30AD, 0x30AE, 0x30AF, 0x30B0,
+0x30B1, 0x30B2, 0x30B3, 0x30B4, 0x30B5, 0x30B6, 0x30B7, 0x30B8,
+0x30B9, 0x30BA, 0x30BB, 0x30BC, 0x30BD, 0x30BE, 0x30BF, 0x30C0,
+0x30C1, 0x30C2, 0x30C3, 0x30C4, 0x30C5, 0x30C6, 0x30C7, 0x30C8,
+0x30C9, 0x30CA, 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF, 0x30D0,
+0x30D1, 0x30D2, 0x30D3, 0x30D4, 0x30D5, 0x30D6, 0x30D7, 0x30D8,
+0x30D9, 0x30DA, 0x30DB, 0x30DC, 0x30DD, 0x30DE, 0x30DF, 0x30E0,
+0x30E1, 0x30E2, 0x30E3, 0x30E4, 0x30E5, 0x30E6, 0x30E7, 0x30E8,
+0x30E9, 0x30EA, 0x30EB, 0x30EC, 0x30ED, 0x30EE, 0x30EF, 0x30F0,
+0x30F1, 0x30F2, 0x30F3, 0x30F4, 0x30F5, 0x30F6, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 06 */
+0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398,
+0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
+0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8,
+0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0,
+0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 07 */
+0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416,
+0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
+0x041F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426,
+0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E,
+0x042F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451, 0x0436,
+0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
+0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446,
+0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E,
+0x044F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 08 */
+0x2500, 0x2502, 0x250C, 0x2510, 0x2518, 0x2514, 0x251C, 0x252C,
+0x2524, 0x2534, 0x253C, 0x2501, 0x2503, 0x250F, 0x2513, 0x251B,
+0x2517, 0x2523, 0x2533, 0x252B, 0x253B, 0x254B, 0x2520, 0x252F,
+0x2528, 0x2537, 0x253F, 0x251D, 0x2530, 0x2525, 0x2538, 0x2542,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 09 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 10 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 11 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 12 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 13 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 14 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 15 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 16 */
+0x4E9C, 0x5516, 0x5A03, 0x963F, 0x54C0, 0x611B, 0x6328, 0x59F6,
+0x9022, 0x8475, 0x831C, 0x7A50, 0x60AA, 0x63E1, 0x6E25, 0x65ED,
+0x8466, 0x82A6, 0x9BF5, 0x6893, 0x5727, 0x65A1, 0x6271, 0x5B9B,
+0x59D0, 0x867B, 0x98F4, 0x7D62, 0x7DBE, 0x9B8E, 0x6216, 0x7C9F,
+0x88B7, 0x5B89, 0x5EB5, 0x6309, 0x6697, 0x6848, 0x95C7, 0x978D,
+0x674F, 0x4EE5, 0x4F0A, 0x4F4D, 0x4F9D, 0x5049, 0x56F2, 0x5937,
+0x59D4, 0x5A01, 0x5C09, 0x60DF, 0x610F, 0x6170, 0x6613, 0x6905,
+0x70BA, 0x754F, 0x7570, 0x79FB, 0x7DAD, 0x7DEF, 0x80C3, 0x840E,
+0x8863, 0x8B02, 0x9055, 0x907A, 0x533B, 0x4E95, 0x4EA5, 0x57DF,
+0x80B2, 0x90C1, 0x78EF, 0x4E00, 0x58F1, 0x6EA2, 0x9038, 0x7A32,
+0x8328, 0x828B, 0x9C2F, 0x5141, 0x5370, 0x54BD, 0x54E1, 0x56E0,
+0x59FB, 0x5F15, 0x98F2, 0x6DEB, 0x80E4, 0x852D},
+{ /* category 17 */
+0x9662, 0x9670, 0x96A0, 0x97FB, 0x540B, 0x53F3, 0x5B87, 0x70CF,
+0x7FBD, 0x8FC2, 0x96E8, 0x536F, 0x9D5C, 0x7ABA, 0x4E11, 0x7893,
+0x81FC, 0x6E26, 0x5618, 0x5504, 0x6B1D, 0x851A, 0x9C3B, 0x59E5,
+0x53A9, 0x6D66, 0x74DC, 0x958F, 0x5642, 0x4E91, 0x904B, 0x96F2,
+0x834F, 0x990C, 0x53E1, 0x55B6, 0x5B30, 0x5F71, 0x6620, 0x66F3,
+0x6804, 0x6C38, 0x6CF3, 0x6D29, 0x745B, 0x76C8, 0x7A4E, 0x9834,
+0x82F1, 0x885B, 0x8A60, 0x92ED, 0x6DB2, 0x75AB, 0x76CA, 0x99C5,
+0x60A6, 0x8B01, 0x8D8A, 0x95B2, 0x698E, 0x53AD, 0x5186, 0x5712,
+0x5830, 0x5944, 0x5BB4, 0x5EF6, 0x6028, 0x63A9, 0x63F4, 0x6CBF,
+0x6F14, 0x708E, 0x7114, 0x7159, 0x71D5, 0x733F, 0x7E01, 0x8276,
+0x82D1, 0x8597, 0x9060, 0x925B, 0x9D1B, 0x5869, 0x65BC, 0x6C5A,
+0x7525, 0x51F9, 0x592E, 0x5965, 0x5F80, 0x5FDC},
+{ /* category 18 */
+0x62BC, 0x65FA, 0x6A2A, 0x6B27, 0x6BB4, 0x738B, 0x7FC1, 0x8956,
+0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96, 0x837B, 0x5104, 0x5C4B,
+0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA, 0x5378, 0x6069,
+0x6E29, 0x7A4F, 0x97F3, 0x4E0B, 0x5316, 0x4EEE, 0x4F55, 0x4F3D,
+0x4FA1, 0x4F73, 0x52A0, 0x53EF, 0x5609, 0x590F, 0x5AC1, 0x5BB6,
+0x5BE1, 0x79D1, 0x6687, 0x679C, 0x67B6, 0x6B4C, 0x6CB3, 0x706B,
+0x73C2, 0x798D, 0x79BE, 0x7A3C, 0x7B87, 0x82B1, 0x82DB, 0x8304,
+0x8377, 0x83EF, 0x83D3, 0x8766, 0x8AB2, 0x5629, 0x8CA8, 0x8FE6,
+0x904E, 0x971E, 0x868A, 0x4FC4, 0x5CE8, 0x6211, 0x7259, 0x753B,
+0x81E5, 0x82BD, 0x86FE, 0x8CC0, 0x96C5, 0x9913, 0x99D5, 0x4ECB,
+0x4F1A, 0x89E3, 0x56DE, 0x584A, 0x58CA, 0x5EFB, 0x5FEB, 0x602A,
+0x6094, 0x6062, 0x61D0, 0x6212, 0x62D0, 0x6539},
+{ /* category 19 */
+0x9B41, 0x6666, 0x68B0, 0x6D77, 0x7070, 0x754C, 0x7686, 0x7D75,
+0x82A5, 0x87F9, 0x958B, 0x968E, 0x8C9D, 0x51F1, 0x52BE, 0x5916,
+0x54B3, 0x5BB3, 0x5D16, 0x6168, 0x6982, 0x6DAF, 0x788D, 0x84CB,
+0x8857, 0x8A72, 0x93A7, 0x9AB8, 0x6D6C, 0x99A8, 0x86D9, 0x57A3,
+0x67FF, 0x86CE, 0x920E, 0x5283, 0x5687, 0x5404, 0x5ED3, 0x62E1,
+0x64B9, 0x683C, 0x6838, 0x6BBB, 0x7372, 0x78BA, 0x7A6B, 0x899A,
+0x89D2, 0x8D6B, 0x8F03, 0x90ED, 0x95A3, 0x9694, 0x9769, 0x5B66,
+0x5CB3, 0x697D, 0x984D, 0x984E, 0x639B, 0x7B20, 0x6A2B, 0x6A7F,
+0x68B6, 0x9C0D, 0x6F5F, 0x5272, 0x559D, 0x6070, 0x62EC, 0x6D3B,
+0x6E07, 0x6ED1, 0x845B, 0x8910, 0x8F44, 0x4E14, 0x9C39, 0x53F6,
+0x691B, 0x6A3A, 0x9784, 0x682A, 0x515C, 0x7AC3, 0x84B2, 0x91DC,
+0x938C, 0x565B, 0x9D28, 0x6822, 0x8305, 0x8431},
+{ /* category 20 */
+0x7CA5, 0x5208, 0x82C5, 0x74E6, 0x4E7E, 0x4F83, 0x51A0, 0x5BD2,
+0x520A, 0x52D8, 0x52E7, 0x5DFB, 0x559A, 0x582A, 0x59E6, 0x5B8C,
+0x5B98, 0x5BDB, 0x5E72, 0x5E79, 0x60A3, 0x611F, 0x6163, 0x61BE,
+0x63DB, 0x6562, 0x67D1, 0x6853, 0x68FA, 0x6B3E, 0x6B53, 0x6C57,
+0x6F22, 0x6F97, 0x6F45, 0x74B0, 0x7518, 0x76E3, 0x770B, 0x7AFF,
+0x7BA1, 0x7C21, 0x7DE9, 0x7F36, 0x7FF0, 0x809D, 0x8266, 0x839E,
+0x89B3, 0x8ACC, 0x8CAB, 0x9084, 0x9451, 0x9593, 0x9591, 0x95A2,
+0x9665, 0x97D3, 0x9928, 0x8218, 0x4E38, 0x542B, 0x5CB8, 0x5DCC,
+0x73A9, 0x764C, 0x773C, 0x5CA9, 0x7FEB, 0x8D0B, 0x96C1, 0x9811,
+0x9854, 0x9858, 0x4F01, 0x4F0E, 0x5371, 0x559C, 0x5668, 0x57FA,
+0x5947, 0x5B09, 0x5BC4, 0x5C90, 0x5E0C, 0x5E7E, 0x5FCC, 0x63EE,
+0x673A, 0x65D7, 0x65E2, 0x671F, 0x68CB, 0x68C4},
+{ /* category 21 */
+0x6A5F, 0x5E30, 0x6BC5, 0x6C17, 0x6C7D, 0x757F, 0x7948, 0x5B63,
+0x7A00, 0x7D00, 0x5FBD, 0x898F, 0x8A18, 0x8CB4, 0x8D77, 0x8ECC,
+0x8F1D, 0x98E2, 0x9A0E, 0x9B3C, 0x4E80, 0x507D, 0x5100, 0x5993,
+0x5B9C, 0x622F, 0x6280, 0x64EC, 0x6B3A, 0x72A0, 0x7591, 0x7947,
+0x7FA9, 0x87FB, 0x8ABC, 0x8B70, 0x63AC, 0x83CA, 0x97A0, 0x5409,
+0x5403, 0x55AB, 0x6854, 0x6A58, 0x8A70, 0x7827, 0x6775, 0x9ECD,
+0x5374, 0x5BA2, 0x811A, 0x8650, 0x9006, 0x4E18, 0x4E45, 0x4EC7,
+0x4F11, 0x53CA, 0x5438, 0x5BAE, 0x5F13, 0x6025, 0x6551, 0x673D,
+0x6C42, 0x6C72, 0x6CE3, 0x7078, 0x7403, 0x7A76, 0x7AAE, 0x7B08,
+0x7D1A, 0x7CFE, 0x7D66, 0x65E7, 0x725B, 0x53BB, 0x5C45, 0x5DE8,
+0x62D2, 0x62E0, 0x6319, 0x6E20, 0x865A, 0x8A31, 0x8DDD, 0x92F8,
+0x6F01, 0x79A6, 0x9B5A, 0x4EA8, 0x4EAB, 0x4EAC},
+{ /* category 22 */
+0x4F9B, 0x4FA0, 0x50D1, 0x5147, 0x7AF6, 0x5171, 0x51F6, 0x5354,
+0x5321, 0x537F, 0x53EB, 0x55AC, 0x5883, 0x5CE1, 0x5F37, 0x5F4A,
+0x602F, 0x6050, 0x606D, 0x631F, 0x6559, 0x6A4B, 0x6CC1, 0x72C2,
+0x72ED, 0x77EF, 0x80F8, 0x8105, 0x8208, 0x854E, 0x90F7, 0x93E1,
+0x97FF, 0x9957, 0x9A5A, 0x4EF0, 0x51DD, 0x5C2D, 0x6681, 0x696D,
+0x5C40, 0x66F2, 0x6975, 0x7389, 0x6850, 0x7C81, 0x50C5, 0x52E4,
+0x5747, 0x5DFE, 0x9326, 0x65A4, 0x6B23, 0x6B3D, 0x7434, 0x7981,
+0x79BD, 0x7B4B, 0x7DCA, 0x82B9, 0x83CC, 0x887F, 0x895F, 0x8B39,
+0x8FD1, 0x91D1, 0x541F, 0x9280, 0x4E5D, 0x5036, 0x53E5, 0x533A,
+0x72D7, 0x7396, 0x77E9, 0x82E6, 0x8EAF, 0x99C6, 0x99C8, 0x99D2,
+0x5177, 0x611A, 0x865E, 0x55B0, 0x7A7A, 0x5076, 0x5BD3, 0x9047,
+0x9685, 0x4E32, 0x6ADB, 0x91E7, 0x5C51, 0x5C48},
+{ /* category 23 */
+0x6398, 0x7A9F, 0x6C93, 0x9774, 0x8F61, 0x7AAA, 0x718A, 0x9688,
+0x7C82, 0x6817, 0x7E70, 0x6851, 0x936C, 0x52F2, 0x541B, 0x85AB,
+0x8A13, 0x7FA4, 0x8ECD, 0x90E1, 0x5366, 0x8888, 0x7941, 0x4FC2,
+0x50BE, 0x5211, 0x5144, 0x5553, 0x572D, 0x73EA, 0x578B, 0x5951,
+0x5F62, 0x5F84, 0x6075, 0x6176, 0x6167, 0x61A9, 0x63B2, 0x643A,
+0x656C, 0x666F, 0x6842, 0x6E13, 0x7566, 0x7A3D, 0x7CFB, 0x7D4C,
+0x7D99, 0x7E4B, 0x7F6B, 0x830E, 0x834A, 0x86CD, 0x8A08, 0x8A63,
+0x8B66, 0x8EFD, 0x981A, 0x9D8F, 0x82B8, 0x8FCE, 0x9BE8, 0x5287,
+0x621F, 0x6483, 0x6FC0, 0x9699, 0x6841, 0x5091, 0x6B20, 0x6C7A,
+0x6F54, 0x7A74, 0x7D50, 0x8840, 0x8A23, 0x6708, 0x4EF6, 0x5039,
+0x5026, 0x5065, 0x517C, 0x5238, 0x5263, 0x55A7, 0x570F, 0x5805,
+0x5ACC, 0x5EFA, 0x61B2, 0x61F8, 0x62F3, 0x6372},
+{ /* category 24 */
+0x691C, 0x6A29, 0x727D, 0x72AC, 0x732E, 0x7814, 0x786F, 0x7D79,
+0x770C, 0x80A9, 0x898B, 0x8B19, 0x8CE2, 0x8ED2, 0x9063, 0x9375,
+0x967A, 0x9855, 0x9A13, 0x9E78, 0x5143, 0x539F, 0x53B3, 0x5E7B,
+0x5F26, 0x6E1B, 0x6E90, 0x7384, 0x73FE, 0x7D43, 0x8237, 0x8A00,
+0x8AFA, 0x9650, 0x4E4E, 0x500B, 0x53E4, 0x547C, 0x56FA, 0x59D1,
+0x5B64, 0x5DF1, 0x5EAB, 0x5F27, 0x6238, 0x6545, 0x67AF, 0x6E56,
+0x72D0, 0x7CCA, 0x88B4, 0x80A1, 0x80E1, 0x83F0, 0x864E, 0x8A87,
+0x8DE8, 0x9237, 0x96C7, 0x9867, 0x9F13, 0x4E94, 0x4E92, 0x4F0D,
+0x5348, 0x5449, 0x543E, 0x5A2F, 0x5F8C, 0x5FA1, 0x609F, 0x68A7,
+0x6A8E, 0x745A, 0x7881, 0x8A9E, 0x8AA4, 0x8B77, 0x9190, 0x4E5E,
+0x9BC9, 0x4EA4, 0x4F7C, 0x4FAF, 0x5019, 0x5016, 0x5149, 0x516C,
+0x529F, 0x52B9, 0x52FE, 0x539A, 0x53E3, 0x5411},
+{ /* category 25 */
+0x540E, 0x5589, 0x5751, 0x57A2, 0x597D, 0x5B54, 0x5B5D, 0x5B8F,
+0x5DE5, 0x5DE7, 0x5DF7, 0x5E78, 0x5E83, 0x5E9A, 0x5EB7, 0x5F18,
+0x6052, 0x614C, 0x6297, 0x62D8, 0x63A7, 0x653B, 0x6602, 0x6643,
+0x66F4, 0x676D, 0x6821, 0x6897, 0x69CB, 0x6C5F, 0x6D2A, 0x6D69,
+0x6E2F, 0x6E9D, 0x7532, 0x7687, 0x786C, 0x7A3F, 0x7CE0, 0x7D05,
+0x7D18, 0x7D5E, 0x7DB1, 0x8015, 0x8003, 0x80AF, 0x80B1, 0x8154,
+0x818F, 0x822A, 0x8352, 0x884C, 0x8861, 0x8B1B, 0x8CA2, 0x8CFC,
+0x90CA, 0x9175, 0x9271, 0x783F, 0x92FC, 0x95A4, 0x964D, 0x9805,
+0x9999, 0x9AD8, 0x9D3B, 0x525B, 0x52AB, 0x53F7, 0x5408, 0x58D5,
+0x62F7, 0x6FE0, 0x8C6A, 0x8F5F, 0x9EB9, 0x514B, 0x523B, 0x544A,
+0x56FD, 0x7A40, 0x9177, 0x9D60, 0x9ED2, 0x7344, 0x6F09, 0x8170,
+0x7511, 0x5FFD, 0x60DA, 0x9AA8, 0x72DB, 0x8FBC},
+{ /* category 26 */
+0x6B64, 0x9803, 0x4ECA, 0x56F0, 0x5764, 0x58BE, 0x5A5A, 0x6068,
+0x61C7, 0x660F, 0x6606, 0x6839, 0x68B1, 0x6DF7, 0x75D5, 0x7D3A,
+0x826E, 0x9B42, 0x4E9B, 0x4F50, 0x53C9, 0x5506, 0x5D6F, 0x5DE6,
+0x5DEE, 0x67FB, 0x6C99, 0x7473, 0x7802, 0x8A50, 0x9396, 0x88DF,
+0x5750, 0x5EA7, 0x632B, 0x50B5, 0x50AC, 0x518D, 0x6700, 0x54C9,
+0x585E, 0x59BB, 0x5BB0, 0x5F69, 0x624D, 0x63A1, 0x683D, 0x6B73,
+0x6E08, 0x707D, 0x91C7, 0x7280, 0x7815, 0x7826, 0x796D, 0x658E,
+0x7D30, 0x83DC, 0x88C1, 0x8F09, 0x969B, 0x5264, 0x5728, 0x6750,
+0x7F6A, 0x8CA1, 0x51B4, 0x5742, 0x962A, 0x583A, 0x698A, 0x80B4,
+0x54B2, 0x5D0E, 0x57FC, 0x7895, 0x9DFA, 0x4F5C, 0x524A, 0x548B,
+0x643E, 0x6628, 0x6714, 0x67F5, 0x7A84, 0x7B56, 0x7D22, 0x932F,
+0x685C, 0x9BAD, 0x7B39, 0x5319, 0x518A, 0x5237},
+{ /* category 27 */
+0x5BDF, 0x62F6, 0x64AE, 0x64E6, 0x672D, 0x6BBA, 0x85A9, 0x96D1,
+0x7690, 0x9BD6, 0x634C, 0x9306, 0x9BAB, 0x76BF, 0x6652, 0x4E09,
+0x5098, 0x53C2, 0x5C71, 0x60E8, 0x6492, 0x6563, 0x685F, 0x71E6,
+0x73CA, 0x7523, 0x7B97, 0x7E82, 0x8695, 0x8B83, 0x8CDB, 0x9178,
+0x9910, 0x65AC, 0x66AB, 0x6B8B, 0x4ED5, 0x4ED4, 0x4F3A, 0x4F7F,
+0x523A, 0x53F8, 0x53F2, 0x55E3, 0x56DB, 0x58EB, 0x59CB, 0x59C9,
+0x59FF, 0x5B50, 0x5C4D, 0x5E02, 0x5E2B, 0x5FD7, 0x601D, 0x6307,
+0x652F, 0x5B5C, 0x65AF, 0x65BD, 0x65E8, 0x679D, 0x6B62, 0x6B7B,
+0x6C0F, 0x7345, 0x7949, 0x79C1, 0x7CF8, 0x7D19, 0x7D2B, 0x80A2,
+0x8102, 0x81F3, 0x8996, 0x8A5E, 0x8A69, 0x8A66, 0x8A8C, 0x8AEE,
+0x8CC7, 0x8CDC, 0x96CC, 0x98FC, 0x6B6F, 0x4E8B, 0x4F3C, 0x4F8D,
+0x5150, 0x5B57, 0x5BFA, 0x6148, 0x6301, 0x6642},
+{ /* category 28 */
+0x6B21, 0x6ECB, 0x6CBB, 0x723E, 0x74BD, 0x75D4, 0x78C1, 0x793A,
+0x800C, 0x8033, 0x81EA, 0x8494, 0x8F9E, 0x6C50, 0x9E7F, 0x5F0F,
+0x8B58, 0x9D2B, 0x7AFA, 0x8EF8, 0x5B8D, 0x96EB, 0x4E03, 0x53F1,
+0x57F7, 0x5931, 0x5AC9, 0x5BA4, 0x6089, 0x6E7F, 0x6F06, 0x75BE,
+0x8CEA, 0x5B9F, 0x8500, 0x7BE0, 0x5072, 0x67F4, 0x829D, 0x5C61,
+0x854A, 0x7E1E, 0x820E, 0x5199, 0x5C04, 0x6368, 0x8D66, 0x659C,
+0x716E, 0x793E, 0x7D17, 0x8005, 0x8B1D, 0x8ECA, 0x906E, 0x86C7,
+0x90AA, 0x501F, 0x52FA, 0x5C3A, 0x6753, 0x707C, 0x7235, 0x914C,
+0x91C8, 0x932B, 0x82E5, 0x5BC2, 0x5F31, 0x60F9, 0x4E3B, 0x53D6,
+0x5B88, 0x624B, 0x6731, 0x6B8A, 0x72E9, 0x73E0, 0x7A2E, 0x816B,
+0x8DA3, 0x9152, 0x9996, 0x5112, 0x53D7, 0x546A, 0x5BFF, 0x6388,
+0x6A39, 0x7DAC, 0x9700, 0x56DA, 0x53CE, 0x5468},
+{ /* category 29 */
+0x5B97, 0x5C31, 0x5DDE, 0x4FEE, 0x6101, 0x62FE, 0x6D32, 0x79C0,
+0x79CB, 0x7D42, 0x7E4D, 0x7FD2, 0x81ED, 0x821F, 0x8490, 0x8846,
+0x8972, 0x8B90, 0x8E74, 0x8F2F, 0x9031, 0x914B, 0x916C, 0x96C6,
+0x919C, 0x4EC0, 0x4F4F, 0x5145, 0x5341, 0x5F93, 0x620E, 0x67D4,
+0x6C41, 0x6E0B, 0x7363, 0x7E26, 0x91CD, 0x9283, 0x53D4, 0x5919,
+0x5BBF, 0x6DD1, 0x795D, 0x7E2E, 0x7C9B, 0x587E, 0x719F, 0x51FA,
+0x8853, 0x8FF0, 0x4FCA, 0x5CFB, 0x6625, 0x77AC, 0x7AE3, 0x821C,
+0x99FF, 0x51C6, 0x5FAA, 0x65EC, 0x696F, 0x6B89, 0x6DF3, 0x6E96,
+0x6F64, 0x76FE, 0x7D14, 0x5DE1, 0x9075, 0x9187, 0x9806, 0x51E6,
+0x521D, 0x6240, 0x6691, 0x66D9, 0x6E1A, 0x5EB6, 0x7DD2, 0x7F72,
+0x66F8, 0x85AF, 0x85F7, 0x8AF8, 0x52A9, 0x53D9, 0x5973, 0x5E8F,
+0x5F90, 0x6055, 0x92E4, 0x9664, 0x50B7, 0x511F},
+{ /* category 30 */
+0x52DD, 0x5320, 0x5347, 0x53EC, 0x54E8, 0x5546, 0x5531, 0x5617,
+0x5968, 0x59BE, 0x5A3C, 0x5BB5, 0x5C06, 0x5C0F, 0x5C11, 0x5C1A,
+0x5E84, 0x5E8A, 0x5EE0, 0x5F70, 0x627F, 0x6284, 0x62DB, 0x638C,
+0x6377, 0x6607, 0x660C, 0x662D, 0x6676, 0x677E, 0x68A2, 0x6A1F,
+0x6A35, 0x6CBC, 0x6D88, 0x6E09, 0x6E58, 0x713C, 0x7126, 0x7167,
+0x75C7, 0x7701, 0x785D, 0x7901, 0x7965, 0x79F0, 0x7AE0, 0x7B11,
+0x7CA7, 0x7D39, 0x8096, 0x83D6, 0x848B, 0x8549, 0x885D, 0x88F3,
+0x8A1F, 0x8A3C, 0x8A54, 0x8A73, 0x8C61, 0x8CDE, 0x91A4, 0x9266,
+0x937E, 0x9418, 0x969C, 0x9798, 0x4E0A, 0x4E08, 0x4E1E, 0x4E57,
+0x5197, 0x5270, 0x57CE, 0x5834, 0x58CC, 0x5B22, 0x5E38, 0x60C5,
+0x64FE, 0x6761, 0x6756, 0x6D44, 0x72B6, 0x7573, 0x7A63, 0x84B8,
+0x8B72, 0x91B8, 0x9320, 0x5631, 0x57F4, 0x98FE},
+{ /* category 31 */
+0x62ED, 0x690D, 0x6B96, 0x71ED, 0x7E54, 0x8077, 0x8272, 0x89E6,
+0x98DF, 0x8755, 0x8FB1, 0x5C3B, 0x4F38, 0x4FE1, 0x4FB5, 0x5507,
+0x5A20, 0x5BDD, 0x5BE9, 0x5FC3, 0x614E, 0x632F, 0x65B0, 0x664B,
+0x68EE, 0x699B, 0x6D78, 0x6DF1, 0x7533, 0x75B9, 0x771F, 0x795E,
+0x79E6, 0x7D33, 0x81E3, 0x82AF, 0x85AA, 0x89AA, 0x8A3A, 0x8EAB,
+0x8F9B, 0x9032, 0x91DD, 0x9707, 0x4EBA, 0x4EC1, 0x5203, 0x5875,
+0x58EC, 0x5C0B, 0x751A, 0x5C3D, 0x814E, 0x8A0A, 0x8FC5, 0x9663,
+0x976D, 0x7B25, 0x8ACF, 0x9808, 0x9162, 0x56F3, 0x53A8, 0x9017,
+0x5439, 0x5782, 0x5E25, 0x63A8, 0x6C34, 0x708A, 0x7761, 0x7C8B,
+0x7FE0, 0x8870, 0x9042, 0x9154, 0x9310, 0x9318, 0x968F, 0x745E,
+0x9AC4, 0x5D07, 0x5D69, 0x6570, 0x67A2, 0x8DA8, 0x96DB, 0x636E,
+0x6749, 0x6919, 0x83C5, 0x9817, 0x96C0, 0x88FE},
+{ /* category 32 */
+0x6F84, 0x647A, 0x5BF8, 0x4E16, 0x702C, 0x755D, 0x662F, 0x51C4,
+0x5236, 0x52E2, 0x59D3, 0x5F81, 0x6027, 0x6210, 0x653F, 0x6574,
+0x661F, 0x6674, 0x68F2, 0x6816, 0x6B63, 0x6E05, 0x7272, 0x751F,
+0x76DB, 0x7CBE, 0x8056, 0x58F0, 0x88FD, 0x897F, 0x8AA0, 0x8A93,
+0x8ACB, 0x901D, 0x9192, 0x9752, 0x9759, 0x6589, 0x7A0E, 0x8106,
+0x96BB, 0x5E2D, 0x60DC, 0x621A, 0x65A5, 0x6614, 0x6790, 0x77F3,
+0x7A4D, 0x7C4D, 0x7E3E, 0x810A, 0x8CAC, 0x8D64, 0x8DE1, 0x8E5F,
+0x78A9, 0x5207, 0x62D9, 0x63A5, 0x6442, 0x6298, 0x8A2D, 0x7A83,
+0x7BC0, 0x8AAC, 0x96EA, 0x7D76, 0x820C, 0x8749, 0x4ED9, 0x5148,
+0x5343, 0x5360, 0x5BA3, 0x5C02, 0x5C16, 0x5DDD, 0x6226, 0x6247,
+0x64B0, 0x6813, 0x6834, 0x6CC9, 0x6D45, 0x6D17, 0x67D3, 0x6F5C,
+0x714E, 0x717D, 0x65CB, 0x7A7F, 0x7BAD, 0x7DDA},
+{ /* category 33 */
+0x7E4A, 0x7FA8, 0x817A, 0x821B, 0x8239, 0x85A6, 0x8A6E, 0x8CCE,
+0x8DF5, 0x9078, 0x9077, 0x92AD, 0x9291, 0x9583, 0x9BAE, 0x524D,
+0x5584, 0x6F38, 0x7136, 0x5168, 0x7985, 0x7E55, 0x81B3, 0x7CCE,
+0x564C, 0x5851, 0x5CA8, 0x63AA, 0x66FE, 0x66FD, 0x695A, 0x72D9,
+0x758F, 0x758E, 0x790E, 0x7956, 0x79DF, 0x7C97, 0x7D20, 0x7D44,
+0x8607, 0x8A34, 0x963B, 0x9061, 0x9F20, 0x50E7, 0x5275, 0x53CC,
+0x53E2, 0x5009, 0x55AA, 0x58EE, 0x594F, 0x723D, 0x5B8B, 0x5C64,
+0x531D, 0x60E3, 0x60F3, 0x635C, 0x6383, 0x633F, 0x63BB, 0x64CD,
+0x65E9, 0x66F9, 0x5DE3, 0x69CD, 0x69FD, 0x6F15, 0x71E5, 0x4E89,
+0x75E9, 0x76F8, 0x7A93, 0x7CDF, 0x7DCF, 0x7D9C, 0x8061, 0x8349,
+0x8358, 0x846C, 0x84BC, 0x85FB, 0x88C5, 0x8D70, 0x9001, 0x906D,
+0x9397, 0x971C, 0x9A12, 0x50CF, 0x5897, 0x618E},
+{ /* category 34 */
+0x81D3, 0x8535, 0x8D08, 0x9020, 0x4FC3, 0x5074, 0x5247, 0x5373,
+0x606F, 0x6349, 0x675F, 0x6E2C, 0x8DB3, 0x901F, 0x4FD7, 0x5C5E,
+0x8CCA, 0x65CF, 0x7D9A, 0x5352, 0x8896, 0x5176, 0x63C3, 0x5B58,
+0x5B6B, 0x5C0A, 0x640D, 0x6751, 0x905C, 0x4ED6, 0x591A, 0x592A,
+0x6C70, 0x8A51, 0x553E, 0x5815, 0x59A5, 0x60F0, 0x6253, 0x67C1,
+0x8235, 0x6955, 0x9640, 0x99C4, 0x9A28, 0x4F53, 0x5806, 0x5BFE,
+0x8010, 0x5CB1, 0x5E2F, 0x5F85, 0x6020, 0x614B, 0x6234, 0x66FF,
+0x6CF0, 0x6EDE, 0x80CE, 0x817F, 0x82D4, 0x888B, 0x8CB8, 0x9000,
+0x902E, 0x968A, 0x9EDB, 0x9BDB, 0x4EE3, 0x53F0, 0x5927, 0x7B2C,
+0x918D, 0x984C, 0x9DF9, 0x6EDD, 0x7027, 0x5353, 0x5544, 0x5B85,
+0x6258, 0x629E, 0x62D3, 0x6CA2, 0x6FEF, 0x7422, 0x8A17, 0x9438,
+0x6FC1, 0x8AFE, 0x8338, 0x51E7, 0x86F8, 0x53EA},
+{ /* category 35 */
+0x53E9, 0x4F46, 0x9054, 0x8FB0, 0x596A, 0x8131, 0x5DFD, 0x7AEA,
+0x8FBF, 0x68DA, 0x8C37, 0x72F8, 0x9C48, 0x6A3D, 0x8AB0, 0x4E39,
+0x5358, 0x5606, 0x5766, 0x62C5, 0x63A2, 0x65E6, 0x6B4E, 0x6DE1,
+0x6E5B, 0x70AD, 0x77ED, 0x7AEF, 0x7BAA, 0x7DBB, 0x803D, 0x80C6,
+0x86CB, 0x8A95, 0x935B, 0x56E3, 0x58C7, 0x5F3E, 0x65AD, 0x6696,
+0x6A80, 0x6BB5, 0x7537, 0x8AC7, 0x5024, 0x77E5, 0x5730, 0x5F1B,
+0x6065, 0x667A, 0x6C60, 0x75F4, 0x7A1A, 0x7F6E, 0x81F4, 0x8718,
+0x9045, 0x99B3, 0x7BC9, 0x755C, 0x7AF9, 0x7B51, 0x84C4, 0x9010,
+0x79E9, 0x7A92, 0x8336, 0x5AE1, 0x7740, 0x4E2D, 0x4EF2, 0x5B99,
+0x5FE0, 0x62BD, 0x663C, 0x67F1, 0x6CE8, 0x866B, 0x8877, 0x8A3B,
+0x914E, 0x92F3, 0x99D0, 0x6A17, 0x7026, 0x732A, 0x82E7, 0x8457,
+0x8CAF, 0x4E01, 0x5146, 0x51CB, 0x558B, 0x5BF5},
+{ /* category 36 */
+0x5E16, 0x5E33, 0x5E81, 0x5F14, 0x5F35, 0x5F6B, 0x5FB4, 0x61F2,
+0x6311, 0x66A2, 0x671D, 0x6F6E, 0x7252, 0x753A, 0x773A, 0x8074,
+0x8139, 0x8178, 0x8776, 0x8ABF, 0x8ADC, 0x8D85, 0x8DF3, 0x929A,
+0x9577, 0x9802, 0x9CE5, 0x52C5, 0x6357, 0x76F4, 0x6715, 0x6C88,
+0x73CD, 0x8CC3, 0x93AE, 0x9673, 0x6D25, 0x589C, 0x690E, 0x69CC,
+0x8FFD, 0x939A, 0x75DB, 0x901A, 0x585A, 0x6802, 0x63B4, 0x69FB,
+0x4F43, 0x6F2C, 0x67D8, 0x8FBB, 0x8526, 0x7DB4, 0x9354, 0x693F,
+0x6F70, 0x576A, 0x58F7, 0x5B2C, 0x7D2C, 0x722A, 0x540A, 0x91E3,
+0x9DB4, 0x4EAD, 0x4F4E, 0x505C, 0x5075, 0x5243, 0x8C9E, 0x5448,
+0x5824, 0x5B9A, 0x5E1D, 0x5E95, 0x5EAD, 0x5EF7, 0x5F1F, 0x608C,
+0x62B5, 0x633A, 0x63D0, 0x68AF, 0x6C40, 0x7887, 0x798E, 0x7A0B,
+0x7DE0, 0x8247, 0x8A02, 0x8AE6, 0x8E44, 0x9013},
+{ /* category 37 */
+0x90B8, 0x912D, 0x91D8, 0x9F0E, 0x6CE5, 0x6458, 0x64E2, 0x6575,
+0x6EF4, 0x7684, 0x7B1B, 0x9069, 0x93D1, 0x6EBA, 0x54F2, 0x5FB9,
+0x64A4, 0x8F4D, 0x8FED, 0x9244, 0x5178, 0x586B, 0x5929, 0x5C55,
+0x5E97, 0x6DFB, 0x7E8F, 0x751C, 0x8CBC, 0x8EE2, 0x985B, 0x70B9,
+0x4F1D, 0x6BBF, 0x6FB1, 0x7530, 0x96FB, 0x514E, 0x5410, 0x5835,
+0x5857, 0x59AC, 0x5C60, 0x5F92, 0x6597, 0x675C, 0x6E21, 0x767B,
+0x83DF, 0x8CED, 0x9014, 0x90FD, 0x934D, 0x7825, 0x783A, 0x52AA,
+0x5EA6, 0x571F, 0x5974, 0x6012, 0x5012, 0x515A, 0x51AC, 0x51CD,
+0x5200, 0x5510, 0x5854, 0x5858, 0x5957, 0x5B95, 0x5CF6, 0x5D8B,
+0x60BC, 0x6295, 0x642D, 0x6771, 0x6843, 0x68BC, 0x68DF, 0x76D7,
+0x6DD8, 0x6E6F, 0x6D9B, 0x706F, 0x71C8, 0x5F53, 0x75D8, 0x7977,
+0x7B49, 0x7B54, 0x7B52, 0x7CD6, 0x7D71, 0x5230},
+{ /* category 38 */
+0x8463, 0x8569, 0x85E4, 0x8A0E, 0x8B04, 0x8C46, 0x8E0F, 0x9003,
+0x900F, 0x9419, 0x9676, 0x982D, 0x9A30, 0x95D8, 0x50CD, 0x52D5,
+0x540C, 0x5802, 0x5C0E, 0x61A7, 0x649E, 0x6D1E, 0x77B3, 0x7AE5,
+0x80F4, 0x8404, 0x9053, 0x9285, 0x5CE0, 0x9D07, 0x533F, 0x5F97,
+0x5FB3, 0x6D9C, 0x7279, 0x7763, 0x79BF, 0x7BE4, 0x6BD2, 0x72EC,
+0x8AAD, 0x6803, 0x6A61, 0x51F8, 0x7A81, 0x6934, 0x5C4A, 0x9CF6,
+0x82EB, 0x5BC5, 0x9149, 0x701E, 0x5678, 0x5C6F, 0x60C7, 0x6566,
+0x6C8C, 0x8C5A, 0x9041, 0x9813, 0x5451, 0x66C7, 0x920D, 0x5948,
+0x90A3, 0x5185, 0x4E4D, 0x51EA, 0x8599, 0x8B0E, 0x7058, 0x637A,
+0x934B, 0x6962, 0x99B4, 0x7E04, 0x7577, 0x5357, 0x6960, 0x8EDF,
+0x96E3, 0x6C5D, 0x4E8C, 0x5C3C, 0x5F10, 0x8FE9, 0x5302, 0x8CD1,
+0x8089, 0x8679, 0x5EFF, 0x65E5, 0x4E73, 0x5165},
+{ /* category 39 */
+0x5982, 0x5C3F, 0x97EE, 0x4EFB, 0x598A, 0x5FCD, 0x8A8D, 0x6FE1,
+0x79B0, 0x7962, 0x5BE7, 0x8471, 0x732B, 0x71B1, 0x5E74, 0x5FF5,
+0x637B, 0x649A, 0x71C3, 0x7C98, 0x4E43, 0x5EFC, 0x4E4B, 0x57DC,
+0x56A2, 0x60A9, 0x6FC3, 0x7D0D, 0x80FD, 0x8133, 0x81BF, 0x8FB2,
+0x8997, 0x86A4, 0x5DF4, 0x628A, 0x64AD, 0x8987, 0x6777, 0x6CE2,
+0x6D3E, 0x7436, 0x7834, 0x5A46, 0x7F75, 0x82AD, 0x99AC, 0x4FF3,
+0x5EC3, 0x62DD, 0x6392, 0x6557, 0x676F, 0x76C3, 0x724C, 0x80CC,
+0x80BA, 0x8F29, 0x914D, 0x500D, 0x57F9, 0x5A92, 0x6885, 0x6973,
+0x7164, 0x72FD, 0x8CB7, 0x58F2, 0x8CE0, 0x966A, 0x9019, 0x877F,
+0x79E4, 0x77E7, 0x8429, 0x4F2F, 0x5265, 0x535A, 0x62CD, 0x67CF,
+0x6CCA, 0x767D, 0x7B94, 0x7C95, 0x8236, 0x8584, 0x8FEB, 0x66DD,
+0x6F20, 0x7206, 0x7E1B, 0x83AB, 0x99C1, 0x9EA6},
+{ /* category 40 */
+0x51FD, 0x7BB1, 0x7872, 0x7BB8, 0x8087, 0x7B48, 0x6AE8, 0x5E61,
+0x808C, 0x7551, 0x7560, 0x516B, 0x9262, 0x6E8C, 0x767A, 0x9197,
+0x9AEA, 0x4F10, 0x7F70, 0x629C, 0x7B4F, 0x95A5, 0x9CE9, 0x567A,
+0x5859, 0x86E4, 0x96BC, 0x4F34, 0x5224, 0x534A, 0x53CD, 0x53DB,
+0x5E06, 0x642C, 0x6591, 0x677F, 0x6C3E, 0x6C4E, 0x7248, 0x72AF,
+0x73ED, 0x7554, 0x7E41, 0x822C, 0x85E9, 0x8CA9, 0x7BC4, 0x91C6,
+0x7169, 0x9812, 0x98EF, 0x633D, 0x6669, 0x756A, 0x76E4, 0x78D0,
+0x8543, 0x86EE, 0x532A, 0x5351, 0x5426, 0x5983, 0x5E87, 0x5F7C,
+0x60B2, 0x6249, 0x6279, 0x62AB, 0x6590, 0x6BD4, 0x6CCC, 0x75B2,
+0x76AE, 0x7891, 0x79D8, 0x7DCB, 0x7F77, 0x80A5, 0x88AB, 0x8AB9,
+0x8CBB, 0x907F, 0x975E, 0x98DB, 0x6A0B, 0x7C38, 0x5099, 0x5C3E,
+0x5FAE, 0x6787, 0x6BD8, 0x7435, 0x7709, 0x7F8E},
+{ /* category 41 */
+0x9F3B, 0x67CA, 0x7A17, 0x5339, 0x758B, 0x9AED, 0x5F66, 0x819D,
+0x83F1, 0x8098, 0x5F3C, 0x5FC5, 0x7562, 0x7B46, 0x903C, 0x6867,
+0x59EB, 0x5A9B, 0x7D10, 0x767E, 0x8B2C, 0x4FF5, 0x5F6A, 0x6A19,
+0x6C37, 0x6F02, 0x74E2, 0x7968, 0x8868, 0x8A55, 0x8C79, 0x5EDF,
+0x63CF, 0x75C5, 0x79D2, 0x82D7, 0x9328, 0x92F2, 0x849C, 0x86ED,
+0x9C2D, 0x54C1, 0x5F6C, 0x658C, 0x6D5C, 0x7015, 0x8CA7, 0x8CD3,
+0x983B, 0x654F, 0x74F6, 0x4E0D, 0x4ED8, 0x57E0, 0x592B, 0x5A66,
+0x5BCC, 0x51A8, 0x5E03, 0x5E9C, 0x6016, 0x6276, 0x6577, 0x65A7,
+0x666E, 0x6D6E, 0x7236, 0x7B26, 0x8150, 0x819A, 0x8299, 0x8B5C,
+0x8CA0, 0x8CE6, 0x8D74, 0x961C, 0x9644, 0x4FAE, 0x64AB, 0x6B66,
+0x821E, 0x8461, 0x856A, 0x90E8, 0x5C01, 0x6953, 0x98A8, 0x847A,
+0x8557, 0x4F0F, 0x526F, 0x5FA9, 0x5E45, 0x670D},
+{ /* category 42 */
+0x798F, 0x8179, 0x8907, 0x8986, 0x6DF5, 0x5F17, 0x6255, 0x6CB8,
+0x4ECF, 0x7269, 0x9B92, 0x5206, 0x543B, 0x5674, 0x58B3, 0x61A4,
+0x626E, 0x711A, 0x596E, 0x7C89, 0x7CDE, 0x7D1B, 0x96F0, 0x6587,
+0x805E, 0x4E19, 0x4F75, 0x5175, 0x5840, 0x5E63, 0x5E73, 0x5F0A,
+0x67C4, 0x4E26, 0x853D, 0x9589, 0x965B, 0x7C73, 0x9801, 0x50FB,
+0x58C1, 0x7656, 0x78A7, 0x5225, 0x77A5, 0x8511, 0x7B86, 0x504F,
+0x5909, 0x7247, 0x7BC7, 0x7DE8, 0x8FBA, 0x8FD4, 0x904D, 0x4FBF,
+0x52C9, 0x5A29, 0x5F01, 0x97AD, 0x4FDD, 0x8217, 0x92EA, 0x5703,
+0x6355, 0x6B69, 0x752B, 0x88DC, 0x8F14, 0x7A42, 0x52DF, 0x5893,
+0x6155, 0x620A, 0x66AE, 0x6BCD, 0x7C3F, 0x83E9, 0x5023, 0x4FF8,
+0x5305, 0x5446, 0x5831, 0x5949, 0x5B9D, 0x5CF0, 0x5CEF, 0x5D29,
+0x5E96, 0x62B1, 0x6367, 0x653E, 0x65B9, 0x670B},
+{ /* category 43 */
+0x6CD5, 0x6CE1, 0x70F9, 0x7832, 0x7E2B, 0x80DE, 0x82B3, 0x840C,
+0x84EC, 0x8702, 0x8912, 0x8A2A, 0x8C4A, 0x90A6, 0x92D2, 0x98FD,
+0x9CF3, 0x9D6C, 0x4E4F, 0x4EA1, 0x508D, 0x5256, 0x574A, 0x59A8,
+0x5E3D, 0x5FD8, 0x5FD9, 0x623F, 0x66B4, 0x671B, 0x67D0, 0x68D2,
+0x5192, 0x7D21, 0x80AA, 0x81A8, 0x8B00, 0x8C8C, 0x8CBF, 0x927E,
+0x9632, 0x5420, 0x982C, 0x5317, 0x50D5, 0x535C, 0x58A8, 0x64B2,
+0x6734, 0x7267, 0x7766, 0x7A46, 0x91E6, 0x52C3, 0x6CA1, 0x6B86,
+0x5800, 0x5E4C, 0x5954, 0x672C, 0x7FFB, 0x51E1, 0x76C6, 0x6469,
+0x78E8, 0x9B54, 0x9EBB, 0x57CB, 0x59B9, 0x6627, 0x679A, 0x6BCE,
+0x54E9, 0x69D9, 0x5E55, 0x819C, 0x6795, 0x9BAA, 0x67FE, 0x9C52,
+0x685D, 0x4EA6, 0x4FE3, 0x53C8, 0x62B9, 0x672B, 0x6CAB, 0x8FC4,
+0x4FAD, 0x7E6D, 0x9EBF, 0x4E07, 0x6162, 0x6E80},
+{ /* category 44 */
+0x6F2B, 0x8513, 0x5473, 0x672A, 0x9B45, 0x5DF3, 0x7B95, 0x5CAC,
+0x5BC6, 0x871C, 0x6E4A, 0x84D1, 0x7A14, 0x8108, 0x5999, 0x7C8D,
+0x6C11, 0x7720, 0x52D9, 0x5922, 0x7121, 0x725F, 0x77DB, 0x9727,
+0x9D61, 0x690B, 0x5A7F, 0x5A18, 0x51A5, 0x540D, 0x547D, 0x660E,
+0x76DF, 0x8FF7, 0x9298, 0x9CF4, 0x59EA, 0x725D, 0x6EC5, 0x514D,
+0x68C9, 0x7DBF, 0x7DEC, 0x9762, 0x9EBA, 0x6478, 0x6A21, 0x8302,
+0x5984, 0x5B5F, 0x6BDB, 0x731B, 0x76F2, 0x7DB2, 0x8017, 0x8499,
+0x5132, 0x6728, 0x9ED9, 0x76EE, 0x6762, 0x52FF, 0x9905, 0x5C24,
+0x623B, 0x7C7E, 0x8CB0, 0x554F, 0x60B6, 0x7D0B, 0x9580, 0x5301,
+0x4E5F, 0x51B6, 0x591C, 0x723A, 0x8036, 0x91CE, 0x5F25, 0x77E2,
+0x5384, 0x5F79, 0x7D04, 0x85AC, 0x8A33, 0x8E8D, 0x9756, 0x67F3,
+0x85AE, 0x9453, 0x6109, 0x6108, 0x6CB9, 0x7652},
+{ /* category 45 */
+0x8AED, 0x8F38, 0x552F, 0x4F51, 0x512A, 0x52C7, 0x53CB, 0x5BA5,
+0x5E7D, 0x60A0, 0x6182, 0x63D6, 0x6709, 0x67DA, 0x6E67, 0x6D8C,
+0x7336, 0x7337, 0x7531, 0x7950, 0x88D5, 0x8A98, 0x904A, 0x9091,
+0x90F5, 0x96C4, 0x878D, 0x5915, 0x4E88, 0x4F59, 0x4E0E, 0x8A89,
+0x8F3F, 0x9810, 0x50AD, 0x5E7C, 0x5996, 0x5BB9, 0x5EB8, 0x63DA,
+0x63FA, 0x64C1, 0x66DC, 0x694A, 0x69D8, 0x6D0B, 0x6EB6, 0x7194,
+0x7528, 0x7AAF, 0x7F8A, 0x8000, 0x8449, 0x84C9, 0x8981, 0x8B21,
+0x8E0A, 0x9065, 0x967D, 0x990A, 0x617E, 0x6291, 0x6B32, 0x6C83,
+0x6D74, 0x7FCC, 0x7FFC, 0x6DC0, 0x7F85, 0x87BA, 0x88F8, 0x6765,
+0x83B1, 0x983C, 0x96F7, 0x6D1B, 0x7D61, 0x843D, 0x916A, 0x4E71,
+0x5375, 0x5D50, 0x6B04, 0x6FEB, 0x85CD, 0x862D, 0x89A7, 0x5229,
+0x540F, 0x5C65, 0x674E, 0x68A8, 0x7406, 0x7483},
+{ /* category 46 */
+0x75E2, 0x88CF, 0x88E1, 0x91CC, 0x96E2, 0x9678, 0x5F8B, 0x7387,
+0x7ACB, 0x844E, 0x63A0, 0x7565, 0x5289, 0x6D41, 0x6E9C, 0x7409,
+0x7559, 0x786B, 0x7C92, 0x9686, 0x7ADC, 0x9F8D, 0x4FB6, 0x616E,
+0x65C5, 0x865C, 0x4E86, 0x4EAE, 0x50DA, 0x4E21, 0x51CC, 0x5BEE,
+0x6599, 0x6881, 0x6DBC, 0x731F, 0x7642, 0x77AD, 0x7A1C, 0x7CE7,
+0x826F, 0x8AD2, 0x907C, 0x91CF, 0x9675, 0x9818, 0x529B, 0x7DD1,
+0x502B, 0x5398, 0x6797, 0x6DCB, 0x71D0, 0x7433, 0x81E8, 0x8F2A,
+0x96A3, 0x9C57, 0x9E9F, 0x7460, 0x5841, 0x6D99, 0x7D2F, 0x985E,
+0x4EE4, 0x4F36, 0x4F8B, 0x51B7, 0x52B1, 0x5DBA, 0x601C, 0x73B2,
+0x793C, 0x82D3, 0x9234, 0x96B7, 0x96F6, 0x970A, 0x9E97, 0x9F62,
+0x66A6, 0x6B74, 0x5217, 0x52A3, 0x70C8, 0x88C2, 0x5EC9, 0x604B,
+0x6190, 0x6F23, 0x7149, 0x7C3E, 0x7DF4, 0x806F},
+{ /* category 47 */
+0x84EE, 0x9023, 0x932C, 0x5442, 0x9B6F, 0x6AD3, 0x7089, 0x8CC2,
+0x8DEF, 0x9732, 0x52B4, 0x5A41, 0x5ECA, 0x5F04, 0x6717, 0x697C,
+0x6994, 0x6D6A, 0x6F0F, 0x7262, 0x72FC, 0x7BED, 0x8001, 0x807E,
+0x874B, 0x90CE, 0x516D, 0x9E93, 0x7984, 0x808B, 0x9332, 0x8AD6,
+0x502D, 0x548C, 0x8A71, 0x6B6A, 0x8CC4, 0x8107, 0x60D1, 0x67A0,
+0x9DF2, 0x4E99, 0x4E98, 0x9C10, 0x8A6B, 0x85C1, 0x8568, 0x6900,
+0x6E7E, 0x7897, 0x8155, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 48 */
+0x5F0C, 0x4E10, 0x4E15, 0x4E2A, 0x4E31, 0x4E36, 0x4E3C, 0x4E3F,
+0x4E42, 0x4E56, 0x4E58, 0x4E82, 0x4E85, 0x8C6B, 0x4E8A, 0x8212,
+0x5F0D, 0x4E8E, 0x4E9E, 0x4E9F, 0x4EA0, 0x4EA2, 0x4EB0, 0x4EB3,
+0x4EB6, 0x4ECE, 0x4ECD, 0x4EC4, 0x4EC6, 0x4EC2, 0x4ED7, 0x4EDE,
+0x4EED, 0x4EDF, 0x4EF7, 0x4F09, 0x4F5A, 0x4F30, 0x4F5B, 0x4F5D,
+0x4F57, 0x4F47, 0x4F76, 0x4F88, 0x4F8F, 0x4F98, 0x4F7B, 0x4F69,
+0x4F70, 0x4F91, 0x4F6F, 0x4F86, 0x4F96, 0x5118, 0x4FD4, 0x4FDF,
+0x4FCE, 0x4FD8, 0x4FDB, 0x4FD1, 0x4FDA, 0x4FD0, 0x4FE4, 0x4FE5,
+0x501A, 0x5028, 0x5014, 0x502A, 0x5025, 0x5005, 0x4F1C, 0x4FF6,
+0x5021, 0x5029, 0x502C, 0x4FFE, 0x4FEF, 0x5011, 0x5006, 0x5043,
+0x5047, 0x6703, 0x5055, 0x5050, 0x5048, 0x505A, 0x5056, 0x506C,
+0x5078, 0x5080, 0x509A, 0x5085, 0x50B4, 0x50B2},
+{ /* category 49 */
+0x50C9, 0x50CA, 0x50B3, 0x50C2, 0x50D6, 0x50DE, 0x50E5, 0x50ED,
+0x50E3, 0x50EE, 0x50F9, 0x50F5, 0x5109, 0x5101, 0x5102, 0x5116,
+0x5115, 0x5114, 0x511A, 0x5121, 0x513A, 0x5137, 0x513C, 0x513B,
+0x513F, 0x5140, 0x5152, 0x514C, 0x5154, 0x5162, 0x7AF8, 0x5169,
+0x516A, 0x516E, 0x5180, 0x5182, 0x56D8, 0x518C, 0x5189, 0x518F,
+0x5191, 0x5193, 0x5195, 0x5196, 0x51A4, 0x51A6, 0x51A2, 0x51A9,
+0x51AA, 0x51AB, 0x51B3, 0x51B1, 0x51B2, 0x51B0, 0x51B5, 0x51BD,
+0x51C5, 0x51C9, 0x51DB, 0x51E0, 0x8655, 0x51E9, 0x51ED, 0x51F0,
+0x51F5, 0x51FE, 0x5204, 0x520B, 0x5214, 0x520E, 0x5227, 0x522A,
+0x522E, 0x5233, 0x5239, 0x524F, 0x5244, 0x524B, 0x524C, 0x525E,
+0x5254, 0x526A, 0x5274, 0x5269, 0x5273, 0x527F, 0x527D, 0x528D,
+0x5294, 0x5292, 0x5271, 0x5288, 0x5291, 0x8FA8},
+{ /* category 50 */
+0x8FA7, 0x52AC, 0x52AD, 0x52BC, 0x52B5, 0x52C1, 0x52CD, 0x52D7,
+0x52DE, 0x52E3, 0x52E6, 0x98ED, 0x52E0, 0x52F3, 0x52F5, 0x52F8,
+0x52F9, 0x5306, 0x5308, 0x7538, 0x530D, 0x5310, 0x530F, 0x5315,
+0x531A, 0x5323, 0x532F, 0x5331, 0x5333, 0x5338, 0x5340, 0x5346,
+0x5345, 0x4E17, 0x5349, 0x534D, 0x51D6, 0x535E, 0x5369, 0x536E,
+0x5918, 0x537B, 0x5377, 0x5382, 0x5396, 0x53A0, 0x53A6, 0x53A5,
+0x53AE, 0x53B0, 0x53B6, 0x53C3, 0x7C12, 0x96D9, 0x53DF, 0x66FC,
+0x71EE, 0x53EE, 0x53E8, 0x53ED, 0x53FA, 0x5401, 0x543D, 0x5440,
+0x542C, 0x542D, 0x543C, 0x542E, 0x5436, 0x5429, 0x541D, 0x544E,
+0x548F, 0x5475, 0x548E, 0x545F, 0x5471, 0x5477, 0x5470, 0x5492,
+0x547B, 0x5480, 0x5476, 0x5484, 0x5490, 0x5486, 0x54C7, 0x54A2,
+0x54B8, 0x54A5, 0x54AC, 0x54C4, 0x54C8, 0x54A8},
+{ /* category 51 */
+0x54AB, 0x54C2, 0x54A4, 0x54BE, 0x54BC, 0x54D8, 0x54E5, 0x54E6,
+0x550F, 0x5514, 0x54FD, 0x54EE, 0x54ED, 0x54FA, 0x54E2, 0x5539,
+0x5540, 0x5563, 0x554C, 0x552E, 0x555C, 0x5545, 0x5556, 0x5557,
+0x5538, 0x5533, 0x555D, 0x5599, 0x5580, 0x54AF, 0x558A, 0x559F,
+0x557B, 0x557E, 0x5598, 0x559E, 0x55AE, 0x557C, 0x5583, 0x55A9,
+0x5587, 0x55A8, 0x55DA, 0x55C5, 0x55DF, 0x55C4, 0x55DC, 0x55E4,
+0x55D4, 0x5614, 0x55F7, 0x5616, 0x55FE, 0x55FD, 0x561B, 0x55F9,
+0x564E, 0x5650, 0x71DF, 0x5634, 0x5636, 0x5632, 0x5638, 0x566B,
+0x5664, 0x562F, 0x566C, 0x566A, 0x5686, 0x5680, 0x568A, 0x56A0,
+0x5694, 0x568F, 0x56A5, 0x56AE, 0x56B6, 0x56B4, 0x56C2, 0x56BC,
+0x56C1, 0x56C3, 0x56C0, 0x56C8, 0x56CE, 0x56D1, 0x56D3, 0x56D7,
+0x56EE, 0x56F9, 0x5700, 0x56FF, 0x5704, 0x5709},
+{ /* category 52 */
+0x5708, 0x570B, 0x570D, 0x5713, 0x5718, 0x5716, 0x55C7, 0x571C,
+0x5726, 0x5737, 0x5738, 0x574E, 0x573B, 0x5740, 0x574F, 0x5769,
+0x57C0, 0x5788, 0x5761, 0x577F, 0x5789, 0x5793, 0x57A0, 0x57B3,
+0x57A4, 0x57AA, 0x57B0, 0x57C3, 0x57C6, 0x57D4, 0x57D2, 0x57D3,
+0x580A, 0x57D6, 0x57E3, 0x580B, 0x5819, 0x581D, 0x5872, 0x5821,
+0x5862, 0x584B, 0x5870, 0x6BC0, 0x5852, 0x583D, 0x5879, 0x5885,
+0x58B9, 0x589F, 0x58AB, 0x58BA, 0x58DE, 0x58BB, 0x58B8, 0x58AE,
+0x58C5, 0x58D3, 0x58D1, 0x58D7, 0x58D9, 0x58D8, 0x58E5, 0x58DC,
+0x58E4, 0x58DF, 0x58EF, 0x58FA, 0x58F9, 0x58FB, 0x58FC, 0x58FD,
+0x5902, 0x590A, 0x5910, 0x591B, 0x68A6, 0x5925, 0x592C, 0x592D,
+0x5932, 0x5938, 0x593E, 0x7AD2, 0x5955, 0x5950, 0x594E, 0x595A,
+0x5958, 0x5962, 0x5960, 0x5967, 0x596C, 0x5969},
+{ /* category 53 */
+0x5978, 0x5981, 0x599D, 0x4F5E, 0x4FAB, 0x59A3, 0x59B2, 0x59C6,
+0x59E8, 0x59DC, 0x598D, 0x59D9, 0x59DA, 0x5A25, 0x5A1F, 0x5A11,
+0x5A1C, 0x5A09, 0x5A1A, 0x5A40, 0x5A6C, 0x5A49, 0x5A35, 0x5A36,
+0x5A62, 0x5A6A, 0x5A9A, 0x5ABC, 0x5ABE, 0x5ACB, 0x5AC2, 0x5ABD,
+0x5AE3, 0x5AD7, 0x5AE6, 0x5AE9, 0x5AD6, 0x5AFA, 0x5AFB, 0x5B0C,
+0x5B0B, 0x5B16, 0x5B32, 0x5AD0, 0x5B2A, 0x5B36, 0x5B3E, 0x5B43,
+0x5B45, 0x5B40, 0x5B51, 0x5B55, 0x5B5A, 0x5B5B, 0x5B65, 0x5B69,
+0x5B70, 0x5B73, 0x5B75, 0x5B78, 0x6588, 0x5B7A, 0x5B80, 0x5B83,
+0x5BA6, 0x5BB8, 0x5BC3, 0x5BC7, 0x5BC9, 0x5BD4, 0x5BD0, 0x5BE4,
+0x5BE6, 0x5BE2, 0x5BDE, 0x5BE5, 0x5BEB, 0x5BF0, 0x5BF6, 0x5BF3,
+0x5C05, 0x5C07, 0x5C08, 0x5C0D, 0x5C13, 0x5C20, 0x5C22, 0x5C28,
+0x5C38, 0x5C39, 0x5C41, 0x5C46, 0x5C4E, 0x5C53},
+{ /* category 54 */
+0x5C50, 0x5C4F, 0x5B71, 0x5C6C, 0x5C6E, 0x4E62, 0x5C76, 0x5C79,
+0x5C8C, 0x5C91, 0x5C94, 0x599B, 0x5CAB, 0x5CBB, 0x5CB6, 0x5CBC,
+0x5CB7, 0x5CC5, 0x5CBE, 0x5CC7, 0x5CD9, 0x5CE9, 0x5CFD, 0x5CFA,
+0x5CED, 0x5D8C, 0x5CEA, 0x5D0B, 0x5D15, 0x5D17, 0x5D5C, 0x5D1F,
+0x5D1B, 0x5D11, 0x5D14, 0x5D22, 0x5D1A, 0x5D19, 0x5D18, 0x5D4C,
+0x5D52, 0x5D4E, 0x5D4B, 0x5D6C, 0x5D73, 0x5D76, 0x5D87, 0x5D84,
+0x5D82, 0x5DA2, 0x5D9D, 0x5DAC, 0x5DAE, 0x5DBD, 0x5D90, 0x5DB7,
+0x5DBC, 0x5DC9, 0x5DCD, 0x5DD3, 0x5DD2, 0x5DD6, 0x5DDB, 0x5DEB,
+0x5DF2, 0x5DF5, 0x5E0B, 0x5E1A, 0x5E19, 0x5E11, 0x5E1B, 0x5E36,
+0x5E37, 0x5E44, 0x5E43, 0x5E40, 0x5E4E, 0x5E57, 0x5E54, 0x5E5F,
+0x5E62, 0x5E64, 0x5E47, 0x5E75, 0x5E76, 0x5E7A, 0x9EBC, 0x5E7F,
+0x5EA0, 0x5EC1, 0x5EC2, 0x5EC8, 0x5ED0, 0x5ECF},
+{ /* category 55 */
+0x5ED6, 0x5EE3, 0x5EDD, 0x5EDA, 0x5EDB, 0x5EE2, 0x5EE1, 0x5EE8,
+0x5EE9, 0x5EEC, 0x5EF1, 0x5EF3, 0x5EF0, 0x5EF4, 0x5EF8, 0x5EFE,
+0x5F03, 0x5F09, 0x5F5D, 0x5F5C, 0x5F0B, 0x5F11, 0x5F16, 0x5F29,
+0x5F2D, 0x5F38, 0x5F41, 0x5F48, 0x5F4C, 0x5F4E, 0x5F2F, 0x5F51,
+0x5F56, 0x5F57, 0x5F59, 0x5F61, 0x5F6D, 0x5F73, 0x5F77, 0x5F83,
+0x5F82, 0x5F7F, 0x5F8A, 0x5F88, 0x5F91, 0x5F87, 0x5F9E, 0x5F99,
+0x5F98, 0x5FA0, 0x5FA8, 0x5FAD, 0x5FBC, 0x5FD6, 0x5FFB, 0x5FE4,
+0x5FF8, 0x5FF1, 0x5FDD, 0x60B3, 0x5FFF, 0x6021, 0x6060, 0x6019,
+0x6010, 0x6029, 0x600E, 0x6031, 0x601B, 0x6015, 0x602B, 0x6026,
+0x600F, 0x603A, 0x605A, 0x6041, 0x606A, 0x6077, 0x605F, 0x604A,
+0x6046, 0x604D, 0x6063, 0x6043, 0x6064, 0x6042, 0x606C, 0x606B,
+0x6059, 0x6081, 0x608D, 0x60E7, 0x6083, 0x609A},
+{ /* category 56 */
+0x6084, 0x609B, 0x6096, 0x6097, 0x6092, 0x60A7, 0x608B, 0x60E1,
+0x60B8, 0x60E0, 0x60D3, 0x60B4, 0x5FF0, 0x60BD, 0x60C6, 0x60B5,
+0x60D8, 0x614D, 0x6115, 0x6106, 0x60F6, 0x60F7, 0x6100, 0x60F4,
+0x60FA, 0x6103, 0x6121, 0x60FB, 0x60F1, 0x610D, 0x610E, 0x6147,
+0x613E, 0x6128, 0x6127, 0x614A, 0x613F, 0x613C, 0x612C, 0x6134,
+0x613D, 0x6142, 0x6144, 0x6173, 0x6177, 0x6158, 0x6159, 0x615A,
+0x616B, 0x6174, 0x616F, 0x6165, 0x6171, 0x615F, 0x615D, 0x6153,
+0x6175, 0x6199, 0x6196, 0x6187, 0x61AC, 0x6194, 0x619A, 0x618A,
+0x6191, 0x61AB, 0x61AE, 0x61CC, 0x61CA, 0x61C9, 0x61F7, 0x61C8,
+0x61C3, 0x61C6, 0x61BA, 0x61CB, 0x7F79, 0x61CD, 0x61E6, 0x61E3,
+0x61F6, 0x61FA, 0x61F4, 0x61FF, 0x61FD, 0x61FC, 0x61FE, 0x6200,
+0x6208, 0x6209, 0x620D, 0x620C, 0x6214, 0x621B},
+{ /* category 57 */
+0x621E, 0x6221, 0x622A, 0x622E, 0x6230, 0x6232, 0x6233, 0x6241,
+0x624E, 0x625E, 0x6263, 0x625B, 0x6260, 0x6268, 0x627C, 0x6282,
+0x6289, 0x627E, 0x6292, 0x6293, 0x6296, 0x62D4, 0x6283, 0x6294,
+0x62D7, 0x62D1, 0x62BB, 0x62CF, 0x62FF, 0x62C6, 0x64D4, 0x62C8,
+0x62DC, 0x62CC, 0x62CA, 0x62C2, 0x62C7, 0x629B, 0x62C9, 0x630C,
+0x62EE, 0x62F1, 0x6327, 0x6302, 0x6308, 0x62EF, 0x62F5, 0x6350,
+0x633E, 0x634D, 0x641C, 0x634F, 0x6396, 0x638E, 0x6380, 0x63AB,
+0x6376, 0x63A3, 0x638F, 0x6389, 0x639F, 0x63B5, 0x636B, 0x6369,
+0x63BE, 0x63E9, 0x63C0, 0x63C6, 0x63E3, 0x63C9, 0x63D2, 0x63F6,
+0x63C4, 0x6416, 0x6434, 0x6406, 0x6413, 0x6426, 0x6436, 0x651D,
+0x6417, 0x6428, 0x640F, 0x6467, 0x646F, 0x6476, 0x644E, 0x652A,
+0x6495, 0x6493, 0x64A5, 0x64A9, 0x6488, 0x64BC},
+{ /* category 58 */
+0x64DA, 0x64D2, 0x64C5, 0x64C7, 0x64BB, 0x64D8, 0x64C2, 0x64F1,
+0x64E7, 0x8209, 0x64E0, 0x64E1, 0x62AC, 0x64E3, 0x64EF, 0x652C,
+0x64F6, 0x64F4, 0x64F2, 0x64FA, 0x6500, 0x64FD, 0x6518, 0x651C,
+0x6505, 0x6524, 0x6523, 0x652B, 0x6534, 0x6535, 0x6537, 0x6536,
+0x6538, 0x754B, 0x6548, 0x6556, 0x6555, 0x654D, 0x6558, 0x655E,
+0x655D, 0x6572, 0x6578, 0x6582, 0x6583, 0x8B8A, 0x659B, 0x659F,
+0x65AB, 0x65B7, 0x65C3, 0x65C6, 0x65C1, 0x65C4, 0x65CC, 0x65D2,
+0x65DB, 0x65D9, 0x65E0, 0x65E1, 0x65F1, 0x6772, 0x660A, 0x6603,
+0x65FB, 0x6773, 0x6635, 0x6636, 0x6634, 0x661C, 0x664F, 0x6644,
+0x6649, 0x6641, 0x665E, 0x665D, 0x6664, 0x6667, 0x6668, 0x665F,
+0x6662, 0x6670, 0x6683, 0x6688, 0x668E, 0x6689, 0x6684, 0x6698,
+0x669D, 0x66C1, 0x66B9, 0x66C9, 0x66BE, 0x66BC},
+{ /* category 59 */
+0x66C4, 0x66B8, 0x66D6, 0x66DA, 0x66E0, 0x663F, 0x66E6, 0x66E9,
+0x66F0, 0x66F5, 0x66F7, 0x670F, 0x6716, 0x671E, 0x6726, 0x6727,
+0x9738, 0x672E, 0x673F, 0x6736, 0x6741, 0x6738, 0x6737, 0x6746,
+0x675E, 0x6760, 0x6759, 0x6763, 0x6764, 0x6789, 0x6770, 0x67A9,
+0x677C, 0x676A, 0x678C, 0x678B, 0x67A6, 0x67A1, 0x6785, 0x67B7,
+0x67EF, 0x67B4, 0x67EC, 0x67B3, 0x67E9, 0x67B8, 0x67E4, 0x67DE,
+0x67DD, 0x67E2, 0x67EE, 0x67B9, 0x67CE, 0x67C6, 0x67E7, 0x6A9C,
+0x681E, 0x6846, 0x6829, 0x6840, 0x684D, 0x6832, 0x684E, 0x68B3,
+0x682B, 0x6859, 0x6863, 0x6877, 0x687F, 0x689F, 0x688F, 0x68AD,
+0x6894, 0x689D, 0x689B, 0x6883, 0x6AAE, 0x68B9, 0x6874, 0x68B5,
+0x68A0, 0x68BA, 0x690F, 0x688D, 0x687E, 0x6901, 0x68CA, 0x6908,
+0x68D8, 0x6922, 0x6926, 0x68E1, 0x690C, 0x68CD},
+{ /* category 60 */
+0x68D4, 0x68E7, 0x68D5, 0x6936, 0x6912, 0x6904, 0x68D7, 0x68E3,
+0x6925, 0x68F9, 0x68E0, 0x68EF, 0x6928, 0x692A, 0x691A, 0x6923,
+0x6921, 0x68C6, 0x6979, 0x6977, 0x695C, 0x6978, 0x696B, 0x6954,
+0x697E, 0x696E, 0x6939, 0x6974, 0x693D, 0x6959, 0x6930, 0x6961,
+0x695E, 0x695D, 0x6981, 0x696A, 0x69B2, 0x69AE, 0x69D0, 0x69BF,
+0x69C1, 0x69D3, 0x69BE, 0x69CE, 0x5BE8, 0x69CA, 0x69DD, 0x69BB,
+0x69C3, 0x69A7, 0x6A2E, 0x6991, 0x69A0, 0x699C, 0x6995, 0x69B4,
+0x69DE, 0x69E8, 0x6A02, 0x6A1B, 0x69FF, 0x6B0A, 0x69F9, 0x69F2,
+0x69E7, 0x6A05, 0x69B1, 0x6A1E, 0x69ED, 0x6A14, 0x69EB, 0x6A0A,
+0x6A12, 0x6AC1, 0x6A23, 0x6A13, 0x6A44, 0x6A0C, 0x6A72, 0x6A36,
+0x6A78, 0x6A47, 0x6A62, 0x6A59, 0x6A66, 0x6A48, 0x6A38, 0x6A22,
+0x6A90, 0x6A8D, 0x6AA0, 0x6A84, 0x6AA2, 0x6AA3},
+{ /* category 61 */
+0x6A97, 0x8617, 0x6ABB, 0x6AC3, 0x6AC2, 0x6AB8, 0x6AB3, 0x6AAC,
+0x6ADE, 0x6AD1, 0x6ADF, 0x6AAA, 0x6ADA, 0x6AEA, 0x6AFB, 0x6B05,
+0x8616, 0x6AFA, 0x6B12, 0x6B16, 0x9B31, 0x6B1F, 0x6B38, 0x6B37,
+0x76DC, 0x6B39, 0x98EE, 0x6B47, 0x6B43, 0x6B49, 0x6B50, 0x6B59,
+0x6B54, 0x6B5B, 0x6B5F, 0x6B61, 0x6B78, 0x6B79, 0x6B7F, 0x6B80,
+0x6B84, 0x6B83, 0x6B8D, 0x6B98, 0x6B95, 0x6B9E, 0x6BA4, 0x6BAA,
+0x6BAB, 0x6BAF, 0x6BB2, 0x6BB1, 0x6BB3, 0x6BB7, 0x6BBC, 0x6BC6,
+0x6BCB, 0x6BD3, 0x6BDF, 0x6BEC, 0x6BEB, 0x6BF3, 0x6BEF, 0x9EBE,
+0x6C08, 0x6C13, 0x6C14, 0x6C1B, 0x6C24, 0x6C23, 0x6C5E, 0x6C55,
+0x6C62, 0x6C6A, 0x6C82, 0x6C8D, 0x6C9A, 0x6C81, 0x6C9B, 0x6C7E,
+0x6C68, 0x6C73, 0x6C92, 0x6C90, 0x6CC4, 0x6CF1, 0x6CD3, 0x6CBD,
+0x6CD7, 0x6CC5, 0x6CDD, 0x6CAE, 0x6CB1, 0x6CBE},
+{ /* category 62 */
+0x6CBA, 0x6CDB, 0x6CEF, 0x6CD9, 0x6CEA, 0x6D1F, 0x884D, 0x6D36,
+0x6D2B, 0x6D3D, 0x6D38, 0x6D19, 0x6D35, 0x6D33, 0x6D12, 0x6D0C,
+0x6D63, 0x6D93, 0x6D64, 0x6D5A, 0x6D79, 0x6D59, 0x6D8E, 0x6D95,
+0x6FE4, 0x6D85, 0x6DF9, 0x6E15, 0x6E0A, 0x6DB5, 0x6DC7, 0x6DE6,
+0x6DB8, 0x6DC6, 0x6DEC, 0x6DDE, 0x6DCC, 0x6DE8, 0x6DD2, 0x6DC5,
+0x6DFA, 0x6DD9, 0x6DE4, 0x6DD5, 0x6DEA, 0x6DEE, 0x6E2D, 0x6E6E,
+0x6E2E, 0x6E19, 0x6E72, 0x6E5F, 0x6E3E, 0x6E23, 0x6E6B, 0x6E2B,
+0x6E76, 0x6E4D, 0x6E1F, 0x6E43, 0x6E3A, 0x6E4E, 0x6E24, 0x6EFF,
+0x6E1D, 0x6E38, 0x6E82, 0x6EAA, 0x6E98, 0x6EC9, 0x6EB7, 0x6ED3,
+0x6EBD, 0x6EAF, 0x6EC4, 0x6EB2, 0x6ED4, 0x6ED5, 0x6E8F, 0x6EA5,
+0x6EC2, 0x6E9F, 0x6F41, 0x6F11, 0x704C, 0x6EEC, 0x6EF8, 0x6EFE,
+0x6F3F, 0x6EF2, 0x6F31, 0x6EEF, 0x6F32, 0x6ECC},
+{ /* category 63 */
+0x6F3E, 0x6F13, 0x6EF7, 0x6F86, 0x6F7A, 0x6F78, 0x6F81, 0x6F80,
+0x6F6F, 0x6F5B, 0x6FF3, 0x6F6D, 0x6F82, 0x6F7C, 0x6F58, 0x6F8E,
+0x6F91, 0x6FC2, 0x6F66, 0x6FB3, 0x6FA3, 0x6FA1, 0x6FA4, 0x6FB9,
+0x6FC6, 0x6FAA, 0x6FDF, 0x6FD5, 0x6FEC, 0x6FD4, 0x6FD8, 0x6FF1,
+0x6FEE, 0x6FDB, 0x7009, 0x700B, 0x6FFA, 0x7011, 0x7001, 0x700F,
+0x6FFE, 0x701B, 0x701A, 0x6F74, 0x701D, 0x7018, 0x701F, 0x7030,
+0x703E, 0x7032, 0x7051, 0x7063, 0x7099, 0x7092, 0x70AF, 0x70F1,
+0x70AC, 0x70B8, 0x70B3, 0x70AE, 0x70DF, 0x70CB, 0x70DD, 0x70D9,
+0x7109, 0x70FD, 0x711C, 0x7119, 0x7165, 0x7155, 0x7188, 0x7166,
+0x7162, 0x714C, 0x7156, 0x716C, 0x718F, 0x71FB, 0x7184, 0x7195,
+0x71A8, 0x71AC, 0x71D7, 0x71B9, 0x71BE, 0x71D2, 0x71C9, 0x71D4,
+0x71CE, 0x71E0, 0x71EC, 0x71E7, 0x71F5, 0x71FC},
+{ /* category 64 */
+0x71F9, 0x71FF, 0x720D, 0x7210, 0x721B, 0x7228, 0x722D, 0x722C,
+0x7230, 0x7232, 0x723B, 0x723C, 0x723F, 0x7240, 0x7246, 0x724B,
+0x7258, 0x7274, 0x727E, 0x7282, 0x7281, 0x7287, 0x7292, 0x7296,
+0x72A2, 0x72A7, 0x72B9, 0x72B2, 0x72C3, 0x72C6, 0x72C4, 0x72CE,
+0x72D2, 0x72E2, 0x72E0, 0x72E1, 0x72F9, 0x72F7, 0x500F, 0x7317,
+0x730A, 0x731C, 0x7316, 0x731D, 0x7334, 0x732F, 0x7329, 0x7325,
+0x733E, 0x734E, 0x734F, 0x9ED8, 0x7357, 0x736A, 0x7368, 0x7370,
+0x7378, 0x7375, 0x737B, 0x737A, 0x73C8, 0x73B3, 0x73CE, 0x73BB,
+0x73C0, 0x73E5, 0x73EE, 0x73DE, 0x74A2, 0x7405, 0x746F, 0x7425,
+0x73F8, 0x7432, 0x743A, 0x7455, 0x743F, 0x745F, 0x7459, 0x7441,
+0x745C, 0x7469, 0x7470, 0x7463, 0x746A, 0x7476, 0x747E, 0x748B,
+0x749E, 0x74A7, 0x74CA, 0x74CF, 0x74D4, 0x73F1},
+{ /* category 65 */
+0x74E0, 0x74E3, 0x74E7, 0x74E9, 0x74EE, 0x74F2, 0x74F0, 0x74F1,
+0x74F8, 0x74F7, 0x7504, 0x7503, 0x7505, 0x750C, 0x750E, 0x750D,
+0x7515, 0x7513, 0x751E, 0x7526, 0x752C, 0x753C, 0x7544, 0x754D,
+0x754A, 0x7549, 0x755B, 0x7546, 0x755A, 0x7569, 0x7564, 0x7567,
+0x756B, 0x756D, 0x7578, 0x7576, 0x7586, 0x7587, 0x7574, 0x758A,
+0x7589, 0x7582, 0x7594, 0x759A, 0x759D, 0x75A5, 0x75A3, 0x75C2,
+0x75B3, 0x75C3, 0x75B5, 0x75BD, 0x75B8, 0x75BC, 0x75B1, 0x75CD,
+0x75CA, 0x75D2, 0x75D9, 0x75E3, 0x75DE, 0x75FE, 0x75FF, 0x75FC,
+0x7601, 0x75F0, 0x75FA, 0x75F2, 0x75F3, 0x760B, 0x760D, 0x7609,
+0x761F, 0x7627, 0x7620, 0x7621, 0x7622, 0x7624, 0x7634, 0x7630,
+0x763B, 0x7647, 0x7648, 0x7646, 0x765C, 0x7658, 0x7661, 0x7662,
+0x7668, 0x7669, 0x766A, 0x7667, 0x766C, 0x7670},
+{ /* category 66 */
+0x7672, 0x7676, 0x7678, 0x767C, 0x7680, 0x7683, 0x7688, 0x768B,
+0x768E, 0x7696, 0x7693, 0x7699, 0x769A, 0x76B0, 0x76B4, 0x76B8,
+0x76B9, 0x76BA, 0x76C2, 0x76CD, 0x76D6, 0x76D2, 0x76DE, 0x76E1,
+0x76E5, 0x76E7, 0x76EA, 0x862F, 0x76FB, 0x7708, 0x7707, 0x7704,
+0x7729, 0x7724, 0x771E, 0x7725, 0x7726, 0x771B, 0x7737, 0x7738,
+0x7747, 0x775A, 0x7768, 0x776B, 0x775B, 0x7765, 0x777F, 0x777E,
+0x7779, 0x778E, 0x778B, 0x7791, 0x77A0, 0x779E, 0x77B0, 0x77B6,
+0x77B9, 0x77BF, 0x77BC, 0x77BD, 0x77BB, 0x77C7, 0x77CD, 0x77D7,
+0x77DA, 0x77DC, 0x77E3, 0x77EE, 0x77FC, 0x780C, 0x7812, 0x7926,
+0x7820, 0x792A, 0x7845, 0x788E, 0x7874, 0x7886, 0x787C, 0x789A,
+0x788C, 0x78A3, 0x78B5, 0x78AA, 0x78AF, 0x78D1, 0x78C6, 0x78CB,
+0x78D4, 0x78BE, 0x78BC, 0x78C5, 0x78CA, 0x78EC},
+{ /* category 67 */
+0x78E7, 0x78DA, 0x78FD, 0x78F4, 0x7907, 0x7912, 0x7911, 0x7919,
+0x792C, 0x792B, 0x7940, 0x7960, 0x7957, 0x795F, 0x795A, 0x7955,
+0x7953, 0x797A, 0x797F, 0x798A, 0x799D, 0x79A7, 0x9F4B, 0x79AA,
+0x79AE, 0x79B3, 0x79B9, 0x79BA, 0x79C9, 0x79D5, 0x79E7, 0x79EC,
+0x79E1, 0x79E3, 0x7A08, 0x7A0D, 0x7A18, 0x7A19, 0x7A20, 0x7A1F,
+0x7980, 0x7A31, 0x7A3B, 0x7A3E, 0x7A37, 0x7A43, 0x7A57, 0x7A49,
+0x7A61, 0x7A62, 0x7A69, 0x9F9D, 0x7A70, 0x7A79, 0x7A7D, 0x7A88,
+0x7A97, 0x7A95, 0x7A98, 0x7A96, 0x7AA9, 0x7AC8, 0x7AB0, 0x7AB6,
+0x7AC5, 0x7AC4, 0x7ABF, 0x9083, 0x7AC7, 0x7ACA, 0x7ACD, 0x7ACF,
+0x7AD5, 0x7AD3, 0x7AD9, 0x7ADA, 0x7ADD, 0x7AE1, 0x7AE2, 0x7AE6,
+0x7AED, 0x7AF0, 0x7B02, 0x7B0F, 0x7B0A, 0x7B06, 0x7B33, 0x7B18,
+0x7B19, 0x7B1E, 0x7B35, 0x7B28, 0x7B36, 0x7B50},
+{ /* category 68 */
+0x7B7A, 0x7B04, 0x7B4D, 0x7B0B, 0x7B4C, 0x7B45, 0x7B75, 0x7B65,
+0x7B74, 0x7B67, 0x7B70, 0x7B71, 0x7B6C, 0x7B6E, 0x7B9D, 0x7B98,
+0x7B9F, 0x7B8D, 0x7B9C, 0x7B9A, 0x7B8B, 0x7B92, 0x7B8F, 0x7B5D,
+0x7B99, 0x7BCB, 0x7BC1, 0x7BCC, 0x7BCF, 0x7BB4, 0x7BC6, 0x7BDD,
+0x7BE9, 0x7C11, 0x7C14, 0x7BE6, 0x7BE5, 0x7C60, 0x7C00, 0x7C07,
+0x7C13, 0x7BF3, 0x7BF7, 0x7C17, 0x7C0D, 0x7BF6, 0x7C23, 0x7C27,
+0x7C2A, 0x7C1F, 0x7C37, 0x7C2B, 0x7C3D, 0x7C4C, 0x7C43, 0x7C54,
+0x7C4F, 0x7C40, 0x7C50, 0x7C58, 0x7C5F, 0x7C64, 0x7C56, 0x7C65,
+0x7C6C, 0x7C75, 0x7C83, 0x7C90, 0x7CA4, 0x7CAD, 0x7CA2, 0x7CAB,
+0x7CA1, 0x7CA8, 0x7CB3, 0x7CB2, 0x7CB1, 0x7CAE, 0x7CB9, 0x7CBD,
+0x7CC0, 0x7CC5, 0x7CC2, 0x7CD8, 0x7CD2, 0x7CDC, 0x7CE2, 0x9B3B,
+0x7CEF, 0x7CF2, 0x7CF4, 0x7CF6, 0x7CFA, 0x7D06},
+{ /* category 69 */
+0x7D02, 0x7D1C, 0x7D15, 0x7D0A, 0x7D45, 0x7D4B, 0x7D2E, 0x7D32,
+0x7D3F, 0x7D35, 0x7D46, 0x7D73, 0x7D56, 0x7D4E, 0x7D72, 0x7D68,
+0x7D6E, 0x7D4F, 0x7D63, 0x7D93, 0x7D89, 0x7D5B, 0x7D8F, 0x7D7D,
+0x7D9B, 0x7DBA, 0x7DAE, 0x7DA3, 0x7DB5, 0x7DC7, 0x7DBD, 0x7DAB,
+0x7E3D, 0x7DA2, 0x7DAF, 0x7DDC, 0x7DB8, 0x7D9F, 0x7DB0, 0x7DD8,
+0x7DDD, 0x7DE4, 0x7DDE, 0x7DFB, 0x7DF2, 0x7DE1, 0x7E05, 0x7E0A,
+0x7E23, 0x7E21, 0x7E12, 0x7E31, 0x7E1F, 0x7E09, 0x7E0B, 0x7E22,
+0x7E46, 0x7E66, 0x7E3B, 0x7E35, 0x7E39, 0x7E43, 0x7E37, 0x7E32,
+0x7E3A, 0x7E67, 0x7E5D, 0x7E56, 0x7E5E, 0x7E59, 0x7E5A, 0x7E79,
+0x7E6A, 0x7E69, 0x7E7C, 0x7E7B, 0x7E83, 0x7DD5, 0x7E7D, 0x8FAE,
+0x7E7F, 0x7E88, 0x7E89, 0x7E8C, 0x7E92, 0x7E90, 0x7E93, 0x7E94,
+0x7E96, 0x7E8E, 0x7E9B, 0x7E9C, 0x7F38, 0x7F3A},
+{ /* category 70 */
+0x7F45, 0x7F4C, 0x7F4D, 0x7F4E, 0x7F50, 0x7F51, 0x7F55, 0x7F54,
+0x7F58, 0x7F5F, 0x7F60, 0x7F68, 0x7F69, 0x7F67, 0x7F78, 0x7F82,
+0x7F86, 0x7F83, 0x7F88, 0x7F87, 0x7F8C, 0x7F94, 0x7F9E, 0x7F9D,
+0x7F9A, 0x7FA3, 0x7FAF, 0x7FB2, 0x7FB9, 0x7FAE, 0x7FB6, 0x7FB8,
+0x8B71, 0x7FC5, 0x7FC6, 0x7FCA, 0x7FD5, 0x7FD4, 0x7FE1, 0x7FE6,
+0x7FE9, 0x7FF3, 0x7FF9, 0x98DC, 0x8006, 0x8004, 0x800B, 0x8012,
+0x8018, 0x8019, 0x801C, 0x8021, 0x8028, 0x803F, 0x803B, 0x804A,
+0x8046, 0x8052, 0x8058, 0x805A, 0x805F, 0x8062, 0x8068, 0x8073,
+0x8072, 0x8070, 0x8076, 0x8079, 0x807D, 0x807F, 0x8084, 0x8086,
+0x8085, 0x809B, 0x8093, 0x809A, 0x80AD, 0x5190, 0x80AC, 0x80DB,
+0x80E5, 0x80D9, 0x80DD, 0x80C4, 0x80DA, 0x80D6, 0x8109, 0x80EF,
+0x80F1, 0x811B, 0x8129, 0x8123, 0x812F, 0x814B},
+{ /* category 71 */
+0x968B, 0x8146, 0x813E, 0x8153, 0x8151, 0x80FC, 0x8171, 0x816E,
+0x8165, 0x8166, 0x8174, 0x8183, 0x8188, 0x818A, 0x8180, 0x8182,
+0x81A0, 0x8195, 0x81A4, 0x81A3, 0x815F, 0x8193, 0x81A9, 0x81B0,
+0x81B5, 0x81BE, 0x81B8, 0x81BD, 0x81C0, 0x81C2, 0x81BA, 0x81C9,
+0x81CD, 0x81D1, 0x81D9, 0x81D8, 0x81C8, 0x81DA, 0x81DF, 0x81E0,
+0x81E7, 0x81FA, 0x81FB, 0x81FE, 0x8201, 0x8202, 0x8205, 0x8207,
+0x820A, 0x820D, 0x8210, 0x8216, 0x8229, 0x822B, 0x8238, 0x8233,
+0x8240, 0x8259, 0x8258, 0x825D, 0x825A, 0x825F, 0x8264, 0x8262,
+0x8268, 0x826A, 0x826B, 0x822E, 0x8271, 0x8277, 0x8278, 0x827E,
+0x828D, 0x8292, 0x82AB, 0x829F, 0x82BB, 0x82AC, 0x82E1, 0x82E3,
+0x82DF, 0x82D2, 0x82F4, 0x82F3, 0x82FA, 0x8393, 0x8303, 0x82FB,
+0x82F9, 0x82DE, 0x8306, 0x82DC, 0x8309, 0x82D9},
+{ /* category 72 */
+0x8335, 0x8334, 0x8316, 0x8332, 0x8331, 0x8340, 0x8339, 0x8350,
+0x8345, 0x832F, 0x832B, 0x8317, 0x8318, 0x8385, 0x839A, 0x83AA,
+0x839F, 0x83A2, 0x8396, 0x8323, 0x838E, 0x8387, 0x838A, 0x837C,
+0x83B5, 0x8373, 0x8375, 0x83A0, 0x8389, 0x83A8, 0x83F4, 0x8413,
+0x83EB, 0x83CE, 0x83FD, 0x8403, 0x83D8, 0x840B, 0x83C1, 0x83F7,
+0x8407, 0x83E0, 0x83F2, 0x840D, 0x8422, 0x8420, 0x83BD, 0x8438,
+0x8506, 0x83FB, 0x846D, 0x842A, 0x843C, 0x855A, 0x8484, 0x8477,
+0x846B, 0x84AD, 0x846E, 0x8482, 0x8469, 0x8446, 0x842C, 0x846F,
+0x8479, 0x8435, 0x84CA, 0x8462, 0x84B9, 0x84BF, 0x849F, 0x84D9,
+0x84CD, 0x84BB, 0x84DA, 0x84D0, 0x84C1, 0x84C6, 0x84D6, 0x84A1,
+0x8521, 0x84FF, 0x84F4, 0x8517, 0x8518, 0x852C, 0x851F, 0x8515,
+0x8514, 0x84FC, 0x8540, 0x8563, 0x8558, 0x8548},
+{ /* category 73 */
+0x8541, 0x8602, 0x854B, 0x8555, 0x8580, 0x85A4, 0x8588, 0x8591,
+0x858A, 0x85A8, 0x856D, 0x8594, 0x859B, 0x85EA, 0x8587, 0x859C,
+0x8577, 0x857E, 0x8590, 0x85C9, 0x85BA, 0x85CF, 0x85B9, 0x85D0,
+0x85D5, 0x85DD, 0x85E5, 0x85DC, 0x85F9, 0x860A, 0x8613, 0x860B,
+0x85FE, 0x85FA, 0x8606, 0x8622, 0x861A, 0x8630, 0x863F, 0x864D,
+0x4E55, 0x8654, 0x865F, 0x8667, 0x8671, 0x8693, 0x86A3, 0x86A9,
+0x86AA, 0x868B, 0x868C, 0x86B6, 0x86AF, 0x86C4, 0x86C6, 0x86B0,
+0x86C9, 0x8823, 0x86AB, 0x86D4, 0x86DE, 0x86E9, 0x86EC, 0x86DF,
+0x86DB, 0x86EF, 0x8712, 0x8706, 0x8708, 0x8700, 0x8703, 0x86FB,
+0x8711, 0x8709, 0x870D, 0x86F9, 0x870A, 0x8734, 0x873F, 0x8737,
+0x873B, 0x8725, 0x8729, 0x871A, 0x8760, 0x875F, 0x8778, 0x874C,
+0x874E, 0x8774, 0x8757, 0x8768, 0x876E, 0x8759},
+{ /* category 74 */
+0x8753, 0x8763, 0x876A, 0x8805, 0x87A2, 0x879F, 0x8782, 0x87AF,
+0x87CB, 0x87BD, 0x87C0, 0x87D0, 0x96D6, 0x87AB, 0x87C4, 0x87B3,
+0x87C7, 0x87C6, 0x87BB, 0x87EF, 0x87F2, 0x87E0, 0x880F, 0x880D,
+0x87FE, 0x87F6, 0x87F7, 0x880E, 0x87D2, 0x8811, 0x8816, 0x8815,
+0x8822, 0x8821, 0x8831, 0x8836, 0x8839, 0x8827, 0x883B, 0x8844,
+0x8842, 0x8852, 0x8859, 0x885E, 0x8862, 0x886B, 0x8881, 0x887E,
+0x889E, 0x8875, 0x887D, 0x88B5, 0x8872, 0x8882, 0x8897, 0x8892,
+0x88AE, 0x8899, 0x88A2, 0x888D, 0x88A4, 0x88B0, 0x88BF, 0x88B1,
+0x88C3, 0x88C4, 0x88D4, 0x88D8, 0x88D9, 0x88DD, 0x88F9, 0x8902,
+0x88FC, 0x88F4, 0x88E8, 0x88F2, 0x8904, 0x890C, 0x890A, 0x8913,
+0x8943, 0x891E, 0x8925, 0x892A, 0x892B, 0x8941, 0x8944, 0x893B,
+0x8936, 0x8938, 0x894C, 0x891D, 0x8960, 0x895E},
+{ /* category 75 */
+0x8966, 0x8964, 0x896D, 0x896A, 0x896F, 0x8974, 0x8977, 0x897E,
+0x8983, 0x8988, 0x898A, 0x8993, 0x8998, 0x89A1, 0x89A9, 0x89A6,
+0x89AC, 0x89AF, 0x89B2, 0x89BA, 0x89BD, 0x89BF, 0x89C0, 0x89DA,
+0x89DC, 0x89DD, 0x89E7, 0x89F4, 0x89F8, 0x8A03, 0x8A16, 0x8A10,
+0x8A0C, 0x8A1B, 0x8A1D, 0x8A25, 0x8A36, 0x8A41, 0x8A5B, 0x8A52,
+0x8A46, 0x8A48, 0x8A7C, 0x8A6D, 0x8A6C, 0x8A62, 0x8A85, 0x8A82,
+0x8A84, 0x8AA8, 0x8AA1, 0x8A91, 0x8AA5, 0x8AA6, 0x8A9A, 0x8AA3,
+0x8AC4, 0x8ACD, 0x8AC2, 0x8ADA, 0x8AEB, 0x8AF3, 0x8AE7, 0x8AE4,
+0x8AF1, 0x8B14, 0x8AE0, 0x8AE2, 0x8AF7, 0x8ADE, 0x8ADB, 0x8B0C,
+0x8B07, 0x8B1A, 0x8AE1, 0x8B16, 0x8B10, 0x8B17, 0x8B20, 0x8B33,
+0x97AB, 0x8B26, 0x8B2B, 0x8B3E, 0x8B28, 0x8B41, 0x8B4C, 0x8B4F,
+0x8B4E, 0x8B49, 0x8B56, 0x8B5B, 0x8B5A, 0x8B6B},
+{ /* category 76 */
+0x8B5F, 0x8B6C, 0x8B6F, 0x8B74, 0x8B7D, 0x8B80, 0x8B8C, 0x8B8E,
+0x8B92, 0x8B93, 0x8B96, 0x8B99, 0x8B9A, 0x8C3A, 0x8C41, 0x8C3F,
+0x8C48, 0x8C4C, 0x8C4E, 0x8C50, 0x8C55, 0x8C62, 0x8C6C, 0x8C78,
+0x8C7A, 0x8C82, 0x8C89, 0x8C85, 0x8C8A, 0x8C8D, 0x8C8E, 0x8C94,
+0x8C7C, 0x8C98, 0x621D, 0x8CAD, 0x8CAA, 0x8CBD, 0x8CB2, 0x8CB3,
+0x8CAE, 0x8CB6, 0x8CC8, 0x8CC1, 0x8CE4, 0x8CE3, 0x8CDA, 0x8CFD,
+0x8CFA, 0x8CFB, 0x8D04, 0x8D05, 0x8D0A, 0x8D07, 0x8D0F, 0x8D0D,
+0x8D10, 0x9F4E, 0x8D13, 0x8CCD, 0x8D14, 0x8D16, 0x8D67, 0x8D6D,
+0x8D71, 0x8D73, 0x8D81, 0x8D99, 0x8DC2, 0x8DBE, 0x8DBA, 0x8DCF,
+0x8DDA, 0x8DD6, 0x8DCC, 0x8DDB, 0x8DCB, 0x8DEA, 0x8DEB, 0x8DDF,
+0x8DE3, 0x8DFC, 0x8E08, 0x8E09, 0x8DFF, 0x8E1D, 0x8E1E, 0x8E10,
+0x8E1F, 0x8E42, 0x8E35, 0x8E30, 0x8E34, 0x8E4A},
+{ /* category 77 */
+0x8E47, 0x8E49, 0x8E4C, 0x8E50, 0x8E48, 0x8E59, 0x8E64, 0x8E60,
+0x8E2A, 0x8E63, 0x8E55, 0x8E76, 0x8E72, 0x8E7C, 0x8E81, 0x8E87,
+0x8E85, 0x8E84, 0x8E8B, 0x8E8A, 0x8E93, 0x8E91, 0x8E94, 0x8E99,
+0x8EAA, 0x8EA1, 0x8EAC, 0x8EB0, 0x8EC6, 0x8EB1, 0x8EBE, 0x8EC5,
+0x8EC8, 0x8ECB, 0x8EDB, 0x8EE3, 0x8EFC, 0x8EFB, 0x8EEB, 0x8EFE,
+0x8F0A, 0x8F05, 0x8F15, 0x8F12, 0x8F19, 0x8F13, 0x8F1C, 0x8F1F,
+0x8F1B, 0x8F0C, 0x8F26, 0x8F33, 0x8F3B, 0x8F39, 0x8F45, 0x8F42,
+0x8F3E, 0x8F4C, 0x8F49, 0x8F46, 0x8F4E, 0x8F57, 0x8F5C, 0x8F62,
+0x8F63, 0x8F64, 0x8F9C, 0x8F9F, 0x8FA3, 0x8FAD, 0x8FAF, 0x8FB7,
+0x8FDA, 0x8FE5, 0x8FE2, 0x8FEA, 0x8FEF, 0x9087, 0x8FF4, 0x9005,
+0x8FF9, 0x8FFA, 0x9011, 0x9015, 0x9021, 0x900D, 0x901E, 0x9016,
+0x900B, 0x9027, 0x9036, 0x9035, 0x9039, 0x8FF8},
+{ /* category 78 */
+0x904F, 0x9050, 0x9051, 0x9052, 0x900E, 0x9049, 0x903E, 0x9056,
+0x9058, 0x905E, 0x9068, 0x906F, 0x9076, 0x96A8, 0x9072, 0x9082,
+0x907D, 0x9081, 0x9080, 0x908A, 0x9089, 0x908F, 0x90A8, 0x90AF,
+0x90B1, 0x90B5, 0x90E2, 0x90E4, 0x6248, 0x90DB, 0x9102, 0x9112,
+0x9119, 0x9132, 0x9130, 0x914A, 0x9156, 0x9158, 0x9163, 0x9165,
+0x9169, 0x9173, 0x9172, 0x918B, 0x9189, 0x9182, 0x91A2, 0x91AB,
+0x91AF, 0x91AA, 0x91B5, 0x91B4, 0x91BA, 0x91C0, 0x91C1, 0x91C9,
+0x91CB, 0x91D0, 0x91D6, 0x91DF, 0x91E1, 0x91DB, 0x91FC, 0x91F5,
+0x91F6, 0x921E, 0x91FF, 0x9214, 0x922C, 0x9215, 0x9211, 0x925E,
+0x9257, 0x9245, 0x9249, 0x9264, 0x9248, 0x9295, 0x923F, 0x924B,
+0x9250, 0x929C, 0x9296, 0x9293, 0x929B, 0x925A, 0x92CF, 0x92B9,
+0x92B7, 0x92E9, 0x930F, 0x92FA, 0x9344, 0x932E},
+{ /* category 79 */
+0x9319, 0x9322, 0x931A, 0x9323, 0x933A, 0x9335, 0x933B, 0x935C,
+0x9360, 0x937C, 0x936E, 0x9356, 0x93B0, 0x93AC, 0x93AD, 0x9394,
+0x93B9, 0x93D6, 0x93D7, 0x93E8, 0x93E5, 0x93D8, 0x93C3, 0x93DD,
+0x93D0, 0x93C8, 0x93E4, 0x941A, 0x9414, 0x9413, 0x9403, 0x9407,
+0x9410, 0x9436, 0x942B, 0x9435, 0x9421, 0x943A, 0x9441, 0x9452,
+0x9444, 0x945B, 0x9460, 0x9462, 0x945E, 0x946A, 0x9229, 0x9470,
+0x9475, 0x9477, 0x947D, 0x945A, 0x947C, 0x947E, 0x9481, 0x947F,
+0x9582, 0x9587, 0x958A, 0x9594, 0x9596, 0x9598, 0x9599, 0x95A0,
+0x95A8, 0x95A7, 0x95AD, 0x95BC, 0x95BB, 0x95B9, 0x95BE, 0x95CA,
+0x6FF6, 0x95C3, 0x95CD, 0x95CC, 0x95D5, 0x95D4, 0x95D6, 0x95DC,
+0x95E1, 0x95E5, 0x95E2, 0x9621, 0x9628, 0x962E, 0x962F, 0x9642,
+0x964C, 0x964F, 0x964B, 0x9677, 0x965C, 0x965E},
+{ /* category 80 */
+0x965D, 0x965F, 0x9666, 0x9672, 0x966C, 0x968D, 0x9698, 0x9695,
+0x9697, 0x96AA, 0x96A7, 0x96B1, 0x96B2, 0x96B0, 0x96B4, 0x96B6,
+0x96B8, 0x96B9, 0x96CE, 0x96CB, 0x96C9, 0x96CD, 0x894D, 0x96DC,
+0x970D, 0x96D5, 0x96F9, 0x9704, 0x9706, 0x9708, 0x9713, 0x970E,
+0x9711, 0x970F, 0x9716, 0x9719, 0x9724, 0x972A, 0x9730, 0x9739,
+0x973D, 0x973E, 0x9744, 0x9746, 0x9748, 0x9742, 0x9749, 0x975C,
+0x9760, 0x9764, 0x9766, 0x9768, 0x52D2, 0x976B, 0x9771, 0x9779,
+0x9785, 0x977C, 0x9781, 0x977A, 0x9786, 0x978B, 0x978F, 0x9790,
+0x979C, 0x97A8, 0x97A6, 0x97A3, 0x97B3, 0x97B4, 0x97C3, 0x97C6,
+0x97C8, 0x97CB, 0x97DC, 0x97ED, 0x9F4F, 0x97F2, 0x7ADF, 0x97F6,
+0x97F5, 0x980F, 0x980C, 0x9838, 0x9824, 0x9821, 0x9837, 0x983D,
+0x9846, 0x984F, 0x984B, 0x986B, 0x986F, 0x9870},
+{ /* category 81 */
+0x9871, 0x9874, 0x9873, 0x98AA, 0x98AF, 0x98B1, 0x98B6, 0x98C4,
+0x98C3, 0x98C6, 0x98E9, 0x98EB, 0x9903, 0x9909, 0x9912, 0x9914,
+0x9918, 0x9921, 0x991D, 0x991E, 0x9924, 0x9920, 0x992C, 0x992E,
+0x993D, 0x993E, 0x9942, 0x9949, 0x9945, 0x9950, 0x994B, 0x9951,
+0x9952, 0x994C, 0x9955, 0x9997, 0x9998, 0x99A5, 0x99AD, 0x99AE,
+0x99BC, 0x99DF, 0x99DB, 0x99DD, 0x99D8, 0x99D1, 0x99ED, 0x99EE,
+0x99F1, 0x99F2, 0x99FB, 0x99F8, 0x9A01, 0x9A0F, 0x9A05, 0x99E2,
+0x9A19, 0x9A2B, 0x9A37, 0x9A45, 0x9A42, 0x9A40, 0x9A43, 0x9A3E,
+0x9A55, 0x9A4D, 0x9A5B, 0x9A57, 0x9A5F, 0x9A62, 0x9A65, 0x9A64,
+0x9A69, 0x9A6B, 0x9A6A, 0x9AAD, 0x9AB0, 0x9ABC, 0x9AC0, 0x9ACF,
+0x9AD1, 0x9AD3, 0x9AD4, 0x9ADE, 0x9ADF, 0x9AE2, 0x9AE3, 0x9AE6,
+0x9AEF, 0x9AEB, 0x9AEE, 0x9AF4, 0x9AF1, 0x9AF7},
+{ /* category 82 */
+0x9AFB, 0x9B06, 0x9B18, 0x9B1A, 0x9B1F, 0x9B22, 0x9B23, 0x9B25,
+0x9B27, 0x9B28, 0x9B29, 0x9B2A, 0x9B2E, 0x9B2F, 0x9B32, 0x9B44,
+0x9B43, 0x9B4F, 0x9B4D, 0x9B4E, 0x9B51, 0x9B58, 0x9B74, 0x9B93,
+0x9B83, 0x9B91, 0x9B96, 0x9B97, 0x9B9F, 0x9BA0, 0x9BA8, 0x9BB4,
+0x9BC0, 0x9BCA, 0x9BB9, 0x9BC6, 0x9BCF, 0x9BD1, 0x9BD2, 0x9BE3,
+0x9BE2, 0x9BE4, 0x9BD4, 0x9BE1, 0x9C3A, 0x9BF2, 0x9BF1, 0x9BF0,
+0x9C15, 0x9C14, 0x9C09, 0x9C13, 0x9C0C, 0x9C06, 0x9C08, 0x9C12,
+0x9C0A, 0x9C04, 0x9C2E, 0x9C1B, 0x9C25, 0x9C24, 0x9C21, 0x9C30,
+0x9C47, 0x9C32, 0x9C46, 0x9C3E, 0x9C5A, 0x9C60, 0x9C67, 0x9C76,
+0x9C78, 0x9CE7, 0x9CEC, 0x9CF0, 0x9D09, 0x9D08, 0x9CEB, 0x9D03,
+0x9D06, 0x9D2A, 0x9D26, 0x9DAF, 0x9D23, 0x9D1F, 0x9D44, 0x9D15,
+0x9D12, 0x9D41, 0x9D3F, 0x9D3E, 0x9D46, 0x9D48},
+{ /* category 83 */
+0x9D5D, 0x9D5E, 0x9D64, 0x9D51, 0x9D50, 0x9D59, 0x9D72, 0x9D89,
+0x9D87, 0x9DAB, 0x9D6F, 0x9D7A, 0x9D9A, 0x9DA4, 0x9DA9, 0x9DB2,
+0x9DC4, 0x9DC1, 0x9DBB, 0x9DB8, 0x9DBA, 0x9DC6, 0x9DCF, 0x9DC2,
+0x9DD9, 0x9DD3, 0x9DF8, 0x9DE6, 0x9DED, 0x9DEF, 0x9DFD, 0x9E1A,
+0x9E1B, 0x9E1E, 0x9E75, 0x9E79, 0x9E7D, 0x9E81, 0x9E88, 0x9E8B,
+0x9E8C, 0x9E92, 0x9E95, 0x9E91, 0x9E9D, 0x9EA5, 0x9EA9, 0x9EB8,
+0x9EAA, 0x9EAD, 0x9761, 0x9ECC, 0x9ECE, 0x9ECF, 0x9ED0, 0x9ED4,
+0x9EDC, 0x9EDE, 0x9EDD, 0x9EE0, 0x9EE5, 0x9EE8, 0x9EEF, 0x9EF4,
+0x9EF6, 0x9EF7, 0x9EF9, 0x9EFB, 0x9EFC, 0x9EFD, 0x9F07, 0x9F08,
+0x76B7, 0x9F15, 0x9F21, 0x9F2C, 0x9F3E, 0x9F4A, 0x9F52, 0x9F54,
+0x9F63, 0x9F5F, 0x9F60, 0x9F61, 0x9F66, 0x9F67, 0x9F6C, 0x9F6A,
+0x9F77, 0x9F72, 0x9F76, 0x9F95, 0x9F9C, 0x9FA0},
+{ /* category 84 */
+0x582F, 0x69C7, 0x9059, 0x7464, 0x51DC, 0x7199, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 85 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 86 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 87 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 88 */
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
+{ /* category 89 */
+0x7E8A, 0x891C, 0x9348, 0x9288, 0x84DC, 0x4FC9, 0x70BB, 0x6631,
+0x68C8, 0x92F9, 0x66FB, 0x5F45, 0x4E28, 0x4EE1, 0x4EFC, 0x4F00,
+0x4F03, 0x4F39, 0x4F56, 0x4F92, 0x4F8A, 0x4F9A, 0x4F94, 0x4FCD,
+0x5040, 0x5022, 0x4FFF, 0x501E, 0x5046, 0x5070, 0x5042, 0x5094,
+0x50F4, 0x50D8, 0x514A, 0x5164, 0x519D, 0x51BE, 0x51EC, 0x5215,
+0x529C, 0x52A6, 0x52C0, 0x52DB, 0x5300, 0x5307, 0x5324, 0x5372,
+0x5393, 0x53B2, 0x53DD, 0xFA0E, 0x549C, 0x548A, 0x54A9, 0x54FF,
+0x5586, 0x5759, 0x5765, 0x57AC, 0x57C8, 0x57C7, 0xFA0F, 0xFA10,
+0x589E, 0x58B2, 0x590B, 0x5953, 0x595B, 0x595D, 0x5963, 0x59A4,
+0x59BA, 0x5B56, 0x5BC0, 0x752F, 0x5BD8, 0x5BEC, 0x5C1E, 0x5CA6,
+0x5CBA, 0x5CF5, 0x5D27, 0x5D53, 0xFA11, 0x5D42, 0x5D6D, 0x5DB8,
+0x5DB9, 0x5DD0, 0x5F21, 0x5F34, 0x5F67, 0x5FB7},
+{ /* category 90 */
+0x5FDE, 0x605D, 0x6085, 0x608A, 0x60DE, 0x60D5, 0x6120, 0x60F2,
+0x6111, 0x6137, 0x6130, 0x6198, 0x6213, 0x62A6, 0x63F5, 0x6460,
+0x649D, 0x64CE, 0x654E, 0x6600, 0x6615, 0x663B, 0x6609, 0x662E,
+0x661E, 0x6624, 0x6665, 0x6657, 0x6659, 0xFA12, 0x6673, 0x6699,
+0x66A0, 0x66B2, 0x66BF, 0x66FA, 0x670E, 0xF929, 0x6766, 0x67BB,
+0x6852, 0x67C0, 0x6801, 0x6844, 0x68CF, 0xFA13, 0x6968, 0xFA14,
+0x6998, 0x69E2, 0x6A30, 0x6A6B, 0x6A46, 0x6A73, 0x6A7E, 0x6AE2,
+0x6AE4, 0x6BD6, 0x6C3F, 0x6C5C, 0x6C86, 0x6C6F, 0x6CDA, 0x6D04,
+0x6D87, 0x6D6F, 0x6D96, 0x6DAC, 0x6DCF, 0x6DF8, 0x6DF2, 0x6DFC,
+0x6E39, 0x6E5C, 0x6E27, 0x6E3C, 0x6EBF, 0x6F88, 0x6FB5, 0x6FF5,
+0x7005, 0x7007, 0x7028, 0x7085, 0x70AB, 0x710F, 0x7104, 0x715C,
+0x7146, 0x7147, 0xFA15, 0x71C1, 0x71FE, 0x72B1},
+{ /* category 91 */
+0x72BE, 0x7324, 0xFA16, 0x7377, 0x73BD, 0x73C9, 0x73D6, 0x73E3,
+0x73D2, 0x7407, 0x73F5, 0x7426, 0x742A, 0x7429, 0x742E, 0x7462,
+0x7489, 0x749F, 0x7501, 0x756F, 0x7682, 0x769C, 0x769E, 0x769B,
+0x76A6, 0xFA17, 0x7746, 0x52AF, 0x7821, 0x784E, 0x7864, 0x787A,
+0x7930, 0xFA18, 0xFA19, 0xFA1A, 0x7994, 0xFA1B, 0x799B, 0x7AD1,
+0x7AE7, 0xFA1C, 0x7AEB, 0x7B9E, 0xFA1D, 0x7D48, 0x7D5C, 0x7DB7,
+0x7DA0, 0x7DD6, 0x7E52, 0x7F47, 0x7FA1, 0xFA1E, 0x8301, 0x8362,
+0x837F, 0x83C7, 0x83F6, 0x8448, 0x84B4, 0x8553, 0x8559, 0x856B,
+0xFA1F, 0x85B0, 0xFA20, 0xFA21, 0x8807, 0x88F5, 0x8A12, 0x8A37,
+0x8A79, 0x8AA7, 0x8ABE, 0x8ADF, 0xFA22, 0x8AF6, 0x8B53, 0x8B7F,
+0x8CF0, 0x8CF4, 0x8D12, 0x8D76, 0xFA23, 0x8ECF, 0xFA24, 0xFA25,
+0x9067, 0x90DE, 0xFA26, 0x9115, 0x9127, 0x91DA},
+{ /* category 92 */
+0x91D7, 0x91DE, 0x91ED, 0x91EE, 0x91E4, 0x91E5, 0x9206, 0x9210,
+0x920A, 0x923A, 0x9240, 0x923C, 0x924E, 0x9259, 0x9251, 0x9239,
+0x9267, 0x92A7, 0x9277, 0x9278, 0x92E7, 0x92D7, 0x92D9, 0x92D0,
+0xFA27, 0x92D5, 0x92E0, 0x92D3, 0x9325, 0x9321, 0x92FB, 0xFA28,
+0x931E, 0x92FF, 0x931D, 0x9302, 0x9370, 0x9357, 0x93A4, 0x93C6,
+0x93DE, 0x93F8, 0x9431, 0x9445, 0x9448, 0x9592, 0xF9DC, 0xFA29,
+0x969D, 0x96AF, 0x9733, 0x973B, 0x9743, 0x974D, 0x974F, 0x9751,
+0x9755, 0x9857, 0x9865, 0xFA2A, 0xFA2B, 0x9927, 0xFA2C, 0x999E,
+0x9A4E, 0x9AD9, 0x9ADC, 0x9B75, 0x9B72, 0x9B8F, 0x9BB1, 0x9BBB,
+0x9C00, 0x9D70, 0x9D6B, 0xFA2D, 0x9E19, 0x9ED1, 0x0000, 0x0000,
+0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177,
+0x2178, 0x2179, 0xFFE2, 0xFFE4, 0xFF07, 0xFF02}};
+
+#endif /* JISX0208_H */
--- /dev/null
+#include <stdio.h>
+#include <math.h>
+
+#define scale 1024
+
+int basis[91];
+int cost[360];
+
+main (void)
+{
+ int i;
+ printf ("#define costScale %d\n", scale);
+ printf ("int cost[] = {\n ");
+ for (i = 0; (i <= 90); i++)
+ {
+ basis[i] = cos ((double) i * .0174532925) * scale;
+ }
+ for (i = 0; (i < 90); i++)
+ {
+ printf ("%d,\n ", cost[i] = basis[i]);
+ }
+ for (i = 90; (i < 180); i++)
+ {
+ printf ("%d,\n ", cost[i] = -basis[180 - i]);
+ }
+ for (i = 180; (i < 270); i++)
+ {
+ printf ("%d,\n ", cost[i] = -basis[i - 180]);
+ }
+ for (i = 270; (i < 359); i++)
+ {
+ printf ("%d,\n ", cost[i] = basis[360 - i]);
+ }
+ printf ("%d\n", cost[359] = basis[1]);
+ printf ("};\n");
+ printf ("#define sintScale %d\n", scale);
+ printf ("int sint[] = {\n ");
+ for (i = 0; (i < 360); i++)
+ {
+ int val;
+ val = cost[(i + 270) % 360];
+ if (i != 359)
+ {
+ printf ("%d,\n ", val);
+ }
+ else
+ {
+ printf ("%d\n", val);
+ }
+ }
+ printf ("};\n");
+}
--- /dev/null
+
+#include <stdio.h>
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in, *out;
+ if (argc != 3)
+ {
+ fprintf (stderr, "Usage: pngtogd filename.png filename.gd\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromPng (in);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in PNG format!\n");
+ exit (1);
+ }
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ gdImageGd (im, out);
+ fclose (out);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "gd.h"
+
+/* A short program which converts a .png file into a .gd file, for
+ your convenience in creating images on the fly from a
+ basis image that must be loaded quickly. The .gd format
+ is not intended to be a general-purpose format. */
+
+int
+main (int argc, char **argv)
+{
+ gdImagePtr im;
+ FILE *in, *out;
+ int cs, fmt;
+
+ if (argc != 5)
+ {
+ fprintf (stderr, "Usage: pngtogd2 filename.png filename.gd2 cs fmt\n");
+ fprintf (stderr, " where cs is the chunk size\n");
+ fprintf (stderr, " fmt is 1 for raw, 2 for compressed\n");
+ exit (1);
+ }
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Input file does not exist!\n");
+ exit (1);
+ }
+ im = gdImageCreateFromPng (in);
+ fclose (in);
+ if (!im)
+ {
+ fprintf (stderr, "Input is not in PNG format!\n");
+ exit (1);
+ }
+ out = fopen (argv[2], "wb");
+ if (!out)
+ {
+ fprintf (stderr, "Output file cannot be written to!\n");
+ gdImageDestroy (im);
+ exit (1);
+ }
+ cs = atoi (argv[3]);
+ fmt = atoi (argv[4]);
+ gdImageGd2 (im, out, cs, fmt);
+ fclose (out);
+ gdImageDestroy (im);
+
+ return 0;
+}
--- /dev/null
+
+#include <stdio.h>
+#include "gd.h"
+
+/* If palette is true, we convert from truecolor to palette at the end,
+ to test gdImageTrueColorToPalette and see file size/
+ quality tradeoffs. */
+
+void testDrawing (
+ gdImagePtr im_in,
+ double scale,
+ int blending,
+ int palette,
+ char *filename);
+
+int
+main (int argc, char *argv[])
+{
+ /* Input and output files */
+ FILE *in;
+ FILE *out;
+
+ /* Input image */
+ gdImagePtr im_in = 0;
+
+ /* Colors */
+ int lightBlue;
+
+ if (argc != 2)
+ {
+ fprintf (stderr, "Usage: testac filename.png\n");
+ exit (1);
+ }
+ /* Load original PNG, which should contain alpha channel
+ information. We will use it in two ways: preserving it
+ literally, for use with compatible browsers, and
+ compositing it ourselves against a background of our
+ choosing (alpha blending). We'll change its size
+ and try creating palette versions of it. */
+ in = fopen (argv[1], "rb");
+ if (!in)
+ {
+ fprintf (stderr, "Can't load %s.\n", argv[1]);
+ exit (1);
+ }
+ else
+ {
+ im_in = gdImageCreateFromPng (in);
+ fclose (in);
+ }
+ testDrawing (im_in, 1.0, 0, 0, "noblending-fullsize-truecolor.png");
+ testDrawing (im_in, 1.0, 1, 0, "blending-fullsize-truecolor.png");
+ testDrawing (im_in, 0.5, 0, 0, "noblending-halfsize-truecolor.png");
+ testDrawing (im_in, 0.5, 1, 0, "blending-halfsize-truecolor.png");
+ testDrawing (im_in, 2.0, 0, 0, "noblending-doublesize-truecolor.png");
+ testDrawing (im_in, 2.0, 1, 0, "blending-doublesize-truecolor.png");
+ testDrawing (im_in, 1.0, 0, 1, "noblending-fullsize-palette.png");
+ testDrawing (im_in, 1.0, 1, 1, "blending-fullsize-palette.png");
+ testDrawing (im_in, 0.5, 0, 1, "noblending-halfsize-palette.png");
+ testDrawing (im_in, 0.5, 1, 1, "blending-halfsize-palette.png");
+ testDrawing (im_in, 2.0, 0, 1, "noblending-doublesize-palette.png");
+ testDrawing (im_in, 2.0, 1, 1, "blending-doublesize-palette.png");
+ gdImageDestroy (im_in);
+ return 0;
+}
+
+/* If palette is true, we convert from truecolor to palette at the end,
+ to test gdImageTrueColorToPalette and see file size/
+ quality tradeoffs. */
+void
+testDrawing (
+ gdImagePtr im_in,
+ double scale,
+ int blending,
+ int palette,
+ char *filename)
+{
+ gdImagePtr im_out;
+ FILE *out;
+ /* Create output image. */
+ im_out = gdImageCreateTrueColor ((int) (gdImageSX (im_in) * scale),
+ (int) (gdImageSY (im_in) * scale));
+ /*
+ Request alpha blending. This causes future
+ drawing operations to perform alpha channel blending
+ with the background, resulting in an opaque image.
+ Without this call, pixels in the foreground color are
+ copied literally, *including* the alpha channel value,
+ resulting in an output image which is potentially
+ not opaque. This flag can be set and cleared as often
+ as desired. */
+ gdImageAlphaBlending (im_out, blending);
+
+ /* Flood with light blue. */
+ gdImageFill (im_out, (int) (gdImageSX (im_in) * scale / 2),
+ (int) (gdImageSY (im_in) * scale / 2),
+ gdTrueColor (192, 192, 255));
+ /* Copy the source image. Alpha blending should result in
+ compositing against red. With blending turned off, the
+ browser or viewer will composite against its preferred
+ background, or, if it does not support an alpha channel,
+ we will see the original colors for the pixels that
+ ought to be transparent or semitransparent. */
+ gdImageCopyResampled (im_out, im_in,
+ 0, 0,
+ 0, 0,
+ (int) (gdImageSX (im_in) * scale), (int) (gdImageSY (im_in) * scale),
+ gdImageSX (im_in), gdImageSY (im_in));
+ /* Write PNG */
+ out = fopen (filename, "wb");
+
+ /* If this image is the result of alpha channel blending,
+ it will not contain an interesting alpha channel itself.
+ Save a little file size by not saving the alpha channel.
+ Otherwise the file would typically be slightly larger. */
+ gdImageSaveAlpha (im_out, !blending);
+
+ /* If requested, convert from truecolor to palette. */
+ if (palette)
+ {
+ /* Dithering, 256 colors. */
+ gdImageTrueColorToPalette (im_out, 1, 256);
+ }
+
+ gdImagePng (im_out, out);
+ fclose (out);
+
+ gdImageDestroy (im_out);
+}
--- /dev/null
+
+/* WBMP
+ ** ----
+ ** WBMP Level 0: B/W, Uncompressed
+ ** This implements the WBMP format as specified in WAPSpec 1.1 and 1.2.
+ ** It does not support ExtHeaders as defined in the spec. The spec states
+ ** that a WAP client does not need to implement ExtHeaders.
+ **
+ ** (c) 2000 Johan Van den Brande <johan@vandenbrande.com>
+ */
+
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "wbmp.h"
+#include "gd.h"
+#include "gdhelpers.h"
+
+#ifdef NOTDEF
+#define __TEST /* Compile with main function */
+#define __DEBUG /* Extra verbose when with __TEST */
+#define __WRITE /* readwbmp and writewbmp(stdout) */
+#define __VIEW /* view the wbmp on stdout */
+#endif
+
+/* getmbi
+ ** ------
+ ** Get a multibyte integer from a generic getin function
+ ** 'getin' can be getc, with in = NULL
+ ** you can find getin as a function just above the main function
+ ** This way you gain a lot of flexibilty about how this package
+ ** reads a wbmp file.
+ */
+int
+getmbi (int (*getin) (void *in), void *in)
+{
+ int i, mbi = 0;
+
+ do
+ {
+ i = getin (in);
+ if (i < 0)
+ return (-1);
+ mbi = mbi << 7 | i & 0x7f;
+ }
+ while (i & 0x80);
+
+ return (mbi);
+}
+
+
+/* putmbi
+ ** ------
+ ** Put a multibyte intgerer in some kind of output stream
+ ** I work here with a function pointer, to make it as generic
+ ** as possible. Look at this function as an iterator on the
+ ** mbi integers it spits out.
+ **
+ */
+void
+putmbi (int i, void (*putout) (int c, void *out), void *out)
+{
+ int cnt, l, accu;
+
+ /* Get number of septets */
+ cnt = 0;
+ accu = 0;
+ while (accu != i)
+ accu += i & 0x7f << 7 * cnt++;
+
+ /* Produce the multibyte output */
+ for (l = cnt - 1; l > 0; l--)
+ putout (0x80 | (i & 0x7f << 7 * l) >> 7 * l, out);
+
+ putout (i & 0x7f, out);
+
+}
+
+
+
+/* skipheader
+ ** ----------
+ ** Skips the ExtHeader. Not needed for the moment
+ **
+ */
+int
+skipheader (int (*getin) (void *in), void *in)
+{
+ int i;
+
+ do
+ {
+ i = getin (in);
+ if (i < 0)
+ return (-1);
+ }
+ while (i & 0x80);
+
+ return (0);
+}
+
+/* create wbmp
+ ** -----------
+ ** create an empty wbmp
+ **
+ */
+Wbmp *
+createwbmp (int width, int height, int color)
+{
+ int i;
+
+ Wbmp *wbmp;
+ if ((wbmp = (Wbmp *) gdMalloc (sizeof (Wbmp))) == NULL)
+ return (NULL);
+
+ if ((wbmp->bitmap = (int *) gdMalloc (sizeof (int) * width * height)) == NULL)
+ {
+ gdFree (wbmp);
+ return (NULL);
+ }
+
+ wbmp->width = width;
+ wbmp->height = height;
+
+ for (i = 0; i < width * height; wbmp->bitmap[i++] = color);
+
+ return (wbmp);
+}
+
+
+
+/* readwbmp
+ ** -------
+ ** Actually reads the WBMP format from an open file descriptor
+ ** It goes along by returning a pointer to a WBMP struct.
+ **
+ */
+int
+readwbmp (int (*getin) (void *in), void *in, Wbmp ** return_wbmp)
+{
+ int row, col, byte, pel, pos;
+ Wbmp *wbmp;
+
+ if ((wbmp = (Wbmp *) gdMalloc (sizeof (Wbmp))) == NULL)
+ return (-1);
+
+ wbmp->type = getin (in);
+ if (wbmp->type != 0)
+ {
+ gdFree (wbmp);
+ return (-1);
+ }
+
+ if (skipheader (getin, in))
+ return (-1);
+
+
+ wbmp->width = getmbi (getin, in);
+ if (wbmp->width == -1)
+ {
+ gdFree (wbmp);
+ return (-1);
+ }
+
+ wbmp->height = getmbi (getin, in);
+ if (wbmp->height == -1)
+ {
+ gdFree (wbmp);
+ return (-1);
+ }
+
+#ifdef __DEBUG
+ printf ("W: %d, H: %d\n", wbmp->width, wbmp->height);
+#endif
+
+ if ((wbmp->bitmap = (int *) gdMalloc (sizeof (int) * wbmp->width * wbmp->height)) == NULL)
+ {
+ gdFree (wbmp);
+ return (-1);
+ }
+
+#ifdef __DEBUG
+ printf ("DATA CONSTRUCTED\n");
+#endif
+
+ pos = 0;
+ for (row = 0; row < wbmp->height; row++)
+ {
+ for (col = 0; col < wbmp->width;)
+ {
+ byte = getin (in);
+
+ for (pel = 7; pel >= 0; pel--)
+ {
+ if (col++ < wbmp->width)
+ {
+ if (byte & 1 << pel)
+ {
+ wbmp->bitmap[pos] = WBMP_WHITE;
+ }
+ else
+ {
+ wbmp->bitmap[pos] = WBMP_BLACK;
+ }
+ pos++;
+ }
+ }
+ }
+ }
+
+ *return_wbmp = wbmp;
+
+ return (0);
+}
+
+
+/* writewbmp
+ ** ---------
+ ** Write a wbmp to a file descriptor
+ **
+ ** Why not just giving a filedescriptor to this function?
+ ** Well, the incentive to write this function was the complete
+ ** integration in gd library from www.boutell.com. They use
+ ** their own io functions, so the passing of a function seemed to be
+ ** a logic(?) decision ...
+ **
+ */
+int
+writewbmp (Wbmp * wbmp, void (*putout) (int c, void *out), void *out)
+{
+ int row, col;
+ int bitpos, octet;
+
+ /* Generate the header */
+ putout (0, out); /* WBMP Type 0: B/W, Uncompressed bitmap */
+ putout (0, out); /* FixHeaderField */
+
+
+
+ /* Size of the image */
+ putmbi (wbmp->width, putout, out); /* width */
+ putmbi (wbmp->height, putout, out); /* height */
+
+
+ /* Image data */
+ for (row = 0; row < wbmp->height; row++)
+ {
+ bitpos = 8;
+ octet = 0;
+ for (col = 0; col < wbmp->width; col++)
+ {
+ octet |= ((wbmp->bitmap[row * wbmp->width + col] == 1) ? WBMP_WHITE : WBMP_BLACK) << --bitpos;
+ if (bitpos == 0)
+ {
+ bitpos = 8;
+ putout (octet, out);
+ octet = 0;
+ }
+ }
+ if (bitpos != 8)
+ putout (octet, out);
+
+ }
+ return (0);
+
+}
+
+
+/* freewbmp
+ ** --------
+ ** gdFrees up memory occupied by a WBMP structure
+ **
+ */
+void
+freewbmp (Wbmp * wbmp)
+{
+ gdFree (wbmp->bitmap);
+ gdFree (wbmp);
+}
+
+
+/* printwbmp
+ ** ---------
+ ** print a WBMP to stdout for visualisation
+ **
+ */
+void
+printwbmp (Wbmp * wbmp)
+{
+ int row, col;
+ for (row = 0; row < wbmp->height; row++)
+ {
+ for (col = 0; col < wbmp->width; col++)
+ {
+ if (wbmp->bitmap[wbmp->width * row + col] == WBMP_BLACK)
+ {
+ putchar ('#');
+ }
+ else
+ {
+ putchar (' ');
+ }
+ }
+ putchar ('\n');
+ }
+}
+
+#ifdef __TEST
+
+/* putout to file descriptor
+ ** -------------------------
+ */
+int
+putout (int c, void *out)
+{
+ return (putc (c, (FILE *) out));
+}
+
+/* getin from file descriptor
+ ** --------------------------
+ */
+int
+getin (void *in)
+{
+ return (getc ((FILE *) in));
+}
+
+
+/* Main function
+ ** -------------
+ **
+ */
+int
+main (int argc, char *argv[])
+{
+ FILE *wbmp_file;
+ Wbmp *wbmp;
+
+ wbmp_file = fopen (argv[1], "rb");
+ if (wbmp_file)
+ {
+ readwbmp (&getin, wbmp_file, &wbmp);
+
+#ifdef __VIEW
+
+#ifdef __DEBUG
+ printf ("\nVIEWING IMAGE\n");
+#endif
+
+ printwbmp (wbmp);
+#endif
+
+#ifdef __WRITE
+
+#ifdef __DEBUG
+ printf ("\nDUMPING WBMP to STDOUT\n");
+#endif
+
+ writewbmp (wbmp, &putout, stdout);
+#endif
+
+ freewbmp (wbmp);
+ fclose (wbmp_file);
+ }
+}
+#endif
--- /dev/null
+/* WBMP
+** ----
+** WBMP Level 0: B/W, Uncompressed
+** This implements the WBMP format as specified in WAPSpec 1.1 and 1.2.
+** It does not support ExtHeaders as defined in the spec. The spec states
+** that a WAP client does not need to implement ExtHeaders.
+**
+** (c) 2000 Johan Van den Brande <johan@vandenbrande.com>
+**
+** Header file
+*/
+#ifndef __WBMP_H
+#define __WBMP_H 1
+
+
+/* WBMP struct
+** -----------
+** A Wireless bitmap structure
+**
+*/
+
+typedef struct Wbmp_
+{
+ int type; /* type of the wbmp */
+ int width; /* width of the image */
+ int height; /* height of the image */
+ int *bitmap; /* pointer to data: 0 = WHITE , 1 = BLACK */
+} Wbmp;
+
+#define WBMP_WHITE 1
+#define WBMP_BLACK 0
+
+
+/* Proto's
+** -------
+**
+*/
+void putmbi( int i, void (*putout)(int c, void *out), void *out);
+int getmbi ( int (*getin)(void *in), void *in );
+int skipheader( int (*getin)(void *in), void *in );
+Wbmp *createwbmp( int width, int height, int color );
+int readwbmp( int (*getin)(void *in), void *in, Wbmp **wbmp );
+int writewbmp( Wbmp *wbmp, void (*putout)( int c, void *out), void *out);
+void freewbmp( Wbmp *wbmp );
+void printwbmp( Wbmp *wbmp );
+
+#endif
--- /dev/null
+/* Bring in the gd library functions */
+#include "gd.h"
+
+/* Bring in standard I/O and string manipulation functions */
+#include <stdio.h>
+#include <stdlib.h> /* for atoi() */
+#include <string.h>
+
+#ifdef _WIN32
+#include <process.h>
+int
+getpid ()
+{
+ return _getpid ();
+}
+#else
+#include <unistd.h> /* for getpid(), unlink() */
+#endif
+int
+main (int argc, char **argv)
+{
+ FILE *in;
+ FILE *out;
+ char outFn[20];
+ int useStdinStdout = 0;
+
+ /* Declare our image pointer */
+ gdImagePtr im = 0;
+ int i;
+ /* We'll clear 'no' once we know the user has made a
+ reasonable request. */
+ int no = 1;
+ /* We'll set 'write' once we know the user's request
+ requires that the image be written back to disk. */
+ int write = 0;
+ /* C programs always get at least one argument; we want at
+ least one more (the image), more in practice. */
+ if (argc < 2 || !strcmp (argv[1], "--help"))
+ {
+ no = 1;
+ goto usage;
+ }
+
+ /* The last argument should be the image. Open the file. */
+ if (strcmp ("-", argv[argc - 1]) == 0)
+ { /* - is synonymous with STDIN */
+ useStdinStdout = 1;
+ in = stdin;
+ }
+ else
+ {
+ in = fopen (argv[argc - 1], "rb");
+ }
+ if (!in)
+ {
+ fprintf (stderr,
+ "Error: can't open file %s.\n", argv[argc - 1]);
+ exit (1);
+ }
+ /* Now load the image. */
+ im = gdImageCreateFromPng (in);
+ fclose (in);
+ /* If the load failed, it must not be a PNG file. */
+ if (!im)
+ {
+ fprintf (stderr,
+ "Error: %s is not a valid PNG file.\n", argv[argc - 1]);
+ exit (1);
+ }
+ /* Consider each argument in turn. */
+ for (i = 1; (i < (argc - 1)); i++)
+ {
+ /* -i turns on and off interlacing. */
+ if (!strcmp (argv[i], "--help"))
+ {
+ /* Every program should use this for help! :) */
+ no = 1;
+ goto usage;
+ }
+ else if (!strcmp (argv[i], "-i"))
+ {
+ if (i == (argc - 2))
+ {
+ fprintf (stderr,
+ "Error: -i specified without y or n.\n");
+ no = 1;
+ goto usage;
+ }
+ if (!strcmp (argv[i + 1], "y"))
+ {
+ /* Set interlace. */
+ gdImageInterlace (im, 1);
+ }
+ else if (!strcmp (argv[i + 1], "n"))
+ {
+ /* Clear interlace. */
+ gdImageInterlace (im, 0);
+ }
+ else
+ {
+ fprintf (stderr,
+ "Error: -i specified without y or n.\n");
+ no = 1;
+ goto usage;
+ }
+ i++;
+ no = 0;
+ write = 1;
+ }
+ else if (!strcmp (argv[i], "-t"))
+ {
+ /* Set transparent index (or none). */
+ int index;
+ if (i == (argc - 2))
+ {
+ fprintf (stderr,
+ "Error: -t specified without a color table index.\n");
+ no = 1;
+ goto usage;
+ }
+ if (!strcmp (argv[i + 1], "none"))
+ {
+ /* -1 means not transparent. */
+ gdImageColorTransparent (im, -1);
+ }
+ else
+ {
+ /* OK, get an integer and set the index. */
+ index = atoi (argv[i + 1]);
+ gdImageColorTransparent (im, index);
+ }
+ i++;
+ write = 1;
+ no = 0;
+ }
+ else if (!strcmp (argv[i], "-l"))
+ {
+ /* List the colors in the color table. */
+ int j;
+ if (!im->trueColor)
+ {
+ /* Tabs used below. */
+ printf ("Index Red Green Blue Alpha\n");
+ for (j = 0; (j < gdImageColorsTotal (im)); j++)
+ {
+ /* Use access macros to learn colors. */
+ printf ("%d %d %d %d %d\n",
+ j,
+ gdImageRed (im, j),
+ gdImageGreen (im, j),
+ gdImageBlue (im, j),
+ gdImageAlpha (im, j));
+ }
+ }
+ else
+ {
+ printf ("Truecolor image, no palette entries to list.\n");
+ }
+ no = 0;
+ }
+ else if (!strcmp (argv[i], "-d"))
+ {
+ /* Output dimensions, etc. */
+ int t;
+ printf ("Width: %d Height: %d Colors: %d\n",
+ gdImageSX (im), gdImageSY (im),
+ gdImageColorsTotal (im));
+ t = gdImageGetTransparent (im);
+ if (t != (-1))
+ {
+ printf ("First 100% transparent index: %d\n", t);
+ }
+ else
+ {
+ /* -1 means the image is not transparent. */
+ printf ("First 100% transparent index: none\n");
+ }
+ if (gdImageGetInterlaced (im))
+ {
+ printf ("Interlaced: yes\n");
+ }
+ else
+ {
+ printf ("Interlaced: no\n");
+ }
+ no = 0;
+ }
+ else
+ {
+ fprintf (stderr, "Unknown argument: %s\n", argv[i]);
+ break;
+ }
+ }
+usage:
+ if (no)
+ {
+ /* If the command failed, output an explanation. */
+ fprintf (stderr,
+ "Usage: webpng [-i y|n ] [-l] [-t index|none ] [-d] pngname.png\n"
+
+ " -i [y|n] Turns on/off interlace\n"
+ " -l Prints the table of color indexes\n"
+ " -t [index] Set the transparent color to the specified index (0-255 or \"none\")\n"
+ " -d Reports the dimensions and other characteristics of the image.\n"
+ "\n"
+ "If you specify '-' as the input file, stdin/stdout will be used input/output.\n"
+ );
+ }
+ if (write)
+ {
+ if (useStdinStdout)
+ {
+ out = stdout;
+ }
+ else
+ {
+ /* Open a temporary file. */
+
+ /* "temp.tmp" is not good temporary filename. */
+ sprintf (outFn, "webpng.tmp%d", getpid ());
+ out = fopen (outFn, "wb");
+
+ if (!out)
+ {
+ fprintf (stderr,
+ "Unable to write to %s -- exiting\n", outFn);
+ exit (1);
+ }
+ }
+
+ /* Write the new PNG. */
+ gdImagePng (im, out);
+
+ if (!useStdinStdout)
+ {
+ fclose (out);
+ /* Erase the old PNG. */
+ unlink (argv[argc - 1]);
+ /* Rename the new to the old. */
+ if (rename (outFn, argv[argc - 1]) != 0)
+ {
+ perror ("rename");
+ exit (1);
+ }
+ }
+ }
+ /* Delete the image from memory. */
+ if (im)
+ {
+ gdImageDestroy (im);
+ }
+ /* All's well that ends well. */
+ return 0;
+}
projects / php / commitdiff