pax_global_header00006660000000000000000000000064141676456150014531gustar00rootroot0000000000000052 comment=73f2c5dedadcd656e9a04c552aac3cae6a3ec05a kgames-2.2/000077500000000000000000000000001416764561500126435ustar00rootroot00000000000000kgames-2.2/.editorconfig000066400000000000000000000002251416764561500153170ustar00rootroot00000000000000[*.{c,h}] indent_style = space indent_size = 4 tab_width = 8 charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true root = true kgames-2.2/.gitignore000066400000000000000000000000061416764561500146270ustar00rootroot00000000000000build kgames-2.2/COPYING000066400000000000000000000023241416764561500136770ustar00rootroot00000000000000Unless otherwise noted in the body of the source file(s), the following copyright notices will apply: Copyright © 1992, 2020 Keith Packard Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. kgames-2.2/PatchLevel000066400000000000000000000000271416764561500146140ustar00rootroot00000000000000Current patch level: 2 kgames-2.2/README000066400000000000000000000041361416764561500135270ustar00rootroot00000000000000This is a collection of games, and some useful widgets which have been used in their construction. I've tested everything here with the original R6 release, but only on a Sparc-10 running SunOS 4. The Widgets (Xkw/): Layout a constraint based geometry widget. Included in this release is some code purported to make it work with Motif; I cannot test that as I do not have access to Motif. Hand, Cards Playing card management widget; does all of the nasty redisplay and layout of stacks of overlapping cards. Cards is a subclass and deals with regular playing cards. Message Utilities which allow a printf-style interface to the Athena Label widget. Pad A text display widget; handles scrolling and simple repaint. More powerful than Label as it optimizes repaint, but it only handles char cell fonts. Thermo Displays a "thermometer" for indicating a bounded-range value. Draws tick-marks and numbers. Handles both vertical and horizontal orientation. The Games (everything else). For rules on how to play them, consult Hoyle or just play around and see what they'll let you do. dominos Double 9 dominos against the computer. kcanfield Standard Canfield solitare. kcribbage Cribbage against the computer. The score keeping widget is not very pretty. kklondike "Regular" solitaire. kmontana An interesting single-deck solitaire. Stolen from the Macintosh game of the same name. kspider The classic double-deck solitaire. Probably the most interesting game here. kthieves 40-thieves. I've only seen this won a few times. ktowers A perfect-knowledge single deck game. Nearly every configuration can be eventually solved. mcarlo Monte-carlo. A very simple matching solitaire. Written by Dave Lemke reversi Or "Othello", except that that name is copywritten. slyfox Any easier double-deck solitaire. This one includes instructions; see slyfox-rules. Written by Dave Lemke xmille My first X program. Doesn't look much like the original anymore, except for the gory pictures. Keith Packard keithp@ncd.com June 6, 1994 kgames-2.2/Xkw/000077500000000000000000000000001416764561500134145ustar00rootroot00000000000000kgames-2.2/Xkw/.gitignore000066400000000000000000000000461416764561500154040ustar00rootroot00000000000000laylex.c laygram.c laygram.h *.a *.so*kgames-2.2/Xkw/Animate.c000066400000000000000000000144511416764561500151430ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include "Cards.h" # include "CardsUtil.h" #define DEFAULT_ANIMATION_SPEED 20 static double animation_speed = DEFAULT_ANIMATION_SPEED; static void do_animate (Widget widget, Pixel xor_value, int ox, int oy, int dx, int dy, Dimension width, Dimension height); static void draw_square (Widget widget, GC gc, int x1, int y1, int x2, int y2); static void compute_position (Widget w, int row, int col, Widget animate, int *xp, int *yp); static GC get_gc(Widget widget, Pixel xor_value); static void release_gc(Widget widget, GC gc); void AnimateSetSpeed (int i) { if (i < 0) i = DEFAULT_ANIMATION_SPEED; animation_speed = i; } void Animate (Widget srcWidget, int srcRow, int srcCol, Widget dstWidget, int dstRow, int dstCol) { int ox, oy, dx, dy; Arg arg[4]; Pixel obverse, black, xor_value; Dimension width, height; if (!animation_speed) return; XtSetArg (arg[0], XtNcardWidth, &width); XtSetArg (arg[1], XtNcardHeight, &height); XtSetArg (arg[2], XtNobverseColor, &obverse); XtSetArg (arg[3], XtNforeground, &black); XtGetValues (srcWidget, arg, 4); xor_value = obverse ^ black; compute_position (srcWidget, srcRow, srcCol, XtParent(srcWidget), &ox, &oy); compute_position (dstWidget, dstRow, dstCol, XtParent(srcWidget), &dx, &dy); do_animate (XtParent(srcWidget), xor_value, ox, oy, dx, dy, width, height); } # define abs(x) ((x) < 0 ? -(x) : (x)) /* * bigger numbers make it go faster */ # define accerate(v,r) ((v) + (speed/25 * (r))) static void msleep (int ms) { struct timeval t; int f = 0; t.tv_sec = ms / 1000; t.tv_usec = (ms % 1000) * 1000; select (1, (fd_set *) &f, 0, 0, &t); } static void do_animate (Widget widget, Pixel xor_value, int ox, int oy, int dx, int dy, Dimension width, Dimension height) { Display *dpy = XtDisplay (widget); GC gc; double x, y; double xc, yc; int xd, yd; int xp, yp; int x1, y1, x2, y2, x3, y3, x4, y4; int ix, iy; double dist; double rx, ry; double speed; x = ox; y = oy; xd = dx - ox; yd = dy - oy; dist = sqrt ((double) xd * xd + yd * yd); rx = (double) xd / dist; ry = (double) yd / dist; speed = animation_speed * width / 100.0; xc = speed * rx; yc = speed * ry; xp = yp = -32767; XFlush (dpy); gc = get_gc(widget, xor_value); while (abs(dx - x) > abs (xc) || abs(dy - y) > abs (yc)) { ix = x; iy = y; if (xp == -32767) draw_square (widget, gc, ix, iy, ix + width, iy + height); else { if (xp < ix) { x1 = xp + width; x2 = ix + width; x3 = ix; x4 = ix + width; } else if (xp > ix) { x1 = ix; x2 = xp; x3 = ix; x4 = ix + width; } else { x1 = -32767; x2 = -32767; x3 = ix; x4 = ix + width; } if (yp < iy) { y1 = iy; y2 = yp + height; y3 = yp + height; y4 = iy + height; } else if (yp > iy) { y1 = yp; y2 = iy + height; y3 = iy; y4 = yp; } else { y1 = iy; y2 = iy + height; y3 = -32767; y4 = -32767; } if (x1 != -32767 && y1 != -32767) draw_square (widget, gc, x1, y1, x2, y2); if (x3 != -32767 && y3 != -32767) draw_square (widget, gc, x3, y3, x4, y4); if (ix < xp) { x1 = ix + width; x2 = xp + width; x3 = xp; x4 = xp + width; } else if (ix > xp) { x1 = xp; x2 = ix; x3 = xp; x4 = xp + width; } else { x1 = -32767; x2 = -32767; x3 = xp; x4 = xp + width; } if (iy < yp) { y1 = yp; y2 = iy + height; y3 = iy + height; y4 = yp + height; } else if (iy > yp) { y1 = iy; y2 = yp + height; y3 = yp; y4 = iy; } else { y1 = yp; y2 = yp + height; y3 = -32767; y4 = -32767; } if (x1 != -32767 && y1 != -32767) draw_square (widget, gc, x1, y1, x2, y2); if (x3 != -32767 && y3 != -32767) draw_square (widget, gc, x3, y3, x4, y4); } xp = ix; yp = iy; if (abs (dx - x) > xc) x += xc; if (abs (dy - y) > yc) y += yc; xc = accerate(xc, rx); yc = accerate(yc, ry); XFlush (dpy); msleep (10); } draw_square (widget, gc, xp, yp, xp+width, yp+height); release_gc(widget, gc); XFlush (dpy); } static GC get_gc(Widget widget, Pixel xor_value) { XGCValues gcv = { .function = GXxor, .foreground = xor_value, .subwindow_mode = IncludeInferiors }; return XtGetGC (widget, GCForeground | GCFunction | GCSubwindowMode, &gcv); } static void release_gc(Widget widget, GC gc) { XtReleaseGC (widget, gc); } static void draw_square (Widget widget, GC gc, int x1, int y1, int x2, int y2) { XFillRectangle (XtDisplay (widget), XtWindow(widget), gc, x1, y1, x2-x1, y2-y1); } static void compute_position (Widget w, int row, int col, Widget animate, int *xp, int *yp) { XRectangle r; Position x, y; Arg args[2]; (void) animate; HandRectangleForPos (w, row, col, &r); XtSetArg (args[0], XtNx, &x); XtSetArg (args[1], XtNy, &y); XtGetValues (w, args, 2); *xp = r.x + x; *yp = r.y + y; } kgames-2.2/Xkw/Animate.h000066400000000000000000000025541416764561500151510ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _ANIMATE_H_ #define _ANIMATE_H_ void AnimateSetSpeed (int i); void Animate (Widget srcWidget, int srcRow, int srcCol, Widget dstWidget, int dstRow, int dstCol); #endif /* _ANIMATE_H_ */ kgames-2.2/Xkw/Cards.c000066400000000000000000000315051416764561500146200ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include #include #include #include #include #include #include #include #include #include "CardsP.h" #include "cards-svg.h" #define offset(field) XtOffsetOf(CardsRec, cards.field) #define COLOR_UNSET 10 static XtResource resources[] = { {XtNcardWidth, XtCCardWidth, XtRDimension, sizeof(Dimension), offset(card_width), XtRImmediate, (XtPointer) 0}, {XtNoverlap, XtCOverlap, XtRCardsOverlap, sizeof (CardsOverlap), offset(overlap), XtRImmediate, (XtPointer) CardsOverlapNeither}, {XtNback, XtCBack, XtRBitmap, sizeof (Pixmap), offset(back), XtRString, (XtPointer) NULL }, {XtNobverseColor, XtNobverseColor, XtRPixel, sizeof (Pixel), offset(obverse_color), XtRString, (XtPointer) "white"}, {XtNinverseColor, XtCInverseColor, XtRPixel, sizeof (Pixel), offset(inverse_color), XtRString, (XtPointer) "Sea Green"}, {XtNcolor, XtCColor, XtRBoolean, sizeof (Boolean), offset(color), XtRImmediate, (XtPointer) COLOR_UNSET }, }; #undef offset #undef hoffset #include #define ROUND_W 7 #define ROUND_H 7 #define INSET 1 #include "playing_card" #define NUM_RANKS 13 #define NUM_SUITS 4 #define CARDS_PER_DECK 52 #include #include "cards-svg.h" static Boolean any_svg, made_svg; static RsvgHandle *svg_map[CARDS_PER_DECK]; #define SuperClass ((HandWidgetClass)&handClassRec) static void DisplayCallback (Widget gw, XtPointer closure, XtPointer data); static Status GetSize (Display *dpy, Pixmap p, unsigned int *widthp, unsigned int *heightp) { int x, y; unsigned int borderWidth, depth; Window root; return XGetGeometry (dpy, p, &root, &x, &y, widthp, heightp, &borderWidth, &depth); } static inline int CARD_WIDTH(CardsWidget w) { return w->cards.card_width; } static inline int CARD_HEIGHT(CardsWidget w) { return (int) (w->cards.card_width * svg_card_height / svg_card_width); } #define ScreenNo(w) XScreenNumberOfScreen (XtScreen (w)) static void make_card_maps (CardsWidget w); static void setSizeVars (CardsWidget req, CardsWidget new) { Arg args[10]; int i = 0; int col_offset, row_offset; int display_x, display_y, display_width, display_height; Boolean row_major; Boolean row_major_set; (void) req; /* Default card size is based on the DPI value */ if (new->cards.card_width == 0) new->cards.card_width = 100 * new->ksimple.dpi / 72; int width = CARD_WIDTH(new); int height = CARD_HEIGHT(new); XtSetArg (args[i], XtNcardWidth, width); i++; XtSetArg (args[i], XtNcardHeight, height); i++; display_x = 0; display_y = 0; display_width = width; display_height = height; new->cards.offset_other = XkwHandDefaultOffset; row_major_set = False; if (new->cards.overlap & CardsOverlapHorizontal) { row_major = True; row_major_set = True; display_x = ROUND_W; display_width -= display_x * 2; col_offset = CARD_WIDTH(new) / 5; new->cards.offset_other = col_offset / 2; display_x = CARD_WIDTH(new) / 4; display_width = width - display_x * 2; } else { display_y = CARD_WIDTH(new) / 5; display_height = height - display_y * 2; col_offset = width + width / 10; } if (new->cards.overlap & CardsOverlapVertical) { if (!row_major_set) { row_major = False; row_major_set = True; } row_offset = CARD_HEIGHT(new) / 5; if (!row_major) new->cards.offset_other = row_offset / 2; } else row_offset = height + width / 10; XtSetArg (args[i], XtNcolOffset, col_offset); i++; XtSetArg (args[i], XtNrowOffset, row_offset); i++; XtSetArg (args[i], XtNinternalBorderWidth, width / 20); i++; XtSetArg (args[i], XtNdisplayX, display_x); i++; XtSetArg (args[i], XtNdisplayY, display_y); i++; XtSetArg (args[i], XtNdisplayWidth, display_width); i++; XtSetArg (args[i], XtNdisplayHeight, display_height); i++; if (row_major_set) { XtSetArg (args[i], XtNrowMajor, row_major); i++; } XtSetValues ((Widget) new, args, i); } static Boolean CvtStringToCardsOverlap (Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *from, XrmValue *to, XtPointer *converter_data) { char *s = (char *) from->addr; CardsOverlap *result = (CardsOverlap *) to->addr; (void) dpy; (void) args; (void) num_args; (void) converter_data; if (!strcmp (s, "neither")) *result = CardsOverlapNeither; else if (!strcmp (s, "vertical")) *result = CardsOverlapVertical; else if (!strcmp (s, "horizontal")) *result = CardsOverlapHorizontal; else if (!strcmp (s, "both")) *result = CardsOverlapBoth; else return FALSE; return TRUE; } static void ClassInitialize(void) { XkwInitializeWidgetSet(); XtSetTypeConverter ( XtRString, XtRCardsOverlap, CvtStringToCardsOverlap, NULL, (Cardinal)0, XtCacheNone, (XtDestructor)NULL ); } #define CardOffset(w,card) ((card)->suit > CardsSpade ? (w)->cards.offset_other : XkwHandDefaultOffset) XtPointer CardsAddCard (Widget gw, CardsCardPtr card, int row, int col) { CardsWidget w = (CardsWidget) gw; return HandAddCard (gw, (XtPointer) card, row, col, CardOffset(w,card)); } void CardsReplaceCard (Widget gw, XtPointer data, CardsCardPtr card) { CardsWidget w = (CardsWidget) gw; HandReplaceCard (gw, data, (XtPointer) card, CardOffset(w,card)); } #define UsualSuspects(w) Display *dpy = XtDisplay ((Widget) w); \ Window window = XtWindow ((Widget) w) #define UsualDpy(w) Display *dpy = XtDisplay ((Widget) w) #define GetScreen(w) int screen = ScreenNo(w) #define SetClip(dpy,gc,clip,has) if (((clip) != NULL) != *(has)) { \ if ((*(has) = ((clip) != NULL))) \ XSetClipRectangles(dpy, gc, 0, 0, \ clip, 1, YXBanded); \ else \ XSetClipMask(dpy,gc,None); \ } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { CardsWidget req = (CardsWidget) greq, new = (CardsWidget) gnew; (void) args; (void) count; CardDragInit(XtParent(gnew)); new->hand.force_erase = True; setSizeVars (req, new); XtAddCallback (gnew, XtNdisplayCallback, DisplayCallback, (XtPointer) gnew); /* back surface */ Pixmap back = new->cards.back; unsigned int width, height; UsualDpy(new); GetScreen(new); if (back) { GetSize (dpy, back, &width, &height); } else { back = XCreatePixmapFromBitmapData (dpy, RootWindow (dpy, screen), (char *) playing_card_bits, playing_card_width, playing_card_height, new->cards.inverse_color, new->cards.obverse_color, DefaultDepth(dpy, screen)); width = playing_card_width; height = playing_card_height; } cairo_surface_t *back_surface = cairo_xlib_surface_create (dpy, back, XtScreen(new)->root_visual, width, height); new->cards.back_pattern = cairo_pattern_create_for_surface(back_surface); cairo_surface_destroy(back_surface); cairo_pattern_set_extend(new->cards.back_pattern, CAIRO_EXTEND_REPEAT); new->cards.back_delta_x = (CARD_WIDTH(new) - width) / 2; new->cards.back_delta_y = (CARD_HEIGHT(new) - height) / 2; } static void Destroy (Widget gw) { CardsWidget w = (CardsWidget) gw; cairo_pattern_destroy(w->cards.back_pattern); } static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { CardsWidget cur = (CardsWidget) gcur, req = (CardsWidget) greq, new = (CardsWidget) gnew; (void) args; (void) count; new->hand.force_erase = False; any_svg = True; new->hand.force_erase = True; make_card_maps(cur); if (req->cards.overlap != cur->cards.overlap) { setSizeVars (req, new); return TRUE; } return TRUE; } static void make_card_maps(CardsWidget w) { int i; (void) w; if (any_svg && !made_svg) { made_svg = True; for (i = 0; i < CARDS_PER_DECK; i++) svg_map[i] = XkwRsvgCreate(svg_cards[i]); } } static void paint_card(CardsWidget w, cairo_t *cr, CardsRank rank, CardsSuit suit) { int card_number = 0; switch (suit) { case CardsSpade: card_number = 3 * NUM_RANKS; break; case CardsHeart: card_number = 2 * NUM_RANKS; break; case CardsDiamond: card_number = NUM_RANKS; break; case CardsClub: card_number = 0; break; default: break; } card_number += CardsRankToInt (rank); RsvgHandle *rsvg_handle = svg_map[card_number]; if (rsvg_handle) { XkwRsvgDraw(cr, CARD_WIDTH(w), CARD_HEIGHT(w), rsvg_handle); } } static void FillCard (CardsWidget w, cairo_t *cr) { double width, height; double lw; double radius; width = CARD_WIDTH(w); height = CARD_HEIGHT(w); radius = width / 20.0; lw = width / 200.0; cairo_save(cr); cairo_translate(cr, lw/2.0, lw/2.0); XkwDrawRoundedRect(cr, width - lw, height - lw, radius); cairo_fill_preserve(cr); XkwSetSource(cr, &w->ksimple.foreground); cairo_set_line_width(cr, lw); cairo_stroke(cr); cairo_restore(cr); } static void DisplayCallback (Widget gw, XtPointer closure, XtPointer data) { CardsWidget w = (CardsWidget) gw; HandDisplayPtr display = (HandDisplayPtr) data; CardsCardPtr card = (CardsCardPtr) display->private; cairo_t *cr = display->cr; cairo_matrix_t back_matrix; (void) closure; switch (card->suit) { case CardsEmpty: XkwSetSource(cr, &w->ksimple.background); FillCard (w, cr); break; case CardsBack: /* change the origin so cards will have the same back anywhere * on the table */ cairo_matrix_init(&back_matrix, 1, 0, 0, 1, 0, 0); cairo_pattern_set_matrix(w->cards.back_pattern, &back_matrix); cairo_set_source(cr, w->cards.back_pattern); FillCard (w, cr); break; case CardsNone: break; default: paint_card (w, cr, card->rank, card->suit); break; } } static Boolean CardsCardIsEmpty(Widget gw, XtPointer private) { CardsCardRec *card = private; (void) gw; if (!card) return TRUE; if (card->suit == CardsEmpty || card->suit == CardsNone) return TRUE; return FALSE; } CardsClassRec cardsClassRec = { { /* core fields */ /* superclass */ (WidgetClass) SuperClass, /* class_name */ "Cards", /* widget_size */ sizeof(CardsRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ Destroy, /* resize */ XtInheritResize, /* expose */ XtInheritExpose, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ XtInheritTranslations, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* simple fields */ /* change_sensitive */ XtInheritChangeSensitive, #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, { /* hand fields */ .card_is_empty = CardsCardIsEmpty, }, { /* cards fields */ /* ignore */ 0 }, }; WidgetClass cardsWidgetClass = (WidgetClass) &cardsClassRec; kgames-2.2/Xkw/Cards.h000066400000000000000000000064701416764561500146300ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _XtCards_h #define _XtCards_h #include "Hand.h" typedef enum _CardsRank { CardsAce = 1, Cards2 = 2, Cards3 = 3, Cards4 = 4, Cards5 = 5, Cards6 = 6, Cards7 = 7, Cards8 = 8, Cards9 = 9, Cards10 = 10, CardsJack = 11, CardsQueen = 12, CardsKing = 13, CardsRankEmpty = 14 } CardsRank; typedef enum _CardsOverlap { CardsOverlapNeither = 0, CardsOverlapVertical = 1, CardsOverlapHorizontal = 2, CardsOverlapBoth = 3 } CardsOverlap; #define CardsRankToInt(c) ((int) (c) - 1) #define IntToCardsRank(i) ((CardsRank) ((i) + 1)) typedef enum _CardsSuit { CardsClub, CardsDiamond, CardsHeart, CardsSpade, CardsBack, CardsEmpty, CardsNone } CardsSuit; #define CardsSuitToInt(s) ((int) (s)) #define IntToCardsSuit(i) ((int) (i)) typedef struct { CardsRank rank; CardsSuit suit; } CardsCardRec, *CardsCardPtr; /* define exposed functions */ XtPointer CardsAddCard(Widget, CardsCardPtr, int row, int col); void CardsReplaceCard(Widget, XtPointer, CardsCardPtr); char * CardsRankName (CardsRank r); char * CardsSuitName (CardsSuit s); /* Add aliases to stuff which is simply inherited from the Hand widget */ #define CardsRemoveCard HandRemoveCard #define CardsRectangleForCard HandRectangleForCard #define CardsRectangleForPos HandRectangleForPos #define CardsRemoveAllCards HandRemoveAllCards #define CardsXYToPos HandXYToPos #define CardsUpdateDisplay HandUpdateDisplay #define CardsInputRec HandInputRec #define CardsInputPtr HandInputPtr typedef struct _CardsRec *CardsWidget; typedef struct _CardsClassRec *CardsWidgetClass; extern WidgetClass cardsWidgetClass; static inline void CardDragInit(Widget parent) { HandDragInit(parent, cardsWidgetClass); } #define XtNcardWidth "cardWidth" #define XtCCardWidth "CardWidth" #define XtNback "back" #define XtCBack "Back" #define XtNobverseColor "obverseColor" #define XtCObverseColor "ObverseColor" #define XtNinverseColor "inverseColor" #define XtCInverseColor "InverseColor" #define XtNcolor "color" #define XtNoverlap "overlap" #define XtCOverlap "Overlap" #define XtRCardsOverlap "CardsOverlap" #endif /* _XtCards_h */ kgames-2.2/Xkw/CardsP.h000066400000000000000000000046001416764561500147410ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _XtCardsP_h #define _XtCardsP_h #include "Cards.h" #include "HandP.h" /************************************ * * Class structure * ***********************************/ /* * New fields for the Cards widget class record */ typedef struct _CardsClass { int makes_compiler_happy; /* not used */ } CardsClassPart; /* * Full class record declaration */ typedef struct _CardsClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; HandClassPart hand_class; CardsClassPart cards_class; } CardsClassRec; extern CardsClassRec cardsClassRec; typedef struct { /* resources */ double scale; CardsOverlap overlap; Pixmap back; Pixel obverse_color; Pixel inverse_color; Boolean color; Dimension card_width; /* private state */ cairo_pattern_t *back_pattern; int offset_face; int offset_other; int back_delta_x; int back_delta_y; } CardsPart; /* * Full widget declaration */ typedef struct _CardsRec { CorePart core; SimplePart simple; KSimplePart ksimple; HandPart hand; CardsPart cards; } CardsRec; #endif /* _XtCardsP_h */ kgames-2.2/Xkw/CardsUtil.c000066400000000000000000000331131416764561500154530ustar00rootroot00000000000000/* * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include "Cards.h" # include "CardsUtil.h" # include typedef struct _CardHistory *CardHistoryPtr; typedef enum { HistoryMove, HistoryTurn, HistoryCallback, HistoryShuffle } CardHistoryType; typedef struct _CardHistory { CardHistoryPtr prev; CardHistoryType type; int serial; union { struct { CardPtr card; CardFace face; } turn; struct { CardStackPtr source; CardStackPtr dest; CardPtr before; CardPtr first; CardPtr last; } move; struct { void (*func)(void *closure); void *closure; } callback; struct { CardStackPtr stack; CardPtr *cards; int numCards; } shuffle; } u; } CardHistoryRec; static CardHistoryPtr history; static int historySerial; static Boolean canAnimate = True; static void SetShoulds (CardStackPtr stack) { CardPtr card; if (!stack->first) return; switch (stack->display) { case CardDisplayTop: card = stack->last; card->shouldBeUp = True; for (card = card->prev; card; card = card->prev) card->shouldBeUp = False; break; case CardDisplayBottom: card = stack->first; card->shouldBeUp = True; for (card = card->next; card; card = card->next) card->shouldBeUp = False; break; case CardDisplayAll: for (card = stack->first; card; card = card->next) card->shouldBeUp = True; break; case CardDisplayNone: for (card = stack->first; card; card = card->next) card->shouldBeUp = False; break; default: break; } } static void DisplayCards (CardStackPtr stack, CardPtr c) { int row = 0, col = 0; int pos; CardsSuit suit; Boolean animated = !canAnimate; if (stack->horizontal) row = stack->position; else col = stack->position; pos = stack->basePosition;; while (c) { if (stack->horizontal) col = pos; else row = pos; if (c->face == CardFaceDown) suit = CardsBack; else suit = c->card.suit; if (c->isUp && c->shouldBeUp && c->widget == stack->widget && row == c->row && col == c->col && c->data) { if (suit != c->display.suit) { c->display.suit = suit; CardsReplaceCard (c->widget, c->data, &c->display); } } else { if (c->data) { if (c->shouldBeUp && !animated) { Animate (c->widget, c->row, c->col, stack->widget, row, col); animated = True; } CardsRemoveCard (c->widget, c->data); c->data = 0; } if (c->shouldBeUp) { c->display.suit = suit; c->display.rank = c->card.rank; c->row = row; c->col = col; c->widget = stack->widget; c->data = CardsAddCard (c->widget, &c->display, row, col); } c->isUp = c->shouldBeUp; } if (c->isUp) pos++; c = c->next; } } Boolean CardIsInOrder (CardPtr a, CardPtr b) { return a->face == b->face && a->card.rank + 1 == b->card.rank; } Boolean CardIsInRingOrder (CardPtr a, CardPtr b) { return a->face == b->face && (a->card.rank + 1 == b->card.rank || (a->card.rank == CardsKing && b->card.rank == CardsAce)); } Boolean CardIsInSuitOrder (CardPtr a, CardPtr b) { return a->face == b->face && a->card.suit == b->card.suit && CardIsInOrder (a, b); } Boolean CardIsInSuitRingOrder (CardPtr a, CardPtr b) { return a->face == b->face && a->card.suit == b->card.suit && CardIsInRingOrder (a, b); } CardPtr CardInSuitOrder (CardPtr card) { while (card->next && CardIsInSuitOrder (card->next, card)) card = card->next; return card; } CardPtr CardInSuitRingOrder (CardPtr card) { while (card->next && CardIsInSuitRingOrder (card->next, card)) card = card->next; return card; } CardPtr CardInOrder (CardPtr card) { while (card->next && CardIsInOrder (card->next, card)) card = card->next; return card; } CardPtr CardInRingOrder (CardPtr card) { while (card->next && CardIsInRingOrder (card->next, card)) card = card->next; return card; } CardPtr CardInReverseSuitOrder (CardPtr card) { while (card->prev && CardIsInSuitOrder (card, card->prev)) card = card->prev; return card; } CardPtr CardInReverseSuitRingOrder (CardPtr card) { while (card->prev && CardIsInSuitRingOrder (card, card->prev)) card = card->prev; return card; } CardPtr CardInReverseOrder (CardPtr card) { while (card->prev && CardIsInOrder (card, card->prev)) card = card->prev; return card; } CardPtr CardInReverseRingOrder (CardPtr card) { while (card->prev && CardIsInRingOrder (card, card->prev)) card = card->prev; return card; } static Boolean IsAlternateSuit (CardsSuit a, CardsSuit b) { return (a == CardsSpade || a == CardsClub) ^ (b == CardsSpade || b == CardsClub); } Boolean CardIsInAlternatingSuitOrder (CardPtr a, CardPtr b) { return CardIsInOrder (a,b) && IsAlternateSuit (a->card.suit, b->card.suit); } Boolean CardIsInAlternatingSuitRingOrder (CardPtr a, CardPtr b) { return CardIsInRingOrder (a,b) && IsAlternateSuit (a->card.suit, b->card.suit); } CardPtr CardInAlternatingSuitOrder (CardPtr card) { while (card->next && CardIsInAlternatingSuitOrder (card->next, card)) card = card->next; return card; } CardPtr CardInAlternatingSuitRingOrder (CardPtr card) { while (card->next && CardIsInAlternatingSuitRingOrder (card->next, card)) card = card->next; return card; } CardPtr CardInReverseAlternatingSuitOrder (CardPtr card) { while (card->prev && CardIsInAlternatingSuitOrder (card, card->prev)) card = card->prev; return card; } CardPtr CardInReverseAlternatingSuitRingOrder (CardPtr card) { while (card->prev && CardIsInAlternatingSuitRingOrder (card, card->prev)) card = card->prev; return card; } void CardSetAnimate (Boolean animate) { canAnimate = animate; } void CardDisplayStack (CardStackPtr stack) { stack->empty.shouldBeUp = stack->first || stack->empty.card.suit == CardsNone ? False : True; SetShoulds (stack); DisplayCards (stack, stack->first); DisplayCards (stack, &stack->empty); } void CardTurn (CardPtr card, CardFace face, Boolean remember) { if (remember) { CardHistoryPtr h = New(CardHistoryRec); h->u.turn.card = card; h->u.turn.face = card->face; h->type = HistoryTurn; h->prev = history; h->serial = historySerial; history = h; } card->face = face; } void CardMove (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack, Boolean remember) { CardMoveCards (from_stack, from_card, from_stack->last, to_stack, to_stack->last, remember); } static void RemoveStack (CardStackPtr stack, CardPtr first, CardPtr last) { if (first->prev) first->prev->next = last->next; else stack->first = last->next; if (last->next) last->next->prev = first->prev; else stack->last = first->prev; first->prev = 0; last->next = 0; } static void AddStack (CardStackPtr stack, CardPtr first, CardPtr last, CardPtr before) { first->prev = before; if (before) { last->next = before->next; before->next = first; } else { last->next = stack->first; stack->first = first; } if (last->next) last->next->prev = last; else stack->last = last; } void CardMoveCards ( CardStackPtr from_stack, CardPtr first_card, CardPtr last_card, CardStackPtr to_stack, CardPtr to_card, Boolean remember) { if (remember) { CardHistoryPtr h = New(CardHistoryRec); h->u.move.source = from_stack; h->u.move.dest = to_stack; h->u.move.before = first_card->prev; h->u.move.first = first_card; h->u.move.last = last_card; h->type = HistoryMove; h->prev = history; h->serial = historySerial; history = h; } RemoveStack (from_stack, first_card, last_card); AddStack (to_stack, first_card, last_card, to_card); } void CardInitStack (CardStackPtr stack, Widget widget, CardsSuit emptySuit, Boolean horizontal, int position, CardDisplay display) { CardPtr empty; stack->first = stack->last = 0; stack->widget = widget; stack->horizontal = horizontal; stack->position = position; stack->basePosition = 0; stack->display = display; empty = &stack->empty; empty->card.suit = emptySuit; empty->card.rank = CardsAce; empty->display.suit = emptySuit; empty->display.rank = CardsAce; empty->isUp = False; empty->face = CardFaceUp; empty->next = 0; empty->prev = 0; empty->row = 0; empty->col = 0; empty->data = 0; } void CardGenerateStandardDeck (CardPtr card) { CardsSuit suit; CardsRank rank; for (suit = CardsClub; suit <= CardsSpade; suit++) { for (rank = CardsAce; rank <= CardsKing; rank++) { card->next = card + 1; card->prev = card - 1; card->card.suit = suit; card->card.rank = rank; card->row = -1; card->data = 0; card->face = CardFaceDown; card->shouldBeUp = True; card->isUp = False; card++; } } card[-1].next = 0; card[-52].prev = 0; } int CardRandom (void) { static int been_here; #if 0 static int random_fd; static int random_tried; unsigned char buf[2]; if (!random_tried) { random_fd = open ("/dev/urandom", 0); random_tried = 1; } if (random_fd != -1) { if (read (random_fd, buf, 2) == 2) return buf[0] | (buf[1] << 8); close (random_fd); random_fd = -1; } #endif if (!been_here) { srandom (getpid () ^ time (0)); been_here = 1; } return random (); } void CardShuffle (CardStackPtr stack, Boolean remember) { CardPtr card, *save; int numCards; CardPtr *shuffle, *shuf; int i; int r; numCards = 0; for (card = stack->first; card; card = card->next) ++numCards; save = 0; if (remember) { CardHistoryPtr h = New(CardHistoryRec); h->u.shuffle.stack = stack; h->u.shuffle.cards = Some (CardPtr, numCards); h->u.shuffle.numCards = numCards; h->type = HistoryShuffle; h->prev = history; h->serial = historySerial; history = h; save = h->u.shuffle.cards; } shuffle = Some (CardPtr, numCards); shuf = shuffle; for (card = stack->first; card; card = card->next) { if (save) *save++ = card; *shuf++ = card; } for (i = 0; i < numCards - 1; i++) { r = CardRandom (); if (r < 0) r = -r; r = r % (numCards - i) + i; card = shuffle[i]; shuffle[i] = shuffle[r]; shuffle[r] = card; } shuf = shuffle; stack->first = shuffle[0]; stack->last = shuffle[numCards-1]; for (i = 0; i < numCards; i++) { if (i < numCards - 1) shuf[0]->next = shuf[1]; else shuf[0]->next = 0; if (i > 0) shuf[0]->prev = shuf[-1]; else shuf[0]->prev = 0; shuf++; } Dispose (shuffle); } static void Unshuffle (CardStackPtr stack, CardPtr *cards, int numCards) { int i; stack->first = cards[0]; stack->last = cards[numCards-1]; for (i = 0; i < numCards; i++, cards++) { if (i > 0) cards[0]->prev = cards[-1]; else cards[0]->prev = 0; if (i < numCards-1) cards[0]->next = cards[1]; else cards[0]->next = 0; } } void CardInitHistory (void) { CardHistoryPtr h, p; for (h = history; h; h = p) { p = h->prev; if (h->type == HistoryShuffle) Dispose (h->u.shuffle.cards); Dispose (h); } history = 0; historySerial = 0; } void CardRecordHistoryCallback (void (*func)(void *closure), void *closure) { CardHistoryPtr h = New(CardHistoryRec); h->u.callback.func = func; h->u.callback.closure = closure; h->type = HistoryCallback; h->prev = history; h->serial = historySerial; history = h; } Boolean CardUndo (void) { CardHistoryPtr h, p; int serial; if (!history) return False; serial = history->serial; CardSetAnimate(True); for (h = history; h && h->serial == serial; h = p) { p = h->prev; switch (h->type) { case HistoryMove: CardMoveCards (h->u.move.dest, h->u.move.first, h->u.move.last, h->u.move.source, h->u.move.before, False); break; case HistoryTurn: h->u.turn.card->face = h->u.turn.face; break; case HistoryCallback: (*h->u.callback.func) (h->u.callback.closure); break; case HistoryShuffle: Unshuffle (h->u.shuffle.stack, h->u.shuffle.cards, h->u.shuffle.numCards); Dispose (h->u.shuffle.cards); break; } Dispose (h); } history = h; return True; } int CardNextHistory (void) { return historySerial++; } kgames-2.2/Xkw/CardsUtil.h000066400000000000000000000074531416764561500154700ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _CARDS_UTIL_H_ #define _CARDS_UTIL_H_ #include "Xkw/Animate.h" #include "Xkw/Cards.h" #include "Xkw/list.h" typedef struct _Card *CardPtr; typedef enum _CardFace { CardFaceUp, CardFaceDown } CardFace; typedef enum _CardDisplay { CardDisplayTop, CardDisplayBottom, CardDisplayAll, CardDisplaySome, CardDisplayNone } CardDisplay; typedef struct _Card { CardPtr next, prev; CardsCardRec card; CardsCardRec display; CardFace face; Boolean shouldBeUp; Boolean isUp; Widget widget; int row, col; XtPointer data; } CardRec; typedef struct _CardStack *CardStackPtr; typedef struct _CardStack { Widget widget; Boolean horizontal; CardDisplay display; int position; int basePosition; CardPtr first, last; CardRec empty; } CardStackRec; #define New(t) (t *) malloc(sizeof (t)) #define Dispose(p) free((char *) p) #define Some(t,n) (t*) malloc(sizeof(t) * n) #define More(p,t,n) ((p)? (t *) realloc((char *) p, sizeof(t)*n):Some(t,n)) int CardRandom (void); Boolean CardIsInOrder (CardPtr, CardPtr); Boolean CardIsInRingOrder (CardPtr, CardPtr); Boolean CardIsInSuitOrder (CardPtr, CardPtr); Boolean CardIsInSuitRingOrder (CardPtr, CardPtr); Boolean CardIsInAlternatingSuitOrder (CardPtr, CardPtr); Boolean CardIsInAlternatingSuitRingOrder (CardPtr, CardPtr); CardPtr CardInOrder (CardPtr); CardPtr CardInRingOrder (CardPtr); CardPtr CardInSuitOrder (CardPtr); CardPtr CardInSuitRingOrder (CardPtr); CardPtr CardInAlternatingSuitOrder (CardPtr); CardPtr CardInAlternatingSuitRingOrder (CardPtr); void CardSetAnimate (Boolean animate); CardPtr CardInReverseOrder (CardPtr); CardPtr CardInReverseRingOrder (CardPtr); CardPtr CardInReverseSuitOrder (CardPtr); CardPtr CardInReverseSuitRingOrder (CardPtr); CardPtr CardInReverseAlternatingSuitOrder (CardPtr); CardPtr CardInReverseAlternatingSuitRingOrder (CardPtr); void CardDisplayStack (CardStackPtr); static inline CardPtr CardFromHandCard(XtPointer private) { return container_of(private, CardRec, display); } void CardTurn (CardPtr, CardFace, Boolean); void CardMove (CardStackPtr, CardPtr, CardStackPtr, Boolean); void CardMoveCards (CardStackPtr, CardPtr, CardPtr, CardStackPtr, CardPtr, Boolean); void CardRecordHistoryCallback (void (*)(void *), void *); Boolean CardUndo (void); void CardInitStack (CardStackPtr, Widget, CardsSuit, Boolean, int position, CardDisplay display); void CardGenerateStandardDeck (CardPtr); void CardShuffle (CardStackPtr, Boolean remember); void CardInitHistory (void); int CardNextHistory (void); #endif /* _CARDS_UTIL_H_ */ kgames-2.2/Xkw/Dialog.c000066400000000000000000000032451416764561500147630ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include #include #include void XkwDialogAddButton(Widget dialog, _Xconst char* name, XtCallbackProc function, XtPointer param) { /* * Correct Constraints are all set in ConstraintInitialize() */ Widget button; button = XtCreateManagedWidget(name, kcommandWidgetClass, dialog, NULL, 0); if (function != NULL) /* don't add NULL callback func */ XtAddCallback(button, XtNcallback, function, param); } kgames-2.2/Xkw/Draw.c000066400000000000000000000051231416764561500144560ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include void XkwDrawRoundedRect(cairo_t *cr, double width, double height, double radius) { cairo_move_to(cr, radius, 0); /* top */ cairo_line_to(cr, width - radius, 0); /* top right */ cairo_arc(cr, width - radius, radius, radius, -M_PI/2, 0); /* right */ cairo_line_to(cr, width, height - radius); /* bottom right */ cairo_arc(cr, width - radius, height - radius, radius, 0, M_PI/2); /* bottom */ cairo_line_to(cr, radius, height); /* bottom left */ cairo_arc(cr, radius, height - radius, radius, M_PI/2, M_PI); /* left */ cairo_line_to(cr, 0, radius); /* top left */ cairo_arc(cr, radius, radius, radius, M_PI, M_PI * 3 / 2); } void XkwDrawOval(cairo_t *cr, double width, double height) { if (width >= height) { double radius = height / 2.0; cairo_move_to(cr, radius, 0); /* top */ cairo_line_to(cr, width - radius, 0); /* right */ cairo_arc(cr, width - radius, radius, radius, -M_PI/2, M_PI/2); /* bottom */ cairo_line_to(cr, radius, height); /* left */ cairo_arc(cr, radius, radius, radius, M_PI/2, M_PI * 3/2); } else { double radius = width / 2.0; cairo_move_to(cr, width, radius); /* right */ cairo_line_to(cr, width, height - radius); /* bottom */ cairo_arc(cr, radius, height - radius, radius, 0, M_PI); /* left */ cairo_line_to(cr, 0, radius); /* top */ cairo_arc(cr, radius, radius, radius, -M_PI, 0); } } kgames-2.2/Xkw/Events.c000066400000000000000000000116401416764561500150260ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include typedef struct { Position x, y; } XkwPosition; static void XkwTranslateOffset(Widget to, Widget from, XkwPosition *p) { Position to_x, to_y; Position from_x, from_y; XtTranslateCoords(to, 0, 0, &to_x, &to_y); XtTranslateCoords(from, 0, 0, &from_x, &from_y); p->x = from_x - to_x; p->y = from_y - to_y; } void XkwTranslateCoordsPosition(Widget to, Widget from, Position *x, Position *y) { XkwPosition p; XkwTranslateOffset(to, from, &p); *x += p.x; *y += p.y; } void XkwTranslateCoordsInt(Widget to, Widget from, int *x, int *y) { XkwPosition p; XkwTranslateOffset(to, from, &p); *x += p.x; *y += p.y; } void XkwGetEventCoordPointers(XEvent *e, XkwEventCoordPointers *cp) { *cp = (XkwEventCoordPointers) { 0 }; switch(e->type) { case MotionNotify: cp->x = &e->xmotion.x; cp->y = &e->xmotion.y; cp->x_root = &e->xmotion.x_root; cp->y_root = &e->xmotion.y_root; cp->window = &e->xmotion.window; break; case ButtonPress: case ButtonRelease: cp->x = &e->xbutton.x; cp->y = &e->xbutton.y; cp->x_root = &e->xbutton.x_root; cp->y_root = &e->xbutton.y_root; cp->window = &e->xbutton.window; break; case KeyPress: case KeyRelease: cp->x = &e->xkey.x; cp->y = &e->xkey.y; cp->x_root = &e->xkey.x_root; cp->y_root = &e->xkey.y_root; cp->window = &e->xkey.window; break; case EnterNotify: case LeaveNotify: cp->x = &e->xcrossing.x; cp->y = &e->xcrossing.y; cp->x_root = &e->xcrossing.x_root; cp->y_root = &e->xcrossing.y_root; cp->window = &e->xcrossing.window; break; case FocusIn: case FocusOut: cp->window = &e->xfocus.window; break; case Expose: cp->x = &e->xexpose.x; cp->y = &e->xexpose.y; cp->window = &e->xexpose.window; break; } } void XkwTranslateEvent(Widget to, Widget from, XEvent *e) { XkwEventCoordPointers c; XkwGetEventCoordPointers(e, &c); if (c.x) { XkwPosition p; XkwTranslateOffset(to, from, &p); *c.x += p.x; *c.y += p.y; if (c.x_root) { *c.x_root += p.x; *c.y_root += p.y; } } if (c.window) *c.window = XtWindow(to); } Bool XkwGetEventCoords(XEvent *e, Position *x, Position *y) { XkwEventCoordPointers c; XkwGetEventCoordPointers(e, &c); if (c.x) { *x = *c.x; *y = *c.y; return TRUE; } return FALSE; } #define ForAllChildren(pw, childP) \ for ( (childP) = (pw)->composite.children ; \ (childP) < (pw)->composite.children + (pw)->composite.num_children ; \ (childP)++ ) if (!XtIsManaged(*childP)) ; else Widget XkwXYToWidget(Widget w, Position x, Position y) { Dimension width = XtWidth(w), height = XtHeight(w); if (x < 0 || width <= x || y < 0 || height <= y) return NULL; if (XtIsComposite(w)) { CompositeWidget cw = (CompositeWidget) w; Widget *children; Widget child; ForAllChildren(cw, children) { child = *children; w = XkwXYToWidget(child, x - XtX(child), y - XtY(child)); if (w) { Arg arg[1]; Boolean want_forward = True; XtSetArg(arg[0], "wantForward", &want_forward); XtGetValues(w, arg, 1); if (want_forward) break; } } } return w; } Bool XkwForwardEvent(Widget to, Widget from, XEvent *e) { XEvent copy; if (!to) { Widget shell = from; while (!XtIsShell(shell) && XtParent(shell)) shell = XtParent(shell); copy = *e; XkwTranslateEvent(shell, from, ©); Position x, y; if (XkwGetEventCoords(©, &x, &y)) to = XkwXYToWidget(shell, x, y); } if (to == from || !to) return FALSE; if (XtClass(to) != XtClass(from)) return FALSE; copy = *e; XkwTranslateEvent(to, from, ©); XtDispatchEvent(©); return TRUE; } kgames-2.2/Xkw/Hand.c000066400000000000000000000730241416764561500144400ustar00rootroot00000000000000/* $XConsortium: Hand.c,v 1.18 91/07/26 15:21:52 keith Exp $ */ /* * Copyright 1991 Massachusetts Institute of Technology * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ /* * Hand - display collection of cards */ #include #include #include #include #include #include #define offset(field) XtOffsetOf(HandRec, hand.field) static XtResource resources[] = { {XtNcardWidth, XtCCardWidth, XtRDimension, sizeof (Dimension), offset(card_width), XtRImmediate, (XtPointer) 0 }, {XtNcardHeight, XtCCardHeight, XtRDimension, sizeof (Dimension), offset(card_height), XtRImmediate, (XtPointer) 0 }, {XtNdisplayWidth, XtCDisplayWidth, XtRDimension, sizeof (Dimension), offset(display_width), XtRImmediate, (XtPointer) 0 }, {XtNdisplayHeight, XtCDisplayHeight, XtRDimension, sizeof (Dimension), offset(display_height), XtRImmediate, (XtPointer) 0 }, {XtNdisplayX, XtCDisplayX, XtRDimension, sizeof (Dimension), offset(display_x), XtRImmediate, (XtPointer) 0 }, {XtNdisplayY, XtCDisplayY, XtRDimension, sizeof (Dimension), offset(display_y), XtRImmediate, (XtPointer) 0 }, {XtNinternalBorderWidth, XtCInternalBorderWidth, XtRDimension, sizeof (Dimension), offset(internal_border), XtRImmediate, (XtPointer) 0}, {XtNnumRows, XtCNumRows, XtRDimension, sizeof (Dimension), offset(num_rows), XtRImmediate, (XtPointer) 1 }, {XtNnumCols, XtCNumCols, XtRDimension, sizeof (Dimension), offset(num_cols), XtRImmediate, (XtPointer) 1 }, {XtNrowsHint, XtCRowsHint, XtRBoolean, sizeof (Boolean), offset(rows_hint), XtRImmediate, (XtPointer) False}, {XtNcolsHint, XtCColsHint, XtRBoolean, sizeof (Boolean), offset(cols_hint), XtRImmediate, (XtPointer) False}, {XtNrowOffset, XtCRowOffset, XtRDimension, sizeof (Dimension), offset(row_offset), XtRImmediate, (XtPointer) 0 }, {XtNcolOffset, XtCColOffset, XtRDimension, sizeof (Dimension), offset(col_offset), XtRImmediate, (XtPointer) 0 }, {XtNrowMajor, XtCRowMajor, XtRBoolean, sizeof (Boolean), offset(row_major), XtRImmediate, (XtPointer) False }, {XtNdisplayCallback, XtCDisplayCallback, XtRCallback, sizeof (XtPointer), offset(display_callback), XtRCallback, (XtPointer) NULL}, {XtNinputCallback, XtCInputCallback, XtRCallback, sizeof (XtPointer), offset(input_callback), XtRCallback, (XtPointer) NULL}, {XtNrowInsert, XtCInsert, XtRBoolean, sizeof (Boolean), offset(row_insert), XtRImmediate, (XtPointer) False}, {XtNcolInsert, XtCInsert, XtRBoolean, sizeof (Boolean), offset(col_insert), XtRImmediate, (XtPointer) False}, {XtNimmediateUpdate, XtCImmediateUpdate, XtRBoolean, sizeof (Boolean), offset(immediate_update), XtRImmediate, (XtPointer) True}, {XtNselect, XtCSelect, XtRHandSelect, sizeof(HandSelect), offset(select), XtRImmediate, (XtPointer) HandSelectOverlap}, }; #undef offset static char defaultTranslations[] = "Shift: expand()\n" "Shift: stop()\n" ": zoomout()\n" ":\n" ": zoomin()\n" ":\n" ": start()\n" ": drag()\n" ": stop()\n" ": start()\n" ": drag()\n" ": stop()\n" ": start()\n" ": drag()\n" ": stop()"; #define SuperClass ((KSimpleWidgetClass)&ksimpleClassRec) static int handWidth (HandWidget w, int num_cols) { return w->hand.card_width + 2 * w->hand.internal_border + (num_cols - 1) * w->hand.col_offset; } static int handHeight (HandWidget w, int num_rows) { return w->hand.card_height + 2 * w->hand.internal_border + (num_rows - 1) * w->hand.row_offset; } static void getHandSize (HandWidget w, Dimension *widthp, Dimension *heightp) { *widthp = handWidth (w, w->hand.num_cols); *heightp = handHeight (w, w->hand.num_rows); } static int BestOffset (int want, int have, int desired, int item_size, int num_items) { int val, min; int last_showing; if (want <= have || num_items <= 1) return desired; if (have < 0) have = 0; last_showing = item_size; min = item_size / 4; do { last_showing /= 2; val = (have - last_showing) / (num_items - 1); } while (val < min && val < last_showing); if (val > desired) val = desired; return val; } static int BestColOffset (HandWidget w, int num_cols) { int borders = 2 * w->hand.internal_border; return BestOffset (handWidth (w, num_cols) - borders, w->core.width - borders, w->hand.col_offset, w->hand.card_width, num_cols); } static int BestRowOffset (HandWidget w, int num_rows) { int borders = 2 * w->hand.internal_border; return BestOffset (handHeight (w, num_rows) - borders, w->core.height - borders, w->hand.row_offset, w->hand.card_height, num_rows); } static int ColsInRow (HandWidget w, int row) { int maxCol = -1; CardPtr c; xkw_foreach_rev(c, &w->hand.cards, list) if (c->row == row && c->col > maxCol) maxCol = c->col; return maxCol; } static int RowsInCol (HandWidget w, int col) { int maxRow = -1; CardPtr c; xkw_foreach_rev(c, &w->hand.cards, list) if (c->col == col && c->row > maxRow) maxRow = c->row; return maxRow; } static int XPos (HandWidget w, int row, int col) { int offset; CardPtr c; int numCol; int numDefault; int defaultOffset; int lastCol; if (w->hand.row_major) { numCol = ColsInRow (w, row) + 1; if (w->hand.cols_hint) defaultOffset = BestColOffset (w, numCol); else defaultOffset = w->hand.real_col_offset; lastCol = 0; offset = 0; numDefault = 0; xkw_foreach_rev(c, &w->hand.cards, list) { if (c->row == row && c->col >= lastCol && c->col < col) { numDefault += (c->col - lastCol); if (c->offset == XkwHandDefaultOffset || c->offset > defaultOffset) numDefault++; else offset += c->offset; lastCol = c->col + 1; } } if (col > lastCol) numDefault += (col - lastCol); if (numDefault) offset += numDefault * defaultOffset; } else offset = col * w->hand.real_col_offset; return offset + w->hand.internal_border; } static int ColFromX (HandWidget w, int x, int row) { int offset; int adjust; int x1, x2; int col; if (w->hand.row_major) { x2 = w->hand.internal_border; for (col = 1; ; col++) { x1 = x2; x2 = XPos (w, row, col); adjust = 0; if (x2 - x1 > w->hand.card_width) adjust = ((x2 - x1) - w->hand.card_width) / 2; if (x < x2 - adjust) return col - 1; } } else { offset = w->hand.real_col_offset; adjust = -w->hand.internal_border; if (offset > w->hand.card_width) adjust += (offset - w->hand.card_width) / 2; return (x + adjust) / offset; } } static int YPos (HandWidget w, int row, int col) { CardPtr c; int offset; int numRow; int numDefault; int defaultOffset; int lastRow; if (!w->hand.row_major) { numRow = RowsInCol (w, col) + 1; if (w->hand.rows_hint) defaultOffset = BestRowOffset (w, numRow); else defaultOffset = w->hand.real_row_offset; lastRow = 0; offset = 0; numDefault = 0; xkw_foreach_rev(c, &w->hand.cards, list) { if (c->col == col && c->row >= lastRow && c->row < row) { numDefault += (c->row - lastRow); if (c->offset == XkwHandDefaultOffset || c->offset > defaultOffset) numDefault++; else offset += c->offset; lastRow = c->row + 1; } } if (row > lastRow) numDefault += (row - lastRow); if (numDefault) offset += numDefault * defaultOffset; } else offset = row * w->hand.real_row_offset; return offset + w->hand.internal_border; } static int RowFromY (HandWidget w, int y, int col) { int offset; int adjust; int y1, y2; int row; if (!w->hand.row_major) { y2 = w->hand.internal_border; for (row = 1; ; row++) { y1 = y2; y2 = YPos (w, row, col); adjust = 0; if (y2 - y1 > w->hand.card_height) adjust = ((y2 - y1) - w->hand.card_height) / 2; if (y < y2 - adjust) return row - 1; } } else { offset = w->hand.real_row_offset; adjust = -w->hand.internal_border; if (offset > w->hand.card_height) adjust += (offset - w->hand.card_height) / 2; return (y + adjust) / offset; } } static void preferredSize(HandWidget w, Dimension *width, Dimension *height) { CardPtr c; int max_x = 0, max_y = 0; xkw_foreach_rev(c, &w->hand.cards, list) { int x = XPos(w, c->row, c->col); int y = YPos(w, c->row, c->col); if (x > max_x) max_x = x; if (y > max_y) max_y = y; } *width = max_x + w->hand.card_width; *height = max_y + w->hand.card_height; } static Boolean CvtStringToHandSelect (Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *from, XrmValue *to, XtPointer *converter_data) { char *s = (char *) from->addr; HandSelect *result = (HandSelect *) to->addr; (void) dpy; (void) args; (void) num_args; (void) converter_data; if (!strcmp (s, "overlap")) *result = HandSelectOverlap; else if (!strcmp (s, "one")) *result = HandSelectOne; else if (!strcmp (s, "all")) *result = HandSelectAll; else return FALSE; return TRUE; } static void ClassInitialize(void) { XtSetTypeConverter (XtRString, XtRHandSelect, CvtStringToHandSelect, NULL, (Cardinal)0, XtCacheNone, (XtDestructor)NULL); } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { HandWidget req = (HandWidget) greq, new = (HandWidget) gnew; (void) args; (void) count; getHandSize (req, &new->core.width, &new->core.height); new->hand.real_row_offset = new->hand.row_offset; new->hand.real_col_offset = new->hand.col_offset; new->hand.damage = NULL; xkw_list_init(&new->hand.cards); } #define MotionMask ( \ PointerMotionMask | Button1MotionMask | \ Button2MotionMask | Button3MotionMask | Button4MotionMask | \ Button5MotionMask | ButtonMotionMask ) #define PointerGrabMask ( \ ButtonPressMask | ButtonReleaseMask | \ EnterWindowMask | LeaveWindowMask | \ PointerMotionHintMask | KeymapStateMask | \ MotionMask ) static void Realize (Widget widget, XtValueMask *value_mask, XSetWindowAttributes *attributes) { *value_mask |= CWBitGravity; attributes->bit_gravity = NorthWestGravity; (*SuperClass->core_class.realize)(widget, value_mask, attributes); } static void Destroy (Widget gw) { HandWidget w = (HandWidget) gw; CardPtr c; xkw_foreach(c, &w->hand.cards, list) Dispose (c); if (w->hand.update_proc) XtRemoveWorkProc(w->hand.update_proc); } static XtGeometryResult QueryGeometry (Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *prefered) { HandWidget w = (HandWidget) gw; Dimension width, height; XtGeometryResult result; getHandSize (w, &width, &height); result = XtGeometryYes; prefered->request_mode = 0; if (intended->request_mode & CWWidth) { if (intended->width != width) { if (width == w->core.width) { result = XtGeometryNo; } else if (result != XtGeometryNo) { prefered->request_mode |= CWWidth; prefered->width = width; result = XtGeometryAlmost; } } } if (intended->request_mode & CWHeight) { if (intended->height != height) { if (height == w->core.height) { result = XtGeometryNo; } else if (result != XtGeometryNo) { prefered->request_mode |= CWHeight; prefered->height = height; result = XtGeometryAlmost; } } } return result; } static Bool XYInCard (HandWidget w, CardPtr c, int x, int y) { return c->x <= x && x < c->x + w->hand.card_width && c->y <= y && y < c->y + w->hand.card_height; } static CardPtr XYToCard (HandWidget w, int x, int y) { CardPtr c; xkw_foreach(c, &w->hand.cards, list) { if (XYInCard (w, c, x, y)) return c; } return NULL; } /* Start location information */ static HandLocation start_location; /* where the drag started */ static Boolean expanding; static void DoInputCallback(Widget gw, Action action, XEvent *event, String *params, Cardinal *num_params) { HandWidget w = (HandWidget) gw; CardPtr c; HandInputRec input; int row, col; XtPointer private; HandAction hand_action; Position x = event->xmotion.x; Position y = event->xmotion.y; c = XYToCard (w, x, y); if (c) { row = c->row; col = c->col; private = c->private; } else { if (w->hand.row_major) { row = RowFromY (w, y, -1); col = ColFromX (w, x, row); } else { col = ColFromX (w, x, -1); row = RowFromY (w, y, col); } if (row < 0) row = 0; else if (w->hand.row_major && w->hand.num_rows <= row) row = w->hand.num_rows - 1; if (col < 0) col = 0; else if (!w->hand.row_major && w->hand.num_cols <= col) col = w->hand.num_cols - 1; private = 0; } input.current.w = gw; input.current.x = x; input.current.y = y; input.current.row = row; input.current.col = col; input.current.card = c; input.current.private = private; input.current.dragging = FALSE; switch (action) { case ActionExpand: start_location = input.current; hand_action = HandActionExpand; expanding = TRUE; break; case ActionStart: start_location = input.current; hand_action = HandActionStart; expanding = FALSE; break; case ActionDrag: { Position w_x = x; Position w_y = y; Position dx, dy; Dimension motion_min = (w->hand.card_width * w->hand.card_height) / 100; XkwTranslateCoordsPosition(start_location.w, gw, &w_x, &w_y); dx = w_x - start_location.x; dy = w_y - start_location.y; hand_action = HandActionStart; if (dx * dx + dy * dy >= motion_min) start_location.dragging = TRUE; if (!start_location.dragging) return; break; } case ActionStop: if (expanding) hand_action = HandActionUnexpand; else if (start_location.dragging) hand_action = HandActionDrag; else hand_action = HandActionClick; break; } input.start = start_location; input.action = hand_action; input.params = params; input.num_params = num_params; HandDrag(&input, action); if (action != ActionDrag) XtCallCallbackList ((Widget) w, w->hand.input_callback, (XtPointer) &input); } static void StartAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { DoInputCallback(gw, ActionStart, event, params, num_params); } static void DragAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { DoInputCallback(gw, ActionDrag, event, params, num_params); } static void StopAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { if (!XkwForwardEvent(NULL, gw, event)) DoInputCallback(gw, ActionStop, event, params, num_params); } static void ZoomInAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { (void) gw; (void) event; (void) params; (void) num_params; } static void ZoomOutAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { (void) gw; (void) event; (void) params; (void) num_params; } static void ExpandAction (Widget gw, XEvent *event, String *params, Cardinal *num_params) { DoInputCallback(gw, ActionExpand, event, params, num_params); } void HandCardRectangle(HandWidget w, CardPtr card, XRectangle *c) { c->x = card->x; c->y = card->y; c->width = w->hand.card_width; c->height = w->hand.card_height; } static void DamageCard(HandWidget w, CardPtr card) { XRectangle c; if (card->shown) { HandCardRectangle(w, card, &c); if (!w->hand.damage) w->hand.damage = XCreateRegion(); XUnionRectWithRegion(&c, w->hand.damage, w->hand.damage); } } Bool HandCardInRegion (HandWidget w, CardPtr card, Region region) { if (region == NULL) return True; XRectangle c; HandCardRectangle(w, card, &c); return XRectInRegion(region, c.x, c.y, c.width, c.height); } static void UpdateCards (HandWidget w) { CardPtr c; xkw_foreach_rev(c, &w->hand.cards, list) { int x = XPos(w, c->row, c->col); int y = YPos(w, c->row, c->col); if (!c->shown || x != c->x || y != c->y) { if (c->shown) DamageCard(w, c); c->x = x; c->y = y; c->shown = True; DamageCard(w, c); } } } static void Redisplay (Widget gw, XEvent *event, Region region); static void EraseTimer(XtPointer client_data, XtIntervalId *timer) { Widget gw = (Widget) client_data; HandWidget w = (HandWidget) gw; (void) timer; w->hand.erase_proc = 0; Redisplay(gw, NULL, NULL); } /* * widget was resized, adjust row and column offsets. The expose * event will cause the card positions to get recomputed which will * then cause them all to be redrawn */ static void Resize (Widget gw) { HandWidget w = (HandWidget) gw; Dimension col_offset, row_offset; Bool erase = FALSE; if (*SuperClass->core_class.resize != NULL) (*SuperClass->core_class.resize)(gw); /* Reschedule the erase if we resize again */ if (w->hand.erase_proc) erase = TRUE; col_offset = BestColOffset (w, w->hand.num_cols); row_offset = BestRowOffset (w, w->hand.num_rows); /* Check to see if the global offsets change */ if (col_offset != w->hand.real_col_offset || row_offset != w->hand.real_row_offset) { erase = TRUE; w->hand.real_col_offset = col_offset; w->hand.real_row_offset = row_offset; } /* Check to see if any card will move */ if (!erase && (w->hand.rows_hint || w->hand.cols_hint)) { CardPtr c; xkw_foreach(c, &w->hand.cards, list) { int x = XPos(w, c->row, c->col); int y = YPos(w, c->row, c->col); if (x != c->x || y != c->y) erase = TRUE; } } /* Schedule a repaint */ if (XtIsRealized(gw) && erase) { if (w->hand.erase_proc) XtRemoveTimeOut(w->hand.erase_proc); w->hand.erase_proc = XtAddTimeOut(10, EraseTimer, gw); } } static void Paint (HandWidget w, Region region) { if (XtIsRealized((Widget) w)) { cairo_t *cr = XkwDrawBegin ((Widget) w, region); HandDisplayRec display; CardPtr c; display.w = (Widget) w; display.cr = cr; /* redisplay cards */ xkw_foreach_rev(c, &w->hand.cards, list) { if (!c->hidden && HandCardInRegion(w, c, region)) { cairo_save(cr); cairo_translate(cr, c->x, c->y); display.private = c->private; XtCallCallbackList ((Widget) w, w->hand.display_callback, (XtPointer) &display); cairo_restore(cr); } } XkwDrawEnd((Widget) w, region, cr); } if (w->hand.damage) { XDestroyRegion(w->hand.damage); w->hand.damage = NULL; } } /* * Redisplay function. Queue the rectangle as an erased area * and redisplay when we've gotten all of the events */ static void Redisplay (Widget gw, XEvent *event, Region region) { HandWidget w = (HandWidget) gw; (void) event; if (!XtIsRealized (gw)) return; if (w->hand.erase_proc) return; UpdateCards(w); if (region && w->hand.damage) { XUnionRegion(region, w->hand.damage, w->hand.damage); region = w->hand.damage; } Paint (w, region); } /* * When values are set which change the desired size, ask for * the new size */ static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { HandWidget cur = (HandWidget) gcur, req = (HandWidget) greq, new = (HandWidget) gnew; Dimension curwidth, curheight, reqwidth, reqheight; Dimension width, height; Bool force_resize = FALSE; (void) args; (void) count; (void) new; if (cur->hand.num_rows != req->hand.num_rows || cur->hand.num_cols != req->hand.num_cols || cur->hand.row_offset != req->hand.row_offset || cur->hand.col_offset != req->hand.col_offset) force_resize = TRUE; getHandSize (cur, &curwidth, &curheight); getHandSize (req, &reqwidth, &reqheight); if (curwidth != reqwidth || curheight != reqheight || force_resize) { XtMakeResizeRequest (gnew, reqwidth, reqheight, &width, &height); if (width != curwidth || height != curheight || force_resize) Resize (gnew); } return TRUE; } void HandUpdateDisplay (Widget gw) { HandWidget w = (HandWidget) gw; UpdateCards (w); if (w->hand.damage) Paint(w, w->hand.damage); } void HandSetPreferredSize (Widget gw) { HandWidget w = (HandWidget) gw; Dimension width, height; Dimension curwidth = XtWidth(gw); Dimension curheight = XtHeight(gw); preferredSize(w, &width, &height); if (width != curwidth || height != curheight) { XtMakeResizeRequest (gw, width, height, &width, &height); if (width != curwidth || height != curheight) Resize (gw); } } /* Insert a card */ XtPointer HandAddCard (Widget gw, XtPointer private, int row, int col, int offset) { HandWidget w = (HandWidget) gw; CardPtr c, sib; int maxPos; /* compute values for row/col if requested */ if (row == InsertRow) { maxPos = -1; xkw_foreach(c, &w->hand.cards, list) { if (w->hand.row_major) { if (c->row > maxPos) maxPos = c->row; } else { if (c->col == col && c->row > maxPos) maxPos = c->row; } } row = maxPos + 1; } if (col == InsertCol) { maxPos = -1; xkw_foreach(c, &w->hand.cards, list) { if (!w->hand.row_major) { if (c->col > maxPos) maxPos = c->col; } else { if (c->row == row && c->col > maxPos) maxPos = c->col; } } col = maxPos + 1; } /* find the card below this one */ sib = (CardPtr) &w->hand.cards; xkw_foreach_rev(c, &w->hand.cards, list) { if (w->hand.row_major) { if ((c->row == row && c->col <= col) || c->row < row) sib = c; else break; } else { if ((c->col == col && c->row <= row) || c->col < col) sib = c; else break; } } c = New(CardRec); c->private = private; c->row = row; c->col = col; c->offset = offset; c->shown = False; c->hidden = False; /* insert the new card on the list */ xkw_list_append(&c->list, &sib->list); /* adjust higher cards rows */ if (w->hand.row_insert) { xkw_foreach_startat_rev(sib, xkw_prev(c, list), &w->hand.cards, list) if (sib->col == c->col && sib->row == row) sib->row = ++row; } /* adjust higher cards columns */ if (w->hand.col_insert) { xkw_foreach_startat_rev(sib, xkw_prev(c, list), &w->hand.cards, list) if (sib->row == c->row && sib->col == col) sib->col = ++col; } if (XtIsRealized(gw) && w->hand.immediate_update) HandUpdateDisplay (gw); return (XtPointer) c; } /* remove a card */ void HandRemoveCard (Widget gw, XtPointer card) { HandWidget w = (HandWidget) gw; CardPtr c, sib; int row, col; Bool found = FALSE; xkw_foreach(c, &w->hand.cards, list) if (c == (CardPtr) card) { found = TRUE; break; } if (!found) return; if (w->hand.row_insert) { row = c->row; xkw_foreach_startat_rev(sib, xkw_prev(c, list), &w->hand.cards, list) if (sib->col == c->col && sib->row == row + 1) sib->row = row++; } if (w->hand.col_insert) { col = c->col; xkw_foreach_startat_rev(sib, xkw_prev(c, list), &w->hand.cards, list) if (sib->row == c->row && sib->col == col + 1) sib->col = col++; } xkw_list_del(&c->list); DamageCard(w, c); Dispose (c); if (XtIsRealized (gw) && w->hand.immediate_update) HandUpdateDisplay (gw); } /* change the private value for a card and force a redisplay */ void HandReplaceCard (Widget gw, XtPointer card, XtPointer private, int offset) { HandWidget w = (HandWidget) gw; CardPtr c; Bool found = FALSE; xkw_foreach(c, &w->hand.cards, list) if (c == (CardPtr) card) { found = TRUE; break; } if (!found) return; c->private = private; c->offset = offset; DamageCard(w, c); if (XtIsRealized (gw) && w->hand.immediate_update) HandUpdateDisplay (gw); } void HandRectangleForPos (Widget gw, int row, int col, XRectangle *r) { HandWidget w = (HandWidget) gw; r->x = XPos (w, row, col); r->y = YPos (w, row, col); r->width = w->hand.card_width; r->height = w->hand.card_height; } #if 0 static void HandRectangleForCard (Widget gw, XtPointer card, XRectangle *r) { HandWidget w = (HandWidget) gw; CardPtr c; Bool found = FALSE; xkw_foreach(c, &w->hand.cards, list) if (c == (CardPtr) card) { found = TRUE; break; } if (!found) { r->x = 0; r->y = 0; r->width = 0; r->height = 0; } else HandRectangleForPos (gw, c->row, c->col, r); } static Boolean HandXYToPos (Widget gw, int x, int y, int *rowp, int *colp) { HandWidget w = (HandWidget) gw; CardPtr c; c = XYToCard (w, x, y); if (c) { *rowp = c->row; *colp = c->col; return True; } return False; } #endif void HandRemoveAllCards (Widget gw) { HandWidget w = (HandWidget) gw; CardPtr c; xkw_foreach(c, &w->hand.cards, list) free ((char *) c); xkw_list_init(&w->hand.cards); if (XtIsRealized (gw)) Redisplay(gw, NULL, NULL); } static Boolean HandUpdateAllCards(XtPointer p) { Widget gw = (Widget) p; HandWidget w = (HandWidget) gw; w->hand.update_proc = 0; if (XtIsRealized(gw)) HandUpdateDisplay(gw); return TRUE; } void HandShowAllCards (Widget gw) { HandWidget w = (HandWidget) gw; CardPtr c; Boolean changed = FALSE; xkw_foreach(c, &w->hand.cards, list) if (c->hidden) { c->hidden = FALSE; changed = TRUE; DamageCard(w, c); } if (changed && XtIsRealized (gw)) { if (!w->hand.update_proc) w->hand.update_proc = XtAddWorkProc(HandUpdateAllCards, (XtPointer) gw); } } void HandHideCard (Widget gw, CardPtr c) { HandWidget w = (HandWidget) gw; c->hidden = TRUE; DamageCard(w, c); if (XtIsRealized (gw) && w->hand.immediate_update) HandUpdateDisplay (gw); } static Boolean HandDefaultCardIsEmpty (Widget gw, XtPointer private) { (void) gw; (void) private; return FALSE; } Boolean HandCardIsEmpty (Widget gw, XtPointer private) { HandClassRec *class = (HandClassRec *) (gw->core.widget_class); return (*class->hand_class.card_is_empty)(gw, private); } static XtActionsRec actions[] = { { "start", StartAction }, /* select card */ { "drag", DragAction }, { "stop", StopAction }, { "zoomin", ZoomInAction }, { "zoomout", ZoomOutAction }, { "expand", ExpandAction }, }; HandClassRec handClassRec = { { /* core fields */ /* superclass */ (WidgetClass) SuperClass, /* class_name */ "Hand", /* widget_size */ sizeof(HandRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ Realize, /* actions */ actions, /* num_actions */ XtNumber(actions), /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ Destroy, /* resize */ Resize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ defaultTranslations, /* query_geometry */ QueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, { /* hand fields */ .card_is_empty = HandDefaultCardIsEmpty, } }; WidgetClass handWidgetClass = (WidgetClass) &handClassRec; kgames-2.2/Xkw/Hand.h000066400000000000000000000106441416764561500144440ustar00rootroot00000000000000/* * $XConsortium: Hand.h,v 1.5 91/07/25 21:33:53 keith Exp $ */ #ifndef _XtHand_h #define _XtHand_h #include #include /*********************************************************************** * * Hand Widget * ***********************************************************************/ /* Parameters: Name Class RepType Default Value ---- ----- ------- ------------- background Background pixel XtDefaultForeground cardWidth CardWidth Dimension 0 cardHeight CardHeight Dimension 0 displayWidth DisplayWidth Dimension 0 displayHeight DisplayHeight Dimension 0 displayX DisplayX Position 0 displayY DisplayY Position 0 internalBorderWidthInternalBorderWidth Dimension 0 numRows NumRows Dimension 0 numCols NumCols Dimension 0 rowsHint RowsHint Boolean False colsHint ColsHint Boolean False rowOffset RowOffset Dimension 0 colOffset ColOffset Dimension 0 displayCallback DisplayCallback Callback NULL inputCallback InputCallback Callback NULL rowInsert Insert Boolean False colInsert Insert Boolean False immediateUpdate ImmediateUpdate Boolean True */ typedef struct _HandRec *HandWidget; /* completely defined in HandPrivate.h */ typedef struct _HandClassRec *HandWidgetClass; /* completely defined in HandPrivate.h */ extern WidgetClass handWidgetClass; typedef struct _HandDisplay { Widget w; cairo_t *cr; XtPointer private; } HandDisplayRec, *HandDisplayPtr; typedef enum { HandActionStart, HandActionDrag, HandActionClick, HandActionExpand, HandActionUnexpand, } HandAction; typedef enum { HandSelectOverlap, HandSelectOne, HandSelectAll } HandSelect; typedef struct _HandLocation { Widget w; Position x, y; Position row, col; struct _HandCard *card; XtPointer private; Boolean dragging; } HandLocation; typedef struct _HandInput { HandLocation current; HandLocation start; HandAction action; String *params; Cardinal *num_params; } HandInputRec, *HandInputPtr; void HandRectangleForPos (Widget gw, int row, int col, XRectangle *r); typedef struct _HandBasePos { Widget widget; int x, y; } HandBasePosRec, *HandBasePosPtr; XtPointer HandAddCard (Widget gw, XtPointer private, int row, int col, int offset); void HandRemoveCard (Widget gw, XtPointer card); void HandReplaceCard (Widget gw, XtPointer card, XtPointer private, int offset); void HandRemoveAllCards (Widget gw); void HandUpdateDisplay (Widget gw); void HandSetPreferredSize (Widget gw); Boolean HandCardIsEmpty (Widget gw, XtPointer private); void HandDragInit(Widget parent, WidgetClass class); #define InsertRow -1 #define InsertCol -1 #define XkwHandDefaultOffset -32767 #define XtNcardWidth "cardWidth" #define XtCCardWidth "CardWidth" #define XtNcardHeight "cardHeight" #define XtCCardHeight "CardHeight" #define XtNdisplayWidth "displayWidth" #define XtCDisplayWidth "DisplayWidth" #define XtNdisplayHeight "displayHeight" #define XtCDisplayHeight "DisplayHeight" #define XtNdisplayX "displayX" #define XtCDisplayX "DisplayX" #define XtNdisplayY "displayY" #define XtCDisplayY "DisplayY" #define XtNinternalBorderWidth "internalBorderWidth" #define XtCInternalBorderWidth "InternalBorderWidth" #define XtNnumRows "numRows" #define XtCNumRows "NumRows" #define XtNnumCols "numCols" #define XtCNumCols "NumCols" #define XtNrowsHint "rowsHint" #define XtCRowsHint "RowsHint" #define XtNcolsHint "colsHint" #define XtCColsHint "ColsHint" #define XtNcolOffset "colOffset" #define XtCColOffset "ColOffset" #define XtNrowOffset "rowOffset" #define XtCRowOffset "RowOffset" #define XtNredisplay "redisplay" #define XtCRedisplay "Redisplay" #define XtNrowMajor "rowMajor" #define XtCRowMajor "RowMajor" #define XtNdisplayCallback "displayCallback" #define XtCDisplayCallback "DisplayCallback" #define XtNinputCallback "inputCallback" #define XtCInputCallback "InputCallback" #define XtNexpandCallback "expandCallback" #define XtCExpandCallback "ExpandCallback" #define XtNrowInsert "rowInsert" #define XtNcolInsert "colInsert" #define XtCInsert "Insert" #define XtNimmediateUpdate "immediateUpdate" #define XtCImmediateUpdate "ImmediateUpdate" #define XtNselect "select" #define XtCSelect "Select" #define XtRHandSelect "HandSelect" #endif /* _XtHand_h */ /* DON'T ADD STUFF AFTER THIS #endif */ kgames-2.2/Xkw/HandDrag.c000066400000000000000000000124621416764561500152350ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ # include # include # include # include # include "HandP.h" # include static Boolean initialized; static Boolean dragging; static Widget drag; static Widget dragParent; static Position start_x, start_y; static Position off_x, off_y; void HandDragInit(Widget parent, WidgetClass class) { if (!initialized) { Arg arg[3]; initialized = TRUE; drag = XtCreateManagedWidget("draghand", class, parent, NULL, 0); /* Cards widget smashes these values at initialize time, so * force them by using SetValues afterwards */ XtSetArg(arg[0], XtNinternalBorderWidth, 0); XtSetArg(arg[1], XtNwantForward, False); XtSetArg(arg[2], XtNborderWidth, 0); XtSetValues(drag, arg, 3); dragParent = parent; XtSetMappedWhenManaged(drag, FALSE); } } static void Drag (Widget child, Position x, Position y) { XkwTranslateCoordsPosition(dragParent, child, &x, &y); XtWidgetGeometry request = { .x = x, .y = y, .stack_mode = Above, .request_mode = CWX | CWY | CWStackMode }; XtMakeGeometryRequest(drag, &request, NULL); } void HandDrag(HandInputPtr input, Action action) { switch (action) { case ActionStart: start_x = input->start.x; start_y = input->start.y; if (input->start.card) { off_x = start_x - input->start.card->x; off_y = start_y - input->start.card->y; } else { off_x = 0; off_y = 0; } XkwTranslateCoordsPosition(dragParent, input->start.w, &start_x, &start_y); break; case ActionDrag: if (!dragging) { if (!input->start.card) break; if (HandCardIsEmpty(input->start.w, input->start.private)) break; CardPtr c; HandWidget w = (HandWidget) input->start.w; int row = 0; int col = 0; int rows = 0; int cols = 0; Region region = NULL; xkw_foreach_startat_rev(c, input->start.card, &w->hand.cards, list) { Boolean pick = FALSE; switch(w->hand.select) { case HandSelectOverlap: if (!region || HandCardInRegion(w, c, region)) { XRectangle rect; HandCardRectangle(w, c, &rect); if (!region) region = XCreateRegion(); XUnionRectWithRegion(&rect, region, region); pick = TRUE; } break; case HandSelectOne: if (c == input->start.card) pick = TRUE; break; case HandSelectAll: pick = TRUE; break; } if (!pick) break; col = c->col - input->start.col; row = c->row - input->start.row; if (row >= rows) rows = row + 1; if (col >= cols) cols = col + 1; HandHideCard(input->start.w, c); HandAddCard(drag, c->private, row, col, XkwHandDefaultOffset); } if (region) XDestroyRegion(region); Arg args[4]; XtSetArg(args[0], XtNcolOffset, w->hand.col_offset); XtSetArg(args[1], XtNrowOffset, w->hand.row_offset); XtSetArg(args[2], XtNnumRows, rows); XtSetArg(args[3], XtNnumCols, cols); XtSetValues(drag, args, 4); HandSetPreferredSize(drag); } Drag(input->current.w, input->current.x - off_x, input->current.y - off_y); if (!dragging) { dragging = TRUE; XtMapWidget(drag); } break; case ActionStop: if (dragging) { dragging = FALSE; XtUnmapWidget(drag); HandRemoveAllCards(drag); HandShowAllCards(input->start.w); } break; case ActionExpand: break; } } kgames-2.2/Xkw/HandP.h000066400000000000000000000075211416764561500145640ustar00rootroot00000000000000/* * $XConsortium: HandP.h,v 1.9 91/07/26 15:21:49 keith Exp $ */ /* * HandP.h - Private definitions for Hand widget */ #ifndef _XtHandP_h #define _XtHandP_h #include #include "Hand.h" #include #include /*********************************************************************** * * Hand Widget Private Data * ***********************************************************************/ /************************************ * * Class structure * ***********************************/ /* * New fields for the Hand widget class record */ typedef struct _HandClass { Boolean (*card_is_empty)(Widget gw, XtPointer private); } HandClassPart; /* * Full class record declaration */ typedef struct _HandClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; HandClassPart hand_class; } HandClassRec; extern HandClassRec handClassRec; /*************************************** * * Instance (widget) structure * **************************************/ /* * New fields for the Hand widget record */ #define New(t) (t *) malloc(sizeof (t)) #define Dispose(p) free((char *) p) #define Some(t,n) (t*) malloc(sizeof(t) * n) #define More(p,t,n) ((p)? (t *) realloc((char *) p, sizeof(t)*n):Some(t,n) typedef enum { ClipUnclipped, ClipPartclipped, ClipAllclipped } HandClip; typedef enum { ActionExpand, ActionStart, ActionDrag, ActionStop, } Action; typedef struct _HandCard { struct xkw_list list; XtPointer private; int x, y; int row, col; int offset; Boolean shown; Boolean hidden; } CardRec, *CardPtr; void HandShowAllCards (Widget gw); void HandHideCard (Widget gw, CardPtr c); Bool HandCardInRegion (HandWidget w, CardPtr card, Region region); void HandCardRectangle(HandWidget w, CardPtr card, XRectangle *c); void HandDrag(HandInputPtr input, Action action); typedef struct { /* * Resource specifiable values */ Dimension card_width; /* area occupied by card */ Dimension card_height; /* */ Dimension internal_border; /* space around entire hand */ Dimension num_cols; /* number of columns */ Dimension num_rows; /* number of rows */ Dimension col_offset; /* distance to space columns apart */ Dimension row_offset; /* distance to space rows apart */ Position display_x; /* inside display rectangle, */ Position display_y; /* the display func will fill */ Dimension display_width; /* the entire space. Used to */ Dimension display_height; /* optimize redisplay */ Boolean cols_hint; /* number of columns is only a hint */ Boolean rows_hint; /* number of rows is only a hint */ Boolean row_insert; /* when inserting cards, those on */ Boolean col_insert; /* top get moved down/right */ Boolean immediate_update; /* redisplay after every edit */ Boolean row_major; /* stack cards in cols */ Boolean force_erase; /* erase stack even if card replaces */ XtCallbackList display_callback; /* func to display cards */ XtCallbackList input_callback; /* func called on button press */ HandSelect select; /* what cards to select for drag */ /* List of cards could be changed by resource, but easier by func */ struct xkw_list cards; Region damage; /* Damage caused by card changes */ Dimension real_col_offset; /* when widget gets reshaped, */ Dimension real_row_offset; /* the offset values are adjusted */ XtWorkProcId update_proc; XtIntervalId erase_proc; } HandPart; /* * Full widget declaration */ typedef struct _HandRec { CorePart core; SimplePart simple; KSimplePart ksimple; HandPart hand; } HandRec; #endif /* _XtHandP_h */ kgames-2.2/Xkw/Icon.c000066400000000000000000000107431416764561500144550ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include "Xkw.h" #include "cards-svg.h" static Dimension icon_sizes[] = {32, 64, 128}; #define NUM_SIZES (sizeof(icon_sizes)/sizeof(icon_sizes[0])) static unsigned long * XkwIconValue(unsigned long *total_sizep, const char *svg) { unsigned long *value = NULL; unsigned long *pixels; unsigned long total_size; int i; int x, y; RsvgHandle *svg_handle = NULL; svg_handle = XkwRsvgCreate(svg); if (!svg_handle) return NULL; total_size = 0; for (i = 0; i < (int) NUM_SIZES; i++) { total_size += 2; /* width/height */ total_size += icon_sizes[i] * icon_sizes[i]; /* pixels */ } value = calloc(total_size, sizeof(unsigned long)); if (!value) return NULL; pixels = value; for (i = 0; i < (int) NUM_SIZES; i++) { Dimension width = icon_sizes[i]; Dimension height = icon_sizes[i]; *pixels++ = width; *pixels++ = height; uint32_t stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); unsigned char *surface_data = calloc(stride, height); if (!surface_data) goto bail; cairo_surface_t *surface = cairo_image_surface_create_for_data(surface_data, CAIRO_FORMAT_ARGB32, width, height, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width)); if (!surface) { free(surface_data); goto bail; } cairo_t *cr = cairo_create(surface); if (!cr) { free(surface_data); cairo_surface_destroy(surface); goto bail; } XkwRsvgDraw(cr, width, height, svg_handle); cairo_destroy(cr); cairo_surface_destroy(surface); for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { uint8_t a, r, g, b; a = surface_data[y * stride + x * 4 + 3]; r = surface_data[y * stride + x * 4 + 2]; g = surface_data[y * stride + x * 4 + 1]; b = surface_data[y * stride + x * 4 + 0]; uint32_t pixel = (a << 24) | (r << 16) | (g << 8) | (b); pixels[y * width + x] = pixel; } } free(surface_data); pixels += width * height; } XkwRsvgDestroy(svg_handle); *total_sizep = total_size; return value; bail: if (value) free(value); if (svg_handle) XkwRsvgDestroy(svg_handle); return NULL; } void XkwSetIcon(Widget toplevel, const char *svg) { unsigned long *value; unsigned long size; Atom _net_wm_icon = XInternAtom(XtDisplay(toplevel), "_NET_WM_ICON", FALSE); value = XkwIconValue(&size, svg); if (value) { XChangeProperty(XtDisplay(toplevel), XtWindow(toplevel), _net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) value, (int) size); free(value); } } void XkwSetCardIcon(Widget toplevel) { XkwSetIcon(toplevel, svg_card_game); } kgames-2.2/Xkw/KCommand.c000066400000000000000000000365251416764561500152640ustar00rootroot00000000000000/*********************************************************** Copyright 1987, 1988, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Digital not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ /* * KCommand.c - Command button widget */ #include #include #include #include #include #include #include #include #define DEFAULT_HIGHLIGHT_THICKNESS 2 #define DEFAULT_SHAPE_HIGHLIGHT 32767 #define STR_EQUAL(str1, str2) (str1 == str2 || strcmp(str1, str2) == 0) /* * Class Methods */ static void XkwKCommandClassInitialize(void); static void XkwKCommandInitialize(Widget, Widget, ArgList, Cardinal*); static void XkwKCommandRealize(Widget, Mask*, XSetWindowAttributes*); static void XkwKCommandResize(Widget); static void XkwKCommandRedisplay(Widget, XEvent*, Region); static Boolean XkwKCommandSetValues(Widget, Widget, Widget, ArgList, Cardinal*); static void XkwKCommandGetValuesHook(Widget, ArgList, Cardinal*); /* * Prototypes */ static void PaintKCommandWidget(Widget, XEvent*, Region, Bool); static Region HighlightRegion(KCommandWidget); static void XkwKCommandToggle(Widget); /* * Actions */ static void Highlight(Widget, XEvent*, String*, Cardinal*); static void Notify(Widget, XEvent*, String*, Cardinal*); static void Reset(Widget, XEvent*, String*, Cardinal*); static void Set(Widget, XEvent*, String*, Cardinal*); static void Unhighlight(Widget, XEvent*, String*, Cardinal*); static void Unset(Widget, XEvent*, String*, Cardinal*); /* * Initialization */ static char defaultTranslations[] = ":" "highlight()\n" ":" "reset()\n" ":" "set()\n" ":" "notify() unset()\n" ; #define offset(field) XtOffsetOf(KCommandRec, kcommand.field) static XtResource resources[] = { { XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(callbacks), XtRCallback, NULL }, { XtNhighlightThickness, XtCThickness, XtRDimension, sizeof(Dimension), offset(highlight_thickness), XtRImmediate, (XtPointer)DEFAULT_SHAPE_HIGHLIGHT }, { XtNshapeStyle, XtCShapeStyle, XtRShapeStyle, sizeof(int), offset(shape_style), XtRImmediate, (XtPointer)XmuShapeRectangle }, { XtNcornerRoundPercent, XtCCornerRoundPercent, XtRDimension, sizeof(Dimension), offset(corner_round), XtRImmediate, (XtPointer)25 }, }; #undef offset static XtActionsRec actionsList[] = { {"set", Set}, {"notify", Notify}, {"highlight", Highlight}, {"reset", Reset}, {"unset", Unset}, {"unhighlight", Unhighlight} }; #define SuperClass ((KLabelWidgetClass)&klabelClassRec) /* * Implementation */ /*ARGSUSED*/ static void XkwKCommandInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KCommandWidget cbw = (KCommandWidget)cnew; (void) request; (void) args; (void) num_args; cbw->kcommand.set = False; cbw->kcommand.highlighted = HighlightNone; } static Region HighlightRegion(KCommandWidget cbw) { static Region outerRegion = NULL, innerRegion, emptyRegion; XRectangle rect; if (cbw->kcommand.highlight_thickness == 0 || cbw->kcommand.highlight_thickness > Min(XtWidth(cbw), XtHeight(cbw)) / 2) return (NULL); if (outerRegion == NULL) { /* save time by allocating scratch regions only once. */ outerRegion = XCreateRegion(); innerRegion = XCreateRegion(); emptyRegion = XCreateRegion(); } rect.x = rect.y = 0; rect.width = XtWidth(cbw); rect.height = XtHeight(cbw); XUnionRectWithRegion(&rect, emptyRegion, outerRegion); rect.x = rect.y = cbw->kcommand.highlight_thickness; rect.width -= cbw->kcommand.highlight_thickness * 2; rect.height -= cbw->kcommand.highlight_thickness * 2; XUnionRectWithRegion(&rect, emptyRegion, innerRegion); XSubtractRegion(outerRegion, innerRegion, outerRegion); return (outerRegion); } /*************************** * Action Procedures ***************************/ static void XkwKCommandToggle(Widget w) { KCommandWidget kcw = (KCommandWidget)w; Arg args[2]; Cardinal num_args; XRenderColor foreground = kcw->ksimple.background; XRenderColor background = kcw->ksimple.foreground; num_args = 0; XkwSetArg(args[num_args], XtNbackgroundColor, &background); ++num_args; XkwSetArg(args[num_args], XtNforegroundColor, &foreground); ++num_args; XtSetValues(w, args, num_args); } /*ARGSUSED*/ static void Set(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; (void) event; (void) params; (void) num_params; if (cbw->kcommand.set) return; XkwKCommandToggle(w); cbw->kcommand.set= True; } /*ARGSUSED*/ static void Unset(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; (void) event; (void) params; (void) num_params; if (!cbw->kcommand.set) return; cbw->kcommand.set = False; XkwKCommandToggle(w); } /*ARGSUSED*/ static void Reset(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; if (cbw->kcommand.set) { cbw->kcommand.highlighted = HighlightNone; Unset(w, event, params, num_params); } else Unhighlight(w, event, params, num_params); } /*ARGSUSED*/ static void Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; if (*num_params == (Cardinal)0) cbw->kcommand.highlighted = HighlightWhenUnset; else { if (*num_params != (Cardinal)1) XtWarning("Too many parameters passed to highlight action table."); switch (params[0][0]) { case 'A': case 'a': cbw->kcommand.highlighted = HighlightAlways; break; default: cbw->kcommand.highlighted = HighlightWhenUnset; break; } } if (XtIsRealized(w)) PaintKCommandWidget(w, event, HighlightRegion(cbw), True); } /*ARGSUSED*/ static void Unhighlight(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; (void) event; (void) params; (void) num_params; cbw->kcommand.highlighted = HighlightNone; if (XtIsRealized(w)) PaintKCommandWidget(w, event, HighlightRegion(cbw), True); } /*ARGSUSED*/ static void Notify(Widget w, XEvent *event, String *params, Cardinal *num_params) { KCommandWidget cbw = (KCommandWidget)w; (void) event; (void) params; (void) num_params; /* check to be sure state is still Set so that user can cancel the action (e.g. by moving outside the window, in the default bindings. */ if (cbw->kcommand.set) XtCallCallbackList(w, cbw->kcommand.callbacks, (XtPointer) NULL); } static void XkwKCommandRedisplay(Widget w, XEvent *event, Region region) { PaintKCommandWidget(w, event, region, False); } /* * Function: * PaintKCommandWidget * Parameters: * w - kcommand widget * region - region to paint (passed to the superclass) * change - did it change either set or highlight state? */ static void PaintKCommandWidget(Widget w, XEvent *event, Region region, Bool change) { KCommandWidget cbw = (KCommandWidget)w; if (cbw->kcommand.highlight_thickness) { Bool very_thick = cbw->kcommand.highlight_thickness > Min(XtWidth(cbw), XtHeight(cbw)) / 2; /* * If we are set then use the same colors as if we are not highlighted */ if (!((!change && cbw->kcommand.highlighted == HighlightNone) || (cbw->kcommand.highlighted == HighlightWhenUnset && cbw->kcommand.set))) { cairo_t *cr = XkwGetCairo(w); if (cbw->kcommand.highlighted != HighlightNone) XkwSetSource(cr, &cbw->ksimple.foreground); else XkwSetSource(cr, &cbw->ksimple.background); if (very_thick) cairo_paint(cr); else { cairo_set_line_width(cr, cbw->kcommand.highlight_thickness); double offset = cbw->kcommand.highlight_thickness / 2.0; cairo_rectangle(cr, offset, offset, XtWidth(cbw) - cbw->kcommand.highlight_thickness, XtHeight(cbw) - cbw->kcommand.highlight_thickness); cairo_fill(cr); } cairo_destroy(cr); } } (*SuperClass->core_class.expose)(w, event, region); } static Bool ShapeButton(KCommandWidget cbw, Bool checkRectangular) { Dimension corner_size = 0; if (cbw->kcommand.shape_style == XmuShapeRoundedRectangle) { corner_size = XtWidth(cbw) < XtHeight(cbw) ? XtWidth(cbw) : XtHeight(cbw); corner_size = (corner_size * cbw->kcommand.corner_round) / 100; } if (checkRectangular || cbw->kcommand.shape_style != XmuShapeRectangle) { if (!XmuReshapeWidget((Widget)cbw, cbw->kcommand.shape_style, corner_size, corner_size)) { cbw->kcommand.shape_style = XmuShapeRectangle; return (False); } } return (True); } /*ARGSUSED*/ static Boolean XkwKCommandSetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KCommandWidget oldcbw = (KCommandWidget)current; KCommandWidget cbw = (KCommandWidget)cnew; (void) request; if (oldcbw->core.sensitive != cbw->core.sensitive && !cbw->core.sensitive) { cbw->kcommand.highlighted = HighlightNone; } if (cbw->kcommand.set) { unsigned int i; XRenderColor foreground, background; foreground = oldcbw->ksimple.foreground; background = oldcbw->ksimple.background; for (i = 0; i < *num_args; i++) { if (STR_EQUAL(args[i].name, XtNforegroundColor)) background = cbw->ksimple.foreground; else if (STR_EQUAL(args[i].name, XtNbackgroundColor)) foreground = cbw->ksimple.background; } cbw->ksimple.foreground = foreground; cbw->ksimple.background = background; } if (XtIsRealized(cnew) && oldcbw->kcommand.shape_style != cbw->kcommand.shape_style && !ShapeButton(cbw, True)) cbw->kcommand.shape_style = oldcbw->kcommand.shape_style; return True; } static void XkwKCommandGetValuesHook(Widget w, ArgList args, Cardinal *num_args) { KCommandWidget cbw = (KCommandWidget)w; unsigned int i; for (i = 0; i < *num_args; i++) { if (STR_EQUAL(args[i].name, XtNforegroundColor)) *((XRenderColor*)args[i].value) = cbw->kcommand.set ? cbw->ksimple.background : cbw->ksimple.foreground; else if (STR_EQUAL(args[i].name, XtNbackgroundColor)) *((XRenderColor*)args[i].value) = cbw->kcommand.set ? cbw->ksimple.foreground : cbw->ksimple.background; } } static void XkwKCommandClassInitialize(void) { XkwInitializeWidgetSet(); XtSetTypeConverter(XtRShapeStyle, XtRString, XmuCvtShapeStyleToString, NULL, 0, XtCacheNone, NULL); } static void XkwKCommandClassPartInitialize(WidgetClass cclass) { KCommandWidgetClass class = (KCommandWidgetClass) cclass; KCommandWidgetClass super = (KCommandWidgetClass) cclass->core_class.superclass; if (class->kcommand_class.set == XtInheritSet) class->kcommand_class.set = super->kcommand_class.set; if (class->kcommand_class.unset == XtInheritSet) class->kcommand_class.unset = super->kcommand_class.unset; if (class->kcommand_class.notify == XtInheritSet) class->kcommand_class.notify = super->kcommand_class.notify; } static void XkwKCommandRealize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes) { (*kcommandWidgetClass->core_class.superclass->core_class.realize) (w, valueMask, attributes); ShapeButton((KCommandWidget)w, False); } static void XkwKCommandResize(Widget w) { if (XtIsRealized(w)) ShapeButton((KCommandWidget)w, False); if (kcommandWidgetClass->core_class.superclass->core_class.resize) (*kcommandWidgetClass->core_class.superclass->core_class.resize)(w); } KCommandClassRec kcommandClassRec = { /* core */ { (WidgetClass)SuperClass, /* superclass */ "Command", /* class_name */ sizeof(KCommandRec), /* size */ XkwKCommandClassInitialize, /* class_initialize */ XkwKCommandClassPartInitialize, /* class_part_initialize */ False, /* class_inited */ XkwKCommandInitialize, /* initialize */ NULL, /* initialize_hook */ XkwKCommandRealize, /* realize */ actionsList, /* actions */ XtNumber(actionsList), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ False, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ NULL, /* destroy */ XkwKCommandResize, /* resize */ XkwKCommandRedisplay, /* expose */ XkwKCommandSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ XkwKCommandGetValuesHook, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ defaultTranslations, /* tm_table */ XtInheritQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { 0, /* not used */ }, /* klabel */ { 0, /* not used */ }, /* kcommand */ { Set, Unset, Notify, }, }; WidgetClass kcommandWidgetClass = (WidgetClass)&kcommandClassRec; kgames-2.2/Xkw/KCommand.h000066400000000000000000000106541416764561500152640ustar00rootroot00000000000000/*********************************************************** Copyright 1987, 1988, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Digital not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XkwKCommand_h #define _XkwKCommand_h #include /* Command widget resources: Name Class RepType Default Value ---- ----- ------- ------------- accelerators Accelerators AcceleratorTable NULL ancestorSensitive AncestorSensitive Boolean True background Background Pixel XtDefaultBackground backgroundPixmap Pixmap Pixmap XtUnspecifiedPixmap bitmap Pixmap Pixmap None borderColor BorderColor Pixel XtDefaultForeground borderPixmap Pixmap Pixmap XtUnspecifiedPixmap borderWidth BorderWidth Dimension 1 callback Callback XtCallbackList NULL colormap Colormap Colormap parent's colormap cornerRoundPercent CornerRoundPercent Dimension 25 cursor Cursor Cursor None cursorName Cursor String NULL depth Depth int parent's depth destroyCallback Callback XtCallbackList NULL displayList DisplayList XawDisplayList* NULL encoding Encoding UnsignedChar XawTextEncoding8bit font Font XFontStruct* XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension text height highlightThickness Thickness Dimension 0 if shaped, else 2 insensitiveBorder Insensitive Pixmap Gray internalHeight Height Dimension 2 internalWidth Width Dimension 4 justify Justify XtJustify XtJustifyCenter label Label String NULL leftBitmap LeftBitmap Pixmap None mappedWhenManaged MappedWhenManaged Boolean True pointerColor Foreground Pixel XtDefaultForeground pointerColorBackground Background Pixel XtDefaultBackground resize Resize Boolean True screen Screen Screen parent's Screen sensitive Sensitive Boolean True shapeStyle ShapeStyle ShapeStyle Rectangle translations Translations TranslationTable see doc or source width Width Dimension text width x Position Position 0 y Position Position 0 */ #define XtNhighlightThickness "highlightThickness" extern WidgetClass kcommandWidgetClass; typedef struct _KCommandClassRec *KCommandWidgetClass; typedef struct _KCommandRec *KCommandWidget; #endif /* _XkwKCommand_h */ kgames-2.2/Xkw/KCommandP.h000066400000000000000000000075451416764561500154110ustar00rootroot00000000000000/*********************************************************** Copyright 1987, 1988, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Digital not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XkwKCommandP_h #define _XkwKCommandP_h /* * Command Widget Private Data */ #include #include typedef enum { HighlightNone, /* Do not highlight */ HighlightWhenUnset, /* Highlight only when unset, this is to preserve current command widget functionality */ HighlightAlways /* Always highlight, lets the toggle widget and other subclasses do the right thing */ } XtCommandHighlight; /* New fields for the KCommand widget class record */ typedef struct _KCommandClass { XtActionProc set; XtActionProc unset; XtActionProc notify; } KCommandClassPart; #define XtInheritSet ((XtActionProc)_XtInherit) #define XtInheritUnset ((XtActionProc)_XtInherit) #define XtInheritNotify ((XtActionProc)_XtInherit) /* Full class record declaration */ typedef struct _KCommandClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KLabelClassPart klabel_class; KCommandClassPart kcommand_class; } KCommandClassRec; extern KCommandClassRec kcommandClassRec; /* New fields for the KCommand widget record */ typedef struct { /* resources */ Dimension highlight_thickness; XtCallbackList callbacks; int shape_style; Dimension corner_round; /* private state */ Boolean set; XtCommandHighlight highlighted; } KCommandPart; /* Full widget declaration */ typedef struct _KCommandRec { CorePart core; SimplePart simple; KSimplePart ksimple; KLabelPart klabel; KCommandPart kcommand; } KCommandRec; #endif /* _XkwKCommandP_h */ kgames-2.2/Xkw/KLabel.c000066400000000000000000000175151416764561500147230ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include static XtResource resources[] = { #define offset(field) XtOffsetOf(KLabelRec, klabel.field) /* {name, class, type, size, offset, default_type, default_addr}, */ { XtNlabel, XtCLabel, XtRString, sizeof(String), offset (label), XtRString, NULL }, { XtNresize, XtCResize, XtRBoolean, sizeof(Boolean), offset(resize), XtRImmediate, (XtPointer) True }, { XtNfont, XtCFont, XtRXkwFont, sizeof (XkwFont), offset (font), XtRString, XtDefaultFont }, { XtNjustify, XtCJustify, XtRJustify, sizeof(XtJustify), offset (justify), XtRImmediate, (XtPointer) XtJustifyCenter }, #undef offset }; #define superclass (&ksimpleClassRec) static void XkwKLabelClassInitialize(void) { XtSetTypeConverter(XtRString, XtRShapeStyle, XmuCvtStringToShapeStyle, NULL, 0, XtCacheNone, NULL); } static void init_cairo(KLabelWidget w, cairo_t *cr) { cairo_set_font_face(cr, w->klabel.font.font_face); cairo_set_font_size(cr, w->klabel.font.size * w->ksimple.dpi / 72.0); } static cairo_t * get_cairo(KLabelWidget w) { cairo_t *cr = XkwGetCairo((Widget) w); init_cairo(w, cr); return cr; } static cairo_t * draw_begin(KLabelWidget w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); init_cairo(w, cr); return cr; } static void draw_end(KLabelWidget w, Region region, cairo_t *cr) { XkwDrawEnd((Widget) w, region, cr); } static double pad(cairo_font_extents_t *font_extents) { return font_extents->height / 4.0; } static void preferred_size(KLabelWidget w, Dimension *width, Dimension *height) { cairo_t *cr = get_cairo(w); cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); cairo_text_extents(cr, w->klabel.label, &text_extents); cairo_destroy(cr); *width = text_extents.width + pad(&font_extents) * 2; *height = font_extents.height + pad(&font_extents) * 2; } static void XkwKLabelInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KLabelWidget w = (KLabelWidget)cnew; (void) request; (void) args; (void) num_args; if (w->klabel.label == NULL) w->klabel.label = XtNewString(w->core.name); else w->klabel.label = XtNewString(w->klabel.label); if (XtWidth(w) == 0 || XtHeight(w) == 0) { Dimension width, height; preferred_size(w, &width, &height); if (XtWidth(w) == 0) XtWidth(w) = width; if (XtHeight(w) == 0) XtHeight(w) = height; } } static void XkwKLabelDestroy(Widget gw) { KLabelWidget w = (KLabelWidget)gw; if (w->klabel.label != w->core.name) XtFree(w->klabel.label); } static void XkwKLabelRedisplay(Widget gw, XEvent *event, Region region) { KLabelWidget w = (KLabelWidget)gw; cairo_t *cr = draw_begin(w, region); (void) event; if (!XtIsSensitive(gw)) XkwSetSourceInterp(cr, &w->ksimple.foreground, &w->ksimple.background); cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); cairo_text_extents(cr, w->klabel.label, &text_extents); double x; switch (w->klabel.justify) { case XtJustifyLeft: x = pad(&font_extents); break; case XtJustifyRight: x = w->core.width - text_extents.width - pad(&font_extents); break; default: x = (w->core.width - text_extents.width) / 2 - text_extents.x_bearing; break; } double y = (w->core.height - text_extents.height) / 2 - text_extents.y_bearing; cairo_move_to(cr, x, y); cairo_show_text(cr, w->klabel.label); draw_end(w, region, cr); } static Boolean XkwKLabelSetValues(Widget gcur, Widget greq, Widget gnew, ArgList args, Cardinal *num_args) { KLabelWidget cur = (KLabelWidget)gcur; KLabelWidget req = (KLabelWidget)greq; KLabelWidget new = (KLabelWidget)gnew; Boolean was_resized = False; (void) req; (void) args; (void) num_args; if (new->klabel.label != cur->klabel.label) { XtFree(cur->klabel.label); if (!new->klabel.label) new->klabel.label = XtNewString(new->core.name); else new->klabel.label = XtNewString(new->klabel.label); was_resized = True; } if (new->klabel.font.font_face != cur->klabel.font.font_face || new->klabel.font.size != cur->klabel.font.size) was_resized = True; if (new->klabel.resize && was_resized) { Dimension width, height; preferred_size(new, &width, &height); if (XtHeight(cur) == XtHeight(req)) XtHeight(new) = height; if (XtWidth(cur) == XtWidth(req)) XtWidth(new) = width; } return TRUE; } static XtGeometryResult XkwKLabelQueryGeometry(Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { KLabelWidget w = (KLabelWidget)gw; preferred->request_mode = CWWidth | CWHeight; preferred_size(w, &preferred->width, &preferred->height); if (((intended->request_mode & (CWWidth | CWHeight)) == (CWWidth | CWHeight)) && intended->width == preferred->width && intended->height == preferred->height) return (XtGeometryYes); else if (preferred->width == XtWidth(w) && preferred->height == XtHeight(w)) return (XtGeometryNo); return (XtGeometryAlmost); } KLabelClassRec klabelClassRec = { /* core */ { (WidgetClass)superclass, /* superclass */ "Label", /* class_name */ sizeof(KLabelRec), /* widget_size */ XkwKLabelClassInitialize, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ XkwKLabelInitialize, /* initialize */ NULL, /* initialize_hook */ XtInheritRealize, /* realize */ NULL, /* actions */ 0, /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ XkwKLabelDestroy, /* destroy */ XtInheritResize, /* resize */ XkwKLabelRedisplay, /* expose */ XkwKLabelSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ NULL, /* tm_table */ XkwKLabelQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, /* klabel */ { 0, /* extension */ } }; WidgetClass klabelWidgetClass = (WidgetClass)&klabelClassRec; kgames-2.2/Xkw/KLabel.h000066400000000000000000000031571416764561500147250ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKLabel_h #define _XkwKLabel_h /* KLabel Widget */ #include #define XtNshapeStyle "shapeStyle" #define XtCShapeStyle "ShapeStyle" #define XtRShapeStyle "ShapeStyle" #define XtNcornerRoundPercent "cornerRoundPercent" #define XtCCornerRoundPercent "CornerRoundPercent" extern WidgetClass klabelWidgetClass; typedef struct _KLabelClassRec *KLabelWidgetClass; typedef struct _KLabelRec *KLabelWidget; #endif /* _XkwKLabel_h */ kgames-2.2/Xkw/KLabelP.h000066400000000000000000000036511416764561500150440ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKLabelP_h #define _XkwKLabelP_h #include #include #include typedef struct _KLabelClass { int unused; } KLabelClassPart; typedef struct _KLabelClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KLabelClassPart klabel_class; } KLabelClassRec; extern KLabelClassRec klabelClassRec; /* New fields for the KLabel widget record */ typedef struct { XkwFont font; char *label; XtJustify justify; Boolean resize; } KLabelPart; /* * Full instance record declaration */ typedef struct _KLabelRec { CorePart core; SimplePart simple; KSimplePart ksimple; KLabelPart klabel; } KLabelRec; #endif /* _XkwKLabelP_h */ kgames-2.2/Xkw/KMenuButton.c000066400000000000000000000173111416764561500157760ustar00rootroot00000000000000/* Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * */ /* * MenuButton.c - Source code for MenuButton widget. * * This is the source code for the Athena MenuButton widget. * It is intended to provide an easy method of activating pulldown menus. * * Date: May 2, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include /* * Class Methods */ static void XkwKMenuButtonClassInitialize(void); static void XkwKMenuButtonInitialize(Widget, Widget, ArgList, Cardinal*); static void XkwKMenuButtonDestroy(Widget); static Boolean XkwKMenuButtonSetValues(Widget, Widget, Widget, ArgList, Cardinal*); /* * Actions */ static void PopupMenu(Widget, XEvent*, String*, Cardinal*); /* * Initialization */ #define superclass ((KCommandWidgetClass)&kcommandClassRec) static char defaultTranslations[] = ":" "highlight()\n" ":" "reset()\n" "Any:" "reset() PopupMenu()\n"; static char default_menu_name[] = "menu"; #define offset(field) XtOffsetOf(KMenuButtonRec, field) static XtResource resources[] = { { XtNmenuName, XtCMenuName, XtRString, sizeof(String), offset(menu_button.menu_name), XtRString, (XtPointer)default_menu_name }, }; #undef offset static XtActionsRec actionsList[] = { {"PopupMenu", PopupMenu}, }; KMenuButtonClassRec kmenuButtonClassRec = { /* core */ { (WidgetClass)superclass, /* superclass */ "MenuButton", /* class_name */ sizeof(KMenuButtonRec), /* size */ XkwKMenuButtonClassInitialize, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ XkwKMenuButtonInitialize, /* initialize */ NULL, /* initialize_hook */ XtInheritRealize, /* realize */ actionsList, /* actions */ XtNumber(actionsList), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ False, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ XkwKMenuButtonDestroy, /* destroy */ XtInheritResize, /* resize */ XtInheritExpose, /* expose */ XkwKMenuButtonSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ defaultTranslations, /* tm_table */ XtInheritQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { 0, }, /* klabel */ { 0, /* extension */ }, /* kcommand */ { 0, /* extension */ }, /* kmenu_button */ { NULL, /* extension */ }, }; WidgetClass kmenuButtonWidgetClass = (WidgetClass)&kmenuButtonClassRec; /* * Implementation */ static void XkwKMenuButtonClassInitialize(void) { XkwInitializeWidgetSet(); XtRegisterGrabAction(PopupMenu, True, ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync); } /*ARGSUSED*/ static void XkwKMenuButtonInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KMenuButtonWidget mbw = (KMenuButtonWidget)cnew; (void) request; (void) args; (void) num_args; if (mbw->menu_button.menu_name != default_menu_name) mbw->menu_button.menu_name = XtNewString(mbw->menu_button.menu_name); } static void XkwKMenuButtonDestroy(Widget w) { KMenuButtonWidget mbw = (KMenuButtonWidget)w; if (mbw->menu_button.menu_name != default_menu_name) XtFree(mbw->menu_button.menu_name); } /*ARGSUSED*/ static Boolean XkwKMenuButtonSetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KMenuButtonWidget mbw_old = (KMenuButtonWidget)current; KMenuButtonWidget mbw_new = (KMenuButtonWidget)cnew; (void) request; (void) args; (void) num_args; if (mbw_old->menu_button.menu_name != mbw_new->menu_button.menu_name) { if (mbw_old->menu_button.menu_name != default_menu_name) XtFree(mbw_old->menu_button.menu_name); if (mbw_new->menu_button.menu_name != default_menu_name) mbw_new->menu_button.menu_name = XtNewString(mbw_new->menu_button.menu_name); } return TRUE; } /*ARGSUSED*/ static void PopupMenu(Widget w, XEvent *event, String *params, Cardinal *num_params) { KMenuButtonWidget mbw = (KMenuButtonWidget)w; Widget menu = NULL, temp; Arg arglist[2]; Cardinal num_args; int menu_x, menu_y, menu_width, menu_height, button_height; Position button_x, button_y; (void) event; (void) params; (void) num_params; temp = w; while(temp != NULL) { menu = XtNameToWidget(temp, mbw->menu_button.menu_name); if (menu == NULL) temp = XtParent(temp); else break; } if (menu == NULL) { char error_buf[BUFSIZ]; snprintf(error_buf, sizeof(error_buf), "KMenuButton: Could not find menu widget named %s.", mbw->menu_button.menu_name); XtAppWarning(XtWidgetToApplicationContext(w), error_buf); return; } if (!XtIsRealized(menu)) XtRealizeWidget(menu); menu_width = XtWidth(menu) + (XtBorderWidth(menu) << 1); button_height = XtHeight(w) + (XtBorderWidth(w) << 1); menu_height = XtHeight(menu) + (XtBorderWidth(menu) << 1); XtTranslateCoords(w, 0, 0, &button_x, &button_y); menu_x = button_x; menu_y = button_y + button_height; if (menu_y >= 0) { int scr_height = HeightOfScreen(XtScreen(menu)); if (menu_y + menu_height > scr_height) menu_y = button_y - menu_height; if (menu_y < 0) { menu_y = scr_height - menu_height; menu_x = button_x + XtWidth(w) + (XtBorderWidth(w) << 1); if (menu_x + menu_width > WidthOfScreen(XtScreen(menu))) menu_x = button_x - menu_width; } } if (menu_y < 0) menu_y = 0; if (menu_x >= 0) { int scr_width = WidthOfScreen(XtScreen(menu)); if (menu_x + menu_width > scr_width) menu_x = scr_width - menu_width; } if (menu_x < 0) menu_x = 0; num_args = 0; XtSetArg(arglist[num_args], XtNx, menu_x); num_args++; XtSetArg(arglist[num_args], XtNy, menu_y); num_args++; XtSetValues(menu, arglist, num_args); XtPopupSpringLoaded(menu); } kgames-2.2/Xkw/KMenuButton.h000066400000000000000000000061261416764561500160050ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /*********************************************************************** * * MenuButton Widget * ***********************************************************************/ /* * MenuButton.h - Public Header file for MenuButton widget. * * This is the public header file for the Athena MenuButton widget. * It is intended to provide an easy method of activating pulldown menus. * * Date: May 2, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _XkwKMenuButton_h #define _XkwKMenuButton_h #include /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground bitmap Pixmap Pixmap None border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 callback Callback Pointer NULL cursor Cursor Cursor None destroyCallback Callback Pointer NULL displayList DisplayList XkwDisplayList* NULL font Font XFontStruct* XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension text height highlightThickness Thickness Dimension 2 insensitiveBorder Insensitive Pixmap Gray internalHeight Height Dimension 2 internalWidth Width Dimension 4 justify Justify XtJustify XtJustifyCenter label Label String NULL mappedWhenManaged MappedWhenManaged Boolean True menuName MenuName String "menu" resize Resize Boolean True sensitive Sensitive Boolean True width Width Dimension text width x Position Position 0 y Position Position 0 */ #define XtNmenuName "menuName" #define XtCMenuName "MenuName" extern WidgetClass kmenuButtonWidgetClass; typedef struct _KMenuButtonClassRec *KMenuButtonWidgetClass; typedef struct _KMenuButtonRec *KMenuButtonWidget; #endif /* _XkwKMenuButton_h */ kgames-2.2/Xkw/KMenuButtonP.h000066400000000000000000000047341416764561500161300ustar00rootroot00000000000000/* * Copyright 1989,1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * KMenuButtonP.h - Private Header file for KMenuButton widget. * * This is the private header file for the Athena KMenuButton widget. * It is intended to provide an easy method of activating pulldown menus. * * Date: May 2, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _XkwKMenuButtonP_h #define _XkwKMenuButtonP_h #include #include /* New fields for the KMenuButton widget class */ typedef struct _KMenuButtonClass { XtPointer extension; } KMenuButtonClassPart; /* class record declaration */ typedef struct _KMenuButtonClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KLabelClassPart klabel_class; KCommandClassPart kcommand_class; KMenuButtonClassPart kmenuButton_class; } KMenuButtonClassRec; extern KMenuButtonClassRec kmenuButtonClassRec; /* New fields for the KMenuButton widget */ typedef struct { /* resources */ String menu_name; } KMenuButtonPart; /* widget declaration */ typedef struct _KMenuButtonRec { CorePart core; SimplePart simple; KSimplePart ksimple; KLabelPart label; KCommandPart kcommand; KMenuButtonPart menu_button; } KMenuButtonRec; #endif /* _XkwKMenuButtonP_h */ kgames-2.2/Xkw/KPorthole.c000066400000000000000000000273701416764561500155000ustar00rootroot00000000000000/* * Copyright 1990, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Jim Fulton, MIT X Consortium * * This widget is a trivial clipping widget. It is typically used with a * panner or scrollbar to navigate. */ #include #include /* * Implementation */ static Widget find_child(KPortholeWidget pw) { Widget *children; unsigned int i; /* * Find the managed child on which we should operate. Ignore multiple * managed children */ for (i = 0, children = pw->composite.children; i < pw->composite.num_children; i++, children++) if (XtIsManaged(*children)) return (*children); return (NULL); } static void SendReport(KPortholeWidget pw) { Widget child = find_child(pw); if (pw->kporthole.callbacks && child) XtCallCallbackList((Widget)pw, pw->kporthole.callbacks, child); } static void LayoutChild(KPortholeWidget pw, Widget child, XtWidgetGeometry *geomp, Position *xp, Position *yp, Dimension *widthp, Dimension *heightp) { Position minx, miny; XtWidgetGeometry intended = { .request_mode = CWWidth | CWHeight, .width = XtWidth(pw), .height = XtHeight(pw) }; XtWidgetGeometry preferred = intended; (void) XtQueryGeometry(child, &intended, &preferred); *xp = XtX(child); /* default to current pos, preferred size */ *yp = XtY(child); *widthp = preferred.width; *heightp = preferred.height; if (geomp) { /* mix in any requested changes */ if (geomp->request_mode & CWX) *xp = geomp->x; if (geomp->request_mode & CWY) *yp = geomp->y; if (geomp->request_mode & CWWidth) *widthp = geomp->width; if (geomp->request_mode & CWHeight) *heightp = geomp->height; } /* * Make sure that the child is at least as large as the porthole; there * is no maximum size */ if (*widthp < XtWidth(pw)) *widthp = XtWidth(pw); if (*heightp < XtHeight(pw)) *heightp = XtHeight(pw); /* * Make sure that the child is still on the screen. Note that this must * be done *after* the size computation so that we know where to put it */ minx = (Position)XtWidth(pw) - (Position)*widthp; miny = (Position)XtHeight(pw) - (Position)*heightp; if (*xp < minx) *xp = minx; if (*yp < miny) *yp = miny; if (*xp > 0) *xp = 0; if (*yp > 0) *yp = 0; } static void KPortholeStart(Widget, XEvent*, String*, Cardinal*); static void KPortholeClassInitialize(void) { XkwInitializeWidgetSet(); XtRegisterGrabAction(KPortholeStart, False, PointerMotionMask|ButtonReleaseMask|ButtonPressMask, GrabModeAsync, GrabModeAsync); } static void KPortholeRealize(Widget gw, Mask *valueMask, XSetWindowAttributes *attr) { attr->bit_gravity = NorthWestGravity; *valueMask |= CWBitGravity; if (XtWidth(gw) < 1) XtWidth(gw) = 1; if (XtHeight(gw) < 1) XtHeight(gw) = 1; (*kportholeWidgetClass->core_class.superclass->core_class.realize) (gw, valueMask, attr); } static void KPortholeResize(Widget gw) { KPortholeWidget pw = (KPortholeWidget)gw; Widget child = find_child(pw); /* * If we have a child, we need to make sure that it is at least as big * as we are and in the right place */ if (child) { Position x, y; Dimension width, height; LayoutChild(pw, child, NULL, &x, &y, &width, &height); XtConfigureWidget(child, x, y, width, height, 0); } SendReport(pw); } static XtGeometryResult KPortholeQueryGeometry(Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { KPortholeWidget pw = (KPortholeWidget)gw; Widget child = find_child(pw); if (child) { #define SIZEONLY (CWWidth | CWHeight) preferred->request_mode = intended->request_mode & SIZEONLY; preferred->width = XtWidth(child); preferred->height = XtHeight(child); if (((intended->request_mode & CWWidth) == 0 || intended->width == preferred->width) && ((intended->request_mode & CWHeight) == 0 || intended->height == preferred->height)) return (XtGeometryYes); else if (preferred->width == XtWidth(pw) && preferred->height == XtHeight(pw)) return (XtGeometryNo); return (XtGeometryAlmost); #undef SIZEONLY } return (XtGeometryNo); } static XtGeometryResult KPortholeGeometryManager(Widget w, XtWidgetGeometry *req, XtWidgetGeometry *reply) { KPortholeWidget pw = (KPortholeWidget) w->core.parent; Widget child = find_child(pw); Bool okay = True; if (child != w) return (XtGeometryNo); *reply = *req; /* assume we'll grant everything */ if ((req->request_mode & CWBorderWidth) && req->border_width != 0) { reply->border_width = 0; okay = False; } LayoutChild(pw, child, req, &reply->x, &reply->y, &reply->width, &reply->height); if ((req->request_mode & CWX) && req->x != reply->x) okay = False; if ((req->request_mode & CWY) && req->x != reply->x) okay = False; if ((req->request_mode & CWWidth) && req->width != reply->width) okay = False; if ((req->request_mode & CWHeight) && req->height != reply->height) okay = False; /* * If we failed on anything, simply return without touching widget */ if (!okay) return (XtGeometryAlmost); /* * If not just doing a query, update widget and send report. Note that * we will often set fields that weren't requested because we want to keep * the child visible */ if (!(req->request_mode & XtCWQueryOnly)) { XtX(child) = reply->x; XtY(child) = reply->y; XtWidth(child) = reply->width; XtHeight(child) = reply->height; SendReport(pw); } return (XtGeometryYes); /* success! */ } static void KPortholeChangeManaged(Widget gw) { KPortholeWidget pw = (KPortholeWidget)gw; Widget child = find_child (pw); /* ignore extra children */ if (child) { if (!XtIsRealized (gw)) { XtWidgetGeometry geom, retgeom; geom.request_mode = 0; if (XtWidth(pw) == 0) { geom.width = XtWidth(child); geom.request_mode |= CWWidth; } if (XtHeight(pw) == 0) { geom.height = XtHeight(child); geom.request_mode |= CWHeight; } if (geom.request_mode && XtMakeGeometryRequest (gw, &geom, &retgeom) == XtGeometryAlmost) (void)XtMakeGeometryRequest(gw, &retgeom, NULL); } XtResizeWidget(child, Max(XtWidth(child), XtWidth(pw)), Max(XtHeight(child), XtHeight(pw)), 0); SendReport(pw); } } static Boolean GetPosition(XEvent *event, Position *x, Position *y) { switch(event->type) { case MotionNotify: *x = event->xmotion.x; *y = event->xmotion.y; break; case ButtonPress: case ButtonRelease: *x = event->xbutton.x; *y = event->xbutton.y; break; case KeyPress: case KeyRelease: *x = event->xkey.x; *y = event->xkey.y; break; case EnterNotify: case LeaveNotify: *x = event->xcrossing.x; *y = event->xcrossing.y; break; default: *x = 0; *y = 0; return False; } return True; } static void KPortholeStart(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KPortholeWidget w = (KPortholeWidget) gw; Widget child = find_child(w); (void) params; (void) num_params; w->kporthole.dragging = GetPosition(event, &w->kporthole.start_x, &w->kporthole.start_y); if (child) { w->kporthole.child_start_x = XtX(child); w->kporthole.child_start_y = XtY(child); } } static void KPortholeDrag(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KPortholeWidget w = (KPortholeWidget) gw; Position x, y; (void) params; (void) num_params; if (w->kporthole.dragging && GetPosition(event, &x, &y)) { Widget child = find_child(w); if (child) { Position dx = x - w->kporthole.start_x; Position dy = y - w->kporthole.start_y; Position child_x = w->kporthole.child_start_x + dx; Position child_y = w->kporthole.child_start_y + dy; Position min_x = XtWidth(gw) - XtWidth(child); Position min_y = XtHeight(gw) - XtHeight(child); if (child_x > 0) child_x = 0; if (child_y > 0) child_y = 0; if (child_x < min_x) child_x = min_x; if (child_y < min_y) child_y = min_y; if (child_x != XtX(child) || child_y != XtY(child)) { Arg args[2]; XtSetArg(args[0], XtNx, child_x); XtSetArg(args[1], XtNy, child_y); XtSetValues(child, args, 2); } } } } static void KPortholeStop(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KPortholeWidget w = (KPortholeWidget) gw; (void) event; (void) params; (void) num_params; w->kporthole.dragging = False; } static const char defaultTranslations[] = ":" "start()\n" ":" "drag()\n" ":" "stop()\n" "Shift :" "start()\n" "Shift : drag()\n" "Shift :" "stop()\n"; static XtActionsRec actions[] = { { "start", KPortholeStart, }, { "drag", KPortholeDrag, }, { "stop", KPortholeStop, }, }; #define offset(field) XtOffsetOf(KPortholeRec, kporthole.field) static XtResource resources[] = { { XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(callbacks), XtRCallback, NULL }, }; #undef offset #define Superclass (&compositeClassRec) KPortholeClassRec kportholeClassRec = { /* core */ { (WidgetClass)Superclass, /* superclass */ "Porthole", /* class_name */ sizeof(KPortholeRec), /* widget_size */ KPortholeClassInitialize, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ NULL, /* initialize */ NULL, /* initialize_hook */ KPortholeRealize, /* realize */ actions, /* actions */ XtNumber(actions), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ NULL, /* destroy */ KPortholeResize, /* resize */ NULL, /* expose */ NULL, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ (char *)defaultTranslations, /* tm_table */ KPortholeQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* composite */ { KPortholeGeometryManager, /* geometry_manager */ KPortholeChangeManaged, /* change_managed */ XtInheritInsertChild, /* insert_child */ XtInheritDeleteChild, /* delete_child */ NULL, /* extension */ }, { /* porthole */ NULL, /* extension */ }, }; WidgetClass kportholeWidgetClass = (WidgetClass)&kportholeClassRec; kgames-2.2/Xkw/KPorthole.h000066400000000000000000000041651416764561500155020ustar00rootroot00000000000000/* * Copyright 1990, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Jim Fulton, MIT X Consortium */ #ifndef _XkwKPorthole_h #define _XkwKPorthole_h #include /***************************************************************************** * * KPorthole Widget (subclass of Composite) * * This widget is similar to a viewport without scrollbars. Child movement * is done by dragging * * Parameters: * * Name Class Type Default * ---- ----- ---- ------- * * background Background Pixel XtDefaultBackground * border BorderColor Pixel XtDefaultForeground * borderWidth BorderWidth Dimension 1 * height Height Dimension 0 * reportCallback ReportCallback Pointer NULL * width Width Dimension 0 * x Position Position 0 * y Position Position 0 * *****************************************************************************/ extern WidgetClass kportholeWidgetClass; typedef struct _KPortholeClassRec *KPortholeWidgetClass; typedef struct _KPortholeRec *KPortholeWidget; #endif /* _XkwKPorthole_h */ kgames-2.2/Xkw/KPortholeP.h000066400000000000000000000040211416764561500156110ustar00rootroot00000000000000/* * Copyright 1990, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Jim Fulton, MIT X Consortium */ #ifndef _XkwKPortholeP_h #define _XkwKPortholeP_h #include #include #include #include /* new fields in widget class */ typedef struct { XtPointer extension; } KPortholeClassPart; /* widget class */ typedef struct _KPortholeClassRec { CoreClassPart core_class; CompositeClassPart composite_class; KPortholeClassPart kporthole_class; } KPortholeClassRec; /* new fields in widget */ typedef struct { /* resources */ XtCallbackList callbacks; /* private */ Boolean dragging; Position start_x, start_y; Position child_start_x, child_start_y; } KPortholePart; typedef struct _KPortholeRec { CorePart core; CompositePart composite; KPortholePart kporthole; } KPortholeRec; extern KPortholeClassRec kportholeClassRec; #endif /* _XkwKPortholeP_h */ kgames-2.2/Xkw/KScrollbar.c000066400000000000000000000223771416764561500156310ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #define superclass (&ksimpleClassRec) static double Thickness(KScrollbarWidget w) { return w->kscrollbar.thickness * w->ksimple.dpi / 72.0; } static double Pad(KScrollbarWidget w) { return Thickness(w) / 4; } static double Room(KScrollbarWidget w) { Dimension l; if (w->kscrollbar.orientation == XtorientHorizontal) l = XtWidth(w); else l = XtHeight(w); return l - Pad(w) * 2; } static double Length(KScrollbarWidget w) { double thick = Thickness(w); double length = w->kscrollbar.size * Room(w); if (length < thick) length = thick; return length; } static double Avail (KScrollbarWidget w) { return Room(w) - Length(w); } static Dimension PreferredSize(KScrollbarWidget w) { return (Dimension) (Thickness(w) + Pad(w) * 2 + 0.5); } static double ThumbStart(KScrollbarWidget w) { return w->kscrollbar.position * Avail(w) + Pad(w); } static void ClassInitialize(void) { XkwInitializeWidgetSet(); } static void Initialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KScrollbarWidget w = (KScrollbarWidget) cnew; (void) request; (void) args; (void) num_args; if (XtWidth(w) == 0) XtWidth(w) = PreferredSize(w); if (XtHeight(w) == 0) XtWidth(w) = PreferredSize(w); w->kscrollbar.dragging = False; } static void Redisplay(Widget gw, XEvent *event, Region region) { KScrollbarWidget w = (KScrollbarWidget)gw; double thick = Thickness(w); double pos = w->kscrollbar.position * Avail(w) + Pad(w); cairo_t *cr = XkwDrawBegin(gw, region); (void) event; if (w->kscrollbar.orientation == XtorientHorizontal) { double width = Length(w); double x = pos; double y = (XtHeight(w) - thick) / 2.0; cairo_translate(cr, x, y); XkwDrawOval(cr, width, thick); } else { double height = Length(w); double x = (XtWidth(w) - thick) / 2.0; double y = pos; cairo_translate(cr, x, y); XkwDrawOval(cr, thick, height); } cairo_fill(cr); XkwDrawEnd(gw, region, cr); } static Boolean SetValues(Widget gcur, Widget greq, Widget gnew, ArgList args, Cardinal *num_args) { (void) gcur; (void) greq; (void) gnew; (void) args; (void) num_args; if (XtIsRealized(gnew)) Redisplay(gnew, NULL, NULL); return False; } static XtGeometryResult QueryGeometry(Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { KScrollbarWidget w = (KScrollbarWidget) gw; if (w->kscrollbar.orientation == XtorientHorizontal) { preferred->request_mode = CWHeight; preferred->height = PreferredSize(w); if (intended->request_mode & CWHeight && intended->height == preferred->height) return XtGeometryYes; else if (preferred->height == XtHeight(w)) return XtGeometryNo; } else { preferred->request_mode = CWWidth; preferred->width = PreferredSize(w); if (intended->request_mode & CWWidth && intended->width == preferred->width) return XtGeometryYes; else if (preferred->width == XtWidth(w)) return XtGeometryNo; } return XtGeometryAlmost; } static double CoordToPosition(KScrollbarWidget w, int coord) { double length = Length(w); double avail = Avail(w); double c = coord - length / 2.0; return c/avail; } static int ClassifyCoord(KScrollbarWidget w, int coord) { double thumb_start = ThumbStart(w); double thumb_end = ThumbStart(w) + Length(w); if (coord < thumb_start) return -1; if (coord > thumb_end) return 1; return 0; } static Position Coord(KScrollbarWidget w, XEvent *event) { Position x = 0, y = 0; switch(event->type) { case MotionNotify: x = event->xmotion.x; y = event->xmotion.y; break; case ButtonPress: case ButtonRelease: x = event->xbutton.x; y = event->xbutton.y; break; case KeyPress: case KeyRelease: x = event->xkey.x; y = event->xkey.y; break; case EnterNotify: case LeaveNotify: x = event->xcrossing.x; y = event->xcrossing.y; break; } if (w->kscrollbar.orientation == XtorientHorizontal) return x; return y; } static void Notify(KScrollbarWidget w, double position) { XtCallCallbackList((Widget) w, w->kscrollbar.callbacks, (XtPointer) &position); } static void Start(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KScrollbarWidget w = (KScrollbarWidget) gw; int coord = Coord(w, event); int class = ClassifyCoord(w, coord); (void) params; (void) num_params; w->kscrollbar.dragging = False; if (class < 0) Notify(w, XkwScrollbarPageUp); else if (class > 0) Notify(w, XkwScrollbarPageDown); else { w->kscrollbar.dragging = True; w->kscrollbar.start_pos = CoordToPosition(w, coord) - w->kscrollbar.position; } } static void Drag(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KScrollbarWidget w = (KScrollbarWidget) gw; (void) params; (void) num_params; if (w->kscrollbar.dragging) { double coord = CoordToPosition(w, Coord(w, event)) - w->kscrollbar.start_pos; if (coord < 0) coord = 0; if (coord > 1) coord = 1; Notify(w, coord); } } static void Stop(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KScrollbarWidget w = (KScrollbarWidget) gw; (void) event; (void) params; (void) num_params; w->kscrollbar.dragging = False; } void XkwScrollbarSetThumb(Widget gw, double position, double size) { Arg args[2]; Cardinal n; n = 0; /* Don't update from invalid data */ if (0 <= position && position <= 1) { XkwSetArg(args[n], XtNposition, &position); n++; } if (0 <= size && size <= 1) { XkwSetArg(args[n], XtNsize, &size); n++; } XtSetValues(gw, args, n); } static XtResource resources[] = { #define offset(field) XtOffsetOf(KScrollbarRec, kscrollbar.field) { XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation), offset(orientation), XtRImmediate, (XtPointer)XtorientVertical }, { XtNthickness, XtCThickness, XtRDouble, sizeof(double), offset(thickness), XtRString, "9" }, { XtNsize, XtCSize, XtRDouble, sizeof(double), offset(size), XtRString, (XtPointer) "1" }, { XtNposition, XtCPosition, XtRDouble, sizeof(double), offset(position), XtRString, "0" }, { XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(callbacks), XtRCallback, NULL }, #undef offset }; static XtActionsRec actions[] = { {"start", Start}, {"drag", Drag}, {"stop", Stop}, }; static char defaultTranslations[] = ":" "start()\n" ":" "drag()\n" ":" "stop()\n"; KScrollbarClassRec kscrollbarClassRec = { /* core */ { (WidgetClass)superclass, /* superclass */ "Scrollbar", /* class_name */ sizeof(KScrollbarRec), /* widget_size */ ClassInitialize, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ Initialize, /* initialize */ NULL, /* initialize_hook */ XtInheritRealize, /* realize */ actions, /* actions */ XtNumber(actions), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ NULL, /* destroy */ XtInheritResize, /* resize */ Redisplay, /* expose */ SetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ defaultTranslations, /* tm_table */ QueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ 0 /* empty */ }, /* kscrollbar */ { 0, /* empty */ } }; WidgetClass kscrollbarWidgetClass = (WidgetClass)&kscrollbarClassRec; kgames-2.2/Xkw/KScrollbar.h000066400000000000000000000032011416764561500156170ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKScrollbar_h_ #define _XkwKScrollbar_h_ #include #define XtNsize "size" #define XtCSize "Size" #define XtNposition "position" #define XkwScrollbarPageDown -2 #define XkwScrollbarPageUp -3 extern WidgetClass kscrollbarWidgetClass; typedef struct _KScrollbarClassRec *KScrollbarWidgetClass; typedef struct _KScrollbarRec *KScrollbarWidget; void XkwScrollbarSetThumb(Widget gw, double position, double size); #endif /* _XkwKScrollbar_h_ */ kgames-2.2/Xkw/KScrollbarP.h000066400000000000000000000043251416764561500157470ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKScrollbarP_h #define _XkwKScrollbarP_h #include #include #include /* New fields for the KScrollbar widget class record */ typedef struct _KScrollbarClass { int unused; } KScrollbarClassPart; /* Full class record declaration */ typedef struct _KScrollbarClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KScrollbarClassPart kscrollbar_class; } KScrollbarClassRec; extern KScrollbarClassRec kscrollbarClassRec; /* New fields for the KScrollbar widget record */ typedef struct { /* resources */ XtOrientation orientation; double thickness; double size; double position; XtCallbackList callbacks; /* private */ Boolean dragging; double start_pos; } KScrollbarPart; /* Full widget declaration */ typedef struct _KScrollbarRec { CorePart core; SimplePart simple; KSimplePart ksimple; KScrollbarPart kscrollbar; } KScrollbarRec; #endif /* _XkwKScrollbarP_h */ kgames-2.2/Xkw/KSimple.c000066400000000000000000000116411416764561500151270ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #define SuperClass (&simpleClassRec) static void KSimpleClassInitialize(void) { XkwInitializeWidgetSet(); } static void KSimpleInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSimpleWidget w = (KSimpleWidget) cnew; (void) request; (void) args; (void) num_args; w->ksimple.surface = NULL; w->ksimple.surface_width = 0; w->ksimple.surface_height = 0; } static void KSimpleRealize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes) { *valueMask &= ~(CWBackPixel); *valueMask |= (CWBackPixmap); attributes->background_pixmap = None; (*ksimpleWidgetClass->core_class.superclass->core_class.realize) (w, valueMask, attributes); } static void KSimpleDestroy(Widget gw) { KSimpleWidget w = (KSimpleWidget) gw; if (w->ksimple.surface) { cairo_surface_destroy(w->ksimple.surface); w->ksimple.surface = NULL; } } static void KSimpleRedisplay(Widget gw, XEvent *event, Region region) { KSimpleWidget w = (KSimpleWidget) gw; cairo_t *cr = XkwGetCairo(gw); (void) event; (void) region; XkwSetSource(cr, &w->ksimple.background); cairo_paint(cr); cairo_destroy(cr); } static Boolean KSimpleSetValues(Widget gcur, Widget greq, Widget gnew, ArgList args, Cardinal *num_args) { KSimpleWidget cur = (KSimpleWidget)gcur; KSimpleWidget req = (KSimpleWidget)greq; KSimpleWidget new = (KSimpleWidget)gnew; (void) req; (void) args; (void) num_args; if (!XkwColorEqual(&cur->ksimple.foreground, &new->ksimple.foreground) || !XkwColorEqual(&cur->ksimple.background, &new->ksimple.background)) return True; return False; } #define offset(field) XtOffsetOf(KSimpleRec, ksimple.field) static XtResource resources[] = { { XtNbackgroundColor, XtCBackground, XtRRenderColor, sizeof (XRenderColor), offset (background), XtRString, XtDefaultBackground }, { XtNforegroundColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (foreground), XtRString, XtDefaultForeground }, { XtNdpi, XtCDpi, XtRDpi, sizeof(double), offset (dpi), XtRString, "" }, {XtNwantForward, XtCWantForward, XtRBoolean, sizeof(Boolean), offset(want_forward), XtRImmediate, (XtPointer) True}, }; #undef offset KSimpleClassRec ksimpleClassRec = { /* core */ { (WidgetClass)SuperClass, /* superclass */ "KSimple", /* class_name */ sizeof(KSimpleRec), /* widget_size */ KSimpleClassInitialize, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ KSimpleInitialize, /* initialize */ NULL, /* initialize_hook */ KSimpleRealize, /* realize */ NULL, /* actions */ 0, /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ KSimpleDestroy, /* destroy */ NULL, /* resize */ KSimpleRedisplay, /* expose */ KSimpleSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ NULL, /* tm_table */ XtInheritQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { 0, }, }; WidgetClass ksimpleWidgetClass = (WidgetClass)&ksimpleClassRec; kgames-2.2/Xkw/KSimple.h000066400000000000000000000027061416764561500151360ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKSimple_h_ #define _XkwKSimple_h_ extern WidgetClass ksimpleWidgetClass; typedef struct _KSimpleClassRec *KSimpleWidgetClass; typedef struct _KSimpleRec *KSimpleWidget; #define XtNwantForward "wantForward" #define XtCWantForward "WantForward" #endif /* _XkwKSimple_h_ */ kgames-2.2/Xkw/KSimpleMenu.c000066400000000000000000001273721416764561500157650ustar00rootroot00000000000000/* Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * SimpleMenu.c - Source code file for SimpleMenu widget. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #define streq(a, b) (strcmp((a), (b)) == 0) #define ForAllChildren(smw, childP) \ for ((childP) = (KSmeObject *)(smw)->composite.children; \ (childP) < (KSmeObject *)((smw)->composite.children \ + (smw)->composite.num_children); \ (childP)++) #ifndef OLDXAW #define SMW_UNMAPPING 0x01 #define SMW_POPLEFT 0x02 #endif /* * Class Methods */ static void XkwKSimpleMenuChangeManaged(Widget); static void XkwKSimpleMenuClassInitialize(void); static void XkwKSimpleMenuClassPartInitialize(WidgetClass); static XtGeometryResult XkwKSimpleMenuGeometryManager(Widget, XtWidgetGeometry*, XtWidgetGeometry*); static void XkwKSimpleMenuInitialize(Widget, Widget, ArgList, Cardinal*); static void XkwKSimpleMenuRealize(Widget, XtValueMask*, XSetWindowAttributes*); static void XkwKSimpleMenuRedisplay(Widget, XEvent*, Region); static void XkwKSimpleMenuResize(Widget); static Boolean XkwKSimpleMenuSetValues(Widget, Widget, Widget, ArgList, Cardinal*); static Boolean XkwKSimpleMenuSetValuesHook(Widget, ArgList, Cardinal*); #define OLDXAW #ifndef OLDXAW static void PopupSubMenu(SimpleMenuWidget); static void PopdownSubMenu(SimpleMenuWidget); static void PopupCB(Widget, XtPointer, XtPointer); #endif /* * Prototypes */ static void AddPositionAction(XtAppContext, XPointer); static void CalculateNewSize(Widget, Dimension*, Dimension*); static void ChangeCursorOnGrab(Widget, XtPointer, XtPointer); static void CreateLabel(Widget); static KSmeObject DoGetEventEntry(Widget, int, int); static Widget FindMenu(Widget, String); static KSmeObject GetEventEntry(Widget, XEvent*); static void Layout(Widget, Dimension*, Dimension*); static void MakeResizeRequest(Widget); static void MakeSetValuesRequest(Widget, unsigned int, unsigned int); static void MoveMenu(Widget, int, int); static void PositionMenu(Widget, XPoint*); #define OLDXAW /* * Actions */ static void Highlight(Widget, XEvent*, String*, Cardinal*); static void Notify(Widget, XEvent*, String*, Cardinal*); #ifndef OLDXAW static void Popdown(Widget, XEvent*, String*, Cardinal*); #endif static void PositionMenuAction(Widget, XEvent*, String*, Cardinal*); static void Unhighlight(Widget, XEvent*, String*, Cardinal*); /* * Initialization */ #define offset(field) XtOffsetOf(KSimpleMenuRec, ksimple_menu.field) static XtResource resources[] = { /* label */ { XtNlabel, XtCLabel, XtRString, sizeof(String), offset(label_string), XtRString, NULL }, { XtNlabelClass, XtCLabelClass, XtRPointer, sizeof(WidgetClass), offset(label_class), XtRImmediate, NULL }, /* layout */ { XtNrowHeight, XtCRowHeight, XtRDimension, sizeof(Dimension), offset(row_height), XtRImmediate, (XtPointer)0 }, { XtNtopMargin, XtCVerticalMargins, XtRDimension, sizeof(Dimension), offset(top_margin), XtRImmediate, (XtPointer)0 }, { XtNbottomMargin, XtCVerticalMargins, XtRDimension, sizeof(Dimension), offset(bottom_margin), XtRImmediate, (XtPointer)0 }, { XtNbackgroundColor, XtCBackground, XtRRenderColor, sizeof (XRenderColor), offset (background), XtRString, XtDefaultBackground }, { XtNforegroundColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (foreground), XtRString, XtDefaultForeground }, #ifndef OLDXAW { XtNleftMargin, XtCHorizontalMargins, XtRDimension, sizeof(Dimension), offset(left_margin), XtRImmediate, (XtPointer)0 }, { XtNrightMargin, XtCHorizontalMargins, XtRDimension, sizeof(Dimension), offset(right_margin), XtRImmediate, (XtPointer)0 }, #endif /* misc */ { XtNallowShellResize, XtCAllowShellResize, XtRBoolean, sizeof(Boolean), XtOffsetOf(KSimpleMenuRec, shell.allow_shell_resize), XtRImmediate, (XtPointer)True }, { XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor), offset(cursor), XtRImmediate, (XtPointer)None }, { XtNmenuOnScreen, XtCMenuOnScreen, XtRBoolean, sizeof(Boolean), offset(menu_on_screen), XtRImmediate, (XtPointer)True }, { XtNpopupOnEntry, XtCPopupOnEntry, XtRWidget, sizeof(Widget), offset(popup_entry), XtRWidget, NULL }, { XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof(int), offset(backing_store), XtRImmediate, (XtPointer)(Always + WhenMapped + NotUseful) }, #ifndef OLDXAW { XawNdisplayList, XawCDisplayList, XawRDisplayList, sizeof(XawDisplayList*), offset(display_list), XtRImmediate, NULL }, #endif }; #undef offset static char defaultTranslations[] = ":" "highlight()\n" ":" "unhighlight()\n" ":" "highlight()\n" #ifndef OLDXAW ":" "popdown() notify() unhighlight()\n" #else ":" "MenuPopdown() notify() unhighlight()\n" #endif ; static XtActionsRec actionsList[] = { {"notify", Notify}, {"highlight", Highlight}, {"unhighlight", Unhighlight}, #ifndef OLDXAW {"popdown", Popdown}, {"set-values", XawSetValuesAction}, {"get-values", XawGetValuesAction}, {"declare", XawDeclareAction}, {"call-proc", XawCallProcAction}, #endif }; static CompositeClassExtensionRec extension_rec = { NULL, /* next_extension */ NULLQUARK, /* record_type */ XtCompositeExtensionVersion, /* version */ sizeof(CompositeClassExtensionRec), /* record_size */ True, /* accepts_objects */ True, /* allows_changed_managed_set */ }; #define Superclass (&overrideShellClassRec) KSimpleMenuClassRec ksimpleMenuClassRec = { /* core */ { (WidgetClass)Superclass, /* superclass */ "SimpleMenu", /* class_name */ sizeof(KSimpleMenuRec), /* size */ XkwKSimpleMenuClassInitialize, /* class_initialize */ XkwKSimpleMenuClassPartInitialize, /* class_part_initialize */ False, /* class_inited */ XkwKSimpleMenuInitialize, /* initialize */ NULL, /* initialize_hook */ XkwKSimpleMenuRealize, /* realize */ actionsList, /* actions */ XtNumber(actionsList), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ NULL, /* destroy */ XkwKSimpleMenuResize, /* resize */ XkwKSimpleMenuRedisplay, /* expose */ XkwKSimpleMenuSetValues, /* set_values */ XkwKSimpleMenuSetValuesHook, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* intrinsics version */ NULL, /* callback offsets */ defaultTranslations, /* tm_table */ NULL, /* query_geometry */ NULL, /* display_accelerator */ NULL, /* extension */ }, /* composite */ { XkwKSimpleMenuGeometryManager, /* geometry_manager */ XkwKSimpleMenuChangeManaged, /* change_managed */ XtInheritInsertChild, /* insert_child */ XtInheritDeleteChild, /* delete_child */ NULL, /* extension */ }, /* shell */ { NULL, /* extension */ }, /* override */ { NULL, /* extension */ }, /* ksimple_menu */ { NULL, /* extension */ }, }; WidgetClass ksimpleMenuWidgetClass = (WidgetClass)&ksimpleMenuClassRec; /* * Implementation */ /* * Function: * XkwKSimpleMenuClassInitialize * * Description: * Class Initialize routine, called only once. */ static void XkwKSimpleMenuClassInitialize(void) { XkwInitializeWidgetSet(); XtAddConverter(XtRString, XtRBackingStore, XmuCvtStringToBackingStore, NULL, 0); XtSetTypeConverter(XtRBackingStore, XtRString, XmuCvtBackingStoreToString, NULL, 0, XtCacheNone, NULL); XmuAddInitializer(AddPositionAction, NULL); } /* * Function: * XkwKSimpleMenuClassPartInitialize * Arguments: wc - the widget class of the subclass. * * Description: * Class Part Initialize routine, called for every subclass. Makes * sure that the subclasses pick up the extension record. */ static void XkwKSimpleMenuClassPartInitialize(WidgetClass wc) { KSimpleMenuWidgetClass smwc = (KSimpleMenuWidgetClass)wc; /* * Make sure that our subclass gets the extension rec too */ extension_rec.next_extension = smwc->composite_class.extension; smwc->composite_class.extension = (XtPointer) &extension_rec; } /* * Function: * XkwKSimpleMenuInitialize * * Parameters: * request - widget requested by the argument list * cnew - new widget with both resource and non resource values * * Description: * Initializes the ksimple menu widget. */ /*ARGSUSED*/ static void XkwKSimpleMenuInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSimpleMenuWidget smw = (KSimpleMenuWidget)cnew; Dimension width, height; (void) request; (void) args; (void) num_args; XmuCallInitializers(XtWidgetToApplicationContext(cnew)); if (smw->ksimple_menu.label_class == NULL) smw->ksimple_menu.label_class = ksmeBSBObjectClass; smw->ksimple_menu.label = NULL; smw->ksimple_menu.entry_set = NULL; smw->ksimple_menu.recursive_set_values = False; #ifndef OLDXAW smw->ksimple_menu.sub_menu = NULL; smw->ksimple_menu.state = 0; XtAddCallback(cnew, XtNpopupCallback, PopupCB, NULL); #endif if (smw->ksimple_menu.label_string != NULL) CreateLabel(cnew); width = height = 0; CalculateNewSize(cnew, &width, &height); smw->ksimple_menu.menu_width = True; if (XtWidth(smw) == 0) { smw->ksimple_menu.menu_width = False; XtWidth(smw) = width; } smw->ksimple_menu.menu_height = True; if (XtHeight(smw) == 0) { smw->ksimple_menu.menu_height = False; XtHeight(smw) = height; } /* * Add a popup_callback routine for changing the cursor */ XtAddCallback(cnew, XtNpopupCallback, ChangeCursorOnGrab, NULL); } /* * Function: * XkwKSimpleMenuRedisplay * * Parameters: * w - ksimple menu widget * event - X event that caused this redisplay * region - region the needs to be repainted * * Description: * Redisplays the contents of the widget. */ /*ARGSUSED*/ static void XkwKSimpleMenuRedisplay(Widget w, XEvent *event, Region region) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject *entry; KSmeObjectClass cclass; (void) event; if (region == NULL) { cairo_t *cr = XkwGetCairo(w); XkwSetSource(cr, &smw->ksimple_menu.background); cairo_paint(cr); cairo_destroy(cr); } /* * Check and Paint each of the entries - including the label */ ForAllChildren(smw, entry) { if (!XtIsManaged((Widget)*entry)) continue; if (region != NULL) switch(XRectInRegion(region, XtX(*entry),XtY(*entry), XtWidth(*entry), XtHeight(*entry))) { case RectangleIn: case RectanglePart: break; default: continue; } cclass = (KSmeObjectClass)(*entry)->object.widget_class; if (cclass->rect_class.expose != NULL) (cclass->rect_class.expose)((Widget)*entry, NULL, NULL); } } /* * Function: * XkwKSimpleMenuRealize * * Parameters: * w - ksimple menu widget * mask - value mask for the window to create * attrs - attributes for the window to create * * Description: * Realizes the widget. */ static void XkwKSimpleMenuRealize(Widget gw, XtValueMask *mask, XSetWindowAttributes *attrs) { KSimpleMenuWidget w = (KSimpleMenuWidget)gw; #ifndef OLDXAW XawPixmap *pixmap; #endif attrs->cursor = w->ksimple_menu.cursor; *mask |= CWCursor; if (w->ksimple_menu.backing_store == Always || w->ksimple_menu.backing_store == NotUseful || w->ksimple_menu.backing_store == WhenMapped) { *mask |= CWBackingStore; attrs->backing_store = w->ksimple_menu.backing_store; } else *mask &= ~CWBackingStore; (*Superclass->core_class.realize)(gw, mask, attrs); w->ksimple_menu.surface = XkwGetSurface(gw); #ifndef OLDXAW if (w->core.background_pixmap > XtUnspecifiedPixmap) { pixmap = XawPixmapFromXPixmap(w->core.background_pixmap, XtScreen(w), w->core.colormap, w->core.depth); if (pixmap && pixmap->mask) XawReshapeWidget(w, pixmap); } #endif } /* * Function: * XkwKSimpleMenuResize * * Parameters: * w - ksimple menu widget * * Description: * Handle the menu being resized. */ static void XkwKSimpleMenuResize(Widget gw) { KSimpleMenuWidget w = (KSimpleMenuWidget) gw; if (!XtIsRealized(gw)) return; cairo_surface_destroy(w->ksimple_menu.surface); w->ksimple_menu.surface = XkwGetSurface(gw); Layout(gw, NULL, NULL); XkwKSimpleMenuRedisplay(gw, NULL, NULL); } /* * Function: * XkwKSimpleMenuSetValues * * Parameters: * current - current state of the widget * request - what was requested * cnew - what the widget will become * * Description: * Relayout the menu when one of the resources is changed. */ /*ARGSUSED*/ static Boolean XkwKSimpleMenuSetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSimpleMenuWidget smw_old = (KSimpleMenuWidget)current; KSimpleMenuWidget smw_new = (KSimpleMenuWidget)cnew; Boolean ret_val = False, layout = False; (void) request; (void) args; (void) num_args; if (!XtIsRealized(current)) return (False); if (!smw_new->ksimple_menu.recursive_set_values) { if (XtWidth(smw_new) != XtWidth(smw_old)) { smw_new->ksimple_menu.menu_width = XtWidth(smw_new) != 0; layout = True; } if (XtHeight(smw_new) != XtHeight(smw_old)) { smw_new->ksimple_menu.menu_height = XtHeight(smw_new) != 0; layout = True; } } if (smw_old->ksimple_menu.cursor != smw_new->ksimple_menu.cursor) XDefineCursor(XtDisplay(cnew), XtWindow(cnew), smw_new->ksimple_menu.cursor); if (smw_old->ksimple_menu.label_string !=smw_new->ksimple_menu.label_string) { if (smw_new->ksimple_menu.label_string == NULL) /* Destroy */ XtDestroyWidget((Widget)smw_old->ksimple_menu.label); else if (smw_old->ksimple_menu.label_string == NULL) /* Create */ CreateLabel(cnew); else { /* Change */ Arg arglist[1]; XtSetArg(arglist[0], XtNlabel, smw_new->ksimple_menu.label_string); XtSetValues((Widget)smw_new->ksimple_menu.label, arglist, ONE); } } if (smw_old->ksimple_menu.label_class != smw_new->ksimple_menu.label_class) XtAppWarning(XtWidgetToApplicationContext(cnew), "No Dynamic class change of the KSimpleMenu Label."); if (smw_old->ksimple_menu.top_margin != smw_new->ksimple_menu.top_margin || smw_old->ksimple_menu.bottom_margin != smw_new->ksimple_menu.bottom_margin) { layout = True; ret_val = True; } #ifndef OLDXAW if (smw_old->core.background_pixmap != smw_new->core.background_pixmap) { XawPixmap *opix, *npix; opix = XawPixmapFromXPixmap(smw_old->core.background_pixmap, XtScreen(smw_old), smw_old->core.colormap, smw_old->core.depth); npix = XawPixmapFromXPixmap(smw_new->core.background_pixmap, XtScreen(smw_new), smw_new->core.colormap, smw_new->core.depth); if ((npix && npix->mask) || (opix && opix->mask)) XawReshapeWidget(cnew, npix); } #endif if (layout) Layout(cnew, NULL, NULL); return (ret_val); } /* * Function: * XkwKSimpleMenuSetValuesHook * * Parameters: * w - menu widget * arglist - argument list passed to XtSetValues * num_args - number of args * * Description: * To handle a special case, this is passed the actual arguments. */ static Boolean XkwKSimpleMenuSetValuesHook(Widget w, ArgList arglist, Cardinal *num_args) { Cardinal i; Dimension width, height; width = XtWidth(w); height = XtHeight(w); for (i = 0 ; i < *num_args ; i++) { if (streq(arglist[i].name, XtNwidth)) width = (Dimension)arglist[i].value; if (streq(arglist[i].name, XtNheight)) height = (Dimension) arglist[i].value; } if (width != XtWidth(w) || height != XtHeight(w)) MakeSetValuesRequest(w, width, height); return (False); } /* * Geometry Management routines */ /* * Function: * XkwKSimpleMenuGeometryManager * * Parameters: * w - Menu Entry making the request * request - requested new geometry * reply - the allowed geometry. * * Description: * This is the KSimpleMenu Widget's Geometry Manager. * * Returns: * XtGeometry{Yes, No, Almost} */ static XtGeometryResult XkwKSimpleMenuGeometryManager(Widget w, XtWidgetGeometry *request, XtWidgetGeometry *reply) { KSimpleMenuWidget smw = (KSimpleMenuWidget)XtParent(w); KSmeObject entry = (KSmeObject)w; XtGeometryMask mode = request->request_mode; XtGeometryResult answer; Dimension old_height, old_width; if (!(mode & CWWidth) && !(mode & CWHeight)) return (XtGeometryNo); reply->width = request->width; reply->height = request->height; old_width = XtWidth(entry); old_height = XtHeight(entry); Layout(w, &reply->width, &reply->height); /* * Since we are an override shell and have no parent there is no one to * ask to see if this geom change is okay, so I am just going to assume * we can do whatever we want. If you subclass be very careful with this * assumption, it could bite you. * * Chris D. Peterson - Sept. 1989. */ if ((!(mode & CWWidth) || reply->width == request->width) && (!(mode & CWHeight) || reply->height == request->height)) { if (mode & XtCWQueryOnly) { /* Actually perform the layout */ XtWidth(entry) = old_width; XtHeight(entry) = old_height; } else Layout((Widget)smw, NULL, NULL); answer = XtGeometryDone; } else { XtWidth(entry) = old_width; XtHeight(entry) = old_height; if ((reply->width == request->width && !(mode & CWHeight)) || (reply->height == request->height && !(mode & CWWidth)) || (reply->width == request->width && reply->height == request->height)) answer = XtGeometryNo; else { answer = XtGeometryAlmost; reply->request_mode = 0; if (reply->width != request->width) reply->request_mode |= CWWidth; if (reply->height != request->height) reply->request_mode |= CWHeight; } } return (answer); } /* * Function: * XkwKSimpleMenuChangeManaged * * Parameters: * w - ksimple menu widget * * Description: * Called whenever a new child is managed. */ static void XkwKSimpleMenuChangeManaged(Widget w) { Layout(w, NULL, NULL); } /* * Global Action Routines * * These actions routines will be added to the application's * global action list */ /* * Function: * PositionMenuAction * * Parameters: * w - a widget (no the ksimple menu widget) * event - the event that caused this action * params - parameters passed to the routine. * we expect the name of the menu here. * num_params - "" * * Description: * Positions the ksimple menu widget. */ /*ARGSUSED*/ static void PositionMenuAction(Widget w, XEvent *event, String *params, Cardinal *num_params) { Widget menu; XPoint loc; if (*num_params != 1) { XtAppWarning(XtWidgetToApplicationContext(w), "KSimpleMenuWidget: position menu action expects " "only one parameter which is the name of the menu."); return; } if ((menu = FindMenu(w, params[0])) == NULL) { char error_buf[BUFSIZ]; snprintf(error_buf, sizeof(error_buf), "KSimpleMenuWidget: could not find menu named %s.", params[0]); XtAppWarning(XtWidgetToApplicationContext(w), error_buf); return; } switch (event->type) { case ButtonPress: case ButtonRelease: loc.x = event->xbutton.x_root; loc.y = event->xbutton.y_root; PositionMenu(menu, &loc); break; case EnterNotify: case LeaveNotify: loc.x = event->xcrossing.x_root; loc.y = event->xcrossing.y_root; PositionMenu(menu, &loc); break; case MotionNotify: loc.x = event->xmotion.x_root; loc.y = event->xmotion.y_root; PositionMenu(menu, &loc); break; default: PositionMenu(menu, NULL); break; } } /* * Widget Action Routines */ /* * Function: * Unhighlight * * Parameters: * w - ksimple menu widget * event - event that caused this action * params - not used * num_params - "" * * Description: * Unhighlights current entry. */ /*ARGSUSED*/ static void Unhighlight(Widget w, XEvent *event, String *params, Cardinal *num_params) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject entry = smw->ksimple_menu.entry_set; (void) event; (void) params; (void) num_params; if (entry == NULL) return; #ifndef OLDXAW if (!smw->ksimple_menu.sub_menu) #endif { KSmeObjectClass cclass; smw->ksimple_menu.entry_set = NULL; cclass = (KSmeObjectClass)entry->object.widget_class; (cclass->sme_class.unhighlight)((Widget)entry); } } /* * Function: * Highlight * * Parameters: * w - ksimple menu widget * event - event that caused this action * params - not used * num_params - "" * * Description: * Highlights current entry. */ /*ARGSUSED*/ static void Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject entry; if (!XtIsSensitive(w)) return; entry = GetEventEntry(w, event); if (entry == smw->ksimple_menu.entry_set) return; #ifndef OLDXAW if (!smw->ksimple_menu.sub_menu) #endif Unhighlight(w, event, params, num_params); if (entry == NULL) return; if (!XtIsSensitive((Widget)entry)) return; #ifndef OLDXAW if (smw->ksimple_menu.sub_menu) PopdownSubMenu(smw); #endif Unhighlight(w, event, params, num_params); #ifndef OLDXAW if (!(smw->ksimple_menu.state & SMW_UNMAPPING)) #endif { KSmeObjectClass cclass; smw->ksimple_menu.entry_set = entry; cclass = (KSmeObjectClass)entry->object.widget_class; (cclass->sme_class.highlight)((Widget)entry); #ifndef OLDXAW if (XtIsSubclass((Widget)entry, smeBSBObjectClass)) PopupSubMenu(smw); #endif } } /* * Function: * Notify * * Parameters: * w - ksimple menu widget * event - event that caused this action * params - not used * num_params - "" * * Description: * Notify user of current entry. */ /*ARGSUSED*/ static void Notify(Widget w, XEvent *event, String *params, Cardinal *num_params) { KSmeObject entry; KSmeObjectClass cclass; (void) params; (void) num_params; /* may be a propagated event from a sub menu, need to check it */ if (XtWindow(w) != event->xany.window) return; entry = GetEventEntry(w, event); if (entry == NULL || !XtIsSensitive((Widget)entry)) return; cclass = (KSmeObjectClass) entry->object.widget_class; (cclass->sme_class.notify)((Widget)entry); } /* * Public Functions */ /* * Function: * XkwKSimpleMenuAddGlobalActions * * Arguments: * app_con - appcontext * * Description: * Adds the global actions to the ksimple menu widget. */ void XkwKSimpleMenuAddGlobalActions(XtAppContext app_con) { XtInitializeWidgetClass(ksimpleMenuWidgetClass); XmuCallInitializers(app_con); } /* * Function: * XkwKSimpleMenuGetActiveEntry * * Parameters: * w - smw widget * * Description: * Gets the currently active (set) entry. * * Returns: * The currently set entry or NULL if none is set */ Widget XkwKSimpleMenuGetActiveEntry(Widget w) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; return ((Widget)smw->ksimple_menu.entry_set); } /* * Function: * XkwKSimpleMenuClearActiveEntry * * Parameters: * w - smw widget * * Description: * Unsets the currently active (set) entry. */ void XkwKSimpleMenuClearActiveEntry(Widget w) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; smw->ksimple_menu.entry_set = NULL; } /* * Private Functions */ /* * Function: * CreateLabel * * Parameters: * w - smw widget * * Description: * Creates the label object and makes sure it is the first child in * in the list. */ static void CreateLabel(Widget w) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; Widget *child, *next_child; int i; Arg args[2]; if (smw->ksimple_menu.label_string == NULL || smw->ksimple_menu.label != NULL) { XtAppWarning(XtWidgetToApplicationContext(w), "Xaw KSimple Menu Widget: label string is NULL or " "label already exists, no label is being created."); return; } XtSetArg(args[0], XtNlabel, smw->ksimple_menu.label_string); XtSetArg(args[1], XtNjustify, XtJustifyCenter); smw->ksimple_menu.label = (KSmeObject) XtCreateManagedWidget("menuLabel", smw->ksimple_menu.label_class, w, args, TWO); next_child = NULL; for (child = smw->composite.children + smw->composite.num_children, i = smw->composite.num_children; i > 0; i--, child--) { if (next_child != NULL) *next_child = *child; next_child = child; } *child = (Widget)smw->ksimple_menu.label; } /* * Function: * Layout * * Arguments: * w - See below * width_ret - returned width * height_ret - returned height * * Note: * if width == NULL || height == NULL then it assumes the you do not care * about the return values, and just want a relayout. * * if this is not the case then it will set width_ret and height_ret * to be width and height that the child would get if it were layed out * at this time. * * "w" can be the ksimple menu widget or any of its object children. */ static void Layout(Widget w, Dimension *width_ret, Dimension *height_ret) { KSmeObject current_entry; KSimpleMenuWidget smw; Dimension width, height; Boolean allow_change_size; Widget kid; Cardinal i, count, n; int width_kid, height_kid, tmp_w, tmp_h; short vadd, hadd, x_ins, y_ins; Dimension *widths; height = 0; if (XtIsSubclass(w, ksimpleMenuWidgetClass)) { smw = (KSimpleMenuWidget)w; current_entry = NULL; } else { smw = (KSimpleMenuWidget)XtParent(w); current_entry = (KSmeObject)w; } allow_change_size = (!XtIsRealized((Widget)smw) || smw->shell.allow_shell_resize); for (i = smw->ksimple_menu.label ? 1 : 0; i < smw->composite.num_children; i++) { XtWidgetGeometry preferred; kid = smw->composite.children[i]; if (!XtIsManaged(kid)) continue; if (smw->ksimple_menu.row_height != 0) XtHeight(kid) = smw->ksimple_menu.row_height; XtQueryGeometry(kid, NULL, &preferred); if (preferred.request_mode & CWWidth) XtWidth(kid) = preferred.width; } if (smw->ksimple_menu.label && XtIsManaged((Widget)smw->ksimple_menu.label)) { XtWidgetGeometry preferred; kid = (Widget)smw->ksimple_menu.label; XtQueryGeometry(kid, NULL, &preferred); if (preferred.request_mode & CWWidth) XtWidth(kid) = preferred.width; if (preferred.request_mode & CWHeight) XtHeight(kid) = preferred.height; } /* reset */ if (!smw->ksimple_menu.menu_width) XtWidth(smw) = 0; if (!smw->ksimple_menu.menu_height) XtHeight(smw) = 0; if (!XtWidth(smw) || !XtHeight(smw)) MakeResizeRequest((Widget)smw); widths = (Dimension *)XtMalloc(sizeof(Dimension)); #ifndef OLDXAW hadd = smw->ksimple_menu.left_margin; #else hadd = 0; #endif vadd = smw->ksimple_menu.top_margin; if (smw->ksimple_menu.label) vadd += XtHeight(smw->ksimple_menu.label); count = 1; width = tmp_w = tmp_h = n = 0; height = vadd; for (i = smw->ksimple_menu.label ? 1 : 0; i < smw->composite.num_children; i++) { kid = smw->composite.children[i]; if (!XtIsManaged(kid)) continue; width_kid = XtWidth(kid); height_kid = XtHeight(kid); if (n && (height + height_kid + smw->ksimple_menu.bottom_margin > XtHeight(smw))) { ++count; widths = (Dimension *)XtRealloc((char *)widths, sizeof(Dimension) * count); widths[count - 1] = width_kid; width += tmp_w; tmp_w = width_kid; height = height_kid + vadd; } else height += height_kid; if (height > tmp_h) tmp_h = height; if (width_kid > tmp_w) widths[count - 1] = tmp_w = width_kid; ++n; } height = tmp_h + smw->ksimple_menu.bottom_margin; width += tmp_w; if (smw->ksimple_menu.label && width < XtWidth(smw->ksimple_menu.label)) { float inc; inc = (XtWidth(smw->ksimple_menu.label) - width) / (float)count; width = XtWidth(smw->ksimple_menu.label); for (n = 0; n < count; n++) widths[n] += inc; } #ifndef OLDXAW width += hadd + smw->ksimple_menu.right_margin; #endif x_ins = n = count = 0; tmp_w = widths[0]; tmp_h = vadd; for (i = smw->ksimple_menu.label ? 1 : 0; i < smw->composite.num_children; i++) { kid = smw->composite.children[i]; if (!XtIsManaged(kid)) continue; height_kid = XtHeight(kid); if (n && (tmp_h + height_kid + smw->ksimple_menu.bottom_margin > XtHeight(smw))) { x_ins = tmp_w; y_ins = vadd; ++count; tmp_w += widths[count]; tmp_h = height_kid + vadd; } else { y_ins = tmp_h; tmp_h += height_kid; } ++n; XtX(kid) = x_ins + hadd; XtY(kid) = y_ins; XtWidth(kid) = widths[count]; } XtFree((char *)widths); if (allow_change_size) MakeSetValuesRequest((Widget) smw, width, height); if (smw->ksimple_menu.label) { XtX(smw->ksimple_menu.label) = 0; XtY(smw->ksimple_menu.label) = smw->ksimple_menu.top_margin; XtWidth(smw->ksimple_menu.label) = XtWidth(smw) #ifndef OLDXAW - (smw->ksimple_menu.left_margin + smw->ksimple_menu.right_margin) #endif ; } if (current_entry) { if (width_ret) *width_ret = XtWidth(current_entry); if (height_ret) *height_ret = XtHeight(current_entry); } } /* * Function: * AddPositionAction * * Parameters: * app_con - application context * data - (not used) * * Description: * Adds the XawPositionKSimpleMenu action to the global * action list for this appcon. */ /*ARGSUSED*/ static void AddPositionAction(XtAppContext app_con, XPointer data) { static XtActionsRec pos_action[] = { {"XawPositionKSimpleMenu", PositionMenuAction}, }; (void) data; XtAppAddActions(app_con, pos_action, XtNumber(pos_action)); } /* * Function: * FindMenu * * Parameters: * widget - reference widget * name - menu widget's name * * Description: * Find the menu give a name and reference widget * * Returns: * The menu widget or NULL. */ static Widget FindMenu(Widget widget, String name) { Widget w, menu; for (w = widget; w != NULL; w = XtParent(w)) if ((menu = XtNameToWidget(w, name)) != NULL) return (menu); return (NULL); } /* * Function: * PositionMenu * * Parameters: * w - ksimple menu widget * location - pointer the the position or NULL * * Description: * Places the menu */ static void PositionMenu(Widget w, XPoint *location) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject entry; XPoint t_point; if (location == NULL) { Window temp1, temp2; int root_x, root_y, tempX, tempY; unsigned int tempM; location = &t_point; if (XQueryPointer(XtDisplay(w), XtWindow(w), &temp1, &temp2, &root_x, &root_y, &tempX, &tempY, &tempM) == False) { XtAppWarning(XtWidgetToApplicationContext(w), "Xaw KSimple Menu Widget: " "Could not find location of mouse pointer"); return; } location->x = (short) root_x; location->y = (short) root_y; } /* * The width will not be correct unless it is realized */ XtRealizeWidget(w); location->x -= XtWidth(w) >> 1; if (smw->ksimple_menu.popup_entry == NULL) entry = smw->ksimple_menu.label; else entry = smw->ksimple_menu.popup_entry; if (entry != NULL) location->y -= XtY(entry) + (XtHeight(entry) >> 1); MoveMenu(w, location->x, location->y); } /* * Function: * MoveMenu * * Parameters: * w - ksimple menu widget * x - current location of the widget * y - "" * * Description: * Actually moves the menu, may force it to * to be fully visable if menu_on_screen is True. */ static void MoveMenu(Widget w, int x, int y) { Arg arglist[2]; Cardinal num_args = 0; KSimpleMenuWidget smw = (KSimpleMenuWidget)w; if (smw->ksimple_menu.menu_on_screen) { int width = XtWidth(w) + (XtBorderWidth(w) << 1); int height = XtHeight(w) + (XtBorderWidth(w) << 1); if (x >= 0) { int scr_width = WidthOfScreen(XtScreen(w)); if (x + width > scr_width) x = scr_width - width; } if (x < 0) x = 0; if (y >= 0) { int scr_height = HeightOfScreen(XtScreen(w)); if (y + height > scr_height) y = scr_height - height; } if (y < 0) y = 0; } XtSetArg(arglist[num_args], XtNx, x); num_args++; XtSetArg(arglist[num_args], XtNy, y); num_args++; XtSetValues(w, arglist, num_args); } /* * Function: * ChangeCursorOnGrab * * Parameters: * w - menu widget * temp1 - not used * temp2 - "" * * Description: * Changes the cursor on the active grab to the one * specified in out resource list. */ /*ARGSUSED*/ static void ChangeCursorOnGrab(Widget w, XtPointer temp1, XtPointer temp2) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; (void) temp1; (void) temp2; /* * The event mask here is what is currently in the MIT implementation. * There really needs to be a way to get the value of the mask out * of the toolkit (CDP 5/26/89). */ XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask | ButtonReleaseMask, smw->ksimple_menu.cursor, XtLastTimestampProcessed(XtDisplay(w))); } /* * Function: * MakeSetValuesRequest * * Parameters: * w - ksimple menu widget * width - size requested * height - "" */ static void MakeSetValuesRequest(Widget w, unsigned int width, unsigned int height) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; Arg arglist[2]; Cardinal num_args = 0; if (!smw->ksimple_menu.recursive_set_values) { if (XtWidth(smw) != width || XtHeight(smw) != height) { smw->ksimple_menu.recursive_set_values = True; XtSetArg(arglist[num_args], XtNwidth, width); num_args++; XtSetArg(arglist[num_args], XtNheight, height); num_args++; XtSetValues(w, arglist, num_args); } else if (XtIsRealized((Widget)smw)) XkwKSimpleMenuRedisplay((Widget)smw, NULL, NULL); } smw->ksimple_menu.recursive_set_values = False; } static KSmeObject DoGetEventEntry(Widget w, int x_loc, int y_loc) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject *entry; ForAllChildren(smw, entry) { if (!XtIsManaged((Widget)*entry)) continue; if (x_loc > XtX(*entry) && x_loc <= XtX(*entry) + XtWidth(*entry) && y_loc > XtY(*entry) && y_loc <= XtY(*entry) + XtHeight(*entry)) { if (*entry == smw->ksimple_menu.label) return (NULL); /* cannot select the label */ else return (*entry); } } return (NULL); } /* * Function: * GetEventEntry * * Parameters: * w - ksimple menu widget * event - X event * * Description: * Gets an entry given an event that has X and Y coords. * * Returns: * The entry that this point is in */ static KSmeObject GetEventEntry(Widget w, XEvent *event) { int x_loc, y_loc, x_root; KSimpleMenuWidget smw = (KSimpleMenuWidget)w; KSmeObject entry; int warp, move; switch (event->type) { case MotionNotify: x_loc = event->xmotion.x; y_loc = event->xmotion.y; x_root = event->xmotion.x_root; break; case EnterNotify: case LeaveNotify: x_loc = event->xcrossing.x; y_loc = event->xcrossing.y; x_root = event->xcrossing.x_root; break; case ButtonPress: case ButtonRelease: x_loc = event->xbutton.x; y_loc = event->xbutton.y; x_root = event->xbutton.x_root; break; default: XtAppError(XtWidgetToApplicationContext(w), "Unknown event type in GetEventEntry()."); return (NULL); } if (x_loc < 0 || x_loc >= XtWidth(smw) || y_loc < 0 || y_loc >= XtHeight(smw)) return (NULL); /* Move the menu if it's outside the screen, does not check * smw->ksimple_menu.menu_on_screen because menus is bigger than screen */ if (x_root == WidthOfScreen(XtScreen(w)) - 1 && XtX(w) + XtWidth(w) + (XtBorderWidth(w)) > x_root) { warp = -8; if (smw->ksimple_menu.entry_set) { entry = DoGetEventEntry(w, XtX(smw->ksimple_menu.entry_set) + XtWidth(smw->ksimple_menu.entry_set) + 1, y_loc); Unhighlight(w, event, NULL, NULL); if (entry) { warp = -(int)XtWidth(entry) >> 1; move = x_loc - XtWidth(entry) - XtX(entry) + XtBorderWidth(w); } else { warp = 0; move = WidthOfScreen(XtScreen(w)) - (XtX(w) + XtWidth(w) + (XtBorderWidth(w) << 1)); } } else { warp = 0; move = WidthOfScreen(XtScreen(w)) - (XtX(w) + XtWidth(w) + (XtBorderWidth(w) << 1)); } } else if (x_root == 0 && XtX(w) < 0) { warp = 8; if (smw->ksimple_menu.entry_set) { entry = DoGetEventEntry(w, XtX(smw->ksimple_menu.entry_set) - 1, y_loc); Unhighlight(w, event, NULL, NULL); if (entry) { warp = XtWidth(entry) >> 1; move = x_loc - XtX(entry); } else move = x_loc + XtBorderWidth(w); } else move = x_loc + XtBorderWidth(w); } else move = warp = 0; if (move) XtMoveWidget(w, XtX(w) + move, XtY(w)); if (warp) XWarpPointer(XtDisplay(w), None, None, 0, 0, 0, 0, warp, 0); return (DoGetEventEntry(w, x_loc, y_loc)); } static void CalculateNewSize(Widget w, Dimension *width_return, Dimension *height_return) { KSimpleMenuWidget xaw = (KSimpleMenuWidget)w; Widget kid; Cardinal i; int width_kid, height_kid; int width, height, tmp_w, tmp_h, max_dim; short vadd, hadd; int n, columns, test_h, num_children = 0; Boolean try_layout = False; #ifndef OLDXAW hadd = xaw->ksimple_menu.left_margin + xaw->ksimple_menu.right_margin; #else hadd = 0; #endif vadd = xaw->ksimple_menu.top_margin + xaw->ksimple_menu.bottom_margin; if (xaw->ksimple_menu.label) vadd += XtHeight(xaw->ksimple_menu.label); if (*height_return) max_dim = *height_return; else if (!XtHeight(w)) { max_dim = HeightOfScreen(XtScreen(w)); try_layout = True; } else max_dim = XtHeight(w); max_dim -= vadd; width = height = tmp_w = tmp_h = n = test_h = 0; columns = 1; for (i = xaw->ksimple_menu.label ? 1 : 0; i < xaw->composite.num_children; i++) { kid = xaw->composite.children[i]; if (!XtIsManaged(kid)) continue; ++num_children; width_kid = XtWidth(kid); height_kid = XtHeight(kid); if (try_layout) { if (!test_h) test_h = height_kid; else if (test_h != height_kid) try_layout = False; } if (n && (height + height_kid > max_dim)) { ++columns; width += tmp_w; tmp_w = width_kid; height = height_kid; } else height += height_kid; if (height > tmp_h) tmp_h = height; if (width_kid > tmp_w) tmp_w = width_kid; ++n; } height = tmp_h + vadd; width += tmp_w + hadd; if (xaw->ksimple_menu.label) { int nwidth = XtWidth(xaw->ksimple_menu.label) + hadd; if (nwidth > width) width = nwidth; } *width_return = width; *height_return = height; if (try_layout && columns > 1 && num_children > 2) { int space; height = test_h * (xaw->ksimple_menu.label ? num_children - 1 : num_children); max_dim -= max_dim % test_h; space = max_dim - (height % max_dim); if (space >= test_h * columns) { height = max_dim - space / columns; if (height % test_h) height += test_h - (height % test_h); *height_return = height + vadd; CalculateNewSize(w, width_return, height_return); } } } static void MakeResizeRequest(Widget w) { int tries; Dimension width, height; width = XtWidth(w); height = XtHeight(w); for (tries = 0; tries < 100; tries++) { CalculateNewSize(w, &width, &height); if (width == XtWidth(w) && height == XtHeight(w)) break; if (XtMakeResizeRequest(w, width, height, &width, &height) == XtGeometryNo) break; } } #ifndef OLDXAW static void Popdown(Widget w, XEvent *event, String *params, Cardinal *num_params) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; while (XtParent(w) && XtIsSubclass(XtParent(w), ksimpleMenuWidgetClass)) { if (((KSimpleMenuWidget)XtParent(w))->ksimple_menu.sub_menu == (Widget)w) { w = XtParent(w); smw = (KSimpleMenuWidget)w; smw->ksimple_menu.entry_set = NULL; } else break; } smw->ksimple_menu.state |= SMW_UNMAPPING; if (smw->ksimple_menu.sub_menu) PopdownSubMenu(smw); XtCallActionProc(w, "XtMenuPopdown", event, params, *num_params); } static void PopupSubMenu(KSimpleMenuWidget smw) { Arg args[2]; Cardinal num_args; Widget menu; KSmeBSBObject entry = (KSmeBSBObject)smw->ksimple_menu.entry_set; Position menu_x, menu_y; Bool popleft; if (entry->sme_bsb.menu_name == NULL) return; if ((menu = FindMenu((Widget)smw, entry->sme_bsb.menu_name)) == NULL) return; smw->ksimple_menu.sub_menu = menu; if (!XtIsRealized(menu)) XtRealizeWidget(menu); popleft = (smw->ksimple_menu.state & SMW_POPLEFT) != 0; if (popleft) XtTranslateCoords((Widget)smw, -(int)XtWidth(menu), XtY(entry) - XtBorderWidth(menu), &menu_x, &menu_y); else XtTranslateCoords((Widget)smw, XtWidth(smw), XtY(entry) - XtBorderWidth(menu), &menu_x, &menu_y); if (!popleft && menu_x >= 0) { int scr_width = WidthOfScreen(XtScreen(menu)); if (menu_x + XtWidth(menu) > scr_width) { menu_x -= XtWidth(menu) + XtWidth(smw); popleft = True; } } else if (popleft && menu_x < 0) { menu_x = 0; popleft = False; } if (menu_y >= 0) { int scr_height = HeightOfScreen(XtScreen(menu)); if (menu_y + XtHeight(menu) > scr_height) menu_y = scr_height - XtHeight(menu) - XtBorderWidth(menu); } if (menu_y < 0) menu_y = 0; num_args = 0; XtSetArg(args[num_args], XtNx, menu_x); num_args++; XtSetArg(args[num_args], XtNy, menu_y); num_args++; XtSetValues(menu, args, num_args); if (popleft) ((KSimpleMenuWidget)menu)->ksimple_menu.state |= SMW_POPLEFT; else ((KSimpleMenuWidget)menu)->ksimple_menu.state &= ~SMW_POPLEFT; XtPopup(menu, XtGrabNone); } static void PopdownSubMenu(KSimpleMenuWidget smw) { KSimpleMenuWidget menu = (KSimpleMenuWidget)smw->ksimple_menu.sub_menu; if (!menu) return; menu->ksimple_menu.state |= SMW_UNMAPPING; PopdownSubMenu(menu); XtPopdown((Widget)menu); smw->ksimple_menu.sub_menu = NULL; } /*ARGSUSED*/ static void PopupCB(Widget w, XtPointer client_data, XtPointer call_data) { KSimpleMenuWidget smw = (KSimpleMenuWidget)w; smw->ksimple_menu.state &= ~(SMW_UNMAPPING | SMW_POPLEFT); } #endif /* OLDXAW */ kgames-2.2/Xkw/KSimpleMenu.h000066400000000000000000000114661416764561500157660ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Chris D. Peterson, MIT X Consortium */ /* * SimpleMenu.h - Public Header file for SimpleMenu widget. * * This is the public header file for the Athena SimpleMenu widget. * It is intended to provide one pane pulldown and popup menus within * the framework of the X Toolkit. As the name implies it is a first and * by no means complete implementation of menu code. It does not attempt to * fill the needs of all applications, but does allow a resource oriented * interface to menus. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSimpleMenu_h #define _KSimpleMenu_h #include #include /* * SimpleMenu widget */ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground backgroundPixmap BackgroundPixmap Pixmap None borderColor BorderColor Pixel XtDefaultForeground borderPixmap BorderPixmap Pixmap None borderWidth BorderWidth Dimension 1 bottomMargin VerticalMargins Dimension VerticalSpace columnWidth ColumnWidth Dimension Width of widest text cursor Cursor Cursor None destroyCallback Callback Pointer NULL displayList DisplayList XawDisplayList* NULL height Height Dimension 0 label Label String NULL (No label) labelClass LabelClass Pointer smeBSBObjectClass leftMargin HorizontalMargins Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True rightMargin HorizontalMargins Dimension 0 rowHeight RowHeight Dimension Height of Font sensitive Sensitive Boolean True topMargin VerticalMargins Dimension VerticalSpace width Width Dimension 0 x Position Position 0 y Position Position 0 */ typedef struct _KSimpleMenuClassRec* KSimpleMenuWidgetClass; typedef struct _KSimpleMenuRec* KSimpleMenuWidget; extern WidgetClass ksimpleMenuWidgetClass; #define XtNcursor "cursor" #define XtNbottomMargin "bottomMargin" #define XtNcolumnWidth "columnWidth" #define XtNlabelClass "labelClass" #define XtNmenuOnScreen "menuOnScreen" #define XtNpopupOnEntry "popupOnEntry" #define XtNrowHeight "rowHeight" #define XtNtopMargin "topMargin" #define XtNleftMargin "leftMargin" #define XtNrightMargin "rightMargin" #define XtCColumnWidth "ColumnWidth" #define XtCLabelClass "LabelClass" #define XtCMenuOnScreen "MenuOnScreen" #define XtCPopupOnEntry "PopupOnEntry" #define XtCRowHeight "RowHeight" #define XtCVerticalMargins "VerticalMargins" #ifndef OLDXAW #define XtCHorizontalMargins "HorizontalMargins" #define XawNdisplayList "displayList" #define XawCDisplayList "DisplayList" #define XawRDisplayList "XawDisplayList" #endif /* * Public Functions */ _XFUNCPROTOBEGIN /* * Function: * XkwKSimpleMenuAddGlobalActions * * Parameters: * app_con - appcontext * * Description: * Adds the global actions to the simple menu widget. */ void XkwKSimpleMenuAddGlobalActions ( XtAppContext app_con ); /* * Function: * XkwKSimpleMenuGetActiveEntry * * Parameters: * w - smw widget * * Description: * Gets the currently active (set) entry. * * Returns: * The currently set entry or NULL if none is set */ Widget XkwKSimpleMenuGetActiveEntry ( Widget w ); /* * Function: * XkwKSimpleMenuClearActiveEntry * * Parameters: * w - smw widget * * Description: * Unsets the currently active (set) entry. */ void XkwKSimpleMenuClearActiveEntry ( Widget w ); _XFUNCPROTOEND #endif /* _KSimpleMenu_h */ kgames-2.2/Xkw/KSimpleMenuP.h000066400000000000000000000064321416764561500161030ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * */ /* * SimpleMenuP.h - Private Header file for SimpleMenu widget. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSimpleMenuP_h #define _KSimpleMenuP_h #include #include #include #include typedef struct { XtPointer extension; /* For future needs */ } KSimpleMenuClassPart; typedef struct _KSimpleMenuClassRec { CoreClassPart core_class; CompositeClassPart composite_class; ShellClassPart shell_class; OverrideShellClassPart override_shell_class; KSimpleMenuClassPart ksimpleMenu_class; } KSimpleMenuClassRec; extern KSimpleMenuClassRec ksimpleMenuClassRec; typedef struct _KSimpleMenuPart { /* resources */ String label_string; /* The string for the label or NULL */ KSmeObject label; /* If label_string is non-NULL then this is the label widget */ XRenderColor background; XRenderColor foreground; WidgetClass label_class; /* Widget Class of the menu label object */ Dimension top_margin; /* Top and bottom margins */ Dimension bottom_margin; Dimension row_height; /* height of each row (menu entry) */ Cursor cursor; /* The menu's cursor */ KSmeObject popup_entry; /* The entry to position the cursor on for when using XawPositionKSimpleMenu */ Boolean menu_on_screen; /* Force the menus to be fully on the screen*/ int backing_store; /* What type of backing store to use */ /* private */ cairo_surface_t *surface; Dimension surface_width; Dimension surface_height; Boolean recursive_set_values; /* contain a possible infinite loop */ Boolean menu_width; /* If true then force width to remain core.width */ Boolean menu_height; /* Just like menu_width, but for height */ KSmeObject entry_set; /* The entry that is currently set or highlighted */ } KSimpleMenuPart; typedef struct _KSimpleMenuRec { CorePart core; CompositePart composite; ShellPart shell; OverrideShellPart override; KSimpleMenuPart ksimple_menu; } KSimpleMenuRec; #endif /* _KSimpleMenuP_h */ kgames-2.2/Xkw/KSimpleP.h000066400000000000000000000041131416764561500152500ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKSimpleP_h_ #define _XkwKSimpleP_h_ #include #include #include #include #include _XFUNCPROTOBEGIN typedef struct { int unused; } KSimpleClassPart; typedef struct _KSimpleClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; } KSimpleClassRec; extern KSimpleClassRec ksimpleClassRec; typedef struct { /* resources */ XRenderColor background; XRenderColor foreground; double dpi; Boolean want_forward; /* does this widget want event forwarding */ /* private */ cairo_surface_t *surface; Dimension surface_width; Dimension surface_height; } KSimplePart; typedef struct _KSimpleRec { CorePart core; SimplePart simple; KSimplePart ksimple; } KSimpleRec; _XFUNCPROTOEND #endif /* _XkwKSimple_h_ */ kgames-2.2/Xkw/KSme.c000066400000000000000000000146201416764561500144220ustar00rootroot00000000000000/* Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * Date: September 26, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include /* * Class Methods */ static void Highlight(Widget); static void Notify(Widget); static void Unhighlight(Widget); static void XkwKSmeClassPartInitialize(WidgetClass); static void XkwKSmeInitialize(Widget, Widget, ArgList, Cardinal*); static XtGeometryResult XkwKSmeQueryGeometry(Widget, XtWidgetGeometry*, XtWidgetGeometry*); /* * Initialization */ #define offset(field) XtOffsetOf(KSmeRec, ksme.field) static XtResource resources[] = { { XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(callbacks), XtRCallback, NULL }, { XtNinternational, XtCInternational, XtRBoolean, sizeof(Boolean), offset(international), XtRImmediate, (XtPointer)False }, }; #undef offset #define Superclass (&rectObjClassRec) KSmeClassRec ksmeClassRec = { /* rectangle */ { (WidgetClass)Superclass, /* superclass */ "KSme", /* class_name */ sizeof(KSmeRec), /* widget_size */ XkwInitializeWidgetSet, /* class_initialize */ XkwKSmeClassPartInitialize, /* class_part_initialize */ False, /* class_initialized */ XkwKSmeInitialize, /* initialize */ NULL, /* initialize_hook */ NULL, /* realize */ NULL, /* actions */ 0, /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ False, /* compress_motion */ False, /* compress_exposure */ False, /* compress_enterleave */ False, /* visible_interest */ NULL, /* destroy */ XtInheritResize, /* resize */ NULL, /* expose */ NULL, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* intrinsics_version */ NULL, /* callback offsets */ NULL, /* tm_table */ XkwKSmeQueryGeometry, /* query_geometry */ NULL, /* display_accelerator */ NULL, /* extension */ }, /* sme */ { Highlight, /* highlight */ Unhighlight, /* unhighlight */ Notify, /* notify */ NULL, /* extension */ } }; WidgetClass ksmeObjectClass = (WidgetClass)&ksmeClassRec; /* * Implementation */ /* * Function: * XkwKSmeClassPartInitialize * * Parameters: * cclass - widget classs of this widget * * Description: * Handles inheritance of class functions. */ static void XkwKSmeClassPartInitialize(WidgetClass cclass) { KSmeObjectClass m_ent, superC; m_ent = (KSmeObjectClass)cclass; superC = (KSmeObjectClass)m_ent->rect_class.superclass; if (m_ent->sme_class.highlight == XtInheritHighlight) m_ent->sme_class.highlight = superC->sme_class.highlight; if (m_ent->sme_class.unhighlight == XtInheritUnhighlight) m_ent->sme_class.unhighlight = superC->sme_class.unhighlight; if (m_ent->sme_class.notify == XtInheritNotify) m_ent->sme_class.notify = superC->sme_class.notify; } /* * Function: * XkwKSmeInitialize * * Parameters: * request - widget requested by the argument list * cnew - new widget with both resource and non resource values * * Description: * Initializes the simple menu widget entry */ /*ARGSUSED*/ static void XkwKSmeInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSmeObject entry = (KSmeObject)cnew; (void) request; (void) args; (void) num_args; entry->rectangle.border_width = 0; } /* * Function: * Highlight * * Parameters: * w - menu entry * * Description: * Default highlight proceedure for menu entries. */ /*ARGSUSED*/ static void Highlight(Widget w) { (void) w; } /* * Function: * Unhighlight * * Parameters: * w - menu entry * * Description: * Default unhighlight proceedure for menu entries. */ /*ARGSUSED*/ static void Unhighlight(Widget w) { (void) w; } /* * Function: * Notify * * Parameters: * w - menu entry * * Description: * Calls the callback proceedures for this entry. */ static void Notify(Widget w) { XtCallCallbacks(w, XtNcallback, NULL); } /* * Function: * QueryGeometry * * Parameeters: * w - menu entry object * itended - intended and return geometry info * return_val - * * Description: * Returns the preferred geometry for this widget. * * Returns: * Geometry Result * * Note: * See the Intrinsics manual for details on what this function is for. */ static XtGeometryResult XkwKSmeQueryGeometry(Widget w, XtWidgetGeometry *intended, XtWidgetGeometry *return_val) { KSmeObject entry = (KSmeObject)w; Dimension width; XtGeometryResult ret_val = XtGeometryYes; XtGeometryMask mode = intended->request_mode; width = 1; if (((mode & CWWidth) && intended->width != width) || !(mode & CWWidth)) { return_val->request_mode |= CWWidth; return_val->width = width; mode = return_val->request_mode; if ((mode & CWWidth) && width == XtWidth(entry)) return (XtGeometryNo); return (XtGeometryAlmost); } return (ret_val); } kgames-2.2/Xkw/KSme.h000066400000000000000000000041401416764561500144230ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * This is the public header file for the Athena KSme object. * It is intended to be used with the simple menu widget. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSme_h #define _KSme_h #include #include /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- callback Callback Pointer NULL destroyCallback Callback Pointer NULL height Height Dimension 0 sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ #ifndef XtCInternational #define XtCInternational "International" #endif #ifndef XtNinternational #define XtNinternational "international" #endif typedef struct _KSmeClassRec *KSmeObjectClass; typedef struct _KSmeRec *KSmeObject; extern WidgetClass ksmeObjectClass; #endif /* _KSme_h */ kgames-2.2/Xkw/KSmeBSB.c000066400000000000000000000365011416764561500147530ustar00rootroot00000000000000/* Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * KSmeBSB.c - Source code file for BSB Menu Entry object. * * Date: September 26, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #define ONE_HUNDRED 100 /* * Class Methods */ static void FlipColors(Widget); static void XkwKSmeBSBClassInitialize(void); static void XkwKSmeBSBInitialize(Widget, Widget, ArgList, Cardinal*); static void XkwKSmeBSBDestroy(Widget); static XtGeometryResult XkwKSmeBSBQueryGeometry(Widget, XtWidgetGeometry*, XtWidgetGeometry*); static void XkwKSmeBSBRedisplay(Widget, XEvent*, Region); static Boolean XkwKSmeBSBSetValues(Widget, Widget, Widget, ArgList, Cardinal*); /* * Prototypes */ static void GetBitmapInfo(Widget, Bool); static void GetDefaultSize(Widget, Dimension*, Dimension*); static void DrawBitmaps(Widget, cairo_t *); /* * Initialization */ #define offset(field) XtOffsetOf(KSmeBSBRec, ksme_bsb.field) static XtResource resources[] = { { XtNlabel, XtCLabel, XtRString, sizeof(String), offset(label), XtRString, NULL }, { XtNvertSpace, XtCVertSpace, XtRInt, sizeof(int), offset(vert_space), XtRImmediate, (XtPointer)25 }, { XtNleftBitmap, XtCLeftBitmap, XtRBitmap, sizeof(Pixmap), offset(left_bitmap), XtRImmediate, (XtPointer)None }, { XtNjustify, XtCJustify, XtRJustify, sizeof(XtJustify), offset(justify), XtRImmediate, (XtPointer)XtJustifyLeft }, { XtNrightBitmap, XtCRightBitmap, XtRBitmap, sizeof(Pixmap), offset(right_bitmap), XtRImmediate, (XtPointer)None }, { XtNleftMargin, XtCHorizontalMargins, XtRDimension, sizeof(Dimension), offset(left_margin), XtRImmediate, (XtPointer)4 }, { XtNrightMargin, XtCHorizontalMargins, XtRDimension, sizeof(Dimension), offset(right_margin), XtRImmediate, (XtPointer)4 }, { XtNbackgroundColor, XtCBackground, XtRRenderColor, sizeof (XRenderColor), offset (background), XtRString, XtDefaultBackground }, { XtNforegroundColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (foreground), XtRString, XtDefaultForeground }, { XtNdpi, XtCDpi, XtRDpi, sizeof(double), offset (dpi), XtRString, "" }, { XtNfont, XtCFont, XtRXkwFont, sizeof (XkwFont), offset (font), XtRString, XtDefaultFont }, }; #undef offset #define superclass (&ksmeClassRec) KSmeBSBClassRec ksmeBSBClassRec = { /* rectangle */ { (WidgetClass)superclass, /* superclass */ "KSmeBSB", /* class_name */ sizeof(KSmeBSBRec), /* size */ XkwKSmeBSBClassInitialize, /* class_init */ NULL, /* class_part_initialize */ False, /* class_inited */ XkwKSmeBSBInitialize, /* initialize */ NULL, /* initialize_hook */ NULL, /* realize */ NULL, /* actions */ 0, /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ False, /* compress_motion */ False, /* compress_exposure */ False, /* compress_enterleave */ False, /* visible_interest */ XkwKSmeBSBDestroy, /* destroy */ XtInheritResize, /* resize */ XkwKSmeBSBRedisplay, /* expose */ XkwKSmeBSBSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* intrinsics version */ NULL, /* callback offsets */ NULL, /* tm_table */ XkwKSmeBSBQueryGeometry, /* query_geometry */ NULL, /* display_accelerator */ NULL, /* extension */ }, /* sme */ { FlipColors, /* highlight */ FlipColors, /* unhighlight */ XtInheritNotify, /* notify */ NULL, /* extension */ }, /* sme_bsb */ { NULL, /* extension */ }, }; WidgetClass ksmeBSBObjectClass = (WidgetClass)&ksmeBSBClassRec; /* * Function: * XkwKSmeBSBClassInitialize * * Description: * Initializes the KSmeBSBObject. */ static void XkwKSmeBSBClassInitialize(void) { XkwInitializeWidgetSet(); } /* * Function: * XkwKSmeBSBInitialize * * Parameters: * request - widget requested by the argument list * cnew - new widget with both resource and non resource values * * Description: * Initializes the simple menu widget entry. */ /*ARGSUSED*/ static void XkwKSmeBSBInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSmeBSBObject entry = (KSmeBSBObject)cnew; (void) request; (void) args; (void) num_args; if (entry->ksme_bsb.label == NULL) entry->ksme_bsb.label = XtName(cnew); else entry->ksme_bsb.label = XtNewString(entry->ksme_bsb.label); GetDefaultSize(cnew, &entry->rectangle.width, &entry->rectangle.height); entry->ksme_bsb.left_bitmap_width = entry->ksme_bsb.left_bitmap_height = 0; entry->ksme_bsb.right_bitmap_width = entry->ksme_bsb.right_bitmap_height = 0; GetBitmapInfo(cnew, True); /* Left Bitmap Info */ GetBitmapInfo(cnew, False); /* Right Bitmap Info */ } /* * Function: * XkwKSmeBSBDestroy * * Parameters: * w - simple menu widget entry */ static void XkwKSmeBSBDestroy(Widget w) { KSmeBSBObject entry = (KSmeBSBObject)w; if (entry->ksme_bsb.label != XtName(w)) XtFree(entry->ksme_bsb.label); } static void init_cairo(KSmeBSBObject w, cairo_t *cr) { cairo_set_font_face(cr, w->ksme_bsb.font.font_face); cairo_set_font_size(cr, w->ksme_bsb.font.size * w->ksme_bsb.dpi / 72.0); } static cairo_t * get_cairo(KSmeBSBObject w) { cairo_t *cr = XkwGetCairo((Widget) w); init_cairo(w, cr); return cr; } static cairo_t * draw_begin(KSmeBSBObject w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); init_cairo(w, cr); return cr; } static void draw_end(KSmeBSBObject w, Region region, cairo_t *cr) { XkwDrawEnd((Widget) w, region, cr); } /* * Function: * XkwKSmeBSBRedisplay * * Parameters: * w - simple menu widget entry * event - X event that caused this redisplay * region - region the needs to be repainted * * Description: * Redisplays the contents of the widget. */ /* ARGSUSED */ static void XkwKSmeBSBRedisplay(Widget w, XEvent *event, Region region) { KSmeBSBObject entry = (KSmeBSBObject)w; cairo_t *cr = draw_begin(entry, region); (void) event; if (XtIsSensitive(w) && XtIsSensitive(XtParent(w))) { if (w == XkwKSimpleMenuGetActiveEntry(XtParent(w))) { XkwSetSource(cr, &entry->ksme_bsb.foreground); cairo_rectangle(cr, 0, 0, XtWidth(entry), XtHeight(entry)); cairo_fill(cr); XkwSetSource(cr, &entry->ksme_bsb.background); } } else XkwSetSourceInterp(cr, &entry->ksme_bsb.foreground, &entry->ksme_bsb.background); if (entry->ksme_bsb.label != NULL) { int margin = entry->ksme_bsb.left_margin; cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); cairo_text_extents(cr, entry->ksme_bsb.label, &text_extents); double x; switch (entry->ksme_bsb.justify) { case XtJustifyLeft: x = margin; break; case XtJustifyRight: x = XtWidth(entry) - text_extents.width - margin; break; default: x = (XtWidth(entry) - text_extents.width) / 2 - text_extents.x_bearing; break; } double y = (XtHeight(entry) - text_extents.height) / 2 - text_extents.y_bearing; cairo_move_to(cr, x, y); cairo_show_text(cr, entry->ksme_bsb.label); } DrawBitmaps(w, cr); draw_end(entry, region, cr); } /* * Function: * XkwKSmeBSBSetValues * * Parameters: * current - current state of the widget * request - what was requested * cnew - what the widget will become * * Description: * Relayout the menu when one of the resources is changed. */ /*ARGSUSED*/ static Boolean XkwKSmeBSBSetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSmeBSBObject entry = (KSmeBSBObject)cnew; KSmeBSBObject old_entry = (KSmeBSBObject)current; Boolean ret_val = False; (void) request; (void) args; (void) num_args; if (old_entry->ksme_bsb.label != entry->ksme_bsb.label) { if (old_entry->ksme_bsb.label != XtName(cnew)) XtFree((char *)old_entry->ksme_bsb.label); if (entry->ksme_bsb.label != XtName(cnew)) entry->ksme_bsb.label = XtNewString(entry->ksme_bsb.label); ret_val = True; } if (entry->rectangle.sensitive != old_entry->rectangle.sensitive) ret_val = True; if (entry->ksme_bsb.left_bitmap != old_entry->ksme_bsb.left_bitmap) { GetBitmapInfo(cnew, True); ret_val = True; } if (entry->ksme_bsb.right_bitmap != old_entry->ksme_bsb.right_bitmap) { GetBitmapInfo(cnew, False); ret_val = True; } if (memcpy(&old_entry->ksme_bsb.foreground, &entry->ksme_bsb.foreground, sizeof(XRenderColor)) != 0 || memcpy(&old_entry->ksme_bsb.background, &entry->ksme_bsb.background, sizeof(XRenderColor)) != 0) ret_val = True; if (old_entry->ksme_bsb.font.font_face != entry->ksme_bsb.font.font_face || old_entry->ksme_bsb.font.size != entry->ksme_bsb.font.size) { ret_val = True; } if (ret_val) { Dimension width, height; GetDefaultSize(cnew, &width, &height); XtMakeResizeRequest(cnew, width, height, NULL, NULL); } return (ret_val); } /* * Function: * XkwKSmeBSBQueryGeometry * * Parameters: * w - menu entry object * itended - intended and return geometry info * return_val - "" * * Returns: * Geometry Result * * Description: * Returns the preferred geometry for this widget. * See the Intrinsics manual for details on what this function is for. */ static XtGeometryResult XkwKSmeBSBQueryGeometry(Widget w, XtWidgetGeometry *intended, XtWidgetGeometry *return_val) { KSmeBSBObject entry = (KSmeBSBObject)w; Dimension width, height; XtGeometryResult ret_val = XtGeometryYes; XtGeometryMask mode = intended->request_mode; GetDefaultSize(w, &width, &height); if (((mode & CWWidth) && intended->width != width) || !(mode & CWWidth)) { return_val->request_mode |= CWWidth; return_val->width = width; ret_val = XtGeometryAlmost; } if (((mode & CWHeight) && intended->height != height) || !(mode & CWHeight)) { return_val->request_mode |= CWHeight; return_val->height = height; ret_val = XtGeometryAlmost; } if (ret_val == XtGeometryAlmost) { mode = return_val->request_mode; if (((mode & CWWidth) && width == XtWidth(entry)) && ((mode & CWHeight) && height == XtHeight(entry))) return (XtGeometryNo); } return (ret_val); } /* * Function: * FlipColors * * Parameters: * w - bsb menu entry widget * * Description: * Invert the colors of the current entry. */ static void FlipColors(Widget w) { XkwKSmeBSBRedisplay(w, NULL, NULL); } /* * Function: * GetDefaultSize * * Parameters: * w - menu entry widget. * width - default width (return) * height - default height (return) * * Description: * Calculates the Default (preferred) size of this menu entry. */ static void GetDefaultSize(Widget w, Dimension *width, Dimension *height) { KSmeBSBObject entry = (KSmeBSBObject)w; cairo_t *cr = get_cairo(entry); cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); cairo_text_extents(cr, entry->ksme_bsb.label, &text_extents); cairo_destroy(cr); if (entry->ksme_bsb.label == NULL) *width = 0; else *width = text_extents.width + entry->ksme_bsb.left_margin + entry->ksme_bsb.right_margin; *height = font_extents.height * (1.0 + entry->ksme_bsb.vert_space / 100.0); } /* * Function: * DrawBitmaps * * Parameters: * w - simple menu widget entry * gc - graphics context to use for drawing * * Description: * Draws left and right bitmaps. */ static void DrawBitmaps(Widget w, cairo_t *cr) { KSmeBSBObject entry = (KSmeBSBObject)w; if (entry->ksme_bsb.left_bitmap == None && entry->ksme_bsb.right_bitmap == None) return; (void) cr; #if 0 int x_loc, y_loc; /* * Draw Left Bitmap */ if (entry->ksme_bsb.left_bitmap != None) { x_loc = ((entry->ksme_bsb.left_margin - entry->ksme_bsb.left_bitmap_width) >> 1) + XtX(w); y_loc = XtY(entry) + ((XtHeight(entry) - entry->ksme_bsb.left_bitmap_height) >> 1); XCopyPlane(XtDisplayOfObject(w), entry->ksme_bsb.left_bitmap, XtWindowOfObject(w), gc, 0, 0, entry->ksme_bsb.left_bitmap_width, entry->ksme_bsb.left_bitmap_height, x_loc, y_loc, 1); } /* * Draw Right Bitmap */ if (entry->ksme_bsb.right_bitmap != None) { x_loc = XtWidth(entry) - ((entry->ksme_bsb.right_margin + entry->ksme_bsb.right_bitmap_width) >> 1) + XtX(w); y_loc = XtY(entry) + ((XtHeight(entry) - entry->ksme_bsb.right_bitmap_height) >> 1); XCopyPlane(XtDisplayOfObject(w), entry->ksme_bsb.right_bitmap, XtWindowOfObject(w), gc, 0, 0, entry->ksme_bsb.right_bitmap_width, entry->ksme_bsb.right_bitmap_height, x_loc, y_loc, 1); } #endif } /* * Function: * GetBitmapInfo * * Parameters: * w - bsb menu entry object * is_left - True: if we are testing left bitmap * False: if we are testing the right bitmap * * Description: * Gets the bitmap information from either of the bitmaps. */ static void GetBitmapInfo(Widget w, Bool is_left) { KSmeBSBObject entry = (KSmeBSBObject)w; unsigned int depth, bw; Window root; int x, y; unsigned int width, height; if (is_left) { if (entry->ksme_bsb.left_bitmap != None && XGetGeometry(XtDisplayOfObject(w), entry->ksme_bsb.left_bitmap, &root, &x, &y, &width, &height, &bw, &depth)) { entry->ksme_bsb.left_bitmap_width = width; entry->ksme_bsb.left_bitmap_height = height; } } else if (entry->ksme_bsb.right_bitmap != None && XGetGeometry(XtDisplayOfObject(w), entry->ksme_bsb.right_bitmap, &root, &x, &y, &width, &height, &bw, &depth)) { entry->ksme_bsb.right_bitmap_width = width; entry->ksme_bsb.right_bitmap_height = height; } } kgames-2.2/Xkw/KSmeBSB.h000066400000000000000000000062661416764561500147650ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * KSmeBSB.h - Public Header file for KSmeBSB object. * * This is the public header file for the Athena BSB KSme object. * It is intended to be used with the simple menu widget. This object * provides bitmap - string - bitmap style entries. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSmeBSB_h #define _KSmeBSB_h #include #include /* BSB Menu Entry Resources: Name Class RepType Default Value ---- ----- ------- ------------- callback Callback Callback NULL destroyCallback Callback Pointer NULL font Font XFontStruct * XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension 0 label Label String Name of entry leftBitmap LeftBitmap Pixmap None leftMargin HorizontalMargins Dimension 4 menuName MenuName String NULL rightBitmap RightBitmap Pixmap None rightMargin HorizontalMargins Dimension 4 sensitive Sensitive Boolean True vertSpace VertSpace int 25 width Width Dimension 0 x Position Position 0 y Position Position 0 */ typedef struct _KSmeBSBClassRec *KSmeBSBObjectClass; typedef struct _KSmeBSBRec *KSmeBSBObject; extern WidgetClass ksmeBSBObjectClass; #define XtNleftBitmap "leftBitmap" #define XtNleftMargin "leftMargin" #define XtNrightBitmap "rightBitmap" #define XtNrightMargin "rightMargin" #define XtNvertSpace "vertSpace" #define XtNmenuName "menuName" #define XtCMenuName "MenuName" #ifndef XtNfontSet #define XtNfontSet "fontSet" #endif #ifndef XtCFontSet #define XtCFontSet "FontSet" #endif #define XtCLeftBitmap "LeftBitmap" #define XtCHorizontalMargins "HorizontalMargins" #define XtCRightBitmap "RightBitmap" #define XtCVertSpace "VertSpace" #endif /* _KSmeBSB_h */ kgames-2.2/Xkw/KSmeBSBP.h000066400000000000000000000051101416764561500150700ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Chris D. Peterson, MIT X Consortium */ #ifndef _XkwKSmeBSBP_h #define _XkwKSmeBSBP_h /* * Sme Object Private Data */ #include #include #include #include typedef struct _KSmeBSBClassPart { XtPointer extension; } KSmeBSBClassPart; /* Full class record declaration */ typedef struct _KSmeBSBClassRec { RectObjClassPart rect_class; KSmeClassPart ksme_class; KSmeBSBClassPart ksme_bsb_class; } KSmeBSBClassRec; extern KSmeBSBClassRec smeBSBClassRec; /* New fields for the KSme Object record */ typedef struct { /* resources */ String label; /* The entry label */ int vert_space; /* extra vert space to leave, as a percentage of the font height of the label */ Pixmap left_bitmap, right_bitmap; /* bitmaps to show */ Dimension left_margin, right_margin;/* left and right margins */ XRenderColor foreground; XRenderColor background; double dpi; XkwFont font; XtJustify justify; /* Justification for the label. */ /* private */ Dimension left_bitmap_width; /* size of each bitmap */ Dimension left_bitmap_height; Dimension right_bitmap_width; Dimension right_bitmap_height; } KSmeBSBPart; /* * Full instance record declaration */ typedef struct _KSmeBSBRec { ObjectPart object; RectObjPart rectangle; KSmePart ksme; KSmeBSBPart ksme_bsb; } KSmeBSBRec; #endif /* _XkwKSmeBSBP_h */ kgames-2.2/Xkw/KSmeLine.c000066400000000000000000000126771416764561500152440ustar00rootroot00000000000000/* Copyright 1989, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Chris D. Peterson, MIT X Consortium */ /* * Sme.c - Source code for the generic menu entry * * Date: September 26, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include /* * Class Methods */ static void XkwKSmeLineDestroy(Widget); static void XkwKSmeLineInitialize(Widget, Widget, ArgList, Cardinal*); static void XkwKSmeLineRedisplay(Widget, XEvent*, Region); static Boolean XkwKSmeLineSetValues(Widget, Widget, Widget, ArgList, Cardinal*); /* * Initialization */ #define offset(field) XtOffsetOf(KSmeLineRec, ksme_line.field) static XtResource resources[] = { { XtNlineWidth, XtCLineWidth, XtRDimension, sizeof(Dimension), offset(line_width), XtRImmediate, (XtPointer)1 }, { XtNbackgroundColor, XtCBackground, XtRRenderColor, sizeof (XRenderColor), offset (background), XtRString, XtDefaultBackground }, { XtNforegroundColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (foreground), XtRString, XtDefaultForeground }, }; #undef offset #define Superclass (&ksmeClassRec) KSmeLineClassRec ksmeLineClassRec = { /* rectangle */ { (WidgetClass)Superclass, /* superclass */ "KSmeLine", /* class_name */ sizeof(KSmeLineRec), /* widget_size */ XkwInitializeWidgetSet, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class inited */ XkwKSmeLineInitialize, /* initialize */ NULL, /* initialize_hook */ NULL, /* realize */ NULL, /* actions */ 0, /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ False, /* compress_motion */ False, /* compress_exposure */ False, /* compress_enterleave */ False, /* visible_interest */ XkwKSmeLineDestroy, /* destroy */ XtInheritResize, /* resize */ XkwKSmeLineRedisplay, /* expose */ XkwKSmeLineSetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* intrinsics version */ NULL, /* callback offsets */ NULL, /* tm_table */ XtInheritQueryGeometry, /* query_geometry */ NULL, /* display_accelerator */ NULL, /* extension */ }, /* ksme */ { XtInheritHighlight, /* highlight */ XtInheritUnhighlight, /* unhighlight */ XtInheritNotify, /* notify */ NULL, /* extension */ }, /* ksme_line */ { NULL, /* extension */ } }; WidgetClass ksmeLineObjectClass = (WidgetClass)&ksmeLineClassRec; /* * Implementation */ /*ARGSUSED*/ static void XkwKSmeLineInitialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSmeLineObject entry = (KSmeLineObject)cnew; (void) request; (void) args; (void) num_args; if (XtHeight(entry) == 0) XtHeight(entry) = entry->ksme_line.line_width; } static void XkwKSmeLineDestroy(Widget w) { (void) w; } /*ARGSUSED*/ static void XkwKSmeLineRedisplay(Widget w, XEvent *event, Region region) { KSmeLineObject entry = (KSmeLineObject)w; int y = XtY(w) + (((int)XtHeight(w) - entry->ksme_line.line_width) >> 1); cairo_t *cr = XkwGetCairo(w); (void) event; (void) region; XkwSetSource(cr, &entry->ksme_line.foreground); cairo_rectangle(cr, XtX(w), y, XtWidth(w), entry->ksme_line.line_width); cairo_fill(cr); cairo_destroy(cr); } /* * Function: * XkwKSmeLineSetValues * * Parameters: * current - current state of the widget * request - what was requested * cnew - what the widget will become * * Description: * Relayout the menu when one of the resources is changed. */ /*ARGSUSED*/ static Boolean XkwKSmeLineSetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KSmeLineObject entry = (KSmeLineObject)cnew; KSmeLineObject old_entry = (KSmeLineObject)current; (void) request; (void) args; (void) num_args; if (entry->ksme_line.line_width != old_entry->ksme_line.line_width) { return (True); } return (False); } kgames-2.2/Xkw/KSmeLine.h000066400000000000000000000041531416764561500152370ustar00rootroot00000000000000/* * Copyright 1989, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * */ /* * This is the public header file for the Athena KSmeLine object. * It is intended to be used with the simple menu widget. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSmeLine_h #define _KSmeLine_h #include #include /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- callback Callback Pointer NULL destroyCallback Callback Pointer NULL height Height Dimension 0 sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ #define XtCLineWidth "LineWidth" #define XtCStipple "Stipple" #define XtNlineWidth "lineWidth" #define XtNstipple "stipple" typedef struct _KSmeLineClassRec *KSmeLineObjectClass; typedef struct _KSmeLineRec *KSmeLineObject; extern WidgetClass smeLineObjectClass; #endif /* _KSmeLine_h */ kgames-2.2/Xkw/KSmeLineP.h000066400000000000000000000041231416764561500153540ustar00rootroot00000000000000/* * Copyright 1989, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. * * Author: Chris D. Peterson, MIT X Consortium */ #ifndef _XkwKSmeLineP_h #define _XkwKSmeLineP_h /* * KSmeLine Widget Private Data */ #include #include #include /* New fields for the KSmeLine widget class */ typedef struct _KSmeLineClassPart { XtPointer extension; } KSmeLineClassPart; /* Full class record */ typedef struct _KSmeLineClassRec { RectObjClassPart rect_class; KSmeClassPart ksme_class; KSmeLineClassPart ksme_line_class; } KSmeLineClassRec; extern KSmeLineClassRec smeLineClassRec; /* New fields for the KSmeLine widget */ typedef struct { /* resources */ XRenderColor foreground; XRenderColor background; Dimension line_width; /* Width of the line */ } KSmeLinePart; /* Full instance record */ typedef struct _KSmeLineRec { ObjectPart object; RectObjPart rectangle; KSmePart ksme; KSmeLinePart ksme_line; } KSmeLineRec; #endif /* _XkwKSmeLineP_h */ kgames-2.2/Xkw/KSmeP.h000066400000000000000000000045321416764561500145500ustar00rootroot00000000000000/* * Copyright 1989, 1994, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ /* * This is the private header file for the Athena Sme object. * This object is intended to be used with the simple menu widget. * * Date: April 3, 1989 * * By: Chris D. Peterson * MIT X Consortium * kit@expo.lcs.mit.edu */ #ifndef _KSmeP_h #define _KSmeP_h /* * Sme Widget Private Data */ #include #include _XFUNCPROTOBEGIN /* New fields for the KSme widget class */ typedef struct _KSmeClassPart { XtWidgetProc highlight; XtWidgetProc unhighlight; XtWidgetProc notify; XtPointer extension; } KSmeClassPart; /* Full class record */ typedef struct _KSmeClassRec { RectObjClassPart rect_class; KSmeClassPart sme_class; } KSmeClassRec; extern KSmeClassRec ksmeClassRec; /* New fields for the KSme widget */ typedef struct { /* resources */ XtCallbackList callbacks; Boolean international; } KSmePart; /* Full instance record */ typedef struct _KSmeRec { ObjectPart object; RectObjPart rectangle; KSmePart ksme; } KSmeRec; #define XtInheritHighlight ((XtWidgetProc)_XtInherit) #define XtInheritUnhighlight XtInheritHighlight #define XtInheritNotify XtInheritHighlight _XFUNCPROTOEND #endif /* _KSmeP_h */ kgames-2.2/Xkw/KTextLine.c000066400000000000000000000305741416764561500154400ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #define superclass (&ksimpleClassRec) static void init_cairo(KTextLineWidget w, cairo_t *cr) { cairo_set_font_face(cr, w->ktext_line.font.font_face); cairo_set_font_size(cr, w->ktext_line.font.size * w->ksimple.dpi / 72.0); } static cairo_t * get_cairo(KTextLineWidget w) { cairo_t *cr = XkwGetCairo((Widget) w); init_cairo(w, cr); return cr; } static cairo_t * draw_begin(KTextLineWidget w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); init_cairo(w, cr); return cr; } static void draw_end(KTextLineWidget w, Region region, cairo_t *cr) { XkwDrawEnd((Widget) w, region, cr); } static double pad(cairo_font_extents_t *font_extents) { return font_extents->height / 4.0; } static double cursor_width(cairo_font_extents_t *font_extents) { return font_extents->height / 8.0; } static void preferred_size(KTextLineWidget w, Dimension *width, Dimension *height) { cairo_t *cr = get_cairo(w); char *string; cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); if (w->ktext_line.string && w->ktext_line.string[0]) string = w->ktext_line.string; else string = ""; cairo_text_extents(cr, string, &text_extents); cairo_destroy(cr); *width = text_extents.x_advance + pad(&font_extents) * 2; *height = font_extents.height + pad(&font_extents) * 2; } static void Initialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KTextLineWidget w = (KTextLineWidget) cnew; (void) request; (void) args; (void) num_args; if (w->ktext_line.string == NULL) w->ktext_line.string = ""; w->ktext_line.string = XtNewString(w->ktext_line.string); w->ktext_line.size = strlen (w->ktext_line.string); w->ktext_line.cursor = w->ktext_line.size; if (XtWidth(w) == 0 || XtHeight(w) == 0) { Dimension width, height; preferred_size(w, &width, &height); if (XtWidth(w) == 0) XtWidth(w) = width; if (XtHeight(w) == 0) XtHeight(w) = height; } } static void Destroy(Widget gw) { KTextLineWidget w = (KTextLineWidget)gw; XtFree(w->ktext_line.string); } static double text_width(cairo_t *cr, char *text, int len) { char save = text[len]; if (save != '\0') text[len] = '\0'; cairo_text_extents_t text_extents; cairo_text_extents(cr, text, &text_extents); if (save != '\0') text[len] = save; return text_extents.x_advance; } static void Redisplay(Widget gw, XEvent *event, Region region) { KTextLineWidget w = (KTextLineWidget) gw; cairo_t *cr = draw_begin(w, region); (void) event; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); double padding = pad(&font_extents); double top = (w->core.height - (font_extents.ascent + font_extents.descent)) / 2; double x = padding; double y = top + font_extents.ascent; cairo_move_to(cr, x, y); cairo_show_text(cr, w->ktext_line.string); x = padding + text_width(cr, w->ktext_line.string, w->ktext_line.cursor); cairo_set_line_width(cr, cursor_width(&font_extents)); cairo_move_to(cr, x, top); cairo_line_to(cr, x, top + font_extents.height); cairo_stroke(cr); draw_end(w, region, cr); } static Boolean SetValues(Widget gcur, Widget greq, Widget gnew, ArgList args, Cardinal *num_args) { KTextLineWidget cur = (KTextLineWidget)gcur; KTextLineWidget req = (KTextLineWidget)greq; KTextLineWidget new = (KTextLineWidget)gnew; Boolean redisplay = False; (void) args; (void) num_args; if (new->ktext_line.string != cur->ktext_line.string) { XtFree(cur->ktext_line.string); if (!new->ktext_line.string) new->ktext_line.string = XtNewString(""); else new->ktext_line.string = XtNewString(new->ktext_line.string); redisplay = True; } if (new->ktext_line.font.font_face != cur->ktext_line.font.font_face || new->ktext_line.font.size != cur->ktext_line.font.size) redisplay = True; if (redisplay) { Dimension width, height; preferred_size(new, &width, &height); if (XtHeight(cur) == XtHeight(req)) XtHeight(new) = height; if (XtWidth(cur) == XtWidth(req)) XtWidth(new) = width; } return redisplay; } static XtGeometryResult QueryGeometry(Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { KTextLineWidget w = (KTextLineWidget)gw; preferred->request_mode = CWWidth | CWHeight; preferred_size(w, &preferred->width, &preferred->height); if (((intended->request_mode & (CWWidth | CWHeight)) == (CWWidth | CWHeight)) && intended->width == preferred->width && intended->height == preferred->height) return (XtGeometryYes); else if (preferred->width == XtWidth(w) && preferred->height == XtHeight(w)) return (XtGeometryNo); return (XtGeometryAlmost); } static void EditCallbacks(KTextLineWidget w, XEvent *ev) { Dimension width, height; XtCallCallbackList((Widget) w, w->ktext_line.edit_callbacks, (XtPointer) ev); preferred_size(w, &width, &height); if (width != w->core.width || height != w->core.height) { XtMakeResizeRequest((Widget) w, width, height, &width, &height); } } static void MoveForwardChar(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; (void) ev; (void) args; (void) num; if (w->ktext_line.cursor < (ssize_t) strlen(w->ktext_line.string)) { w->ktext_line.cursor++; Redisplay(gw, NULL, NULL); } } static void MoveBackwardChar(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; (void) ev; (void) args; (void) num; if (w->ktext_line.cursor > 0) { w->ktext_line.cursor--; Redisplay(gw, NULL, NULL); } } static void DeleteBackwardChar(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; (void) ev; (void) args; (void) num; if (w->ktext_line.cursor > 0) { memmove(w->ktext_line.string + w->ktext_line.cursor - 1, w->ktext_line.string + w->ktext_line.cursor, strlen(w->ktext_line.string) - w->ktext_line.cursor + 1); w->ktext_line.cursor--; Redisplay(gw, NULL, NULL); EditCallbacks(w, ev); } } static void Delete(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; int len = strlen(w->ktext_line.string); (void) ev; (void) args; (void) num; if (len > w->ktext_line.cursor) { memmove(w->ktext_line.string + w->ktext_line.cursor, w->ktext_line.string + w->ktext_line.cursor + 1, strlen(w->ktext_line.string) - w->ktext_line.cursor); Redisplay(gw, NULL, NULL); EditCallbacks(w, ev); } } static void Accept(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; (void) ev; (void) args; (void) num; XtCallCallbackList(gw, w->ktext_line.callbacks, (XtPointer) w->ktext_line.string); } static void InsertChar(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; char strbuf[128]; KeySym keysym; int new = XLookupString((XKeyEvent*)ev, strbuf, sizeof(strbuf), &keysym, NULL); (void) args; (void) num; if (new == 0) return; int len = strlen(w->ktext_line.string); if (len + new + 1 > w->ktext_line.size) w->ktext_line.string = realloc(w->ktext_line.string, w->ktext_line.size += (new + 16)); /* shift text right, including NUL */ memmove(w->ktext_line.string + w->ktext_line.cursor + new, w->ktext_line.string + w->ktext_line.cursor, len + 1 - w->ktext_line.cursor); memcpy(w->ktext_line.string + w->ktext_line.cursor, strbuf, new); w->ktext_line.cursor += new; Redisplay(gw, NULL, NULL); EditCallbacks(w, ev); } static void SetCursor(Widget gw, XEvent *ev, String *args, Cardinal *num) { KTextLineWidget w = (KTextLineWidget) gw; cairo_t *cr = get_cairo(w); cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); double padding = pad(&font_extents); int i; int len = strlen(w->ktext_line.string); (void) args; (void) num; for (i = 0; i < len; i++) { double x = padding + text_width(cr, w->ktext_line.string, i); if (x >= ev->xbutton.x) break; } w->ktext_line.cursor = i; cairo_destroy(cr); Redisplay(gw, NULL, NULL); } static XtActionsRec actionsTable[] = { {"forward-character", MoveForwardChar}, {"backward-character", MoveBackwardChar}, {"delete-previous-character", DeleteBackwardChar}, {"delete", Delete}, {"accept", Accept}, {"insert-char", InsertChar}, {"set-cursor", SetCursor}, }; static const char defaultTranslations[] = "cH:" "delete-previous-character()\n" "Right:" "forward-character()\n" ":KP_Right:" "forward-character()\n" "Left:" "backward-character()\n" ":KP_Left:" "backward-character()\n" "Delete:" "delete()\n" ":KP_Delete:" "delete()\n" "BackSpace:" "delete-previous-character()\n" "Return:" "accept()\n" ":KP_Enter:" "accept()\n" ":" "insert-char()\n" ":" "set-cursor()\n" ; static XtResource resources[] = { #define offset(field) XtOffsetOf(KTextLineRec, ktext_line.field) /* {name, class, type, size, offset, default_type, default_addr}, */ { XtNstring, XtCString, XtRString, sizeof(String), offset (string), XtRString, NULL }, { XtNfont, XtCFont, XtRXkwFont, sizeof (XkwFont), offset (font), XtRString, XtDefaultFont }, { XtNcallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(callbacks), XtRCallback, NULL }, { XtNeditCallback, XtCCallback, XtRCallback, sizeof(XtPointer), offset(edit_callbacks), XtRCallback, NULL }, #undef offset }; KTextLineClassRec ktextLineClassRec = { /* core */ { (WidgetClass)superclass, /* superclass */ "KTextLine", /* class_name */ sizeof(KTextLineRec), /* widget_size */ NULL, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ Initialize, /* initialize */ NULL, /* initialize_hook */ XtInheritRealize, /* realize */ actionsTable, /* actions */ XtNumber(actionsTable), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ Destroy, /* destroy */ XtInheritResize, /* resize */ Redisplay, /* expose */ SetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ (void *) defaultTranslations, /* tm_table */ QueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, /* ktextLine */ { 0, /* extension */ } }; WidgetClass ktextLineWidgetClass = (WidgetClass)&ktextLineClassRec; kgames-2.2/Xkw/KTextLine.h000066400000000000000000000027431416764561500154420ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKTextLine_h #define _XkwKTextLine_h /* KTextLine Widget */ #include extern WidgetClass ktextLineWidgetClass; typedef struct _KTextLineClassRec *KTextLineWidgetClass; typedef struct _KTextLineRec *KTextLineWidget; #define XtNeditCallback "editCallback" #endif /* _XkwKTextLine_h */ kgames-2.2/Xkw/KTextLineP.h000066400000000000000000000041501416764561500155540ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKTextLineP_h_ #define _XkwKTextLineP_h_ #include #include #include typedef struct _KTextLineClass { int notused; } KTextLineClassPart; /* Full class record declaration */ typedef struct _KCommandClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KTextLineClassPart ktext_line_class; } KTextLineClassRec; extern KTextLineClassRec ktextLineClassRec; typedef struct { /* resources */ XkwFont font; String string; XtCallbackList callbacks; /* on 'return' */ XtCallbackList edit_callbacks; /* on every text change */ /* private */ int size; int cursor; } KTextLinePart; /* * Full instance record declaration */ typedef struct _KTextLineRec { CorePart core; SimplePart simple; KSimplePart ksimple; KTextLinePart ktext_line; } KTextLineRec; #endif /* _XkwKTextLineP_h_ */ kgames-2.2/Xkw/KToggle.c000066400000000000000000000160241416764561500151170ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #define superclass (&kcommandClassRec) static KToggleWidget RadioGroupLeader(KToggleWidget w) { KToggleWidget leader; for (leader = w; leader && leader->ktoggle.radio_prev; leader = leader->ktoggle.radio_prev) ; return leader; } static void AppendToRadioGroup(KToggleWidget w, KToggleWidget leader) { KToggleWidget last; /* Find last member of radio group */ for (last = leader; last->ktoggle.radio_next != NULL; last = (KToggleWidget) last->ktoggle.radio_next) ; /* Insert into list */ w->ktoggle.radio_prev = last; w->ktoggle.radio_next = NULL; last->ktoggle.radio_next = w; } static void RemoveFromRadioGroup(KToggleWidget w) { if (w->ktoggle.radio_prev) w->ktoggle.radio_prev->ktoggle.radio_next = w->ktoggle.radio_next; if (w->ktoggle.radio_next) w->ktoggle.radio_next->ktoggle.radio_prev = w->ktoggle.radio_prev; } static void Initialize(Widget request, Widget cnew, ArgList args, Cardinal *num_args) { KToggleWidget w = (KToggleWidget) cnew; (void) request; (void) args; (void) num_args; w->ktoggle.radio_prev = NULL; w->ktoggle.radio_next = NULL; if (w->ktoggle.radio_leader != NULL) AppendToRadioGroup(w, (KToggleWidget) w->ktoggle.radio_leader); } static void Destroy(Widget gw) { KToggleWidget w = (KToggleWidget) gw; RemoveFromRadioGroup(w); } static Boolean SetValues(Widget current, Widget request, Widget cnew, ArgList args, Cardinal *num_args) { (void) current; (void) request; (void) cnew; (void) args; (void) num_args; return False; } static void TurnOffRadioSiblings(Widget gw) { KToggleWidget w = (KToggleWidget) gw; KToggleWidget radio; /* Find group leader */ radio = RadioGroupLeader(w); for (; radio; radio = (KToggleWidget) (radio->ktoggle.radio_next)) if (radio->kcommand.set && radio != w) { KToggleWidgetClass cclass = (KToggleWidgetClass)radio->core.widget_class; cclass->kcommand_class.unset((Widget) radio, NULL, NULL, NULL); cclass->kcommand_class.notify((Widget) radio, NULL, NULL, NULL); } } static void ToggleSet(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KToggleWidget w = (KToggleWidget) gw; KToggleWidgetClass cclass = (KToggleWidgetClass)w->core.widget_class; (void) params; (void) num_params; TurnOffRadioSiblings(gw); cclass->kcommand_class.set(gw, event, NULL, NULL); } static void Toggle(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KToggleWidget w = (KToggleWidget) gw; KToggleWidgetClass cclass = (KToggleWidgetClass)gw->core.widget_class; if (w->kcommand.set) cclass->kcommand_class.unset(gw, event, NULL, NULL); else ToggleSet(gw, event, params, num_params); } static void Notify(Widget gw, XEvent *event, String *params, Cardinal *num_params) { KToggleWidgetClass cclass = (KToggleWidgetClass)gw->core.widget_class; cclass->kcommand_class.notify(gw, event, params, num_params); } XtPointer XkwKToggleGetCurrent (Widget radio_group) { KToggleWidget radio; for (radio = RadioGroupLeader((KToggleWidget) radio_group); radio; radio = radio->ktoggle.radio_next) { if (radio->kcommand.set) return radio->ktoggle.radio_data; } return NULL; } void XkwKToggleSetCurrent(Widget radio_group, XtPointer radio_data) { KToggleWidget radio; for (radio = RadioGroupLeader((KToggleWidget) radio_group); radio; radio = radio->ktoggle.radio_next) { if (radio->ktoggle.radio_data == radio_data) { ToggleSet((Widget) radio, NULL, NULL, NULL); break; } } } static XtResource resources[] = { #define offset(field) XtOffsetOf(KToggleRec, ktoggle.field) { XtNradioGroup, XtCWidget, XtRWidget, sizeof(Widget), offset(radio_leader), XtRWidget, NULL }, { XtNradioData, XtCRadioData, XtRPointer, sizeof(XtPointer), offset(radio_data), XtRPointer, NULL }, }; static char defaultTranslations[] = ":" "highlight(Always)\n" ":" "unhighlight()\n" ",:" "toggle() notify()\n" ; static XtActionsRec actionsList[] = { {"toggle", Toggle}, {"notify", Notify}, {"set", ToggleSet}, }; KToggleClassRec ktoggleClassRec = { /* core */ { (WidgetClass)superclass, /* superclass */ "Toggle", /* class_name */ sizeof(KToggleRec), /* widget_size */ NULL, /* class_initialize */ NULL, /* class_part_initialize */ False, /* class_inited */ Initialize, /* initialize */ NULL, /* initialize_hook */ XtInheritRealize, /* realize */ actionsList, /* actions */ XtNumber(actionsList), /* num_actions */ resources, /* resources */ XtNumber(resources), /* num_resources */ NULLQUARK, /* xrm_class */ True, /* compress_motion */ True, /* compress_exposure */ True, /* compress_enterleave */ False, /* visible_interest */ Destroy, /* destroy */ XtInheritResize, /* resize */ XtInheritExpose, /* expose */ SetValues, /* set_values */ NULL, /* set_values_hook */ XtInheritSetValuesAlmost, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ XtVersion, /* version */ NULL, /* callback_private */ defaultTranslations, /* tm_table */ XtInheritQueryGeometry, /* query_geometry */ XtInheritDisplayAccelerator, /* display_accelerator */ NULL, /* extension */ }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { /* empty */ 0 }, /* klabel */ { /* empty */ 0 }, /* kcommand */ { XtInheritSet, /* set */ XtInheritUnset, /* unset */ XtInheritNotify, /* notify */ }, /* ktoggle */ { /* empty */ 0 } }; WidgetClass ktoggleWidgetClass = (WidgetClass)&ktoggleClassRec; kgames-2.2/Xkw/KToggle.h000066400000000000000000000032461416764561500151260ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKToggle_h #define _XkwKToggle_h /* KToggle Widget */ #include extern WidgetClass ktoggleWidgetClass; typedef struct _KToggleClassRec *KToggleWidgetClass; typedef struct _KToggleRec *KToggleWidget; #define XtNradioGroup "radioGroup" #define XtNradioData "radioData" #define XtCRadioData "RadioData" #define XtCWidget "Widget" XtPointer XkwKToggleGetCurrent (Widget radio_group); void XkwKToggleSetCurrent(Widget radio_group, XtPointer radio_data); #endif /* _XkwKToggle_h */ kgames-2.2/Xkw/KToggleP.h000066400000000000000000000042411416764561500152420ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _XkwKToggleP_h_ #define _XkwKToggleP_h_ #include #include #include typedef struct _KToggleClass { int unused; } KToggleClassPart; typedef struct _KToggleClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; KLabelClassPart klabel_class; KCommandClassPart kcommand_class; KToggleClassPart ktoggle_class; } KToggleClassRec; extern KToggleClassRec ktoggleClassRec; typedef struct { /* resources */ Widget radio_leader; /* leader of radio group */ XtPointer radio_data; /* application data for radio group */ /* private */ KToggleWidget radio_prev; /* previous radio button */ KToggleWidget radio_next; /* next radio button */ } KTogglePart; typedef struct _KToggleRec { CorePart core; SimplePart simple; KSimplePart ksimple; KLabelPart klabel; KCommandPart kcommand; KTogglePart ktoggle; } KToggleRec; #endif /* _XkwKToggleP_h_ */ kgames-2.2/Xkw/Layout.ad000066400000000000000000000010341416764561500151750ustar00rootroot00000000000000*allowShellResize: true *label1.label: Label 1 Label 1 *label2.label: Label 2 Label 2 *label3.label: Label 3 Label 3 *cards.numRows: 12 *cards.numCols: 2 *cards.overlap: vertical *cards.smallCards: false *cards.rowsHint: true *layout: vertical { \ NormalSpace = (25 % of height cards) \ NormalAdjust = 25% \ horizontal {\ $NormalSpace < +infinity -$NormalSpace > \ label1 label2 label3 \ $NormalSpace < +infinity -$NormalSpace > \ } \ horizontal {\ cards < * +infinity -$NormalAdjust > \ 0 < +infinity > \ } \ } kgames-2.2/Xkw/Layout.c000066400000000000000000000705501416764561500150440ustar00rootroot00000000000000/* * $XConsortium: Layout.c,v 1.1 91/09/13 18:51:44 keith Exp $ * * Copyright 1991 Massachusetts Institute of Technology * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, MIT X Consortium */ #include #include #include #include #include "LayoutP.h" #include #include /***************************************************************************** * * Full instance record declaration * ****************************************************************************/ #define offset(field) XtOffsetOf(LayoutRec, layout.field) static XtResource resources[] = { {XtNlayout, XtCLayout, XtRLayout, sizeof (BoxPtr), offset(layout), XtRLayout, NULL }, {XtNdebug, XtCBoolean, XtRBoolean, sizeof(Boolean), offset(debug), XtRImmediate, (XtPointer) FALSE}, {XtNresize, XtCResize, XtRBoolean, sizeof(Boolean), offset(resize), XtRImmediate, (XtPointer) FALSE}, }; #undef offset #ifdef MOTIF #define SuperClass ((ConstraintWidgetClass)&xmManagerClassRec) #else #define SuperClass ((ConstraintWidgetClass)&constraintClassRec) #endif static void LayoutFreeLayout (BoxPtr box); static void LayoutLayout (LayoutWidget l, Bool attemptResize); static void LayoutGetNaturalSize (LayoutWidget l, Dimension *widthp, Dimension *heightp); static Boolean ChildInLayout (LayoutWidget l, Widget child); /************************************************************ * * Semi-public routines. * ************************************************************/ /* Function Name: ClassInitialize * Description: The Layout widgets class initialization proc. * Arguments: none. * Returns: none. */ /*ARGSUSED*/ static Boolean CvtStringToLayout (Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *from, XrmValue *to, XtPointer *converter_data) { (void) dpy; (void) args; (void) num_args; (void) converter_data; LayYYsetsource ((char *) from->addr); LayYYsetdest ((BoxPtr *) to->addr); if (LayYYparse () == 0) return TRUE; else return FALSE; } static void DisposeLayout (XtAppContext app, XrmValue *to, XtPointer data, XrmValuePtr args, Cardinal *num_args) { (void) app; (void) data; (void) args; (void) num_args; LayoutFreeLayout (* (LayoutPtr *) to->addr); } static void ClassInitialize(void) { XtSetTypeConverter ( XtRString, XtRLayout, CvtStringToLayout, NULL, (Cardinal)0, XtCacheNone, DisposeLayout ); } static XtGeometryResult GeometryManager(Widget child, XtWidgetGeometry *request, XtWidgetGeometry *reply) { LayoutWidget w = (LayoutWidget) XtParent(child); SubInfoPtr p = SubInfo(child); int bw; Bool changed, bwChanged; (void) reply; if (!ChildInLayout(w, child)) { /* copy values from request to child */ if (request->request_mode & CWX) child->core.x = request->x; if (request->request_mode & CWY) child->core.y = request->y; if (request->request_mode & CWWidth) child->core.width = request->width; if (request->request_mode & CWHeight) child->core.height = request->height; if (request->request_mode & CWBorderWidth) child->core.border_width = request->border_width; return XtGeometryYes; } bw = p->naturalBw; changed = FALSE; bwChanged = FALSE; if (request->request_mode & CWBorderWidth && request->border_width != child->core.border_width) { p->naturalBw = bw; bw = request->border_width; changed = TRUE; bwChanged = TRUE; } if (bwChanged || ((request->request_mode & CWWidth) && request->width != child->core.width)) { p->naturalSize[LayoutHorizontal] = request->width + bw * 2; changed = TRUE; } if (bwChanged || ((request->request_mode & CWHeight) && request->height != child->core.height)) { p->naturalSize[LayoutVertical] = request->height + bw * 2; changed = TRUE; } /* * Allow arbitrary restacking by just doing it here; the layout * process doesn't need to know about it */ if (request->request_mode & CWStackMode) { XWindowChanges ch; ch.stack_mode = request->stack_mode; if (request->request_mode & CWSibling) ch.sibling = XtWindow (request->sibling); XConfigureWindow (XtDisplay (child), XtWindow (child), request->request_mode & (CWStackMode|CWSibling), &ch); } if (changed) LayoutLayout (w, TRUE); return XtGeometryDone; } static void Initialize(Widget request, Widget new, Arg *args, Cardinal *count) { (void) request; (void) new; (void) args; (void) count; } static void GetDesiredSize (Widget child) { XtWidgetGeometry desired; SubInfoPtr p; XtQueryGeometry (child, (XtWidgetGeometry *) NULL, &desired); p = SubInfo (child); p->naturalBw = desired.border_width; p->naturalSize[LayoutHorizontal] = desired.width + desired.border_width * 2; p->naturalSize[LayoutVertical] = desired.height + desired.border_width * 2; } static void ChangeManaged(Widget gw) { LayoutWidget w = (LayoutWidget) gw; Widget *children; ForAllChildren (w, children) GetDesiredSize (*children); LayoutLayout ((LayoutWidget) w, TRUE); } static void InsertChild (Widget child) { (*SuperClass->composite_class.insert_child) (child); GetDesiredSize (child); } static void Resize(Widget gw) { LayoutLayout ((LayoutWidget) gw, FALSE); } static Boolean SetValues(Widget gold, Widget greq, Widget gnew, Arg *args, Cardinal *count) { LayoutWidget old = (LayoutWidget) gold, req = (LayoutWidget) greq, new = (LayoutWidget) gnew; (void) req; (void) args; (void) count; if (old->layout.layout != new->layout.layout) LayoutLayout (new, TRUE); return FALSE; } /* SetValues */ static XtGeometryResult QueryGeometry (Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { LayoutWidget w = (LayoutWidget) gw; XtGeometryResult result; if (intended && !(intended->request_mode & (CWWidth|CWHeight))) return XtGeometryYes; LayoutGetNaturalSize (w, &preferred->width, &preferred->height); preferred->request_mode = 0; printf("Layout %s query geometry mode %x intended %d x %d preferred %d x %d\n", w->core.name, intended->request_mode & (CWWidth|CWHeight), intended->width, intended->height, preferred->width, preferred->height); /* Check to see if the intended change matches our preferred * geometry */ result = XtGeometryYes; if ((intended->request_mode & CWWidth) && intended->width != preferred->width) { preferred->request_mode |= CWWidth; result = XtGeometryAlmost; } if ((intended->request_mode & CWHeight) && intended->height != preferred->height) { preferred->request_mode |= CWHeight; result = XtGeometryAlmost; } /* Check to see if the intended geometry matches the current * geometry */ if (result == XtGeometryAlmost) { if (((intended->request_mode & CWWidth) == 0 || intended->width == w->core.width) && ((intended->request_mode & CWHeight) == 0 || intended->height == w->core.height)) { result = XtGeometryNo; } } return result; } /* * Layout section. Exports LayoutGetNaturalSize and * LayoutLayout to above section */ static void PrintGlue (GlueRec g) { if (g.order == 0 || g.value != 1.0) printf ("%g", g.value); if (g.order > 0) { printf (" inf"); if (g.order > 1) printf (" %d", g.order); } } static void PrintDirection (LayoutDirection dir) { switch (dir) { case LayoutHorizontal: printf ("horizontal"); break; case LayoutVertical: printf ("vertical"); break; case LayoutOverlay: printf ("overlay"); break; default: printf ("Unknown layout direction %d\n", dir); break; } } static void TabTo(int level) { while (level--) printf (" "); } static void PrintBox (BoxPtr box, int level) { BoxPtr child; TabTo (level); switch (box->type) { case BoxBox: PrintDirection (box->u.box.dir); break; case WidgetBox: printf ("%s ", XrmQuarkToString (box->u.widget.quark)); break; case GlueBox: printf ("glue "); break; case VariableBox: printf ("variable %s\n", XrmQuarkToString (box->u.variable.quark)); return; } printf ("< "); printf (" + "); PrintGlue (box->params.stretch[LayoutHorizontal]); printf (" - "); PrintGlue (box->params.shrink[LayoutHorizontal]); printf (" * "); printf (" + "); PrintGlue (box->params.stretch[LayoutVertical]); printf (" - "); PrintGlue (box->params.shrink[LayoutVertical]); printf (" >"); printf (" size: %d x %d", box->size[0], box->size[1]); printf (" natural: %d x %d\n", box->natural[0], box->natural[1]); if (box->type == BoxBox) for (child = box->u.box.firstChild; child; child = child->nextSibling) PrintBox (child, level+1); } static ExprPtr LookupVariable (BoxPtr child, XrmQuark quark) { BoxPtr parent, box; while ((parent = child->parent)) { for (box = parent->u.box.firstChild; box != child; box = box->nextSibling) { if (box->type == VariableBox && box->u.variable.quark == quark) return box->u.variable.expr; } child = parent; } return 0; } static double Evaluate (LayoutWidget l, BoxPtr box, ExprPtr expr, double natural) { double left, right, down; Widget widget; SubInfoPtr info; switch (expr->type) { case Constant: return expr->u.constant; case Binary: left = Evaluate (l, box, expr->u.binary.left, natural); right = Evaluate (l, box, expr->u.binary.right, natural); switch (expr->u.binary.op) { case Plus: return left + right; case Minus: return left - right; case Times: return left * right; case Divide: return left / right; case Percent: return right * left / 100.0; case Minimum: if (right < left) return right; return left; case Maximum: if (right > left) return right; return left; default: return left; } case Unary: down = Evaluate (l, box, expr->u.unary.down, natural); switch (expr->u.unary.op) { case Percent: return natural * down / 100.0; case Minus: return -down; case Minimum: case Maximum: return down; case Plus: return down; default: return down; } case Width: widget = QuarkToWidget (l, expr->u.width); if (!widget) return 0; info = SubInfo (widget); return info->naturalSize[LayoutHorizontal]; case Height: widget = QuarkToWidget (l, expr->u.height); if (!widget) return 0; info = SubInfo (widget); return info->naturalSize[LayoutVertical]; case Variable: expr = LookupVariable (box, expr->u.variable); if (!expr) { char buf[256]; sprintf (buf, "Layout: undefined variable %s\n", XrmQuarkToString (expr->u.variable)); XtError (buf); return 0.0; } return Evaluate (l, box, expr, natural); default: return 0.0; } } static void DisposeExpr (ExprPtr expr) { if (!expr) return; switch (expr->type) { case Constant: break; case Binary: DisposeExpr (expr->u.binary.left); DisposeExpr (expr->u.binary.right); break; case Unary: DisposeExpr (expr->u.unary.down); break; case Width: break; case Height: break; default: break; } Dispose (expr); } #define CheckGlue(l, box, glue, n) { \ if (glue.expr) \ glue.value = Evaluate (l, box, glue.expr, n); \ if (glue.order == 0 && glue.value == 0) \ glue.order = -1; \ else if (glue.order == -1 && glue.value != 0) \ glue.order = 0; \ } static Boolean ChildInBox(LayoutWidget l, BoxPtr box, Widget child) { while (box) { switch (box->type) { case WidgetBox: if (child == QuarkToWidget(l, box->u.widget.quark)) return True; break; case GlueBox: break; case BoxBox: if (ChildInBox(l, box->u.box.firstChild, child)) return True; break; case VariableBox: break; } box = box->nextSibling; } return False; } static Boolean ChildInLayout(LayoutWidget l, Widget child) { return ChildInBox(l, l->layout.layout, child); } #define DoStretch(l, box, dir) \ CheckGlue (l, box, box->params.stretch[dir], (double) box->natural[dir]); #define DoShrink(l, box, dir) \ CheckGlue (l, box, box->params.shrink[dir], (double) box->natural[dir]) /* compute the natural sizes of a box */ static void ComputeNaturalSizes (LayoutWidget l, BoxPtr box, LayoutDirection dir) { BoxPtr child; Widget w; SubInfoPtr info; int minStretchOrder, minShrinkOrder; LayoutDirection thisDir; switch (box->type) { case WidgetBox: w = box->u.widget.widget = QuarkToWidget (l, box->u.widget.quark); if (!w) { box->natural[LayoutHorizontal] = 0; box->natural[LayoutVertical] = 0; } else { info = SubInfo (w); box->natural[LayoutHorizontal] = info->naturalSize[LayoutHorizontal]; box->natural[LayoutVertical] = info->naturalSize[LayoutVertical]; } DoStretch (l, box, LayoutHorizontal); DoShrink (l, box, LayoutHorizontal); DoStretch (l, box, LayoutVertical); DoShrink (l, box, LayoutVertical); break; case GlueBox: if (box->u.glue.expr[1]) { box->natural[LayoutHorizontal] = Evaluate(l, box, box->u.glue.expr[LayoutHorizontal], 0.0); box->natural[LayoutVertical] = Evaluate(l, box, box->u.glue.expr[LayoutVertical], 0.0); DoStretch (l, box, LayoutHorizontal); DoShrink (l, box, LayoutHorizontal); DoStretch (l, box, LayoutVertical); DoShrink (l, box, LayoutVertical); } else { if (dir == LayoutHorizontal || dir == LayoutVertical) { box->natural[dir] = Evaluate (l, box, box->u.glue.expr[0], 0.0); box->natural[!dir] = 0; DoStretch (l, box, dir); DoShrink (l, box, dir); } else { box->natural[LayoutHorizontal] = 0; box->natural[LayoutVertical] = 0; } } break; case BoxBox: thisDir = box->u.box.dir; box->natural[0] = 0; box->natural[1] = 0; minStretchOrder = 100000; minShrinkOrder = 100000; for (thisDir = LayoutHorizontal; thisDir <= LayoutVertical; thisDir++) { if (thisDir == box->u.box.dir) { ZeroGlue (box->params.shrink[thisDir]); ZeroGlue (box->params.stretch[thisDir]); } else { box->params.shrink[thisDir].order = 100000; box->params.shrink[thisDir].value = 0; box->params.stretch[thisDir].order = 100000; box->params.stretch[thisDir].value = 0; } } for (child = box->u.box.firstChild; child; child = child->nextSibling) { if (child->type == VariableBox) continue; ComputeNaturalSizes (l, child, box->u.box.dir); for (thisDir = LayoutHorizontal; thisDir <= LayoutVertical; thisDir++) { if (thisDir == box->u.box.dir) { /* * along box axis: * normal size += child normal size * shrink += child shrink * stretch += child stretch */ box->natural[thisDir] += child->natural[thisDir]; AddGlue (box->params.shrink[thisDir], box->params.shrink[thisDir], child->params.shrink[thisDir]); AddGlue (box->params.stretch[thisDir], box->params.stretch[thisDir], child->params.stretch[thisDir]); } else { /* * normal to box axis: * normal size = maximum child normal size of minimum shrink order * shrink = difference between normal size and minimum shrink * stretch = minimum child stretch */ if (box->natural[thisDir] >= child->natural[thisDir]) { if (child->params.stretch[thisDir].order < minShrinkOrder) { box->natural[thisDir] = child->natural[thisDir]; minStretchOrder = child->params.stretch[thisDir].order; if (child->params.shrink[thisDir].order < minShrinkOrder) minShrinkOrder = child->params.shrink[thisDir].order; } } else { if (child->params.shrink[thisDir].order <= minStretchOrder) { box->natural[thisDir] = child->natural[thisDir]; minShrinkOrder = child->params.shrink[thisDir].order; if (child->params.stretch[thisDir].order < minStretchOrder) minStretchOrder = child->params.stretch[thisDir].order; } } MinGlue (box->params.stretch[thisDir], box->params.stretch[thisDir], child->params.stretch[thisDir]); MinGlue (box->params.shrink[thisDir], box->params.shrink[thisDir], child->params.shrink[thisDir]); } } } for (thisDir = LayoutHorizontal; thisDir <= LayoutVertical; thisDir++) { if (thisDir != box->u.box.dir) { if (box->params.shrink[thisDir].order <= 0) { int minSize; int largestMinSize; largestMinSize = 0; for (child = box->u.box.firstChild; child; child = child->nextSibling) { if (child->type == VariableBox) continue; if (child->params.shrink[thisDir].order <= 0) { minSize = child->natural[thisDir] - child->params.shrink[thisDir].value; if (minSize > largestMinSize) largestMinSize = minSize; } } box->params.shrink[thisDir].value = box->natural[thisDir] - largestMinSize; if (box->params.shrink[thisDir].value == 0) box->params.shrink[thisDir].order = -1; else box->params.shrink[thisDir].order = 0; } } } break; case VariableBox: box->natural[LayoutHorizontal] = 0; box->natural[LayoutVertical] = 0; break; } } /* given the boxs geometry, set the geometry of the pieces */ #define GluePart(a,b,dist) ((a) ? ((int) (((a) * (dist)) / (b) + \ ((dist >= 0) ? 0.5 : -0.5))) : 0) static Bool ComputeSizes (BoxPtr box) { LayoutDirection dir; BoxPtr child; GlueRec stretch; GlueRec shrink; GlueRec totalGlue[2] = { { .order = 0, .value = 0 }, { .order = 0, .value = 0} }; double remainingGlue = 0.0; GluePtr glue; int size; int totalSizes; int finalSize[2]; int totalChange[2] = { 0, 0 }; int change; int remainingChange = 0; Bool shrinking = 0; Bool happy; int i; int maxGlue = 0; happy = True; for (dir = LayoutHorizontal; dir <= LayoutVertical; dir++) { if (dir == box->u.box.dir) { size = box->size[dir]; stretch = box->params.stretch[dir]; shrink = box->params.shrink[dir]; /* pick the correct adjustment parameters based on the change direction */ totalChange[0] = size - box->natural[dir]; shrinking = totalChange[0] < 0; totalChange[1] = 0; totalGlue[1].order = 100000; totalGlue[1].value = 0; maxGlue = 1; if (shrinking) { totalGlue[0] = shrink; /* for first-order infinites, shrink it to zero and then * shrink the zero-orders */ if (shrink.order == 1) { totalSizes = 0; remainingGlue = 0; for (child = box->u.box.firstChild; child; child = child->nextSibling) { if (child->type == VariableBox) continue; switch (child->params.shrink[dir].order) { case 0: remainingGlue += child->params.shrink[dir].value; break; case 1: totalSizes += child->natural[dir]; break; } } /* * If the amount of first-order shrinkability is less * than the change in size, shrink the zero-order objects * by the difference */ if (totalSizes < -totalChange[0]) { totalGlue[1] = shrink; totalGlue[0].order = 0; totalGlue[0].value = remainingGlue; totalChange[1] = -totalSizes; totalChange[0] = totalChange[0] - totalChange[1]; /* * whoa -- running out of both zero and first order * shrink; shrink zero by max, shrink first by rest */ if (remainingGlue < -totalChange[0]) { totalChange[1] += (totalChange[0] + remainingGlue); totalChange[0] = -remainingGlue; } maxGlue = 2; } } if (totalGlue[0].order <= 0 && -totalChange[0] > totalGlue[0].value) { totalChange[0] = -totalGlue[0].value; } } else totalGlue[0] = stretch; } } /* adjust each box */ for (dir = LayoutHorizontal; dir <= LayoutVertical; dir++) { finalSize[dir] = 0; if (dir == box->u.box.dir) { remainingGlue = totalGlue[0].value + totalGlue[1].value; remainingChange = totalChange[0] + totalChange[1]; } } for (child = box->u.box.firstChild; child; child = child->nextSibling) { if (child->type == VariableBox) continue; for (dir = LayoutHorizontal; dir <= LayoutVertical; dir++) { if (dir == box->u.box.dir) { if (shrinking) glue = &child->params.shrink[dir]; else glue = &child->params.stretch[dir]; child->size[dir] = child->natural[dir]; for (i = 0; i < maxGlue; i++) { if (glue->order == totalGlue[i].order) { remainingGlue -= glue->value; if (remainingGlue <= 0) change = remainingChange; else change = GluePart (glue->value, totalGlue[i].value, totalChange[i]); if (glue->order == -1 && change) happy = False; child->size[dir] += change; remainingChange -= change; } } finalSize[dir] += child->size[dir]; } else { child->size[dir] = box->size[dir]; finalSize[dir] = box->size[dir]; } } if (child->type == BoxBox) if (!ComputeSizes (child)) happy = False; } for (dir = LayoutHorizontal; dir <= LayoutVertical; dir++) if (finalSize[dir] != box->size[dir]) happy = False; return happy; } static void SetSizes (BoxPtr box, Position x, Position y) { BoxPtr child; int width, height; int bw; Widget w; SubInfoPtr info; switch (box->type) { case WidgetBox: w = box->u.widget.widget; if (w) { info = (SubInfoPtr) w->core.constraints; width = box->size[LayoutHorizontal]; height = box->size[LayoutVertical]; bw = info->naturalBw; width -= bw * 2; height -= bw * 2; /* Widgets which grow too small are placed off screen */ if (width <= 0 || height <= 0) { width = 1; height = 1; bw = 0; x = -1; y = -1; } XtConfigureWidget (w, x, y, width, height, bw); } break; case GlueBox: break; case BoxBox: for (child = box->u.box.firstChild; child; child = child->nextSibling) { if (child->type == VariableBox) continue; SetSizes (child, x, y); if (box->u.box.dir == LayoutHorizontal) x += child->size[LayoutHorizontal]; else if (box->u.box.dir == LayoutVertical) y += child->size[LayoutVertical]; } break; case VariableBox: break; } } static void LayoutFreeLayout (BoxPtr box) { BoxPtr child, next; switch (box->type) { default: break; case BoxBox: for (child = box->u.box.firstChild; child; child = next) { next = child->nextSibling; LayoutFreeLayout (child); } break; case GlueBox: DisposeExpr (box->u.glue.expr[LayoutHorizontal]); DisposeExpr (box->u.glue.expr[LayoutVertical]); break; } DisposeExpr (box->params.stretch[LayoutHorizontal].expr); DisposeExpr (box->params.shrink[LayoutHorizontal].expr); DisposeExpr (box->params.stretch[LayoutVertical].expr); DisposeExpr (box->params.shrink[LayoutVertical].expr); Dispose (box); } static void LayoutGetNaturalSize (LayoutWidget l, Dimension *widthp, Dimension *heightp) { BoxPtr box; box = l->layout.layout; if (box) { ComputeNaturalSizes (l, box, LayoutHorizontal); *widthp = box->natural[LayoutHorizontal]; *heightp = box->natural[LayoutVertical]; } else { *widthp = 0; *heightp = 0; } } static void LayoutLayout (LayoutWidget l, Bool attemptResize) { BoxPtr box; Dimension prefered_width, prefered_height; box = l->layout.layout; if (!box) return; prefered_width = l->layout.prefered_width; prefered_height = l->layout.prefered_height; LayoutGetNaturalSize (l, &l->layout.prefered_width, &l->layout.prefered_height); if (l->core.width == 0 || l->core.height == 0) { l->core.width = l->layout.prefered_width; l->core.height = l->layout.prefered_height; } if (prefered_width == 0) prefered_width = l->layout.prefered_width; if (prefered_height == 0) prefered_height = l->layout.prefered_height; if (attemptResize && (!XtIsRealized((Widget) l) || l->layout.resize) && (l->layout.prefered_width != prefered_width || l->layout.prefered_height != prefered_height)) { printf("Layout %s request resize to %d x %d\n", l->core.name, l->layout.prefered_width, l->layout.prefered_height); (void) XtMakeResizeRequest ((Widget) l, l->layout.prefered_width, l->layout.prefered_height, NULL, NULL); printf("\tresult %d x %d\n", l->core.width, l->core.height); } box->size[LayoutHorizontal] = l->core.width; box->size[LayoutVertical] = l->core.height; ComputeSizes (box); if (l->layout.debug) { printf ("Layout widget %s\n", XtName ((Widget) l)); PrintBox (box, 1); fflush (stdout); } SetSizes (box, 0, 0); if (l->layout.debug) printf ("Layout widget done with %s\n", XtName((Widget) l)); } LayoutClassRec layoutClassRec = { { /* core class fields */ /* superclass */ (WidgetClass) SuperClass, /* class name */ "Layout", /* size */ sizeof(LayoutRec), /* class_initialize */ ClassInitialize, /* class_part init */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* resource_count */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ 0, /* compress_exposure */ 0, /* compress_enterleave*/ 0, /* visible_interest */ FALSE, /* destroy */ NULL, /* resize */ Resize, /* expose */ NULL, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ NULL, /* query_geometry */ QueryGeometry, /* display_accelerator*/ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* composite class fields */ /* geometry_manager */ GeometryManager, /* change_managed */ ChangeManaged, /* insert_child */ InsertChild, /* delete_child */ XtInheritDeleteChild, /* extension */ NULL }, { /* constraint class fields */ /* subresources */ NULL, /* subresource_count */ 0, /* constraint_size */ sizeof(LayoutConstraintsRec), /* initialize */ NULL, /* destroy */ NULL, /* set_values */ NULL, /* extension */ NULL }, #ifdef MOTIF /* manager class fields */ { /* stolen from the one minute manager's Template.c */ XtInheritTranslations, /* translations */ NULL, /* syn_resources */ 0, /* num_syn_resources */ NULL, /* syn_constraint_resources */ 0, /* num_syn_constraint_resources */ XmInheritParentProcess, /* parent_process */ NULL, /* extension */ }, #endif /* MOTIF */ /* layout class fields */ { 0 }, }; WidgetClass layoutWidgetClass = (WidgetClass) &layoutClassRec; kgames-2.2/Xkw/Layout.h000066400000000000000000000063521416764561500150500ustar00rootroot00000000000000/* * $XConsortium: Layout.h,v 1.2 92/01/22 18:03:05 keith Exp $ * * Copyright 1991 Massachusetts Institute of Technology * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, MIT X Consortium */ #ifndef _Layout_h #define _Layout_h #include #include /**************************************************************** * * Layout Widget (SubClass of CompositeClass) * ****************************************************************/ /* RESOURCES: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 cursor Cursor Cursor None destroyCallback Callback Pointer NULL height Height Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 layout Layout Layout NULL */ /* * Syntax of layout resource * * *layout:\ * .,.: distance + stretch-factor\n\ * ... * where the null widget-name is taken to be the Layout widget * * e.g: * * *label-1.hStretch: 0 * *label-2.vStretch: 1 * *layout:\ * .left, label-1.left: 10 + 0\n\ * label-1.right, label-2.left: 10 + 1\n\ * label-2.right, .right: 10 + 0 * * This layout causes label-1 to be set 10 pixels from the left edge * and be whatever size the label widget requests, while label-2 will * be set 10 pixels from the right edge, and take up half of the remaining * space to 10 pixels from the right edge of label-1. */ /* New Fields */ #define XtNlayout "layout" #define XtCLayout "Layout" #define XtRLayout "Layout" #define XtNdebug "debug" /* Class record constant */ extern WidgetClass layoutWidgetClass; typedef struct _LayoutClassRec *LayoutWidgetClass; typedef struct _LayoutRec *LayoutWidget; #endif /* _Layout_h */ /* DON'T ADD STUFF AFTER THIS #endif */ kgames-2.2/Xkw/LayoutP.h000066400000000000000000000135151416764561500151670ustar00rootroot00000000000000/* * $XConsortium: LayoutP.h,v 1.2 92/01/22 18:03:08 keith Exp $ * * Copyright 1991 Massachusetts Institute of Technology * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, MIT X Consortium */ #ifndef _LayoutP_h #define _LayoutP_h #include "Layout.h" #include #ifdef MOTIF #include #endif #define GlueEqual(a,b) ((a).order == (b).order && (a).value == (b).value) #define AddGlue(r,a,b) if (a.order == b.order) { \ r.order = a.order; \ r.value = a.value + b.value; \ } else { \ if (a.order > b.order) \ r = a; \ else \ r = b; \ } #define MinGlue(r,a,b) if (a.order == b.order) { \ r.order = a.order; \ if (a.value > b.value) \ r.value = b.value; \ else \ r.value = a.value; \ } else { \ if (a.order > b.order) \ r = b; \ else \ r = a; \ } #define SubGlue(r,a,b) if (a.order == b.order) { \ r.order = a.order; \ r.value = a.value - b.value; \ } else { \ if (a.order > b.order) \ r = a; \ else { \ r.order = b.order; \ r.value = -b.value; \ } \ } #define ZeroGlue(g) ((g).value = 0, (g).order = -1, (g).expr = 0) #define IsZeroGlue(g) ((g).value == 0) #define QuarkToWidget(l,q) XtNameToWidget((Widget) l, \ (char *) XrmQuarkToString(q)) typedef enum _BoxType { BoxBox, WidgetBox, GlueBox, VariableBox } BoxType; typedef enum _LayoutDirection { LayoutHorizontal = 0, LayoutVertical = 1, LayoutOverlay = 2, } LayoutDirection; typedef enum _Operator { Plus, Minus, Times, Divide, Percent, Minimum, Maximum } Operator; typedef enum _ExprType { Constant, Binary, Unary, Width, Height, Variable } ExprType; typedef struct _Expr *ExprPtr; typedef struct _Expr { ExprType type; union { double constant; struct { Operator op; ExprPtr left, right; } binary; struct { Operator op; ExprPtr down; } unary; XrmQuark width; XrmQuark height; XrmQuark variable; } u; } ExprRec; typedef struct _Glue { int order; double value; ExprPtr expr; } GlueRec, *GluePtr; typedef struct _BoxParams { GlueRec stretch[2]; GlueRec shrink[2]; } BoxParamsRec, *BoxParamsPtr; typedef struct _Box *BoxPtr; typedef BoxPtr LayoutPtr; typedef struct _Box { BoxPtr nextSibling; BoxPtr parent; BoxParamsRec params; int size[2]; int natural[2]; BoxType type; union { struct { BoxPtr firstChild; LayoutDirection dir; } box; struct { XrmQuark quark; Widget widget; } widget; struct { ExprPtr expr[2]; } glue; struct { XrmQuark quark; ExprPtr expr; } variable; } u; } BoxRec; typedef struct _SubInfo { int naturalSize[2]; int naturalBw; } SubInfoRec, *SubInfoPtr; #define New(t) (t *) malloc(sizeof (t)) #define Dispose(p) free((char *) p) #define Some(t,n) (t*) malloc(sizeof(t) * n) #define More(p,t,n) ((p)? (t *) realloc((char *) p, sizeof(t)*n):Some(t,n) #define ForAllChildren(pw, childP) \ for ( (childP) = (pw)->composite.children ; \ (childP) < (pw)->composite.children + (pw)->composite.num_children ; \ (childP)++ ) if (!XtIsManaged(*childP)) ; else void LayYYsetsource(char *s); int LayYYlex(void); void LayYYsetdest (LayoutPtr *c); int LayYYparse(void); /********************************************************************* * * Layout Widget Private Data * *********************************************************************/ /* New fields for the Layout widget class record */ typedef struct _LayoutClassPart { int foo; /* keep compiler happy. */ } LayoutClassPart; /* Full Class record declaration */ typedef struct _LayoutClassRec { CoreClassPart core_class; CompositeClassPart composite_class; ConstraintClassPart constraint_class; #ifdef MOTIF XmManagerClassPart manager_class; #endif LayoutClassPart layout_class; } LayoutClassRec; extern LayoutClassRec layoutClassRec; typedef struct _LayoutConstraintsRec { SubInfoRec layout; } LayoutConstraintsRec, *LayoutConstraints; #define SubInfo(w) (&(((LayoutConstraints) (w)->core.constraints)->layout)) /* New Fields for the Layout widget record */ typedef struct { /* resources */ LayoutPtr layout; Boolean debug; Boolean resize; Dimension prefered_width; Dimension prefered_height; } LayoutPart; /************************************************************************** * * Full instance record declaration * **************************************************************************/ typedef struct _LayoutRec { CorePart core; CompositePart composite; ConstraintPart constraint; #ifdef MOTIF XmManagerPart manager; #endif LayoutPart layout; } LayoutRec; #endif kgames-2.2/Xkw/Message.c000066400000000000000000000102041416764561500151410ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include "Cards.h" # include # include # include # include "Message.h" char * CardsSuitName (CardsSuit s) { switch (s) { case CardsSpade: return "Spade"; case CardsHeart: return "Heart"; case CardsDiamond: return "Diamond"; case CardsClub: return "Club"; default: return "???"; } } char * CardsRankName (CardsRank r) { switch (r) { case CardsAce: return "Ace"; case Cards2: return "Deuce"; case Cards3: return "Three"; case Cards4: return "Four"; case Cards5: return "Five"; case Cards6: return "Six"; case Cards7: return "Seven"; case Cards8: return "Eight"; case Cards9: return "Nine"; case Cards10: return "Ten"; case CardsJack: return "Jack"; case CardsQueen: return "Queen"; case CardsKing: return "King"; default: return "???"; } } static char * MessageCard (char *s, CardsCardPtr c) { if (c->suit > CardsSpade || c->rank > CardsKing) sprintf (s, "empty stack"); else sprintf (s, "%s of %ss", CardsRankName (c->rank), CardsSuitName (c->suit)); return s + strlen(s); } static char * MessageShortCard (char *s, CardsCardPtr c) { char suit; suit = *CardsSuitName(c->suit) - ('A' - 'a'); if (Cards2 <= c->rank && c->rank <= Cards10) sprintf (s, "%d%c", c->rank, suit); else sprintf (s, "%c%c", *CardsRankName(c->rank), suit); return s + strlen(s); } static char * MessageInt (char *s, int i) { sprintf (s, "%d", i); return s + strlen(s); } static char MessageBuffer[1024]; static char *MessagePtr; void MessageAppendV (const char *format, va_list args) { char *m; m = MessagePtr; while (*format) { if (*format == '%') switch (*++format) { case 's': strcpy (m, va_arg(args, char *)); m += strlen (m); break; case 'c': *m++ = va_arg(args, int); break; case 'd': m = MessageInt (m, va_arg(args, int)); break; case 'p': m = MessageShortCard (m, va_arg(args, CardsCardPtr)); break; case 'P': m = MessageCard (m, va_arg(args, CardsCardPtr)); break; default: *m++ = *format; } else *m++ = *format; format++; } MessagePtr = m; } void MessageStart (void) { MessagePtr = MessageBuffer; } void MessageEnd (Widget w) { Arg arg[1]; *MessagePtr = '\0'; XtSetArg (arg[0], XtNlabel, MessageBuffer); XtSetValues (w, arg, 1); } void MessageAppend (const char *format, ...) { va_list args; va_start (args, format); MessageAppendV (format, args); va_end (args); } void MessageV (Widget w, const char *format, va_list args) { MessageStart (); MessageAppendV (format, args); MessageEnd (w); } void Message (Widget w, const char *format, ...) { va_list args; va_start (args, format); MessageV(w, format, args); va_end (args); } kgames-2.2/Xkw/Message.h000066400000000000000000000030121416764561500151450ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _MESSAGE_H_ #define _MESSAGE_H_ #include void MessageStart (void); void MessageEnd (Widget w); void MessageAppend (const char *format, ...); void MessageAppendV (const char *format, va_list ap); void Message (Widget w, const char *format, ...); void MessageV (Widget w, const char *format, va_list ap); #endif /* _MESSAGE_H_ */ kgames-2.2/Xkw/Pad.c000066400000000000000000000357021416764561500142730ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include #include #include #include "PadP.h" static void Clear (PadLinePtr l, int n) { char *t, *a; t = l->text; a = l->attr; while (n--) { *t++ = ' '; *a++ = XkwPadNormal; } *t = '\0'; } static void ResizeBuffer (PadLinePtr *bp, Dimension old_rows, Dimension old_cols, Dimension new_rows, Dimension new_cols) { PadLinePtr oldb; PadLinePtr b; int row; int max_row, max_col; b = Some(PadLineRec, new_rows); for (row = 0; row < new_rows; row++) AllocText (&b[row], new_cols); oldb = *bp; if (oldb) { max_col = new_cols; if (max_col > old_cols) max_col = old_cols; max_row = new_rows; if (max_row > old_rows) max_row = old_rows; for (row = 0; row < max_row; row++) CopyText (&oldb[row], &b[row], 0, max_col); for (row = 0; row < old_rows; row++) DisposeText (&oldb[row]); Dispose (oldb); } *bp = b; } static void ResizeText (PadWidget w, Dimension rows, Dimension cols) { ResizeBuffer (&w->pad.lines, w->pad.rows, w->pad.cols, rows, cols); w->pad.rows = rows; w->pad.cols = cols; if (w->pad.resize_callbacks != NULL) XtCallCallbackList ((Widget) w, w->pad.resize_callbacks, (XtPointer) NULL); } static void init_cairo(PadWidget w, cairo_t *cr) { cairo_set_font_face(cr, w->pad.font.font_face); cairo_set_font_size(cr, w->pad.font.size * w->ksimple.dpi / 72.0); } static cairo_t * get_cairo(PadWidget w) { cairo_t *cr = XkwGetCairo((Widget) w); init_cairo(w, cr); return cr; } static cairo_t * draw_begin(PadWidget w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); init_cairo(w, cr); return cr; } static void draw_end(PadWidget w, Region region, cairo_t *cr) { XkwDrawEnd((Widget) w, region, cr); } static int show_text(cairo_t *cr, XRenderColor *fg, XRenderColor *bg, double x, double y, char *text, int len) { char save = text[len]; if (save != '\0') text[len] = '\0'; cairo_text_extents_t text_extents; cairo_font_extents_t font_extents; cairo_text_extents(cr, text, &text_extents); cairo_font_extents(cr, &font_extents); if (bg) { XkwSetSource(cr, bg); cairo_rectangle(cr, x, y - font_extents.ascent, text_extents.x_advance, font_extents.ascent + font_extents.descent); cairo_fill(cr); } XkwSetSource(cr, fg); cairo_move_to(cr, x, y); cairo_show_text(cr, text); if (save != '\0') text[len] = save; return text_extents.x_advance; } static double text_width(cairo_t *cr, char *text, int len) { char save = text[len]; if (save != '\0') text[len] = '\0'; cairo_text_extents_t text_extents; cairo_text_extents(cr, text, &text_extents); if (save != '\0') text[len] = save; return text_extents.x_advance; } static void getSize (PadWidget w, Dimension rows, Dimension cols, Dimension *widthp, Dimension *heightp) { cairo_t *cr = get_cairo(w); cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); w->pad.underline_pos = (font_extents.descent) / 2; w->pad.underline_thickness = font_extents.height / 10; if (w->pad.underline_thickness < 1) w->pad.underline_thickness = 1; if (w->pad.underline_pos + w->pad.underline_thickness > font_extents.descent) { if (w->pad.underline_pos > 1) w->pad.underline_pos = font_extents.descent - w->pad.underline_thickness; if (w->pad.underline_pos <= 1) { if (w->pad.underline_pos < 0) w->pad.underline_pos = 0; w->pad.underline_thickness = font_extents.descent - w->pad.underline_pos; } } w->pad.char_width = text_width(cr, "0", 1); w->pad.char_height = font_extents.height * 1.1; w->pad.char_vAdjust = font_extents.ascent; w->pad.char_hAdjust = 0; *widthp = w->pad.char_width * cols + 2 * w->pad.internal_border; *heightp = w->pad.char_height * rows + 2 * w->pad.internal_border; cairo_destroy(cr); } static void setSize (PadWidget w) { int rows, cols; rows = ((int) w->core.height - 2 * (int) w->pad.internal_border) / (int) w->pad.char_height; if (rows <= 0) rows = 1; cols = ((int) w->core.width - 2 * (int) w->pad.internal_border) / (int) w->pad.char_width; if (cols <= 0) cols = 1; if (rows != w->pad.rows || cols != w->pad.cols) ResizeText (w, rows, cols); } static void ClassInitialize(void) { XkwInitializeWidgetSet(); } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { PadWidget new = (PadWidget) gnew; (void) greq; (void) args; (void) count; getSize (new, new->pad.rows, new->pad.cols, &new->core.width, &new->core.height); new->pad.lines = 0; ResizeText (new, new->pad.rows, new->pad.cols); } static int XToCol(PadWidget w, cairo_t *cr, int row, int x) { char *c; int col; c = w->pad.lines[row].text; for (col = 0; col < w->pad.cols - 1; col++) if (x < text_width (cr, c, col)) break; return col; } static void DrawText (PadWidget w, cairo_t *cr, int row, int start_col, int end_col) { int change_col; char attr; char *a, *t; PadLinePtr line; int x, y; int width; line = &w->pad.lines[row]; a = line->attr + start_col; t = line->text + start_col; change_col = start_col; x = (w)->pad.internal_border + w->pad.char_hAdjust + text_width(cr, line->text, start_col); y = (w)->pad.internal_border + w->pad.char_vAdjust + row * w->pad.char_height; while (start_col < end_col) { attr = *a; do { ++a; ++change_col; } while (change_col < end_col && *a == attr); XRenderColor *fg = &w->ksimple.foreground; XRenderColor *bg = NULL; if (attr & XkwPadBold) fg = &w->pad.bold; if (attr & XkwPadInverse) { bg = fg; fg = &w->ksimple.background; } width = show_text(cr, fg, bg, x, y, t, change_col - start_col); if (attr & XkwPadUnderline) { cairo_rectangle(cr, x, y + w->pad.underline_pos, width, w->pad.underline_thickness); cairo_fill(cr); } /* if (attr & XkwPadOutline) { int o_col, o_x, o_y, o_w, o_h; o_x = x; o_y = y - w->pad.font->ascent; o_h = w->pad.font->ascent + w->pad.font->descent; for (o_col = start_col; o_col < change_col; o_col++) { o_w = XTextWidth (w->pad.font, is->text + o_col, 1); if (o_w && o_h) { XDrawRectangle (dpy, win, gc, o_x, o_y, o_w - 1, o_h - 1); } } } */ x += width; t += (change_col - start_col); start_col = change_col; } } static void RedrawText (PadWidget w, cairo_t *cr, int row, int start_col, int end_col) { char *t, *a; t = w->pad.lines[row].text + start_col; a = w->pad.lines[row].attr + start_col; while (start_col < end_col && *t == ' ' && *a == XkwPadNormal) { t++; a++; start_col++; } t = w->pad.lines[row].text + end_col - 1; a = w->pad.lines[row].attr + end_col - 1; while (end_col > start_col && *t == ' ' && *a == XkwPadNormal) { t--; a--; end_col--; } if (start_col < end_col) DrawText (w, cr, row, start_col, end_col); } static void Redisplay (Widget gw, XEvent *event, Region region) { PadWidget w = (PadWidget) gw; int row; if (!XtIsRealized (gw)) return; if (!event || (event->type == Expose && event->xexpose.count == 0)) { cairo_t *cr = draw_begin(w, region); for (row = 0; row < w->pad.rows; row++) RedrawText (w, cr, row, 0, w->pad.cols); draw_end(w, region, cr); } } static void Resize (Widget gw) { PadWidget w = (PadWidget) gw; setSize (w); } void XkwPadUpdate (Widget gw) { Redisplay(gw, NULL, NULL); } void XkwPadText (Widget gw, int row, int col, char *text, int len) { PadWidget w = (PadWidget) gw; PadLinePtr line; if (row >= w->pad.rows || col >= w->pad.cols) return; line = &w->pad.lines[row]; if (col + len > w->pad.cols) len = w->pad.cols - col; memcpy (line->text + col, text, len); } void XkwPadAttributes (Widget gw, int row, int col, char *attr, int len) { PadWidget w = (PadWidget) gw; PadLinePtr line; if (row >= w->pad.rows || col >= w->pad.cols) return; line = &w->pad.lines[row]; if (col + len > w->pad.cols) len = w->pad.cols - col; memcpy (line->attr + col, attr, len); } void XkwPadTextAndAttributes (Widget gw, int row, int col, char *text, char *attr, int len) { PadWidget w = (PadWidget) gw; PadLinePtr line; if (row >= w->pad.rows || col >= w->pad.cols) return; line = &w->pad.lines[row]; if (col + len > w->pad.cols) len = w->pad.cols - col; memcpy (line->text + col, text, len); memcpy (line->attr + col, attr, len); } void XkwPadClearToEnd (Widget gw, int row, int col) { PadWidget w = (PadWidget) gw; PadLinePtr line; char *t, *a; if (row >= w->pad.rows || col >= w->pad.cols) return; line = &w->pad.lines[row]; t = line->text + col; a = line->attr + col; col = w->pad.cols - col; while (col--) { *t++ = ' '; *a++ = XkwPadNormal; } } void XkwPadClear (Widget gw) { PadWidget w = (PadWidget) gw; int row; for (row = 0; row < w->pad.rows; row++) XkwPadClearToEnd (gw, row, 0); } static void ScrollBuffer (PadWidget w, PadLinePtr b, int start_row, int end_row, int dist) { int first_row, row, next_row; PadLineRec tmp1, tmp2; int n; if (end_row <= start_row) return; n = end_row - start_row; first_row = start_row; while (n) { tmp2 = b[first_row]; row = first_row; do { next_row = row + dist; if (next_row < start_row) next_row = next_row + end_row - start_row; else if (next_row >= end_row) next_row = next_row - end_row + start_row; tmp1 = b[next_row]; b[next_row] = tmp2; tmp2 = tmp1; n--; row = next_row; } while (row != first_row); first_row++; } n = dist; if (n < 0) { n = -n; row = end_row - n; } else row = start_row; while (n--) { Clear (&b[row], w->pad.cols); row++; } } void XkwPadScroll (Widget gw, int start_row, int end_row, int dist) { PadWidget w = (PadWidget) gw; ScrollBuffer (w, w->pad.lines, start_row, end_row, dist); } void XkwPadXYToRowCol (Widget gw, int x, int y, int *rowp, int *colp) { PadWidget w = (PadWidget) gw; int row, col; cairo_t *cr = get_cairo(w); row = RowPos (w, y); if (row < 0) row = 0; if (row >= w->pad.rows) row = w->pad.rows - 1; // if (w->pad.fixed_width) // col = ColPos (w, x); // else col = XToCol (w, cr, row, x); if (col < 0) col = 0; if (col >= w->pad.cols) col = w->pad.cols - 1; *rowp = row; *colp = col; cairo_destroy(cr); } static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { PadWidget cur = (PadWidget) gcur, req = (PadWidget) greq, new = (PadWidget) gnew; Boolean redraw = FALSE, newsize = FALSE; Dimension width, height; (void) args; (void) count; if (memcmp(&req->ksimple.foreground, &cur->ksimple.foreground, sizeof(XRenderColor)) != 0) redraw = TRUE; if (req->pad.font.font_face != cur->pad.font.font_face || req->pad.font.size != cur->pad.font.size) newsize = TRUE; if (req->pad.rows != cur->pad.rows || req->pad.cols != cur->pad.cols) { newsize = TRUE; } if (newsize) { getSize (new, req->pad.rows, req->pad.cols, &width, &height); new->pad.rows = cur->pad.rows; new->pad.cols = cur->pad.cols; XtMakeResizeRequest (gnew, width, height, &width, &height); redraw = TRUE; } return redraw; } static XtResource resources[] = { #define offset(field) XtOffsetOf(PadRec, pad.field) /* {name, class, type, size, offset, default_type, default_addr}, */ { XtNfont, XtCFont, XtRXkwFont, sizeof (XkwFont), offset (font), XtRString, XtDefaultFont }, { XtNbold, XtCBold, XtRRenderColor, sizeof (XRenderColor), offset (bold), XtRString, "red" }, { XtNnumRows, XtCNumRows, XtRDimension, sizeof (Dimension), offset (rows), XtRImmediate, (XtPointer) 1}, { XtNnumCols, XtCNumCols, XtRDimension, sizeof (Dimension), offset (cols), XtRImmediate, (XtPointer) 1}, {XtNinternalBorderWidth, XtCInternalBorderWidth, XtRDimension, sizeof (Dimension), offset(internal_border), XtRImmediate, (XtPointer) 2}, {XtNresizeCallback, XtCCallback, XtRCallback,sizeof(XtPointer), offset(resize_callbacks), XtRCallback, (XtPointer)NULL}, #undef offset }; PadClassRec padClassRec = { { /* core fields */ /* superclass */ (WidgetClass) &ksimpleClassRec, /* class_name */ "Pad", /* widget_size */ sizeof(PadRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ XtExposeCompressSeries|XtExposeGraphicsExpose|XtExposeNoExpose, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ NULL, /* resize */ Resize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ NULL, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { 0, }, { /* pad fields */ /* empty */ 0 } }; WidgetClass padWidgetClass = (WidgetClass)&padClassRec; kgames-2.2/Xkw/Pad.h000066400000000000000000000062141416764561500142740ustar00rootroot00000000000000/* $XConsortium: Pad.h,v 1.5 90/12/19 18:46:00 converse Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #ifndef _Pad_h #define _Pad_h /**************************************************************** * * Pad widget * ****************************************************************/ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 resizeCallbacks Callback Pointer NULL destroyCallback Callback Pointer NULL height Height Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ /* define any special resource names here that are not in */ #define XtNresizeCallback "resizeCallback" #define XtNinternalBorderWidth "internalBorderWidth" #define XtCInternalBorderWidth "InternalBorderWidth" #define XtNnumRows "numRows" #define XtCNumRows "NumRows" #define XtNnumCols "numCols" #define XtCNumCols "NumCols" #define XtNbold "bold" #define XtCBold "Bold" /* declare the class constant */ extern WidgetClass padWidgetClass; /* declare class-specific functions */ #define XkwPadNormal 0 #define XkwPadInverse 1 #define XkwPadBold 2 #define XkwPadUnderline 4 #define XkwPadBlink 8 #define XkwPadOutline 16 extern void XkwPadUpdate (Widget gw); extern void XkwPadText (Widget gw, int row, int col, char *text, int len); extern void XkwPadAttributes (Widget gw, int row, int col, char *attr, int len); extern void XkwPadTextAndAttributes (Widget gw, int row, int col, char *text, char *attr, int len); extern void XkwPadClearToEnd (Widget gw, int row, int col); extern void XkwPadClear (Widget gw); extern void XkwPadScroll (Widget gw, int start_row, int end_row, int dist); extern void XkwPadXYToRowCol (Widget gw, int x, int y, int *rowp, int *colp); #endif /* _Pad_h */ kgames-2.2/Xkw/PadP.h000066400000000000000000000061321416764561500144130ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _PadP_h #define _PadP_h #include "Pad.h" /* include superclass private header file */ #include #include #include typedef struct { int empty; } PadClassPart; typedef struct _PadClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; PadClassPart pad_class; } PadClassRec; extern PadClassRec padClassRec; typedef struct _PadLine { char *text; char *attr; } PadLineRec, *PadLinePtr; typedef struct { /* resources */ XkwFont font; XRenderColor bold; Dimension rows, cols; Dimension internal_border; XtCallbackList resize_callbacks; /* private state */ PadLinePtr lines; int underline_pos; int underline_thickness; int char_width; int char_height; int char_vAdjust; int char_hAdjust; } PadPart; #define New(t) (t *) malloc(sizeof (t)) #define Dispose(p) free((char *) p) #define Some(t,n) (t*) malloc(sizeof(t) * n) #define More(p,t,n) ((p)? (t *) realloc((char *) p, sizeof(t)*n):Some(t,n) #define AllocText(b, cols) (\ (b)->text = Some(char, (cols)+1),\ (b)->attr = Some(char, (cols)+1),\ Clear (b, cols)) #define DisposeText(b) (Dispose ((b)->text), Dispose ((b)->attr)) #define CopyText(fromb, tob, col, num) (\ memcpy((tob)->text + col, (fromb)->text + col, num), \ memcpy((tob)->attr + col, (fromb)->attr + col, num)) #define ColPos(w,x) (((x)-(int)(w)->pad.internal_border) /\ (int)(w)->pad.char_width) #define RowPos(w,y) (((y)-(int)(w)->pad.internal_border) /\ (int)(w)->pad.char_height) typedef struct _PadRec { CorePart core; SimplePart simple; KSimplePart ksimple; PadPart pad; } PadRec; /* declare specific PadWidget class and instance datatypes */ typedef struct _PadClassRec* PadWidgetClass; typedef struct _PadRec* PadWidget; #endif /* _PadP_h */ kgames-2.2/Xkw/PadTest.ad000066400000000000000000000000421416764561500152620ustar00rootroot00000000000000*pad.numRows: 24 *pad.numCols: 80 kgames-2.2/Xkw/SuitCards.c000066400000000000000000000105011416764561500154560ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include void SuitCardsInit (SuitCardsPtr s, CardStackPtr under, Widget widget, CardsSuit emptySuit, Boolean horizontal, int row, int col, CardDisplay display) { int position; int basePosition; CardsSuit suit; CardStackPtr stack; (void) under; if (horizontal) { position = col; basePosition = row; } else { position = row; basePosition = col; } for (suit = CardsClub; suit <= CardsSpade; suit++) { stack = &s->suits[CardsSuitToInt(suit)]; CardInitStack (stack, widget, emptySuit, !horizontal, position, display); stack->basePosition = basePosition; position++; } s->aceHigh = True; } static Boolean SuitRankGreater (CardsRank a, CardsRank b, Boolean aceHigh) { if (a == b) return False; if (a == CardsAce) return aceHigh; if (b == CardsAce) return !aceHigh; return a > b; } static void SuitCardsMoveFromStack (CardStackPtr from_stack, CardPtr card, SuitCardsPtr to_suit, Boolean remember) { CardStackPtr to_stack; CardPtr to_card, next_card; CardsSuit suit; CardsRank rank; suit = card->card.suit; rank = card->card.rank; to_stack = &to_suit->suits[CardsSuitToInt(suit)]; to_card = 0; for (next_card = to_stack->first; next_card; next_card = next_card->next) { if (SuitRankGreater (rank, next_card->card.rank, to_suit->aceHigh)) break; to_card = next_card; } CardMoveCards (from_stack, card, card, to_stack, to_card, remember); } void SuitCardsMove (SuitCardsPtr from_suit, CardPtr card, SuitCardsPtr to_suit, Boolean remember) { CardStackPtr from_stack; CardsSuit suit; suit = card->card.suit; from_stack = &from_suit->suits[CardsSuitToInt(suit)]; SuitCardsMoveFromStack (from_stack, card, to_suit, remember); } void SuitCardsMoveToStack (SuitCardsPtr from_suit, CardPtr card, CardStackPtr to_stack, CardPtr to_card, Boolean remember) { CardStackPtr from_stack; CardsSuit suit; suit = card->card.suit; from_stack = &from_suit->suits[CardsSuitToInt(suit)]; CardMoveCards (from_stack, card, card, to_stack, to_card, remember); } void SuitCardsDisplay (SuitCardsPtr s) { CardsSuit suit; for (suit = CardsClub; suit <= CardsSpade; suit++) CardDisplayStack (&s->suits[CardsSuitToInt(suit)]); } CardPtr SuitCardsHandInputToCard (SuitCardsPtr s, HandInputPtr input) { CardsSuit suit; int suitPosition; CardStackPtr stack; CardPtr card; if (s->suits[CardsClub].horizontal) suitPosition = input->current.row; else suitPosition = input->current.col; suit = IntToCardsSuit (suitPosition - s->suits[CardsClub].position); stack = &s->suits[suit]; for (card = stack->last; card; card = card->prev) if (card->shouldBeUp && card->row == input->current.row && card->col == input->current.col) return card; return 0; } kgames-2.2/Xkw/SuitCards.h000066400000000000000000000037511416764561500154740ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include typedef struct _SuitCards { Boolean aceHigh; CardStackRec suits[4]; } SuitCardsRec, *SuitCardsPtr; CardPtr SuitCardsHandInputToCard (SuitCardsPtr, HandInputPtr); void SuitCardsInit (SuitCardsPtr s, CardStackPtr under, Widget widget, CardsSuit emptySuit, Boolean horizontal, int row, int col, CardDisplay display); void SuitCardsDisplay (SuitCardsPtr s); void SuitCardsMove (SuitCardsPtr from_suit, CardPtr card, SuitCardsPtr to_suit, Boolean remember); void SuitCardsMoveToStack (SuitCardsPtr from_suit, CardPtr card, CardStackPtr to_stack, CardPtr to_card, Boolean remember); CardPtr SuitCardsHandInputToCard (SuitCardsPtr s, HandInputPtr input); kgames-2.2/Xkw/Svg.c000066400000000000000000000043111416764561500143160ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include #include //#include RsvgHandle * XkwRsvgCreate(const char *str) { GError *error; error = NULL; return rsvg_handle_new_from_data((const guint8 *) str, strlen(str), &error); } void XkwRsvgDestroy(RsvgHandle *handle) { g_object_unref(handle); } double XkwRsvgAspect(RsvgHandle *rsvg) { RsvgDimensionData dimension_data; rsvg_handle_get_dimensions(rsvg, &dimension_data); if (dimension_data.height == 0) return INFINITY; return (double) dimension_data.width / (double) dimension_data.height; } void XkwRsvgDraw(cairo_t *cr, int surface_width, int surface_height, RsvgHandle *rsvg) { RsvgDimensionData dimension_data; double scale_x; double scale_y; cairo_save(cr); rsvg_handle_get_dimensions(rsvg, &dimension_data); scale_x = (double) surface_width / (double) dimension_data.width; scale_y = (double) surface_height / (double) dimension_data.height; cairo_scale(cr, scale_x, scale_y); rsvg_handle_render_cairo(rsvg, cr); cairo_restore(cr); } kgames-2.2/Xkw/Thermo.c000066400000000000000000000333061416764561500150230ustar00rootroot00000000000000/* $XConsortium: Thermo.c,v 1.4 91/02/17 16:18:42 converse Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #include #include #include #include "ThermoP.h" static XtResource resources[] = { #define offset(field) XtOffsetOf(ThermoRec, thermo.field) /* {name, class, type, size, offset, default_type, default_addr}, */ { XtNfont, XtCFont, XtRXkwFont, sizeof (XkwFont), offset (font), XtRString, XtDefaultFont }, { XtNmercuryColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (mercuryColor), XtRString, XtDefaultForeground }, { XtNtickColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (tickColor), XtRString, XtDefaultForeground }, { XtNthickness, XtCThickness, XtRInt, sizeof (int), offset (reqThickness), XtRImmediate, (XtPointer) ThermoUnspecified }, { XtNminimum, XtCMinimum, XtRInt, sizeof (int), offset (minimum), XtRImmediate, (XtPointer) 0}, { XtNmaximum, XtCMaximum, XtRInt, sizeof (int), offset (maximum), XtRImmediate, (XtPointer) 0}, { XtNcurrent, XtCCurrent, XtRInt, sizeof (int), offset (current), XtRImmediate, (XtPointer) 0}, { XtNminorStart, XtCMinorStart, XtRInt, sizeof (int), offset (reqMinorStart), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNmajorStart, XtCMajorStart, XtRInt, sizeof (int), offset (reqMajorStart), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNminorStep, XtCMinorStep, XtRInt, sizeof (int), offset (reqMinorStep), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNmajorStep, XtCMajorStep, XtRInt, sizeof (int), offset (reqMajorStep), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNstartPad, XtCStartPad, XtRDimension, sizeof (Dimension), offset (reqStartPad), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNendPad, XtCEndPad, XtRDimension, sizeof (Dimension), offset (reqEndPad), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNmajorTickLen, XtCStartPad, XtRDimension, sizeof (Dimension), offset (reqMajorTickLen), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNminorTickLen, XtCMinorTickLen, XtRDimension, sizeof (Dimension), offset (reqMinorTickLen), XtRImmediate, (XtPointer) ThermoUnspecified}, { XtNvertical, XtCVertical, XtRBoolean, sizeof (Boolean), offset (vertical), XtRImmediate, (XtPointer) FALSE}, #undef offset }; double scale_points(ThermoWidget w, double points) { return points * w->ksimple.dpi / 72.0; } static void init_cairo(ThermoWidget w, cairo_t *cr) { cairo_set_font_face(cr, w->thermo.font.font_face); cairo_set_font_size(cr, scale_points(w, w->thermo.font.size)); } static cairo_t * get_cairo(ThermoWidget w) { cairo_t *cr = XkwGetCairo((Widget) w); init_cairo(w, cr); return cr; } static cairo_t * draw_begin(ThermoWidget w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); init_cairo(w, cr); return cr; } static void draw_end(ThermoWidget w, Region region, cairo_t *cr) { XkwDrawEnd((Widget) w, region, cr); } static void getSize (ThermoWidget w, Dimension *widthp, Dimension *heightp) { int size; if (w->thermo.vertical) { size = w->thermo.textWidth; if (w->thermo.majorTickLen > size) size = w->thermo.majorTickLen; if (w->thermo.minorTickLen > size) size = w->thermo.minorTickLen; *widthp = size + w->thermo.thickness; } else { cairo_t *cr = get_cairo(w); cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); cairo_destroy(cr); size = font_extents.height; size += w->thermo.majorTickLen; if (w->thermo.minorTickLen > size) size = w->thermo.minorTickLen; *heightp = size + w->thermo.thickness; } } static int NiceValue (int num, int den) { int v; int l; v = num / den; if (v == 0) return 1; if (v < 5) return v; if (v < 8) return 5; l = 1; while (v > 100) { v /= 10; l++; } if (v < 15) v = 10; else if (v < 37) v = 25; else if (v < 75) v = 50; else v = 100; while (l--) v *= 10; return v; } static void setDefaults (ThermoWidget req, ThermoWidget new) { double max_text_width; char label[30]; cairo_t *cr = get_cairo(new); sprintf(label, "%d", req->thermo.minimum); cairo_text_extents_t text_extents; cairo_text_extents(cr, label, &text_extents); max_text_width = text_extents.width; sprintf(label, "%d", req->thermo.maximum); cairo_text_extents(cr, label, &text_extents); if (text_extents.width > max_text_width) max_text_width = text_extents.width; cairo_font_extents_t font_extents; cairo_font_extents(cr, &font_extents); new->thermo.textWidth = max_text_width; if (req->thermo.reqThickness == ThermoUnspecified) new->thermo.thickness = font_extents.height; else new->thermo.thickness = req->thermo.reqThickness; if (req->thermo.reqMinorStart == ThermoUnspecified) new->thermo.minorStart = req->thermo.minimum; else new->thermo.minorStart = req->thermo.reqMinorStart; if (req->thermo.reqMajorStart == ThermoUnspecified) new->thermo.majorStart = req->thermo.minimum; else new->thermo.majorStart = req->thermo.reqMajorStart; if (req->thermo.reqMajorStep == ThermoUnspecified) new->thermo.majorStep = NiceValue (req->thermo.maximum - req->thermo.majorStart, 10); else new->thermo.majorStep = req->thermo.reqMajorStep; if (req->thermo.reqMinorStep == ThermoUnspecified) new->thermo.minorStep = NiceValue (new->thermo.majorStep, 4); else new->thermo.minorStep = req->thermo.reqMinorStep; if (req->thermo.reqStartPad == ThermoUnspecified) { if (new->thermo.vertical) new->thermo.startPad = 0; else new->thermo.startPad = new->thermo.textWidth / 2.0; } if (req->thermo.reqEndPad == ThermoUnspecified) { if (new->thermo.vertical) new->thermo.endPad = font_extents.height + 2.0; else new->thermo.endPad = new->thermo.textWidth / 2.0; } if (req->thermo.reqMajorTickLen == ThermoUnspecified) new->thermo.majorTickLen = font_extents.height / 2.0; else new->thermo.majorTickLen = req->thermo.reqMajorTickLen; if (req->thermo.reqMinorTickLen == ThermoUnspecified) new->thermo.minorTickLen = new->thermo.majorTickLen / 2.0; else new->thermo.minorTickLen = req->thermo.reqMinorTickLen; } static void ClassInitialize(void) { XkwInitializeWidgetSet(); } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { ThermoWidget req = (ThermoWidget) greq, new = (ThermoWidget) gnew; (void) args; (void) count; setDefaults (req, new); getSize (new, &new->core.width, &new->core.height); } #define AreaPad(w) ((w)->thermo.startPad + (w)->thermo.endPad) #define VArea(w) ((w)->core.height - AreaPad(w)) #define HArea(w) ((w)->core.width - AreaPad(w)) #define VerticalPos(w,v) ((w)->core.height - (w)->thermo.startPad - VArea(w) * (v) / \ ((w)->thermo.maximum - (w)->thermo.minimum)) #define HorizontalPos(w,v) ((w)->thermo.startPad + HArea(w) * (v) / \ ((w)->thermo.maximum - (w)->thermo.minimum)) static void drawMercury (ThermoWidget w, cairo_t *cr, int old, int new) { double x, y, other, width, height; if (w->thermo.vertical) { width = w->thermo.thickness; x = w->core.width - width; other = VerticalPos (w, old); y = VerticalPos (w, new); height = other - y; if (height < 0) { XkwSetSource(cr, &w->ksimple.background); cairo_rectangle(cr, x, other, width, -height); } else { XkwSetSource(cr, &w->thermo.mercuryColor); cairo_rectangle (cr, x, y, width, height); } } else { height = w->thermo.thickness; y = w->core.height - height; x = HorizontalPos (w, old); other = HorizontalPos (w, new); width = other - x; if (width < 0) { XkwSetSource(cr, &w->ksimple.background); cairo_rectangle(cr, other, y, -width, height); } else { XkwSetSource(cr, &w->thermo.mercuryColor); cairo_rectangle(cr, x, y, width, height); } } cairo_fill(cr); } static void drawTick (ThermoWidget w, cairo_t *cr, int v, double len) { double x, y, width, height; if (w->thermo.vertical) { x = w->core.width - w->thermo.thickness - len; width = len; height = len / 10.0; y = VerticalPos (w, v) - height / 2.0; } else { y = w->core.height - w->thermo.thickness - len; height = len; width = len / 10.0; x = HorizontalPos (w, v) - width / 2.0; } XkwSetSource(cr, &w->thermo.tickColor); cairo_rectangle(cr, x, y, width, height); cairo_fill(cr); } static void drawValue (ThermoWidget w, cairo_t *cr, int v) { char label[30]; double width; double x, y; cairo_text_extents_t text_extents; sprintf (label, "%d", v); cairo_text_extents(cr, label, &text_extents); width = text_extents.width; if (w->thermo.vertical) { x = w->core.width - w->thermo.thickness - width; y = VerticalPos (w, v) - 2; } else { y = w->core.height - w->thermo.thickness - w->thermo.majorTickLen - 2; x = HorizontalPos (w, v) - width / 2.0 - text_extents.x_bearing; } cairo_move_to(cr, x, y); cairo_show_text(cr, label); } static void Redisplay (Widget gw, XEvent *event, Region region) { ThermoWidget w = (ThermoWidget) gw; int v; (void) event; cairo_t *cr = draw_begin(w, region); drawMercury (w, cr, w->thermo.minimum, w->thermo.current); for (v = w->thermo.minorStart; v <= w->thermo.maximum; v += w->thermo.minorStep) drawTick (w, cr, v, w->thermo.minorTickLen); for (v = w->thermo.majorStart; v <= w->thermo.maximum; v += w->thermo.majorStep) { drawTick (w, cr, v, w->thermo.majorTickLen); drawValue (w, cr, v); } draw_end(w, region, cr); } static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { ThermoWidget cur = (ThermoWidget) gcur, req = (ThermoWidget) greq, new = (ThermoWidget) gnew; Boolean redraw = FALSE; Dimension width, height; (void) args; (void) count; if (memcmp(&req->thermo.mercuryColor, &cur->thermo.mercuryColor, sizeof (XRenderColor)) != 0) { redraw = TRUE; } if (memcmp(&req->thermo.tickColor, &cur->thermo.tickColor, sizeof (XRenderColor)) != 0) { redraw = TRUE; } if (req->thermo.minimum != cur->thermo.minimum || req->thermo.maximum != cur->thermo.maximum || req->thermo.reqThickness != cur->thermo.reqThickness || req->thermo.reqMinorStart != cur->thermo.reqMinorStart || req->thermo.reqMajorStart != cur->thermo.reqMajorStart || req->thermo.reqMinorStep != cur->thermo.reqMinorStep || req->thermo.reqMajorStep != cur->thermo.reqMajorStep || req->thermo.reqStartPad != cur->thermo.reqStartPad || req->thermo.reqEndPad != cur->thermo.reqEndPad || req->thermo.reqMinorTickLen != cur->thermo.reqMinorTickLen || req->thermo.reqMajorTickLen != cur->thermo.reqMajorTickLen || req->thermo.vertical != cur->thermo.vertical) { setDefaults (req, new); getSize (new, &width, &height); XtMakeResizeRequest (gnew, width, height, &width, &height); redraw = TRUE; } if (!redraw && req->thermo.current != cur->thermo.current) Redisplay(gnew, NULL, NULL); return redraw; } ThermoClassRec thermoClassRec = { { /* core fields */ /* superclass */ (WidgetClass) &ksimpleClassRec, /* class_name */ "Thermo", /* widget_size */ sizeof(ThermoRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ NULL, /* resize */ XtInheritResize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ NULL, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, { /* thermo fields */ /* empty */ 0 } }; WidgetClass thermoWidgetClass = (WidgetClass)&thermoClassRec; kgames-2.2/Xkw/Thermo.h000066400000000000000000000062071416764561500150300ustar00rootroot00000000000000/* $XConsortium: Thermo.h,v 1.5 90/12/19 18:46:00 converse Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #ifndef _Thermo_h #define _Thermo_h /**************************************************************** * * Thermo widget * ****************************************************************/ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 destroyCallback Callback Pointer NULL height Height Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ /* define any special resource names here that are not in */ #define XtNmercuryColor "mercuryColor" #define XtNtextColor "textColor" #define XtNtickColor "tickColor" #define XtNminimum "minimum" #define XtCMinimum "Minimum" #define XtNmaximum "maximum" #define XtCMaximum "Maximum" #define XtNcurrent "current" #define XtCCurrent "Current" #define XtNminorStep "minorStep" #define XtCMinorStep "MinorStep" #define XtNmajorStep "majorStep" #define XtCMajorStep "MajorStep" #define XtNminorStart "minorStart" #define XtCMinorStart "MinorStart" #define XtNmajorStart "majorStart" #define XtCMajorStart "MajorStart" #define XtNstartPad "startPad" #define XtCStartPad "StartPad" #define XtNendPad "endPad" #define XtCEndPad "EndPad" #define XtNminorTickLen "minorTickLen" #define XtCMinorTickLen "MinorTickLen" #define XtNmajorTickLen "majorTickLen" #define XtCMajorTickLen "MajorTickLen" #define XtNvertical "vertical" #define XtCVertical "Vertical" #define ThermoUnspecified (32765) /* declare specific ThermoWidget class and instance datatypes */ typedef struct _ThermoClassRec* ThermoWidgetClass; typedef struct _ThermoRec* ThermoWidget; /* declare the class constant */ extern WidgetClass thermoWidgetClass; #endif /* _Thermo_h */ kgames-2.2/Xkw/ThermoP.h000066400000000000000000000052371416764561500151520ustar00rootroot00000000000000/* $XConsortium: ThermoP.h,v 1.6 91/03/13 20:12:07 rws Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #ifndef _ThermoP_h #define _ThermoP_h #include "Thermo.h" /* include superclass private header file */ #include #include /* define unique representation types not found in */ #define XtRThermoResource "ThermoResource" typedef struct { int empty; } ThermoClassPart; typedef struct _ThermoClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; ThermoClassPart thermo_class; } ThermoClassRec; extern ThermoClassRec thermoClassRec; typedef struct { /* resources */ XkwFont font; XRenderColor mercuryColor; XRenderColor tickColor; int current; int minimum; int maximum; int reqThickness; int reqMinorStart; int reqMajorStart; int reqMinorStep; int reqMajorStep; Dimension reqStartPad; Dimension reqEndPad; Dimension reqMajorTickLen; Dimension reqMinorTickLen; Boolean vertical; /* private state */ double thickness; double minorStart; double majorStart; double minorStep; double majorStep; double startPad; double endPad; double majorTickLen; double minorTickLen; double textWidth; } ThermoPart; typedef struct _ThermoRec { CorePart core; SimplePart simple; KSimplePart ksimple; ThermoPart thermo; } ThermoRec; #endif /* _ThermoP_h */ kgames-2.2/Xkw/Xkw.h000066400000000000000000000114331416764561500143400ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _Xkw_h #define _Xkw_h #include #include #include #include #include #include #include //#include extern const char _XtRRenderColor[]; #define XtRRenderColor ((char *)_XtRRenderColor) extern const char _XtRXkwFont[]; #define XtRXkwFont ((char *)_XtRXkwFont) extern const char _XtRDpi[]; #define XtRDpi ((char *)_XtRDpi) extern const char _XtRDouble[]; #define XtRDouble ((char *)_XtRDouble) extern const char _XtNdpi[]; #define XtNdpi ((char *)_XtNdpi) extern const char _XtCDpi[]; #define XtCDpi ((char *)_XtCDpi) extern const char _XtNbackgroundColor[]; #define XtNbackgroundColor ((char *)_XtNbackgroundColor) extern const char _XtNforegroundColor[]; #define XtNforegroundColor ((char *)_XtNforegroundColor) typedef struct { cairo_font_face_t *font_face; double size; } XkwFont; typedef struct { int *x; int *y; int *x_root; int *y_root; Window *window; } XkwEventCoordPointers; #ifndef XtX #define XtX(w) (((RectObj)w)->rectangle.x) #endif #ifndef XtY #define XtY(w) (((RectObj)w)->rectangle.y) #endif #ifndef XtWidth #define XtWidth(w) (((RectObj)w)->rectangle.width) #endif #ifndef XtHeight #define XtHeight(w) (((RectObj)w)->rectangle.height) #endif #ifndef XtBorderWidth #define XtBorderWidth(w) (((RectObj)w)->rectangle.border_width) #endif /* * Ok, Xt is surprisingly broken. Values that *can* fit in the arg * value are assumed to be there, even if they are passed by * address. We work around this by creating a macro which always uses * an address and then figuring out how to pass the resulting value * based on the size */ #define XkwSetArg(arg, n, d) do { \ (arg).name = (n); \ if (sizeof(*(d)) <= sizeof(XtArgVal)) \ memcpy(&(arg).value, (d), sizeof(*d)); \ else \ (arg).value = (XtArgVal) (d); \ } while(0) _XFUNCPROTOBEGIN static inline Boolean XkwColorEqual(XRenderColor *a, XRenderColor *b) { return memcmp(a, b, sizeof (XRenderColor)) == 0; } Widget XkwInitialize(const char *class, XrmOptionDescRec *options, Cardinal num_options, int *argc, _XtString *argv, Boolean input, char const * const *fallback_resources); void XkwInitializeWidgetSet(void); cairo_surface_t * XkwGetSurface(Widget w); cairo_t * XkwGetCairo(Widget w); void XkwSetSource(cairo_t *cr, XRenderColor *color); void XkwSetSourceInterp(cairo_t *cr, XRenderColor *a, XRenderColor *b); void XkwDialogAddButton(Widget dialog, _Xconst char* name, XtCallbackProc function, XtPointer param); RsvgHandle * XkwRsvgCreate(const char *str); void XkwRsvgDestroy(RsvgHandle *handle); double XkwRsvgAspect(RsvgHandle *rsvg); void XkwRsvgDraw(cairo_t *cr, int surface_width, int surface_height, RsvgHandle *rsvg); cairo_t * XkwDrawBegin(Widget gw, Region region); void XkwDrawEnd(Widget gw, Region region, cairo_t *cr); void XkwDrawRoundedRect(cairo_t *cr, double width, double height, double radius); void XkwDrawOval(cairo_t *cr, double width, double height); void XkwTranslateCoordsPosition(Widget to, Widget from, Position *x, Position *y); void XkwTranslateCoordsInt(Widget to, Widget from, int *x, int *y); void XkwGetEventCoordPointers(XEvent *e, XkwEventCoordPointers *cp); void XkwTranslateEvent(Widget to, Widget from, XEvent *e); Bool XkwGetEventCoords(XEvent *e, Position *x, Position *y); Bool XkwForwardEvent(Widget to, Widget from, XEvent *e); void XkwSetIcon(Widget toplevel, const char *svg); void XkwSetCardIcon(Widget toplevel); _XFUNCPROTOEND #endif /* _Xkw_h */ kgames-2.2/Xkw/XkwInit.c000066400000000000000000000273411416764561500151640ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include const char _XtRRenderColor[] = "RenderColor"; const char _XtRXkwFont[] = "XkwFont"; const char _XtRDpi[] = "Dpi"; const char _XtRDouble[] = "Double"; const char _XtNdpi[] = "dpi"; const char _XtCDpi[] = "Dpi"; const char _XtNbackgroundColor[] = "backgroundColor"; const char _XtNforegroundColor[] = "foregroundColor"; #define donestr(type, value, tstr) \ { \ if (toVal->addr != NULL) { \ if (toVal->size < sizeof(type)) { \ toVal->size = sizeof(type); \ XtDisplayStringConversionWarning(dpy, \ (char*) fromVal->addr, tstr); \ return False; \ } \ *(type*)(toVal->addr) = (value); \ } \ else { \ static type static_val; \ static_val = (value); \ toVal->addr = (XPointer)&static_val; \ } \ toVal->size = sizeof(type); \ return True; \ } static Boolean XkwCvtStringToRenderColor(Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *fromVal, XrmValue *toVal, XtPointer *converter_data) { char *spec; XRenderColor renderColor; (void) args; (void) num_args; (void) converter_data; spec = (char *) fromVal->addr; if (strcasecmp (spec, XtDefaultForeground) == 0) { renderColor.red = 0; renderColor.green = 0; renderColor.blue = 0; renderColor.alpha = 0xffff; } else if (strcasecmp (spec, XtDefaultBackground) == 0) { renderColor.red = 0xffff; renderColor.green = 0xffff; renderColor.blue = 0xffff; renderColor.alpha = 0xffff; } else if (!XRenderParseColor (dpy, spec, &renderColor)) return False; donestr (XRenderColor, renderColor, XtRRenderColor); } static Boolean XkwCvtStringToXkwFont(Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *fromVal, XrmValue *toVal, XtPointer *converter_data) { char *string_name = (char *) fromVal->addr; FcPattern *pat, *match; FcResult result; XkwFont xkwFont; (void) args; (void) num_args; (void) converter_data; if (strncmp(string_name, "fixed", 5) == 0) string_name = "monospace-12"; if (*string_name == '-') { pat = XftXlfdParse(string_name, False, False); } else { pat = FcNameParse ((FcChar8 *) string_name); } if (!pat) return False; FcConfigSubstitute (0, pat, FcMatchPattern); FcDefaultSubstitute (pat); match = FcFontMatch (0, pat, &result); FcPatternDestroy (pat); if (!match) return False; FcPatternGetDouble (match, FC_SIZE, 0, &xkwFont.size); xkwFont.font_face = cairo_ft_font_face_create_for_pattern (match); FcPatternDestroy (match); if (!xkwFont.font_face) return False; donestr (XkwFont, xkwFont, XtRXkwFont); } static void XkwFreeXkwFont(XtAppContext app_context, XrmValue *val, XtPointer converter_data, XrmValue *args, Cardinal *num_args) { XkwFont *xkwFont = (XkwFont *) val; (void) app_context; (void) args; (void) num_args; (void) converter_data; cairo_font_face_destroy(xkwFont->font_face); } static Boolean xkw_str_to_double(char *string, double *result) { char *end; double d; if (!string) return False; d = strtod(string, &end); if (end == string) return False; *result = d; return True; } static Boolean XkwCvtStringToDpi(Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *fromVal, XrmValue *toVal, XtPointer *converter_data) { double dpi; (void) args; (void) num_args; (void) converter_data; if (!xkw_str_to_double((char *) fromVal->addr, &dpi)) { if (!xkw_str_to_double(XGetDefault(dpy, "Xft", "dpi"), &dpi)) { int screen = DefaultScreen (dpy); int height_pix = DisplayHeight(dpy, screen); int height_mm = DisplayHeightMM(dpy, screen); dpi = (double) height_pix / ((double) height_mm / 25.4); } } donestr (double, dpi, XtRDpi); } static Boolean XkwCvtStringToDouble(Display *dpy, XrmValue *args, Cardinal *num_args, XrmValue *fromVal, XrmValue *toVal, XtPointer *converter_data) { double d = NAN; (void) args; (void) num_args; (void) converter_data; (void) xkw_str_to_double((char *) fromVal->addr, &d); donestr (double, d, XtRDouble); } cairo_surface_t * XkwGetSurface(Widget w) { return cairo_xlib_surface_create(XtDisplay(w), XtWindow(w), XtScreen(w)->root_visual, XtWidth(w), XtHeight(w)); } cairo_t * XkwGetCairo(Widget w) { Widget real = w; while (!XtIsWidget(real)) real = XtParent(real); cairo_surface_t *s = XkwGetSurface(real); cairo_t *cr = cairo_create(s); cairo_translate(cr, XtX(w) - XtX(real), XtY(w) - XtY(real)); cairo_surface_destroy (s); return cr; } static XRectangle XkwDrawRect(Widget gw, Region region) { int x1 = 0; int x2 = XtWidth(gw); int y1 = 0; int y2 = XtHeight(gw); if (region) { int cx1 = region->extents.x1; int cx2 = region->extents.x2; int cy1 = region->extents.y1; int cy2 = region->extents.y2; if (cx1 > x1) x1 = cx1; if (cy1 > y1) y1 = cy1; if (cx2 < x2) x2 = cx2; if (cy2 < y2) y2 = cy2; if (x2 < x1) x1 = x2 = 0; if (y2 < y1) y1 = y2 = 0; } XRectangle ret = { .x = x1, .y = y1, .width = x2 - x1, .height = y2 - y1 }; return ret; } static cairo_surface_t * get_widget_surface(Widget gw, Boolean *temp, XRenderColor **fg, XRenderColor **bg) { if (XtIsSubclass(gw, ksimpleWidgetClass)) { KSimpleWidget w = (KSimpleWidget) gw; if (w->ksimple.surface && (w->ksimple.surface_width != gw->core.width || w->ksimple.surface_height != gw->core.height)) { cairo_surface_destroy(w->ksimple.surface); w->ksimple.surface = NULL; } if (!w->ksimple.surface) { w->ksimple.surface = XkwGetSurface(gw); w->ksimple.surface_width = gw->core.width; w->ksimple.surface_height = gw->core.height; } if (fg) *fg = &w->ksimple.foreground; if (bg) *bg = &w->ksimple.background; *temp = False; return w->ksimple.surface; } else if (XtIsSubclass(gw, ksimpleMenuWidgetClass)) { KSimpleMenuWidget w = (KSimpleMenuWidget) gw; if (w->ksimple_menu.surface && (w->ksimple_menu.surface_width != gw->core.width || w->ksimple_menu.surface_height != gw->core.height)) { cairo_surface_destroy(w->ksimple_menu.surface); w->ksimple_menu.surface = NULL; } if (!w->ksimple_menu.surface) { w->ksimple_menu.surface = XkwGetSurface(gw); w->ksimple_menu.surface_width = gw->core.width; w->ksimple_menu.surface_height = gw->core.height; } if (fg) *fg = &w->ksimple_menu.foreground; if (bg) *bg = &w->ksimple_menu.background; *temp = False; return w->ksimple_menu.surface; } else { *temp = True; return XkwGetSurface(gw); } } cairo_t * XkwDrawBegin(Widget gw, Region region) { Widget greal = gw; while (!XtIsWidget(greal)) greal = XtParent(greal); XRenderColor *fg = NULL; XRenderColor *bg = NULL; Boolean surface_created = False; cairo_surface_t *surface = get_widget_surface(greal, &surface_created, &fg, &bg); XRectangle rect = XkwDrawRect(gw, region); cairo_surface_t *pix = cairo_surface_create_similar(surface, CAIRO_CONTENT_COLOR, rect.width, rect.height); if (surface_created) cairo_surface_destroy(surface); cairo_t *cr = cairo_create(pix); cairo_translate(cr, -rect.x, -rect.y); cairo_surface_destroy(pix); if (bg) { XkwSetSource(cr, bg); cairo_paint(cr); } if (fg) XkwSetSource(cr, fg); return cr; } void XkwDrawEnd(Widget gw, Region region, cairo_t *cr) { Widget greal = gw; while (!XtIsWidget(greal)) greal = XtParent(greal); Boolean surface_created = False; cairo_surface_t *surface = get_widget_surface(greal, &surface_created, NULL, NULL); cairo_t *dest = cairo_create(surface); if (surface_created) cairo_surface_destroy(surface); XRectangle rect = XkwDrawRect(gw, region); double x = rect.x; double y = rect.y; if (gw != greal) { x += XtX(gw); y += XtY(gw); } cairo_set_source_surface(dest, cairo_get_target(cr), x, y); if (region) { long i; BOX *b = region->rects; for (i = 0; i < region->numRects; i++) { cairo_rectangle(dest, b->x1, b->y1, b->x2 - b->x1, b->y2 - b->y1); b++; } cairo_fill(dest); } else { cairo_paint(dest); } cairo_destroy(cr); cairo_destroy(dest); } void XkwSetSource(cairo_t *cr, XRenderColor *color) { cairo_set_source_rgba(cr, color->red / 65535.0, color->green / 65535.0, color->blue / 65535.0, color->alpha / 65535.0); } void XkwSetSourceInterp(cairo_t *cr, XRenderColor *a, XRenderColor *b) { cairo_set_source_rgba(cr, a->red / (2.0 * 65535.0) + b->red / (2.0 * 65535.0), a->green / (2.0 * 65535.0) + b->green / (2.0 * 65535.0), a->blue / (2.0 * 65535.0) + b->blue / (2.0 * 65535.0), a->alpha / (2.0 * 65535.0) + b->alpha / (2.0 * 65535.0)); } void XkwInitializeWidgetSet(void) { static Boolean init_done; if (!init_done) { init_done = True; XtSetTypeConverter(XtRString, XtRRenderColor, XkwCvtStringToRenderColor, NULL, 0, XtCacheByDisplay, NULL); XtSetTypeConverter(XtRString, XtRXkwFont, XkwCvtStringToXkwFont, NULL, 0, XtCacheAll, XkwFreeXkwFont); XtSetTypeConverter(XtRString, XtRDpi, XkwCvtStringToDpi, NULL, 0, XtCacheByDisplay, NULL); XtSetTypeConverter(XtRString, XtRDouble, XkwCvtStringToDouble, NULL, 0, XtCacheAll, NULL); XtAddConverter(XtRString, XtRJustify, XmuCvtStringToJustify, NULL, 0); XtSetTypeConverter(XtRJustify, XtRString, XmuCvtJustifyToString, NULL, 0, XtCacheNone, NULL); XtAddConverter(XtRString, XtROrientation, XmuCvtStringToOrientation, NULL, 0); } } Widget XkwInitialize(const char *class, XrmOptionDescRec *options, Cardinal num_options, int *argc, _XtString *argv, Boolean input, char const * const *fallback_resources) { XtAppContext app_con; Widget toplevel; Arg args[1]; Cardinal num_args = 0; if (input) { XtSetArg(args[0], XtNinput, True); num_args = 1; } toplevel = XtAppInitialize (&app_con, class, options, num_options, argc, argv, (char **) fallback_resources, args, num_args); _XtGetProcessContext()->defaultAppContext = app_con; return toplevel; } kgames-2.2/Xkw/bob000066400000000000000000000073551416764561500141130ustar00rootroot00000000000000#define bob_width 61 #define bob_height 75 static char bob_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xfb, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xcf, 0x9f, 0xd1, 0x03, 0x00, 0x00, 0xf0, 0x7f, 0x8c, 0x33, 0x91, 0x07, 0x00, 0x00, 0xf8, 0xa7, 0x18, 0x27, 0xb1, 0x06, 0x00, 0x00, 0xfc, 0x47, 0x31, 0x4e, 0xa6, 0x0e, 0x00, 0x00, 0xfe, 0x4f, 0x21, 0x4c, 0xae, 0x3d, 0x00, 0x00, 0xff, 0xdf, 0x23, 0x8d, 0xbe, 0x7d, 0x00, 0x80, 0xff, 0xff, 0x67, 0xbd, 0xfe, 0xff, 0x01, 0x80, 0xff, 0xff, 0x7f, 0xbf, 0xff, 0xff, 0x03, 0xc0, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xf8, 0x07, 0xc0, 0xff, 0xff, 0xff, 0xbf, 0x3f, 0xf8, 0x07, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf8, 0x0f, 0xc0, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xf8, 0x0f, 0xe0, 0x7f, 0x00, 0xf8, 0x07, 0x00, 0xf0, 0x0f, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe7, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x07, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x07, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x78, 0xf6, 0x07, 0xa0, 0xbf, 0xff, 0x00, 0x00, 0xff, 0xf7, 0x07, 0x70, 0x9f, 0xff, 0x01, 0x80, 0xff, 0xef, 0x07, 0xf0, 0x1c, 0x80, 0x03, 0xe0, 0x01, 0xef, 0x07, 0xf0, 0x1f, 0xbe, 0x07, 0xf0, 0x3f, 0xee, 0x07, 0xe0, 0x9d, 0x83, 0x1f, 0xf8, 0xe1, 0xdc, 0x07, 0xe0, 0xc1, 0x7f, 0x1f, 0xfc, 0xff, 0xc8, 0x07, 0xe0, 0xc1, 0x69, 0x1e, 0x7e, 0xca, 0xc0, 0x03, 0xe0, 0x81, 0xb8, 0x1f, 0xc0, 0x0e, 0xc0, 0x03, 0xe0, 0x01, 0xc0, 0x1b, 0xc0, 0xcf, 0xc1, 0x03, 0xc0, 0x03, 0xf7, 0x11, 0x00, 0x7f, 0xc0, 0x03, 0xc0, 0x03, 0x7c, 0x18, 0x00, 0x1c, 0xc0, 0x02, 0xc0, 0x02, 0x30, 0x08, 0x00, 0x00, 0x40, 0x03, 0x40, 0x03, 0x00, 0x08, 0x00, 0x00, 0x40, 0x02, 0x40, 0x13, 0x00, 0x0c, 0x00, 0x00, 0x60, 0x02, 0x40, 0x12, 0x00, 0x0e, 0x00, 0x00, 0xc0, 0x03, 0x80, 0x33, 0x80, 0x0e, 0x00, 0x00, 0xa8, 0x01, 0x00, 0x33, 0x40, 0x0f, 0xa0, 0x03, 0x2c, 0x00, 0x00, 0x74, 0x30, 0x0f, 0x38, 0x07, 0x2e, 0x00, 0x00, 0x74, 0x98, 0x1f, 0x1e, 0x1e, 0x2f, 0x00, 0x00, 0xfc, 0x8f, 0xff, 0x0f, 0xfc, 0x2f, 0x00, 0x00, 0xf8, 0xe3, 0xff, 0x03, 0xf8, 0x2f, 0x00, 0x00, 0xf8, 0xfd, 0xff, 0x81, 0xff, 0x3f, 0x00, 0x00, 0xb8, 0xf9, 0x1f, 0xf8, 0x0f, 0x1e, 0x00, 0x00, 0x30, 0xf1, 0xf0, 0x0f, 0x03, 0x0e, 0x00, 0x00, 0x30, 0xf1, 0x01, 0x80, 0x01, 0x0f, 0x00, 0x00, 0x20, 0xf1, 0xf7, 0xff, 0x00, 0x07, 0x00, 0x00, 0x60, 0xe3, 0x01, 0x60, 0x80, 0x07, 0x00, 0x00, 0x60, 0xc3, 0xef, 0x3f, 0x80, 0x03, 0x00, 0x00, 0x40, 0xc2, 0xff, 0x0f, 0xc0, 0x03, 0x00, 0x00, 0xc0, 0xe6, 0x1f, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80, 0xf4, 0xfe, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x80, 0x79, 0xfe, 0x1f, 0xe0, 0x00, 0x00, 0xc0, 0x01, 0x3d, 0x3e, 0x00, 0x70, 0x00, 0x00, 0x30, 0x06, 0x3e, 0x0f, 0x00, 0x38, 0x00, 0x00, 0xc8, 0x8c, 0x1f, 0x07, 0x00, 0x38, 0x00, 0x00, 0xf4, 0xcc, 0x8f, 0x07, 0x00, 0x1c, 0x00, 0x00, 0x72, 0xee, 0xf7, 0x07, 0x00, 0x0e, 0x00, 0x00, 0x02, 0xff, 0xe3, 0x07, 0x00, 0x07, 0x00, 0x00, 0x32, 0xfe, 0xc1, 0xff, 0x8f, 0x03, 0x00, 0x00, 0x3e, 0xfe, 0x80, 0xff, 0xff, 0x01, 0x00, 0x00, 0x7e, 0x7c, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x7c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/Xkw/cards.bm000066400000000000000000002773711416764561500150510ustar00rootroot00000000000000/* * Spider * * (c) Copyright 1989, Donald R. Woods and Sun Microsystems, Inc. * (c) Copyright 1990, David Lemke and Network Computing Devices Inc. * * See copyright.h for the terms of the copyright. * * @(#)cards.bm 2.1 90/04/25 * */ static char card_bits[52][300] = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xa1, 0x00, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x19, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xc0, 0xe3, 0x01, 0x80, 0x01, 0xe0, 0xf7, 0x03, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8d, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0xc0, 0x98, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x36, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x36, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x36, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x36, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x36, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x6c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x6c, 0x08, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0xd8, 0x10, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x6c, 0x1c, 0x80, 0x01, 0x20, 0xfe, 0x08, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0xd8, 0x38, 0x36, 0x80, 0x01, 0xfc, 0x11, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x6c, 0x1c, 0x80, 0x01, 0x20, 0xfe, 0x08, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0xd8, 0x38, 0x36, 0x80, 0x01, 0xfc, 0x11, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0xd8, 0x00, 0x36, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x6c, 0x1c, 0x80, 0x01, 0x20, 0xfe, 0x08, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0xd8, 0x38, 0x36, 0x80, 0x01, 0xfc, 0x11, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x60, 0x14, 0x03, 0x80, 0x01, 0xa0, 0xa2, 0x02, 0x80, 0x01, 0x20, 0x41, 0x02, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0xa0, 0xe3, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x1c, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x40, 0x00, 0x01, 0x80, 0x01, 0x40, 0x3e, 0x01, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x00, 0x41, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8d, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x49, 0x01, 0x00, 0x00, 0x80, 0x89, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0xb0, 0xe3, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x1c, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x70, 0x22, 0x07, 0x80, 0x01, 0x70, 0x3e, 0x07, 0x80, 0x01, 0xf8, 0x80, 0x0f, 0x80, 0x01, 0xfe, 0x80, 0x3f, 0x80, 0x01, 0x3c, 0x63, 0x1e, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8d, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x94, 0x01, 0x00, 0x00, 0x80, 0x98, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x90, 0xe3, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x1c, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x20, 0x3e, 0x02, 0x80, 0x01, 0x60, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x80, 0x01, 0x80, 0x01, 0xc0, 0xe3, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x80, 0x8d, 0x01, 0x00, 0x3e, 0xc0, 0x9f, 0x01, 0x00, 0x1c, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xa1, 0x00, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x19, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0xc0, 0x98, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x60, 0x14, 0x03, 0x80, 0x01, 0xa0, 0xa2, 0x02, 0x80, 0x01, 0x20, 0x41, 0x02, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0xa0, 0xe3, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x1c, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x40, 0x00, 0x01, 0x80, 0x01, 0x40, 0x3e, 0x01, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x00, 0x41, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x49, 0x01, 0x00, 0x00, 0x80, 0x89, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0xb0, 0xe3, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x1c, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x70, 0x22, 0x07, 0x80, 0x01, 0x70, 0x3e, 0x07, 0x80, 0x01, 0xf8, 0x80, 0x0f, 0x80, 0x01, 0xfe, 0x80, 0x3f, 0x80, 0x01, 0x3c, 0x63, 0x1e, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x94, 0x01, 0x00, 0x00, 0x80, 0x98, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x90, 0xe3, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x1c, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x20, 0x3e, 0x02, 0x80, 0x01, 0x60, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x80, 0x01, 0x80, 0x01, 0xc0, 0xe3, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x82, 0x01, 0x00, 0x3e, 0x00, 0x87, 0x01, 0x00, 0x1c, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xa1, 0x00, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x19, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x80, 0xdd, 0x00, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0x80, 0xdd, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0xc0, 0x98, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x38, 0x1c, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x60, 0x14, 0x03, 0x80, 0x01, 0xa0, 0xa2, 0x02, 0x80, 0x01, 0x20, 0x41, 0x02, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0xa0, 0xe3, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x1c, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x40, 0x00, 0x01, 0x80, 0x01, 0x40, 0x3e, 0x01, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x00, 0x41, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x49, 0x01, 0x00, 0x00, 0x80, 0x89, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0xb0, 0xe3, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x1c, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x70, 0x22, 0x07, 0x80, 0x01, 0x70, 0x3e, 0x07, 0x80, 0x01, 0xf8, 0x80, 0x0f, 0x80, 0x01, 0xfe, 0x80, 0x3f, 0x80, 0x01, 0x3c, 0x63, 0x1e, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x94, 0x01, 0x00, 0x00, 0x80, 0x98, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0xe1, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x90, 0xe3, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x1c, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x20, 0x3e, 0x02, 0x80, 0x01, 0x60, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x80, 0x01, 0x80, 0x01, 0xc0, 0xe3, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x82, 0x01, 0x00, 0x3e, 0x00, 0x87, 0x01, 0x00, 0x1c, 0x80, 0x8a, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xa1, 0x00, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0x11, 0x01, 0x00, 0x00, 0x80, 0x19, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0xc0, 0xff, 0x01, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0xe0, 0xeb, 0x03, 0x80, 0x01, 0xc0, 0xc9, 0x01, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0xc0, 0x98, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x2a, 0x00, 0x80, 0x01, 0x00, 0x08, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x51, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x00, 0x10, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x00, 0x80, 0x79, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf9, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x21, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x00, 0x38, 0x00, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0x54, 0x00, 0x80, 0x01, 0x20, 0x10, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x10, 0x2a, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x20, 0x54, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x9e, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0x29, 0x01, 0x00, 0x00, 0x80, 0xc9, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x10, 0x2a, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x20, 0x54, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x70, 0x00, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x10, 0x2a, 0x80, 0x01, 0x20, 0x38, 0x08, 0x80, 0x01, 0x00, 0x7c, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x00, 0xfe, 0x00, 0x80, 0x01, 0x20, 0x54, 0x08, 0x80, 0x01, 0x70, 0x10, 0x1c, 0x80, 0x01, 0xf8, 0x00, 0x3e, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xfc, 0x01, 0x7f, 0x80, 0x01, 0xa8, 0x00, 0x2a, 0x80, 0x01, 0x20, 0x00, 0x08, 0x80, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x92, 0x01, 0x00, 0x00, 0x80, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x01, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x81, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x71, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x01, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x60, 0x14, 0x03, 0x80, 0x01, 0xa0, 0xa2, 0x02, 0x80, 0x01, 0x20, 0x41, 0x02, 0x80, 0x01, 0xe0, 0xff, 0x03, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0xa0, 0xe3, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x08, 0x02, 0x80, 0x01, 0x20, 0x1c, 0x02, 0x80, 0x01, 0x20, 0x00, 0x02, 0x80, 0x01, 0x40, 0x00, 0x01, 0x80, 0x01, 0x40, 0x3e, 0x01, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x80, 0x80, 0x00, 0x80, 0x01, 0x00, 0x41, 0x00, 0x80, 0x01, 0x00, 0x3e, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x9c, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x80, 0x88, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x09, 0x01, 0x00, 0x00, 0x80, 0x49, 0x01, 0x00, 0x00, 0x80, 0x89, 0x01, 0x00, 0x00, 0x80, 0xf1, 0x00, 0x00, 0x00, 0x80, 0x01, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x21, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0xb0, 0xe3, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x08, 0x06, 0x80, 0x01, 0x30, 0x1c, 0x06, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x70, 0x22, 0x07, 0x80, 0x01, 0x70, 0x3e, 0x07, 0x80, 0x01, 0xf8, 0x80, 0x0f, 0x80, 0x01, 0xfe, 0x80, 0x3f, 0x80, 0x01, 0x3c, 0x63, 0x1e, 0x80, 0x01, 0x00, 0x1c, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x87, 0x01, 0x00, 0x00, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x90, 0x01, 0x00, 0x00, 0x80, 0x94, 0x01, 0x00, 0x00, 0x80, 0x98, 0x01, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x19, 0x00, 0x00, 0x00, 0x80, 0x29, 0x00, 0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x00, 0x80, 0x89, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x41, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x00, 0x00, 0x00, 0x80, 0xf1, 0x01, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0xf9, 0x03, 0x00, 0x00, 0x80, 0x51, 0x21, 0x22, 0x02, 0x80, 0x41, 0x20, 0x22, 0x02, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x50, 0x55, 0x05, 0x80, 0x01, 0x90, 0x88, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0xf0, 0xff, 0x07, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x90, 0xe3, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x08, 0x04, 0x80, 0x01, 0x10, 0x1c, 0x04, 0x80, 0x01, 0x10, 0x00, 0x04, 0x80, 0x01, 0x30, 0x00, 0x06, 0x80, 0x01, 0x20, 0x3e, 0x02, 0x80, 0x01, 0x60, 0x00, 0x03, 0x80, 0x01, 0xc0, 0x80, 0x01, 0x80, 0x01, 0xc0, 0xe3, 0x01, 0x80, 0x01, 0x80, 0xff, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x80, 0x01, 0x00, 0x7f, 0x00, 0x82, 0x01, 0x00, 0x3e, 0x00, 0x87, 0x01, 0x00, 0x1c, 0x80, 0x8f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0xc0, 0x9f, 0x01, 0x00, 0x00, 0x80, 0x8a, 0x01, 0x00, 0x00, 0x00, 0x82, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x85, 0x01, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff }}; kgames-2.2/Xkw/cards/000077500000000000000000000000001416764561500145105ustar00rootroot00000000000000kgames-2.2/Xkw/cards/1B.svg000066400000000000000000000010311416764561500154660ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/1J.svg000066400000000000000000000065361416764561500155150ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/2C.svg000066400000000000000000000025751416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/2D.svg000066400000000000000000000023761416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/2H.svg000066400000000000000000000025041416764561500155030ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/2S.svg000066400000000000000000000025631416764561500155230ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/3C.svg000066400000000000000000000027241416764561500155030ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/3D.svg000066400000000000000000000025251416764561500155030ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/3H.svg000066400000000000000000000026331416764561500155070ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/3S.svg000066400000000000000000000027121416764561500155200ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/4C.svg000066400000000000000000000027261416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/4D.svg000066400000000000000000000025271416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/4H.svg000066400000000000000000000026351416764561500155120ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/4S.svg000066400000000000000000000027141416764561500155230ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/5C.svg000066400000000000000000000031311416764561500154760ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/5D.svg000066400000000000000000000027321416764561500155050ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/5H.svg000066400000000000000000000030401416764561500155020ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/5S.svg000066400000000000000000000031171416764561500155220ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/6C.svg000066400000000000000000000032151416764561500155020ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/6D.svg000066400000000000000000000030161416764561500155020ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/6H.svg000066400000000000000000000031241416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/6S.svg000066400000000000000000000032031416764561500155170ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/7C.svg000066400000000000000000000032101416764561500154760ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/7D.svg000066400000000000000000000030111416764561500154760ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/7H.svg000066400000000000000000000031171416764561500155110ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/7S.svg000066400000000000000000000031761416764561500155310ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/8C.svg000066400000000000000000000033061416764561500155050ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/8D.svg000066400000000000000000000031071416764561500155050ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/8H.svg000066400000000000000000000032151416764561500155110ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/8S.svg000066400000000000000000000032741416764561500155310ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/9C.svg000066400000000000000000000035221416764561500155060ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/9D.svg000066400000000000000000000033211416764561500155040ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/9H.svg000066400000000000000000000034271416764561500155170ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/9S.svg000066400000000000000000000035061416764561500155300ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/AC.svg000066400000000000000000000024321416764561500155150ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/AD.svg000066400000000000000000000022331416764561500155150ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/AH.svg000066400000000000000000000023411416764561500155210ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/AS.svg000066400000000000000000000025711416764561500155410ustar00rootroot00000000000000 kgameskgames-2.2/Xkw/cards/JC.svg000066400000000000000000001106201416764561500155250ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/JD.svg000066400000000000000000000770571416764561500155460ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/JH.svg000066400000000000000000001132011416764561500155300ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/JS.svg000066400000000000000000001243511416764561500155530ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/KC.svg000066400000000000000000001114611416764561500155320ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/KD.svg000066400000000000000000001020661416764561500155340ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/KH.svg000066400000000000000000001433131416764561500155400ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/KS.svg000066400000000000000000001733201416764561500155540ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/QC.svg000066400000000000000000001223461416764561500155440ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/QD.svg000066400000000000000000001242351416764561500155440ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/QH.svg000066400000000000000000001347661416764561500155620ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/QS.svg000066400000000000000000001134151416764561500155610ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/README000066400000000000000000000121021416764561500153640ustar00rootroot00000000000000These cards were downloaded from https://www.me.uk/cards and are licensed under the CC0 Public Domain License: 1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following: i. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work; ii. moral rights retained by the original author(s) and/or performer(s); iii. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work; iv. rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below; v. rights protecting the extraction, dissemination, use and reuse of data in a Work; vi. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and vii. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof. 2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose. 3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose. 4. Limitations and Disclaimers. a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document. b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law. c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work. d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. kgames-2.2/Xkw/cards/TC.svg000066400000000000000000000035601416764561500155430ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/TD.svg000066400000000000000000000033611416764561500155430ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/TH.svg000066400000000000000000000034671416764561500155560ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/TS.svg000066400000000000000000000035461416764561500155670ustar00rootroot00000000000000 kgames-2.2/Xkw/cards/kgames.svg000066400000000000000000000047741416764561500165140ustar00rootroot00000000000000 kgames-2.2/Xkw/face.bm000066400000000000000000001243001416764561500146320ustar00rootroot00000000000000/* * Spider * * (c) Copyright 1989, Donald R. Woods and Sun Microsystems, Inc. * (c) Copyright 1990, David Lemke and Network Computing Devices Inc. * * See copyright.h for the terms of the copyright. * * @(#)face.bm 2.1 90/04/25 * */ #define king_c_width 47 #define king_c_height 92 #define king_c_x_hot -1 #define king_c_y_hot -1 static char king_c_bits[] = { 0x00, 0xb0, 0x20, 0x08, 0x82, 0x06, 0x80, 0xe3, 0x20, 0x08, 0x82, 0x03, 0xc0, 0xc7, 0xdb, 0xb6, 0xed, 0x01, 0xe0, 0x8f, 0x21, 0x08, 0xc2, 0x00, 0xe0, 0x0f, 0xff, 0xff, 0x7f, 0x00, 0xe0, 0x0f, 0x56, 0x55, 0x35, 0x00, 0xc0, 0x07, 0xac, 0xaa, 0x1a, 0x00, 0xb8, 0x3b, 0xfc, 0xff, 0x0f, 0x00, 0xfc, 0x7f, 0xfc, 0xff, 0x0f, 0x00, 0xfe, 0xff, 0x04, 0xa0, 0x0a, 0x08, 0xfe, 0xff, 0x3c, 0xae, 0x0a, 0x1c, 0xfe, 0xff, 0x74, 0xa6, 0x0a, 0x3e, 0xfc, 0x7f, 0x7c, 0xbe, 0x0a, 0x3a, 0x38, 0x39, 0x24, 0xa0, 0x0a, 0x2a, 0x00, 0x01, 0x24, 0xa0, 0x0a, 0x3a, 0x80, 0x03, 0xe4, 0xa1, 0x0a, 0x2a, 0x80, 0x03, 0x44, 0xa0, 0x0a, 0x3a, 0xc0, 0x07, 0xb4, 0xa1, 0x3a, 0x2a, 0x00, 0x00, 0x47, 0xa0, 0x2e, 0x3a, 0x00, 0x80, 0xe4, 0xb8, 0x2b, 0x2a, 0x00, 0x80, 0x06, 0xa7, 0x3a, 0x3a, 0x00, 0xe0, 0xe0, 0xac, 0x1e, 0x2a, 0x00, 0xf8, 0xf1, 0x21, 0x32, 0x3a, 0x00, 0xfe, 0x9f, 0xff, 0x6b, 0x2a, 0x80, 0xff, 0x3f, 0x22, 0xe2, 0x3a, 0xe0, 0xff, 0xbf, 0x88, 0xf8, 0x2b, 0xf8, 0xdf, 0x7f, 0x22, 0xbe, 0x3b, 0xfe, 0xbf, 0xfe, 0x88, 0xcf, 0x2b, 0xff, 0xf7, 0xf5, 0xe3, 0x63, 0x3a, 0x7f, 0x36, 0xeb, 0xff, 0x31, 0x2b, 0x3e, 0x36, 0xf6, 0x3e, 0x78, 0x3a, 0xbe, 0xf7, 0xea, 0x00, 0x1c, 0x6b, 0xde, 0xe3, 0xd5, 0x38, 0xce, 0x7b, 0xfe, 0x9c, 0xef, 0x38, 0x9e, 0x6b, 0x7e, 0x7f, 0xd7, 0xd6, 0xc6, 0x7b, 0xbe, 0xeb, 0xae, 0xee, 0xf3, 0x6b, 0xde, 0xdd, 0xd5, 0xd6, 0xe3, 0x7b, 0xff, 0xaa, 0xab, 0x10, 0xf7, 0x6b, 0x7b, 0x77, 0xd7, 0x38, 0xf3, 0x7b, 0x7d, 0x2a, 0xeb, 0x87, 0xf9, 0x6b, 0xfc, 0xc9, 0x9d, 0x8c, 0xf9, 0x7b, 0xf8, 0xff, 0x86, 0x90, 0xfb, 0x0f, 0xfc, 0x67, 0xb6, 0xb6, 0xf9, 0x78, 0xfe, 0xd7, 0x32, 0xa6, 0xfd, 0x0e, 0xcf, 0xcf, 0x82, 0xa0, 0xf9, 0x7e, 0xd8, 0xef, 0xde, 0xbd, 0xfb, 0x0d, 0xb0, 0xdf, 0xbd, 0x7b, 0xf7, 0x1b, 0x7e, 0x9f, 0x05, 0x41, 0xf3, 0xf3, 0x70, 0xbf, 0x65, 0x4c, 0xeb, 0x7f, 0x1e, 0x9f, 0x6d, 0x6d, 0xe6, 0x3f, 0xf0, 0xdf, 0x09, 0x61, 0xff, 0x1f, 0xde, 0x9f, 0x31, 0xb9, 0x93, 0x3f, 0xd6, 0x9f, 0xe1, 0xd7, 0x54, 0xbe, 0xde, 0xcf, 0x1c, 0xeb, 0xee, 0xde, 0xd6, 0xef, 0x08, 0xd5, 0x55, 0xff, 0xde, 0xc7, 0x6b, 0xab, 0xbb, 0x7b, 0xd6, 0xcf, 0x77, 0x75, 0xd7, 0x7d, 0xde, 0x63, 0x6b, 0xeb, 0xfe, 0x7e, 0xd6, 0x79, 0x1c, 0xf7, 0x39, 0x7f, 0xde, 0x73, 0x1c, 0xab, 0xc7, 0x7b, 0xd6, 0x38, 0x00, 0x57, 0xef, 0x7d, 0x5c, 0x1e, 0x7c, 0x6f, 0x6c, 0x7c, 0xd4, 0x8c, 0xff, 0xd7, 0x6c, 0xfe, 0x5c, 0xc6, 0xc7, 0xaf, 0xef, 0xff, 0xd4, 0xf3, 0x11, 0x7f, 0xfd, 0x7f, 0xdc, 0x7d, 0x44, 0xfe, 0xfb, 0x1f, 0xd4, 0x1f, 0x11, 0xfd, 0xff, 0x07, 0x5c, 0x47, 0x44, 0xfc, 0xff, 0x01, 0x54, 0xd6, 0xff, 0xf9, 0x7f, 0x00, 0x5c, 0x4c, 0x84, 0x8f, 0x1f, 0x00, 0x54, 0x78, 0x35, 0x07, 0x07, 0x00, 0x5c, 0x5c, 0xe5, 0x60, 0x01, 0x00, 0x54, 0xd4, 0x1d, 0x27, 0x01, 0x00, 0x5c, 0x74, 0x05, 0xe2, 0x00, 0x00, 0x54, 0x5c, 0x85, 0x2d, 0xe0, 0x03, 0x5c, 0x50, 0x05, 0x22, 0xc0, 0x01, 0x54, 0x50, 0x85, 0x27, 0xc0, 0x01, 0x5c, 0x50, 0x05, 0x24, 0x80, 0x00, 0x54, 0x50, 0x05, 0x24, 0x9c, 0x1c, 0x5c, 0x50, 0x7d, 0x3e, 0xfe, 0x3f, 0x7c, 0x50, 0x65, 0x2e, 0xff, 0x7f, 0x38, 0x50, 0x75, 0x3c, 0xff, 0x7f, 0x10, 0x50, 0x05, 0x20, 0xff, 0x7f, 0x00, 0xf0, 0xff, 0x3f, 0xfe, 0x3f, 0x00, 0xf0, 0xff, 0x3f, 0xdc, 0x1d, 0x00, 0x58, 0x55, 0x35, 0xe0, 0x03, 0x00, 0xac, 0xaa, 0x6a, 0xf0, 0x07, 0x00, 0xfe, 0xff, 0xff, 0xf0, 0x07, 0x00, 0x43, 0x10, 0x84, 0xf1, 0x07, 0x80, 0xb7, 0x6d, 0xdb, 0xe3, 0x03, 0xc0, 0x41, 0x10, 0x04, 0xc7, 0x01, 0x60, 0x41, 0x10, 0x04, 0x0d, 0x00}; #define king_d_width 47 #define king_d_height 92 #define king_d_x_hot -1 #define king_d_y_hot -1 static char king_d_bits[] = { 0x00, 0x2c, 0x22, 0x22, 0xa2, 0x01, 0x80, 0x58, 0x55, 0x55, 0xd5, 0x00, 0x80, 0x30, 0x22, 0x22, 0xe2, 0x08, 0xc0, 0xe1, 0x88, 0x88, 0x48, 0x04, 0xc0, 0xc1, 0x55, 0x55, 0x75, 0x06, 0xe0, 0x83, 0x89, 0x88, 0x28, 0x45, 0xf0, 0x07, 0xff, 0x1f, 0x32, 0x65, 0xf0, 0x07, 0xfe, 0xff, 0x95, 0x24, 0xf8, 0x0f, 0x02, 0xfc, 0x93, 0x6a, 0xfc, 0x1f, 0xf2, 0xf0, 0x5f, 0x76, 0xfe, 0x3f, 0x0a, 0xd1, 0xdf, 0x1d, 0xfc, 0x1f, 0x7a, 0x50, 0xdf, 0x1d, 0xf8, 0x0f, 0xb2, 0x50, 0x55, 0x76, 0xf0, 0x07, 0x79, 0x50, 0xb5, 0x6a, 0xf0, 0x07, 0x01, 0xa0, 0xaa, 0x24, 0xe0, 0x83, 0x22, 0xa0, 0x2a, 0x65, 0xc0, 0x81, 0x4d, 0x40, 0x55, 0x65, 0xc0, 0x01, 0x31, 0x5c, 0x55, 0x26, 0x80, 0x00, 0x02, 0x66, 0x55, 0x64, 0x80, 0x00, 0x0e, 0x5b, 0x55, 0x68, 0x0c, 0x00, 0x06, 0x55, 0xd5, 0x20, 0xd6, 0x40, 0x41, 0xa5, 0xaa, 0x60, 0xaa, 0xa0, 0xaa, 0xfa, 0xff, 0x7f, 0x56, 0x5d, 0x55, 0x3f, 0xc6, 0x48, 0x6a, 0xbf, 0xaa, 0x6a, 0xad, 0x65, 0xd4, 0x7a, 0xff, 0xc7, 0x18, 0x73, 0xb8, 0x34, 0xfe, 0xff, 0xff, 0x7f, 0x9c, 0x25, 0xde, 0x03, 0x00, 0x7f, 0xb2, 0x4d, 0xac, 0xff, 0xff, 0x41, 0x33, 0xcf, 0xdc, 0x31, 0xc6, 0x5b, 0xe6, 0xd8, 0xfd, 0x5b, 0xeb, 0x57, 0x36, 0xde, 0x7d, 0x8d, 0xb9, 0x4e, 0x8c, 0x97, 0x9d, 0xfd, 0x75, 0x5f, 0xe4, 0x2d, 0xb9, 0xac, 0xaa, 0x7a, 0xf2, 0x28, 0xd8, 0x56, 0xcb, 0x7d, 0x59, 0x2d, 0x99, 0xeb, 0xcf, 0x6a, 0x2c, 0x2e, 0x7b, 0x35, 0xa7, 0x77, 0x56, 0xad, 0xaf, 0x2a, 0x25, 0x2b, 0x8b, 0x5e, 0x5b, 0x35, 0x74, 0x5e, 0x55, 0x5f, 0xaa, 0xaa, 0xaa, 0x2a, 0x22, 0x5f, 0xf8, 0xdf, 0xaa, 0x74, 0xd5, 0x5b, 0xaa, 0xfa, 0xcb, 0x29, 0xe8, 0x59, 0xfb, 0xdf, 0x9a, 0x52, 0x95, 0xdb, 0x6f, 0x53, 0x9a, 0x32, 0x2a, 0x5f, 0x9b, 0x1c, 0x3d, 0x67, 0x27, 0x5e, 0xfd, 0x5f, 0x3d, 0x72, 0x4e, 0xbc, 0xfa, 0xbf, 0x7a, 0xe4, 0xe6, 0xbc, 0x38, 0xd9, 0xfa, 0x54, 0x4c, 0x59, 0xca, 0xf6, 0xdb, 0xa9, 0x4a, 0x59, 0xfb, 0xdf, 0x9a, 0x17, 0x94, 0xd3, 0x5f, 0x55, 0xda, 0xab, 0x2e, 0x55, 0xfb, 0x1f, 0xfa, 0x44, 0x54, 0x55, 0x55, 0x55, 0xfa, 0xaa, 0x7a, 0x2e, 0xac, 0xda, 0x7a, 0xd1, 0xd4, 0xa4, 0x54, 0xf5, 0xb5, 0x6a, 0xee, 0xe5, 0xac, 0xde, 0x74, 0x34, 0x56, 0xf3, 0xd7, 0x99, 0xb4, 0x9a, 0xbe, 0xd3, 0x6a, 0x1b, 0x14, 0x4f, 0x5e, 0x55, 0x35, 0x9d, 0xb4, 0x27, 0xfa, 0xae, 0xbf, 0xb9, 0xe9, 0x31, 0x72, 0x9d, 0xb1, 0xbe, 0x7b, 0x6c, 0xea, 0xd7, 0xda, 0xbf, 0x1b, 0x67, 0xda, 0x63, 0x8c, 0x3b, 0xf3, 0xcc, 0x82, 0xff, 0xff, 0x35, 0xb2, 0x4d, 0xfe, 0x00, 0xc0, 0x7b, 0xa4, 0x39, 0xfe, 0xff, 0xff, 0x7f, 0x2c, 0x1d, 0xce, 0x18, 0xe3, 0xff, 0x5e, 0x2b, 0xa6, 0xb5, 0x56, 0x55, 0xfd, 0x56, 0x12, 0x63, 0xfc, 0xaa, 0xba, 0x6a, 0xfe, 0xff, 0x5f, 0x55, 0x05, 0x55, 0x06, 0x55, 0xa5, 0x82, 0x02, 0x6b, 0x04, 0xab, 0xaa, 0x60, 0x00, 0x30, 0x16, 0xaa, 0xda, 0x70, 0x00, 0x01, 0x26, 0xaa, 0x66, 0x40, 0x00, 0x01, 0x64, 0xaa, 0x3a, 0x8c, 0x80, 0x03, 0xa6, 0xaa, 0x02, 0xb2, 0x81, 0x03, 0xa6, 0x54, 0x05, 0x44, 0xc1, 0x07, 0x24, 0x55, 0x05, 0x80, 0xe0, 0x0f, 0x56, 0xad, 0x0a, 0x9e, 0xe0, 0x0f, 0x6e, 0xaa, 0x0a, 0x4d, 0xf0, 0x1f, 0xb8, 0xfb, 0x0a, 0x5e, 0xf8, 0x3f, 0xb8, 0xfb, 0x8b, 0x50, 0xfc, 0x7f, 0x6e, 0xfa, 0x0f, 0x4f, 0xf8, 0x3f, 0x56, 0xc9, 0x3f, 0x40, 0xf0, 0x1f, 0x24, 0xa9, 0xff, 0x7f, 0xe0, 0x0f, 0xa6, 0x4c, 0xf8, 0xff, 0xe0, 0x0f, 0xa2, 0x14, 0x11, 0x91, 0xc1, 0x07, 0x60, 0xae, 0xaa, 0xaa, 0x83, 0x03, 0x20, 0x12, 0x11, 0x11, 0x87, 0x03, 0x10, 0x47, 0x44, 0x44, 0x0c, 0x01, 0x00, 0xab, 0xaa, 0xaa, 0x1a, 0x01, 0x80, 0x45, 0x44, 0x44, 0x34, 0x00}; #define king_h_width 47 #define king_h_height 92 #define king_h_x_hot -1 #define king_h_y_hot -1 static char king_h_bits[] = { 0x00, 0x08, 0x00, 0x00, 0x80, 0x00, 0x00, 0xb0, 0x6d, 0xdb, 0x76, 0x00, 0x00, 0x60, 0x55, 0x55, 0x55, 0x00, 0x00, 0xc0, 0x28, 0x8a, 0x22, 0x03, 0x00, 0x80, 0x10, 0x04, 0xa1, 0x04, 0x38, 0x38, 0x11, 0x04, 0xf1, 0x02, 0x7c, 0x7c, 0xfe, 0xff, 0x9f, 0x3e, 0xfe, 0xfe, 0xaa, 0xaa, 0xca, 0x6a, 0xfe, 0xfe, 0xfc, 0xff, 0x2f, 0x2a, 0xfe, 0xff, 0x04, 0xa0, 0xca, 0x2a, 0xfe, 0xff, 0x1a, 0xaf, 0x8a, 0x2a, 0xfc, 0x7f, 0xa6, 0xa0, 0xfa, 0x56, 0xfc, 0x7f, 0x3e, 0x4f, 0x55, 0x02, 0xf8, 0x3f, 0x3a, 0x4c, 0x95, 0x45, 0xf0, 0x1f, 0x3e, 0x4e, 0x35, 0x7e, 0xe0, 0x0f, 0xa2, 0x80, 0x2a, 0x02, 0xe0, 0x0f, 0x62, 0x80, 0x2a, 0x7f, 0xc0, 0x07, 0x42, 0x40, 0x55, 0x01, 0x80, 0x03, 0x03, 0x40, 0xd5, 0x7f, 0x80, 0xc3, 0xb2, 0x21, 0xd5, 0x3c, 0x00, 0x21, 0x43, 0xd0, 0x54, 0x1e, 0x00, 0x91, 0xe2, 0x50, 0x2a, 0x4f, 0x00, 0xf0, 0x04, 0xa8, 0x9f, 0x27, 0x00, 0x58, 0xab, 0xaa, 0xc9, 0x33, 0x00, 0x46, 0x55, 0x75, 0xea, 0x69, 0xc0, 0x2f, 0x0b, 0x6a, 0xff, 0x2c, 0x78, 0x56, 0xe6, 0xf8, 0x66, 0x1a, 0xae, 0xf5, 0xbc, 0x6f, 0xf5, 0x4b, 0x95, 0xd9, 0xf3, 0xe3, 0x1d, 0x67, 0x4a, 0x5a, 0x0d, 0x58, 0x6d, 0x7c, 0xa5, 0xf4, 0xf5, 0xd7, 0x87, 0x71, 0xb2, 0x59, 0x5d, 0x5d, 0x47, 0x46, 0x49, 0xb2, 0xd5, 0xf5, 0xa6, 0x38, 0x97, 0x55, 0x5f, 0x7d, 0x15, 0x4d, 0x3a, 0xed, 0xf6, 0xb7, 0xa7, 0x44, 0x74, 0xb2, 0x84, 0x30, 0x55, 0x56, 0xf9, 0x2c, 0x55, 0x55, 0xad, 0x52, 0xf2, 0xaf, 0xa7, 0xf2, 0x96, 0x5b, 0x74, 0x59, 0x44, 0x51, 0x97, 0x59, 0xb1, 0x3a, 0x8f, 0x50, 0xe6, 0x5d, 0x38, 0x1d, 0x50, 0xb9, 0x96, 0x44, 0xb5, 0x1a, 0x9f, 0xd8, 0xc5, 0x72, 0x72, 0x1c, 0x50, 0x99, 0x42, 0x3c, 0xb8, 0x1a, 0x1f, 0xa8, 0x62, 0x0f, 0xf5, 0x2e, 0x90, 0x78, 0xf2, 0x63, 0x8e, 0xe7, 0xcf, 0xf9, 0xf3, 0x38, 0x1c, 0xcf, 0x9f, 0xf3, 0xe7, 0x71, 0xc6, 0x4f, 0x1e, 0x09, 0x74, 0xaf, 0xf0, 0x46, 0x15, 0xf8, 0x58, 0x1d, 0x3c, 0x42, 0x99, 0x0a, 0x38, 0x4e, 0x4e, 0xa3, 0x1b, 0xf9, 0x58, 0xad, 0x22, 0x69, 0x9d, 0x0a, 0xb8, 0x1c, 0xba, 0x67, 0x0a, 0xf1, 0x5c, 0x8d, 0x9a, 0xe9, 0x8a, 0x22, 0x9a, 0x2e, 0xda, 0x69, 0x4f, 0xe5, 0xf5, 0x4f, 0x4a, 0xb5, 0xaa, 0xaa, 0x34, 0x9f, 0x6a, 0xaa, 0x0c, 0x21, 0x4d, 0x2e, 0x22, 0xe5, 0xed, 0x6f, 0xb7, 0x5c, 0xb2, 0xa8, 0xbe, 0xfa, 0xaa, 0xe9, 0x1c, 0x65, 0xaf, 0xab, 0x4d, 0x92, 0x62, 0xe2, 0xba, 0xba, 0x9a, 0x4d, 0x8e, 0xe1, 0xeb, 0xaf, 0x2f, 0xa5, 0x3e, 0xb6, 0x1a, 0xb0, 0x5a, 0x52, 0xe6, 0xb8, 0xc7, 0xcf, 0x9b, 0xa9, 0xd2, 0xaf, 0xf6, 0x3d, 0xaf, 0x75, 0x58, 0x66, 0x1f, 0x67, 0x6a, 0x1e, 0x34, 0xff, 0x56, 0xd0, 0xf4, 0x03, 0x96, 0x57, 0xae, 0xaa, 0x62, 0x00, 0xcc, 0x93, 0x55, 0xd5, 0x1a, 0x00, 0xe4, 0xf9, 0x15, 0x20, 0x0f, 0x00, 0xf2, 0x54, 0x0a, 0x47, 0x89, 0x00, 0x78, 0x2a, 0x0b, 0xc2, 0x84, 0x00, 0x3c, 0xab, 0x84, 0x4d, 0xc3, 0x01, 0xfe, 0xab, 0x02, 0xc0, 0xc0, 0x01, 0x80, 0xaa, 0x02, 0x42, 0xe0, 0x03, 0xfe, 0x54, 0x01, 0x46, 0xf0, 0x07, 0x40, 0x54, 0x01, 0x45, 0xf0, 0x07, 0x7e, 0xac, 0x72, 0x7c, 0xf8, 0x0f, 0xa2, 0xa9, 0x32, 0x5c, 0xfc, 0x1f, 0x40, 0xaa, 0xf2, 0x7c, 0xfe, 0x3f, 0x6a, 0x5f, 0x05, 0x65, 0xfe, 0x3f, 0x54, 0x51, 0xf5, 0x58, 0xff, 0x7f, 0x54, 0x53, 0x05, 0x20, 0xff, 0x7f, 0x54, 0xf4, 0xff, 0x3f, 0x7f, 0x7f, 0x56, 0x53, 0x55, 0x55, 0x7f, 0x7f, 0x7c, 0xf9, 0xff, 0x7f, 0x3e, 0x3e, 0x40, 0x8f, 0x20, 0x88, 0x1c, 0x1c, 0x20, 0x85, 0x20, 0x08, 0x01, 0x00, 0xc0, 0x44, 0x51, 0x14, 0x03, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0x06, 0x00, 0x00, 0x6e, 0xdb, 0xb6, 0x0d, 0x00, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00}; #define king_s_width 47 #define king_s_height 92 #define king_s_x_hot -1 #define king_s_y_hot -1 static char king_s_bits[] = { 0x00, 0xa0, 0x10, 0x04, 0x41, 0x02, 0x00, 0xc2, 0x39, 0x8e, 0x63, 0x01, 0x00, 0x82, 0x7d, 0xdf, 0xf7, 0x00, 0x00, 0x07, 0x7d, 0xdf, 0x67, 0x00, 0x00, 0x07, 0x12, 0x04, 0x21, 0x00, 0x80, 0x0f, 0xfc, 0xff, 0x3f, 0x00, 0x80, 0x0f, 0xfc, 0xff, 0x3f, 0x00, 0xc0, 0x1f, 0x54, 0x01, 0x20, 0x20, 0xe0, 0x3f, 0x54, 0x79, 0x3e, 0x70, 0xf0, 0x7f, 0x54, 0x05, 0x21, 0x58, 0xf8, 0xff, 0x54, 0xb9, 0x2f, 0x0c, 0xf8, 0xff, 0x54, 0x9d, 0x26, 0x04, 0xfc, 0xff, 0x55, 0xb9, 0x2f, 0x24, 0xfc, 0xff, 0x55, 0x01, 0x21, 0x24, 0xfc, 0xff, 0x55, 0x01, 0x21, 0x14, 0xfc, 0xff, 0x55, 0x81, 0x21, 0x14, 0xf8, 0xfa, 0x54, 0xb5, 0x36, 0x14, 0x70, 0x72, 0x54, 0x1d, 0x3c, 0x24, 0x00, 0x07, 0x54, 0x61, 0x23, 0x24, 0x80, 0x0f, 0x54, 0x81, 0x20, 0x24, 0x00, 0x00, 0x56, 0xc1, 0xe1, 0x24, 0x00, 0x00, 0x55, 0x03, 0x60, 0x15, 0x00, 0x00, 0x55, 0xad, 0x5a, 0x15, 0x00, 0x80, 0xab, 0xd3, 0xa5, 0x14, 0x00, 0xe0, 0xff, 0xff, 0x7f, 0x34, 0x00, 0xbc, 0x00, 0x00, 0xc4, 0x35, 0x00, 0xb3, 0xff, 0xff, 0x47, 0x35, 0xc0, 0x07, 0x55, 0x55, 0xaf, 0x66, 0x38, 0x67, 0xff, 0xff, 0xad, 0x66, 0x76, 0x6e, 0x01, 0x00, 0xa1, 0x66, 0xe3, 0x4c, 0x31, 0xb8, 0x52, 0x45, 0xc7, 0x1d, 0x3a, 0x84, 0x56, 0x45, 0x8f, 0xd3, 0xf2, 0x87, 0x56, 0x45, 0x9c, 0xd2, 0xe2, 0x4f, 0x28, 0x45, 0x78, 0x9d, 0xda, 0x4f, 0xa9, 0x46, 0xb1, 0x22, 0x42, 0x54, 0xab, 0x46, 0x73, 0x27, 0x24, 0x52, 0xab, 0x66, 0x97, 0xaf, 0x05, 0x40, 0x94, 0x66, 0xbe, 0xbe, 0xfd, 0xbf, 0x54, 0x67, 0x5c, 0x3c, 0xfd, 0xbf, 0x55, 0x7f, 0x7c, 0x78, 0xac, 0xaa, 0x55, 0x11, 0x5f, 0x7c, 0xa8, 0x2a, 0x5e, 0x7f, 0xe8, 0x5e, 0x5b, 0x55, 0x62, 0x0a, 0xbf, 0x4f, 0x3b, 0xd6, 0xa2, 0x7e, 0x68, 0x47, 0x7a, 0xd7, 0x5e, 0x0b, 0xbf, 0x42, 0xc8, 0x09, 0xa1, 0x7e, 0x7e, 0x85, 0x90, 0x13, 0x42, 0xfd, 0xd0, 0x7a, 0xeb, 0x5e, 0xe2, 0x16, 0x7e, 0x45, 0x6b, 0xdc, 0xf2, 0xfd, 0x50, 0x46, 0xaa, 0xda, 0x7a, 0x17, 0xfe, 0x7a, 0x54, 0x15, 0x3e, 0xfa, 0x88, 0xaa, 0x55, 0x35, 0x1e, 0x3e, 0xfe, 0xaa, 0xfd, 0xbf, 0x3c, 0x3a, 0xe6, 0x2a, 0xfd, 0xbf, 0x7d, 0x7d, 0x66, 0x29, 0x02, 0xa0, 0xf5, 0xe9, 0x66, 0xd5, 0x4a, 0x24, 0xe4, 0xce, 0x62, 0xd5, 0x2a, 0x42, 0x44, 0x8d, 0x62, 0x95, 0xf2, 0x5b, 0xb9, 0x1e, 0xa2, 0x14, 0xf2, 0x47, 0x4b, 0x39, 0xa2, 0x6a, 0xe1, 0x4f, 0xcb, 0xf1, 0xa2, 0x6a, 0x21, 0x5c, 0xb8, 0xe3, 0xa2, 0x4a, 0x1d, 0x8c, 0x32, 0xc7, 0x66, 0x85, 0x00, 0x80, 0x76, 0x6e, 0x66, 0xb5, 0xff, 0xff, 0xe6, 0x1c, 0x66, 0xf5, 0xaa, 0xaa, 0xe0, 0x03, 0xac, 0xe2, 0xff, 0xff, 0xcd, 0x00, 0xac, 0x23, 0x00, 0x00, 0x3d, 0x00, 0x2c, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x28, 0xa5, 0xcb, 0xd5, 0x01, 0x00, 0xa8, 0x5a, 0xb5, 0xaa, 0x00, 0x00, 0xa8, 0x06, 0xc0, 0xaa, 0x00, 0x00, 0x24, 0x87, 0x83, 0x6a, 0x00, 0x00, 0x24, 0x04, 0x81, 0x2a, 0xf0, 0x01, 0x24, 0xc4, 0x86, 0x2a, 0xe0, 0x00, 0x24, 0x3c, 0xb8, 0x2a, 0x4e, 0x0e, 0x28, 0x6c, 0xad, 0x2a, 0x5f, 0x1f, 0x28, 0x84, 0x81, 0xaa, 0xff, 0x3f, 0x28, 0x84, 0x80, 0xaa, 0xff, 0x3f, 0x24, 0x84, 0x80, 0xaa, 0xff, 0x3f, 0x24, 0xf4, 0x9d, 0xaa, 0xff, 0x3f, 0x20, 0x64, 0xb9, 0x2a, 0xff, 0x1f, 0x30, 0xf4, 0x9d, 0x2a, 0xff, 0x1f, 0x1a, 0x84, 0xa0, 0x2a, 0xfe, 0x0f, 0x0e, 0x7c, 0x9e, 0x2a, 0xfc, 0x07, 0x04, 0x04, 0x80, 0x2a, 0xf8, 0x03, 0x00, 0xfc, 0xff, 0x3f, 0xf0, 0x01, 0x00, 0xfc, 0xff, 0x3f, 0xf0, 0x01, 0x00, 0x84, 0x20, 0x48, 0xe0, 0x00, 0x00, 0xe6, 0xfb, 0xbe, 0xe0, 0x00, 0x00, 0xef, 0xfb, 0xbe, 0x41, 0x00, 0x80, 0xc6, 0x71, 0x9c, 0x43, 0x00, 0x40, 0x82, 0x20, 0x08, 0x05, 0x00}; #define queen_c_width 47 #define queen_c_height 92 #define queen_c_x_hot -1 #define queen_c_y_hot -1 static char queen_c_bits[] = { 0xc0, 0xec, 0x92, 0x02, 0x00, 0x00, 0xe0, 0xef, 0x29, 0x03, 0xe0, 0x00, 0xe1, 0xaf, 0x44, 0x02, 0xf0, 0x01, 0xc3, 0xa6, 0x92, 0x02, 0xf8, 0x03, 0x02, 0xf6, 0x29, 0x03, 0xf8, 0x03, 0x66, 0xb6, 0xcf, 0x03, 0xf8, 0x03, 0xf4, 0xd7, 0x20, 0x02, 0xf0, 0x01, 0xf4, 0x57, 0xef, 0x03, 0xee, 0x0e, 0x64, 0x73, 0xe6, 0x02, 0xff, 0x1f, 0x04, 0x5b, 0xae, 0x87, 0xff, 0x3f, 0xb4, 0x5b, 0x40, 0x8a, 0xff, 0x3f, 0xfe, 0x4b, 0x68, 0x92, 0xff, 0x3f, 0xfa, 0x79, 0x30, 0x27, 0xff, 0x1f, 0xf2, 0x2d, 0x20, 0x4f, 0x4e, 0x0e, 0xcf, 0x2d, 0x20, 0x9d, 0x40, 0x00, 0xd8, 0x24, 0x04, 0x39, 0xe1, 0x00, 0xf0, 0x7e, 0xbc, 0x73, 0xe2, 0x00, 0xe0, 0xf6, 0xb0, 0x67, 0xf2, 0x01, 0x70, 0xf2, 0xc1, 0xef, 0x04, 0x00, 0x70, 0x5b, 0x43, 0xdc, 0x04, 0x00, 0x38, 0x0f, 0x7f, 0xf1, 0x04, 0x00, 0xb8, 0x29, 0x54, 0xe4, 0x04, 0x00, 0x9c, 0xfc, 0x00, 0xdd, 0x04, 0x01, 0xcc, 0x84, 0xb7, 0xc3, 0x83, 0x02, 0xee, 0x8f, 0x7c, 0x62, 0xc3, 0x06, 0x26, 0xda, 0x6d, 0x37, 0x26, 0x09, 0x33, 0x73, 0xd7, 0x1d, 0xcf, 0x36, 0xbb, 0x3f, 0xba, 0xf8, 0x9b, 0x2a, 0xe9, 0xfb, 0xd7, 0xaf, 0x31, 0x25, 0x6c, 0x55, 0xef, 0xf4, 0xf9, 0x15, 0xf6, 0xee, 0x39, 0xac, 0x19, 0x3a, 0x5e, 0x55, 0x11, 0xdc, 0xf9, 0x45, 0xbb, 0xbb, 0xe2, 0xac, 0xf1, 0x33, 0x55, 0x55, 0xe3, 0xf8, 0x63, 0x4f, 0xee, 0xee, 0x5a, 0x6b, 0xb7, 0x2e, 0x55, 0x55, 0xbb, 0x3b, 0x5e, 0x59, 0xbb, 0xbb, 0x5b, 0x2b, 0xaf, 0x37, 0x55, 0x55, 0x43, 0x38, 0x5b, 0x68, 0xee, 0xee, 0xe2, 0x18, 0xb0, 0x53, 0xf5, 0x57, 0x05, 0x18, 0x70, 0x64, 0x1f, 0xb8, 0x87, 0x18, 0xe8, 0x29, 0x03, 0xc0, 0xc5, 0x99, 0xd9, 0x6b, 0x01, 0x03, 0xa7, 0x9a, 0xa9, 0x2b, 0x1b, 0x03, 0x75, 0x17, 0x50, 0x57, 0x1e, 0x30, 0x2a, 0x2a, 0xe0, 0x2c, 0x0d, 0x30, 0x9e, 0x3c, 0x06, 0x58, 0x1a, 0x60, 0x3c, 0x79, 0x0c, 0xb0, 0x34, 0x07, 0x54, 0x54, 0x0c, 0x78, 0xea, 0x0a, 0xe8, 0xae, 0xc0, 0xd8, 0xd4, 0x95, 0x59, 0xe5, 0xc0, 0x80, 0xd6, 0x9b, 0x99, 0xa3, 0x03, 0xc0, 0x94, 0x17, 0x18, 0xe1, 0x1d, 0xf8, 0x26, 0x0e, 0x18, 0xa0, 0xea, 0xaf, 0xca, 0x0d, 0x18, 0x47, 0x77, 0x77, 0x16, 0xda, 0x1c, 0xc2, 0xaa, 0xaa, 0xec, 0xf5, 0xd4, 0xda, 0xdd, 0xdd, 0x9a, 0x7a, 0xdc, 0xdd, 0xaa, 0xaa, 0x74, 0xed, 0xd6, 0x5a, 0x77, 0x77, 0xf2, 0xc6, 0x1f, 0xc7, 0xaa, 0xaa, 0xcc, 0x8f, 0x35, 0x47, 0xdd, 0xdd, 0xa2, 0x9f, 0x3b, 0x88, 0xaa, 0x7a, 0x5c, 0x98, 0x35, 0x9c, 0x77, 0x6f, 0xa8, 0x9f, 0x2f, 0xf7, 0xaa, 0x36, 0xa4, 0x8c, 0xf5, 0xeb, 0xdf, 0x97, 0x54, 0xd9, 0x1f, 0x5d, 0xfc, 0xdd, 0x6c, 0xf3, 0xb8, 0xeb, 0xce, 0xcc, 0x90, 0x64, 0xec, 0xb6, 0x5b, 0x64, 0x60, 0xc3, 0x46, 0x3e, 0xf1, 0x77, 0x40, 0xc1, 0xc3, 0xed, 0x21, 0x33, 0x80, 0x20, 0xbb, 0x00, 0x3f, 0x39, 0x00, 0x20, 0x27, 0x2a, 0x94, 0x1d, 0x00, 0x20, 0x8f, 0xfe, 0xf0, 0x1c, 0x00, 0x20, 0x3b, 0xc2, 0xda, 0x0e, 0x00, 0x20, 0xf7, 0x83, 0x4f, 0x0e, 0x80, 0x4f, 0xe6, 0x0d, 0x6f, 0x07, 0x00, 0x47, 0xce, 0x3d, 0x7e, 0x0f, 0x00, 0x87, 0x9c, 0x20, 0x24, 0x1b, 0x00, 0x02, 0xb9, 0x04, 0xb4, 0xf3, 0x70, 0x72, 0xf2, 0x04, 0xb4, 0x4f, 0xf8, 0xff, 0xe4, 0x0c, 0x9e, 0x5f, 0xfc, 0xff, 0x49, 0x16, 0xd2, 0x7f, 0xfc, 0xff, 0x51, 0x02, 0xda, 0x2d, 0xfc, 0xff, 0xe1, 0x75, 0xda, 0x20, 0xf8, 0xff, 0x40, 0x67, 0xce, 0x26, 0x70, 0x77, 0xc0, 0xf7, 0xea, 0x2f, 0x80, 0x0f, 0x40, 0x04, 0xeb, 0x2f, 0xc0, 0x1f, 0xc0, 0xf3, 0x6d, 0x66, 0xc0, 0x1f, 0xc0, 0x94, 0x6f, 0x40, 0xc0, 0x1f, 0x40, 0x49, 0x65, 0xc3, 0x80, 0x0f, 0x40, 0x22, 0xf5, 0x87, 0x00, 0x07, 0xc0, 0x94, 0xf7, 0x07, 0x00, 0x00, 0x40, 0x49, 0x37, 0x03}; #define queen_d_width 47 #define queen_d_height 92 #define queen_d_x_hot -1 #define queen_d_y_hot -1 static char queen_d_bits[] = { 0x04, 0xf1, 0x49, 0x01, 0x00, 0x00, 0xc8, 0xb7, 0x94, 0x01, 0x80, 0x00, 0x08, 0x79, 0x22, 0x03, 0x80, 0x00, 0x88, 0x58, 0x41, 0x05, 0xc0, 0x01, 0xe8, 0xbf, 0x80, 0x09, 0xc0, 0x01, 0x88, 0xec, 0x77, 0x0b, 0xe0, 0x03, 0x48, 0x5e, 0x88, 0x17, 0xf0, 0x07, 0xf8, 0x97, 0xef, 0x27, 0xf0, 0x07, 0x48, 0x0f, 0x73, 0x4f, 0xf8, 0x0f, 0x24, 0x1b, 0xd7, 0x5f, 0xfc, 0x1f, 0xfc, 0x17, 0x10, 0x9f, 0xfe, 0x3f, 0xa4, 0x1d, 0x20, 0xbf, 0xfc, 0x1f, 0xc2, 0x17, 0xac, 0x7d, 0xf9, 0x0f, 0xff, 0x0e, 0x90, 0x7a, 0xf2, 0x07, 0xc0, 0x09, 0x80, 0xfd, 0xf2, 0x07, 0x40, 0x1b, 0x9f, 0xfa, 0xe2, 0x03, 0xe0, 0x38, 0xcc, 0xf5, 0xc5, 0x01, 0xa0, 0x62, 0xc0, 0xea, 0xc5, 0x09, 0xf0, 0xc8, 0xe0, 0xf5, 0x89, 0x1c, 0xd0, 0xa3, 0x21, 0xeb, 0x8b, 0x2a, 0xf8, 0x9f, 0x9e, 0xdc, 0x0b, 0x77, 0xa8, 0xff, 0xa2, 0xff, 0x13, 0x2a, 0xdc, 0xfd, 0xff, 0xdf, 0x17, 0x18, 0xf4, 0xea, 0xff, 0xab, 0x17, 0x2c, 0xfe, 0x77, 0x7f, 0xf7, 0x1f, 0x2a, 0xea, 0xaf, 0xaa, 0xfa, 0x3b, 0x55, 0x5f, 0xff, 0xdd, 0x7f, 0xfd, 0x52, 0xfd, 0xfa, 0xff, 0xaf, 0x5f, 0x23, 0xdf, 0xd5, 0xff, 0xd5, 0xae, 0x5e, 0xce, 0xaf, 0xaa, 0xfa, 0x97, 0x35, 0x6f, 0xf2, 0xd5, 0xff, 0xd7, 0x62, 0xa7, 0xf2, 0x7f, 0x3e, 0x57, 0x55, 0x37, 0xf2, 0x4f, 0x06, 0xb7, 0x08, 0xf3, 0x2f, 0x4f, 0x6e, 0x6e, 0x55, 0x5b, 0x31, 0xdc, 0x6c, 0x3e, 0x22, 0x49, 0x55, 0x9b, 0x8c, 0x5f, 0x55, 0x9d, 0x51, 0x9b, 0xfe, 0xaa, 0x08, 0xbc, 0x4e, 0xf8, 0xab, 0x4e, 0x55, 0x2e, 0xb9, 0xaf, 0xfa, 0x75, 0x22, 0x5e, 0xc5, 0xea, 0x0f, 0x8c, 0x55, 0x6f, 0xd5, 0x1f, 0xf0, 0xaa, 0x08, 0x5f, 0xc5, 0xe0, 0x9f, 0x8a, 0x55, 0x6f, 0xb9, 0x3e, 0x40, 0x71, 0x23, 0x5f, 0x9d, 0x82, 0x5f, 0x9d, 0x54, 0x6b, 0xa3, 0xfa, 0x5a, 0xa3, 0x4e, 0x35, 0xab, 0xda, 0xad, 0x6a, 0x56, 0x6a, 0x56, 0xb5, 0x5b, 0xd5, 0xac, 0x72, 0xc5, 0x5a, 0x5f, 0xc5, 0xd6, 0x2a, 0xb9, 0xfa, 0x41, 0xb9, 0xfa, 0xc4, 0x8e, 0x02, 0x7c, 0x9d, 0xf6, 0xaa, 0x51, 0xf9, 0x07, 0xa3, 0xfa, 0x10, 0x55, 0x0f, 0xf8, 0xab, 0xf6, 0xaa, 0x31, 0xf0, 0x57, 0xa3, 0x7a, 0x44, 0xae, 0x5f, 0xf5, 0x9d, 0x74, 0xaa, 0x72, 0xd5, 0x1f, 0x72, 0x3d, 0x10, 0x55, 0x7f, 0xd9, 0x8a, 0xb9, 0xaa, 0xfa, 0x31, 0xd9, 0xaa, 0x92, 0x44, 0x7c, 0x36, 0x3b, 0x8c, 0xda, 0xaa, 0x76, 0x76, 0xf2, 0xf4, 0xcf, 0x10, 0xed, 0x60, 0xf2, 0x4f, 0xec, 0xaa, 0xea, 0x7c, 0xfe, 0x4f, 0xe5, 0x46, 0xeb, 0xff, 0xab, 0x4f, 0xf6, 0xac, 0xe9, 0x5f, 0x55, 0xf5, 0x73, 0x7a, 0x75, 0xab, 0xff, 0xab, 0xfb, 0xc4, 0xfa, 0xf5, 0xff, 0x5f, 0xbf, 0x4a, 0xbf, 0xfe, 0xbb, 0xff, 0xfa, 0xaa, 0xdc, 0x5f, 0x55, 0xf5, 0x57, 0x54, 0xf8, 0xef, 0xfe, 0xee, 0x7f, 0x34, 0xe8, 0xd5, 0xff, 0x57, 0x2f, 0x18, 0xe8, 0xfb, 0xff, 0xbf, 0x3b, 0x54, 0xc8, 0xff, 0x45, 0xff, 0x15, 0xee, 0xd0, 0x3b, 0x79, 0xf9, 0x1f, 0x54, 0xd1, 0xd7, 0x84, 0xc5, 0x0b, 0x38, 0x91, 0xaf, 0x07, 0x13, 0x0f, 0x90, 0xa3, 0x57, 0x03, 0x46, 0x05, 0x80, 0xa3, 0xaf, 0x33, 0x1c, 0x07, 0xc0, 0x47, 0x5f, 0xf9, 0xd8, 0x02, 0xe0, 0x4f, 0xbf, 0x01, 0x90, 0x03, 0xe0, 0x4f, 0x5e, 0x09, 0x70, 0xff, 0xf0, 0x9f, 0xbe, 0x35, 0xe8, 0x43, 0xf8, 0x3f, 0xfd, 0x04, 0xb8, 0x25, 0xfc, 0x7f, 0xf9, 0x08, 0xe8, 0x3f, 0xf8, 0x3f, 0xfa, 0xeb, 0xd8, 0x24, 0xf0, 0x1f, 0xf2, 0xce, 0xf0, 0x12, 0xe0, 0x0f, 0xe4, 0xf7, 0xe9, 0x1f, 0xe0, 0x0f, 0xe8, 0x11, 0x7a, 0x12, 0xc0, 0x07, 0xd0, 0xee, 0x37, 0x11, 0x80, 0x03, 0x90, 0x01, 0xfd, 0x17, 0x80, 0x03, 0xa0, 0x82, 0x1a, 0x11, 0x00, 0x01, 0xc0, 0x44, 0x9e, 0x10, 0x00, 0x01, 0x80, 0x29, 0xed, 0x13, 0x00, 0x00, 0x80, 0x92, 0x8f, 0x20}; #define queen_h_width 47 #define queen_h_height 92 #define queen_h_x_hot -1 #define queen_h_y_hot -1 static char queen_h_bits[] = { 0x00, 0x54, 0x05, 0x20, 0x00, 0x00, 0x00, 0xac, 0xce, 0x20, 0x0e, 0x0e, 0x00, 0x56, 0xcd, 0x11, 0x1f, 0x1f, 0x00, 0xae, 0xda, 0x91, 0xbf, 0x3f, 0x00, 0x16, 0x15, 0x90, 0xbf, 0x3f, 0x00, 0x0e, 0x3a, 0x93, 0xff, 0x3f, 0x00, 0x75, 0x3e, 0x97, 0xff, 0x3f, 0x00, 0x45, 0x70, 0x27, 0xff, 0x1f, 0x00, 0x7d, 0x6e, 0x20, 0xff, 0x1f, 0x00, 0x75, 0xcc, 0x2c, 0xfe, 0x0f, 0x80, 0x7e, 0x9e, 0x5d, 0xfc, 0x07, 0x80, 0x46, 0x80, 0x5d, 0xf8, 0x03, 0x80, 0x86, 0x00, 0x83, 0xf8, 0x03, 0x80, 0x8e, 0x02, 0x37, 0xf1, 0x01, 0x40, 0x8f, 0x81, 0xff, 0xe1, 0x00, 0x40, 0x0f, 0x81, 0x0d, 0xe0, 0x00, 0x40, 0x0f, 0xc4, 0x3f, 0x40, 0x00, 0x40, 0x97, 0xc3, 0x7a, 0x40, 0x08, 0xa0, 0x13, 0xe3, 0xff, 0x00, 0x36, 0xa0, 0x3b, 0x61, 0xf5, 0x03, 0x2a, 0xa0, 0x2f, 0xf0, 0xff, 0x0f, 0x5d, 0xa0, 0x57, 0x58, 0xcd, 0x3f, 0x2a, 0xd0, 0xad, 0xaf, 0xce, 0x1f, 0x36, 0xd0, 0x5d, 0x55, 0xfb, 0x0f, 0x48, 0xd0, 0xf2, 0xea, 0xf1, 0x0f, 0x7e, 0x50, 0x91, 0x3f, 0xfb, 0x35, 0x37, 0x28, 0x8e, 0x24, 0xb6, 0xf0, 0x20, 0x98, 0x7c, 0xe4, 0xb1, 0xd4, 0x2b, 0x48, 0xe6, 0x1f, 0x38, 0x67, 0x76, 0x24, 0xe2, 0x03, 0x18, 0x7a, 0x52, 0x24, 0xf2, 0x67, 0x5b, 0x5d, 0x2a, 0x32, 0xd3, 0xaf, 0xfe, 0x67, 0x52, 0x29, 0x51, 0x4f, 0xad, 0x3b, 0x62, 0x20, 0x39, 0x9d, 0xec, 0x25, 0x73, 0x54, 0xe9, 0x9e, 0xce, 0x3a, 0x79, 0x58, 0xd9, 0x3b, 0xce, 0x2a, 0x3d, 0x12, 0xb9, 0x39, 0x76, 0x35, 0x5f, 0x9c, 0xb9, 0x7b, 0x67, 0x2d, 0x2f, 0x94, 0x68, 0x77, 0x6b, 0x35, 0x57, 0x84, 0x7c, 0x67, 0xbf, 0x2a, 0x2b, 0x8e, 0x64, 0xf9, 0xb7, 0x36, 0x15, 0x95, 0x6c, 0xe7, 0xb5, 0x2a, 0x0b, 0xa4, 0x74, 0x9d, 0x59, 0x3d, 0x25, 0x88, 0xa4, 0x77, 0x5e, 0x2f, 0x13, 0xc9, 0xbc, 0xdc, 0x79, 0x33, 0x11, 0x5e, 0xdc, 0x73, 0xe7, 0x1d, 0x3d, 0xbc, 0xb8, 0xe7, 0xce, 0x3b, 0x7a, 0x88, 0xcc, 0x9e, 0x3b, 0x3d, 0x93, 0xc8, 0xf4, 0x7a, 0xee, 0x25, 0x11, 0xa4, 0xbc, 0x9a, 0xb9, 0x2e, 0x25, 0xd0, 0x54, 0xad, 0xe7, 0x36, 0xa9, 0xa8, 0x6c, 0xed, 0x9f, 0x26, 0x71, 0xd4, 0x54, 0xfd, 0xe6, 0x3e, 0x21, 0xea, 0xac, 0xd6, 0xee, 0x16, 0x29, 0xf4, 0xb4, 0xe6, 0xde, 0x9d, 0x39, 0xfa, 0xac, 0x6e, 0x9c, 0x9d, 0x48, 0xbc, 0x54, 0x73, 0xdc, 0x9b, 0x1a, 0x9e, 0x5c, 0x73, 0x79, 0x97, 0x2a, 0xce, 0xa4, 0x37, 0xb9, 0x9c, 0x04, 0x46, 0xdc, 0xb5, 0xf2, 0x8a, 0x94, 0x4a, 0xe6, 0x7f, 0xf5, 0xcb, 0x4c, 0x54, 0xba, 0xda, 0xe6, 0x4f, 0x24, 0x4a, 0x5e, 0x18, 0xc0, 0x47, 0x24, 0x6e, 0xe6, 0x1c, 0xf8, 0x67, 0x12, 0xd4, 0x2b, 0x8d, 0x27, 0x3e, 0x19, 0x04, 0x0f, 0x6d, 0x24, 0x71, 0x14, 0xec, 0xac, 0xdf, 0xfc, 0x89, 0x0a, 0x7e, 0xf0, 0x8f, 0x57, 0x4f, 0x0b, 0x12, 0xf0, 0xdf, 0xaa, 0xba, 0x0b, 0x6c, 0xf8, 0x73, 0xf5, 0xb5, 0x0b, 0x54, 0xfc, 0xb3, 0x1a, 0xea, 0x05, 0xba, 0xf0, 0xff, 0x0f, 0xf4, 0x05, 0x54, 0xc0, 0xaf, 0x86, 0xdc, 0x05, 0x6c, 0x00, 0xff, 0xc7, 0xc8, 0x05, 0x10, 0x02, 0x5e, 0xc3, 0xe9, 0x02, 0x00, 0x02, 0xfc, 0x23, 0xf0, 0x02, 0x00, 0x07, 0xb0, 0x81, 0xf0, 0x02, 0x00, 0x87, 0xff, 0x81, 0xf1, 0x02, 0x80, 0x8f, 0xec, 0x40, 0x71, 0x01, 0xc0, 0x1f, 0xc1, 0x00, 0x61, 0x01, 0xc0, 0x1f, 0xba, 0x01, 0x62, 0x01, 0xe0, 0x3f, 0xba, 0x79, 0x7e, 0x01, 0xf0, 0x7f, 0x34, 0x33, 0xae, 0x00, 0xf8, 0xff, 0x04, 0x76, 0xbe, 0x00, 0xf8, 0xff, 0xe4, 0x0e, 0xa2, 0x00, 0xfc, 0xff, 0xe9, 0x7c, 0xae, 0x00, 0xfc, 0xff, 0xc9, 0x5c, 0x70, 0x00, 0xfc, 0xfd, 0x09, 0xa8, 0x68, 0x00, 0xfc, 0xfd, 0x89, 0x5b, 0x75, 0x00, 0xf8, 0xf8, 0x88, 0xb3, 0x6a, 0x00, 0x70, 0x70, 0x04, 0x73, 0x35, 0x00, 0x00, 0x00, 0x04, 0xa0, 0x2a, 0x00}; #define queen_s_width 47 #define queen_s_height 92 #define queen_s_x_hot -1 #define queen_s_y_hot -1 static char queen_s_bits[] = { 0x00, 0x96, 0xb4, 0x10, 0x00, 0x00, 0x00, 0x4e, 0x19, 0x08, 0x00, 0x00, 0x00, 0x26, 0xb2, 0x0b, 0x00, 0x00, 0x04, 0x15, 0x34, 0x0b, 0x20, 0x00, 0x04, 0x0d, 0xb8, 0x0a, 0x20, 0x00, 0x0a, 0x75, 0x7c, 0x08, 0x70, 0x00, 0x0a, 0x45, 0x62, 0x0f, 0x70, 0x00, 0x0a, 0x7d, 0x7e, 0x0e, 0xf8, 0x00, 0x11, 0x5d, 0xcc, 0x0d, 0xf8, 0x00, 0x8a, 0x7a, 0xdc, 0x10, 0xfc, 0x01, 0x8e, 0x4a, 0x80, 0x1f, 0xfe, 0x03, 0x84, 0x8a, 0xc1, 0x1d, 0xff, 0x07, 0x84, 0x8a, 0xc0, 0x9f, 0xff, 0x0f, 0x8c, 0x0a, 0xa0, 0xc3, 0xff, 0x1f, 0x86, 0x9a, 0x63, 0xc1, 0xff, 0x1f, 0x4c, 0x9d, 0xd1, 0xc1, 0xff, 0x1f, 0x46, 0x2d, 0x30, 0xc3, 0xff, 0x1f, 0x4c, 0x2d, 0xa8, 0xc2, 0xff, 0x1f, 0x46, 0x55, 0x44, 0x84, 0xaf, 0x0f, 0x4c, 0xaf, 0xab, 0x0a, 0x27, 0x07, 0xe6, 0x13, 0x11, 0x11, 0x70, 0x00, 0xec, 0xab, 0xaa, 0x2e, 0xf8, 0x00, 0x66, 0x46, 0x44, 0x26, 0x00, 0x00, 0x7c, 0xae, 0xaa, 0x41, 0x00, 0x00, 0x16, 0x1c, 0x91, 0x94, 0x00, 0x00, 0xbc, 0xa8, 0x6a, 0x8c, 0x01, 0x04, 0x36, 0x4b, 0x24, 0x8a, 0x02, 0x0e, 0x7c, 0xb3, 0x1e, 0x80, 0x02, 0x15, 0xf6, 0xe4, 0x47, 0x61, 0x87, 0x3b, 0xfc, 0xa1, 0xc2, 0xb0, 0x6f, 0x15, 0xe6, 0x91, 0xb4, 0xdc, 0x7d, 0x4e, 0xcc, 0x93, 0x04, 0xf6, 0xdc, 0x25, 0x96, 0x8f, 0x08, 0x6d, 0xb6, 0x39, 0x3c, 0x8f, 0xc8, 0x32, 0x6b, 0x7f, 0x66, 0xce, 0xb9, 0xbd, 0xc5, 0x2b, 0xcc, 0xfc, 0xdf, 0xbe, 0xa5, 0x30, 0x86, 0xcd, 0x69, 0xa7, 0x55, 0x31, 0x1c, 0x8d, 0x98, 0xa3, 0xb5, 0x4d, 0x36, 0x8b, 0xe8, 0x29, 0x2b, 0x13, 0x2c, 0x9a, 0xe4, 0x6c, 0x16, 0x35, 0x46, 0xbf, 0x74, 0xce, 0x0c, 0x56, 0x8c, 0xa3, 0x3e, 0x80, 0x30, 0x17, 0x86, 0xff, 0xff, 0xff, 0x7f, 0x30, 0xac, 0x45, 0x44, 0x44, 0x84, 0x10, 0xa6, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x8c, 0xab, 0xaa, 0xaa, 0xea, 0x18, 0x18, 0x57, 0x55, 0x55, 0xd5, 0x31, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x65, 0x08, 0x21, 0x22, 0x22, 0xa2, 0x35, 0x0c, 0xfe, 0xff, 0xff, 0xff, 0x61, 0xe8, 0x0c, 0x01, 0x7c, 0xc5, 0x31, 0x6a, 0x30, 0x73, 0x2e, 0xfd, 0x62, 0xac, 0x68, 0x36, 0x27, 0x59, 0x34, 0xc8, 0xd4, 0x94, 0x17, 0xd1, 0x6c, 0xb2, 0xad, 0xc5, 0x19, 0xb1, 0x38, 0x8c, 0xaa, 0xe5, 0x96, 0xb3, 0x61, 0x0c, 0xa5, 0x7d, 0xfb, 0x3f, 0x33, 0xd4, 0xa3, 0xbd, 0x9d, 0x73, 0x66, 0xfe, 0xd6, 0x4c, 0x13, 0xf1, 0x3c, 0x9c, 0x6d, 0xb6, 0x10, 0xf1, 0x69, 0xa4, 0x3b, 0x6f, 0x20, 0xc9, 0x33, 0x72, 0xbe, 0x3b, 0x2d, 0x89, 0x67, 0xa8, 0xf6, 0x0d, 0x43, 0x85, 0x3f, 0xdc, 0xe1, 0x86, 0xe2, 0x27, 0x6f, 0xa8, 0x40, 0x01, 0x78, 0xcd, 0x3e, 0x70, 0x40, 0x51, 0x24, 0xd2, 0x6c, 0x20, 0x80, 0x31, 0x56, 0x15, 0x3d, 0x00, 0x00, 0x29, 0x89, 0x38, 0x68, 0x00, 0x00, 0x82, 0x55, 0x75, 0x3e, 0x00, 0x00, 0x64, 0x22, 0x62, 0x66, 0x00, 0x1f, 0x74, 0x55, 0xd5, 0x37, 0x00, 0x0e, 0x88, 0x88, 0xc8, 0x67, 0xe0, 0xe4, 0x50, 0xd5, 0xf5, 0x32, 0xf0, 0xf5, 0x21, 0x22, 0xaa, 0x62, 0xf8, 0xff, 0x43, 0x15, 0xb4, 0x32, 0xf8, 0xff, 0xc3, 0x0c, 0xb4, 0x62, 0xf8, 0xff, 0x83, 0x8b, 0xb9, 0x32, 0xf8, 0xff, 0x83, 0xc6, 0x59, 0x61, 0xf8, 0xff, 0xc3, 0x05, 0x50, 0x31, 0xf0, 0xff, 0xf9, 0x03, 0x51, 0x21, 0xe0, 0xff, 0xb8, 0x83, 0x51, 0x21, 0xc0, 0x7f, 0xf8, 0x01, 0x52, 0x71, 0x80, 0x3f, 0x08, 0x3b, 0x5e, 0x51, 0x00, 0x1f, 0xb0, 0x33, 0xba, 0x88, 0x00, 0x1f, 0x70, 0x7e, 0xbe, 0x50, 0x00, 0x0e, 0xf0, 0x46, 0xa2, 0x50, 0x00, 0x0e, 0x10, 0x3e, 0xae, 0x50, 0x00, 0x04, 0x50, 0x1d, 0xb0, 0x20, 0x00, 0x04, 0xd0, 0x2c, 0xa8, 0x20, 0x00, 0x00, 0xd0, 0x4d, 0x64, 0x00, 0x00, 0x00, 0x10, 0x98, 0x72, 0x00, 0x00, 0x00, 0x08, 0x2d, 0x69, 0x00}; #define jack_c_width 47 #define jack_c_height 92 #define jack_c_x_hot -1 #define jack_c_y_hot -1 static char jack_c_bits[] = { 0x60, 0xab, 0x6a, 0x6b, 0x03, 0x00, 0xc0, 0xd6, 0x56, 0xb5, 0xe1, 0x00, 0x80, 0xad, 0x6a, 0xdb, 0xf0, 0x01, 0x81, 0xdb, 0x56, 0x6d, 0xf8, 0x03, 0x83, 0xf6, 0x7e, 0x37, 0xf8, 0x03, 0x46, 0x0e, 0x00, 0x18, 0xf8, 0x03, 0x4d, 0xfd, 0xff, 0x0f, 0xf0, 0x01, 0x9b, 0xfd, 0xff, 0x0f, 0xee, 0x0e, 0xb7, 0x04, 0x40, 0x0d, 0xff, 0x1f, 0x60, 0x04, 0x40, 0x95, 0xff, 0x3f, 0xff, 0x1c, 0x5f, 0x95, 0xff, 0x3f, 0x04, 0xa4, 0x40, 0x95, 0xff, 0x3f, 0x04, 0x1e, 0x4f, 0x15, 0xff, 0x1f, 0x04, 0x4c, 0x46, 0x15, 0x4e, 0x0e, 0x04, 0x5c, 0x4e, 0x15, 0x40, 0x00, 0x04, 0x24, 0x40, 0x15, 0xe0, 0x00, 0x04, 0xe4, 0x40, 0x75, 0xe0, 0x00, 0x04, 0x44, 0x40, 0x5d, 0xf0, 0x01, 0x04, 0x04, 0x42, 0x57, 0x00, 0x00, 0x04, 0xe8, 0x41, 0x55, 0x00, 0x00, 0x0f, 0xc8, 0x60, 0x35, 0x00, 0x00, 0x12, 0x18, 0x70, 0x7c, 0x00, 0x00, 0x27, 0x37, 0xdc, 0xff, 0x01, 0x00, 0xe4, 0xe9, 0x07, 0xde, 0x07, 0x00, 0xe7, 0x1c, 0x9f, 0xd7, 0x1e, 0x00, 0xf4, 0x19, 0xfa, 0xe9, 0x7a, 0x40, 0xef, 0xdc, 0x62, 0xc4, 0xea, 0x61, 0xd4, 0x19, 0x06, 0xd6, 0x7e, 0x37, 0xbc, 0x1c, 0x9e, 0xc3, 0xf6, 0x1e, 0x7c, 0xd5, 0xfe, 0xeb, 0x7e, 0x15, 0xec, 0x1a, 0xfa, 0xc1, 0xea, 0x12, 0xd4, 0x1d, 0xe2, 0xd5, 0x6a, 0x19, 0xbc, 0xcf, 0x46, 0xc0, 0xfe, 0x11, 0x6c, 0x0f, 0xdd, 0xfa, 0xf6, 0x10, 0xf4, 0x0a, 0x3b, 0xd0, 0x7e, 0x16, 0xbc, 0x6d, 0x55, 0xcf, 0x7a, 0x10, 0xb4, 0x07, 0x1b, 0xd4, 0x26, 0x18, 0xbc, 0x85, 0xad, 0xd3, 0xa1, 0x15, 0x9c, 0xb5, 0x0a, 0x65, 0x14, 0x14, 0xdc, 0x82, 0xed, 0x94, 0x11, 0x1a, 0xdc, 0xc2, 0x4a, 0x09, 0x6c, 0x1a, 0xcc, 0x5a, 0x3d, 0x35, 0x0b, 0x1d, 0x6c, 0xc1, 0x4a, 0x82, 0x06, 0x1d, 0x6c, 0x61, 0xd5, 0x6d, 0xb5, 0x1e, 0x6c, 0xad, 0xba, 0xb2, 0x86, 0x1e, 0xbc, 0x60, 0x6d, 0x5b, 0x83, 0x1e, 0x78, 0xc1, 0xda, 0xb6, 0x06, 0x3d, 0x78, 0x61, 0x4d, 0x5d, 0xb5, 0x36, 0x78, 0xad, 0xb6, 0xab, 0x86, 0x36, 0xb8, 0x60, 0x41, 0x52, 0x83, 0x36, 0xb8, 0xd0, 0xac, 0xbc, 0x5a, 0x33, 0x58, 0x36, 0x90, 0x52, 0x43, 0x3b, 0x58, 0x88, 0x29, 0xb7, 0x41, 0x3b, 0x28, 0x28, 0xa6, 0x50, 0xad, 0x39, 0xa8, 0x85, 0xcb, 0xb5, 0xa1, 0x3d, 0x18, 0x64, 0x2b, 0xd8, 0xe0, 0x2d, 0x08, 0x5e, 0xf3, 0xaa, 0xb6, 0x3d, 0x68, 0x7e, 0x0b, 0xdc, 0x50, 0x2f, 0x08, 0x6f, 0x5f, 0xbb, 0xf0, 0x36, 0x88, 0x7f, 0x03, 0x62, 0xf3, 0x3d, 0x98, 0x56, 0xab, 0x47, 0xb8, 0x2b, 0x48, 0x57, 0x83, 0x5f, 0x58, 0x37, 0xa8, 0x7e, 0xd7, 0x7f, 0xab, 0x3e, 0x78, 0x6f, 0xc3, 0x79, 0x38, 0x3d, 0xec, 0x7e, 0x6b, 0x60, 0x98, 0x2b, 0x86, 0x57, 0x23, 0x46, 0x3b, 0xf7, 0x02, 0x5e, 0x97, 0x5f, 0x98, 0x2f, 0x00, 0x78, 0xeb, 0xf9, 0x38, 0xe7, 0x00, 0xe0, 0x7b, 0xe0, 0x97, 0x27, 0x00, 0x80, 0xff, 0x3b, 0xec, 0xe4, 0x00, 0x00, 0x3e, 0x0e, 0x18, 0x48, 0x00, 0x00, 0xac, 0x06, 0x13, 0xf0, 0x00, 0x00, 0xaa, 0x82, 0x17, 0x20, 0x00, 0x00, 0xea, 0x42, 0x20, 0x20, 0x80, 0x0f, 0xba, 0x02, 0x22, 0x20, 0x00, 0x07, 0xae, 0x02, 0x27, 0x20, 0x00, 0x07, 0xa8, 0x02, 0x24, 0x20, 0x00, 0x02, 0xa8, 0x72, 0x3a, 0x20, 0x70, 0x72, 0xa8, 0x62, 0x32, 0x20, 0xf8, 0xff, 0xa8, 0xf2, 0x78, 0x20, 0xfc, 0xff, 0xa9, 0x02, 0x25, 0x20, 0xfc, 0xff, 0xa9, 0xfa, 0x38, 0xff, 0xfc, 0xff, 0xa9, 0x02, 0x20, 0x06, 0xf8, 0xff, 0xb0, 0x02, 0x20, 0xed, 0x70, 0x77, 0xf0, 0xff, 0xbf, 0xd9, 0x80, 0x0f, 0xf0, 0xff, 0xbf, 0xb2, 0xc0, 0x1f, 0x18, 0x00, 0x70, 0x62, 0xc0, 0x1f, 0xec, 0x7e, 0x6f, 0xc1, 0xc0, 0x1f, 0xb6, 0x6a, 0xdb, 0x81, 0x80, 0x0f, 0xdb, 0x56, 0xb5, 0x01, 0x00, 0x87, 0xad, 0x6a, 0x6b, 0x03, 0x00, 0xc0, 0xd6, 0x56, 0xd5, 0x06}; #define jack_d_width 47 #define jack_d_height 92 #define jack_d_x_hot -1 #define jack_d_y_hot -1 static char jack_d_bits[] = { 0x00, 0xce, 0xed, 0x76, 0x0e, 0x00, 0x00, 0x9c, 0xed, 0x36, 0x87, 0x00, 0x00, 0x38, 0x0c, 0x86, 0x83, 0x00, 0x01, 0xf0, 0xff, 0xff, 0xc1, 0x01, 0x03, 0xf0, 0xff, 0xff, 0xc0, 0x01, 0x07, 0xb0, 0x02, 0xc0, 0xe0, 0x03, 0x06, 0xa8, 0x42, 0xc0, 0xf0, 0x07, 0x05, 0xa8, 0x3e, 0xfc, 0xf0, 0x07, 0x06, 0xa8, 0x82, 0xc2, 0xf8, 0x0f, 0x05, 0xaa, 0x7e, 0xfa, 0xfc, 0x1f, 0x06, 0xab, 0x3a, 0xba, 0xfe, 0x3f, 0x85, 0xa9, 0x22, 0xa2, 0xfc, 0x1f, 0x46, 0xa9, 0x02, 0xa2, 0xf8, 0x0f, 0xa5, 0xa8, 0x02, 0xa4, 0xf0, 0x07, 0x9e, 0xa8, 0x02, 0xa7, 0xf0, 0x07, 0x47, 0xa8, 0x02, 0xa0, 0xe0, 0x03, 0x22, 0xae, 0x22, 0xa0, 0xc0, 0x01, 0x10, 0xa9, 0xc2, 0xd7, 0xc3, 0x41, 0x0d, 0xaf, 0x83, 0x91, 0x84, 0x60, 0x07, 0x61, 0x06, 0x28, 0x85, 0x70, 0x85, 0x1e, 0x1c, 0x44, 0x0c, 0x30, 0xc4, 0x64, 0xf0, 0xc7, 0x37, 0x10, 0x66, 0x99, 0x03, 0x38, 0xd3, 0x50, 0xf7, 0x66, 0xfc, 0xc7, 0xdc, 0x73, 0xce, 0x8d, 0x03, 0x38, 0xde, 0x5d, 0xac, 0x3b, 0xfc, 0x87, 0xbf, 0x1d, 0x17, 0xd7, 0x03, 0xf8, 0xbe, 0x3b, 0xb4, 0xee, 0xfe, 0xef, 0x76, 0x77, 0x57, 0xdc, 0xbb, 0xbb, 0x76, 0x3e, 0xb4, 0xba, 0xee, 0xee, 0xf6, 0x1c, 0x17, 0x69, 0xbb, 0xbb, 0xf6, 0x59, 0xb4, 0xda, 0xee, 0xee, 0xd6, 0x73, 0x4f, 0xec, 0xbd, 0xbb, 0xf6, 0x57, 0xac, 0xda, 0xeb, 0xee, 0x16, 0x1f, 0x1d, 0xe9, 0xb6, 0xbb, 0xf6, 0x3f, 0xaf, 0xda, 0xee, 0xee, 0x16, 0x78, 0x55, 0xec, 0xdb, 0xbb, 0xf6, 0x3f, 0xbc, 0xda, 0xbb, 0xee, 0x16, 0x10, 0x16, 0xe9, 0x6c, 0xbb, 0xf6, 0x5f, 0xaf, 0x7a, 0xd7, 0xee, 0x16, 0x78, 0x76, 0x7c, 0xab, 0xbd, 0xf6, 0x57, 0xac, 0x9a, 0x5d, 0xeb, 0x56, 0x1c, 0x35, 0xed, 0xa2, 0xb6, 0xf6, 0x37, 0xef, 0xee, 0x59, 0xed, 0xb6, 0x7b, 0xb5, 0x73, 0xdb, 0xda, 0x5e, 0x37, 0x2c, 0xbd, 0x46, 0xb1, 0x5e, 0x1a, 0x58, 0x7a, 0x8d, 0x62, 0xbd, 0x34, 0xec, 0x7a, 0x5b, 0xdb, 0xce, 0xad, 0xde, 0x6d, 0xb7, 0x9a, 0x77, 0xf7, 0xec, 0x6f, 0x6d, 0x45, 0xb7, 0xac, 0x38, 0x6a, 0xd7, 0xba, 0x59, 0x35, 0xea, 0x6f, 0xbd, 0xd5, 0x3e, 0x6e, 0x1e, 0x68, 0x77, 0xeb, 0x5e, 0xf5, 0xfa, 0x6f, 0xdd, 0x36, 0x97, 0x68, 0x08, 0x68, 0x77, 0xdd, 0x5b, 0x3d, 0xfc, 0x6f, 0xdd, 0xdb, 0x37, 0xaa, 0x1e, 0x68, 0x77, 0x77, 0x5b, 0xf5, 0xfc, 0x6f, 0xdd, 0x6d, 0x97, 0xb8, 0xf8, 0x68, 0x77, 0xd7, 0x5b, 0x35, 0xea, 0x6f, 0xdd, 0xbd, 0x37, 0xf2, 0xce, 0x6b, 0x77, 0x77, 0x5b, 0x2d, 0x9a, 0x6f, 0xdd, 0xdd, 0x96, 0xe8, 0x38, 0x6f, 0x77, 0x77, 0x5d, 0x2d, 0x7c, 0x6e, 0xdd, 0xdd, 0x3b, 0xea, 0xee, 0x6e, 0xf7, 0x7f, 0x77, 0x2d, 0xdc, 0x7d, 0x1f, 0xc0, 0xeb, 0xe8, 0xb8, 0xfd, 0xe1, 0x3f, 0xdc, 0x35, 0xba, 0x7b, 0x1c, 0xc0, 0xb1, 0x73, 0xce, 0x3b, 0xe3, 0x3f, 0x66, 0xef, 0x0a, 0xcb, 0x1c, 0xc0, 0x99, 0x66, 0x08, 0xec, 0xe3, 0x0f, 0x26, 0x23, 0x0c, 0x30, 0x22, 0x38, 0x78, 0xa1, 0x0e, 0xa1, 0x14, 0x60, 0x86, 0xe0, 0x06, 0x21, 0x89, 0xc1, 0xf5, 0xb0, 0x82, 0xc3, 0xeb, 0x43, 0x95, 0x08, 0x80, 0x03, 0x05, 0x44, 0x75, 0x44, 0xc0, 0x07, 0x05, 0x40, 0x15, 0xe2, 0xe0, 0x0f, 0xe5, 0x40, 0x15, 0x79, 0xe0, 0x0f, 0x25, 0x40, 0x15, 0xa5, 0xf0, 0x1f, 0x45, 0x40, 0x95, 0x62, 0xf8, 0x3f, 0x45, 0x44, 0x95, 0xa1, 0xfc, 0x7f, 0x5d, 0x5c, 0xd5, 0x60, 0xf8, 0x3f, 0x5f, 0x7e, 0x55, 0xa0, 0xf0, 0x1f, 0x43, 0x41, 0x15, 0x60, 0xe0, 0x0f, 0x3f, 0x7c, 0x15, 0xa0, 0xe0, 0x0f, 0x03, 0x42, 0x15, 0x60, 0xc0, 0x07, 0x03, 0x40, 0x0d, 0xe0, 0x80, 0x03, 0xff, 0xff, 0x0f, 0xc0, 0x80, 0x83, 0xff, 0xff, 0x0f, 0x80, 0x00, 0xc1, 0x61, 0x30, 0x1c, 0x00, 0x00, 0xe1, 0x6c, 0xb7, 0x39, 0x00, 0x00, 0x70, 0x6e, 0xb7, 0x73, 0x00}; #define jack_h_width 47 #define jack_h_height 92 #define jack_h_x_hot -1 #define jack_h_y_hot -1 static char jack_h_bits[] = { 0x60, 0xca, 0x64, 0xca, 0x00, 0x00, 0xc0, 0xd4, 0x6a, 0x65, 0x00, 0x00, 0x81, 0xc9, 0x64, 0x32, 0x07, 0x07, 0x03, 0xd3, 0x6a, 0x99, 0x8f, 0x0f, 0x17, 0xc6, 0x60, 0xcc, 0xdf, 0x1f, 0x37, 0xfc, 0xff, 0xcf, 0xdf, 0x1f, 0x57, 0xf8, 0xff, 0xcf, 0xff, 0x1f, 0x97, 0x50, 0x05, 0xc8, 0xff, 0x1f, 0x37, 0x51, 0xe5, 0x85, 0xff, 0x0f, 0x3f, 0x51, 0xc5, 0x84, 0xff, 0x0f, 0x6a, 0x51, 0xa5, 0x04, 0xff, 0x07, 0xaa, 0x51, 0xc5, 0x09, 0xfe, 0x03, 0x6a, 0xa9, 0x02, 0x08, 0xfc, 0x01, 0x3f, 0xa9, 0x32, 0x10, 0xfc, 0x01, 0x97, 0xa8, 0x12, 0x1b, 0xf8, 0x00, 0x57, 0x56, 0xe1, 0x04, 0x70, 0x00, 0x37, 0x59, 0x01, 0x04, 0x70, 0x09, 0x97, 0x56, 0x81, 0x07, 0x20, 0x0f, 0x87, 0x5a, 0x07, 0x0e, 0x24, 0x06, 0x07, 0xa7, 0x1a, 0x08, 0x09, 0x0d, 0xc7, 0xfe, 0x75, 0x14, 0xf6, 0x0b, 0xf7, 0xff, 0xff, 0x3f, 0x88, 0x06, 0x3f, 0x07, 0x00, 0xc0, 0x84, 0x01, 0x38, 0x8f, 0x44, 0x91, 0x41, 0x02, 0xe7, 0x1e, 0xff, 0x7f, 0xa6, 0x0e, 0xde, 0x3f, 0x80, 0x00, 0x9c, 0x1a, 0xb6, 0x73, 0xfe, 0x7f, 0x7e, 0x17, 0xd9, 0xf3, 0x44, 0x22, 0xf3, 0x0a, 0xed, 0xee, 0x89, 0x91, 0x73, 0x07, 0x76, 0xfc, 0x53, 0xca, 0xdd, 0x06, 0x3b, 0x39, 0x97, 0xe9, 0x7f, 0x1f, 0x9d, 0x3c, 0xaf, 0x75, 0xd6, 0x7a, 0x4e, 0xee, 0x2e, 0x74, 0x6e, 0x6b, 0x27, 0xf7, 0x5f, 0xba, 0xd7, 0x6a, 0x93, 0xaf, 0x59, 0xfa, 0x7b, 0x5b, 0xc9, 0xd5, 0xb9, 0x9d, 0xdd, 0x32, 0xe4, 0xfa, 0xb7, 0x9d, 0x6b, 0x6b, 0x72, 0x1f, 0x7f, 0xee, 0xd7, 0x5a, 0xf9, 0x26, 0x66, 0xfe, 0x7f, 0x37, 0x5c, 0xf3, 0x67, 0x66, 0xdc, 0x6e, 0xaf, 0x09, 0x6e, 0x66, 0xb2, 0x5d, 0xf6, 0xfd, 0x7f, 0xf6, 0x67, 0x3b, 0xed, 0xfa, 0x7f, 0xff, 0xcf, 0x76, 0xda, 0x4a, 0x24, 0x12, 0xd9, 0x2d, 0xed, 0x8a, 0x94, 0x94, 0xa8, 0x57, 0xda, 0x6a, 0x4f, 0x79, 0xab, 0x2d, 0xb4, 0xd5, 0x9e, 0xf2, 0x56, 0x5b, 0xea, 0x15, 0x29, 0x29, 0x51, 0xb7, 0xb4, 0x9b, 0x48, 0x24, 0x52, 0x5b, 0x6e, 0xf3, 0xff, 0xfe, 0x5f, 0xb7, 0xdc, 0xe6, 0x6f, 0xfe, 0xbf, 0x6f, 0xba, 0x4d, 0x66, 0x76, 0x90, 0xf5, 0x76, 0x3b, 0x66, 0xe6, 0xcf, 0x3a, 0xec, 0xfe, 0x7f, 0x66, 0x64, 0x9f, 0x5a, 0xeb, 0x77, 0xfe, 0xf8, 0x4e, 0xd6, 0xd6, 0xb9, 0xed, 0x5f, 0x27, 0x4c, 0xbb, 0xb9, 0x9d, 0xab, 0x93, 0xda, 0xde, 0x5f, 0x9a, 0xf5, 0xc9, 0x56, 0xeb, 0x5d, 0xfa, 0xef, 0xe4, 0xd6, 0x76, 0x2e, 0x74, 0x77, 0x72, 0x5e, 0x6b, 0xae, 0xf5, 0x3c, 0xb9, 0xf8, 0xfe, 0x97, 0xe9, 0x9c, 0xdc, 0x60, 0xbb, 0x53, 0xca, 0x3f, 0x6e, 0xe0, 0xce, 0x89, 0x91, 0x77, 0xb7, 0x50, 0xcf, 0x44, 0x22, 0xcf, 0x9b, 0xe8, 0x7e, 0xfe, 0x7f, 0xce, 0x6d, 0x58, 0x39, 0x00, 0x01, 0xfc, 0x7b, 0x70, 0x65, 0xfe, 0xff, 0x78, 0xe7, 0x40, 0x82, 0x89, 0x22, 0xf1, 0x1c, 0x80, 0x21, 0x03, 0x00, 0xe0, 0xfc, 0x60, 0x11, 0xfc, 0xff, 0xff, 0xef, 0xd0, 0x6f, 0x28, 0xae, 0x7f, 0xe3, 0xb0, 0x90, 0x10, 0x58, 0xe5, 0xe0, 0x60, 0x24, 0x70, 0xe0, 0x5a, 0xe1, 0xf0, 0x04, 0xe0, 0x81, 0x6a, 0xe9, 0x90, 0x0e, 0x20, 0x80, 0x9a, 0xec, 0x00, 0x0e, 0x20, 0x87, 0x6a, 0xea, 0x00, 0x1f, 0xd8, 0x48, 0x15, 0xe9, 0x80, 0x3f, 0x08, 0x4c, 0x95, 0xfc, 0x80, 0x3f, 0x10, 0x40, 0x95, 0x56, 0xc0, 0x7f, 0x90, 0xa3, 0x8a, 0x55, 0xe0, 0xff, 0x20, 0xa5, 0x8a, 0x56, 0xf0, 0xff, 0x21, 0xa3, 0x8a, 0xfc, 0xf0, 0xff, 0xa1, 0xa7, 0x8a, 0xec, 0xf8, 0xff, 0x13, 0xa0, 0x0a, 0xe9, 0xf8, 0xff, 0xf3, 0xff, 0x1f, 0xea, 0xf8, 0xfb, 0xf3, 0xff, 0x3f, 0xec, 0xf8, 0xfb, 0x33, 0x06, 0x63, 0xe8, 0xf0, 0xf1, 0x99, 0x56, 0xcb, 0xc0, 0xe0, 0xe0, 0x4c, 0x26, 0x93, 0x81, 0x00, 0x00, 0xa6, 0x56, 0x2b, 0x03, 0x00, 0x00, 0x53, 0x26, 0x53, 0x06}; #define jack_s_width 47 #define jack_s_height 92 #define jack_s_x_hot -1 #define jack_s_y_hot -1 static char jack_s_bits[] = { 0xb8, 0xba, 0xee, 0xea, 0x40, 0x00, 0x70, 0x75, 0xd7, 0x75, 0xe0, 0x00, 0xe4, 0xba, 0xee, 0x3a, 0xe0, 0x00, 0xca, 0x75, 0xd7, 0x1d, 0xf0, 0x01, 0x8e, 0xff, 0xff, 0x0f, 0xf0, 0x01, 0x0e, 0xff, 0xff, 0x0f, 0xf8, 0x03, 0x0a, 0x01, 0xa8, 0x0a, 0xfc, 0x07, 0x0a, 0xf1, 0xa8, 0x0a, 0xfe, 0x0f, 0x0e, 0x09, 0xab, 0x0a, 0xff, 0x1f, 0x0e, 0x79, 0xa8, 0x0a, 0xff, 0x1f, 0x0a, 0xb1, 0xa8, 0x8a, 0xff, 0x3f, 0x0e, 0x79, 0xa8, 0x8a, 0xff, 0x3f, 0x8a, 0x00, 0xa8, 0x8a, 0xff, 0x3f, 0x95, 0x03, 0xa8, 0x8a, 0xff, 0x3f, 0x0a, 0x99, 0xa8, 0x0a, 0x5f, 0x1f, 0x0e, 0x21, 0xa9, 0x0a, 0x4e, 0x0e, 0x0a, 0xdf, 0xa8, 0x0a, 0xe0, 0x00, 0x0e, 0x0e, 0xa8, 0x0a, 0xf0, 0x01, 0x0e, 0x02, 0xe8, 0x0e, 0x00, 0x00, 0x0a, 0x02, 0xbc, 0x3b, 0x00, 0x00, 0x0a, 0x06, 0xeb, 0x2e, 0x00, 0x00, 0x0e, 0xfc, 0xbf, 0x3b, 0x00, 0x00, 0x9e, 0x03, 0x00, 0xf8, 0x01, 0x00, 0xb1, 0x6d, 0xdb, 0x06, 0x07, 0x00, 0x7e, 0x02, 0x00, 0x74, 0x19, 0x00, 0xd9, 0xff, 0xff, 0x77, 0xed, 0x00, 0xce, 0xb4, 0xbb, 0x27, 0x67, 0x01, 0x55, 0xf9, 0xee, 0x06, 0x33, 0x07, 0x32, 0xb0, 0xfb, 0x77, 0x99, 0x09, 0x39, 0xfe, 0xbf, 0x77, 0xcd, 0x3c, 0x4d, 0x26, 0xa8, 0x24, 0x67, 0x66, 0xe6, 0x4a, 0x72, 0x06, 0x31, 0x3f, 0xb3, 0xf1, 0xac, 0x75, 0xdd, 0x13, 0x98, 0xb1, 0x71, 0x74, 0xb7, 0x2c, 0xef, 0xd2, 0xdb, 0x24, 0x89, 0x21, 0xa0, 0xf6, 0x04, 0x04, 0x27, 0x33, 0x7c, 0x3e, 0xf9, 0xff, 0x89, 0x2d, 0x26, 0x4e, 0x5a, 0xd5, 0x22, 0x21, 0x92, 0x93, 0xae, 0xea, 0x88, 0x33, 0xcb, 0xa4, 0xdb, 0x5d, 0x22, 0x2d, 0x67, 0xc9, 0xe8, 0xae, 0x98, 0x21, 0x70, 0x32, 0x5a, 0x35, 0xb2, 0x72, 0xbf, 0x8c, 0xa8, 0x9a, 0x9c, 0x3c, 0x38, 0x25, 0xfa, 0x2f, 0xa4, 0x31, 0x4c, 0xda, 0x99, 0x0c, 0x57, 0x3a, 0x9c, 0x4f, 0x69, 0x4b, 0xf9, 0x1c, 0x38, 0x9f, 0xd2, 0x96, 0xf2, 0x39, 0x5c, 0xea, 0x30, 0x99, 0x5b, 0x32, 0x8c, 0x25, 0xf4, 0x5f, 0xa4, 0x1c, 0x3c, 0x39, 0x59, 0x15, 0x31, 0xfd, 0x4e, 0x4d, 0xac, 0x5a, 0x4c, 0x0e, 0x84, 0x19, 0x75, 0x17, 0x93, 0xe6, 0xb4, 0x44, 0xba, 0xdb, 0x25, 0xd3, 0xcc, 0x11, 0x57, 0x75, 0xc9, 0x49, 0x84, 0x44, 0xab, 0x5a, 0x72, 0x64, 0xb4, 0x91, 0xff, 0x9f, 0x7c, 0x3e, 0xcc, 0xe4, 0x20, 0x20, 0x6f, 0x05, 0x84, 0x91, 0x24, 0xdb, 0x4b, 0xf7, 0x34, 0xed, 0x2e, 0x8e, 0x8d, 0x19, 0xc8, 0xbb, 0xae, 0x35, 0x8f, 0xcd, 0xfc, 0x8c, 0x60, 0x4e, 0x52, 0x67, 0x66, 0xe6, 0x24, 0x15, 0x64, 0xb2, 0x3c, 0xb3, 0xee, 0xfd, 0x7f, 0x9c, 0x90, 0x99, 0xee, 0xdf, 0x0d, 0x4c, 0xe0, 0xcc, 0x60, 0x77, 0x9f, 0xaa, 0x80, 0xe6, 0xe4, 0xdd, 0x2d, 0x73, 0x00, 0xb7, 0xee, 0xff, 0xff, 0x9b, 0x00, 0x98, 0x2e, 0x00, 0x40, 0x7e, 0x00, 0xe0, 0x60, 0xdb, 0xb6, 0x8d, 0x00, 0x80, 0x1f, 0x00, 0xc0, 0x79, 0x00, 0x00, 0xdc, 0xfd, 0x3f, 0x70, 0x00, 0x00, 0x74, 0xd7, 0x60, 0x50, 0x00, 0x00, 0xdc, 0x3d, 0x40, 0x50, 0x00, 0x00, 0x70, 0x17, 0x40, 0x70, 0x80, 0x0f, 0x50, 0x15, 0x70, 0x70, 0x00, 0x07, 0x50, 0x15, 0xfb, 0x50, 0x70, 0x72, 0x50, 0x95, 0x84, 0x70, 0xf8, 0xfa, 0x50, 0x15, 0x99, 0x50, 0xfc, 0xff, 0x51, 0x15, 0xc0, 0xa9, 0xfc, 0xff, 0x51, 0x15, 0x00, 0x51, 0xfc, 0xff, 0x51, 0x15, 0x9e, 0x70, 0xfc, 0xff, 0x51, 0x15, 0x8d, 0x50, 0xf8, 0xff, 0x50, 0x15, 0x9e, 0x70, 0xf8, 0xff, 0x50, 0xd5, 0x90, 0x70, 0xf0, 0x7f, 0x50, 0x15, 0x8f, 0x50, 0xe0, 0x3f, 0x50, 0x15, 0x80, 0x50, 0xc0, 0x1f, 0xf0, 0xff, 0xff, 0x70, 0x80, 0x0f, 0xf0, 0xff, 0xff, 0x71, 0x80, 0x0f, 0xb8, 0xeb, 0xae, 0x53, 0x00, 0x07, 0x5c, 0x77, 0x5d, 0x27, 0x00, 0x07, 0xae, 0xeb, 0xae, 0x0e, 0x00, 0x02, 0x57, 0x77, 0x5d, 0x1d}; kgames-2.2/Xkw/laygram.y000066400000000000000000000151651416764561500152520ustar00rootroot00000000000000%{ #include #include #include #include #include #include #include #include #include "LayoutP.h" static LayoutPtr *dest; int LayYYwrap (void); void LayYYerror(char *s); %} %union { int ival; XrmQuark qval; BoxPtr bval; BoxParamsPtr pval; GlueRec gval; LayoutDirection lval; ExprPtr eval; Operator oval; } %type box boxes compositebox %type bothparams oneparams %type glue opStretch opShrink %type orientation %type signedExpr simpleExpr expr exprList %token OC CC OA CA OP CP %token NAME %token NUMBER %token INFINITY %token VERTICAL HORIZONTAL OVERLAY %token EQUAL DOLLAR COMMA %nonassoc MIN MAX %left PLUS MINUS %left TIMES DIVIDE PERCENTOF %right PERCENT %nonassoc WIDTH HEIGHT %right UMINUS UPLUS %% layout : compositebox { *dest = $1; } ; box : NAME bothparams { BoxPtr box = New(BoxRec); box->nextSibling = 0; box->type = WidgetBox; box->params = *$2; Dispose ($2); box->u.widget.quark = $1; box->u.widget.widget = 0; $$ = box; } | signedExpr oneparams { BoxPtr box = New(BoxRec); box->nextSibling = 0; box->type = GlueBox; box->params = *$2; Dispose ($2); box->u.glue.expr[0] = $1; box->u.glue.expr[1] = 0; $$ = box; } | signedExpr COMMA signedExpr bothparams { BoxPtr box = New(BoxRec); box->nextSibling = 0; box->type = GlueBox; box->params = *$4; Dispose ($4); box->u.glue.expr[0] = $1; box->u.glue.expr[1] = $3; $$ = box; } | NAME EQUAL signedExpr { BoxPtr box = New(BoxRec); box->nextSibling = 0; box->type = VariableBox; box->u.variable.quark = $1; box->u.variable.expr = $3; ZeroGlue(box->params.stretch[LayoutHorizontal]); ZeroGlue(box->params.stretch[LayoutVertical]); ZeroGlue(box->params.shrink[LayoutHorizontal]); ZeroGlue(box->params.shrink[LayoutVertical]); $$ = box; } | compositebox { $$ = $1; } ; compositebox : orientation OC boxes CC { BoxPtr box = New(BoxRec); BoxPtr child; box->nextSibling = 0; box->parent = 0; box->type = BoxBox; box->u.box.dir = $1; box->u.box.firstChild = $3; for (child = $3; child; child = child->nextSibling) { if (child->type == GlueBox && !child->u.glue.expr[1]) { child->params.stretch[!$1].expr = 0; child->params.shrink[!$1].expr = 0; child->params.stretch[!$1].order = 100000; child->params.shrink[!$1].order = 100000; child->params.stretch[!$1].value = 1; child->params.shrink[!$1].value = 1; } child->parent = box; } $$ = box; } ; boxes : box boxes { $1->nextSibling = $2; $$ = $1; } | box { $$ = $1; } ; bothparams : OA opStretch opShrink TIMES opStretch opShrink CA { BoxParamsPtr p = New(BoxParamsRec); p->stretch[LayoutHorizontal] = $2; p->shrink[LayoutHorizontal] = $3; p->stretch[LayoutVertical] = $5; p->shrink[LayoutVertical] = $6; $$ = p; } | { BoxParamsPtr p = New(BoxParamsRec); ZeroGlue (p->stretch[LayoutHorizontal]); ZeroGlue (p->shrink[LayoutHorizontal]); ZeroGlue (p->stretch[LayoutVertical]); ZeroGlue (p->shrink[LayoutVertical]); $$ = p; } ; oneparams : OA opStretch opShrink CA { BoxParamsPtr p = New(BoxParamsRec); p->stretch[LayoutHorizontal] = $2; p->shrink[LayoutHorizontal] = $3; p->stretch[LayoutVertical] = $2; p->shrink[LayoutVertical] = $3; $$ = p; } | { BoxParamsPtr p = New(BoxParamsRec); ZeroGlue (p->stretch[LayoutHorizontal]); ZeroGlue (p->shrink[LayoutHorizontal]); ZeroGlue (p->stretch[LayoutVertical]); ZeroGlue (p->shrink[LayoutVertical]); $$ = p; } ; opStretch : PLUS glue { $$ = $2; } | { ZeroGlue ($$); } ; opShrink : MINUS glue { $$ = $2; } | { ZeroGlue ($$); } ; glue : simpleExpr INFINITY { $$.order = $2; $$.expr = $1; } | simpleExpr { $$.order = 0; $$.expr = $1; } | INFINITY { $$.order = $1; $$.expr = 0; $$.value = 1; } ; signedExpr : MINUS simpleExpr %prec UMINUS { $$ = New(ExprRec); $$->type = Unary; $$->u.unary.op = $1; $$->u.unary.down = $2; } | PLUS simpleExpr %prec UPLUS { $$ = $2; } | simpleExpr ; simpleExpr : WIDTH NAME { $$ = New(ExprRec); $$->type = Width; $$->u.width = $2; } | HEIGHT NAME { $$ = New(ExprRec); $$->type = Height; $$->u.height = $2; } | OP expr CP { $$ = $2; } | MIN OP exprList CP { ExprPtr e; e = $3; $$ = $3; while (e->type == Binary) { e->u.binary.op = $1; e = e->u.binary.right; } e->u.unary.op = $1; } | MAX OP exprList CP { ExprPtr e; e = $3; $$ = $3; while (e->type == Binary) { e->u.binary.op = $1; e = e->u.binary.right; } e->u.unary.op = $1; } | simpleExpr PERCENT { $$ = New(ExprRec); $$->type = Unary; $$->u.unary.op = $2; $$->u.unary.down = $1; } | NUMBER { $$ = New(ExprRec); $$->type = Constant; $$->u.constant = $1; } | DOLLAR NAME { $$ = New(ExprRec); $$->type = Variable; $$->u.variable = $2; } ; exprList : expr { $$ = New(ExprRec); $$->type = Unary; $$->u.unary.down = $1; } | expr COMMA exprList { $$ = New(ExprRec); $$->type = Binary; $$->u.binary.left = $1; $$->u.binary.right = $3; } expr : expr PLUS expr { binary: ; $$ = New(ExprRec); $$->type = Binary; $$->u.binary.op = $2; $$->u.binary.left = $1; $$->u.binary.right = $3; } | expr MINUS expr { goto binary; } | expr TIMES expr { goto binary; } | expr DIVIDE expr { goto binary; } | expr PERCENTOF expr { goto binary; } | MINUS expr %prec UMINUS { $$ = New(ExprRec); $$->type = Unary; $$->u.unary.op = $1; $$->u.unary.down = $2; } | PLUS expr %prec UPLUS { $$ = $2; } | simpleExpr ; orientation : VERTICAL { $$ = LayoutVertical; } | HORIZONTAL { $$ = LayoutHorizontal; } | OVERLAY { $$ = LayoutOverlay; } ; %% int LayYYwrap (void) { return 1; } void LayYYsetdest (LayoutPtr *c) { (void) LayYYwrap; dest = c; } kgames-2.2/Xkw/laylex.l000066400000000000000000000054601416764561500150740ustar00rootroot00000000000000%{ #undef input #undef unput #include #include #include #include #include #include "LayoutP.h" #include "laygram.h" static char *yysourcebase, *yysource; void yyerror(char *s); static int count (char *s, char c); static int istoken (char c, int first); #ifdef FLEX_SCANNER #define YY_INPUT(buf,result,max_size) \ { \ int c; \ result = 0; \ while (result < max_size) { \ c = *yysource; \ if (c == '\0') \ break; \ buf[result++] = c; \ yysource++; \ } \ } #else #define input() (*yysource++) #define unput(c) (--yysource) #endif %} %% vertical return VERTICAL; horizontal return HORIZONTAL; overlay return OVERLAY; "{" return OC; "}" return CC; "(" return OP; ")" return CP; "<" return OA; ">" return CA; infinity { LayYYlval.ival = 1; return INFINITY; } inff* { LayYYlval.ival = count(yytext, 'f'); return INFINITY; } [0-9][0-9]* { LayYYlval.ival = atoi(yytext); return NUMBER; } "=" { return EQUAL; } "$" { return DOLLAR; } "," { return COMMA; } "+" { LayYYlval.oval = Plus; return PLUS; } "-" { LayYYlval.oval = Minus; return MINUS; } "*" { LayYYlval.oval = Times; return TIMES; } "/" { LayYYlval.oval = Divide; return DIVIDE; } "%" { LayYYlval.oval = Percent; return PERCENT; } %[ \t\n]*of { LayYYlval.oval = Percent; return PERCENTOF; } width return WIDTH; height return HEIGHT; min { LayYYlval.oval = Minimum; return MIN; } max { LayYYlval.oval = Maximum; return MAX; } \\[a-zA-Z_][a-zA-Z0-9_]* { int i = yyleng; while (!istoken (yytext[i-1], i == 0)) i--; yytext[i] = '\0'; LayYYlval.qval = XrmStringToQuark (yytext+1); return NAME; } [a-zA-Z_][a-zA-Z0-9_]* { int i = yyleng; while (!istoken (yytext[i-1], i == 0)) i--; yytext[i] = '\0'; LayYYlval.qval = XrmStringToQuark (yytext); return NAME; } " " ; "\t" ; "\n" ; . fprintf (stderr, "ignoring %c\n", *yytext); %% static int istoken (char c, int first) { if (c == '_') return 1; if ('a' <= c && c <= 'z') return 1; if ('A' <= c && c <= 'Z') return 1; if (!first && '0' <= c && c <= '9') return 1; return 0; } static int count (char *s, char c) { int i = 0; while (*s) if (*s++ == c) i++; return i; } void LayYYsetsource(char *s) { yysourcebase = yysource = s; } void LayYYerror(char *s) { char *t; (void) input; (void) yyunput; fprintf (stderr, "%s\n", s); t = yysource - 50; if (t < yysourcebase) t = yysourcebase; while (*t && t < yysource + 50) { if (t == yysource) putc ('@', stderr); putc (*t++, stderr); } if (t == yysource) putc ('@', stderr); if (!*t) fprintf (stderr, ""); fprintf (stderr, "\n"); } kgames-2.2/Xkw/list.h000066400000000000000000000117201416764561500145410ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _Xkw_list_h #define _Xkw_list_h #include struct xkw_list { struct xkw_list *prev, *next; }; static inline void xkw_list_init(struct xkw_list *list) { list->prev = list->next = list; } /* Insert entry at head of list */ static inline void xkw_list_prepend(struct xkw_list *entry, struct xkw_list *head) { struct xkw_list *next = head->next; entry->next = next; entry->prev = head; head->next = entry; next->prev = entry; } /* append entry to end of list */ static inline void xkw_list_append(struct xkw_list *entry, struct xkw_list *head) { struct xkw_list *prev = head->prev; entry->prev = prev; entry->next = head; head->prev = entry; prev->next = entry; } /* remove entry from list */ static inline void xkw_list_del(struct xkw_list *entry) { struct xkw_list *prev = entry->prev; struct xkw_list *next = entry->next; prev->next = next; next->prev = prev; xkw_list_init(entry); } /* check whether list is empty */ static inline bool xkw_list_is_empty(struct xkw_list *head) { return head->next == head; } /* cut a range of entries from list, saving them to a new list */ static inline void xkw_list_cut(struct xkw_list *first, struct xkw_list *last, struct xkw_list *new) { struct xkw_list *prev = first->prev; struct xkw_list *next = last->next; /* patch original list back together */ prev->next = next; next->prev = prev; /* build new list */ new->next = first; new->prev = last; first->prev = new; last->next = new; } /* paste one list into another after the specified element */ static inline void xkw_list_paste(struct xkw_list *head, struct xkw_list *prev) { if (xkw_list_is_empty(head)) return; struct xkw_list *first = head->next; struct xkw_list *last = head->prev; struct xkw_list *next = prev->next; prev->next = first; next->prev = last; first->prev = prev; last->next = next; xkw_list_init(head); } /* return first entry of list, NULL if empty */ static inline struct xkw_list * xkw_list_first(struct xkw_list *head) { if (xkw_list_is_empty(head)) return NULL; return head->next; } /* return last entry of list, NULL if empty */ static inline struct xkw_list * xkw_list_last(struct xkw_list *head) { if (xkw_list_is_empty(head)) return NULL; return head->prev; } #define container_of(ptr, type, member) ((type *)((char *) (ptr) - offsetof(type, member))) #define xkw_foreach_startat(pos, start, head, member) \ for (struct xkw_list *__tmp = (pos = (start))->member.next; \ &(pos)->member != (head); \ (pos) = container_of(__tmp, typeof(*pos), member), \ __tmp = __tmp->next) #define xkw_foreach(pos, head, member) \ xkw_foreach_startat(pos, container_of((head)->next, typeof(*pos), member), head, member) #define xkw_foreach_startat_rev(pos, start, head, member) \ for (struct xkw_list *__tmp = (pos = (start))->member.prev; \ &(pos)->member != (head); \ (pos) = container_of(__tmp, typeof(*pos), member), \ __tmp = __tmp->prev) #define xkw_foreach_rev(pos, head, member) \ xkw_foreach_startat_rev(pos, container_of((head)->prev, typeof(*pos), member), head, member) #define xkw_first(type, head, member) \ xkw_list_is_empty(head) ? NULL : container_of((head)->next, type, member) #define xkw_last(type, head, member) \ xkw_list_is_empty(head) ? NULL : container_of((head)->prev, type, member) #define xkw_prev(pos, member) \ container_of((pos)->member.prev, typeof(*pos), member) #define xkw_next(pos, member) \ container_of((pos)->member.next, typeof(*pos), member) #endif /* _Xkw_list_h */ kgames-2.2/Xkw/lodemo.c000066400000000000000000000027371416764561500150500ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include #include #include #include #include "Layout.h" #include "Cards.h" int main (int argc, char **argv) { XtAppContext xtcontext; Widget toplevel, layout, label, cards; CardsCardRec card[10]; toplevel = XtAppInitialize(&xtcontext, "Layout", NULL, 0, &argc, argv, NULL, NULL, 0); layout = XtCreateManagedWidget ("layout", layoutWidgetClass, toplevel, NULL, 0); label = XtCreateManagedWidget ("label1", labelWidgetClass, layout, NULL, 0); label = XtCreateManagedWidget ("label2", labelWidgetClass, layout, NULL, 0); label = XtCreateManagedWidget ("label3", labelWidgetClass, layout, NULL, 0); (void) label; cards = XtCreateManagedWidget ("cards", cardsWidgetClass, layout, NULL, 0); card[0].rank = CardsAce; card[0].suit = CardsHeart; card[1].rank = CardsKing; card[1].suit = CardsClub; card[2].rank = CardsAce; card[2].suit = CardsBack; card[3].rank = CardsAce; card[3].suit = CardsEmpty; CardsAddCard (cards, &card[0], 0, 0); CardsAddCard (cards, &card[1], 0, 1); CardsAddCard (cards, &card[2], 1, 0); CardsAddCard (cards, &card[3], 1, 1); XtRealizeWidget (toplevel); XtAppMainLoop (xtcontext); } kgames-2.2/Xkw/make-cards-svg000077500000000000000000000017651416764561500161570ustar00rootroot00000000000000#!/bin/bash dir=`dirname $0` case $# in 2) ;; *) echo "usage: $0 cards.c cards.h" exit 1 ;; esac ( echo '#include "'"$2"'"' for suit in C D H S; do for rank in A 2 3 4 5 6 7 8 9 T J Q K; do file="$dir"/cards/"$rank""$suit".svg echo "const char svg_card_$rank$suit[]" = sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/ "/' -e 's/$/\\n"/' "$file" echo " ;"; echo "" done done file="$dir"/cards/kgames.svg echo "const char svg_card_game[]" = sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/ "/' -e 's/$/\\n"/' "$file" echo " ;"; echo "" echo "const char *const svg_cards[52] = {" for suit in C D H S; do for rank in A 2 3 4 5 6 7 8 9 T J Q K; do echo " svg_card_$rank$suit,"; done done echo "};" echo "" ) > "$1" ( echo '#define svg_card_width 270' echo '#define svg_card_height 420' echo "extern const char *const svg_cards[52];" echo "extern const char svg_card_game[];" ) > "$2" kgames-2.2/Xkw/make-resource000077500000000000000000000005531416764561500161070ustar00rootroot00000000000000#!/bin/bash case $# in 2) ;; *) echo "usage: $0 cards.c cards.h" exit 1 ;; esac input="$1" output="$2" ( echo 'static const char *const defaultResources[] = {' sed -e 's/^[ \t]*//' -e 's/\\n/\\\\n/g' -e 's/"/\\"/g' -e 's/\([^\\]\)$/\1",/' -e 's/^$/"/' -e 's/\\$/"/' -e 's/^/ "/' "$input" echo " 0," echo '};' ) > "$output" kgames-2.2/Xkw/medium.c000066400000000000000000000005311416764561500150370ustar00rootroot00000000000000#include "medium.xpm" const char *const *const medium_xpm[] = { _1c, _2c, _3c, _4c, _5c, _6c, _7c, _8c, _9c, _tc, _jc, _qc, _kc, _1d, _2d, _3d, _4d, _5d, _6d, _7d, _8d, _9d, _td, _jd, _qd, _kd, _1h, _2h, _3h, _4h, _5h, _6h, _7h, _8h, _9h, _th, _jh, _qh, _kh, _1s, _2s, _3s, _4s, _5s, _6s, _7s, _8s, _9s, _ts, _js, _qs, _ks, }; kgames-2.2/Xkw/medium.xpm000066400000000000000000013552041416764561500154340ustar00rootroot00000000000000/* XPM */ static const char * const _1c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa``a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa``a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa````aaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa````aaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaa````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaa````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _1d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`baaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`baaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _1h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _1s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa``a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa``a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``aaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`a````aaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`a````aaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````a````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````a`a````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa````a```a````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````a`````a````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa````a```````a````aaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaa````a````a````a````aaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaa````a````a`a````a````aaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaa````a````a```a````a````aaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaa````a````a``a``a````a````aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaa````a````a``a`a``a````a````aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa````a````a``a```a``a````a````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa````a````a```a```a```a````a````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa````a````a`````a`a`````a````a````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa````a``````a`````a`````a``````a````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```a````````a```a`a```a````````a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa````a```a`````a`a```a`a`````a```a````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a`````a``a``a``a``a``a``a`````a```aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a`````a````a`a```a`a````a`````a```aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a````aa````a```a`a```a````aa````a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a`````a`````a`````a`````a```a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a````a`````````````a````a```a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```a`````a```a`````a```a```a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a````aaa`````a`a`a`a`````aaa````a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```````````a```a```a```````````a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a``````````a`````````a``````````a```aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa````a````````a```````````a````````a````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```aa`````aa````a```a````aa`````aa```aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````aaaaa`````aa```aa`````aaaaa`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa`````````````aaa```aaa`````````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````````aaa`````aaa```````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```````aaaaa`````aaaaa```````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaa````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaa````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _2c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa```aaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```aa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aa```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaa```aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _2d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabbaabbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbaabbaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _2h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabbaabbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbaabbaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _2s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa```aaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```aa``aaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaa``aa```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaa```aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _3c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa``````aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa`````aaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaa`````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa``````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _3d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaaabbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbaaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _3h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaaabbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbaaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _3s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa``````aaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaa``````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _4c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaa````aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaa````aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa````aaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa````aaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa```aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _4d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbaaaabbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbaaaabbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaabbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _4h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaabbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaabbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _4s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaa````aaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaa````aaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaa````aaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaa````aaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa```aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _5c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _5d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbaabbbaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaabbbaabbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _5h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _5s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa``aaa``aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa``aaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aa```````aaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaa`````aaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _6c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _6d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _6h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _6s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _7c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````aaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaaa```````````````aaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaa``aaaaa`", "`aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _7d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbaabbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbaabbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbaabbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _7h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbaabbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbaabbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbaabbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _7s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa``aaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaa``aaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaa`````aaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaa``aaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _8c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _8d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaabbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _8h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbaabbbaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _8s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _9c[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaa``````aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaa```aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa````aaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaa```aaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaa`````aaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aa```````aa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaa```````aaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaa```````aaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaa```a```a```aaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaa`````a`a`````aaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaa```aa`aa```aaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaa```aaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaa`````aaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaa````aaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa```aaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``````aaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _9d[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbaaabbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaaaaabbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaabbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaabbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _9h[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaabbbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbaaaaaabbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbaabbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbaaaabbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbaaaabbbaaaabbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbaaaaaabaaaaaabbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbaaaaaaabaaaaaaabbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbaaaaaaaaaaaaabbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbaaaaaaaaaaaaabbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbaaaaaaaaaaabbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbaaaaaaaaabbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbaaaaaaabbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbaaaaabbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbaaabbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbabbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbaaaabbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaabbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbaabbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbaaaaaabbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbbaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _9s[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``aaa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```````aaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaa``````aaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaa``aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaa```aaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaa`````aaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaa````aaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaa`aaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaa```aaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaa`````aaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaa```````aaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaa`````````aaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaa```````````aaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaa```aaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````aaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaa````aaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaa```aaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa``aaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaa``````aaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aaa``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _jc[] = { /* width height ncolors chars_per_pixel */ "71 96 6 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #00FF00", "c c #FF0000", "d c #FFFFFF", "e c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddd````dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddd````dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`dddddd``ddd```````````````````````````````````````````````ddddddddddd`", "`dd``dd``ddd`dddddddd``cc`ccc`c`cc`c`ccc`c`ddddddddddddddd`ddddddddddd`", "`dd``dd``ddd``dddddddd``cc`cc`c`cc`c`cc`c`dddddd```ddddddd`ddddddddddd`", "`dd``````ddd`c`ddddddd```cc```c````c```c`dddddd`````dddddd`ddddddddddd`", "`ddd````dddd`cc`ddddd`bb`cccccccccccccc``ddddd```````ddddd`ddddddddddd`", "`ddddddddddd`ccc`dddd`b`````````````````dddddd```````ddddd`ddddddddddd`", "`ddddddddddd``````dddbb``dddddddd`e`e`e`dddddd```````ddddd`ddddddddddd`", "`dddd```dddd`eee`ddd`bb``dddddddd`e`e`e`ddddddd`````dddddd`ddddddddddd`", "`ddd`````ddd``ee`ddd```e````d```d`e`e`e`dddd```d```d```ddd`ddddddddddd`", "`ddd`````ddd`eee`ddddd`e```d```d``e`e`e`ddd`````````````dd`ddddddddddd`", "`dd`d```d`dd``ee`ddddd`e`ddd`dddd`e`e`e`dd```````````````d`ddddddddddd`", "`d`````````d`eee`dddd``e`ddd`dddd`e`e`e`dd```````````````d`ddddddddddd`", "`d`````````d``ee`ddd`e`e`ddd`dddd`e`e`e`dd```````````````d`ddddddddddd`", "`d`````````d`eee`ddd`e`e`dd```ddd`e`e`e``dd`````d`d`````dd`ddddddddddd`", "`dd``d`d``dd```e`ddd```e`dddddddd`e`e``ee`dd```dd`dd```ddd`ddddddddddd`", "`dddda`adddd`eee`dd`ee`ed`d```ddd`e```ee``dddddd```ddddddd`ddddddddddd`", "`dddd```dddd```e`dd`e`ee``dddddd``e`ee``````ddd`````dddddd`ddddddddddd`", "`ddddddddddd`eee`dd`eee``c`dddd`c`e``e```d`d`ddddddddddddd`ddddddddddd`", "`ddddddddddd`eee``dd```c`cc````ccc`eee``d``dc``dddddddddd``ddddddddddd`", "`ddddddddddd``e`dd``c`c``cccc``ccc```````e`dccc``ddddddd`e`ddddddddddd`", "`ddddddddddd`d`dddd``c`c`ceec```c``dd``d`e`dccecd``dddd`ee`ddddddddddd`", "`ddddddddddd``````d`c`c``cccc`d```dd``d`ee`dceeecd`````eee`ddddddddddd`", "`ddddddddddd`dd``dd``c`c`ceec`dd`dd``d`eee`deeceed`````eee`ddddddddddd`", "`ddddddddddd```e`dd`c`c``cccc``ddd``d`ee```dceeecd`````eee`ddddddddddd`", "`ddddddddddd`d`e`dd``c`c`ceec```d``dc`eeee`dcceccd`````eee`ddddddddddd`", "`ddddddddddd``ee`dd`c`c``cccc`d```dc`ee````dcccccd`````eee`ddddddddddd`", "`ddddddddddd`d`e`d`c`c```ceec``d`d``eeeeee`dcceccd`````eee`ddddddddddd`", "`ddddddddddd``ee````c````cccc`c`d`c`e`e````dceeecd`````eee`ddddddddddd`", "`ddddddddddd`eee````````ceec`e`c`c`eeeeeee`deeceed`````eee`ddddddddddd`", "`ddddddddddd`eee``d```d`cccc``e`c`e`e``````dceeec```cc`eee`ddddddddddd`", "`ddddddddddd`eee`ddd`dd`ceec`eee`eeeeeeeee`dccecc`ccee`eee`ddddddddddd`", "`ddddddddddd`eee`d`ddd``cccc````ee`e```````d````cccccc`eee`ddddddddddd`", "`ddddddddddd`eee``d`d`d`ceec`eeeeeeeeeeeee``dd`cceeccc`eee`ddddddddddd`", "`ddddddddddd`eee`d`d`d``cccc``ec`e```e`ce`ddd`cccccc```eee`ddddddddddd`", "`ddddddddddd`eee``d`d`dceec`eee`c`ddd`c``dddd`ceecc``d`eee`ddddddddddd`", "`ddddddddddd`eee`d`d`d`cccc``eee`d```d`ddddd`ccccc`d`d`eee`ddddddddddd`", "`ddddddddddd`eee``d`d``ceec`e```d`ccc`d`ddd``ceec`d`d``eee`ddddddddddd`", "`ddddddddddd`eee``````ceec```dd`d`ccc`d``ee`ceec```````eee`ddddddddddd`", "`ddddddddddd`eee`d`d`ccccc`dddd``d```d`eee``cccc`d`d`d`eee`ddddddddddd`", "`ddddddddddd`eee`d``cceec`dddd``c`ddd`c`eee`ceecd`d`d``eee`ddddddddddd`", "`ddddddddddd`eee```cccccc`ddd`ec`e```e`ce``cccc``d`d`d`eee`ddddddddddd`", "`ddddddddddd`eee`ccceecc`ddd`eeeeeeeeeeeee`ceec`d`d`d``eee`ddddddddddd`", "`ddddddddddd`eee`cccccc````````````e`ee````cccc``ddd`d`eee`ddddddddddd`", "`ddddddddddd`eee`eecc`cceccd`eeeeeeeee`eee`ceec`dd`ddd`eee`ddddddddddd`", "`ddddddddddd`eee`cc```ceeecd``````e`e`c`e``cccc`d```d``eee`ddddddddddd`", "`ddddddddddd`eee`````deeceed`eeeeeee`c`c`e`ceec````````eee`ddddddddddd`", "`ddddddddddd`eee`````dceeecd````e`e`c`d`c`cccc````c````ee``ddddddddddd`", "`ddddddddddd`eee`````dcceccd`eeeeee``d`d``ceec```c`c`d`e`d`ddddddddddd`", "`ddddddddddd`eee`````dcccccd````ee`cd```d`cccc``c`c`dd`ee``ddddddddddd`", "`ddddddddddd`eee`````dcceccd`eeee`cd``d```ceec`c`c``dd`e`d`ddddddddddd`", "`ddddddddddd`eee`````dceeecd```ee`d``ddd``cccc``c`c`dd`e```ddddddddddd`", "`ddddddddddd`eee`````deeceed`eee`d``dd`dd`ceec`c`c``dd``dd`ddddddddddd`", "`ddddddddddd`eee`````dceeecd`ee`d``dd```d`cccc``c`c`d``````ddddddddddd`", "`ddddddddddd`ee`dddd``dceccd`e````dd``c```ceec`c`c``dddd`d`ddddddddddd`", "`ddddddddddd`e`ddddddd``cccd`e```````ccc``cccc``c`c``dd`e``ddddddddddd`", "`ddddddddddd``dddddddddd``cd``d``eee`ccc````cc`c```dd``eee`ddddddddddd`", "`ddddddddddd`ddddddddddddd`d`d```e``e`c`dddd`c``eee`dd`eee`ddddddddddd`", "`ddddddddddd`dddddd`````ddd``````ee`e``dddddd``ee`e`dd`e```dddd```dddd`", "`ddddddddddd`ddddddd```dddddd``ee```e`ddd```d`de`ee`dd`eee`ddddd`ddddd`", "`ddddddddddd`ddd```dd`dd```dd`ee``e`e`dddddddd`e```ddd`e```dd``d`d``dd`", "`ddddddddddd`dd`````d`d`````dd``e`e`e`ddd```dd`e`e`ddd`eee`d`````````d`", "`ddddddddddd`d```````````````dd`e`e`e`dddd`ddd`e`e`ddd`ee``d`````````d`", "`ddddddddddd`d```````````````dd`e`e`e`dddd`ddd`e``dddd`eee`d`````````d`", "`ddddddddddd`d```````````````dd`e`e`e`dddd`ddd`e`ddddd`ee``dd`d```d`dd`", "`ddddddddddd`dd`````````````ddd`e`e`e``d```d```e`ddddd`eee`ddd`````ddd`", "`ddddddddddd`ddd```d```d```dddd`e`e`e`d```d````e```ddd`ee``ddd`````ddd`", "`ddddddddddd`dddddd`````ddddddd`e`e`e`dddddddd``bb`ddd`eee`dddd```dddd`", "`ddddddddddd`ddddd```````dddddd`e`e`e`dddddddd``bbddd``````ddddddddddd`", "`ddddddddddd`ddddd```````dddddd`````````````````b`dddd`ccc`ddddddddddd`", "`ddddddddddd`ddddd```````ddddd``cccccccccccccc`bb`ddddd`cc`dddd````ddd`", "`ddddddddddd`dddddd`````dddddd`c```c````c```cc```ddddddd`c`ddd``````dd`", "`ddddddddddd`ddddddd```dddddd`c`cc`c`cc`c`cc`cc``dddddddd``ddd``dd``dd`", "`ddddddddddd`ddddddddddddddd`c`ccc`c`cc`c`ccc`cc``dddddddd`ddd``dd``dd`", "`ddddddddddd```````````````````````````````````````````````ddd``dddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd``dddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd``dddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd``dddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd``dddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd``dddddd`", "`dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd````ddddd`", "`dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd````ddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "`ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _jd[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccc```````````````````````````````````````````````ccccccccccc`", "`ccbbccbbccc`ccccccccc`bcbbbcbbcbbcbbcbbcb``cccccccccccccc`ccccccccccc`", "`ccbbccbbccc`cccccccccc`bcbbcbbcbbcbbcbcb``cccccccbccccccc`ccccccccccc`", "`ccbbbbbbccc`ccccccccccc`bcccbbccccbbccb``cccccccbbbcccccc`ccccccccccc`", "`cccbbbbcccc``ccccccccccc`bbbbbbbbbbbbbb`cccccccbbbbbccccc`ccccccccccc`", "`ccccccccccc```cccccccccc````````````````ccccccabbbbbacccc`ccccccccccc`", "`ccccccccccc``d`ccccccccc`````d`cccccccc``ccccabbbbbbbaccc`ccccccccccc`", "`cccccbccccc``d`ccccccccc```d`d`cccccccc``ccccabbbbbbbaccc`ccccccccccc`", "`ccccbbbcccc``d`ccccccccc`d`d`d`c```c````d`ccbbbbbbbbbbbcc`ccccccccccc`", "`cccabbbaccc``d`cccc`cccc`d`d`d``c```c```d`cbbbbbbbbbbbbbc`ccccccccccc`", "`ccabbbbbacc``d`ccc``cccc`d`d`d`cccc`ccc`d`ccbbbbbbbbbbbcc`ccccccccccc`", "`ccbbbbbbbcc``d`c``d`cccc`d`d`d`cccc`ccc`d`cccabbbbbbbaccc`ccccccccccc`", "`ccabbbbbacc`````dd`ccccc`d`d`d`cccc`ccc`d`cccabbbbbbbaccc`ccccccccccc`", "`cccabbbaccc`bddd```ccccc`d`d`d`ccc```cc`d`ccccabbbbbacccc`ccccccccccc`", "`ccccbbbcccc``d````cccccc`d`d`d`cccccccc`d```cccbbbbbccccc`ccccccccccc`", "`cccccbccccc`bd``cccccc``dd`d`d`ccc```c`cd`dd`cccbbbcccccc`ccccccccccc`", "`ccccccccccc``d`cccccc`dd`d`d`d``cccccc``dd`d`ccccbccccccc`ccccccccccc`", "`ccccccccccc`bd`cccccc`d``d``d`bc`cccc`cb`ddd`ccccccccccc``ccccccccccc`", "`ccccccccccc``d`cccccc`ddd`dd`bbbb````bbbb`````ccccccccc`b`ccccccccccc`", "`ccccccccccc`bd`cccccc````````bbbbbbbbbbb``c`d```cccccc`d``ccccccccccc`", "`ccccccccccc``d`cccc``b```c`````bbbbbbb``````d`c```cccc`db`ccccccccccc`", "`ccccccccccc`bd`cc```d`b````c`````````````c``d```dd``cc`d``ccccccccccc`", "`ccccccccccc``d```````d`b`````c`````````c````d`c`dd`b```db`ccccccccccc`", "`ccccccccccc`bd````````d`b``````c`c`c`c```b``d````d`bbb`d``ccccccccccc`", "`ccccccccccc``d```b`````d`b`````````````b`b``dd`c`dd``b`db`ccccccccccc`", "`ccccccccccc````c``b`````d`b``b`b`b`b`b`b`b`c`d````ddd``d``ccccccccccc`", "`ccccccccccc`cc`c`d`b`````d`b``bdbdbdbdbdbd`c`dd`c```dd`db`ccccccccccc`", "`ccccccccccc````c``d`b`````d`b``b`b`b`b`b`b`c``dd``c````d``ccccccccccc`", "`ccccccccccc`cc```d`d`b`````d`b```b`b`b`b`b`c```ddd```c`db`ccccccccccc`", "`ccccccccccc````bb`d```d`````d`b``b`b`b`b`b`c``c``ddd```d``ccccccccccc`", "`ccccccccccc`c``cb`d`dd`b`````d`b``bdbdbdbd`c``c`c``ddd`db`ccccccccccc`", "`ccccccccccc``d`bbb`d```bd`````d`b``b`b`b`b`c``c``d`````d``ccccccccccc`", "`ccccccccccc``d`ccb`d`d`bdb`````d`b```b`b`b`c``c````d`b`db`ccccccccccc`", "`ccccccccccc`bd`bbb`d```bdbd``c``d`b``b`b`b`c``c`dd`d`c`d``ccccccccccc`", "`ccccccccccc``d`ccb`d`d`bdb``````bd`b``bdbd````c```d`bb`db`ccccccccccc`", "`ccccccccccc`bd`bbb`d```bd``c```dbbd`b``b`b`````dd`d`bc`d``ccccccccccc`", "`ccccccccccc``d`ccb`d`d`b``````b`dbbd`b``b``c`````d`bbb`db`ccccccccccc`", "`ccccccccccc`bd`bbb`d`````c`````b`dbbd`b``````b`d`d`bcc`d``ccccccccccc`", "`ccccccccccc``d`cb`d`d``````b`b``b`dbbd```c``db```d`bbb`db`ccccccccccc`", "`ccccccccccc`bd`bb`d```c````dbdb``b`db``````bdb`d`d`bcc`d``ccccccccccc`", "`ccccccccccc``d`c`d`dd`c``c`b`b`b``b`d``c``dbdb```d`bbb`db`ccccccccccc`", "`ccccccccccc`bd`b`d````c``c`b`b`b```b`d`````bdb`d`d`bcc`d``ccccccccccc`", "`ccccccccccc``d`````d``c``c`b`b`b`b``b`d`````db```d`bbb`d``ccccccccccc`", "`ccccccccccc`bd`ddd``c`c``c`dbdbdbdb``b`d`````b`dd`d`bc``c`ccccccccccc`", "`ccccccccccc``d```ddd``c``c`b`b`b`b`b``b`d`````d```d`bb````ccccccccccc`", "`ccccccccccc`bd`c```ddd```c`b`b`b`b`b```b`d`````b`d`d```cc`ccccccccccc`", "`ccccccccccc``d````c``dd``c`b`b`b`b`b`b``b`d`````b`d``c````ccccccccccc`", "`ccccccccccc`bd`dd```c`dd`c`dbdbdbdbdbdb``b`d`````b`d`c`cc`ccccccccccc`", "`ccccccccccc``d``ddd````d`c`b`b`b`b`b`b`b``b`d`````b``c````ccccccccccc`", "`ccccccccccc`bd`b``dd`c`dd``b`b`````````````b`d`````b```d``ccccccccccc`", "`ccccccccccc``d`bbb`d````d``b```c`c`c`c``````b`d````````db`ccccccccccc`", "`ccccccccccc`bd```b`dd`c`d````c`````````c`````b`d```````d``ccccccccccc`", "`ccccccccccc``d`cc``dd```d``c`````````````c````b`d```cc`db`ccccccccccc`", "`ccccccccccc`bd`cccc```c`d``````bbbbbbb`````c```b``cccc`d``ccccccccccc`", "`ccccccccccc``d`cccccc```d`c``bbbbbbbbbbb````````cccccc`db`ccccccccccc`", "`ccccccccccc`b`ccccccccc`````bbbb````bbbb`dd`ddd`cccccc`d``ccccccccccc`", "`ccccccccccc``ccccccccccc`ddd`bc`cccc`cb`d``d``d`cccccc`db`ccccccccccc`", "`ccccccccccc`cccccccbcccc`d`dd``cccccc``d`d`d`dd`cccccc`d``ccccccccccc`", "`ccccccccccc`ccccccbbbccc`dd`dc`c```ccc`d`d`dd``cccccc``db`cccccbccccc`", "`ccccccccccc`cccccbbbbbccc```d`cccccccc`d`d`d`cccccc````d``ccccbbbcccc`", "`ccccccccccc`ccccabbbbbacccc`d`cc```ccc`d`d`d`ccccc```dddb`cccabbbaccc`", "`ccccccccccc`cccabbbbbbbaccc`d`ccc`cccc`d`d`d`ccccc`dd`````ccabbbbbacc`", "`ccccccccccc`cccabbbbbbbaccc`d`ccc`cccc`d`d`d`cccc`d``c`d``ccbbbbbbbcc`", "`ccccccccccc`ccbbbbbbbbbbbcc`d`ccc`cccc`d`d`d`cccc``ccc`d``ccabbbbbacc`", "`ccccccccccc`cbbbbbbbbbbbbbc`d```c```c``d`d`d`cccc`cccc`d``cccabbbaccc`", "`ccccccccccc`ccbbbbbbbbbbbcc`d````c```c`d`d`d`ccccccccc`d``ccccbbbcccc`", "`ccccccccccc`cccabbbbbbbacccc``cccccccc`d`d```ccccccccc`d``cccccbccccc`", "`ccccccccccc`cccabbbbbbbacccc``cccccccc`d`````ccccccccc`d``ccccccccccc`", "`ccccccccccc`ccccabbbbbacccccc````````````````cccccccccc```ccccccccccc`", "`ccccccccccc`cccccbbbbbccccccc`bbbbbbbbbbbbbb`ccccccccccc``ccccbbbbccc`", "`ccccccccccc`ccccccbbbccccccc``bccbbccccbbcccb`ccccccccccc`cccbbbbbbcc`", "`ccccccccccc`cccccccbccccccc``bcbcbbcbbcbbcbbcb`cccccccccc`cccbbccbbcc`", "`ccccccccccc`cccccccccccccc``bcbbcbbcbbcbbcbbbcb`ccccccccc`cccbbccbbcc`", "`ccccccccccc```````````````````````````````````````````````cccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _jh[] = { /* width height ncolors chars_per_pixel */ "71 96 6 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", "e c #0000FF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccbbccc```````````````````````````````````````````````ccccccccccc`", "`ccbbccbbccc`ccccccccc`bbcbbbcbcbbcbcbbbcb`ccccccccccccccc`ccccccccccc`", "`ccbbccbbccc``cc```cccc`bbcbbcbcbbcbcbbcb`ccbbbacccabbbccc`ccccccccccc`", "`ccbbbbbbccc`b`cc`d`cccc`bbcccbccccbcccb``cbbbbbacabbbbbcc`ccccccccccc`", "`cccbbbbcccc`b`cc`dd`ccc`bbbbbbbbbbbbbb``cbbbbbbbcbbbbbbbc`ccccccccccc`", "`ccccccccccc`b`cc`dd`ccc`````````````````cbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccccccccccc`````c`dd`ccc`d`d`d`d`ccccc`ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccbbacabbcc`cbcbcc`d`ccc`d`d`d`d`cc``c`ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`cbbbbcbbbbc`cbcbccc``cc`d`d`d`d`c``c`c`ccabbbbbbbbbbbbbac`ccccccccccc`", "`cbbbbbbbbbc`c`c`cc`d`cc`d`d`d`d`ccccccecccabbbbbbbbbbbacc`ccccccccccc`", "`cbbbbbbbbbc`````c`dd`cc`d`d`d`d`ccccccc`ccabbbbbbbbbbbacc`ccccccccccc`", "`cabbbbbbbac`b`cc`dd`ccc`d`d`d`d`cccccccc`ccbbbbbbbbbbaccc`ccccccccccc`", "`ccbbbbbbbcc`b`cc`dd`ccc`d`d`d`d`ccc``ce``cccbbbbbbbbbcccc`ccccccccccc`", "`cccbbbbbccc`b`cc`d`cccc`d`d`d`d`c```cc`ccccccbbbbbbbccccc`ccccccccccc`", "`ccccbbbcccc`b`c```ccc```d`d`d`d`cccccc`cccccccbbbbbcccccc`ccccccccccc`", "`cccccbccccc`b`cccccc`ddd``d`d`d`cccc```ccccccccbbbccc`ccc`ccccccccccc`", "`ccccccccccc`b`ccccc`dd`d`d`d``d`cccccc`cccccccccbcc``b``c`ccccccccccc`", "`ccccccccccc`b`ccccc`d`dd`d`d`d`bbbcccc``````ccccccc`bbb`c`ccccccccccc`", "`ccccccccccc`b`ccccc`dd``dd`d``bbbbb```dd`ddd`ccccccc`b`cc`ccccccccccc`", "`ccccccccccc`b`cccccc`dddd`d``bbbbbbbbb`dd``d`cccc````b`cc`ccccccccccc`", "`ccccccccccc`b`cccccc```````dd``bbbbbbb``dddd`ccc`ccc`b`cc`ccccccccccc`", "`ccccccccccc`b`cccc``bcb`ddddddd``````ddd`dd``cc`ccccc```c`ccccccccccc`", "`ccccccccccc`b`cc``````bc``ddddddddddddddd``cb```cc``c`c`c`ccccccccccc`", "`ccccccccccc`b```ccbb````bc```ddddddddd```cbbb````cc`````c`ccccccccccc`", "`ccccccccccc`b`bbccccbb````bcb`````````bcbbb````bb`cc`cc`c`ccccccccccc`", "`ccccccccccc`````bbccccbb````bcbcbcbcbcbbb````bbccc``````c`ccccccccccc`", "`ccccccccccc`ddd```bbccccbb````b```````b````bbccccb```c`cc`ccccccccccc`", "`ccccccccccc`dd`ddd``bbccccbb```b`ccc`b```bbccccbb``cc``cc`ccccccccccc`", "`ccccccccccc`d`ddd`dd``bbccccbb``b`c`b``bbccccbb``d`c`c``c`ccccccccccc`", "`ccccccccccc````d`ddb````bbccccb``b`b``bccccbb``ddd`cccc```ccccccccccc`", "`ccccccccccc`ccc`ddb``ddd``bbcccb``b``bccccb``ddddd`c`c````ccccccccccc`", "`ccccccccccc``ccc`b``dddddd`bbcccb```bcccbb`ddddddd`cccc```ccccccccccc`", "`ccccccccccc`cc`c```d`````````bcccb`bcccb`````````d`c`c````ccccccccccc`", "`ccccccccccc``cccc`dd`ccccccc`bbcc```ccbb`ccccccc`d`cccc```ccccccccccc`", "`ccccccccccc```c`c`dd`c`````c``bb`ccc`bb``c`````c`d`c`c````ccccccccccc`", "`ccccccccccc```cccc`d`c`dd````c``c```c``c````dd`c`d`cccc```ccccccccccc`", "`ccccccccccc````c`c`d`c`dd``cc``c`bbb`c``cc``dd`c`d`c`c````ccccccccccc`", "`ccccccccccc````c`c`d`c`dd``cc``c`bbb`c``cc``dd`c`d`c`c``b`ccccccccccc`", "`ccccccccccc```cccc`d`c`dd````c``c```c``c````dd`c`d`cc``bd`ccccccccccc`", "`ccccccccccc````c`c`d`c`````c``bb`ccc`bb``c`````c`dd```bdd`ccccccccccc`", "`ccccccccccc```cccc`d`ccccccc`bbcc```ccbb`ccccccc`dd``bdd``ccccccccccc`", "`ccccccccccc````c`c`d`````````bcccb`bcccb`````````d``bdd```ccccccccccc`", "`ccccccccccc```cccc`ddddddd`bbcccb```bcccbb`dddddd``bdd````ccccccccccc`", "`ccccccccccc````c`c`ddddd``bccccb``b``bcccbb``ddd``bdd`````ccccccccccc`", "`ccccccccccc```cccc`ddd``bbccccb``b`b``bccccbb````bdd```dd`ccccccccccc`", "`ccccccccccc`c``c`c`d``bbccccbb``b`c`b``bbccccbb``dd```ddd`ccccccccccc`", "`ccccccccccc`cc``cc``bbccccbb```b`ccc`b```bbccccbb```dd`dd`ccccccccccc`", "`ccccccccccc`cc`c```bccccbb````b```````b````bbccccbb````d``ccccccccccc`", "`ccccccccccc`c``````cccbb````bbbcbcbcbcbcb````bbccccbb`````ccccccccccc`", "`ccccccccccc`c`cc`cc`bb````bbbcb`````````bcb````bbccccbb`b`ccccccccccc`", "`ccccccccccc`c`````cc````bbbc```ddddddddd```cb````bbcc```b`ccccccccccc`", "`ccccccccccc`c`c`c``cc```bc``ddddddddddddddd``cb``````cc`b`ccccccccccc`", "`ccccccccccc`c```ccccc`cc``dd``dd``````ddddddd`bcb``cccc`b`ccccccccccc`", "`ccccccccccc`cc`b`ccc`ccc`ddddd``bbbbbb``dd```````cccccc`b`ccccccccccc`", "`ccccccccccc`cc`b````cccc`d``ddd````bbbbb``d`dddd`cccccc`b`ccccccccccc`", "`ccccccccccc`cc`b`ccccccc`ddd`d`cccc``bb``d`dd``dd`ccccc`b`ccccccccccc`", "`ccccccccccc`c`bbb`ccccccc```c``cccccc``d`d`d`dd`d`ccccc`b`ccccccccccc`", "`ccccccccccc`c``b``ccbccccccccc`ccccccc`d`d`d`d`dd`ccccc`b`ccccccccccc`", "`ccccccccccc`ccc`cccbbbcccccccc```cccccd`d`d``ddd`cccccc`b`cccccbccccc`", "`ccccccccccc`ccccccbbbbbccccccc`cccccc`d`d`d`d```ccc```c`b`ccccbbbcccc`", "`ccccccccccc`cccccbbbbbbbcccccc`cc```c`d`d`d`d`cccc`d`cc`b`cccbbbbbccc`", "`ccccccccccc`ccccbbbbbbbbbccc```c``ccc`d`d`d`d`ccc`dd`cc`b`ccbbbbbbbcc`", "`ccccccccccc`cccabbbbbbbbbbcc`cccccccc`d`d`d`d`ccc`dd`cc`b`cabbbbbbbac`", "`ccccccccccc`ccabbbbbbbbbbbacc`ccccccc`d`d`d`d`cc`dd`c`````cbbbbbbbbbc`", "`ccccccccccc`ccabbbbbbbbbbbaccc`cccccc`d`d`d`d`cc`d`cc`c`c`cbbbbbbbbbc`", "`ccccccccccc`cabbbbbbbbbbbbbacc`c`c``c`d`d`d`d`cc``cccbcbc`cbbbbcbbbbc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc`c``cc`d`d`d`d`ccc`d`ccbcbc`ccbbacabbcc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc`ccccc`d`d`d`d`ccc`dd`c`````ccccccccccc`", "`ccccccccccc`cbbbbbbbbbbbbbbbc`````````````````ccc`dd`cc`b`ccccccccccc`", "`ccccccccccc`cbbbbbbbcbbbbbbbc``bbbbbbbbbbbbbb`ccc`dd`cc`b`ccccbbbbccc`", "`ccccccccccc`ccbbbbbacabbbbbc``bcccbccccbcccbb`cccc`d`cc`b`cccbbbbbbcc`", "`ccccccccccc`cccbbbacccabbbcc`bcbbcbcbbcbcbbcbb`cccc```cc``cccbbccbbcc`", "`ccccccccccc`ccccccccccccccc`bcbbbcbcbbcbcbbbcbb`ccccccccc`cccbbccbbcc`", "`ccccccccccc```````````````````````````````````````````````cccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _js[] = { /* width height ncolors chars_per_pixel */ "71 96 6 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", "e c #0000FF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccc````cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccc````cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccccc``ccc```````````````````````````````````````````````ccccccccccc`", "`cc``cc``ccc`ccc``ccc`b`bbb`b`bb`b`bbb`bb`cccccccccccccccc`ccccccccccc`", "`cc``cc``ccc`cc`dd`ccc`b`bb`b`bb`b`bb`bb`cccccccc`cccccccc`ccccccccccc`", "`cc``````ccc`c`d`bd`ccc`b```b````b```bb`cccccccc```ccccccc`ccccccccccc`", "`ccc````cccc`c`d`bd`cccc`bbbbbbbbbbbbbb`ccccccc`````cccccc`ccccccccccc`", "`ccccccccccc`c`d`bd`cccc````````````````cccccc```````ccccc`ccccccccccc`", "`ccccccccccc`cc`dd`ccccc`ccccc`d`d`d`d`cccccc`````````cccc`ccccccccccc`", "`ccccc`ccccc`ccc``cccccc`c``cc`d`d`d`d`ccccc```````````ccc`ccccccccccc`", "`cccc```cccc`cc`dd`ccccc`c`c``c`d`d`d`d`ccc`````````````cc`ccccccccccc`", "`ccc`````ccc`c`d`bd`ccccecccccc`d`d`d`d`ccc`````````````cc`ccccccccccc`", "`cc```````cc`cc`dd`cccc`ccccccc`d`d`d`d`cc```````````````c`ccccccccccc`", "`c`````````c`ccc``cccc`cccccccc`d`d`d`d`cc```````````````c`ccccccccccc`", "`c`````````c`cc`dd`ccc``cc``cec`d`d`d`d`cc```````````````c`ccccccccccc`", "`c`````````c`c`d`bd`cccc`cc``ec`d`d`d`d`cc``````c`c``````c`ccccccccccc`", "`cc``c`c``cc`c`d`bd`cccc`cccccc`d`d`d`dd``c````cc`cc````cc`ccccccccccc`", "`cccca`acccc`c`d`bd`cccc```ccc`dd`d`d`dddd`ccccc```ccccccc`ccccccccccc`", "`cccc```cccc`cc`dd`ccccc`ccccc`dd`dd`d`d`dd`ccc`````cccccc`ccccccccccc`", "`ccccccccccc`c`````cccc``cccccb``d`d`d`dd`d`cccccccccccccc`ccccccccccc`", "`ccccccccccc`c`ccc``c````eccbbbb`d``d`d``dd`cccccccccccccc`ccccccccccc`", "`ccccccccccc`cc``cc````````bbbbb``dd`d`ddd``cccccccccccccc`ccccccccccc`", "`ccccccccccc`c`cc````c````````````````````````cccccccccccc`ccccccccccc`", "`ccccccccccc`c`c```c`c````````````````````c`c```cccccccccc`ccccccccccc`", "`ccccccccccc`c```c````c`d`d`d`d`d`d`d`d`d`c```c```cccccccc`ccccccccccc`", "`ccccccccccc``b```c`c`c```````````````````c`c`c``b``cccccc`ccccccccccc`", "`ccccccccccc`b``b`c````c`bbbbbbbbbbbbbbbb`c```c`bbb```cc```ccccccccccc`", "`ccccccccccc```b```c`c`c``bdbbdbbdbbdbbdb`c`c`c`b```bb``d``ccccccccccc`", "`ccccccccccc``b``d`c````c`bbbd`dbdbd`dbbb`c```c```bb``ddd``ccccccccccc`", "`ccccccccccc`b``d`d`c`c`c``bd`dbdddbd`dbb`c`c`c`bb``dd`````ccccccccccc`", "`ccccccccccc```d`d``c`````d`bdbbd`dbbdbbb`c```c````ddddd```ccccccccccc`", "`ccccccccccc``d`d`d``c``d``````c```c```c``c`c`c```dd`````d`ccccccccccc`", "`ccccccccccc`d`d`d`````d``d`c`c`c`c`c`c`c`c``````dddddd``d`ccccccccccc`", "`ccccccccccc``d`d``b``d``dd``c```c```c````c`c```dd`d````d``ccccccccccc`", "`ccccccccccc`ddd``cb`d````d````````````````````ddddddd``d``ccccccccccc`", "`ccccccccccc`d```bb`d``dddd`cccccccccccccccccc`dd`d````d`b`ccccccccccc`", "`ccccccccccc````cb`d``d```d`bbbbbbbbbbbbbbbbb`ddddddd``dbb`ccccccccccc`", "`ccccccccccc```bb`d``ddddd````````````````````d`d`````d`bb`ccccccccccc`", "`ccccccccccc``db`d````d``d```d``c`ccc``c``c``ddddddd`dbbbb`ccccccccccc`", "`ccccccccccc`dbbbd`ddddddd``c``c``ccc`c``d```d``d````d`bb``ccccccccccc`", "`ccccccccccc`bd`d`````d`d````````````````````ddddd``d`bb```ccccccccccc`", "`ccccccccccc`d`d``ddddddd`bbbbbbbbbbbbbbbbb`d```d``d`bc``d`ccccccccccc`", "`ccccccccccc`b`d````d`dd`cccccccccccccccccc`dddd``d`bb``d``ccccccccccc`", "`ccccccccccc``d``ddddddd````````````````````d````d`bc``d`d`ccccccccccc`", "`ccccccccccc``d````d`dd```c`c````c```c```c``dd``d``b``d`d``ccccccccccc`", "`ccccccccccc`d``dddddd``````c`c`c`c`c`c`c`c`d``d`````d`d`d`ccccccccccc`", "`ccccccccccc`d`````dd```c`c`c``c```c```c``````d``c``d`d`d``ccccccccccc`", "`ccccccccccc```ddddd````c```c`bbbdbbd`dbbdb`d`````c``d`d```ccccccccccc`", "`ccccccccccc`````dd``bb`c`c`c`bbd`dbdddbd`db``c`c`c`d`d``b`ccccccccccc`", "`ccccccccccc``ddd``bb```c```c`bbbd`dbdbd`dbbb`c````c`d``b``ccccccccccc`", "`ccccccccccc``d``bb```b`c`c`c`bdbbdbbdbbdbbdb``c`c`c```b```ccccccccccc`", "`ccccccccccc```cc```bbb`c```c`bbbbbbbbbbbbbbbb`c````c`b``b`ccccccccccc`", "`ccccccccccc`cccccc``b``c`c`c```````````````````c`c`c```b``ccccccccccc`", "`ccccccccccc`cccccccc```c```c`d`d`d`d`d`d`d`d`d`c````c```c`ccccccccccc`", "`ccccccccccc`cccccccccc```c`c````````````````````c`c```c`c`ccccccccccc`", "`ccccccccccc`cccccccccccc````````````````````````c````cc`c`ccccccccccc`", "`ccccccccccc`cccccccccccccc``ddd`d`dd``bbbbb````````cc``cc`ccccccccccc`", "`ccccccccccc`cccccccccccccc`dd``d`d``d`bbbbcce````c``ccc`c`ccccccccccc`", "`ccccccccccc`cccccccccccccc`d`dd`d`d`d``bccccc``cccc`````c`ccccccccccc`", "`ccccccccccc`cccccc`````ccc`dd`d`d`dd`dd`ccccc`ccccc`dd`cc`cccc```cccc`", "`ccccccccccc`ccccccc```ccccc`dddd`d`d`dd`ccc```cccc`db`d`c`cccca`acccc`", "`ccccccccccc`cc````cc`cc````c``dd`d`d`d`cccccc`cccc`db`d`c`cc``c`c``cc`", "`ccccccccccc`c``````c`c``````cc`d`d`d`d`ce``cc`cccc`db`d`c`c`````````c`", "`ccccccccccc`c```````````````cc`d`d`d`d`cec``cc``ccc`dd`cc`c`````````c`", "`ccccccccccc`c```````````````cc`d`d`d`d`cccccccc`cccc``ccc`c`````````c`", "`ccccccccccc`c```````````````cc`d`d`d`d`ccccccc`cccc`dd`cc`cc```````cc`", "`ccccccccccc`cc`````````````ccc`d`d`d`d`ccccccecccc`db`d`c`ccc`````ccc`", "`ccccccccccc`cc`````````````ccc`d`d`d`d`c``c`c`ccccc`dd`cc`cccc```cccc`", "`ccccccccccc`ccc```````````ccccc`d`d`d`d`cc``c`cccccc``ccc`ccccc`ccccc`", "`ccccccccccc`cccc`````````cccccc`d`d`d`d`ccccc`ccccc`dd`cc`ccccccccccc`", "`ccccccccccc`ccccc```````cccccc````````````````cccc`db`d`c`ccccccccccc`", "`ccccccccccc`cccccc`````ccccccc`bbbbbbbbbbbbbb`cccc`db`d`c`cccc````ccc`", "`ccccccccccc`ccccccc```cccccccc`bb```b````b```b`ccc`db`d`c`ccc``````cc`", "`ccccccccccc`cccccccc`cccccccc`bb`bb`b`bb`b`bb`b`ccc`dd`cc`ccc``cc``cc`", "`ccccccccccc`cccccccccccccccc`bb`bbb`b`bb`b`bbb`b`ccc``ccc`ccc``cc``cc`", "`ccccccccccc```````````````````````````````````````````````ccc``cccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````ccccc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````ccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _kc[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`c````c````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`c````c````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``cc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``c``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc```cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``c``cccc```````````````````````````````````````````````ccccccccccc`", "`cc``cc``ccc`cccccccccccccccc`ddd`ddd`ddd`dddddddd`ccccccc`ccccccccccc`", "`cc``ccc``cc`ccccccc```ccccccc`d```d```d```dd`ddd`cccccccc`ccccccccccc`", "`c````c````c`cccccc`````ccccccc`bbbbbbbbbbbb```d`ccccccccc`ccccccccccc`", "`c````c````c`ccccc```````ccccccc````````````bbb`cccccccc`c`ccccccccccc`", "`ccccccccccc`ccccc```````ccccccc````````````````ccccccc````ccccccccccc`", "`ccccccccccc`ccccc```````cccccc``cccccccc`c`````cccccc`c`b`ccccccccccc`", "`cccc```cccc`cccccc`````cccccc`c`cccccccc`c`c```cccccc`c`b`ccccccccccc`", "`ccc`````ccc`ccc```c```c```ccc`c````c`````c`c`c`cccccc`c`b`ccccccccccc`", "`ccc`````ccc`cc`````````````cc`````c```c``c`c`c`cccccc`c`b`ccccccccccc`", "`cc`c```c`cc`c```````````````c`c`ccc`cccc`c`c`c`cccccc`c`b`ccccccccccc`", "`c`````````c`c```````````````c`c`ccc`cccc`c`c`c`cccccc`c`b`ccccccccccc`", "`c`````````c`c```````````````c`c`ccc`cccc`c`c`c`cccccc`c`b`ccccccccccc`", "`c`````````c`cc`````c`c`````cc`c`cc```ccc`c`c`c`cccccc`c`b`ccccccccccc`", "`cc``c`c``cc`ccc```cc`cc```cc`cc```ccc``c`c`c`c```cccc`c`b`ccccccccccc`", "`cccca`acccc`ccccccc```cccccc````cc```ccc`c`c`c`cc`ccc`c`b`ccccccccccc`", "`cccc```cccc`cccccc`````cccccc`c`cccccccc`c`cc`c`c``cc`c`b`ccccccccccc`", "`ccccccccccc`ccccccccccccccc```c`c`ccc`c``c`c```c``b```c`b`ccccccccccc`", "`ccccccccccc`cccccccccccccc`cc`c`c`c`c`c`c``c`c`c`bbbb`c`b`ccccccccccc`", "`ccccccccccc`cccccccccccccc`c`cc`c`c`c`c``c`ccc``bdbbb`c`b`ccccccccccc`", "`ccccccccccc`ccccccccccc````ccc`c`c`b`c`cc`b```bbddbbb`c`b`ccccccccccc`", "`ccccccccccc`cccccccc````````````b`bbb`b``bbbb`bbbbbd``c`b`ccccccccccc`", "`ccccccccccc`ccccc```bb`dd``c``d``bbbbbbbbbb``bdbbbb`c`c`b`ccccccccccc`", "`ccccccccccc`cccc`bbbbbb`dd`````d```bbbbbb```bddbbd`cc`c`b`ccccccccccc`", "`ccccccccccc`cc``bcbcbcbc`dd``c`d`d```bb```d`bbbbb`cc``c`b`ccccccccccc`", "`ccccccccccc`c```bbbbbbbbb`dd````d`d``````d`bbbbd`cc```c`b`ccccccccccc`", "`ccccccccccc`b```cbcbcbcbcb`dd```d`dd````dd`bdbbb`c````c`b`ccccccccccc`", "`ccccccccccc`b```bbbbbbbbbb``db```d``d``d``bddbb`cc````c`b`ccccccccccc`", "`ccccccccccc`b```bcbcbcbcbc```db``d`dddddd`bbbbd`c``b``c`b`ccccccccccc`", "`ccccccccccc`b```bbbbb````b``b`d```d```b```bbbbb`c`````c`b`ccccccccccc`", "`ccccccccccc``dd``bcb`cccc``````d``d`ddddd`bdbd`cc``b``c`b`ccccccccccc`", "`ccccccccccc`dddd`bb`cc``cc``bb`d``d```b``bddbb`c``````c`b`ccccccccccc`", "`ccccccccccc``dd```b`c`bb`c``````d``d`ddd`bbbbd`c````````b`ccccccccccc`", "`ccccccccccc`````````c`bb`c``bbb`d``d``b``bbbbb`c```cc`cc``ccccccccccc`", "`ccccccccccc``bb`````cc``cc```````d`d`ddd`bbdbd`c``cccc````ccccccccccc`", "`ccccccccccc``````````cccc````````````````bddbb`c``c``ccc``ccccccccccc`", "`ccccccccccc``cc`cc```````bb`cccc`bbb``````bbbd`c``ccc`````ccccccccccc`", "`ccccccccccc`````ccc``c`dbbb``````bbb`cccc`bb```````cc`cc``ccccccccccc`", "`ccccccccccc``ccc``c``c`bbddb````````````````cccc``````````ccccccccccc`", "`ccccccccccc````cccc``c`dbdbb`ddd`d`d```````cc``cc`````bb``ccccccccccc`", "`ccccccccccc``cc`cc```c`bbbbb``b``d``d`bbb``c`bb`c`````````ccccccccccc`", "`ccccccccccc`b````````c`dbbbb`ddd`d``d``````c`bb`c`b```dd``ccccccccccc`", "`ccccccccccc`b`c``````c`bbddb``b```d``d`bb``cc``cc`bb`dddd`ccccccccccc`", "`ccccccccccc`b`c``b``cc`dbdb`ddddd`d``d``````cccc`bcb``dd``ccccccccccc`", "`ccccccccccc`b`c`````c`bbbbb```b```d```d`b``b````bbbbb```b`ccccccccccc`", "`ccccccccccc`b`c``b``c`dbbbb`dddddd`d``bd```cbcbcbcbcb```b`ccccccccccc`", "`ccccccccccc`b`c````cc`bbddb``d``d``d```bd``bbbbbbbbbb```b`ccccccccccc`", "`ccccccccccc`b`c````c`bbbdb`dd````dd`d```dd`bcbcbcbcbc```b`ccccccccccc`", "`ccccccccccc`b`c```cc`dbbbb`d``````d`d````dd`bbbbbbbbb```c`ccccccccccc`", "`ccccccccccc`b`c``cc`bbbbb`d```bb```d`d`c``dd`cbcbcbcb``cc`ccccccccccc`", "`ccccccccccc`b`c`cc`dbbddb```bbbbbb```d`````dd`bbbbbb`cccc`ccccccccccc`", "`ccccccccccc`b`c`c`bbbbdb``bbbbbbbbbb``d``c``dd`bb```ccccc`ccccccccccc`", "`ccccccccccc`b`c``dbbbbb`bbbb``b`bbb`b````````````cccccccc`ccccccccccc`", "`ccccccccccc`b`c`bbbddbb```b`cc`c`b`c`c`ccc````ccccccccccc`ccccccccccc`", "`ccccccccccc`b`c`bbbdb``ccc`c``c`c`c`c`cc`c`cccccccccccccc`ccccccccccc`", "`ccccccccccc`b`c`bbbb`c`c`c``c`c`c`c`c`c`cc`cccccccccccccc`ccccccccccc`", "`ccccccccccc`b`c```b``c```c`c``c`ccc`c`c```ccccccccccccccc`ccccccccccc`", "`ccccccccccc`b`c`cc``c`c`cc`c`cccccccc`c`cccccc`````cccccc`cccc```cccc`", "`ccccccccccc`b`c`ccc`cc`c`c`c`ccc```cc````cccccc```ccccccc`ccccc`ccccc`", "`ccccccccccc`b`c`cccc```c`c`c`c``ccc```cc`cc```cc`cc```ccc`cc``c`c``cc`", "`ccccccccccc`b`c`cccccc`c`c`c`ccc```cc`c`cc`````c`c`````cc`c`````````c`", "`ccccccccccc`b`c`cccccc`c`c`c`cccc`ccc`c`c```````````````c`c`````````c`", "`ccccccccccc`b`c`cccccc`c`c`c`cccc`ccc`c`c```````````````c`c`````````c`", "`ccccccccccc`b`c`cccccc`c`c`c`cccc`ccc`c`c```````````````c`cc`c```c`cc`", "`ccccccccccc`b`c`cccccc`c`c`c``c```c`````cc`````````````cc`ccc`````ccc`", "`ccccccccccc`b`c`cccccc`c`c`c`````c````c`ccc```c```c```ccc`ccc`````ccc`", "`ccccccccccc`b`c`cccccc```c`c`cccccccc`c`cccccc`````cccccc`cccc```cccc`", "`ccccccccccc`b`c`cccccc`````c`cccccccc``cccccc```````ccccc`ccccccccccc`", "`ccccccccccc````ccccccc````````````````ccccccc```````ccccc`ccccccccccc`", "`ccccccccccc`c`cccccccc`bbb````````````ccccccc```````ccccc`c````c````c`", "`ccccccccccc`ccccccccc`d```bbbbbbbbbbbb`ccccccc`````cccccc`c````c````c`", "`ccccccccccc`cccccccc`ddd`dd```d```d```d`ccccccc```ccccccc`cc``ccc``cc`", "`ccccccccccc`ccccccc`dddddddd`ddd`ddd`ddd`cccccccccccccccc`ccc``cc``cc`", "`ccccccccccc```````````````````````````````````````````````cccc``c``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc```cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``c``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cc``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````c````c`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````c````c`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _kd[] = { /* width height ncolors chars_per_pixel */ "71 96 6 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", "e c #0000FF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cbbbbcbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cbbbbcbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcbbcccc```````````````````````````````````````````````ccccccccccc`", "`ccbbccbbccc`ccccccccccccc`dddd`ddd`ddddddddddddd`cccccccc`ccccccccccc`", "`ccbbcccbbcc`cccccccbcccccc`dd```d```dd`dddddddd`ccc```cc``ccccccccccc`", "`cbbbbcbbbbc`ccccccbbbcccccc`bbbbbbbbd```dd`ddd`ccc`d`cc`b`ccccccccccc`", "`cbbbbcbbbbc`cccccbbbbbccccc`````````bbbbd```d``cc`dd`cc`b`ccccccccccc`", "`ccccccccccc`ccccabbbbbaccccc````````````bbbbb`ccc`dd`cc`b`ccccccccccc`", "`ccccccccccc`cccabbbbbbbacccc`cccccc``c````````cc`dd`c`````ccccccccccc`", "`cccccbccccc`cccabbbbbbbacccc`c``ccc`c`c```````cc`d`ccbcbc`ccccccccccc`", "`ccccbbbcccc`ccbbbbbbbbbbbccc```c`cc`c`c`c`c`c`cc``cccbcbc`ccccccccccc`", "`cccabbbaccc`cbbbbbbbbbbbbbccecccccc`c`c`c`c`c`cc`d`cc`c`c`ccccccccccc`", "`ccabbbbbacc`ccbbbbbbbbbbbcc`ccccccc`c`c`c`c`c`cc`dd`c`````ccccccccccc`", "`ccbbbbbbbcc`cccabbbbbbbacc`cccccccc`c`c`c`c`c`ccc`dd`cc`b`ccccccccccc`", "`ccabbbbbacc`cccabbbbbbbacc``eccccccc`c`c`c`c`c`cc`dd`cc`b`ccccccccccc`", "`cccabbbaccc`ccccabbbbbaccccc````c`cc`c`c`c`c`c`ccc`d`cc`b`ccccccccccc`", "`ccccbbbcccc`cccccbbbbbcccccc`cc```ccc`c`c`c`c`c`ccc```c`b`ccccccccccc`", "`cccccbccccc`ccccccbbbcccccccc``ccccccc`c`c`c`c`c`cccccc`b`ccccccccccc`", "`ccccccccccc`cccccccbcccccccc`cccccc```cc`c`c`c`c`cccccc`b`ccccccccccc`", "`ccccccccccc`cc```ccccccccccc``cccc`ccc`c`c`c`c`c`cccccc`b`ccccccccccc`", "`ccccccccccc`c`c`c```ccccc``c`ccccc`c``cc`c`c`c`c`cccccc`b`ccccccccccc`", "`ccccccccccc`c``c`c`c`ccc`c``cccccc``ccc`c`c`c`c`ccccccc`b`ccccccccccc`", "`ccccccccccc```c`c`c`c`cc`cccccccccc````````````````cccc`b`ccccccccccc`", "`ccccccccccc``c`c`ccccc``d`ccccc````````dd`ccc`dd`cc```````ccccccccccc`", "`ccccccccccc`c`c`cccc`````d```````````c``dd`c```dd`cc`dd`c`ccccccccccc`", "`ccccccccccc`cc`cc`````bb``d```bb````c``c`dd```c`dd`c``dd``ccccccccccc`", "`ccccccccccc`ccc``b``d`bb```d`b`bb````````````````````c`dc`ccccccccccc`", "`ccccccccccc`c``bbbbb`d``c``d`bb`b``dddddddddddddd`````````ccccccccccc`", "`ccccccccccc``bbbbb``d`d``bb```bb``c`c`c`c`c`c`cc`d````````ccccccccccc`", "`ccccccccccc`bbbb``dddd`d`bb`d```ccccccccccccccc`d`bb``cc``ccccccccccc`", "`ccccccccccc`bb``dddd````d```d`ccc```````````cc`d`d`bb``c``ccccccccccc`", "`ccccccccccc`b`dddd``````d`c`d`c``dddddddddd`c`d``bd`bb````ccccccccccc`", "`ccccccccccc``ddd`````c``d```d``dd````````d`c`d`dd`bd`bb```ccccccccccc`", "`ccccccccccc`ddd````ccc```d````d````bbbb`d`cc`d``dd`bd`bb``ccccccccccc`", "`ccccccccccc`dd`bb```ccc``d```d```bbbbbb`d`c`d````d````````ccccccccccc`", "`ccccccccccc`d`b`bb```cc``d```d`````````d`cc`d`````bd`bd`b`ccccccccccc`", "`ccccccccccc``ddb`bb```c```d``d`bbbbbbb`d`c`d````d`bd`bd`b`ccccccccccc`", "`ccccccccccc``bddb`bb```c``d``d````````d`cc`d``bbd`b```````ccccccccccc`", "`ccccccccccc`bb`bddb```````````d`ccccc`d```````````bddb`bb`ccccccccccc`", "`ccccccccccc`bbb`b```dbb``d`cc`d`ccccc`d```d`````bb`bddb`b`ccccccccccc`", "`ccccccccccc```````b`dbb``d`cc`d```````d```d``c```bb`bddb``ccccccccccc`", "`ccccccccccc`b`db`db`d````d`c``bbbbbbbb`d``d```c```bb`bdd``ccccccccccc`", "`ccccccccccc`b`db`db`````d`cc```````````d```d``cc```bb`b`d`ccccccccccc`", "`ccccccccccc````````d````d`c`d`bbbbbb```d```d``ccc```bb`dd`ccccccccccc`", "`ccccccccccc``bb`db`dd``d`cc`d`bbbb````d````d```ccc````ddd`ccccccccccc`", "`ccccccccccc```bb`db`dd`d`c`d````````dd``d```d``c`````ddd``ccccccccccc`", "`ccccccccccc````bb`db``d`c`dddddddddd````d```d``````dddd`b`ccccccccccc`", "`ccccccccccc``c``bb`d`d`cc```````````ccc`d```d````dddd``bb`ccccccccccc`", "`ccccccccccc``cc``bb`d`ccccccccccccccc```d`bb`d`dddd``bbbb`ccccccccccc`", "`ccccccccccc````````d`cc`c`c`c`c`c`c``bb```bb``d`d``bbbbb``ccccccccccc`", "`ccccccccccc`````````dddddddddddddd``b`bb`d``c``d`bbbbb``c`ccccccccccc`", "`ccccccccccc`cd`c````````````````````bb`b`d```bb`d``b``ccc`ccccccccccc`", "`ccccccccccc``dd``c`dd`c```dd`c``c````bb```d``bb`````c``cc`ccccccccccc`", "`ccccccccccc`c`dd`cc`dd```c`dd``c```````````d`````cccc```c`ccccccccccc`", "`ccccccccccc```````cc`dd`ccc`dd````````ccccc`d``ccccc`c`c``ccccccccccc`", "`ccccccccccc`b`cccc````````````````cccccccccc`cc`c`c`c`c```ccccccccccc`", "`ccccccccccc`b`ccccccc`c`c`c`c`ccc``cccccc``c`ccc`c`c`c``c`ccccccccccc`", "`ccccccccccc`b`cccccc`c`c`c`c`cc``c`ccccc`c``ccccc```c`c`c`ccccccccccc`", "`ccccccccccc`b`cccccc`c`c`c`c`c`ccc`cccc``ccccccccccc```cc`ccccccccccc`", "`ccccccccccc`b`cccccc`c`c`c`c`cc```cccccc`ccccccccbccccccc`ccccccccccc`", "`ccccccccccc`b`cccccc`c`c`c`c`c`ccccccc``ccccccccbbbcccccc`cccccbccccc`", "`ccccccccccc`b`c```ccc`c`c`c`c`c`ccc```cc`ccccccbbbbbccccc`ccccbbbcccc`", "`ccccccccccc`b`cc`d`ccc`c`c`c`c`c`cc`c````cccccabbbbbacccc`cccabbbaccc`", "`ccccccccccc`b`cc`dd`cc`c`c`c`c`c`ccccccce``ccabbbbbbbaccc`ccabbbbbacc`", "`ccccccccccc`b`cc`dd`ccc`c`c`c`c`c`cccccccc`ccabbbbbbbaccc`ccbbbbbbbcc`", "`ccccccccccc`````c`dd`cc`c`c`c`c`c`ccccccc`ccbbbbbbbbbbbcc`ccabbbbbacc`", "`ccccccccccc`c`c`cc`d`cc`c`c`c`c`c`cccccceccbbbbbbbbbbbbbc`cccabbbaccc`", "`ccccccccccc`cbcbccc``cc`c`c`c`c`c`cc`c```cccbbbbbbbbbbbcc`ccccbbbcccc`", "`ccccccccccc`cbcbcc`d`cc```````c`c`ccc``c`ccccabbbbbbbaccc`cccccbccccc`", "`ccccccccccc`````c`dd`cc````````c``cccccc`ccccabbbbbbbaccc`ccccccccccc`", "`ccccccccccc`b`cc`dd`ccc`bbbbb````````````cccccabbbbbacccc`ccccccccccc`", "`ccccccccccc`b`cc`dd`cc``d```dbbbb`````````cccccbbbbbccccc`cbbbbcbbbbc`", "`ccccccccccc`b`cc`d`ccc`ddd`dd```dbbbbbbbb`ccccccbbbcccccc`cbbbbcbbbbc`", "`ccccccccccc``cc```ccc`dddddddd`dd```d```dd`ccccccbccccccc`ccbbcccbbcc`", "`ccccccccccc`cccccccc`ddddddddddddd`ddd`dddd`ccccccccccccc`cccbbccbbcc`", "`ccccccccccc```````````````````````````````````````````````ccccbbcbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbccbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcbbbbc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcbbbbc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _kh[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cbbbbcbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cbbbbcbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbccbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcbbcccc```````````````````````````````````````````````ccccccccccc`", "`ccbbccbbccc`ccccccccccccccc`d`ddd`ddd`ddd`dddddd`cccccccc`ccccccccccc`", "`ccbbcccbbcc`cccbbbacccabbbcc```d```d```d```d``d`ccccccccc`ccccccccccc`", "`cbbbbcbbbbc`ccbbbbbacabbbbbcc`dddddddddddd`dd``cc``cccccc`ccccccccccc`", "`cbbbbcbbbbc`cbbbbbbbcbbbbbbbcc`bbbbbbbbbddddd`cc`dd`ccccc`ccccccccccc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc``````````bbbbb`cc`dd```ccc`ccccccccccc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc`cccccccc``````````d`cc``cc`ccccccccccc`", "`ccbbacabbcc`cbbbbbbbbbbbbbbbcc`cccccccc`c`c`c`cc`d`cc`d`c`ccccccccccc`", "`cbbbbcbbbbc`cabbbbbbbbbbbbbac`````c`````c`c`c```dd````d`c`ccccccccccc`", "`cbbbbbbbbbc`ccabbbbbbbbbbbac`c```c```c``c`c`c```dd``cc`cc`ccccccccccc`", "`cbbbbbbbbbc`ccabbbbbbbbbbbac`c`ccc`cccc`c`c`c`c`dd`ccc`cc`ccccccccccc`", "`cabbbbbbbac`cccabbbbbbbbbbcc`c`ccc`cccc`c`c`c`cc```````cc`ccccccccccc`", "`ccbbbbbbbcc`ccccbbbbbbbbbccc`c`ccc`cccc`c`c`cc`cc`bbbb`cc`ccccccccccc`", "`cccbbbbbccc`cccccbbbbbbbccc`c`ccc```cccc`c`c`c`c````````c`ccccccccccc`", "`ccccbbbcccc`ccccccbbbbbcccc`c`cccccccccc`cc`c`c``b`b`b`b``ccccccccccc`", "`cccccbccccc`cccccccbbbcccccc``c`c```ccccc`c`c`c`bbbbbbb```ccccccccccc`", "`ccccccccccc`ccccccccbccc`````cc`cccccc`c`c`c`cc``bbbbb`cc`ccccccccccc`", "`ccccccccccc`cccccccccc```b``cc`c`ccc`c`c`c`ccc`cc```b`cbb`ccccccccccc`", "`ccccccccccc`ccccccc```````b```cc`c`c`c```ccc``c`ccc```bb``ccccccccccc`", "`ccccccccccc`ccccc```b`cc``bb`c``cc`c`cc`c```ccccc``b``````ccccccccccc`", "`ccccccccccc`ccc``cc`b`ccc``bb``cc``c``c`dd`cc`cc`b`b`d````ccccccccccc`", "`ccccccccccc`c```c`c`b`c`cc``bb```d``c``ddd`c`cc`bd`b```d``ccccccccccc`", "`ccccccccccc``ddb`c`c`b`c`cc`bb``d`d``dddd`cccc`bd`b`````d`ccccccccccc`", "`ccccccccccc`dbbb``cc`b`cccc``bb``d``ddddd``ccc`db`b`d`````ccccccccccc`", "`ccccccccccc`bb`````cc`b`c`cc`bbb```dddddd`ccc`db`b``bdd```ccccccccccc`", "`ccccccccccc`b`````b`c`bb`c`c``bb``dddddd`cc`c`b`bb````dd``ccccccccccc`", "`ccccccccccc``d```bbb`c`bb`ccc`bbb`ddddd``c`cc``bb````bbdd`ccccccccccc`", "`ccccccccccc`dbbd```bb`c`bbb`c``b`ddddd`b`ccc``bb````bbbbd`ccccccccccc`", "`ccccccccccc`bbdddb`````c``bb``c``ddddd``cc``bb`````bbdb`d`ccccccccccc`", "`ccccccccccc`bddd`bdd````cc````````````````bb``````bbbbbdd`ccccccccccc`", "`ccccccccccc`ddd`b```d`````cccccbbbbbbbbbbb```````bbdb`dd``ccccccccccc`", "`ccccccccccc`ddd`bdddd`d`ccccb`````````````c`````bbbbbddd``ccccccccccc`", "`ccccccccccc`ddd`b```d`d`ccccccccc`bbbb`cccc````bbdb`ddd```ccccccccccc`", "`ccccccccccc`ddd`bdddd`d`ccccccc```cbbb`c`c````bdbbbddd````ccccccccccc`", "`ccccccccccc``ddd`bdd```````````c`````b``c```````b`ddd```b`ccccccccccc`", "`ccccccccccc```dddd`````````ccc``ddddd``cc````bb`dddd```b``ccccccccccc`", "`ccccccccccc`b``d`````ddddd`ccc``d`b`d`cc`c`dddddddd````bb`ccccccccccc`", "`ccccccccccc`bb````dddddddd`c`cc`d`b`d``ccc`ddddd`````d``b`ccccccccccc`", "`ccccccccccc``b```dddd`bb````cc``ddddd``ccc`````````dddd```ccccccccccc`", "`ccccccccccc`b```ddd`b```````c``b`````c```````````ddb`ddd``ccccccccccc`", "`ccccccccccc````dddbbbdb``````c`bbbc```ccccccc`d`ddddb`ddd`ccccccccccc`", "`ccccccccccc```ddd`bdbb`````ccc`bbbb`ccccccccc`d`d```b`ddd`ccccccccccc`", "`ccccccccccc``dddbbbbb```````````````````bcccc`d`ddddb`ddd`ccccccccccc`", "`ccccccccccc``dd`bdbb```````bbbbbbbbbbbccccc`````d```b`ddd`ccccccccccc`", "`ccccccccccc`ddbbbbb``````bb````````````````cc````ddb`dddb`ccccccccccc`", "`ccccccccccc`d`bdbb`````bb``cc``ddddd``c``bb``c`````bdddbb`ccccccccccc`", "`ccccccccccc`dbbbb````bb``ccc`b`ddddd`b``c`bbb`c`bb```dbbd`ccccccccccc`", "`ccccccccccc`ddbb````bb``cc`c``ddddd`bbb`ccc`bb`c`bbb```d``ccccccccccc`", "`ccccccccccc``dd````bb`b`c`cc`dddddd``bb``c`c`bb`c`b`````b`ccccccccccc`", "`ccccccccccc```ddb``b`bd`ccc`dddddd```bbb`cc`c`b`cc`````bb`ccccccccccc`", "`ccccccccccc`````d`b`bd`ccc``ddddd``d``bb``cccc`b`cc``bbbd`ccccccccccc`", "`ccccccccccc`d`````b`db`cccc`dddd``d`d``bb`cc`c`b`c`c`bdd``ccccccccccc`", "`ccccccccccc``d```b`db`cc`c`ddd``c``d```bb``cc`c`b`c`c```c`ccccccccccc`", "`ccccccccccc````d`b`b`cc`cc`dd`c``c``cc``bb``ccc`b`cc``ccc`ccccccccccc`", "`ccccccccccc``````b``ccccc```c`cc`c`cc``c`bb``cc`b```ccccc`ccccccccccc`", "`ccccccccccc``bb```ccc`c``ccc```c`c`c`cc```b```````ccccccc`ccccccccccc`", "`ccccccccccc`bbc`b````c`ccc`c`c`c`ccc`c`cc``b```cccccccccc`ccccccccccc`", "`ccccccccccc`cc`bbbbb``cc`c`c`c`cccccc`cc`````cccbcccccccc`ccccccccccc`", "`ccccccccccc```bbbbbbb`c`c`c`ccccc```c`c``ccccccbbbccccccc`cccccbccccc`", "`ccccccccccc``b`b`b`b``c`c`cc`cccccccccc`c`ccccbbbbbcccccc`ccccbbbcccc`", "`ccccccccccc`c````````c`c`c`c`cccc```ccc`c`cccbbbbbbbccccc`cccbbbbbccc`", "`ccccccccccc`cc`bbbb`cc`cc`c`c`cccc`ccc`c`cccbbbbbbbbbcccc`ccbbbbbbbcc`", "`ccccccccccc`cc```````cc`c`c`c`cccc`ccc`c`ccbbbbbbbbbbaccc`cabbbbbbbac`", "`ccccccccccc`cc`ccc`dd`c`c`c`c`cccc`ccc`c`cabbbbbbbbbbbacc`cbbbbbbbbbc`", "`ccccccccccc`cc`cc``dd```c`c`c``c```c```c`cabbbbbbbbbbbacc`cbbbbbbbbbc`", "`ccccccccccc`c`d````dd```c`c`c`````c`````cabbbbbbbbbbbbbac`cbbbbcbbbbc`", "`ccccccccccc`c`d`cc`d`cc`c`c`c`cccccccc`ccbbbbbbbbbbbbbbbc`ccbbacabbcc`", "`ccccccccccc`cc``cc`d``````````cccccccc`ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccccccccccc`ccc```dd`cc`bbbbb``````````ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccccccccccc`ccccc`dd`cc`dddddbbbbbbbbb`ccbbbbbbbcbbbbbbbc`cbbbbcbbbbc`", "`ccccccccccc`cccccc``cc``dd`dddddddddddd`ccbbbbbacabbbbbcc`cbbbbcbbbbc`", "`ccccccccccc`ccccccccc`d``d```d```d```d```ccbbbacccabbbccc`ccbbcccbbcc`", "`ccccccccccc`cccccccc`dddddd`ddd`ddd`ddd`d`ccccccccccccccc`cccbbccbbcc`", "`ccccccccccc```````````````````````````````````````````````ccccbbcbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbccbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcbbbbc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbcbbbbc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _ks[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`c````c````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`c````c````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``cc``ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``c``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc```cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``c``cccc```````````````````````````````````````````````ccccccccccc`", "`cc``cc``ccc`ccccccccccccccc`dddddddddddddddddddd`cccccccc`ccccccccccc`", "`cc``ccc``cc`cccccccc`ccccccc`ddddddd`d`d`d`d`d``ccccccccc`ccccccccccc`", "`c````c````c`ccccccc```ccccccc``d`d`d`b`b`b`b`b`cccccccccc`ccccccccccc`", "`c````c````c`cccccc`````ccccccb`b`b`bbbbbbbbbb`cccccccccc``ccccccccccc`", "`ccccccccccc`ccccc```````cccccc`bbbbb``````````ccccccccc```ccccccccccc`", "`ccccccccccc`cccc`````````ccccc```````cccccccc``ccccccc`d``ccccccccccc`", "`ccccc`ccccc`ccc```````````cccc`c`c`c`cccccccc`c`cccccc`d``ccccccccccc`", "`cccc```cccc`cc`````````````ccc`c`c`c`````c````c`cccccc`d``ccccccccccc`", "`ccc`````ccc`cc`````````````ccc`c`c`c``c```c````ccccccc`d``ccccccccccc`", "`cc```````cc`c```````````````cc`c`c`c`cccc`ccc`c`cccccc`d``ccccccccccc`", "`c`````````c`c```````````````cc`c`c`c`cccc`ccc`c`cccccc`d``ccccccccccc`", "`c`````````c`c```````````````cc`c`c`c`cccc`ccc`c`cccccc`d``ccccccccccc`", "`c`````````c`c``````c`c``````cc`c`c`c`ccc```cc`c`cccccc`d``ccccccccccc`", "`cc``c`c``cc`cc````cc`cc````ccc`c`c`c`c``ccc`c`c`cccccc`d``ccccccccccc`", "`cccca`acccc`ccccccc```cccccc```c`c`c`c`c```cc``c``cccc`d``ccccccccccc`", "`cccc```cccc`cccccc`````cccc`cc`c`c`c`cccccccc`c`cc`ccc`d``ccccccccccc`", "`ccccccccccc`cccccccccccccc`c`c`c`c`c`cc`ccc`c`c`cc`ccc`d``ccccccccccc`", "`ccccccccccc`cccccccccccc```c``cc`c`c``c`c`c`c`cc``d``c`d``ccccccccccc`", "`ccccccccccc`cccccccccc```d``ccc`cc`c`cc`c```cc```d``c``d``ccccccccccc`", "`ccccccccccc`cccccccc``d`bd`````c``c`cc`c`c`d`b``d``c`b`d``ccccccccccc`", "`ccccccccccc`cccccc````d```d``d````````c`c``d```d``c````d``ccccccccccc`", "`ccccccccccc`cccc``d`d``d``d`b``d`d`d``````d`b`d``c`bbb`d``ccccccccccc`", "`ccccccccccc`cc``bb`````d`b`d`bb``````d`d``d```d``c`b```d``ccccccccccc`", "`ccccccccccc`c`bdd``d```d```d`bbbdddd`````d`b`d``c`bbbb`d``ccccccccccc`", "`ccccccccccc``dbb`````d``d``d`bbbd```ddbb`d```d``c`b````d``ccccccccccc`", "`ccccccccccc`bddb``d`d`d`d`b`d`bbddddddbb`d``d``c`bbbbb`d``ccccccccccc`", "`ccccccccccc`bbd`````d```d```d```````````d`b`d``c`b````````ccccccccccc`", "`ccccccccccc`dbb``d`d`ddd`d``d``ccc`ccc``d```d``c`b`dddd```ccccccccccc`", "`ccccccccccc`ddb````d`d```d``d`cc`ccc`cc`d``d``c`b`d```ddd`ccccccccccc`", "`ccccccccccc`bdd``d`d`ddd`d`b`d`c`c`c`cc`d``d``c`b`dd`c`dd`ccccccccccc`", "`ccccccccccc`bbd````d`d```d```d`ccc`ccc`d`b`d````bb````c```ccccccccccc`", "`ccccccccccc`dbb``d`d`dddd`d``d`c`ccc`c`d```d`d```bbbbb````ccccccccccc`", "`ccccccccccc`bdb````d`d````d``d`````````d``d```````````ccc`ccccccccccc`", "`ccccccccccc`bbd``d``d`ddd`d``d`ddddddddd``d````````ccc````ccccccccccc`", "`ccccccccccc```b`````d`d```d``d`````````d``d`dd```d``c`ccc`ccccccccccc`", "`ccccccccccc`cc`c``d``d`dd`d`bd```bbb```d``d```dd````cc````ccccccccccc`", "`ccccccccccc````cc````dd```d``d```bbb```db`d`dd`d``d``c`cc`ccccccccccc`", "`ccccccccccc`ccc`c``d```dd`d``d`````````d``d```d`d`````b```ccccccccccc`", "`ccccccccccc````ccc````````d`bd`ddddddddd``d`ddd`d``d``dbb`ccccccccccc`", "`ccccccccccc`ccc``````d````d``d`````````db`d````d`d````bdb`ccccccccccc`", "`ccccccccccc````bbbbb```d`d```d`c`ccc`c`d``d`dddd`d`d``bbd`ccccccccccc`", "`ccccccccccc```c````bb````d`b`d`ccc`ccc`d```d```d`d````dbb`ccccccccccc`", "`ccccccccccc`dd`c`dd`b`c``d``d`cc`c`c`c`d`b`d`ddd`d`d``ddb`ccccccccccc`", "`ccccccccccc`ddd```d`b`c``d``d`cc`ccc`cc`d``d```d`d````bdd`ccccccccccc`", "`ccccccccccc```dddd`b`c``d```d``ccc`ccc``d``d`ddd`d`d``bbd`ccccccccccc`", "`ccccccccccc````````b`c``d`b`d```````````d```d```d`````dbb`ccccccccccc`", "`ccccccccccc``d`bbbbb`c``d``d`bbddddddbb`d`b`d`d`d`d``bddb`ccccccccccc`", "`ccccccccccc``d````b`c``d```d`bbdd```dbbb`d``d``d`````bbd``ccccccccccc`", "`ccccccccccc``d`bbbb`c``d`b`d`````ddddbbb`d```d```d``ddb`c`ccccccccccc`", "`ccccccccccc``d```b`c``d```d``d`d``````bb`d`b`d`````bb``cc`ccccccccccc`", "`ccccccccccc``d`bbb`c``d`b`d``````d`d`d``b`d``d``d`d``cccc`ccccccccccc`", "`ccccccccccc``d````c``d```d``c``````````d``d```d````cccccc`ccccccccccc`", "`ccccccccccc``d`b`c``d``b`d`c`c`c``c``c`````db`d``cccccccc`ccccccccccc`", "`ccccccccccc``d``c``d```cc```c`cc`c`cc`ccc``d```cccccccccc`ccccccccccc`", "`ccccccccccc``d`c``d``cc`c`c`c`c``c`c`cc``c```cccccccccccc`ccccccccccc`", "`ccccccccccc``d`ccc`cc`c`c`ccc`cc`c`c`c`c`c`cccccccccccccc`ccccccccccc`", "`ccccccccccc``d`ccc`cc`c`cccccccc`c`c`c`cc`cccc`````cccccc`cccc```cccc`", "`ccccccccccc``d`cccc``c``cc```c`c`c`c`c```cccccc```ccccccc`cccca`acccc`", "`ccccccccccc``d`cccccc`c`c`ccc``c`c`c`c`ccc````cc`cc````cc`cc``c`c``cc`", "`ccccccccccc``d`cccccc`c`cc```ccc`c`c`c`cc``````c`c``````c`c`````````c`", "`ccccccccccc``d`cccccc`c`ccc`cccc`c`c`c`cc```````````````c`c`````````c`", "`ccccccccccc``d`cccccc`c`ccc`cccc`c`c`c`cc```````````````c`c`````````c`", "`ccccccccccc``d`cccccc`c`ccc`cccc`c`c`c`cc```````````````c`cc```````cc`", "`ccccccccccc``d`ccccccc````c```c``c`c`c`ccc`````````````cc`ccc`````ccc`", "`ccccccccccc``d`cccccc`c````c`````c`c`c`ccc`````````````cc`cccc```cccc`", "`ccccccccccc``d`cccccc`c`cccc`ccc`c`c`c`cccc```````````ccc`ccccc`ccccc`", "`ccccccccccc``d`ccccccc``cccccccc```````ccccc`````````cccc`ccccccccccc`", "`ccccccccccc```ccccccccc``````````bbbbb`cccccc```````ccccc`ccccccccccc`", "`ccccccccccc``cccccccccc`bbbbbbbbbb`b`b`bcccccc`````cccccc`c````c````c`", "`ccccccccccc`cccccccccc`b`b`b`b`b`d`d`d``ccccccc```ccccccc`c````c````c`", "`ccccccccccc`ccccccccc``d`d`d`d`d`ddddddd`ccccccc`cccccccc`cc``ccc``cc`", "`ccccccccccc`cccccccc`dddddddddddddddddddd`ccccccccccccccc`ccc``cc``cc`", "`ccccccccccc```````````````````````````````````````````````cccc``c``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc```cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``c``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``cc``cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````c````c`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc````c````c`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _qc[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccc`````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc```````cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cc```````````````````````````````````````````````ccccccccccc`", "`cc``ccc``cc`ddddddddddb``bc`c`c``c`cccccccccccccccccccccc`ccccccccccc`", "`cc``ccc``cc``dddddddddb``bc``c`c```cccccccccccc```ccccccc`ccccccccccc`", "`cc```````cc`c`ddddd``db``bc`cc``c``ccccccccccc`````cccccc`ccccccccccc`", "`ccc`````ccc`cc`dddd`dbb``bc`c`cc`c`cccccccccc```````ccccc`ccccccccccc`", "`cccccc```cc`cc`dddddbb``bbc``cccc```ccccccccc```````ccccc`ccccccccccc`", "`ccccccc``cc`ccc`ddddbb``bcc`cccccc``ccccccccc```````ccccc`ccccccccccc`", "`cccc```cccc`ccc`d``db```bcc```c````b`ccccccccc`````cccccc`ccccccccccc`", "`ccc`````ccc`ccc`d`dbb``bbc`c``cc```b`cccccc```c```c```ccc`ccccccccccc`", "`ccc`````ccc`cc`dddbb```bcc`ccc`ccc``b`cccc`````````````cc`ccccccccccc`", "`cc`c```c`cc`cc`dddbb``bbc`cccc`ccc``b`ccc```````````````c`ccccccccccc`", "`c`````````c`c`d``bb``bbcc`cccc`ccc```b`cc```````````````c`ccccccccccc`", "`c`````````c``dd`bb```bcc`cccc```cc`b`bb`c```````````````c`ccccccccccc`", "`c`````````c`c``bb```bbcc`ccccccccc`bb`bb`c`````c`c`````cc`ccccccccccc`", "`cc``c`c``cc`ccc````bbcc`b`ccc```c```b``bb`c```cc`cc```ccc`ccccccccccc`", "`cccca`acccc`cccc```bccc``b`ccc`cc````b``bb`cccc```ccccccc`ccccccccccc`", "`cccc```cccc`ccc```bbcc``d```cccc`d````b``bb`cc`````cccccc`ccccccccccc`", "`ccccccccccc`cc```bbc``bdbd`d````d`bddb`bb``b`cccccccccccc`ccccccccccc`", "`ccccccccccc`c```bbc`cc`bdbbd`d`dbbddb`c`bb``b`ccc``cccccc`ccccccccccc`", "`ccccccccccc````b````````bddbbbbbdddb`````bb`b`cc`bb``cccc`ccccccccccc`", "`ccccccccccc```bddd`````c``bddddddbb`c`c`d`b`b`c`b``bb`ccc`ccccccccccc`", "`ccccccccccc``dd`ddd`cc`cc```b```b``cc``d`d`b`c`bbbbb`cccc`ccccccccccc`", "`ccccccccccc`dddd`d`d`c`c```c`bbb`c````ddd```ccc```b`c```c`ccccccccccc`", "`ccccccccccc`bbbbb`ddd````c`c`bdb`c`c`d`d```d`ccccc`c`ddd``ccccccccccc`", "`ccccccccccc`bbbbbb`dd`d``c`c`bbb`c``ddd`b``d``c```c`dd``c`ccccccccccc`", "`ccccccccccc`bbbbbbb``dddd`````b````d`d`bb``d```ddd`````cc`ccccccccccc`", "`ccccccccccc`d`d`d`bbb``d`dddd```dddd```db``d``ddd`c`ccc`c`ccccccccccc`", "`ccccccccccc``d`d`d`d`bb```dddddddd`````dbb``d`````cc````c`ccccccccccc`", "`ccccccccccc`d`d````````bbd``````````d``dbb```bb`b``c`cc`c`ccccccccccc`", "`ccccccccccc``d``ddddddd``bbd````d``d``dbbbb`bccb````````c`ccccccccccc`", "`ccccccccccc`d`ddd`````ddd`bb`````d`d``dbbb`d`bcbb`b`ccc`c`ccccccccccc`", "`ccccccccccc``dd```d`d```dd`bd`````d```dbb`dd``bbbb`````cc`ccccccccccc`", "`ccccccccccc`b```d`d`d`d``dd`b````d`d``dbb`d`dd`bccb`b`ccc`ccccccccccc`", "`ccccccccccc`bb``d``````dd`d`bd``d```d`db`dd`````bcbb```cc`ccccccccccc`", "`ccccccccccc`bcb``bbbbb````dd`b`d``````db`d`dd`bb`bbbb`b`c`ccccccccccc`", "`ccccccccccc`bccb`bcccbb`dd`d``````dd`````d````bcc`bccb````ccccccccccc`", "`ccccccccccc``bbbb`c``cb````d`bbb`bbbb`dd`d`dd`bc`c`bcbb`b`ccccccccccc`", "`ccccccccccc`b`bbcb`c`cb`dd`d`ddd`bbbb`bb`d````bc``c`bbbb``ccccccccccc`", "`ccccccccccc````bccb`ccb````d``````dd`````d`dd`bbcccb`bccb`ccccccccccc`", "`ccccccccccc`c`b`bbbb`bb`dd`d`bd`d``````b`dd````bbbbb``bcb`ccccccccccc`", "`ccccccccccc`cc```bbcb`````dd`bd``d```d`db`d`dd``````d``bb`ccccccccccc`", "`ccccccccccc`ccc`b`bccb`dd`d`bbd```d`d```b`dd``d`d`d`d```b`ccccccccccc`", "`ccccccccccc`cc`````bbbb``dd`bbd````d````db`dd```d`d```dd``ccccccccccc`", "`ccccccccccc`c`ccc`b`bbcb`d`bbbd```d`d````bb`ddd`````ddd`d`ccccccccccc`", "`ccccccccccc`c````````bccb`bbbbd```d``dd``dbb``ddddddd``d``ccccccccccc`", "`ccccccccccc`c`cc`c``b`bb```bbd```d`````````dbb````````d`d`ccccccccccc`", "`ccccccccccc`c````cc`````d``bbd`````dddddddd```bb`d`d`d`d``ccccccccccc`", "`ccccccccccc`c`ccc`c`ddd``d``bd```dddd```dddd`d``bbb`d`d`d`ccccccccccc`", "`ccccccccccc`cc`````ddd```d``bb`ddd````b`````dddd``bbbbbbb`ccccccccccc`", "`ccccccccccc`c``dd`c```c``d``b`ddd``c`bbb`c`c``d`dd`bbbbbb`ccccccccccc`", "`ccccccccccc``ddd`c`ccccc`d```d`d`c`c`bdb`c`c````ddd`bbbbb`ccccccccccc`", "`ccccccccccc`c```c`b```ccc```ddd````c`bbb`c```c`c`d`d`dddd`ccccccccccc`", "`ccccccccccc`cccc`bbbbb`c`b`d`d``cc``b```b```cc`cc`ddd`dd``ccccccccccc`", "`ccccccccccc`ccc`bb``b`c`b`b`d`c`c`bbddddddb``c`````dddb```ccccccccccc`", "`ccccccccccc`cccc``bb`cc`b`bb`````bdddbbbbbddb````````b````ccccccccccc`", "`ccccccccccc`cccccc``ccc`b``bb`c`bddbbd`d`dbbdb`cc`cbb```c`ccccccccccc`", "`ccccccccccc`cccccccccccc`b``bb`bddb`d````d`dbdb``cbb```cc`ccccccccccc`", "`ccccccccccc`cccccc`````cc`bb``b````d`cccc```d``ccbb```ccc`cccc```cccc`", "`ccccccccccc`ccccccc```cccc`bb``b````cc`ccc`b``cccb```cccc`cccca`acccc`", "`ccccccccccc`ccc```cc`cc```c`bb``b```c```ccc`b`ccbb````ccc`cc``c`c``cc`", "`ccccccccccc`cc`````c`c`````c`bb`bb`ccccccccc`ccbb```bb``c`c`````````c`", "`ccccccccccc`c```````````````c`bb`b`cc```cccc`ccb```bb`dd``c`````````c`", "`ccccccccccc`c```````````````cc`b```ccc`cccc`ccbb``bb``d`c`c`````````c`", "`ccccccccccc`c```````````````ccc`b``ccc`cccc`cbb``bbddd`cc`cc`c```c`cc`", "`ccccccccccc`cc`````````````cccc`b``ccc`ccc`ccb```bbddd`cc`ccc`````ccc`", "`ccccccccccc`ccc```c```c```cccccc`b```cc``c`cbb``bbd`d`ccc`ccc`````ccc`", "`ccccccccccc`cccccc`````ccccccccc`b````c```ccb```bd``d`ccc`cccc```cccc`", "`ccccccccccc`ccccc```````ccccccccc``cccccc`ccb``bbdddd`ccc`cc``ccccccc`", "`ccccccccccc`ccccc```````ccccccccc```cccc``cbb``bbddddd`cc`cc```cccccc`", "`ccccccccccc`ccccc```````cccccccccc`c`cc`c`cb``bbd`dddd`cc`ccc`````ccc`", "`ccccccccccc`cccccc`````ccccccccccc``c``cc`cb``bd``ddddd`c`cc```````cc`", "`ccccccccccc`ccccccc```cccccccccccc```c`c``cb``bddddddddd``cc``ccc``cc`", "`ccccccccccc`cccccccccccccccccccccc`c``c`c`cb``bdddddddddd`cc``ccc``cc`", "`ccccccccccc```````````````````````````````````````````````cc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc```````cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`````ccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _qd[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcc```````````````````````````````````````````````ccccccccccc`", "`ccbbcccbbcc`c`ddddddddd`bb`cc`c`c``d`cccccccccccccccccccc`ccccccccccc`", "`ccbbcccbbcc`cc`ddddd``d`bb`c`c`c`c`dd`cccccccccccbccccccc`ccccccccccc`", "`ccbbbbbbbcc`cc`dddddddd`bb`ccc``c```d`ccccccccccbbbcccccc`ccccccccccc`", "`cccbbbbbccc`ccc`dddd``d`bb`cc`cc`c```d`ccccccccbbbbbccccc`ccccccccccc`", "`ccccccbbbcc`ccc`dddddd``b`c``cccc`````d`ccccccabbbbbacccc`ccccccccccc`", "`cccccccbbcc`ccc`ddd``d`bb``ccccccc`b``d`cccccabbbbbbbaccc`ccccccccccc`", "`cccccbccccc`ccc`ddddd``b`cc```c````b```d`ccccabbbbbbbaccc`ccccccccccc`", "`ccccbbbcccc`ccc`dd``d`bb`c`c```c```bb``d`cccbbbbbbbbbbbcc`ccccccccccc`", "`cccabbbaccc`ccc`dddd``b``ccccc`ccc`bb```d`cbbbbbbbbbbbbbc`ccccccccccc`", "`ccabbbbbacc`cc`dd``d`bb`c`cccc`ccc`bbb``d`ccbbbbbbbbbbbcc`ccccccccccc`", "`ccbbbbbbbcc`cc`dddd``b`c`c`ccc`ccc`bbb``d`cccabbbbbbbaccc`ccccccccccc`", "`ccabbbbbacc`c`dd`d``bb`c``ccc```cc`bbb``d`cccabbbbbbbaccc`ccccccccccc`", "`cccabbbaccc`cc`dd``bb`cc`ccccccccc`bbbb``d`cccabbbbbacccc`ccccccccccc`", "`ccccbbbcccc`ccc```bb`cc`b`ccc```c`d`bbb``d`ccccbbbbbccccc`ccccccccccc`", "`cccccbccccc`cccc`bb`ccc``b`ccc`cc`d``bb``d`cccccbbbcccccc`ccccccccccc`", "`ccccccccccc`ccc`bb`ccc`dd```cccc`dd`c`b``d`ccccccbccccccc`ccccccccccc`", "`ccccccccccc`cc`bb`````c`ddd``````dd`c````d`cccccccccccccc`ccccccccccc`", "`ccccccccccc`c`bb``c````c````dddd```c`````d`cccccc```ccccc`ccccccccccc`", "`ccccccccccc``bb``c`c````cccc````ccc```c``d`cccc``dd``cccc`ccccccccccc`", "`ccccccccccc`bb`c``c````````cccccc```c```d``cccc`d``dd`c`c`ccccccccccc`", "`ccccccccccc`b`d`c````c``c``````````c`c```d`ccc`ddddd`cc```ccccccccccc`", "`ccccccccccc````d`c`````c`c````c`````c```c`d`ccc```d`cc`d``ccccccccccc`", "`ccccccccccc```d`d`c````c`c`c`c`c`c`````c`dd``ccccc``c`dd``ccccccccccc`", "`ccccccccccc``d```d`cc```c````c`c``````c`dd````ccccc``d``c`ccccccccccc`", "`ccccccccccc`d``b``d``c````````c`````cc`d`d``c``ccc`````cc`ccccccccccc`", "`ccccccccccc```b``d`dd```d`````````cc``d``d`c````c`ccc```c`ccccccccccc`", "`ccccccccccc``b``d`b``dd````ccccccc``dd```d`c`````cc```c`c`ccccccccccc`", "`ccccccccccc`b``d```bc``ddd````````dd```b`d`c````d`cc`c``c`ccccccccccc`", "`ccccccccccc```d``b``bc````dddddddd``d``b`d``c``dd``cc`c`c`ccccccccccc`", "`ccccccccccc``d``d`b``bcb`d````````ddd``bc`d```dd````c`c`c`ccccccccccc`", "`ccccccccccc`d```d``b`cbc``d`````dd``d``bc`dd`dd`c`c``c`cc`ccccccccccc`", "`ccccccccccc`c`c``d`b`bcbc`d`cb``ddddd``bcb`ddd````````ccc`ccccccccccc`", "`ccccccccccc``````d`b`cbc``d`cb``d```d``b``b`d```c`c`c``cc`ccccccccccc`", "`ccccccccccc`c`c`c`d``bcbc`d`cb``ddddd```bb`d``d`````````c`ccccccccccc`", "`ccccccccccc```````d`bcbc``d``````````bbbdb`d`b`d``c`c`c```ccccccccccc`", "`ccccccccccc`c`c`c``d`bcbc`d`bbbbbbbbbdddb`d``cb`d`````````ccccccccccc`", "`ccccccccccc`````````d`bc``d`bdddbbbbbbbbb`d`cbcb`d``c`c`c`ccccccccccc`", "`ccccccccccc```c`c`c``d`b`d`bdbbb``````````d``cbcb`d```````ccccccccccc`", "`ccccccccccc`c`````````d``d`bb```ddddd``bc`d`cbcb``d`c`c`c`ccccccccccc`", "`ccccccccccc`cc``c`c`c```d`b``b``d```d``bc`d``cbc`b`d``````ccccccccccc`", "`ccccccccccc`ccc````````ddd`bcb``ddddd``bc`d`cbcb`b`d``c`c`ccccccccccc`", "`ccccccccccc`cc`c``c`c`dd`dd`cb``d``dd`````d``cbc`b``d```d`ccccccccccc`", "`ccccccccccc`c`c`c````dd```d``b``ddd````````d`bcb``b`d``d``ccccccccccc`", "`ccccccccccc`c`c`cc``dd``c``d`b``d``dddddddd````cb``b``d```ccccccccccc`", "`ccccccccccc`c``c`cc`d````c`d`b```dd````````ddd``cb```d``b`ccccccccccc`", "`ccccccccccc`c`c```cc`````c`d```dd``ccccccc````dd``b`d``b``ccccccccccc`", "`ccccccccccc`c```ccc`c````c`d``d``cc`````````d```dd`d``b```ccccccccccc`", "`ccccccccccc`cc`````ccc``c``d`d`cc`````c````````c``d``b``d`ccccccccccc`", "`ccccccccccc`c``d``ccccc````dd`c``````c`c````c```cc`d```d``ccccccccccc`", "`ccccccccccc``dd`c``ccccc``dd`c`````c`c`c`c`c`c````c`d`d```ccccccccccc`", "`ccccccccccc``d`cc`d```ccc`d`c```c`````c````c`c`````c`d````ccccccccccc`", "`ccccccccccc```cc`ddddd`ccc`d```c`c``````````c``c````c`d`b`ccccccccccc`", "`ccccccccccc`c`c`dd``d`cccc``d```c```cccccc````````c``c`bb`ccccccccccc`", "`ccccccccccc`cccc``dd``cccc`d``c```ccc````cccc````c`c``bb``ccccccccccc`", "`ccccccccccc`ccccc```cccccc`d`````c```dddd````c````c``bb`c`ccccccccccc`", "`ccccccccccc`cccccccccccccc`d````c`dd``````ddd`c`````bb`cc`ccccccccccc`", "`ccccccccccc`cccccccbcccccc`d``b`c`dd`cccc```dd`ccc`bb`ccc`ccccccccccc`", "`ccccccccccc`ccccccbbbccccc`d``bb``d`cc`ccc`b``ccc`bb`cccc`cccccbccccc`", "`ccccccccccc`cccccbbbbbcccc`d``bbb`d`c```ccc`b`cc`bb```ccc`ccccbbbcccc`", "`ccccccccccc`ccccabbbbbaccc`d``bbbb`ccccccccc`cc`bb``dd`cc`cccabbbaccc`", "`ccccccccccc`cccabbbbbbbaccc`d``bbb`cc```ccc``c`bb``d`dd`c`ccabbbbbacc`", "`ccccccccccc`cccabbbbbbbaccc`d``bbb`ccc`ccc`c`c`b``dddd`cc`ccbbbbbbbcc`", "`ccccccccccc`ccbbbbbbbbbbbcc`d``bbb`ccc`cccc`c`bb`d``dd`cc`ccabbbbbacc`", "`ccccccccccc`cbbbbbbbbbbbbbc`d```bb`ccc`ccccc``b``dddd`ccc`cccabbbaccc`", "`ccccccccccc`ccbbbbbbbbbbbccc`d``bb```c```c`c`bb`d``dd`ccc`ccccbbbcccc`", "`ccccccccccc`cccabbbbbbbacccc`d```b````c```cc`b``ddddd`ccc`cccccbccccc`", "`ccccccccccc`cccabbbbbbbaccccc`d``b`ccccccc``bb`d``ddd`ccc`ccbbccccccc`", "`ccccccccccc`ccccabbbbbacccccc`d`````cccc``c`b``dddddd`ccc`ccbbbcccccc`", "`ccccccccccc`cccccbbbbbcccccccc`d```c`cc`cc`bb`d``dddd`ccc`cccbbbbbccc`", "`ccccccccccc`ccccccbbbcccccccccc`d```c``ccc`bb`dddddddd`cc`ccbbbbbbbcc`", "`ccccccccccc`cccccccbccccccccccc`dd`c`c`c`c`bb`d``ddddd`cc`ccbbcccbbcc`", "`ccccccccccc`cccccccccccccccccccc`d``c`c`cc`bb`ddddddddd`c`ccbbcccbbcc`", "`ccccccccccc```````````````````````````````````````````````ccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbbbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbbccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _qh[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #FF00FF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cccbbbbbccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbbbbbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccbbcccbbcc```````````````````````````````````````````````ccccccccccc`", "`ccbbcccbbcc`ccccccccccc``c`c`cc```bddddd`cccccccccccccccc`ccccccccccc`", "`ccbbcccbbcc`cccccccccc``c`c`c`c```bd`dd`cccbbbacccabbbccc`ccccccccccc`", "`ccbbbbbbbcc`ccccccccc````c``ccc```bdddd`ccbbbbbacabbbbbcc`ccccccccccc`", "`cccbbbbbccc`ccccccccc`d`c`cc`ccc``bd`d`ccbbbbbbbcbbbbbbbc`ccccccccccc`", "`ccccccbbbcc`cccccccc``d``cccc``c``bbdd`ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`cccccccbbcc`cccccccc`db`ccccccc````bdd`ccbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccccccccccc`ccccccc``db````c```c```bbdd`cbbbbbbbbbbbbbbbc`ccccccccccc`", "`ccbbacabbcc`ccccccc`dbb```c```c`````bbd`cabbbbbbbbbbbbbac`ccccccccccc`", "`cbbbbcbbbbc`cccccc``dbb`ccc`cccc`c```b`cccabbbbbbbbbbbacc`ccccccccccc`", "`cbbbbbbbbbc`cccccc`dbbd`ccc`cccc`c````ccccabbbbbbbbbbbacc`ccccccccccc`", "`cbbbbbbbbbc`cccccc`dbbd`ccc`cccc`cc````ccccbbbbbbbbbbaccc`ccccccccccc`", "`cabbbbbbbac`cccccc`dbbd`cc```cccc`c`````ccccbbbbbbbbbcccc`ccccccccccc`", "`ccbbbbbbbcc`ccccc`dbbdd`ccccccccc`cc`````ccccbbbbbbbccccc`ccccccccccc`", "`cccbbbbbccc`ccccc`dbbd```c```ccc`d`cc`````ccccbbbbbcccccc`ccccccccccc`", "`ccccbbbcccc`ccccc`dbb``d`cc`ccc`dd`ccc``````cccbbbccccccc`ccccccccccc`", "`cccccbccccc`ccccc`db`d``d`cccc`dd```ccc```````ccbcccccccc`ccccccccccc`", "`ccccccccccc`ccccc`d`cd```d````dd```d`ccc``````ccccccccccc`ccccccccccc`", "`ccccccccccc`ccccc``dc`d```dddd````d`c`ccc````cccc``c``ccc`ccccccccccc`", "`ccccccccccc`cccc``d`dbcd`````````dbcd```ccc`cccc`dd`dd`cc`ccccccccccc`", "`ccccccccccc`ccc`dddd`dc`dd````ddd`cd````````cccc`dbbb`ccc`ccccccccccc`", "`ccccccccccc`cc```d``d`dbc`dddd`cbdd````ccccc`cccc`dbdd`cc`ccccccccccc`", "`ccccccccccc`c`dddddddd`dddbc`bddd``c``cc`c`c``c````dd`c`c`ccccccccccc`", "`ccccccccccc`````d```dd````dddd````d``c`cccc`bb`ddd```d``c`ccccccccccc`", "`ccccccccccc`ddddddddd``cc`````d```d``cccc``bb`ddd`cc``d`c`ccccccccccc`", "`ccccccccccc````d````d`c`c``````d`d``c`c``bb``````ccc`dd`c`ccccccccccc`", "`ccccccccccc`dddddddd``c````cc``d`d``cc`bbb`ddd`c`````d`cc`ccccccccccc`", "`ccccccccccc``d`d```d```c``cc`c``d``c`c`bb`dbbb`c`b`c``ccc`ccccccccccc`", "`ccccccccccc`dddddddd`c`c`b``cc``d``cc`bb`dbbdb``c``c``ccc`ccccccccccc`", "`ccccccccccc```d`d``d```c`dbb`cc`d`c`c`bb`dbbb```c`c`cc`cc`ccccccccccc`", "`ccccccccccc`dddddddd``c``ddbb`c```cc`bb`dbbdb``c``c`cc`cc`ccccccccccc`", "`ccccccccccc``d````d``c``d`ddb`````cc`bb`dbbbb`c```cc```cc`ccccccccccc`", "`ccccccccccc`ddddddd``c``d``db``dd````bb`dbdbb`c`c`ccc`b`c`ccccccccccc`", "`ccccccccccc``d``dd```c``db`ddb```ddd``b`dbb```c```c``bbb``ccccccccccc`", "`ccccccccccc`ddddd`b```c`db`dbb`d````dd`````bb``c```bbbbbb`ccccccccccc`", "`ccccccccccc````d`bb`c`c`d``ddb`d`ddd``dd`bbbd`c`c`bbbbbb``ccccccccccc`", "`ccccccccccc`ddd`bbb``c``d`ddb`d`dbbbd```bbddd```c`bbbb``d`ccccccccccc`", "`ccccccccccc`d``bbbb`c```dddbb```dbbbd`d`bdd`d``c``bbb`ddd`ccccccccccc`", "`ccccccccccc``bbbbbb`c`c`dbbb`dd``ddd`d`bdd``d`c`c`bb`d````ccccccccccc`", "`ccccccccccc`bbbbbb```c``bb`````dd````d`bbd`bd`c```b`ddddd`ccccccccccc`", "`ccccccccccc``bbb``c```c```bbd`b``ddd```bdd`bd``c```dd``d``ccccccccccc`", "`ccccccccccc`c`b`ccc`c`c`bbdbd`bb````dd``bd``d``c``ddddddd`ccccccccccc`", "`ccccccccccc`cc```cc```c`bbbbd`bb`cc`````bdd`d``c``d````d``ccccccccccc`", "`ccccccccccc`cc`cc`c``c``bdbbd`bb`cc```c`bbdd``c``dddddddd`ccccccccccc`", "`ccccccccccc`cc`cc`c`c```bbbd`bb`c`c`d`cc`bbd`c```d``d`d```ccccccccccc`", "`ccccccccccc`ccc``c``c``bdbbd`bb`cc``d``cc``b`c`c`dddddddd`ccccccccccc`", "`ccccccccccc`ccc``c`b`c`bbbd`bb`c`c``d``c`cc``c```d```d`d``ccccccccccc`", "`ccccccccccc`cc`d`````c`ddd`bbb`cc``d`d``cc````c``dddddddd`ccccccccccc`", "`ccccccccccc`c`dd`ccc``````bb``c`c``d`d``````c`c`d````d````ccccccccccc`", "`ccccccccccc`c`d``cc`ddd`bb``cccc``d```d`````cc``ddddddddd`ccccccccccc`", "`ccccccccccc`c``d```ddd`bb`cccc`c``d````dddd````dd```d`````ccccccccccc`", "`ccccccccccc`c`c`dd````c``c`c`cc``c``dddb`cbddd`dddddddd`c`ccccccccccc`", "`ccccccccccc`cc`ddbd`cccc`ccccc````ddbc`dddd`cbd`d``d```cc`ccccccccccc`", "`ccccccccccc`ccc`bbbd`cccc````````dc`ddd````dd`cd`dddd`ccc`ccccccccccc`", "`ccccccccccc`cc`dd`dd`cccc`ccc```dcbd`````````dcbd`d``cccc`ccccccccccc`", "`ccccccccccc`ccc``c``cccc````ccc`c`d````dddd```d`cd``ccccc`ccccccccccc`", "`ccccccccccc`ccccccccccc``````ccc`d```dd````d```dc`d`ccccc`ccccccccccc`", "`ccccccccccc`ccccccccbcc```````ccc```dd`cccc`d``d`bd`ccccc`cccccbccccc`", "`ccccccccccc`cccccccbbbccc``````ccc`dd`ccc`cc`d``bbd`ccccc`ccccbbbcccc`", "`ccccccccccc`ccccccbbbbbcccc`````cc`d`ccc```c```dbbd`ccccc`cccbbbbbccc`", "`ccccccccccc`cccccbbbbbbbcccc`````cc`ccccccccc`ddbbd`ccccc`ccbbbbbbbcc`", "`ccccccccccc`ccccbbbbbbbbbcccc`````c`cccc```cc`dbbd`cccccc`cabbbbbbbac`", "`ccccccccccc`cccabbbbbbbbbbcccc````cc`cccc`ccc`dbbd`cccccc`cbbbbbbbbbc`", "`ccccccccccc`ccabbbbbbbbbbbacccc````c`cccc`ccc`dbbd`cccccc`cbbbbbbbbbc`", "`ccccccccccc`ccabbbbbbbbbbbaccc`b```c`cccc`ccc`bbd``cccccc`cbbbbcbbbbc`", "`ccccccccccc`cabbbbbbbbbbbbbac`dbb`````c```c```bbd`ccccccc`ccbbacabbcc`", "`ccccccccccc`cbbbbbbbbbbbbbbbc`ddbb```c```c````bd``ccccccc`ccccccccccc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc`ddb````ccccccc`bd`cccccccc`ccbbccccccc`", "`ccccccccccc`cbbbbbbbbbbbbbbbcc`ddbb``c``cccc``d``cccccccc`ccbbbcccccc`", "`ccccccccccc`cbbbbbbbcbbbbbbbcc`d`db```cc`cc`c`d`ccccccccc`cccbbbbbccc`", "`ccccccccccc`ccbbbbbacabbbbbcc`ddddb```ccc``c````ccccccccc`ccbbbbbbbcc`", "`ccccccccccc`cccbbbacccabbbccc`dd`db```c`c`c`c``cccccccccc`ccbbcccbbcc`", "`ccccccccccc`cccccccccccccccc`dddddb```cc`c`c``ccccccccccc`ccbbcccbbcc`", "`ccccccccccc```````````````````````````````````````````````ccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbcccbbcc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbbbbcc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccbbbbbccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _qs[] = { /* width height ncolors chars_per_pixel */ "71 96 5 1", /* colors */ "` c #000000", "a c #00FFFF", "b c #FF0000", "c c #FFFFFF", "d c #FFFF00", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccc`````ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc```````cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`cc``ccc``cc```````````````````````````````````````````````ccccccccccc`", "`cc``ccc``cc`cccccccccc``c``c`c`cb`d``dddd`ccccccccccccccc`ccccccccccc`", "`cc``ccc``cc`cc`cccccc`````c`c``cb`dd`ddd`ccccccc`cccccccc`ccccccccccc`", "`cc```````cc`cc`cccccc``c`c``cc`cb`dddddd`cccccc```ccccccc`ccccccccccc`", "`ccc`````ccc`cc`cccccc```c`cc`cc`b`d``dd`cccccc`````cccccc`ccccccccccc`", "`cccccc```cc`c`d`ccccc`c``cccc`c`b`dd`dd`ccccc```````ccccc`ccccccccccc`", "`ccccccc``cc`c`d`cccc``c`cccccc``bb`ddddd`ccc`````````cccc`ccccccccccc`", "`ccccc`ccccc`c`d`cccc`bc````c````bb`d``dd`cc```````````ccc`ccccccccccc`", "`cccc```cccc`c`d`cccc`bc```c```c`bbb`d`d`cc`````````````cc`ccccccccccc`", "`ccc`````ccc``ddd`ccc`bc`ccc`ccc`cbb`dd`ccc`````````````cc`ccccccccccc`", "`cc```````cc``d`d`ccc`bc`ccc`cccc`bbb`d`cc```````````````c`ccccccccccc`", "`c`````````c``ddd`cc`bbc`ccc`cccc`cbbb``cc```````````````c`ccccccccccc`", "`c`````````c`c`d`ccc`bc``cc```cccc`bbb``cc```````````````c`ccccccccccc`", "`c`````````c`c`d`ccc`bc``ccccccccc`cbbb`cc``````c`c``````c`ccccccccccc`", "`cc``c`c``cc``````cc`c````c```ccc`b`cbbb`cc````cc`cc````cc`ccccccccccc`", "`cccca`acccc``ddd`c`bc````cc`ccc`b``cbbb``cccccc```ccccccc`ccccccccccc`", "`cccc```cccc`c```cc`bc```d`cccc```d``cbbb``cccc`````cccccc`ccccccccccc`", "`ccccccccccc``ddd`c`bc`d``d````d`d`dd`cbbb``cccccccccccccc`ccccccccccc`", "`ccccccccccc``ddd`c````dd``d`d`d``dd```cccc``cccccccbbcccc`ccccccccccc`", "`ccccccccccc`c```cc````dddd`````ddd````````b``ccccbb``bbcc`ccccccccccc`", "`ccccccccccc`c`b`c```c``d`dddddd`d```cc``bbbb`dccbb`dd`bbc`ccccccccccc`", "`ccccccccccc`c`d``d``c``dd`d`d`dd``cc```bbbc`d``ccbb``bbc``ccccccccccc`", "`ccccccccccc`c`d`bdd`````ddddddd``c```bbbbc`d``d``ccbbcc`b`ccccccccccc`", "`ccccccccccc```d`bbd``c``d`d`dd``c```bbbcc`d```ddd`c`cc`db`ccccccccccc`", "`ccccccccccc```d`bbd``````dddd``c``bbbbcc`d`b```ddd``c```d`ccccccccccc`", "`ccccccccccc```d`bbdd``c``ddd``c``bbbbcbb`d````````d`````d`ccccccccccc`", "`ccccccccccc```d`cbbd```c```d`c``bbbccbbb`d`bbb`````cccc`d`ccccccccccc`", "`ccccccccccc```d``bbdd````dd`c``bbbcbbb```d````````ccccc`d`ccccccccccc`", "`ccccccccccc```d`c`bbd```dbbd``bbbcbb`````dd`bbbb`cccccc`d`ccccccccccc`", "`ccccccccccc```d``cbbdd``dbbd`bbbcb```cc```d`````cc`cc``db`ccccccccccc`", "`ccccccccccc```d`c``bbdd`dbbd`bbcb```cccc```d`bb`c```````b`ccccccccccc`", "`ccccccccccc```d``c`bbbdd`dd`bbc```bcc``cc```d`````d```````ccccccccccc`", "`ccccccccccc```d`c`c`bbbdd```bc```cc`````cc```d`b`dd`d```d`ccccccccccc`", "`ccccccccccc```d``c`c`bbbbbbbb```ccccccccccc```d`ddd`dddd``ccccccccccc`", "`ccccccccccc```d`c`c`c````````````````````````````ddddd``d`ccccccccccc`", "`ccccccccccc```d``c`c`bbbbbbbbbbbbbbbbbbbbbbbbbbb``````dd``ccccccccccc`", "`ccccccccccc```d`c`c```c```c```c```c```c```c```c```dddd````ccccccccccc`", "`ccccccccccc````dddd```c```c```c```c```c```c```c```````d```ccccccccccc`", "`ccccccccccc``dd``````bbbbbbbbbbbbbbbbbbbbbbbbbbb`c`c``d```ccccccccccc`", "`ccccccccccc`d``ddddd````````````````````````````c`c`c`d```ccccccccccc`", "`ccccccccccc``dddd`ddd`d```ccccccccccc```bbbbbbbb`c`c``d```ccccccccccc`", "`ccccccccccc`d```d`dd`b`d```cc`````cc```cb```ddbbb`c`c`d```ccccccccccc`", "`ccccccccccc```````d`````d```cc``ccb```cbb`dd`ddbbb`c``d```ccccccccccc`", "`ccccccccccc`b```````c`bb`d```cccc```bcbb`dbbd`ddbb``c`d```ccccccccccc`", "`ccccccccccc`bd``cc`cc`````d```cc```bcbbb`dbbd``ddbbc``d```ccccccccccc`", "`ccccccccccc`d`cccccc`bbbb`dd`````bbcbbb``dbbd```dbb`c`d```ccccccccccc`", "`ccccccccccc`d`ccccc````````d```bbbcbbb``d`dd````ddbb``d```ccccccccccc`", "`ccccccccccc`d`cccc`````bbb`d`bbbccbbb````d```````dbbc`d```ccccccccccc`", "`ccccccccccc`d`````d````````d`bbcbbbb``c``ddd`````ddbb`d```ccccccccccc`", "`ccccccccccc`d``````ddd```b`d`ccbbbb``c``dddd``````dbb`d```ccccccccccc`", "`ccccccccccc`bd``c`c`ddd```d`ccbbb```c``dd`d`d`````dbb`d```ccccccccccc`", "`ccccccccccc`b``cbbcc``d``d`cbbbb```c``ddddddd`````ddb`d`c`ccccccccccc`", "`ccccccccccc```bb``bbcc``d`cbbb```c```dd`d`d`dd`````d``d`c`ccccccccccc`", "`ccccccccccc``bb`dd`bbccd`bbbb``c````d`dddddd`d``````c`b`c`ccccccccccc`", "`ccccccccccc`ccbb``bbcccc``b````````ddd`````dddd````cc```c`ccccccccccc`", "`ccccccccccc`ccccbbccccccc``c``````dd``d`d`d``dd````c`ddd``ccccccccccc`", "`ccccccccccc`cccccccccccccc``bbb``dd`d`d````d``d`cb`c`ddd``ccccccccccc`", "`ccccccccccc`cccccc`````cccc``bbbc``d```cccc`d```cb`cc```c`cccc```cccc`", "`ccccccccccc`ccccccc```cccccc``bbbc``b`ccc`cc````cb`c`ddd``cccca`acccc`", "`ccccccccccc`cc````cc`cc````cc`bbbb`b`ccc```c````c`cc``````cc``c`c``cc`", "`ccccccccccc`c``````c`c``````cc`bbbc`ccccccccc``cb`ccc`d`c`c`````````c`", "`ccccccccccc`c```````````````cc``bbb`cccc```cc``cb`ccc`d`c`c`````````c`", "`ccccccccccc`c```````````````cc``bbbc`cccc`ccc`cbb`cc`ddd``c`````````c`", "`ccccccccccc`c```````````````cc`d`bbb`cccc`ccc`cb`ccc`d`d``cc```````cc`", "`ccccccccccc`cc`````````````cc``dd`bbc`ccc`ccc`cb`ccc`ddd``ccc`````ccc`", "`ccccccccccc`cc`````````````c``d`d`bbb`c```c```cb`cccc`d`c`cccc```cccc`", "`ccccccccccc`ccc```````````cc`dd``d`bb````c````cb`cccc`d`c`ccccc`ccccc`", "`ccccccccccc`cccc`````````ccc`ddddd`bb``cccccc`b``cccc`d`c`cc``ccccccc`", "`ccccccccccc`ccccc```````ccccc`dd`dd`b`c`cccc``b`ccccc`d`c`cc```cccccc`", "`ccccccccccc`cccccc`````cccccc`dd``d`b`cc`cc`c```cccccc`cc`ccc`````ccc`", "`ccccccccccc`ccccccc```cccccc`dddddd`bc`cc``c`c``cccccc`cc`cc```````cc`", "`ccccccccccc`cccccccc`cccccc``ddd`dd`bc``c`c`````cccccc`cc`cc``ccc``cc`", "`ccccccccccc`cccccccccccccc``dddd``d`bc`c`c``c``cccccccccc`cc``ccc``cc`", "`ccccccccccc```````````````````````````````````````````````cc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc``ccc``cc`", "`cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc```````cc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`````ccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "`ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _tc[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aa``a``````aaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aa``aa````aaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaa```aaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa`````aaaaa`````a`a`````aaaaa```aaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaa``a```a``aaaa```aa`aa```aaaaa`````aaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaa```aaaaaaaa```````aaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaa`````aaaaaaa```````aaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa```````````aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa```a`a```aaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaa```aaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaa```````````````aaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaa`````a`a`````aaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaa```aa`aa```aaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaa```aaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaa`````aaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaa```aa`aa```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaa`````a`a`````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaa`````aaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaa```aaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaa```aa`aa```aaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaa`````a`a`````aaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaa```````````````aaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaaaaaa```aaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaa```a`a```aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaa```````aaaaaaa`````aaaaaa```````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaa```````aaaaaaaa```aaaaaaa```````````aa`", "`aaaaaaaaaaaaaaaa```aa`aa```aaaaa`````aaaaa```aa`aa```aaaa``a```a``aaa`", "`aaaaaaaaaaaaaaa`````a`a`````aaaaa```aaaaa`````a`a`````aaaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaa`````aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaa```aaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaa```a```a```aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaa````aa``aa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaa``````a``aa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _td[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaabaaaaaabbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaabbaaaabbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaabbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbaaaaabbbbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbabbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbaaaaaaaaabbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaabbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbaaaaabbbbbbbbaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbaaaaaaabbbbbbbbaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbaaaaaaaaabbbbbbbbaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbaaaaaaaaabbbbbbbbbabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbaaabbbbbbbbbbaaaaabbbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbabbbbbbbbbbaaaaaaabbbbbbbbaaaaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbaaaaabbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbaaabbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbabbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbaaaabbaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbaaaaaabaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _th[] = { /* width height ncolors chars_per_pixel */ "71 96 3 1", /* colors */ "` c #000000", "a c #FF0000", "b c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabbaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbaabaabbaabbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbaabaabbaabbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbaabaabbaabbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbaabaaaaaabbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbaabbaaaabbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbaaabaaabbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbaaaabaaaabbbbbbaaaaaaaaabbbaaaabbbaaaabbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbaaaaaaabbbaaaaaabaaaaaabbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbaaaaabbbaaaaaaabaaaaaaabbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbaaaaaaaaabbbbbbbbbaaabbbbaaaaaaaaaaaaaaabbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbaaaaaaabbbbbbbbbbbabbbbbaaaaaaaaaaaaaaabbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbaaaaabbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbaaabbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbabbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbaaaaaaabbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbaaaaabbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbaaabbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbbbbbaaabbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbbbbaaaaabbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbbbaaaaaaabbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbabbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbaaabbbbaaaaaaabaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbaaaaabbbbaaaaaabaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbaaaaaaabbbbaaaabbbaaaabbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbabbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbaaabbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbaaaaabbbb`", "`bbbbbbbbbbbbbbbbbbbbbabbbbbaaaaaaaaaaaaaaabbbbbabbbbbbbbbbbaaaaaaabbb`", "`bbbbbbbbbbbbbbbbbbbbaaabbbbaaaaaaaaaaaaaaabbbbaaabbbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbbaaaaabbbaaaaaaabaaaaaaabbbaaaaabbbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbbaaaaaaabbbaaaaaabaaaaaabbbaaaaaaabbbbbbbaaaaaaaaabb`", "`bbbbbbbbbbbbbbbbbaaaaaaaaabbbaaaabbbaaaabbbaaaaaaaaabbbbbbaaaabaaaabb`", "`bbbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbbbaaaaaaaaaaabbbbbbaaabaaabbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbaaaaaaaaaaaaabbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbbaaaabbaabb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbaaaaaabaabb`", "`bbbbbbbbbbbbbbaaaaaaaaaaaaaaabbbbbbbbbbbaaaaaaaaaaaaaaabbbaabbaabaabb`", "`bbbbbbbbbbbbbbaaaaaaabaaaaaaabbbbbbbbbbbaaaaaaabaaaaaaabbbaabbaabaabb`", "`bbbbbbbbbbbbbbbaaaaaabaaaaaabbbbbbbbbbbbbaaaaaabaaaaaabbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbaaaabbbaaaabbbbbbbbbbbbbbbaaaabbbaaaabbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaabbaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaabaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaabbaabb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "`bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb`", "```````````````````````````````````````````````````````````````````````" }; /* XPM */ static const char * const _ts[] = { /* width height ncolors chars_per_pixel */ "71 96 2 1", /* colors */ "` c #000000", "a c #FFFFFF", /* pixels */ "```````````````````````````````````````````````````````````````````````", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``aa````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa``a``aa``aaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aa``a``````aaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aa``aa````aaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaa`aaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaa```aaaaaa```````````````aaaaa`aaaaa```````````````aaaaaaaaaaaaaa`", "`aaaa`````aaaaa``````a`a``````aaaa```aaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaa```````aaaaa````aa`aa````aaaa`````aaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaa```aaaaaaaa```````aaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaa`````aaaaaa`````````aaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aa`````````aaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaa``a`a``aaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaa```aaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaa``````a`a``````aaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaa````aa`aa````aaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaa```aaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaa`````aaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaa````aa`aa````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaaaaaaaaa``````a`a``````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaa`````aaaaaaa```````aaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaa```aaaaaaaaa`````aaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaa````aa`aa````aaaaa```aaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaa``````a`a``````aaaaa`aaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaa```````````````aaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaaaa```aaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaaaaa``a`a``aaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaa`````````aaaaaa`````aaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaa```````aaaaaaaa```aaaaaaaaa`````````aa`", "`aaaaaaaaaaaaaaa````aa`aa````aaaa`````aaaa````aa`aa````aaaaa```````aaa`", "`aaaaaaaaaaaaaa``````a`a``````aaaa```aaaa``````a`a``````aaaaa`````aaaa`", "`aaaaaaaaaaaaaa```````````````aaaaa`aaaaa```````````````aaaaaa```aaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaa`aaaaaa`", "`aaaaaaaaaaaaaa```````````````aaaaaaaaaaa```````````````aaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaa`````````````aaaaaaaaaaaaa`````````````aaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaa```````````aaaaaaaaaaaaaaa```````````aaaaaa````aa``aa`", "`aaaaaaaaaaaaaaaaa`````````aaaaaaaaaaaaaaaaa`````````aaaaaa``````a``aa`", "`aaaaaaaaaaaaaaaaaa```````aaaaaaaaaaaaaaaaaaa```````aaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaa`````aaaaaaaaaaaaaaaaaaaaa`````aaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaa```aaaaaaaaaaaaaaaaaaaaaaa```aaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaaaaaaaaaaaaaaaaa`aaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``aa``a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa``````a``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa````aa``aa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`", "```````````````````````````````````````````````````````````````````````" }; kgames-2.2/Xkw/meson.build000066400000000000000000000060301416764561500155550ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # flex = find_program('flex') bison = find_program('bison') make_resource = find_program('make-resource') res_gen = generator(make_resource, output : ['@BASENAME@-res.h'], arguments : [ '@INPUT@', '@OUTPUT@' ] ) flex_gen = generator(flex, output : ['@BASENAME@.c'], arguments : [ '-o', '@OUTPUT@', '-P', 'LayYY', '@INPUT@']) flex_files = flex_gen.process('laylex.l') bison_gen = generator(bison, output : ['@BASENAME@.c', '@BASENAME@.h'], arguments : [ '-o', '@OUTPUT0@', '--defines=@OUTPUT1@', '-p', 'LayYY', '@INPUT@']) bison_files = bison_gen.process('laygram.y') make_cards_svg = find_program('make-cards-svg') cards_files = custom_target('svg-cards', output : ['cards-svg.c', 'cards-svg.h'], command : [make_cards_svg, '@OUTPUT0@', '@OUTPUT1@']) install_data('cards/kgames.svg', rename : 'kgames.svg', install_dir : svg_icon_dir) srcs_xkw = [ 'Animate.c', 'Cards.c', 'CardsUtil.c', 'Dialog.c', 'Draw.c', 'Events.c', 'Hand.c', 'HandDrag.c', 'Icon.c', 'Layout.c', 'medium.c', 'Message.c', 'Pad.c', 'padtest.c', 'SuitCards.c', 'Thermo.c', 'Svg.c', 'KCommand.c', 'KLabel.c', 'KMenuButton.c', 'KPorthole.c', 'KScrollbar.c', 'KSimple.c', 'KSimpleMenu.c', 'KSme.c', 'KSmeBSB.c', 'KSmeLine.c', 'KTextLine.c', 'KToggle.c', 'XkwInit.c', ] lib_xkw = library('Xkw', srcs_xkw, flex_files, bison_files, cards_files, dependencies: x_libs, install: true, version: '3.0.0', include_directories: inc) executable('lodemo', 'lodemo.c', dependencies: x_libs, include_directories: inc, link_with: [lib_xkw], install: false) executable('padtest', 'padtest.c', dependencies: x_libs, include_directories: inc, link_with: [lib_xkw], install: false) #install_data('PadTest.ad', rename: 'PadTest', install_dir : app_defaults) kgames-2.2/Xkw/padtest.c000066400000000000000000000031021416764561500152200ustar00rootroot00000000000000# include # include # include # include # include # include # include # include # include Widget toplevel; Widget pad; static int row, col; void CheckScroll (Widget w) { Arg arg[1]; Dimension rows; XtSetArg (arg[0], XtNnumRows, &rows); XtGetValues (w, arg, 1); while (row >= rows) { XkwPadScroll (w, 0, rows, -1); row--; } } static void append (XtPointer closure, int *source, XtInputId *inputid) { Widget w = *(Widget *)closure; int fd = *(int *) source; char buf[1024], c; int n, count; (void) inputid; c = XkwPadNormal; XkwPadAttributes (w, row, col, &c, 1); XkwPadUpdate (w); do { count = read (fd, buf, sizeof (buf)); if (count <= 0) exit (0); for (n = 0; n < count; n++) { c = buf[n]; if (c == '\n') { col = 0; row++; CheckScroll (w); } else if (isprint (c)) { XkwPadText (w, row, col, &c, 1); col++; } } ioctl (fd, FIONREAD, &count); } while (count > 0); c = XkwPadInverse; XkwPadAttributes (w, row, col, &c, 1); XkwPadUpdate (w); } int main (int argc, char **argv) { #ifdef APPDEFAULTS setenv("XAPPLRESDIR", APPDEFAULTS, 1); #endif toplevel = XtInitialize (argv[0], "PadTest", 0, 0, &argc, argv); pad = XtCreateManagedWidget ("pad", padWidgetClass, toplevel, NULL, 0); XtAddInput (0, (XtPointer) (intptr_t) XtInputReadMask, append, (XtPointer) &pad); XtRealizeWidget (toplevel); XtMainLoop (); } kgames-2.2/Xkw/playing_card000066400000000000000000000063541416764561500160030ustar00rootroot00000000000000#define playing_card_width 64 #define playing_card_height 64 static unsigned char playing_card_bits[] = { 0x77, 0xd5, 0xd7, 0xdd, 0x77, 0xd5, 0xd7, 0xdd, 0xbb, 0xea, 0xae, 0xbb, 0xbb, 0xea, 0xae, 0xbb, 0x5d, 0x75, 0x5d, 0x77, 0x5d, 0x75, 0x5d, 0x77, 0xee, 0xba, 0xba, 0xee, 0xae, 0xba, 0xba, 0xee, 0x77, 0x5d, 0x75, 0xdd, 0x77, 0x5d, 0x75, 0xdd, 0xbb, 0xae, 0xea, 0xba, 0xbb, 0xae, 0xea, 0xba, 0x5d, 0x57, 0xd5, 0x75, 0x5d, 0x57, 0xd5, 0x75, 0xae, 0xab, 0xaa, 0xeb, 0xae, 0xab, 0xaa, 0xeb, 0xd7, 0x55, 0x55, 0xd7, 0xd7, 0x51, 0x55, 0xd7, 0xeb, 0xae, 0xaa, 0xae, 0xeb, 0xa2, 0xaa, 0xae, 0x75, 0x5d, 0x55, 0x5d, 0x75, 0x44, 0x15, 0x5d, 0xba, 0xbb, 0xea, 0xba, 0xba, 0x88, 0x8a, 0xba, 0x5d, 0x77, 0x75, 0x75, 0x1d, 0x11, 0x45, 0x75, 0xee, 0xee, 0xba, 0xea, 0x2e, 0x22, 0xa2, 0xea, 0xd7, 0xdd, 0x5d, 0xd5, 0x57, 0x44, 0x10, 0xd5, 0xab, 0xbb, 0xef, 0xaa, 0xab, 0x88, 0x88, 0xaa, 0x57, 0x77, 0x77, 0xd5, 0x57, 0x11, 0x45, 0xd5, 0xae, 0xee, 0xba, 0xea, 0xae, 0x22, 0xa2, 0xea, 0x5d, 0xdd, 0x5d, 0x75, 0x5d, 0x45, 0x10, 0x75, 0xba, 0xba, 0xef, 0xba, 0xba, 0x8a, 0x88, 0xba, 0x75, 0x75, 0x77, 0x5d, 0x75, 0x15, 0x45, 0x5d, 0xea, 0xea, 0xba, 0xae, 0xea, 0x2a, 0xa2, 0xae, 0xdd, 0xd5, 0x5d, 0x77, 0xdd, 0x55, 0x50, 0x77, 0xae, 0xab, 0xaf, 0xeb, 0xae, 0xab, 0xa8, 0xeb, 0xd7, 0x55, 0x57, 0xd7, 0xd7, 0x55, 0x55, 0xd7, 0xeb, 0xaa, 0xaa, 0xae, 0xeb, 0xaa, 0xaa, 0xae, 0x75, 0x57, 0x55, 0x5d, 0x75, 0x57, 0x55, 0x5d, 0xba, 0xae, 0xea, 0xba, 0xba, 0xae, 0xaa, 0xba, 0xdd, 0x5d, 0x75, 0x75, 0xdd, 0x5d, 0x75, 0x75, 0xae, 0xbb, 0xba, 0xea, 0xae, 0xbb, 0xba, 0xea, 0x77, 0x77, 0x5d, 0xd5, 0x77, 0x77, 0x5d, 0xd5, 0xeb, 0xee, 0xee, 0xaa, 0xeb, 0xee, 0xae, 0xaa, 0xd7, 0xdd, 0x77, 0xd5, 0xd7, 0xdd, 0x77, 0xd5, 0xae, 0xbb, 0xbb, 0xea, 0xae, 0xbb, 0xbb, 0xea, 0x5d, 0x77, 0x5d, 0x75, 0x5d, 0x77, 0x5d, 0x75, 0xba, 0xee, 0xee, 0xba, 0xba, 0xee, 0xae, 0xba, 0x75, 0xdd, 0x77, 0x5d, 0x75, 0xdd, 0x77, 0x5d, 0xea, 0xba, 0xbb, 0xae, 0xea, 0xba, 0xbb, 0xae, 0xd5, 0x75, 0x5d, 0x57, 0xd5, 0x75, 0x5d, 0x57, 0xaa, 0xeb, 0xae, 0xab, 0xaa, 0xeb, 0xae, 0xab, 0x55, 0xd7, 0xd7, 0x55, 0x55, 0xd7, 0xd7, 0x55, 0xaa, 0xae, 0xeb, 0xae, 0xaa, 0xae, 0xeb, 0xae, 0x55, 0x5d, 0x75, 0x5d, 0x55, 0x5d, 0x75, 0x5d, 0xea, 0xba, 0xba, 0xbb, 0xea, 0xba, 0xba, 0xbb, 0x75, 0x75, 0x5d, 0x77, 0x75, 0x75, 0x5d, 0x77, 0xba, 0xea, 0xee, 0xee, 0xba, 0xea, 0xee, 0xee, 0x5d, 0xd5, 0xd7, 0xdd, 0x5d, 0xd5, 0xd7, 0xdd, 0xef, 0xaa, 0xab, 0xbb, 0xef, 0xaa, 0xab, 0xbb, 0x77, 0xd5, 0x57, 0x77, 0x77, 0xd5, 0x57, 0x77, 0xba, 0xea, 0xae, 0xee, 0xba, 0xea, 0xae, 0xee, 0x5d, 0x75, 0x5d, 0xdd, 0x5d, 0x75, 0x5d, 0xdd, 0xef, 0xba, 0xba, 0xba, 0xef, 0xba, 0xba, 0xba, 0x77, 0x5d, 0x75, 0x75, 0x77, 0x5d, 0x75, 0x75, 0xba, 0xae, 0xea, 0xea, 0xba, 0xae, 0xea, 0xea, 0x5d, 0x77, 0xdd, 0xd5, 0x5d, 0x77, 0xdd, 0xd5, 0xaf, 0xeb, 0xae, 0xab, 0xaf, 0xeb, 0xae, 0xab, 0x57, 0xd7, 0xd7, 0x55, 0x57, 0xd7, 0xd7, 0x55, 0xaa, 0xae, 0xeb, 0xaa, 0xaa, 0xae, 0xeb, 0xaa, 0x55, 0x5d, 0x75, 0x57, 0x55, 0x5d, 0x75, 0x57, 0xaa, 0xba, 0xba, 0xae, 0xaa, 0xba, 0xba, 0xae, 0x75, 0x75, 0xdd, 0x5d, 0x55, 0x75, 0xdd, 0x5d, 0xba, 0xea, 0xae, 0xbb, 0xba, 0xea, 0xae, 0xbb, 0x5d, 0xd5, 0x77, 0x77, 0x5d, 0xd5, 0x77, 0x77, 0xae, 0xaa, 0xeb, 0xee, 0xae, 0xaa, 0xeb, 0xee}; kgames-2.2/Xkw/rank.bm000066400000000000000000000051511416764561500146710ustar00rootroot00000000000000/* * Spider * * (c) Copyright 1989, Donald R. Woods and Sun Microsystems, Inc. * (c) Copyright 1990, David Lemke and Network Computing Devices Inc. * * See copyright.h for the terms of the copyright. * * @(#)rank.bm 2.1 90/04/25 * */ #define rank_width 9 #define rank_height 14 static char rank_bits[13][28] = { { 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x6c, 0x00, 0x6c, 0x00, 0x6c, 0x00, 0x6c, 0x00, 0xc6, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xc6, 0x00, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, }, { 0x7c, 0x00, 0xfe, 0x00, 0xc7, 0x01, 0x83, 0x01, 0x80, 0x01, 0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x0e, 0x00, 0x87, 0x01, 0xff, 0x01, 0xff, 0x01, }, { 0xff, 0x01, 0xff, 0x01, 0xc3, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x78, 0x00, 0xfc, 0x00, 0xc8, 0x01, 0x80, 0x01, 0x80, 0x01, 0x82, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, }, { 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xd8, 0x00, 0xd8, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xc6, 0x00, 0xc6, 0x00, 0xff, 0x01, 0xff, 0x01, 0xc0, 0x00, 0xe0, 0x01, 0xe0, 0x01, }, { 0xff, 0x00, 0xff, 0x00, 0x03, 0x00, 0x03, 0x00, 0x7b, 0x00, 0xff, 0x00, 0xc7, 0x01, 0x82, 0x01, 0x80, 0x01, 0x80, 0x01, 0x82, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, }, { 0x7c, 0x00, 0xfe, 0x00, 0xc7, 0x01, 0x83, 0x00, 0x03, 0x00, 0x7b, 0x00, 0xff, 0x00, 0xc7, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, }, { 0xff, 0x01, 0xff, 0x01, 0x83, 0x01, 0xc0, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, 0x18, 0x00, }, { 0x7c, 0x00, 0xfe, 0x00, 0xc7, 0x01, 0x83, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, 0xfe, 0x00, 0xc7, 0x01, 0x83, 0x01, 0x83, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, }, { 0x7c, 0x00, 0xfe, 0x00, 0xc7, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xc7, 0x01, 0xfe, 0x01, 0xbc, 0x01, 0x80, 0x01, 0x82, 0x01, 0xc7, 0x01, 0xfe, 0x00, 0x7c, 0x00, }, { 0xf3, 0x00, 0xfb, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0x9b, 0x01, 0xfb, 0x01, 0xf3, 0x00, }, { 0xe0, 0x01, 0xe0, 0x01, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0xc3, 0x00, 0xc3, 0x00, 0xe7, 0x00, 0x7e, 0x00, 0x3c, 0x00, }, { 0x38, 0x00, 0x7c, 0x00, 0xee, 0x00, 0xc6, 0x00, 0xc6, 0x00, 0xc6, 0x00, 0xc6, 0x00, 0xc6, 0x00, 0xdf, 0x00, 0xff, 0x00, 0xf6, 0x00, 0xee, 0x00, 0xfc, 0x01, 0xb8, 0x00, }, { 0xef, 0x01, 0xef, 0x01, 0xe6, 0x00, 0x76, 0x00, 0x3e, 0x00, 0x1e, 0x00, 0x1e, 0x00, 0x3e, 0x00, 0x36, 0x00, 0x76, 0x00, 0x66, 0x00, 0xe6, 0x00, 0xef, 0x01, 0xef, 0x01, }, }; kgames-2.2/Xkw/spade_lg000066400000000000000000000032601416764561500151160ustar00rootroot00000000000000#define spade_lg_width 39 #define spade_lg_height 52 static char spade_lg_bits[] = { 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xe0, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00, 0x00, 0xf8, 0xff, 0x0f, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x00, 0x00, 0xfe, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x01, 0xe0, 0xff, 0xff, 0xff, 0x03, 0xf0, 0xff, 0xff, 0xff, 0x07, 0xf8, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0x0f, 0xfc, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0x1f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xbe, 0xff, 0x1f, 0xfc, 0x7f, 0x1c, 0xff, 0x1f, 0xf8, 0x3f, 0x1c, 0xfe, 0x0f, 0xf0, 0x1f, 0x1c, 0xfc, 0x07, 0xc0, 0x07, 0x1c, 0xf0, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xe0, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00}; kgames-2.2/Xkw/suit.bm000066400000000000000000000126571416764561500147330ustar00rootroot00000000000000/* * Spider * * (c) Copyright 1989, Donald R. Woods and Sun Microsystems, Inc. * (c) Copyright 1990, David Lemke and Network Computing Devices Inc. * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #define spade_width 15 #define spade_height 19 #define spade_x_hot -1 #define spade_y_hot -1 static char spade_bits[] = { 0x80, 0x00, 0x80, 0x00, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f, 0xfe, 0x3f, 0xfe, 0x3f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xbe, 0x3e, 0x9c, 0x1c, 0xc0, 0x01, 0xe0, 0x03}; #ifndef USE_BOB #define spade_lg_width 39 #define spade_lg_height 52 #define spade_lg_x_hot -1 #define spade_lg_y_hot -1 static char spade_lg_bits[] = { 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xe0, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00, 0x00, 0xf8, 0xff, 0x0f, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x00, 0x00, 0xfe, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x80, 0xff, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x01, 0xe0, 0xff, 0xff, 0xff, 0x03, 0xf0, 0xff, 0xff, 0xff, 0x07, 0xf8, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0x0f, 0xfc, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0x1f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xbe, 0xff, 0x1f, 0xfc, 0x7f, 0x1c, 0xff, 0x1f, 0xf8, 0x3f, 0x1c, 0xfe, 0x0f, 0xf0, 0x1f, 0x1c, 0xfc, 0x07, 0xc0, 0x07, 0x1c, 0xf0, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x00, 0xe0, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0x07, 0x00}; #endif /* !USE_BOB */ #define spade_sm_width 9 #define spade_sm_height 12 #define spade_sm_x_hot -1 #define spade_sm_y_hot -1 static char spade_sm_bits[] = { 0x10, 0x00, 0x10, 0x00, 0x38, 0x00, 0x38, 0x00, 0x7c, 0x00, 0xfe, 0x00, 0xff, 0x01, 0xff, 0x01, 0xff, 0x01, 0xd6, 0x00, 0x10, 0x00, 0x38, 0x00}; #define heart_width 15 #define heart_height 17 #define heart_x_hot -1 #define heart_y_hot -1 static char heart_bits[] = { 0x1c, 0x1c, 0x3e, 0x3e, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xfe, 0x3f, 0xfe, 0x3f, 0xfc, 0x1f, 0xf8, 0x0f, 0xf0, 0x07, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01, 0xc0, 0x01, 0x80, 0x00, 0x80, 0x00}; #define heart_sm_width 9 #define heart_sm_height 11 #define heart_sm_x_hot -1 #define heart_sm_y_hot -1 static char heart_sm_bits[] = { 0xc6, 0x00, 0xef, 0x01, 0xff, 0x01, 0xff, 0x01, 0xfe, 0x00, 0xfe, 0x00, 0x7c, 0x00, 0x38, 0x00, 0x38, 0x00, 0x10, 0x00, 0x10, 0x00}; #define club_width 15 #define club_height 16 #define club_x_hot -1 #define club_y_hot -1 static char club_bits[] = { 0xc0, 0x81, 0xe0, 0x83, 0xf0, 0x87, 0xf0, 0x87, 0xf0, 0x87, 0xe0, 0x83, 0xdc, 0x9d, 0xfe, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0x3e, 0x9c, 0x1c, 0xc0, 0x81, 0xc0, 0x81, 0xe0, 0x83}; #define club_sm_width 9 #define club_sm_height 11 #define club_sm_x_hot -1 #define club_sm_y_hot -1 static char club_sm_bits[] = { 0x38, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x38, 0x00, 0xd6, 0x00, 0xff, 0x81, 0xff, 0x81, 0xff, 0x81, 0xd6, 0x00, 0x00, 0x00, 0x38, 0x00}; #define diamond_width 13 #define diamond_height 19 #define diamond_x_hot -1 #define diamond_y_hot -1 static char diamond_bits[] = { 0x40, 0x00, 0x40, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x01, 0xf8, 0x03, 0xf8, 0x03, 0xfc, 0x07, 0xfe, 0x0f, 0xff, 0x1f, 0xfe, 0x0f, 0xfc, 0x07, 0xf8, 0x03, 0xf8, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xe0, 0x00, 0x40, 0x00, 0x40, 0x00}; #define diamond_sm_width 7 #define diamond_sm_height 12 #define diamond_sm_x_hot -1 #define diamond_sm_y_hot -1 static char diamond_sm_bits[] = { 0x08, 0x08, 0x1c, 0x1c, 0x3e, 0x7f, 0x3e, 0x1c, 0x1c, 0x08, 0x08, 0x00}; kgames-2.2/contrib.letter000066400000000000000000000057121416764561500155310ustar00rootroot00000000000000 The undersigned Contributor hereby grants to the X Consortium the full and unrestricted irrevocable, world-wide, paid up, royalty-free, nonexclusive right and license to deal in the software known as Keith's Krufty Games, and the accompanying documentation files, if any (file listing attached) (together, the "Software"), subject to the terms set forth below. This license includes without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons who receive copies from the X Consortium or any party who receives the Software any such party to do so. This license includes the right to include the name of the Contributor in copies of the Software provided to third parties. This license includes without limitation a license to do the foregoing actions under any patents of the party supplying this Software to the X Consortium. 1. The Contributor warrants that it holds sufficient right and title and/or interest in the Software to grant the permission herein and in the permission notice set forth below. The X Consortium agrees that title to the Software is not transferred by the Contributor. 2. The X Consortium shall include the appropriate copyright notice and the permission notice set forth below on all copies it creates of the Software. 3. The Contributor acknowledges that the X Consortium is under no obligation to distribute the Software. By placing the Software in distribution, the X Consortium signifies its acceptance of these terms. Name: Keith Packard Date: June 6, 1994 Copyright 1992 Network Computing Devices Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of NCD. not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. NCD. makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Fax the completed, signed letter to +1 617 374 1025 or mail to R6 Contrib X Consortium 1 Memorial Dr Cambridge MA 02142-1301 USA kgames-2.2/kaces/000077500000000000000000000000001416764561500137315ustar00rootroot00000000000000kgames-2.2/kaces/KAces.ad.in000066400000000000000000000027651416764561500156440ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *deck.numCols: 2 *deck.numRows: 1 *piles.numCols: 4 *piles.numRows: 1 *Cards.immediateUpdate: False *stacks.numCols: 7 *stacks.numRows: 9 *stacks.rowsHint: True *stacks.overlap: vertical *stacks.immediate_update: false *message.justify: left *message.label: Keith's Aces Up, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 5 < -5 > \ pileAll \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ horizontal {\ menuBar < +inff -100% * >\ } \ 10 < -inf > \ horizontal { \ 10 < -inf > \ deck < -75% * -90% > \ 10 < +inf -inf > \ piles < -100% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ stacks < -50% * +inf -50% > \ horizontal { \ message < +inff -100% * > \ } \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *pileAll.label: Fill Piles *Command.shapeStyle: oval *frame.translations: #override \ u: acesUndo()\n\ n: acesNewGame()\n\ s: acesScore()\n\ ?: acesFindAMove() kgames-2.2/kaces/aces.c000066400000000000000000000500511416764561500150110ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KAces-res.h" Widget toplevel; Widget frame; Widget deck; Widget piles; Widget stacks; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; Widget pileAll; #define NUM_DECK 1 #define NUM_STACKS 7 #define NUM_PILES 4 #define NUM_CARDS 52 #define MAX_SCORE 340 CardStackRec deckStack; CardStackRec stackStacks[NUM_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardRec rawcards[NUM_CARDS]; int dealNumber; typedef struct _acesResources { int animationSpeed; } AcesResources, *AcesResourcesPtr; AcesResources acesResources; static void InitStacks (void) { int col; CardInitStack (&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); for (col = 0; col < NUM_STACKS; col++) { CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, CardDisplayAll); } for (col = 0; col < NUM_PILES; col++) { CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col, CardDisplayTop); } } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS-1]; } #define FIRST_ROWS 4 static void FirstDeal (void) { int row, col; for (row = 0; row < FIRST_ROWS; row++) { for (col = 0; col < NUM_STACKS; col++) CardMove (&deckStack, deckStack.last, &stackStacks[col], False); } for (col = 0; col < NUM_STACKS; col++) CardTurn (stackStacks[col].last, CardFaceUp, False); dealNumber = 0; } static void CheckStackTop (CardStackPtr stack) { if (stack->last && stack->last->face == CardFaceDown) CardTurn (stack->last, CardFaceUp, True); } static int ComputeScore (void) { int col; int score; CardPtr card; score = 0; for (col = 0; col < NUM_PILES; col++) { for (card = pileStacks[col].first; card; card = card->next) { if (card->card.rank < CardsJack) score += (int) card->card.rank; else score += 10; } } return score; } static void DisplayStacks (void) { int col; CardDisplayStack (&deckStack); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < NUM_STACKS; col++) CardDisplayStack (&stackStacks[col]); CardsUpdateDisplay (deck); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); } /* User interface functions */ #define DEAL_COUNT 3 static void Deal (void) { int col; if (!deckStack.last) { Message (message, "No more cards in the deck."); return; } for (col = 0; col < NUM_STACKS; col++) { if (!deckStack.last) break; CardMove (&deckStack, deckStack.last, &stackStacks[col], True); CardTurn (stackStacks[col].last, CardFaceUp, True); } CardNextHistory (); DisplayStacks (); } static void NewGame (void) { CardsRemoveAllCards (deck); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); InitStacks (); GenerateCards (); CardShuffle (&deckStack, False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static Boolean IsLegalPilePlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (from_card->card.rank == CardsAce) { if (to_stack->last == NULL) return True; } else { if (to_stack->last != NULL && CardIsInSuitOrder (to_stack->last, from_card)) return True; } return False; } static CardStackPtr FindPilePlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = from_stack->last; else return NULL; if (from_card->next) return NULL; for (i = 0; i < NUM_PILES; i++) { to_stack = &pileStacks[i]; if (IsLegalPilePlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalRegularPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { CardPtr to_card; (void) from_stack; to_card = to_stack->last; if (to_card && CardIsInAlternatingSuitOrder (from_card, to_card)) return True; return False; } static CardStackPtr FindRegularPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseAlternatingSuitOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (IsLegalRegularPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalEmptyPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; (void) from_card; if (to_stack->last == NULL) return True; return False; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseAlternatingSuitOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (IsLegalEmptyPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (from_card && from_card->face == CardFaceDown) { Message (message, "Card not turned up."); return; } if (from_card && CardInAlternatingSuitOrder (from_card)->next != NULL) { Message (message, "Cards not in order."); return; } if (to_stack != from_stack) { if (to_stack->widget == stacks) { if (!from_card) from_card = CardInReverseAlternatingSuitOrder (from_stack->last); if (!IsLegalRegularPlay (from_stack, from_card, to_stack) && !IsLegalEmptyPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty pile.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == piles) { if (!from_card) from_card = from_stack->last; if (!IsLegalPilePlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty stack.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else { Message (message, "Can't move cards back to the deck."); return; } } else { if (!from_card && !from_stack->last) { Message (message, "No cards there."); return; } if (!(to_stack = FindPilePlay (from_stack, &from_card)) && !(to_stack = FindRegularPlay (from_stack, &from_card)) && !(to_stack = FindEmptyPlay (from_stack, &from_card))) { Message (message, "Not a valid move."); return; } } CardMove (from_stack, from_card, to_stack, True); CheckStackTop (from_stack); CardNextHistory (); DisplayStacks (); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); else Message(message, ""); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static Boolean AlreadyInOrder (CardPtr a, CardPtr b) { if (a && b && CardIsInAlternatingSuitOrder (a, b)) return True; return False; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[NUM_STACKS]; to_stack = NULL; for (col = 0; col < NUM_STACKS; col++) goodenough[col] = False; #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ if (goodenough[col]) continue; \ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = CardInReverseAlternatingSuitOrder (from_stack->last); \ if (!already (from_card, from_card->prev)) \ to_stack = func(from_stack, &from_card); \ else \ goodenough[col] = True; \ } \ #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, &from_card); \ } \ FindOneCheck (AlreadyInOrder, FindRegularPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } FindOne (FindPilePlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } if (deckStack.last) { Message (message, "Deal."); } else { Message (message, "It's all over."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void PileAll (void) { CardStackPtr from_stack; CardPtr from_card; CardStackPtr to_stack; int col; Boolean done = False; Message (message, ""); do { to_stack = 0; FindOne (FindPilePlay); if (to_stack) { Play (from_stack, from_card, to_stack); done = True; } } while (to_stack); if (!done) Message (message, "No cards to pile."); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; if (w == piles) return &pileStacks[col]; if (w == deck) return &deckStack; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; CardPtr card = NULL; (void) closure; stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; switch (input->action) { case HandActionStart: break; case HandActionClick: CardSetAnimate(True); if (stack == &deckStack) { Deal (); } else if (stack->last) { Play(stack, card, stack); } break; case HandActionDrag: CardSetAnimate(False); if (stack == startStack) break; if (stack == &deckStack) break; if (startStack->last) { CardPtr card = CardFromHandCard(input->start.private); Play (startStack, card, stack); } break; case HandActionExpand: Expand(stack); break; case HandActionUnexpand: Message(message, ""); break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void PileAllCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; PileAll (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void PileAllAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; PileAll (); } XtActionsRec actions[] = { { "acesUndo", UndoAction, }, { "acesNewGame", NewGameAction, }, { "acesScore", ScoreAction, }, { "acesQuit", QuitAction, }, { "acesFindAMove", FindAMoveAction, }, { "acesRestore", RestoreAction, }, { "acesSave", SaveAction, }, { "acesPileAll", PileAllAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(AcesResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KAces", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&acesResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (acesResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: acesQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); pileAll = XtCreateManagedWidget ("pileAll", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(pileAll, XtNcallback, PileAllCallback, NULL); deck = XtCreateManagedWidget ("deck", cardsWidgetClass, frame, NULL, 0); XtAddCallback (deck, XtNinputCallback, InputCallback, &deckStack); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); XtAddCallback (piles, XtNinputCallback, InputCallback, &pileStacks[0]); stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stacks, XtNinputCallback, InputCallback, &stackStacks[0]); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/kaces/kaces.6000066400000000000000000000013041416764561500151040ustar00rootroot00000000000000.TH KACES 6 "1992" "Kgames 1.0" .SH NAME kaces \- X window aces high solitaire .SH SYNOPSIS .B kaces .SH DESCRIPTION .I Kaces brings up a window for a aces solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Top cards of tableaus are available, and may be discarded if they have the same suit and lower rank than another available card. Empty tableaus may be filled with any available card. Aces rank high, above Kings. .P Deal four more cards by clickping the deck. Dealing is not allowed until empty tableaus have been filled (if possible). .P Goal: discard all cards except for the four Aces. .SH AUTHOR Keith Packard kgames-2.2/kaces/kaces.desktop.in000066400000000000000000000003751416764561500170240ustar00rootroot00000000000000[Desktop Entry] Name=KAces GenericName=Solitaire Game Comment=Play Aces Up solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kaces Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kaces/meson.build000066400000000000000000000031521416764561500160740ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KAces.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kaces', 'aces.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kaces.6') configure_file(input: 'kaces.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kcanfield/000077500000000000000000000000001416764561500145635ustar00rootroot00000000000000kgames-2.2/kcanfield/KCanfield.ad.in000066400000000000000000000040311416764561500173140ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *logo.Background: #337744 *logo.Foreground: #fffff0 *baseRank.Background: #337744 *baseRank.Foreground: #fffff0 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *Cards.immediateUpdate: False *talon.numCols: 2 *talon.numRows: 1 *foundation.numCols: 4 *foundation.numRows: 1 *stock.numCols: 1 *stock.numRows: 1 *tableau.numCols: 4 *tableau.numRows: 7 *tableau.rowsHint: True *tableau.overlap: vertical *message.justify: left *message.label: Keith's Canfield, Version @KGAMES_VERSION@ *logo.label: Canfield *logo.font: sans-36 *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 5 < -5 > \ pileAll \ 5 <+inf -inf> \ baseRank \ 5 < -5 > \ } \ 5 < -5 > \ } *frame.layout: vertical {\ -1 \ horizontal {\ -1 \ menuBar < +inff -100% * >\ -1 \ } \ 10 < -inf > \ horizontal { \ 0 < +inf -inf > \ vertical { \ 0 < +inf -inf > \ logo \ 0 < +inf -inf > \ } \ 0 < +inf -inf > \ foundation < -100% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ horizontal {\ 10 < -inf > \ vertical { \ horizontal { \ stock < -75% * -90% > \ 0 < +inf > \ } \ 10 < -inf > \ talon < -75% * -90% > \ 10 < +inf -inf > \ } \ 10 < +inf -inf > \ tableau < -50% * +inf -50% > \ 10 < -inf > \ } \ horizontal { \ -1 \ message < +inff -100% * > \ -1 \ } \ -1 \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *pileAll.label: Fill Piles *Command.shapeStyle: oval *frame.translations: #override \ u: canfieldUndo()\n\ n: canfieldNewGame()\n\ s: canfieldScore()\n\ ?: canfieldFindAMove() kgames-2.2/kcanfield/canfield.c000066400000000000000000000571271416764561500165100ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include Widget toplevel; Widget frame; Widget stockWidget; Widget talonWidget; Widget tableauWidget; Widget foundationWidget; Widget logo; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; Widget pileAll; Widget baseRankWidget; #define NUM_TABLEAU 4 #define NUM_FOUNDATION 4 #define NUM_CARDS 52 CardsRank baseRank; CardStackRec stock; CardStackRec talon; CardStackRec deck; CardStackRec tableau[NUM_TABLEAU]; CardStackRec foundation[NUM_FOUNDATION]; CardRec rawcards[NUM_CARDS]; #define INIT_STOCK 13 typedef struct _canfieldResources { int animationSpeed; } CanfieldResources, *CanfieldResourcesPtr; CanfieldResources canfieldResources; static void InitStacks (void) { int col; CardInitStack (&stock, stockWidget, CardsEmpty, False, 0, CardDisplayTop); CardInitStack (&deck, talonWidget, CardsEmpty, False, 0, CardDisplayBottom); CardInitStack (&talon, talonWidget, CardsEmpty, False, 1, CardDisplayTop); for (col = 0; col < NUM_TABLEAU; col++) { CardInitStack (&tableau[col], tableauWidget, CardsNone, False, col, CardDisplayAll); } for (col = 0; col < NUM_FOUNDATION; col++) { CardInitStack (&foundation[col], foundationWidget, CardsEmpty, False, col, CardDisplayTop); } } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); deck.first = &rawcards[0]; deck.last = &rawcards[NUM_CARDS-1]; } static void FirstDeal (void) { int row, col; CardMove (&deck, deck.last, &foundation[0], False); CardTurn (foundation[0].last, CardFaceUp, False); baseRank = foundation[0].last->card.rank; Message (baseRankWidget, "Base rank is %s", CardsRankName (baseRank)); for (row = 0; row < INIT_STOCK; row++) { CardMove (&deck, deck.last, &stock, False); CardTurn (stock.last, CardFaceUp, False); } for (col = 0; col < NUM_TABLEAU; col++) { CardMove (&deck, deck.last, &tableau[col], False); CardTurn (tableau[col].last, CardFaceUp, False); } } static void CheckStackTop (CardStackPtr stack) { if (stack->last && stack->last->face == CardFaceDown) CardTurn (stack->last, CardFaceUp, True); } static int ComputeScore (void) { int col; int score; CardPtr card; score = 0; for (col = 0; col < NUM_FOUNDATION; col++) for (card = foundation[col].first; card; card = card->next) score += 5; return score; } static void DisplayStacks (void) { int col; CardDisplayStack (&stock); CardDisplayStack (&talon); CardDisplayStack (&deck); for (col = 0; col < NUM_TABLEAU; col++) CardDisplayStack (&tableau[col]); for (col = 0; col < NUM_FOUNDATION; col++) CardDisplayStack (&foundation[col]); CardsUpdateDisplay (stockWidget); CardsUpdateDisplay (talonWidget); CardsUpdateDisplay (tableauWidget); CardsUpdateDisplay (foundationWidget); } /* User interface functions */ #define DEAL_COUNT 3 static void ResetTalon (void) { CardPtr c; while ((c = talon.last)) { CardMove (&talon, talon.last, &deck, True); CardTurn (deck.last, CardFaceDown, True); } CardNextHistory (); DisplayStacks (); } static void Deal (void) { int deal; for (deal = 0; deal < DEAL_COUNT; deal++) { if (!deck.last) { if (!deal) Message (message, "No more cards in the deck."); break; } CardMove (&deck, deck.last, &talon, True); CardTurn (talon.last, CardFaceUp, True); } if (deal) { CardNextHistory (); DisplayStacks (); } } static void NewGame (void) { CardsRemoveAllCards (stockWidget); CardsRemoveAllCards (talonWidget); CardsRemoveAllCards (tableauWidget); CardsRemoveAllCards (foundationWidget); InitStacks (); GenerateCards (); CardShuffle (&deck, False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } #define MAX_SCORE 260 static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static Boolean CanfieldCardIsInOrder (CardPtr a, CardPtr b) { return a->face == b->face && (a->card.rank + 1 == b->card.rank || (a->card.rank == CardsKing && b->card.rank == CardsAce)); } static Boolean CanfieldCardIsInSuitOrder (CardPtr a, CardPtr b) { return a->card.suit == b->card.suit && CanfieldCardIsInOrder (a,b); } static Boolean IsRedSuit (CardsSuit suit) { return suit == CardsHeart || suit == CardsDiamond; } static Boolean CanfieldCardIsInAlternatingSuitOrder (CardPtr a, CardPtr b) { return IsRedSuit(a->card.suit) != IsRedSuit (b->card.suit) && CanfieldCardIsInOrder (a,b); } #if 0 static CardPtr CanfieldCardInSuitOrder (CardPtr card) { while (card->next && CanfieldCardIsInSuitOrder (card->next, card)) card = card->next; return card; } #endif static CardPtr CanfieldCardInAlternatingSuitOrder (CardPtr card) { while (card->next && CanfieldCardIsInAlternatingSuitOrder (card->next, card) && card->next->isUp) card = card->next; return card; } static CardPtr CanfieldCardInReverseAlternatingSuitOrder (CardPtr card) { while (card->prev && CanfieldCardIsInAlternatingSuitOrder (card, card->prev) && card->prev->isUp) card = card->prev; return card; } static Boolean IsLegalFoundationPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (from_card->next) return False; if (from_card->card.rank == baseRank) { if (to_stack->last == NULL) return True; } else { if (to_stack->last != NULL && CanfieldCardIsInSuitOrder (to_stack->last, from_card)) return True; } return False; } static CardStackPtr FindFoundationPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; CardStackPtr to_stack; CardPtr from_card; if (from_stack->widget == foundationWidget) return NULL; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = from_stack->last; else return NULL; for (i = 0; i < NUM_FOUNDATION; i++) { to_stack = &foundation[i]; if (IsLegalFoundationPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalRegularPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { CardPtr to_card; (void) from_stack; to_card = to_stack->last; if (to_card && CanfieldCardIsInAlternatingSuitOrder (from_card, to_card)) return True; return False; } static CardStackPtr FindRegularPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - tableau; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CanfieldCardInReverseAlternatingSuitOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_TABLEAU; i++) { if (i == col) continue; to_stack = &tableau[i]; if (IsLegalRegularPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalEmptyPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_card; if ((from_stack == &stock || stock.last == NULL) && to_stack->last == NULL) return True; return False; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - tableau; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CanfieldCardInReverseAlternatingSuitOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_TABLEAU; i++) { if (i == col) continue; to_stack = &tableau[i]; if (IsLegalEmptyPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (from_card && from_card->face == CardFaceDown) { Message (message, "Card not turned up."); return; } if (from_card && CanfieldCardInAlternatingSuitOrder (from_card)->next != NULL) { Message (message, "Cards not in order."); return; } if (to_stack != from_stack) { if (to_stack->widget == tableauWidget) { if (!from_card) from_card = CanfieldCardInReverseAlternatingSuitOrder (from_stack->last); if (!IsLegalRegularPlay (from_stack, from_card, to_stack) && !IsLegalEmptyPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty pile.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == foundationWidget) { if (!from_card) from_card = from_stack->last; if (!IsLegalFoundationPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty stack.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else { Message (message, "Can't move cards back to the deck."); return; } } else { if (!from_card && !from_stack->last) { Message (message, "No cards there."); return; } if (!(to_stack = FindFoundationPlay (from_stack, &from_card)) && !(to_stack = FindRegularPlay (from_stack, &from_card)) && !(to_stack = FindEmptyPlay (from_stack, &from_card))) { Message (message, "Not a valid move."); return; } } CardMove (from_stack, from_card, to_stack, True); if (from_stack->widget == tableauWidget && !from_stack->last) { if (stock.last) CardMove(&stock, stock.last, from_stack, True); } CheckStackTop (from_stack); CardNextHistory (); DisplayStacks (); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); else Message(message, ""); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static Boolean AlreadyInOrder (CardPtr a, CardPtr b) { if (a && b && CanfieldCardIsInAlternatingSuitOrder (a,b)) return True; return False; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[NUM_TABLEAU]; to_stack = NULL; for (col = 0; col < NUM_TABLEAU; col++) goodenough[col] = False; #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < NUM_TABLEAU; col++) {\ if (goodenough[col]) continue; \ from_stack = &tableau[col]; \ if (!from_stack->last) continue; \ from_card = CanfieldCardInReverseAlternatingSuitOrder (from_stack->last); \ if (!already (from_card, from_card->prev)) \ to_stack = func(from_stack, &from_card); \ else \ goodenough[col] = True; \ } \ if (!to_stack) { \ from_stack = &talon; \ from_card = from_stack->last; \ if (from_card) \ to_stack = func(from_stack, &from_card);\ } #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_TABLEAU; col++) {\ from_stack = &tableau[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, &from_card); \ } \ if (!to_stack) { \ from_stack = &talon; \ from_card = from_stack->last; \ if (from_card) \ to_stack = func(from_stack, &from_card);\ } FindOneCheck (AlreadyInOrder, FindRegularPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - tableau + 1); return; } FindOne (FindFoundationPlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } if (deck.last) { Message (message, "Deal the next hand."); } else { Message (message, "Reset the deck."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void FoundationAll (void) { CardStackPtr from_stack; CardPtr from_card; CardStackPtr to_stack; int col; Boolean done = False; Message (message, ""); CardSetAnimate(True); do { to_stack = 0; FindOne (FindFoundationPlay); if (to_stack) { Play (from_stack, from_card, to_stack); done = True; } } while (to_stack); if (!done) Message (message, "No cards to pile."); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stockWidget) return &stock; if (w == talonWidget) { if (col == 0) return &deck; else return &talon; } if (w == tableauWidget) return &tableau[col]; if (w == foundationWidget) return &foundation[col]; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; switch (input->action) { case HandActionStart: break; case HandActionClick: CardSetAnimate(True); if (stack == &deck) { if (!stack->last) ResetTalon (); else Deal (); } else Play (stack, NULL, stack); break; case HandActionDrag: CardSetAnimate(False); if (startStack == &deck) { if (stack == &talon) Deal (); } else if (startStack == &talon && stack == &deck) { if (!stack->last) ResetTalon(); } else { CardPtr card = CardFromHandCard(input->start.private); Play (startStack, card, stack); } break; case HandActionExpand: Expand(stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void FoundationAllCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FoundationAll (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void FoundationAllAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FoundationAll (); } XtActionsRec actions[] = { { "canfieldUndo", UndoAction, }, { "canfieldNewGame", NewGameAction, }, { "canfieldScore", ScoreAction, }, { "canfieldQuit", QuitAction, }, { "canfieldFindAMove", FindAMoveAction, }, { "canfieldRestore", RestoreAction, }, { "canfieldSave", SaveAction, }, { "canfieldFoundationAll", FoundationAllAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(CanfieldResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KCanfield", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&canfieldResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (canfieldResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: canfieldQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); pileAll = XtCreateManagedWidget ("pileAll", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(pileAll, XtNcallback, FoundationAllCallback, NULL); baseRankWidget = XtCreateManagedWidget ("baseRank", klabelWidgetClass, menuBar, NULL, ZERO); logo = XtCreateManagedWidget ("logo", klabelWidgetClass, frame, NULL, ZERO); talonWidget = XtCreateManagedWidget ("talon", cardsWidgetClass, frame, NULL, 0); XtAddCallback (talonWidget, XtNinputCallback, InputCallback, NULL); foundationWidget = XtCreateManagedWidget ("foundation", cardsWidgetClass, frame, NULL, 0); XtAddCallback (foundationWidget, XtNinputCallback, InputCallback, NULL); tableauWidget = XtCreateManagedWidget ("tableau", cardsWidgetClass, frame, NULL, 0); XtAddCallback (tableauWidget, XtNinputCallback, InputCallback, NULL); stockWidget = XtCreateManagedWidget ("stock", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stockWidget, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/kcanfield/kcanfield.6000066400000000000000000000016321416764561500165740ustar00rootroot00000000000000.TH KCANFIELD 6 "1992" "Kgames 1.0" .SH NAME kcanfield \- X window canfield solitaire .SH SYNOPSIS .B kcanfield .SH DESCRIPTION .I Kcanfield brings up a window for a canfield solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down circularly in alternating colors. Full builds may be moved to other tableaus. Top cards may be moved to foundations. Empty tableaus must be filled immediately from the stock until it is empty; then at will from the discard pile. Foundations build up circularly in suit. Empty foundations must be filled with cards of the same rank as the starter card placed during the layout. .P Deal three cards onto the discard pile by tapping the deck. Top cards of stock and discard may be moved to tableaus or foundations. .P Goal: move all cards to the foundations. .SH AUTHOR Keith Packard kgames-2.2/kcanfield/kcanfield.desktop.in000066400000000000000000000004061416764561500205030ustar00rootroot00000000000000[Desktop Entry] Name=KCanfield GenericName=Solitaire Game Comment=Play Canfield solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kcanfield Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kcanfield/meson.build000066400000000000000000000032751416764561500167340ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KCanfield.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kcanfield', 'canfield.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kcanfield.6') configure_file(input: 'kcanfield.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kcribbage/000077500000000000000000000000001416764561500145545ustar00rootroot00000000000000kgames-2.2/kcribbage/CribBoard.c000066400000000000000000000255301416764561500165540ustar00rootroot00000000000000/* $XConsortium: CribBoard.c,v 1.4 91/02/17 16:18:42 converse Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #include #include #include #include "CribBoardP.h" static XtResource resources[] = { #define offset(field) XtOffsetOf(CribBoardRec, cribBoard.field) /* {name, class, type, size, offset, default_type, default_addr}, */ { XtNpeg1Color, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (pegColor[0]), XtRString, XtDefaultForeground }, { XtNpeg2Color, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (pegColor[1]), XtRString, XtDefaultForeground }, { XtNholeColor, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset (holeColor), XtRString, XtDefaultForeground }, { XtNnumCols, XtCNumCols, XtRInt, sizeof (int), offset (numCols), XtRImmediate, (XtPointer) 30 }, { XtNnumRows, XtCNumRows, XtRInt, sizeof (int), offset (numRows), XtRImmediate, (XtPointer) 8 }, #undef offset }; #define PEG_SIZE 4.0 #define PEG_LENGTH 8.0 #define HOLE_SIZE 3.0 #define GROUP_SPACE 4.0 #define PEG_SPACE 10.0 #define TRACK_WIDTH 10.0 #define BORDER_WIDTH 30.0 #define BORDER_HEIGHT 10.0 static inline double scaleSize(CribBoardWidget w, double size) { return w->ksimple.dpi * size / 72.0; } static inline double pegSize(CribBoardWidget w) { return scaleSize(w, PEG_SIZE); } static inline double pegLength(CribBoardWidget w) { return scaleSize(w, PEG_LENGTH); } static inline double holeSize(CribBoardWidget w) { return scaleSize(w, HOLE_SIZE); } static inline double trackWidth(CribBoardWidget w) { return scaleSize(w, TRACK_WIDTH); } static inline double groupSpace(CribBoardWidget w) { return scaleSize(w, GROUP_SPACE); } static inline double pegSpace(CribBoardWidget w) { return scaleSize(w, PEG_SPACE); } static inline double RowPos(CribBoardWidget w, int row) { return (row + 0.5) * pegSpace(w) + (row >> 1) * groupSpace(w); } static inline double ColPos(CribBoardWidget w, int col) { int group = col / 5; return (col + 0.5) * (pegSpace(w)) + group * groupSpace(w); } static inline double borderWidth(CribBoardWidget w) { return scaleSize(w, BORDER_WIDTH); } static inline double borderHeight(CribBoardWidget w) { return scaleSize(w, BORDER_HEIGHT); } static void getSize (CribBoardWidget w, Dimension *widthp, Dimension *heightp) { *widthp = ColPos(w, w->cribBoard.numCols - 1) + pegSize(w) + borderWidth(w) * 2; *heightp = RowPos(w, w->cribBoard.numRows - 1) + pegSize(w) + borderHeight(w) * 2; } static void ClassInitialize (void) { XkwInitializeWidgetSet(); } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { CribBoardWidget req = (CribBoardWidget) greq, new = (CribBoardWidget) gnew; int p, i; (void) req; (void) args; (void) count; getSize (new, &new->core.width, &new->core.height); for (p = 0; p < NUM_PLAYER; p++) for (i = 0; i < NUM_PEG; i++) new->cribBoard.pegs[p][i] = CribBoardUnset; } static void Destroy (Widget gw) { (void) gw; } /* * The peg is drawn as a trapezoid topped by a filled arc */ #define ANGLE 60 /* angle from vertical */ #define COS 0.5 #define SIN 0.866025403784439 #define PEG_RAD (pegSize(w)) #define HOLE_RAD (holeSize(w)) #define CIRCLE_X -COS * pegLength(w) #define CIRCLE_Y -SIN * pegLength(w) #define POLY_X0 SIN * HOLE_RAD #define POLY_Y0 -COS * HOLE_RAD #define POLY_X1 -SIN * HOLE_RAD #define POLY_Y1 COS * HOLE_RAD #define POLY_X2 CIRCLE_X - PEG_RAD * SIN #define POLY_Y2 CIRCLE_Y + PEG_RAD * COS #define POLY_X3 CIRCLE_X + PEG_RAD * SIN #define POLY_Y3 CIRCLE_Y - PEG_RAD * COS static void drawPeg (CribBoardWidget w, cairo_t *cr, int player, int value) { int row, col; int subrow; double x, y; if (value == CribBoardUnset) return; if (value >= w->cribBoard.numCols * (w->cribBoard.numRows/NUM_PLAYER)) return; if (value < 0) return; row = (value / w->cribBoard.numCols); col = value % w->cribBoard.numCols; if (row & 1) { subrow = (NUM_PLAYER - 1) - player; col = (w->cribBoard.numCols - 1) - col; } else { subrow = player; } row = row * NUM_PLAYER + subrow; x = ColPos (w, col); y = RowPos (w, row); cairo_save(cr); XkwSetSource(cr, &w->cribBoard.pegColor[player]); cairo_translate(cr, x, y); cairo_move_to(cr, POLY_X0, POLY_Y0); cairo_line_to(cr, POLY_X1, POLY_Y1); cairo_line_to(cr, POLY_X2, POLY_Y2); cairo_line_to(cr, POLY_X3, POLY_Y3); cairo_arc(cr, CIRCLE_X, CIRCLE_Y, pegSize(w), 0, 2 * M_PI); cairo_arc(cr, 0, 0, holeSize(w), 0, 2 * M_PI); cairo_fill(cr); cairo_restore(cr); } static void drawHole (CribBoardWidget w, cairo_t *cr, int row, int col) { double x; double y; x = ColPos (w, col); y = RowPos (w, row); cairo_save(cr); XkwSetSource(cr, &w->cribBoard.holeColor); cairo_translate(cr, x, y); cairo_arc(cr, 0, 0, holeSize(w), 0, 2 * M_PI); cairo_fill(cr); cairo_restore(cr); } static void drawTrack (CribBoardWidget w, cairo_t *cr, int player) { int row; cairo_save(cr); XkwSetSourceInterp(cr, &w->cribBoard.pegColor[player], &w->ksimple.background); cairo_set_line_width(cr, trackWidth(w)); cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND); for (row = 0; row < w->cribBoard.numRows; row += (2 * NUM_PLAYER)) { double left_x = ColPos (w, 0) - pegSize(w); double right_x = ColPos (w, w->cribBoard.numCols - 1) + pegSize(w); double top_y = RowPos (w, row + player); double bottom_y = RowPos (w, row + (2 * NUM_PLAYER - player - 1)); double next_top_y = RowPos (w, row + (2 * NUM_PLAYER) + player); if (row == 0) cairo_move_to(cr, left_x, top_y); cairo_line_to(cr, right_x, top_y); cairo_arc(cr, right_x, (top_y + bottom_y) / 2, (bottom_y - top_y) / 2, -M_PI/2.0, M_PI/2.0); if (row < w->cribBoard.numRows - (2 * NUM_PLAYER)) { cairo_line_to(cr, left_x, bottom_y); cairo_arc_negative(cr, left_x, (bottom_y + next_top_y) / 2, (next_top_y - bottom_y) / 2, -M_PI/2.0, M_PI/2.0); } else cairo_line_to(cr, left_x, bottom_y); } cairo_stroke(cr); cairo_restore(cr); } static void Redisplay (Widget gw, XEvent *event, Region region) { CribBoardWidget w = (CribBoardWidget) gw; int v, p, r, c; cairo_t *cr = XkwDrawBegin(gw, region); Dimension natural_width, natural_height; getSize(w, &natural_width, &natural_height); /* scale to fit area */ double width_ratio = (double) XtWidth(w) / (double) natural_width; double height_ratio = (double) XtHeight(w) / (double) natural_height; if (width_ratio > height_ratio) width_ratio = height_ratio; double bw = borderWidth(w); double bh = borderHeight(w); cairo_save(cr); cairo_scale(cr, width_ratio, width_ratio); cairo_translate(cr, bw, bh); (void) event; for (p = 0; p < NUM_PLAYER; p++) drawTrack (w, cr, p); for (r = 0; r < w->cribBoard.numRows; r++) { for (c = 0; c < w->cribBoard.numCols; c++) drawHole (w, cr, r, c); } for (p = 0; p < NUM_PLAYER; p++) for (v = 0; v < NUM_PEG; v++) drawPeg (w, cr, p, w->cribBoard.pegs[p][v]); cairo_restore(cr); XkwDrawEnd(gw, region, cr); } static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { CribBoardWidget cur = (CribBoardWidget) gcur, req = (CribBoardWidget) greq, new = (CribBoardWidget) gnew; Boolean redraw = FALSE; int p; (void) args; (void) count; (void) new; for (p = 0; p < NUM_PLAYER; p++) if (!XkwColorEqual(&req->cribBoard.pegColor[p], &cur->cribBoard.pegColor[p])) redraw = TRUE; if (!XkwColorEqual(&req->cribBoard.holeColor, &cur->cribBoard.holeColor)) redraw = TRUE; return redraw; } CribBoardClassRec cribBoardClassRec = { { /* core fields */ /* superclass */ (WidgetClass) &ksimpleClassRec, /* class_name */ "CribBoard", /* widget_size */ sizeof(CribBoardRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ Destroy, /* resize */ NULL, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ NULL, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, /* simple */ { XtInheritChangeSensitive, /* change_sensitive */ #ifndef OLDXAW NULL, /* extension */ #endif }, /* ksimple */ { 0, /* not used */ }, { /* cribBoard fields */ /* empty */ 0 } }; WidgetClass cribBoardWidgetClass = (WidgetClass)&cribBoardClassRec; void XkwCribBoardSetPeg (Widget gw, int p, int i, int v) { CribBoardWidget w = (CribBoardWidget) gw; if (0 <= i && i < NUM_PEG && 0 <= p && p <= NUM_PLAYER && w->cribBoard.pegs[p][i] != v) { w->cribBoard.pegs[p][i] = v; Redisplay(gw, NULL, NULL); } } kgames-2.2/kcribbage/CribBoard.h000066400000000000000000000056641416764561500165670ustar00rootroot00000000000000/* $XConsortium: CribBoard.h,v 1.5 90/12/19 18:46:00 converse Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #ifndef _CribBoard_h #define _CribBoard_h /**************************************************************** * * CribBoard widget * ****************************************************************/ /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 destroyCallback Callback Pointer NULL height Height Dimension 0 mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension 0 x Position Position 0 y Position Position 0 */ /* define any special resource names here that are not in */ #define XtNpeg1Color "peg1Color" #define XtNpeg2Color "peg2Color" #define XtNpeg3Color "peg3Color" #define XtNpeg4Color "peg4Color" #define XtNholeColor "holeColor" #define XtNpegSize "pegSize" #define XtCPegSize "PegSize" #define XtNholeSize "holeSize" #define XtCHoleSize "HoleSize" #define XtNnumPegs "numPegs" #define XtCNumPegs "NumPegs" #define XtNgroupSpace "groupSpace" #define XtCGroupSpace "GroupSpace" #define XtNrowSpace "rowSpace" #define XtCRowSpace "RowSpace" #define XtNnumRows "numRows" #define XtCNumRows "NumRows" #define XtNnumCols "numCols" #define XtCNumCols "NumCols" #define CribBoardUnset (-1) /* declare specific CribBoardWidget class and instance datatypes */ typedef struct _CribBoardClassRec* CribBoardWidgetClass; typedef struct _CribBoardRec* CribBoardWidget; /* declare the class constant */ extern WidgetClass cribBoardWidgetClass; void XkwCribBoardSetPeg (Widget gw, int i, int p, int v); #endif /* _CribBoard_h */ kgames-2.2/kcribbage/CribBoardP.h000066400000000000000000000044621416764561500167020ustar00rootroot00000000000000/* $XConsortium: CribBoardP.h,v 1.6 91/03/13 20:12:07 rws Exp $ */ /* Copyright Massachusetts Institute of Technology 1987, 1988 * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #ifndef _CribBoardP_h #define _CribBoardP_h #include #include "CribBoard.h" /* include superclass private header file */ #include #define New(t) (t *) malloc(sizeof (t)) #define Dispose(p) free((char *) p) #define Some(t,n) (t*) malloc(sizeof(t) * n) #define More(p,t,n) ((p)? (t *) realloc((char *) p, sizeof(t)*n):Some(t,n) typedef struct { int empty; } CribBoardClassPart; typedef struct _CribBoardClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; CribBoardClassPart cribBoard_class; } CribBoardClassRec; extern CribBoardClassRec cribBoardClassRec; #define NUM_PEG 2 #define NUM_PLAYER 2 typedef struct { /* resources */ XRenderColor pegColor[NUM_PLAYER]; XRenderColor holeColor; int numCols; int numRows; /* private state */ int pegs[NUM_PLAYER][NUM_PEG]; } CribBoardPart; typedef struct _CribBoardRec { CorePart core; SimplePart simple; KSimplePart ksimple; CribBoardPart cribBoard; } CribBoardRec; #endif /* _CribBoardP_h */ kgames-2.2/kcribbage/Cribbage.ad.in000066400000000000000000000040601416764561500171650ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *layout.Background: #337744 *tableScore.Background: #337744 *tableScore.Foreground: #fffff0 *table.Background: #337744 *table.Foreground: #fffff0 *score.peg1Color: #ff1010 *score.peg2Color: #1010ff *borderWidth: 0 *SimpleMenu.borderWidth: 1 *layout.translations: #override \ : cribbageKey() *Cards.immediateUpdate: False *Cards.select: one *message.numRows: 10 *message.numCols: 48 *player.numRows: 1 *player.numCols: 6 *player.overlap: neither *computer.numRows: 1 *computer.numCols: 6 *computer.overlap: neither *tableScore.borderWidth: 0 *tableScore.label: *table.numRows: 6 *table.numCols: 6 *table.borderWidth: 0 *table.overlap: both *playname.label: Your score *playname.Foreground: #ff0000 *playname.justify: left *compname.label: My score *compname.Foreground: #0000ff *compname.justify: left *playcrib.numRows: 1 *playcrib.numCols: 6 *playcrib.overlap: neither *compcrib.numRows: 1 *compcrib.numCols: 6 *compcrib.overlap: neither *deck.numRows: 1 *deck.numCols: 1 *deck.overlap: neither *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *menuBar.layout: vertical { \ 5 < -inf > \ horizontal { \ 5 < -inf > \ fileMenuButton \ 5 < -inf > \ 0 < +inf > \ } \ 5 < -inf > \ } *layout.layout: vertical { \ -1 \ horizontal { \ vertical { \ horizontal { \ menuBar < +inf -inf * > \ } \ computer < -50% * -50% > \ compcrib < -50% * -50% > \ horizontal { \ vertical { \ tableScore < +inf -inf * > \ table < +inf -50% * -50% > \ } \ vertical { \ height tableScore < >\ deck < -50% * -50% > \ } \ } \ playcrib < -50% * -50% > \ player < -50% * -50% > \ } \ vertical { \ playname < +inf * -100% >\ score < +1 -1 * +1 -1 >\ compname < +inf * -100% >\ message < * +inf -inf > \ } \ -1 \ } \ } kgames-2.2/kcribbage/Makefile.curses000066400000000000000000000021751416764561500175240ustar00rootroot00000000000000# # Copyright (c) 1980 Regents of the University of California. # All rights reserved. The Berkeley software License Agreement # specifies the terms and conditions for redistribution. # # @(#)Makefile 5.2 (Berkeley) 5/15/86 # # make file for cribbage # HDRS= cribbage.h deck.h cribcur.h OBJS= extern.o crib.o support.o cards.o score.o io.o curses.o CFILES= extern.c crib.c support.c cards.c score.c io.c curses.c TOBJS= test.o cards.o score.o io.o extern.o CFLAGS= -O DESTDIR= cribbage: ${OBJS} ${CC} ${CFLAGS} -o cribbage ${OBJS} -lcurses -ltermlib all: cribbage crib.instr io.o curses.o: cribcur.h test: ${TOBJS} ${CC} ${CFLAGS} -o test ${TOBJS} -lcurses -ltermlib crib.instr: cribbage.n macro nroff cribbage.n > crib.instr tags: ${HDRS} ${CFILES} ctags -u $? ed - tags < :ctfix sort tags -o tags clean: rm -f ${OBJS} ? a.out core crib.instr cribbage errs crib.o: deck.h cribbage.h cribcur.h support.o: deck.h cribbage.h cribcur.h test.o: deck.h cards.o: deck.h score.o: deck.h io.o: deck.h cribcur.h install: cribbage crib.instr install -s cribbage $(DESTDIR)/usr/games install -m 644 crib.instr $(DESTDIR)/usr/games/lib kgames-2.2/kcribbage/cards.c000066400000000000000000000035471416764561500160250ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ #include #include "deck.h" #include "cribbage.h" /* * initialize a deck of cards to contain one of each type */ void makedeck( CARD *d ) { register int i, j, k; i = time( (long *) 0 ); i = ( (i&0xff) << 8 ) | ( (i >> 8)&0xff ) | 1; srandom( i ); k = 0; for( i = 0; i < RANKS; i++ ) { for( j = 0; j < SUITS; j++ ) { d[k].suit = j; d[k++].rank = i; } } } /* * given a deck of cards, shuffle it -- i.e. randomize it * see Knuth, vol. 2, page 125 */ void shuffle( CARD *d ) { register int j, k; CARD c; for( j = CARDS; j > 0; --j ) { k = ( rand() >> 4 ) % j; /* random 0 <= k < j */ c = d[j - 1]; /* exchange (j - 1) and k */ d[j - 1] = d[k]; d[k] = c; } } /* * return true if the two cards are equal... */ BOOLEAN eq( CARD a, CARD b ) { return( ( a.rank == b.rank ) && ( a.suit == b.suit ) ); } /* * isone returns TRUE if a is in the set of cards b */ BOOLEAN isone( CARD a, CARD *b, int n ) { register int i; for( i = 0; i < n; i++ ) { if( eq( a, b[i] ) ) return( TRUE ); } return( FALSE ); } /* * remove the card a from the deck d of n cards */ void remove_card( CARD a, CARD *d, int n ) { register int i, j; j = 0; for( i = 0; i < n; i++ ) { if( !eq( a, d[i] ) ) d[j++] = d[i]; } if( j < n ) d[j].suit = d[j].rank = EMPTY; } /* * sorthand: * Sort a hand of n cards */ void sorthand(CARD *h, int n) { register CARD *cp, *endp; CARD c; for (endp = &h[n]; h < endp - 1; h++) for (cp = h + 1; cp < endp; cp++) if ((cp->rank < h->rank) || (cp->rank == h->rank && cp->suit < h->suit)) { c = *h; *h = *cp; *cp = c; } } kgames-2.2/kcribbage/crib.c000066400000000000000000000260041416764561500156410ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ # include # include # include "deck.h" # include "cribbage.h" # define LOGFILE "/usr/games/lib/criblog" # define INSTRCMD "ul /usr/games/lib/crib.instr | more -f" int main(int argc, char **argv) { BOOLEAN playing; FILE *f; int bye(void); UIInit (argc, argv); playing = TRUE; do { UIClearMsg (); msg(quiet ? "L or S? " : "Long (to 121) or Short (to 61)? "); if (glimit == SGAME) glimit = (getuchar() == 'L' ? LGAME : SGAME); else glimit = (getuchar() == 'S' ? SGAME : LGAME); game(); msg("Another game? "); playing = (getuchar() == 'Y'); } while (playing); if ((f = fopen(LOGFILE, "a")) != NULL) { fprintf(f, "Won %5.5d, Lost %5.5d\n", cgames, pgames); fclose(f); } quit (0); } /* * makeboard: * Print out the initial board on the screen */ void makeboard(void) { UIInitBoard (); gamescore (); } /* * gamescore: * Print out the current game score */ void gamescore(void) { extern int Lastscore[]; if (pgames || cgames) { UIGameScore(PLAYER, pgames); UIGameScore(COMPUTER, cgames); } Lastscore[0] = -1; Lastscore[1] = -1; } /* * game: * Play one game up to glimit points. Actually, we only ASK the * player what card to turn. We do a random one, anyway. */ void game(void) { register int i, j; BOOLEAN flag; BOOLEAN compcrib; makeboard(); UIRefresh (); makedeck(deck); shuffle(deck); if (gamecount == 0) { flag = TRUE; do { if (!rflag) { /* player cuts deck */ msg(quiet ? "Cut for crib? " : "Cut to see whose crib it is -- low card wins? "); getline(); } i = (random() >> 4) % CARDS; /* random cut */ do { /* comp cuts deck */ j = (random() >> 4) % CARDS; } while (j == i); addmsg(quiet ? "You cut " : "You cut the "); msgcard(deck[i], FALSE); endmsg(TRUE); addmsg(quiet ? "I cut " : "I cut the "); msgcard(deck[j], FALSE); endmsg(TRUE); flag = (deck[i].rank == deck[j].rank); if (flag) { msg(quiet ? "We tied..." : "We tied and have to try again..."); shuffle(deck); continue; } else compcrib = (deck[i].rank > deck[j].rank); } while (flag); } else { UIEraseHand (TABLE); UIEraseHand (COMPUTER); msg("Loser (%s) gets first crib", (iwon ? "you" : "me")); compcrib = !iwon; } pscore = cscore = 0; flag = TRUE; do { shuffle(deck); flag = !playhand(compcrib); compcrib = !compcrib; } while (flag); ++gamecount; if (cscore < pscore) { if (glimit - cscore > 60) { msg("YOU DOUBLE SKUNKED ME!"); pgames += 4; } else if (glimit - cscore > 30) { msg("YOU SKUNKED ME!"); pgames += 2; } else { msg("YOU WON!"); ++pgames; } iwon = FALSE; } else { if (glimit - pscore > 60) { msg("I DOUBLE SKUNKED YOU!"); cgames += 4; } else if (glimit - pscore > 30) { msg("I SKUNKED YOU!"); cgames += 2; } else { msg("I WON!"); ++cgames; } iwon = TRUE; } gamescore(); } /* * playhand: * Do up one hand of the game */ BOOLEAN playhand(BOOLEAN mycrib) { register int deckpos; UIClearHand (COMPUTER); knownum = 0; deckpos = deal(mycrib); sorthand(chand, FULLHAND); sorthand(phand, FULLHAND); makeknown(chand, FULLHAND); UIPrintHand(chand, FULLHAND, COMPUTER, TRUE); UIPrintHand(phand, FULLHAND, PLAYER, FALSE); discard(mycrib); if (cut(mycrib, deckpos)) return TRUE; if (peg(mycrib)) return TRUE; UIEraseHand (TABLE); UIPrintHand(chand, FULLHAND, COMPUTER, TRUE); UIPrintHand(phand, FULLHAND, PLAYER, FALSE); if (score(mycrib)) return TRUE; return FALSE; } /* * deal cards to both players from deck */ int deal(int mycrib) { register int i, j; j = 0; for( i = 0; i < FULLHAND; i++ ) { if( mycrib ) { phand[i] = deck[j++]; chand[i] = deck[j++]; } else { chand[i] = deck[j++]; phand[i] = deck[j++]; } } return( j ); } /* * discard: * Handle players discarding into the crib... * Note: we call cdiscard() after prining first message so player doesn't wait */ void discard(BOOLEAN mycrib) { register char *prompt; CARD crd; crib[0].rank = EMPTY; crib[1].rank = EMPTY; crib[2].rank = EMPTY; crib[3].rank = EMPTY; UIPrintCrib (mycrib ? COMPUTER : PLAYER, &turnover, TRUE); prompt = (quiet ? "Discard --> " : "Discard a card --> "); cdiscard(mycrib); /* puts best discard at end */ crd = phand[UIGetPlayerCard(phand, FULLHAND, prompt)]; remove_card(crd, phand, FULLHAND); UIPrintHand (phand, FULLHAND, PLAYER, FALSE); crib[0] = crd; UIPrintCrib (mycrib ? COMPUTER : PLAYER, &turnover, TRUE); /* next four lines same as last four except for cdiscard() */ crd = phand[UIGetPlayerCard(phand, FULLHAND - 1, prompt)]; remove_card(crd, phand, FULLHAND - 1); UIPrintHand (phand, FULLHAND, PLAYER, FALSE); crib[1] = crd; crib[2] = chand[4]; crib[3] = chand[5]; chand[4].rank = chand[4].suit = chand[5].rank = chand[5].suit = EMPTY; UIPrintCrib (mycrib ? COMPUTER : PLAYER, &turnover, TRUE); } /* * cut: * Cut the deck and set turnover. Actually, we only ASK the * player what card to turn. We do a random one, anyway. */ BOOLEAN cut(BOOLEAN mycrib, int pos) { register int i; BOOLEAN win = FALSE; if (mycrib) { if (!rflag) { /* random cut */ msg(quiet ? "Cut the deck? " : "How many cards down do you wish to cut the deck? "); getline(); } i = (rand() >> 4) % (CARDS - pos); turnover = deck[i + pos]; addmsg(quiet ? "You cut " : "You cut the "); msgcard(turnover, FALSE); endmsg(TRUE); if (turnover.rank == JACK) { msg("I get two for his heels"); win = chkscr(&cscore,2 ); } } else { i = (rand() >> 4) % (CARDS - pos) + pos; turnover = deck[i]; addmsg(quiet ? "I cut " : "I cut the "); msgcard(turnover, FALSE); endmsg(TRUE); if (turnover.rank == JACK) { msg("You get two for his heels"); win = chkscr(&pscore, 2); } } makeknown(&turnover, 1); UIPrintCrib (mycrib ? COMPUTER : PLAYER, &turnover, FALSE); return win; } /* * peg: * Handle all the pegging... */ static CARD Table[14]; static int Tcnt; #define screen_update(pause) do { \ UIPrintHand (ph, pnum, PLAYER, FALSE); \ UIPrintHand (ch, cnum, COMPUTER, TRUE); \ prtable(sum); \ UIRefresh(); \ if (pause) \ UIPause(); \ } while(0) BOOLEAN peg(BOOLEAN mycrib) { static CARD ch[CINHAND], ph[CINHAND]; CARD crd; register int i, j, k; register int l; register int cnum, pnum, sum; register BOOLEAN myturn, mego, ugo, last, played = FALSE; cnum = pnum = CINHAND; for (i = 0; i < CINHAND; i++) { /* make copies of hands */ ch[i] = chand[i]; ph[i] = phand[i]; } Tcnt = 0; /* index to table of cards played */ sum = 0; /* sum of cards played */ mego = ugo = FALSE; myturn = !mycrib; for (;;) { last = TRUE; /* enable last flag */ if (myturn) { /* my tyrn to play */ if (!anymove(ch, cnum, sum)) { /* if no card to play */ if (!mego && cnum) { /* go for comp? */ msg("GO"); mego = TRUE; } if (anymove(ph, pnum, sum)) /* can player move? */ myturn = !myturn; else { /* give him his point */ msg(quiet ? "You get one" : "You get one point"); if (chkscr(&pscore, 1)) { screen_update(FALSE); return TRUE; } sum = 0; mego = ugo = FALSE; Tcnt = 0; } } else { played = TRUE; j = -1; k = 0; for (i = 0; i < cnum; i++) { /* maximize score */ l = pegscore(ch[i], Table, Tcnt, sum); if (l > k) { k = l; j = i; } } if (j < 0) /* if nothing scores */ j = cchose(ch, cnum, sum); crd = ch[j]; remove_card(crd, ch, cnum--); sum += VAL(crd.rank); Table[Tcnt++] = crd; if (k > 0) { addmsg(quiet ? "I get %d playing the " : "I get %d points playing the ", k); msgcard(crd, FALSE); endmsg(TRUE); if (chkscr(&cscore, k)) { screen_update(FALSE); return TRUE; } } else { addmsg("I play the "); msgcard(crd, FALSE); endmsg(TRUE); } myturn = !myturn; } } else { if (!anymove(ph, pnum, sum)) { /* can player move? */ if (!ugo && pnum) { /* go for player */ msg("You have a GO"); ugo = TRUE; } if (anymove(ch, cnum, sum)) /* can computer play? */ myturn = !myturn; else { msg(quiet ? "I get one" : "I get one point"); if (chkscr(&cscore, 1)) { screen_update(FALSE); return TRUE; } sum = 0; mego = ugo = FALSE; Tcnt = 0; } } else { /* player plays */ played = FALSE; if (pnum == 1) { crd = ph[0]; msg("You play your last card"); } else for (;;) { screen_update(FALSE); crd = ph[UIGetPlayerCard(ph, pnum, "Your play: ")]; if (sum + VAL(crd.rank) <= 31) break; else msg("Total > 31 -- try again"); } makeknown(&crd, 1); remove_card(crd, ph, pnum--); i = pegscore(crd, Table, Tcnt, sum); sum += VAL(crd.rank); Table[Tcnt++] = crd; if (i > 0) { msg(quiet ? "You got %d" : "You got %d points", i); if (chkscr(&pscore, i)) { screen_update(FALSE); return TRUE; } } myturn = !myturn; } } screen_update(TRUE); if (sum >= 31) { msg("Next round"); sum = 0; mego = ugo = FALSE; Tcnt = 0; last = FALSE; /* disable last flag */ } if (!pnum && !cnum) break; /* both done */ } if (last) { if (played) { msg(quiet ? "I get one for last" : "I get one point for last"); if (chkscr(&cscore, 1)) return TRUE; } else { msg(quiet ? "You get one for last" : "You get one point for last"); if (chkscr(&pscore, 1)) return TRUE; } } return FALSE; } /* * prtable: * Print out the table with the current score */ void prtable(int score) { UIPrintHand (Table, Tcnt, TABLE, FALSE); UITableScore (score, Tcnt); } /* * score: * Handle the scoring of the hands */ BOOLEAN score(BOOLEAN mycrib) { BOOLEAN r; sorthand(crib, CINHAND); if (mycrib) { if (plyrhand(phand, "hand")) return TRUE; if (comphand(chand, "hand")) return TRUE; UIWait(); r = comphand(crib, "crib"); UIWait(); if (r) return TRUE; } else { if (comphand(chand, "hand")) return TRUE; if (plyrhand(phand, "hand")) return TRUE; if (plyrhand(crib, "crib")) return TRUE; } return FALSE; } kgames-2.2/kcribbage/cribbage.h000066400000000000000000000072151416764561500164700ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * @(#)cribbage.h 5.1 (Berkeley) 5/30/85 */ #include #include #include #include #include extern CARD deck[ CARDS ]; /* a deck */ extern CARD phand[ FULLHAND ]; /* player's hand */ extern CARD chand[ FULLHAND ]; /* computer's hand */ extern CARD crib[ CINHAND ]; /* the crib */ extern CARD turnover; /* the starter */ extern CARD known[ CARDS ]; /* cards we have seen */ extern int knownum; /* # of cards we know */ extern int pscore; /* player's score */ extern int cscore; /* comp's score */ extern int glimit; /* points to win game */ extern int pgames; /* player's games won */ extern int cgames; /* comp's games won */ extern int gamecount; /* # games played */ extern int Lastscore[2]; /* previous score for each */ extern BOOLEAN iwon; /* if comp won last */ extern BOOLEAN explain; /* player mistakes explained */ extern BOOLEAN rflag; /* if all cuts random */ extern BOOLEAN quiet; /* if suppress random mess */ extern BOOLEAN playing; /* currently playing game */ extern char c_expl[]; /* string for explanation */ #define expl c_expl #define PLAYER 0 #define COMPUTER 1 #define TABLE 2 #define getline crib_getline void UIInit (int argc, char **argv); void UISuspend (void); void UIResume (void); void UIFinish (void); void UIInitBoard (void); void UIGameScore (int who, int num); void UIRefresh (void); void UIWait (void); void UIPause(void); void UIEraseHand (int who); void UIClearHand (int who); void UIPrintHand (CARD *h, int n, int who, BOOLEAN blank); void UIPrintCrib (int who, CARD *card, BOOLEAN blank); void UITableScore (int score, int n); void UIPrintPeg (int score, BOOLEAN on, int who); void ShowCursor (void); void HideCursor (void); int UIReadChar (void); void UIEchoChar (char c); void UIReadLine (char *buf, int len); void UIMessage (char *str, int newline); int UIGetMessageSize (void); void UIClearMsg (void); int UIGetPlayerCard (CARD *hand, int n, char *prompt); void msg(char *fmt, ...); void addmsg(char *fmt, ...); int msgcard(CARD c, BOOLEAN brief); int msgcrd(CARD c, BOOLEAN brfrank, char *mid, BOOLEAN brfsuit); int getuchar(void); int number(int lo, int hi, char *prompt); void msg(char *fmt, ...); void addmsg(char *fmt, ...); void endmsg(BOOLEAN newline); void doadd(char *fmt, va_list args); char * getline(void); void quit(int status); void makeboard(void); void gamescore(void); void game(void); BOOLEAN playhand(BOOLEAN mycrib); int deal(int mycrib); void discard(BOOLEAN mycrib); BOOLEAN cut(BOOLEAN mycrib, int pos); BOOLEAN peg(BOOLEAN mycrib); void prtable(int score); BOOLEAN score(BOOLEAN mycrib); void makedeck( CARD *d ); void shuffle( CARD *d ); BOOLEAN eq( CARD a, CARD b ); BOOLEAN isone( CARD a, CARD *b, int n ); void remove_card( CARD a, CARD *d, int n ); void sorthand(CARD *h, int n); int cchose( CARD *h, int n, int s ); BOOLEAN plyrhand(CARD *hand, char *s); BOOLEAN comphand(CARD *h, char *s); BOOLEAN chkscr(int *scr, int inc); void cdiscard( BOOLEAN mycrib ); BOOLEAN anymove( CARD *hand, int n, int sum ); int anysumto( CARD *hand, int n, int s, int t ); int numofval( CARD *h, int n, int v ); void makeknown( CARD *h, int n ); int scorehand(CARD *hand, CARD starter, int n, BOOLEAN crb, BOOLEAN do_explain); int fifteens(CARD *hand, int n); int pairuns( CARD *h, int n ); int pegscore( CARD crd, CARD *tbl, int n, int sum ); int adjust( CARD *cb, CARD tnv ); kgames-2.2/kcribbage/cribcur.h000066400000000000000000000021571416764561500163630ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * @(#)cribcur.h 5.1 (Berkeley) 5/30/85 */ # define PLAY_Y 15 /* size of player's hand window */ # define PLAY_X 12 # define TABLE_Y 21 /* size of table window */ # define TABLE_X 14 # define COMP_Y 15 /* size of computer's hand window */ # define COMP_X 12 # define Y_SCORE_SZ 9 /* Y size of score board */ # define X_SCORE_SZ 41 /* X size of score board */ # define SCORE_Y 0 /* starting position of scoring board */ # define SCORE_X (PLAY_X + TABLE_X + COMP_X) # define CRIB_Y 17 /* position of crib (cut card) */ # define CRIB_X (PLAY_X + TABLE_X) # define MSG_Y (LINES - (Y_SCORE_SZ + 1)) # define MSG_X (COLS - SCORE_X - 1) # define Y_MSG_START (Y_SCORE_SZ + 1) # define PEG '*' /* what a peg looks like on the board */ extern WINDOW *Compwin; /* computer's hand window */ extern WINDOW *Msgwin; /* message window */ extern WINDOW *Playwin; /* player's hand window */ extern WINDOW *Tablewin; /* table window */ kgames-2.2/kcribbage/curses.c000066400000000000000000000270241416764561500162310ustar00rootroot00000000000000# include # include # include # include "deck.h" # include "cribbage.h" # include "cribcur.h" WINDOW *Compwin; /* computer's hand window */ WINDOW *Msgwin; /* messages for the player */ WINDOW *Playwin; /* player's hand window */ WINDOW *Tablewin; /* table window */ # ifndef erasechar # define erasechar() _tty.sg_erase # define killchar() _tty.sg_kill # endif attron #define CNTL(c) ((c) & 0x37) static void bye (int sig) { (void) sig; signal (SIGINT, SIG_IGN); quit (1); } void UIInit (int argc, char **argv) { initscr(); signal(SIGINT, bye); crmode(); noecho(); Playwin = subwin(stdscr, PLAY_Y, PLAY_X, 0, 0); Tablewin = subwin(stdscr, TABLE_Y, TABLE_X, 0, PLAY_X); Compwin = subwin(stdscr, COMP_Y, COMP_X, 0, TABLE_X + PLAY_X); Msgwin = subwin(stdscr, MSG_Y, MSG_X, Y_MSG_START, SCORE_X + 1); leaveok(Playwin, TRUE); leaveok(Tablewin, TRUE); leaveok(Compwin, TRUE); clearok(stdscr, FALSE); while (--argc > 0) { if ((*++argv)[0] != '-') { UIFinish (); fprintf(stderr, "\n\ncribbage: usage is 'cribbage [-eqr]'\n"); exit(1); } bust = FALSE; for (s = argv[0] + 1; *s != NULL; s++) { switch (*s) { case 'e': explain = TRUE; break; case 'q': quiet = TRUE; break; case 'r': rflag = TRUE; break; default: UIFinish (); fprintf(stderr, "\n\ncribbage: usage is 'cribbage [-eqr]'\n"); exit(2); break; } if (bust) break; } } if (!quiet) { msg("Do you need instructions for cribbage? "); if (getuchar() == 'Y') { UISuspend (); system(INSTRCMD); UIResume (); msg("For the rules of this program, do \"man cribbage\""); } } } UISuspend () { endwin(); fflush(stdout); } UIResume () { crmode(); noecho(); clear(); refresh(); } UIFinish () { mvcur(0, COLS - 1, LINES - 1, 0); fflush(stdout); endwin(); putchar('\n'); } UIClearMsg () { wclrtobot(Msgwin); } UIInitBoard () { mvaddstr(SCORE_Y + 0, SCORE_X, "+---------------------------------------+"); mvaddstr(SCORE_Y + 1, SCORE_X, "| Score: 0 YOU |"); mvaddstr(SCORE_Y + 2, SCORE_X, "| *.....:.....:.....:.....:.....:..... |"); mvaddstr(SCORE_Y + 3, SCORE_X, "| *.....:.....:.....:.....:.....:..... |"); mvaddstr(SCORE_Y + 4, SCORE_X, "| |"); mvaddstr(SCORE_Y + 5, SCORE_X, "| *.....:.....:.....:.....:.....:..... |"); mvaddstr(SCORE_Y + 6, SCORE_X, "| *.....:.....:.....:.....:.....:..... |"); mvaddstr(SCORE_Y + 7, SCORE_X, "| Score: 0 ME |"); mvaddstr(SCORE_Y + 8, SCORE_X, "+---------------------------------------+"); } UIGameScore(who, num) { mvprintw(SCORE_Y + 1 + 6 * who, SCORE_X + 28, "Games: %3d", num); } UIRefresh () { refresh (); } static WINDOW * win(who) int who; { switch (who) { case PLAYER: return Playwin; case COMPUTER: return Compwin; case TABLE: return Tablewin; } } UIEraseHand (who) int who; { WINDOW *w = win(who); werase (w); wrefresh (w); } UIClearHand (who) { werase (win(who)); } /* * prcard: * Print out a card on the window at the specified location */ extern char *rankchar[RANKS]; extern char *suitchar[SUITS]; static prcard(win, y, x, c, blank) WINDOW *win; int y, x; CARD c; BOOLEAN blank; { if (c.rank == EMPTY) return; mvwaddstr(win, y + 0, x, "+-----+"); mvwaddstr(win, y + 1, x, "| |"); mvwaddstr(win, y + 2, x, "| |"); mvwaddstr(win, y + 3, x, "| |"); mvwaddstr(win, y + 4, x, "+-----+"); if (!blank) { mvwaddch(win, y + 1, x + 1, rankchar[c.rank][0]); waddch(win, suitchar[c.suit][0]); mvwaddch(win, y + 3, x + 4, rankchar[c.rank][0]); waddch(win, suitchar[c.suit][0]); } } /* * printcard: * Print out a card. */ static printcard(win, cardno, c, blank) WINDOW *win; int cardno; CARD c; BOOLEAN blank; { prcard(win, cardno * 2, cardno, c, blank); } /* * prhand: * Print a hand of n cards */ static prhand(h, n, win, blank) CARD h[]; int n; WINDOW *win; BOOLEAN blank; { register int i; werase(win); for (i = 0; i < n; i++) printcard(win, i, *h++, blank); wrefresh(win); } UIPrintHand (h, n, who, blank) CARD h[]; int n; int who; BOOLEAN blank; { prhand (h, n, win(who), blank); } UIPrintCrib (who, card, blank) int who; CARD *card; BOOLEAN blank; { register int y, cardx; if (who == COMPUTER) cardx = CRIB_X; else cardx = 0; mvaddstr(CRIB_Y, cardx + 1, "CRIB"); prcard(stdscr, CRIB_Y + 1, cardx, *card, blank); if (who == COMPUTER) cardx = 0; else cardx = CRIB_X; for (y = CRIB_Y; y <= CRIB_Y + 5; y++) mvaddstr(y, cardx, " "); refresh (); } UITableScore (score, n) int score; { mvwprintw(Tablewin, (n + 2) * 2, n + 1, "%2d", score); wrefresh(Tablewin); } /* * prpeg: * Put out the peg character on the score board and put the * score up on the board. */ static prpeg(score, peg, myturn) register int score; char peg; BOOLEAN myturn; { register int y, x; if (!myturn) y = SCORE_Y + 2; else y = SCORE_Y + 5; if (score <= 0 || score >= glimit) { if (peg == '.') peg = ' '; if (score == 0) x = SCORE_X + 2; else { x = SCORE_X + 2; y++; } } else { x = (score - 1) % 30; if (score > 90 || (score > 30 && score <= 60)) { y++; x = 29 - x; } x += x / 5; x += SCORE_X + 3; } mvaddch(y, x, peg); mvprintw(SCORE_Y + (myturn ? 7 : 1), SCORE_X + 10, "%3d", score); } UIPrintPeg (score, on, who) int score; BOOLEAN on; int who; { prpeg(score, on ? PEG : '.', who == COMPUTER); } UIReadChar () { register int cnt, y, x; auto char c; over: cnt = 0; while (read(0, &c, 1) <= 0) if (cnt++ > 100) /* if we are getting infinite EOFs */ bye(); /* quit the game */ if (c == CNTL('L')) { wrefresh(curscr); goto over; } if (c == '\r') return '\n'; else return c; } UIEchoChar (c) int c; { waddch (Msgwin, c); } static int Lineno = 0; static int Mpos = 0; UIReadLine (buf, len) char *buf; int len; { register char *sp; register int c, oy, ox; register WINDOW *oscr; oscr = stdscr; stdscr = Msgwin; getyx(stdscr, oy, ox); refresh(); /* * loop reading in the string, and put it in a temporary buffer */ for (sp = buf; (c = UIReadChar()) != '\n'; clrtoeol(), refresh()) { if (c == -1) continue; else if (c == erasechar()) { /* process erase character */ if (sp > buf) { register int i; sp--; for (i = strlen(unctrl(*sp)); i; i--) addch('\b'); } continue; } else if (c == killchar()) { /* process kill character */ sp = buf; move(oy, ox); continue; } else if (sp == buf && c == ' ') continue; if (sp >= &buf[len-1] || !(isprint(c) || c == ' ')) putchar(CNTL('G')); else { if (islower(c)) c = toupper(c); *sp++ = c; addstr(unctrl(c)); Mpos++; } } *sp = '\0'; stdscr = oscr; } UIMessage (str, newline) char *str; int newline; { register int len; register char *mp, *omp; static int lastline = 0; len = strlen(str); if (!newline) { if (Mpos + len < MSG_X) wmove(Msgwin, Lineno > 0 ? Lineno - 1 : MSG_Y - 1, Mpos); else { mvwaddch(Msgwin, Lineno, 0, ' '); wclrtoeol(Msgwin); if (++Lineno >= MSG_Y) Lineno = 0; } waddstr(Msgwin, str); wrefresh(Msgwin); } else { /* * All messages should start with uppercase */ mvaddch(lastline + Y_MSG_START, SCORE_X, ' '); if (islower(str[0]) && str[1] != ')') str[0] = toupper(str[0]); mp = str; if (len / MSG_X + Lineno >= MSG_Y) { while (Lineno < MSG_Y) { wmove(Msgwin, Lineno++, 0); wclrtoeol(Msgwin); } Lineno = 0; } mvaddch(Lineno + Y_MSG_START, SCORE_X, '*'); lastline = Lineno; do { mvwaddstr(Msgwin, Lineno, 0, mp); if ((len = strlen(mp)) > MSG_X) { omp = mp; for (mp = &mp[MSG_X-1]; *mp != ' '; mp--) continue; while (*mp == ' ') mp--; mp++; wmove(Msgwin, Lineno, mp - omp); wclrtoeol(Msgwin); } if (++Lineno >= MSG_Y) Lineno = 0; } while (len > MSG_X); wclrtoeol(Msgwin); Mpos = len; wrefresh(Msgwin); } } UIGetMessageSize () { return MSG_X; } /* * incard: * Inputs a card in any format. It reads a line ending with a CR * and then parses it. */ static incard(crd) CARD *crd; { char *getline(); register int i; int rnk, sut; char *line, *p, *p1; BOOLEAN retval; retval = FALSE; rnk = sut = EMPTY; if (!(line = getline())) goto gotit; p = p1 = line; while( *p1 != ' ' && *p1 != NULL ) ++p1; *p1++ = NULL; if( *p == NULL ) goto gotit; /* IMPORTANT: no real card has 2 char first name */ if( strlen(p) == 2 ) { /* check for short form */ rnk = EMPTY; for( i = 0; i < RANKS; i++ ) { if( *p == *rankchar[i] ) { rnk = i; break; } } if( rnk == EMPTY ) goto gotit; /* it's nothing... */ ++p; /* advance to next char */ sut = EMPTY; for( i = 0; i < SUITS; i++ ) { if( *p == *suitchar[i] ) { sut = i; break; } } if( sut != EMPTY ) retval = TRUE; goto gotit; } rnk = EMPTY; for( i = 0; i < RANKS; i++ ) { if( !strcmp( p, rankname[i] ) || !strcmp( p, rankchar[i] ) ) { rnk = i; break; } } if( rnk == EMPTY ) goto gotit; p = p1; while( *p1 != ' ' && *p1 != NULL ) ++p1; *p1++ = NULL; if( *p == NULL ) goto gotit; if( !strcmp( "OF", p ) ) { p = p1; while( *p1 != ' ' && *p1 != NULL ) ++p1; *p1++ = NULL; if( *p == NULL ) goto gotit; } sut = EMPTY; for( i = 0; i < SUITS; i++ ) { if( !strcmp( p, suitname[i] ) || !strcmp( p, suitchar[i] ) ) { sut = i; break; } } if( sut != EMPTY ) retval = TRUE; gotit: (*crd).rank = rnk; (*crd).suit = sut; return( retval ); } /* * UIGetPlayerCard: * reads a card, supposedly in hand, accepting unambigous brief * input, returns the index of the card found... */ UIGetPlayerCard (hand, n, prompt) CARD hand[]; int n; char *prompt; { register int i, j; CARD crd; if (n < 1) { printf("\nINFROM: %d = n < 1!!\n", n); exit(74); } for (;;) { msg(prompt); if (incard(&crd)) { /* if card is full card */ if (!isone(crd, hand, n)) msg("That's not in your hand"); else { for (i = 0; i < n; i++) if (hand[i].rank == crd.rank && hand[i].suit == crd.suit) break; if (i >= n) { printf("\nINFROM: isone or something messed up\n"); exit(77); } return i; } } else /* if not full card... */ if (crd.rank != EMPTY) { for (i = 0; i < n; i++) if (hand[i].rank == crd.rank) break; if (i >= n) msg("No such rank in your hand"); else { for (j = i + 1; j < n; j++) if (hand[j].rank == crd.rank) break; if (j < n) msg("Ambiguous rank"); else return i; } } else msg("Sorry, I missed that"); } /* NOTREACHED */ } /* * wait_for * Sit around until the guy types the right key */ static void wait_for(ch) register char ch; { register char c; if (ch == '\n') while ((c = UIReadChar ()) != '\n' && c != '\r') continue; else while (UIReadChar () != ch) continue; } /* * do_wait: * Wait for the user to type ' ' before doing anything else */ UIWait () { UIMessage ("--More--", FALSE); wait_for(' '); } kgames-2.2/kcribbage/deck.h000066400000000000000000000023211416764561500156310ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. * * @(#)deck.h 5.1 (Berkeley) 5/30/85 */ /* * define structure of a deck of cards and other related things */ #define CARDS 52 /* number cards in deck */ #define RANKS 13 /* number ranks in deck */ #define SUITS 4 /* number suits in deck */ #define CINHAND 4 /* # cards in cribbage hand */ #define FULLHAND 6 /* # cards in dealt hand */ #define LGAME 121 /* number points in a game */ #define SGAME 61 /* # points in a short game */ #define SPADES 0 /* value of each suit */ #define HEARTS 1 #define DIAMONDS 2 #define CLUBS 3 #define ACE 0 /* value of each rank */ #define TWO 1 #define THREE 2 #define FOUR 3 #define FIVE 4 #define SIX 5 #define SEVEN 6 #define EIGHT 7 #define NINE 8 #define TEN 9 #define JACK 10 #define QUEEN 11 #define KING 12 #define EMPTY 13 #define VAL(c) ( (c) < 9 ? (c)+1 : 10 ) /* val of rank */ #ifndef TRUE # define TRUE 1 # define FALSE 0 #endif typedef struct { int rank; int suit; } CARD; typedef char BOOLEAN; kgames-2.2/kcribbage/extern.c000066400000000000000000000020461416764561500162270ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ # include "deck.h" # include "cribbage.h" BOOLEAN explain = FALSE; /* player mistakes explained */ BOOLEAN iwon = FALSE; /* if comp won last game */ BOOLEAN quiet = FALSE; /* if suppress random mess */ BOOLEAN rflag = FALSE; /* if all cuts random */ char expl[128]; /* explanation */ int cgames = 0; /* number games comp won */ int cscore = 0; /* comp score in this game */ int gamecount = 0; /* number games played */ int glimit = LGAME; /* game playe to glimit */ int knownum = 0; /* number of cards we know */ int pgames = 0; /* number games player won */ int pscore = 0; /* player score in this game */ CARD chand[FULLHAND]; /* computer's hand */ CARD crib[CINHAND]; /* the crib */ CARD deck[CARDS]; /* a deck */ CARD known[CARDS]; /* cards we have seen */ CARD phand[FULLHAND]; /* player's hand */ CARD turnover; /* the starter */ kgames-2.2/kcribbage/io.c000066400000000000000000000074641416764561500153420ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ # include # include # include # include "deck.h" # include "cribbage.h" # define LINESIZE 128 char linebuf[ LINESIZE ]; char *rankname[ RANKS ] = { "ACE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING" }; char *rankchar[ RANKS ] = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K" }; char *suitname[ SUITS ] = { "SPADES", "HEARTS", "DIAMONDS", "CLUBS" }; char *suitchar[ SUITS ] = { "S", "H", "D", "C" }; /* * msgcard: * Call msgcrd in one of two forms */ int msgcard(CARD c, BOOLEAN brief) { if (brief) return msgcrd(c, TRUE, (char *) NULL, TRUE); else return msgcrd(c, FALSE, " of ", FALSE); } /* * msgcrd: * Print the value of a card in ascii */ int msgcrd(CARD c, BOOLEAN brfrank, char *mid, BOOLEAN brfsuit) { if (c.rank == EMPTY || c.suit == EMPTY) return FALSE; if (brfrank) addmsg("%1.1s", rankchar[c.rank]); else addmsg(rankname[c.rank]); if (mid != NULL) addmsg(mid); if (brfsuit) addmsg("%1.1s", suitchar[c.suit]); else addmsg(suitname[c.suit]); return TRUE; } /* * getuchar: * Reads and converts to upper case */ int getuchar(void) { register int c; c = UIReadChar (); if (islower(c)) c = toupper(c); UIEchoChar (c); return c; } /* * number: * Reads in a decimal number and makes sure it is between "lo" and * "hi" inclusive. */ int number(int lo, int hi, char *prompt) { register char *p; register int sum; sum = 0; for (;;) { msg(prompt); if(!(p = getline()) || *p == '\0') { msg(quiet ? "Not a number" : "That doesn't look like a number"); continue; } sum = 0; if (!isdigit(*p)) sum = lo - 1; else while (isdigit(*p)) { sum = 10 * sum + (*p - '0'); ++p; } if (*p != ' ' && *p != '\t' && *p != '\0') sum = lo - 1; if (sum >= lo && sum <= hi) return sum; if (sum == lo - 1) msg("that doesn't look like a number, try again --> "); else msg("%d is not between %d and %d inclusive, try again --> ", sum, lo, hi); } } /* * msg: * Display a message at the top of the screen. */ char Msgbuf[BUFSIZ] = { '\0' }; static int Newpos = 0; /* VARARGS1 */ void msg(char *fmt, ...) { va_list args; va_start(args, fmt); doadd(fmt, args); va_end(args); endmsg(TRUE); } /* * addmsg: * Add things to the current message */ /* VARARGS1 */ void addmsg(char *fmt, ...) { va_list args; va_start (args, fmt); doadd(fmt, args); va_end (args); } /* * endmsg: * Display a new msg. */ void endmsg(BOOLEAN newline) { int linelen, msglen, len; char *mp; linelen = UIGetMessageSize (); msglen = strlen (Msgbuf); mp = Msgbuf; do { len = msglen; if (msglen > linelen) { for (len = linelen; len >= 0; len--) if (mp[len] == ' ') break; while (mp[len] == ' ') len++; mp[len-1] = '\0'; } UIMessage (mp, newline); newline = TRUE; mp += len; msglen -= len; } while (msglen); Newpos = 0; } /* * doadd: * Perform an add onto the message buffer */ void doadd(char *fmt, va_list args) { vsprintf (&Msgbuf[Newpos], fmt, args); Newpos = strlen(Msgbuf); } /* * getline: * Reads the next line up to '\n' or EOF. Multiple spaces are * compressed to one space; a space is inserted before a ',' */ char * getline(void) { UIReadLine (linebuf, LINESIZE); return linebuf; } /* * quit: * Leave the program, cleaning things up as we go. */ void quit(int status) { UIFinish (); exit(status); } kgames-2.2/kcribbage/kcribbage.6000066400000000000000000000006331416764561500165560ustar00rootroot00000000000000.TH KCRIBBAGE 6 "1992" "Kgames 1.0" .SH NAME kcribbage \- X window cribbage game .SH SYNOPSIS .B kcribbage .SH DESCRIPTION .I Kcribbage brings up a window for a cribbage game played against the computer. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. Use the keyboard to provide answers for questions in the text window. .SH AUTHOR Keith Packard kgames-2.2/kcribbage/kcribbage.desktop.in000066400000000000000000000003711416764561500204660ustar00rootroot00000000000000[Desktop Entry] Name=KCribbage GenericName=Card Game Comment=Play Cribbage against the computer Keywords=game;card Exec=@BINDIR@/kcribbage Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kcribbage/meson.build000066400000000000000000000034731416764561500167250ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # srcs_kcribbage = [ 'cards.c', 'CribBoard.c', 'crib.c', 'extern.c', 'io.c', 'score.c', 'support.c', 'xt.c', ] ad_file = configure_file(input: 'Cribbage.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kcribbage', srcs_kcribbage, res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kcribbage.6') configure_file(input: 'kcribbage.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kcribbage/score.c000066400000000000000000000211771416764561500160430ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ #include #include "deck.h" #include "cribbage.h" /* * the following arrays give the sum of the scores of the (50 2)*48 = 58800 * hands obtainable for the crib given the two cards whose ranks index the * array. the two arrays are for the case where the suits are equal and * not equal respectively */ long crbescr[ 169 ] = { -10000, 271827, 278883, 332319, 347769, 261129, 250653, 253203, 248259, 243435, 256275, 237435, 231051, -10000, -10000, 412815, 295707, 349497, 267519, 262521, 259695, 254019, 250047, 262887, 244047, 237663, -10000, -10000, -10000, 333987, 388629, 262017, 266787, 262971, 252729, 254475, 267315, 248475, 242091, -10000, -10000, -10000, -10000, 422097, 302787, 256437, 263751, 257883, 254271, 267111, 248271, 241887, -10000, -10000, -10000, -10000, -10000, 427677, 387837, 349173, 347985, 423861, 436701, 417861, 411477, -10000, -10000, -10000, -10000, -10000, -10000, 336387, 298851, 338667, 236487, 249327, 230487, 224103, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 408483, 266691, 229803, 246195, 227355, 220971, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 300675, 263787, 241695, 226407, 220023, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 295635, 273543, 219771, 216939, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 306519, 252747, 211431, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 304287, 262971, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 244131, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000 }; long crbnescr[ 169 ] = { 325272, 260772, 267828, 321264, 336714, 250074, 239598, 242148, 237204, 232380, 246348, 226380, 219996, -10000, 342528, 401760, 284652, 338442, 256464, 251466, 248640, 242964, 238992, 252960, 232992, 226608, -10000, -10000, 362280, 322932, 377574, 250962, 255732, 251916, 241674, 243420, 257388, 237420, 231036, -10000, -10000, -10000, 360768, 411042, 291732, 245382, 252696, 246828, 243216, 257184, 237216, 230832, -10000, -10000, -10000, -10000, 528768, 416622, 376782, 338118, 336930, 412806, 426774, 406806, 400422, -10000, -10000, -10000, -10000, -10000, 369864, 325332, 287796, 327612, 225432, 239400, 219432, 213048, -10000, -10000, -10000, -10000, -10000, -10000, 359160, 397428, 255636, 218748, 236268, 216300, 209916, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 331320, 289620, 252732, 231768, 215352, 208968, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 325152, 284580, 263616, 208716, 205884, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 321240, 296592, 241692, 200376, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 348600, 294360, 253044, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 308664, 233076, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, -10000, 295896 }; static int ichoose2[ 5 ] = { 0, 0, 2, 6, 12 }; static int pairpoints, runpoints; /* globals from pairuns */ /* * scorehand: * Score the given hand of n cards and the starter card. * n must be <= 4 */ int scorehand(CARD *hand, CARD starter, int n, BOOLEAN crb, BOOLEAN do_explain) { CARD h[(CINHAND + 1)]; register int i, k; register int score; register BOOLEAN flag; char buf[32]; expl[0] = '\0'; /* initialize explanation */ score = 0; flag = TRUE; k = hand[0].suit; for (i = 0; i < n; i++) { /* check for flush */ flag = (flag && (hand[i].suit == k)); if (hand[i].rank == JACK) /* check for his nibs */ if (hand[i].suit == starter.suit) { score++; if (do_explain) strcat(expl, "His Nobs"); } h[i] = hand[i]; } if (flag && n >= CINHAND) { if (do_explain && expl[0] != '\0') strcat(expl, ", "); if (starter.suit == k) { score += 5; if (do_explain) strcat(expl, "Five-flush"); } else if (!crb) { score += 4; if (do_explain && expl[0] != '\0') strcat(expl, ", Four-flush"); else strcpy(expl, "Four-flush"); } } if (do_explain && expl[0] != '\0') strcat(expl, ", "); h[n] = starter; sorthand(h, n + 1); /* sort by rank */ i = 2 * fifteens(h, n + 1); score += i; if (do_explain) { if (i > 0) { sprintf(buf, "%d points in fifteens", i); strcat(expl, buf); } else strcat(expl, "No fifteens"); } i = pairuns(h, n + 1); score += i; if (do_explain) { if (i > 0) { sprintf(buf, ", %d points in pairs, %d in runs", pairpoints, runpoints); strcat(expl, buf); } else strcat(expl, ", No pairs/runs"); } return score; } /* * fifteens: * Return number of fifteens in hand of n cards */ int fifteens(CARD *hand, int n) { register int *sp, *np; register int i; register CARD *endp; static int sums[15], nsums[15]; np = nsums; sp = sums; i = 16; while (--i) { *np++ = 0; *sp++ = 0; } for (endp = &hand[n]; hand < endp; hand++) { i = hand->rank + 1; if (i > 10) i = 10; np = &nsums[i]; np[-1]++; /* one way to make this */ sp = sums; while (i < 15) { *np++ += *sp++; i++; } sp = sums; np = nsums; i = 16; while (--i) *sp++ = *np++; } return sums[14]; } /* * pairuns returns the number of points in the n card sorted hand * due to pairs and runs * this routine only works if n is strictly less than 6 * sets the globals pairpoints and runpoints appropriately */ int pairuns( CARD *h, int n ) { register int i; int runlength, runmult, lastmult, curmult; int mult1, mult2, pair1, pair2; BOOLEAN run; run = TRUE; runlength = 1; mult1 = 1; pair1 = -1; mult2 = 1; pair2 = -1; curmult = runmult = 1; for( i = 1; i < n; i++ ) { lastmult = curmult; if( h[i].rank == h[i - 1].rank ) { if( pair1 < 0 ) { pair1 = h[i].rank; mult1 = curmult = 2; } else { if( h[i].rank == pair1 ) { curmult = ++mult1; } else { if( pair2 < 0 ) { pair2 = h[i].rank; mult2 = curmult = 2; } else { curmult = ++mult2; } } } if( i == (n - 1) && run ) { runmult *= curmult; } } else { curmult = 1; if( h[i].rank == h[i - 1].rank + 1 ) { if( run ) { ++runlength; } else { if( runlength < 3 ) { /* only if old short */ run = TRUE; runlength = 2; runmult = 1; } } runmult *= lastmult; } else { if( run ) runmult *= lastmult; /* if just ended */ run = FALSE; } } } pairpoints = ichoose2[ mult1 ] + ichoose2[ mult2 ]; runpoints = ( runlength >= 3 ? runlength*runmult : 0 ); return( pairpoints + runpoints ); } /* * pegscore tells how many points crd would get if played after * the n cards in tbl during pegging */ int pegscore( CARD crd, CARD *tbl, int n, int sum ) { BOOLEAN got[ RANKS ]; register int i, j, scr; int k, lo, hi; sum += VAL( crd.rank ); if( sum > 31 ) return( -1 ); if( sum == 31 || sum == 15 ) scr = 2; else scr = 0; if( !n ) return( scr ); j = 1; while( ( crd.rank == tbl[n - j].rank ) && ( n - j >= 0 ) ) ++j; if( j > 1 ) return( scr + ichoose2[j] ); if( n < 2 ) return( scr ); lo = hi = crd.rank; for( i = 0; i < RANKS; i++ ) got[i] = FALSE; got[ crd.rank ] = TRUE; k = -1; for( i = n - 1; i >= 0; --i ) { if( got[ tbl[i].rank ] ) break; got[ tbl[i].rank ] = TRUE; if( tbl[i].rank < lo ) lo = tbl[i].rank; if( tbl[i].rank > hi ) hi = tbl[i].rank; for( j = lo; j <= hi; j++ ) if( !got[j] ) break; if( j > hi ) k = hi - lo + 1; } if( k >= 3 ) return( scr + k ); else return( scr ); } /* * adjust takes a two card hand that will be put in the crib * and returns an adjusted normalized score for the number of * points such a crib will get. */ int adjust( CARD *cb, CARD tnv ) { int i, c0, c1; long scr; (void) tnv; c0 = cb[0].rank; c1 = cb[1].rank; if( c0 > c1 ) { i = c0; c0 = c1; c1 = i; } if( cb[0].suit != cb[1].suit ) scr = crbnescr[ RANKS*c0 + c1 ]; else scr = crbescr[ RANKS*c0 + c1 ]; if( scr <= 0 ) { printf( "\nADJUST: internal error %d %d\n", c0, c1 ); exit( 93 ); } return( (scr + 29400)/58800 ); } kgames-2.2/kcribbage/support.c000066400000000000000000000133201416764561500164330ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ #include "deck.h" #include "cribbage.h" #define NTV 10 /* number scores to test */ /* score to test reachability of, and order to test them in */ int tv[ NTV ] = { 8, 7, 9, 6, 11, 12, 13, 14, 10, 5 }; /* * computer chooses what to play in pegging... * only called if no playable card will score points */ int cchose( CARD *h, int n, int s ) { register int i, j, l; if( n <= 1 ) return( 0 ); if( s < 4 ) { /* try for good value */ if( ( j = anysumto(h, n, s, 4) ) >= 0 ) return( j ); if( ( j = anysumto(h, n, s, 3) ) >= 0 && s == 0 ) return( j ); } if( s > 0 && s < 20 ) { for( i = 1; i <= 10; i++ ) { /* try for retaliation to 31 */ if( ( j = anysumto(h, n, s, 21-i) ) >= 0 ) { if( ( l = numofval(h, n, i) ) > 0 ) { if( l > 1 || VAL( h[j].rank ) != i ) return( j ); } } } } if( s < 15 ) { for( i = 0; i < NTV; i++ ) { /* for retaliation after 15 */ if( ( j = anysumto(h, n, s, tv[i]) ) >= 0 ) { if( ( l = numofval(h, n, 15-tv[i]) ) > 0 ) { if( l > 1 || VAL( h[j].rank ) != 15-tv[i] ) return( j ); } } } } j = -1; for( i = n - 1; i >= 0; --i ) { /* remember: h is sorted */ l = s + VAL( h[i].rank ); if( l > 31 ) continue; if( l != 5 && l != 10 && l != 21 ) { j = i; break; } } if( j >= 0 ) return( j ); for( i = n - 1; i >= 0; --i ) { l = s + VAL( h[i].rank ); if( l > 31 ) continue; if( j < 0 ) j = i; if( l != 5 && l != 21 ) { j = i; break; } } return( j ); } /* * plyrhand: * Evaluate and score a player hand or crib */ BOOLEAN plyrhand(CARD *hand, char *s) { register int i, j; register BOOLEAN win; static char prompt[512]; UIPrintHand (hand, CINHAND, PLAYER, FALSE); sprintf(prompt, "Your %s scores ", s); i = scorehand(hand, turnover, CINHAND, strcmp(s, "crib") == 0, explain); if ((j = number(0, 29, prompt)) == 19) j = 0; if (i != j) { if (i < j) { win = chkscr(&pscore, i); msg("It's really only %d points; I get %d", i, 2); if (!win) win = chkscr(&cscore, 2); } else { win = chkscr(&pscore, j); msg("You should have taken %d, not %d!", i, j); } if (explain) msg("Explanation: %s", expl); UIWait (); } else win = chkscr(&pscore, i); return win; } /* * comphand: * Handle scoring and displaying the computers hand */ BOOLEAN comphand(CARD *h, char *s) { register int j; j = scorehand(h, turnover, CINHAND, strcmp(s, "crib") == 0, explain); UIPrintHand (h, CINHAND, COMPUTER, FALSE); msg("My %s scores %d%s%s%s", s, (j == 0 ? 19 : j), explain ? " (" : "", explain ? expl : "", explain ? ")" : ""); return chkscr(&cscore, j); } /* * chkscr: * Add inc to scr and test for > glimit, printing on the scoring * board while we're at it. */ int Lastscore[2] = {-1, -1}; BOOLEAN chkscr(int *scr, int inc) { int who; if (scr == &cscore) who = COMPUTER; else who = PLAYER; if (inc != 0) { UIPrintPeg(Lastscore[who], FALSE, who); Lastscore[who] = *scr; *scr += inc; UIPrintPeg(*scr, TRUE, who); UIRefresh (); } return (*scr >= glimit); } /* * cdiscard -- the computer figures out what is the best discard for * the crib and puts the best two cards at the end */ void cdiscard( BOOLEAN mycrib ) { CARD d[ CARDS ], h[ FULLHAND ], cb[ 2 ]; register int i, j, k; int nc, ns; long sums[ 15 ]; static int undo1[15] = {0,0,0,0,0,1,1,1,1,2,2,2,3,3,4}; static int undo2[15] = {1,2,3,4,5,2,3,4,5,3,4,5,4,5,5}; makedeck( d ); nc = CARDS; for( i = 0; i < knownum; i++ ) { /* get all other cards */ remove_card( known[i], d, nc-- ); } for( i = 0; i < 15; i++ ) sums[i] = 0L; ns = 0; for( i = 0; i < (FULLHAND - 1); i++ ) { cb[0] = chand[i]; for( j = i + 1; j < FULLHAND; j++ ) { cb[1] = chand[j]; for( k = 0; k < FULLHAND; k++ ) h[k] = chand[k]; remove_card( chand[i], h, FULLHAND ); remove_card( chand[j], h, FULLHAND - 1 ); for( k = 0; k < nc; k++ ) { sums[ns] += scorehand( h, d[k], CINHAND, TRUE, FALSE ); if( mycrib ) sums[ns] += adjust( cb, d[k] ); else sums[ns] -= adjust( cb, d[k] ); } ++ns; } } j = 0; for( i = 1; i < 15; i++ ) if( sums[i] > sums[j] ) j = i; for( k = 0; k < FULLHAND; k++ ) h[k] = chand[k]; remove_card( h[ undo1[j] ], chand, FULLHAND ); remove_card( h[ undo2[j] ], chand, FULLHAND - 1 ); chand[4] = h[ undo1[j] ]; chand[5] = h[ undo2[j] ]; } /* * returns true if some card in hand can be played without exceeding 31 */ BOOLEAN anymove( CARD *hand, int n, int sum ) { register int i, j; if( n < 1 ) return( FALSE ); j = hand[0].rank; for( i = 1; i < n; i++ ) { if( hand[i].rank < j ) j = hand[i].rank; } return( sum + VAL( j ) <= 31 ); } /* * anysumto returns the index (0 <= i < n) of the card in hand that brings * the s up to t, or -1 if there is none */ int anysumto( CARD *hand, int n, int s, int t ) { register int i; for( i = 0; i < n; i++ ) { if( s + VAL( hand[i].rank ) == t ) return( i ); } return( -1 ); } /* * return the number of cards in h having the given rank value */ int numofval( CARD *h, int n, int v ) { register int i, j; j = 0; for( i = 0; i < n; i++ ) { if( VAL( h[i].rank ) == v ) ++j; } return( j ); } /* * makeknown remembers all n cards in h for future recall */ void makeknown( CARD *h, int n ) { register int i; for( i = 0; i < n; i++ ) { known[ knownum++ ] = h[i]; } } kgames-2.2/kcribbage/test.c000066400000000000000000000061221416764561500157000ustar00rootroot00000000000000/* * Copyright (c) 1980 Regents of the University of California. * All rights reserved. The Berkeley software License Agreement * specifies the terms and conditions for redistribution. */ #ifndef lint char copyright[] = "@(#) Copyright (c) 1980 Regents of the University of California.\n\ All rights reserved.\n"; #endif not lint #ifndef lint static char sccsid[] = "@(#)test.c 5.1 (Berkeley) 5/30/85"; #endif not lint #include #include "deck.h" CARD known[ CARDS ]; /* a deck */ CARD deck[ CARDS ]; /* a deck */ CARD hand[ 4 ]; /* a hand */ int knownum; main( argc, argv ) int argc; char *argv[]; { register int k, l, m; int i, j, is, n, sum, sum2; CARD ic, jc; CARD d[ CARDS]; extern char expl[]; printf( "Assuming cards are same suit\n" ); if( argc == 2 ) { is = atoi( *++argv ); printf( "Starting at i = %d\n", is ); } makedeck( deck ); # if 0 for( i = is; i < RANKS; i++ ) { /* first card */ ic.rank = i; ic.suit = 0; hand[0] = ic; for( j = 0; j <= i; j++ ) { printf( "%d %d: sum = %d\n", i, j, -10000000 ); printf( "%d %d: sum2 = %d\n", i, j, -10000000 ); } for( j = i + 1; j < RANKS; j++ ) { /* second card */ jc.rank = j; jc.suit = 0; hand[1] = jc; for( k = 0; k < CARDS; k++ ) d[k] = deck[k]; n = CARDS; remove_card( ic, d, n-- ); remove_card( jc, d, n-- ); sum = 0; sum2 = 0; for( k = 0; k < n - 1; k++ ) { /* 3rd card */ hand[2] = d[k]; for( l = k + 1; l < n; l++ ) { /* 4th card */ hand[3] = d[l]; for( m = 0; m < n; m++ ) { /* cut card */ if( m != l && m != k ) sum += scorehand(hand, d[m], 4, FALSE, FALSE); sum2 += scorehand(hand, d[m], 4, TRUE, FALSE); } } } printf( "%d %d: sum = %d\n", i, j, sum ); printf( "%d %d: sum2 = %d\n", i, j, sum2 ); fflush( stdout ); } } printf( "\nthe hand scores %d\n", i ); # else hand[0].rank = 0; hand[1].rank = 1; hand[2].rank = 2; hand[3].rank = 3; hand[4].rank = 4; hand[0].suit = 0; hand[1].suit = 0; hand[2].suit = 0; hand[3].suit = 0; hand[4].suit = 0; printf("scorehand of hand = %d\n", scorehand(hand, hand[4], CINHAND, FALSE, TRUE)); printf("\t%s\n", expl); hand[0].rank = 0; hand[1].rank = 1; hand[2].rank = 2; hand[3].rank = 3; hand[4].rank = 4; hand[0].suit = 0; hand[1].suit = 0; hand[2].suit = 0; hand[3].suit = 0; hand[4].suit = 0; printf("scorehand of crib = %d\n", scorehand(hand, hand[4], CINHAND, TRUE, TRUE)); printf("\t%s\n", expl); hand[0].rank = 0; hand[1].rank = 1; hand[2].rank = 2; hand[3].rank = 3; hand[4].rank = 4; hand[0].suit = 0; hand[1].suit = 0; hand[2].suit = 0; hand[3].suit = 0; hand[4].suit = 1; printf("scorehand of hand = %d\n", scorehand(hand, hand[4], CINHAND, FALSE, TRUE)); printf("\t%s\n", expl); hand[0].rank = 0; hand[1].rank = 1; hand[2].rank = 2; hand[3].rank = 3; hand[4].rank = 4; hand[0].suit = 0; hand[1].suit = 0; hand[2].suit = 0; hand[3].suit = 0; hand[4].suit = 1; printf("scorehand of crib = %d\n", scorehand(hand, hand[4], CINHAND, TRUE, TRUE)); printf("\t%s\n", expl); # endif } kgames-2.2/kcribbage/xt.c000066400000000000000000000377321416764561500153670ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ # include # include # include "deck.h" # include "cribbage.h" # include # include # include # include # include # include # include # include # include # include # include # include # include # include /* # include */ # include # include # include # include # include # include # include "CribBoard.h" # include # include "Cribbage-res.h" static Widget toplevel; static Widget menuBar; static Widget fileMenuButton; static Widget fileMenu; static Widget layout; static Widget computer; static Widget message; static Widget player; static Widget table; static Widget deckWidget; static Widget playcrib; static Widget playName; static Widget compName; static Widget scoreWidget; static Widget compcrib; static Widget tableScore; typedef struct _cribbageResources { int animationSpeed; Boolean explain; Boolean quiet; Boolean random; } CribbageResources, *CribbageResourcesPtr; CribbageResources cribbageResources; #define NUM_CARDS 10 typedef struct _cribbageCard { CardsCardRec card; XtPointer private; } CribbageCardRec, *CribbageCardPtr; static CribbageCardRec computerCards[NUM_CARDS]; static CribbageCardRec playerCards[NUM_CARDS]; static CribbageCardRec tableCards[NUM_CARDS]; static CribbageCardRec playcribCards[NUM_CARDS]; static CribbageCardRec compcribCards[NUM_CARDS]; static CribbageCardRec deckCards[1]; #define SCORE_WIDTH 41 #define SCORE_HEIGHT 9 #define CHAR_BUF 1024 static char textbuf[CHAR_BUF]; static int text_in, text_out; static void key_action (Widget w, XEvent *e, String *p, Cardinal*n) { int len; KeySym keysym; XComposeStatus status; (void) w; (void) p; (void) n; len = XLookupString ((XKeyEvent *) e, textbuf + text_in, CHAR_BUF - text_in, &keysym, &status); text_in += len; } XtActionsRec actions[] = { { "cribbageKey", key_action, } }; static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; quit (0); } static int selectedCard; static Boolean cardSelected; static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; (void) w; (void) closure; switch (input->action) { case HandActionDrag: if (input->start.w == input->current.w) break; /* fall through */ case HandActionClick: selectedCard = input->start.col; cardSelected = True; break; default: break; } } struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, 0); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, 0); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(CribbageResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) 500}, { "explain", "Explain", XtRBoolean, sizeof (Boolean), offset(explain), XtRImmediate, (XtPointer) True}, { "quiet", "Quiet", XtRBoolean, sizeof (Boolean), offset(quiet), XtRImmediate, (XtPointer) False}, { "random", "Random", XtRBoolean, sizeof (Boolean), offset(random), XtRImmediate, (XtPointer) True}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", ".animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed",".animationSpeed", XrmoptionSepArg, NULL, }, { "-explain", ".explain", XrmoptionNoArg, "True", }, { "-noexplain", ".explain", XrmoptionNoArg, "False", }, { "-quiet", ".quiet", XrmoptionNoArg, "True", }, { "-random", ".random", XrmoptionNoArg, "True", }, }; void UIInit (int argc, char **argv) { toplevel = XkwInitialize ("Cribbage", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&cribbageResources, resources, XtNumber (resources), NULL, 0); explain = cribbageResources.explain; quiet = cribbageResources.quiet; rflag = cribbageResources.random; XtAddActions (actions, XtNumber(actions)); layout = XtCreateManagedWidget ("layout", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, layout, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, 0); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); player = XtCreateManagedWidget ("player", cardsWidgetClass, layout, NULL, 0); XtAddCallback (player, XtNinputCallback, InputCallback, NULL); computer = XtCreateManagedWidget ("computer", cardsWidgetClass, layout, NULL, 0); XtAddCallback (computer, XtNinputCallback, InputCallback, NULL); table = XtCreateManagedWidget ("table", cardsWidgetClass, layout, NULL, 0); XtAddCallback (table, XtNinputCallback, InputCallback, NULL); tableScore = XtCreateManagedWidget ("tableScore", klabelWidgetClass, layout, NULL, 0); playName = XtCreateManagedWidget ("playname", klabelWidgetClass, layout, NULL, 0); scoreWidget = XtCreateManagedWidget ("score", cribBoardWidgetClass, layout, NULL, 0); compName = XtCreateManagedWidget ("compname", klabelWidgetClass, layout, NULL, 0); playcrib = XtCreateManagedWidget ("playcrib", cardsWidgetClass, layout, NULL, 0); XtAddCallback (playcrib, XtNinputCallback, InputCallback, NULL); compcrib = XtCreateManagedWidget ("compcrib", cardsWidgetClass, layout, NULL, 0); XtAddCallback (compcrib, XtNinputCallback, InputCallback, NULL); deckWidget = XtCreateManagedWidget ("deck", cardsWidgetClass, layout, NULL, 0); message = XtCreateManagedWidget ("message", padWidgetClass, layout, NULL, 0); XtRealizeWidget (toplevel); XkwSetCardIcon(toplevel); } void UISuspend (void) { } void UIResume (void) { } void UIFinish (void) { } static int compPegs[2]; static int playPegs[2]; static void resetPegs (Widget w, int who, int *pegs) { int i; for (i = 0; i < 2; i++) { pegs[i] = CribBoardUnset; XkwCribBoardSetPeg (w, who, i, CribBoardUnset); } } void UIInitBoard (void) { resetPegs (scoreWidget, PLAYER, playPegs); resetPegs (scoreWidget, COMPUTER, compPegs); Message(compName, "My score"); Message(playName, "Your score"); } void UIGameScore (int who, int num) { (void) who; (void) num; #ifdef NOTDEF char buf[100]; sprintf (buf, "Games: %3d", num); XkwPadText (scoreWidget, 1 + 6 * who, 28, buf, strlen (buf)); #endif } void UIRefresh (void) { XkwPadUpdate (message); HandUpdateDisplay (computer); HandUpdateDisplay (player); HandUpdateDisplay (table); HandUpdateDisplay (playcrib); HandUpdateDisplay (compcrib); HandUpdateDisplay (deckWidget); } void UIWait (void) { XEvent event; UIMessage ("--More--", TRUE); UIRefresh (); for (;;) { XtNextEvent (&event); switch (event.type) { case KeyRelease: case ButtonRelease: continue; case KeyPress: case ButtonPress: return; default: XtDispatchEvent (&event); } } } static Widget widget (int who) { switch (who) { case PLAYER: return player; case COMPUTER: return computer; default: case TABLE: return table; } } static CribbageCardPtr Cards (int who) { switch (who) { case PLAYER: return playerCards; case COMPUTER: return computerCards; default: case TABLE: return tableCards; } } void UIEraseHand (int who) { Widget w = widget (who); UIClearHand (who); HandUpdateDisplay (w); } void UIClearHand (int who) { CribbageCardPtr cards = Cards(who); int i; if (who == TABLE) Message (tableScore, ""); for (i = 0; i < NUM_CARDS; i++) { cards[i].card.suit = CardsNone; cards[i].private = 0; } HandRemoveAllCards (widget (who)); } static const CardsSuit CardsSuitMap[] = { CardsSpade, CardsHeart, CardsDiamond, CardsClub }; static const CardsRank CardsRankMap[] = { CardsAce, Cards2, Cards3, Cards4, Cards5, Cards6, Cards7, Cards8, Cards9, Cards10, CardsJack, CardsQueen, CardsKing, CardsRankEmpty }; static void updateCards (Widget w, CARD *h, int n, CribbageCardPtr cards, int len, BOOLEAN blank) { int i; CardsSuit suit; CardsRank rank; for (i = 0; i < n; i++) { if (h[i].rank == EMPTY) { suit = CardsEmpty; rank = CardsAce; } else { if (blank) { suit = CardsBack; rank = CardsAce; } else { suit = CardsSuitMap[h[i].suit]; rank = CardsRankMap[h[i].rank]; } } if (cards[i].card.suit != suit || cards[i].card.rank != rank) { cards[i].card.suit = suit; cards[i].card.rank = rank; if (cards[i].private) CardsReplaceCard (w, cards[i].private, &cards[i].card); else cards[i].private = CardsAddCard (w, &cards[i].card, 0, i); } } for (; i < len; i++) { if (cards[i].private) { CardsRemoveCard (w, cards[i].private); cards[i].private = 0; cards[i].card.suit = CardsNone; } } } void UIPrintHand (CARD *h, int n, int who, BOOLEAN blank) { Widget w; CribbageCardPtr cards; if (h == crib) { if (who == COMPUTER) { w = compcrib; cards = compcribCards; } else { w = playcrib; cards = playcribCards; } } else { w = widget(who); cards = Cards(who); } updateCards (w, h, n, cards, NUM_CARDS, blank); } void UIPrintCrib (int who, CARD *card, BOOLEAN blank) { Widget w, ow; CribbageCardPtr cards, ocards; if (who == COMPUTER) { w = compcrib; cards = compcribCards; ow = playcrib; ocards = playcribCards; } else { w = playcrib; cards = playcribCards; ow = compcrib; ocards = compcribCards; } updateCards (w, crib, 4, cards, NUM_CARDS, TRUE); updateCards (ow, NULL, 0, ocards, NUM_CARDS, TRUE); updateCards (deckWidget, card, 1, deckCards, 1, blank); } void UITableScore (int score, int n) { (void) n; Message (tableScore, "Score: %d", score); } void UIPrintPeg (int score, BOOLEAN on, int who) { Widget l; int *pegs; int i; const char *label; if (who == COMPUTER) { l = compName; pegs = compPegs; label = "My"; } else { l = playName; pegs = playPegs; label = "Your"; } if (score <= 0) score = CribBoardUnset; if (!on) { if (score == pegs[1]) i = 1; else i = 0; score = CribBoardUnset; } else { if (pegs[0] == CribBoardUnset) i = 0; else i = 1; } pegs[i] = score; XkwCribBoardSetPeg (scoreWidget, who, i, score - 1); Message(l, "%s score: %d", label, score); } static int msgLine, msgCol; static int curLine, curCol; void ShowCursor (void) { char attr[1]; curLine = msgLine; curCol = msgCol; attr[0] = XkwPadInverse; XkwPadAttributes (message, curLine, curCol, attr, 1); } void HideCursor (void) { char attr[1]; attr[0] = XkwPadNormal; if (curLine >= 0) XkwPadAttributes (message, curLine, curCol, attr, 1); curLine = -1; } int UIReadChar (void) { int c; ShowCursor (); UIRefresh (); while (text_in == text_out) { XtProcessEvent (XtIMAll); } c = textbuf[text_out++]; if (text_out == text_in) text_out = text_in = 0; if (c == '\r') c = '\n'; HideCursor (); return c; } void UIEchoChar (char c) { XkwPadText (message, msgLine, msgCol, &c, 1); msgCol++; } void UIReadLine (char *buf, int len) { int ox, oy; char *sp; int c; char str[2]; /* * loop reading in the string, and put it in a temporary buffer */ ox = msgCol; oy = msgLine; for (sp = buf; (c = UIReadChar()) != '\n'; ) { if (c == -1) continue; else if (c == '\b') { /* process erase character */ if (sp > buf) { sp--; --msgCol; XkwPadText (message, msgLine, msgCol, " ", 1); } continue; } else if (c == '\025') { /* process kill character */ sp = buf; msgCol = ox; msgLine = oy; continue; } else if (sp == buf && c == ' ') continue; if (sp >= &buf[len-1] || !(isprint(c) || c == ' ')) XBell (XtDisplay (toplevel), 0); else { if (islower(c)) c = toupper(c); *sp++ = c; str[0] = c; str[1] = '\0'; UIMessage (str, FALSE); } UIRefresh (); } *sp = '\0'; } static void CheckScroll (void) { Arg arg[1]; Dimension rows; XtSetArg (arg[0], XtNnumRows, &rows); XtGetValues (message, arg, 1); while (msgLine >= rows) { XkwPadScroll (message, 0, rows, -1); msgLine--; curLine--; } } void UIMessage (char *str, int newline) { int len = strlen (str); if (newline) { msgLine++; CheckScroll (); msgCol = 0; } XkwPadText (message, msgLine, msgCol, str, len); msgCol += len; } int UIGetMessageSize (void) { Arg arg; Dimension cols; XtSetArg (arg, XtNnumCols, &cols); XtGetValues (message, &arg, 1); return cols; } void UIClearMsg (void) { XkwPadClear (message); msgLine = 0; msgCol = 0; } int UIGetPlayerCard (CARD *hand, int n, char *prompt) { for (;;) { msg (prompt); UIRefresh (); cardSelected = False; while (!cardSelected) { XtProcessEvent(XtIMAll); } if (0 <= selectedCard && selectedCard < n) { msgcard (hand[selectedCard], FALSE); endmsg (FALSE); return selectedCard; } msg ("Sorry, I missed that"); } } static BOOLEAN timer_done; static void timer_proc(XtPointer client_data, XtIntervalId *id) { (void) client_data; (void) id; timer_done = TRUE; } void UIPause(void) { timer_done = FALSE; XtAddTimeOut(1000, timer_proc, NULL); while (!timer_done) { XtProcessEvent(XtIMAll); } } kgames-2.2/kdominos/000077500000000000000000000000001416764561500144665ustar00rootroot00000000000000kgames-2.2/kdominos/Dominos.ad.in000066400000000000000000000053461416764561500170210ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *score0.Foreground: #fffff0 *score1.Foreground: #fffff0 *score0.Background: #337744 *score1.Background: #337744 *Dominos.Background: #337744 *frame.Background: #337744 *panner.Foreground: #fffff0 *yesOrNoDialog.Background: #337744 *yesOrNoLabel.Background: #337744 *yesOrNoLabel.Foreground: #fffff0 *allowShellResize: True *message.justify: left *message.label: Keith's Dominos, Version @KGAMES_VERSION@ *Command.borderWidth: 1 *borderWidth: 0 *menuBar.layout: vertical { \ spacing = (height score0 / 3 ) \ $spacing < -100% >\ horizontal { \ $spacing < -100% > \ fileMenuButton \ $spacing < -100% > \ newGame \ $spacing < -100% > \ hint \ $spacing < -100% > \ undo \ $spacing < -100% > \ draw \ $spacing < -100% > \ zoom_in \ $spacing < -100% > \ zoom_out \ $spacing <+inf -inf> \ score0 \ $spacing < -100% > \ score1 \ $spacing < -100% > \ } \ $spacing < -100% > \ } *board.width: 650 *board.height: 500 *player_scrollbar.orientation: horizontal *Scrollbar.Foreground: gray *scroll_h.orientation: horizontal *scroll_v.orientation: vertical *frame.layout: vertical {\ horizontal { -1 menuBar < +inff -100% * > -1 } \ horizontal { \ message < +inff -100% * > \ computerCount < -100% * > \ } \ horizontal { \ porthole < +inf -inf * +inf -inf > \ scroll_v < * +inff > \ } \ horizontal { \ scroll_h < +inff * > \ vertical { \ width scroll_v, 0 \ corner < +inff -inff * +inff -inff > \ }\ } \ player_porthole < +inf -inf * > \ player_scrollbar < +inf -inf * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *draw.label: Draw *zoom_in.label: Zoom In *zoom_out.label: Zoom Out *pileAll.label: Fill Piles *Command.shapeStyle: oval *frame.translations: #override \ u: dominosUndo()\n\ n: dominosNewGame()\n\ d: dominosDraw()\n\ ?: dominosHint()\n\ +: dominosZoomIn()\n\ -: dominosZoomOut() *yesOrNoShell.allowShellResize: true *yesOrNoLabel.borderWidth: 0 *yesOrNoDialog.translations: #override\n\ y: dominosYes()\n\ n: dominosNo() *yesOrNoDialog.layout: vertical {\ Spacing = (50 % of height yesOrNoLabel) \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < -inf > \ yesOrNoLabel \ $Spacing < -inf > \ } \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < -inf > \ yesOrNoOk \ $Spacing < +inf -inf > \ yesOrNoNo \ $Spacing < -inf > \ } \ $Spacing < +inf -inf > \ } *yesOrNoOk.label: OK *yesOrNoNo.label: No kgames-2.2/kdominos/Dominos.c000066400000000000000000000447111416764561500162510ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include #include #include #include #include #include #include #include "DominosP.h" #define offset(field) XtOffsetOf(DominosRec, dominos.field) #define COLOR_UNSET 10 static XtResource resources[] = { {XtNfaceColor, XtCFaceColor, XtRRenderColor, sizeof (XRenderColor), offset(face_color), XtRString, (XtPointer) "black"}, {XtNpipsColor, XtCPipsColor, XtRRenderColor, sizeof (XRenderColor), offset(pips_color), XtRString, (XtPointer) "white"}, {XtNsize, XtCSize, XtRDimension, sizeof (Dimension), offset(size), XtRImmediate, (XtPointer) 60}, {XtNinputCallback, XtCInputCallback, XtRCallback, sizeof (XtPointer), offset(input_callback), XtRCallback, (XtPointer) NULL}, }; #undef offset #undef hoffset #include static char defaultTranslations[] = ": zoomout()\n" ": zoomin()\n" ":\n" ":\n" ": start()\n" ": drag(drag)\n" ": stop(dest)"; #define SuperClass ((KSimpleWidgetClass)&ksimpleClassRec) #define INSET(w) ((w)->dominos.size / 20.0) #define RADIUS(w) ((w)->dominos.size / 10.0) #define LINE_WIDTH(w) ((w)->dominos.size / 25.0) #define PIP_SIZE(w) ((w)->dominos.size / 15.0) #define PIP_OFF(w) ((w)->dominos.size / 5.0) #define DOMINO_MINOR_SIZE(w) ((w)->dominos.size) #define DOMINO_MAJOR_SIZE(w) ((w)->dominos.size * 2) #define DOMINO_MAJOR_WIDTH(w) DOMINO_MAJOR_SIZE(w) #define DOMINO_MAJOR_HEIGHT(w) DOMINO_MAJOR_SIZE(w) #define DOMINO_MINOR_WIDTH(w) DOMINO_MINOR_SIZE(w) #define DOMINO_MINOR_HEIGHT(w) DOMINO_MINOR_SIZE(w) #define DominoUpright(d) ((d)->orientation == North || \ (d)->orientation == South) static int DominoWidth (DominosWidget w, DominoPtr d) { if (DominoUpright(d)) return DOMINO_MINOR_WIDTH(w); else return DOMINO_MAJOR_WIDTH(w); } static int DominoHeight (DominosWidget w, DominoPtr d) { if (DominoUpright(d)) return DOMINO_MAJOR_HEIGHT(w); else return DOMINO_MINOR_HEIGHT(w); } static DominoPtr Dominos(DominosWidget w) { if (w->dominos.board) return *w->dominos.board; return NULL; } #define DominoX(w,d) (DominoWidth (w, d) / 2) #define DominoY(w,d) (DominoHeight (w, d) / 2) #define ScreenNo(w) XScreenNumberOfScreen (XtScreen (w)) static void ClassInitialize(void) { XkwInitializeWidgetSet(); } #define UsualSuspects(w) Display *dpy = XtDisplay ((Widget) w); \ Window window = XtWindow ((Widget) w); \ Pixmap tmp_map = (w)->dominos.tmp_map #define GetScreen(w) int screen = ScreenNo(w) /*ARGSUSED*/ static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { DominosWidget new = (DominosWidget) gnew; (void) greq; (void) args; (void) count; if (!new->core.width) new->core.width = DOMINO_MINOR_WIDTH(new); if (!new->core.height) new->core.height = DOMINO_MAJOR_HEIGHT(new); } #define MotionMask ( \ PointerMotionMask | Button1MotionMask | \ Button2MotionMask | Button3MotionMask | Button4MotionMask | \ Button5MotionMask | ButtonMotionMask ) #define PointerGrabMask ( \ ButtonPressMask | ButtonReleaseMask | \ EnterWindowMask | LeaveWindowMask | \ PointerMotionHintMask | KeymapStateMask | \ MotionMask ) static void Destroy (Widget gw) { (void) gw; } static int PeerX(DominosWidget w, DominoPtr d, Direction dir) { switch (dir) { default: case North: case South: return 0; case West: return -DominoX(w, d) - DominoWidth(w, d->peer[dir]) + DominoX(w, d->peer[dir]); case East: return -DominoX(w, d) + DominoWidth(w, d) + DominoX(w, d->peer[dir]); } /*NOTREACHED*/ } static int PeerY(DominosWidget w, DominoPtr d, Direction dir) { switch (dir) { default: case East: case West: return 0; case North: return -DominoY(w, d) - DominoHeight(w, d->peer[dir]) + DominoY(w, d->peer[dir]); case South: return -DominoY(w, d) + DominoHeight(w, d) + DominoY(w, d->peer[dir]); } /*NOTREACHED*/ } static void BoardSize (DominosWidget w, DominoPtr b, RectPtr r, int x, int y) { RectRec sub; Direction dir; if (!b) { r->x1 = x; r->y1 = y; r->x2 = x; r->y2 = y; return; } r->x1 = x - DominoX(w, b); r->y1 = y - DominoY(w, b); r->x2 = r->x1 + DominoWidth(w, b); r->y2 = r->y1 + DominoHeight(w, b); for (dir = North; dir <= West; dir++) { if (b->peer[dir]) { BoardSize (w, b->peer[dir], &sub, x + PeerX(w, b, dir), y + PeerY(w, b, dir)); if (sub.x1 < r->x1) r->x1 = sub.x1; if (sub.x2 > r->x2) r->x2 = sub.x2; if (sub.y1 < r->y1) r->y1 = sub.y1; if (sub.y2 > r->y2) r->y2 = sub.y2; } } } static void PreferredSize (DominosWidget w, Dimension *width, Dimension *height, Position *x, Position *y) { RectRec size; Dimension preferred_width, preferred_height; BoardSize (w, Dominos(w), &size, 0, 0); preferred_width = size.x2 - size.x1; preferred_height = size.y2 - size.y1; if (preferred_width < DOMINO_MINOR_WIDTH(w)) preferred_width = DOMINO_MINOR_WIDTH(w); if (preferred_height < DOMINO_MAJOR_HEIGHT(w)) preferred_height = DOMINO_MAJOR_HEIGHT(w); *width = preferred_width; *height = preferred_height; if (x) *x = size.x1; if (y) *y = size.y1; } static Boolean SetValues (Widget gcur, Widget greq, Widget gnew, Arg *args, Cardinal *count) { DominosWidget cur = (DominosWidget) gcur; DominosWidget new = (DominosWidget) gnew; Boolean redisplay = False; (void) greq; (void) args; (void) count; if (!XkwColorEqual(&cur->dominos.face_color, &new->dominos.face_color)) redisplay = True; if (!XkwColorEqual(&cur->dominos.pips_color, &new->dominos.pips_color)) redisplay = True; if (XtWidth(gcur) != XtWidth(greq) || XtHeight(gcur) != XtHeight(greq)) redisplay = True; if (cur->dominos.size != new->dominos.size) { Dimension preferred_width, preferred_height, width, height; XtGeometryResult result; PreferredSize(new, &preferred_width, &preferred_height, NULL, NULL); if (preferred_width != new->core.width || preferred_height != new->core.height) { result = XtMakeResizeRequest ((Widget) new, preferred_width, preferred_height, &width, &height); if (result == XtGeometryAlmost) result = XtMakeResizeRequest ((Widget) new, width, height, NULL, NULL); } redisplay = True; } return redisplay; } static int i_sqrt (int a) { double d_a; d_a = (double) a; d_a = sqrt (d_a); return (int) d_a; } static DominoPtr XYInDomino (DominosWidget w, DominoPtr b, int x, int y, int test_x, int test_y, int *distp, Direction *dirp) { RectRec r; Direction dir; DominoPtr peer, closest; Direction to_dir, x_dir, y_dir; Direction sub_dir; int to_dist; int x_dist, y_dist; int sub_dist; if (!b) return NULL; r.x1 = x - DominoX(w, b); r.y1 = y - DominoY(w, b); r.x2 = r.x1 + DominoWidth(w, b); r.y2 = r.y1 + DominoHeight(w, b); to_dir = North; to_dist = 0; if (test_x < r.x1) { x_dist = r.x1 - test_x; x_dir = West; } else if (r.x2 < test_x) { x_dir = East; x_dist = test_x - r.x2; } else { x_dir = West; x_dist = 0; } if (test_y < r.y1) { y_dir = North; y_dist = r.y1 - test_y; } else if (r.y2 < test_y) { y_dir = South; y_dist = test_y - r.y2; } else { y_dir = South; y_dist = 0; } if (x_dist >= y_dist) to_dir = x_dir; else to_dir = y_dir; to_dist = i_sqrt (x_dist * x_dist + y_dist * y_dist); closest = b; if (to_dist > 0) { for (dir = North; dir <= West; dir++) { if (b->peer[dir]) { peer = XYInDomino (w, b->peer[dir], x + PeerX(w, b, dir), y + PeerY(w, b, dir), test_x, test_y, &sub_dist, &sub_dir); if (peer && sub_dist < to_dist) { to_dist = sub_dist; to_dir = sub_dir; closest = peer; if (sub_dist == 0) break; } } } } *distp = to_dist; *dirp = to_dir; return closest; } static DominoPtr XYToDomino (DominosWidget w, int x, int y, int *distp, Direction *dirp) { return XYInDomino (w, Dominos(w), w->dominos.x_off, w->dominos.y_off, x, y, distp, dirp); } DominoPtr DominosXYToDomino (Widget gw, int x, int y, int *distp, Direction *dirp) { DominosWidget w = (DominosWidget) gw; DominoPtr domino = XYToDomino(w, x, y, distp, dirp); if (domino && *distp > DOMINO_MAJOR_SIZE(w)) domino = NULL; return domino; } static void DoInputCallback(Widget gw, DominosAction action, XEvent *event, String *params, Cardinal *num_params) { DominosWidget w = (DominosWidget) gw; DominoPtr d; DominosInputRec input; Direction dir; int dist; d = XYToDomino (w, event->xbutton.x, event->xbutton.y, &dist, &dir); input.w = gw; input.action = action; input.domino = d; input.direction = dir; input.distance = dist; input.params = params; input.event = *event; input.num_params = num_params; XtCallCallbackList (gw, w->dominos.input_callback, (XtPointer) &input); } static void ActionStart (Widget gw, XEvent *event, String *params, Cardinal *num_params) { DoInputCallback(gw, DominosActionStart, event, params, num_params); } static void ActionDrag (Widget gw, XEvent *event, String *params, Cardinal *num_params) { DoInputCallback(gw, DominosActionDrag, event, params, num_params); } static void ActionStop (Widget gw, XEvent *event, String *params, Cardinal *num_params) { if (XkwForwardEvent(NULL, gw, event)) return; DoInputCallback(gw, DominosActionStop, event, params, num_params); } static void Zoom(Widget w, double ratio) { Arg args[1]; Dimension size; XtSetArg(args[0], XtNsize, &size); XtGetValues(w, args, 1); size = (Dimension) (size * ratio + 0.5); XtSetArg(args[0], XtNsize, size); XtSetValues(w, args, 1); } static void ZoomInAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) e; (void) p; (void) n; Zoom (w, 1.25); } static void ZoomOutAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) e; (void) p; (void) n; Zoom (w, 0.8); } static void OutlineDomino (DominosWidget w, cairo_t *cr, DominoPtr d, double width, double height) { XkwSetSource (cr, &w->dominos.pips_color); cairo_set_line_width(cr, LINE_WIDTH(w)); if (DominoUpright (d)) { cairo_move_to(cr, 0, height/2.0); cairo_line_to(cr, width, height/2.0); } else { cairo_move_to(cr, width / 2.0, 0); cairo_line_to(cr, width / 2.0, height); } XkwDrawRoundedRect(cr, width, height, RADIUS(w)); cairo_stroke(cr); } static void FillDomino (DominosWidget w, cairo_t *cr, DominoPtr d) { double width, height; width = DominoWidth(w, d) - INSET(w) * 2; height = DominoHeight(w, d) - INSET(w) * 2; XkwSetSource (cr, &w->dominos.face_color); cairo_save(cr); cairo_translate(cr, INSET(w), INSET(w)); XkwDrawRoundedRect(cr, width, height, RADIUS(w)); cairo_fill(cr); OutlineDomino (w, cr, d, width, height); cairo_restore(cr); } static void DrawPip (cairo_t *cr, double x, double y, double radius) { cairo_arc(cr, x, y, radius, 0, M_PI * 2); cairo_fill(cr); } static void DrawPips (DominosWidget w, cairo_t *cr, Pips p, int flip) { int off_x, off_y; int half_x, half_y; double radius = PIP_SIZE(w); XkwSetSource(cr, &w->dominos.pips_color); off_x = PIP_OFF(w); off_y = PIP_OFF(w); half_x = 0; half_y = off_y; if (flip) { half_x = off_x; half_y = 0; off_x = -off_x; } if (p & 1) { DrawPip (cr, 0, 0, radius); p = p - 1; } switch (p) { case 8: DrawPip (cr, - half_x, - half_y, radius); DrawPip (cr, + half_x, + half_y, radius); /* fall through */ case 6: DrawPip (cr, - half_y, - half_x, radius); DrawPip (cr, + half_y, + half_x, radius); /* fall through */ case 4: DrawPip (cr, + off_x, - off_y, radius); DrawPip (cr, - off_x, + off_y, radius); /* fall through */ case 2: DrawPip (cr, - off_x, - off_y, radius); DrawPip (cr, + off_x, + off_y, radius); } } static void DrawDomino(DominosWidget w, cairo_t *cr, DominoPtr d) { int off_x, off_y; Pips p; int flip; if (d->hide) return; FillDomino (w, cr, d); flip = !DominoUpright(d); if (d->orientation == North || d->orientation == West) p = d->pips[0]; else p = d->pips[1]; off_x = DOMINO_MINOR_WIDTH(w) / 2; off_y = DOMINO_MINOR_HEIGHT(w) / 2; cairo_save(cr); { cairo_translate(cr, off_x, off_y); DrawPips (w, cr, p, flip); } cairo_restore(cr); if (d->orientation == North || d->orientation == West) p = d->pips[1]; else p = d->pips[0]; if (!flip) off_y = DominoY(w, d) + DOMINO_MINOR_HEIGHT(w) / 2; else off_x = DominoX(w, d) + DOMINO_MINOR_WIDTH(w) / 2; cairo_save(cr); { cairo_translate(cr, off_x, off_y); DrawPips (w, cr, p, flip); } cairo_restore(cr); } static void DrawDominos (DominosWidget w, cairo_t *cr, DominoPtr d, int x, int y) { Direction dir; cairo_save(cr); cairo_translate(cr, x - DominoX(w, d), y - DominoY(w, d)); DrawDomino (w, cr, d); cairo_restore(cr); for (dir = North; dir <= West; dir++) if (d->peer[dir]) DrawDominos (w, cr, d->peer[dir], x + PeerX(w, d, dir), y + PeerY(w, d, dir)); } static void DrawBoard (DominosWidget w, Boolean ok_resize, Region region) { int xoff, yoff; Position x, y; Dimension preferred_width, preferred_height, width, height; XtGeometryResult result; PreferredSize(w, &preferred_width, &preferred_height, &x, &y); if (ok_resize && (XtIsRealized ((Widget) w) || w->core.width < preferred_width || w->core.height < preferred_height) && (preferred_width != w->core.width || preferred_height != w->core.height)) { result = XtMakeResizeRequest ((Widget) w, preferred_width, preferred_height, &width, &height); if (result == XtGeometryAlmost && (width != w->core.width || height != w->core.height)) result = XtMakeResizeRequest ((Widget) w, width, height, NULL, NULL); } if (XtIsRealized ((Widget) w)) { DominoPtr b = Dominos(w); cairo_t *cr = XkwDrawBegin((Widget) w, region); xoff = (w->core.width - preferred_width) / 2 - x; yoff = (w->core.height- preferred_height) / 2 - y; w->dominos.x_off = xoff; w->dominos.y_off = yoff; if (b) DrawDominos (w, cr, b, xoff, yoff); XkwDrawEnd((Widget) w, region, cr); } } void DominosSetDominos (Widget gw, DominoPtr *boardp) { DominosWidget w = (DominosWidget) gw; w->dominos.board = boardp; if (XtIsRealized ((Widget) w)) DrawBoard (w, TRUE, NULL); } static void Redisplay (Widget gw, XEvent *event, Region region) { DominosWidget w = (DominosWidget) gw; (void) event; DrawBoard (w, FALSE, region); } static void Resize (Widget gw) { if (XtIsRealized(gw)) XClearArea(XtDisplay(gw), XtWindow(gw), 0, 0, 0, 0, True); } static XtGeometryResult QueryGeometry(Widget gw, XtWidgetGeometry *intended, XtWidgetGeometry *preferred) { DominosWidget w = (DominosWidget) gw; preferred->request_mode = intended->request_mode & (CWWidth|CWHeight); PreferredSize(w, &preferred->width, &preferred->height, NULL, NULL); if (((intended->request_mode & (CWWidth | CWHeight)) == (CWWidth | CWHeight)) && intended->width == preferred->width && intended->height == preferred->height) return (XtGeometryYes); else if (preferred->width == XtWidth(w) && preferred->height == XtHeight(w)) return (XtGeometryNo); return (XtGeometryAlmost); } static XtActionsRec actions[] = { { "start", ActionStart }, /* select card */ { "drag", ActionDrag }, { "stop", ActionStop }, { "zoomin", ZoomInAction }, { "zoomout", ZoomOutAction }, }; DominosClassRec dominosClassRec = { { /* core fields */ /* superclass */ (WidgetClass) SuperClass, /* class_name */ "Dominos", /* widget_size */ sizeof(DominosRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ actions, /* num_actions */ XtNumber(actions), /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ Destroy, /* resize */ Resize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ defaultTranslations, /* query_geometry */ QueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* simple fields */ /* change_sensitive */ XtInheritChangeSensitive, /* extension */ NULL }, { /* ksimple fields */ /* unused */ 0, }, { /* dominos fields */ /* ignore */ 0 }, }; WidgetClass dominosWidgetClass = (WidgetClass) &dominosClassRec; kgames-2.2/kdominos/Dominos.h000066400000000000000000000043331416764561500162520ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _XtDominos_h #define _XtDominos_h #include "domino.h" #include /* define exposed functions */ void DominosSetDominos(Widget, DominoPtr *); DominoPtr DominosXYToDomino (Widget gw, int x, int y, int *distp, Direction *dirp); typedef struct _DominosRec *DominosWidget; typedef struct _DominosClassRec *DominosWidgetClass; extern WidgetClass dominosWidgetClass; #define XtNfaceColor "faceColor" #define XtCFaceColor "FaceColor" #define XtNpipsColor "pipsColor" #define XtCPipsColor "PipsColor" #define XtNsize "size" #define XtCSize "Size" #define XtNinputCallback "inputCallback" #define XtCInputCallback "InputCallback" typedef enum { DominosActionStart, DominosActionDrag, DominosActionStop, } DominosAction; typedef struct _DominosInput { Widget w; DominosAction action; DominoPtr domino; Direction direction; int distance; XEvent event; String *params; Cardinal *num_params; } DominosInputRec, *DominosInputPtr; #endif /* _XtDominos_h */ kgames-2.2/kdominos/DominosP.h000066400000000000000000000044741416764561500164000ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _XtDominosP_h #define _XtDominosP_h #include #include "Dominos.h" #include "domino.h" /************************************ * * Class structure * ***********************************/ /* * New fields for the Dominos widget class record */ typedef struct _DominosClass { int makes_compiler_happy; /* not used */ } DominosClassPart; /* * Full class record declaration */ typedef struct _DominosClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; DominosClassPart cards_class; } DominosClassRec; extern DominosClassRec cardsClassRec; typedef struct { /* resources */ XRenderColor pips_color; XRenderColor face_color; XRenderColor background; Dimension size; XtCallbackList input_callback; /* func called on button press */ /* private state */ DominoPtr *board; Position x_off, y_off; } DominosPart; /* * Full widget declaration */ typedef struct _DominosRec { CorePart core; SimplePart simple; KSimplePart ksimple; DominosPart dominos; } DominosRec; #endif /* _XtDominosP_h */ kgames-2.2/kdominos/board.c000066400000000000000000000125311416764561500157230ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" #define DOMINO_MAJOR_WIDTH 17 #define DOMINO_MINOR_WIDTH 9 #define DOMINO_MAJOR_HEIGHT 9 #define DOMINO_MINOR_HEIGHT 5 #define DominoUpright(d) ((d)->orientation == North || (d)->orientation == South) #define DominoWidth(d) (DominoUpright(d) ? DOMINO_MINOR_WIDTH : DOMINO_MAJOR_WIDTH) #define DominoHeight(d) (DominoUpright(d) ? DOMINO_MAJOR_HEIGHT : DOMINO_MINOR_HEIGHT) #define DominoX(d) (DominoUpright(d) ? DOMINO_MINOR_WIDTH / 2 : DOMINO_MAJOR_WIDTH / 2) #define DominoY(d) (DominoUpright(d) ? DOMINO_MAJOR_HEIGHT / 2 : DOMINO_MINOR_HEIGHT / 2) PeerX(d, dir) DominoPtr d; Direction dir; { switch (dir) { case North: case South: return 0; case East: return -DominoX(d) - DominoWidth(d->peer[dir]) + DominoX(d->peer[dir]); case West: return -DominoX(d) + DominoWidth(d) + DominoX(d->peer[dir]); } } PeerY(d, dir) DominoPtr d; Direction dir; { switch (dir) { case East: case West: return 0; case North: return -DominoY(d) - DominoHeight(d->peer[dir]) + DominoY(d->peer[dir]); case South: return -DominoY(d) + DominoHeight(d) + DominoY(d->peer[dir]); } } BoardSize (b, r, x, y) DominoPtr b; RectPtr r; int x, y; { RectRec sub; Direction dir; r->x1 = x - DominoX(b); r->y1 = y - DominoY(b); r->x2 = r->x1 + DominoWidth(b); r->y2 = r->y1 + DominoHeight(b); for (dir = North; dir <= West; dir++) { if (b->peer[dir]) { BoardSize (b->peer[dir], &sub, x + PeerX(b,dir), y + PeerY(b, dir)); if (sub.x1 < r->x1) r->x1 = sub.x1; if (sub.x2 > r->x2) r->x2 = sub.x2; if (sub.y1 < r->y1) r->y1 = sub.y1; if (sub.y2 > r->y2) r->y2 = sub.y2; } } } DrawDominos (b, x, y) DominoPtr b; int x, y; { Direction dir; DrawDomino (b, x - DominoX(b), y - DominoY(b)); for (dir = North; dir <= West; dir++) if (b->peer[dir]) DrawDominos (b->peer[dir], x + PeerX(b,dir), y + PeerY(b, dir)); } DrawBoard (b) DominoPtr b; { RectRec size; int xoff, yoff; BoardSize (b, &size, 0, 0); InitDraw (&size); xoff = -size.x1; yoff = -size.y1; DrawDominos (b, xoff, yoff); DoneDraw (&size); } DrawDomino(d, x, y) DominoPtr d; int x, y; { if (d->orientation == North || d->orientation == East) DrawEnd (d->pips[0], x, y); else DrawEnd (d->pips[1], x, y); if (d->orientation == North || d->orientation == South) y += DOMINO_MINOR_HEIGHT-1; else x += DOMINO_MINOR_WIDTH-1; if (d->orientation == North || d->orientation == East) DrawEnd (d->pips[1], x, y); else DrawEnd (d->pips[0], x, y); } char screen[512][512]; InitDraw (r) RectPtr r; { int x, y; int height, width; height = r->y2 - r->y1; width = r->x2 - r->x1; for (y = 0; y < height; y++) for (x = 0; x < width; x++) screen[y][x] = ' '; } DoneDraw (r) RectPtr r; { int x, y; int height, width; height = r->y2 - r->y1; width = r->x2 - r->x1; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) putchar (screen[y][x]); putchar ('\n'); } } char picture[][DOMINO_MINOR_HEIGHT][DOMINO_MINOR_WIDTH] = { { "+-------+", "| |", "| |", "| |", "+-------+", }, { "+-------+", "| |", "| * |", "| |", "+-------+", }, { "+-------+", "| * |", "| |", "| * |", "+-------+", }, { "+-------+", "| * |", "| * |", "| * |", "+-------+", }, { "+-------+", "| * * |", "| |", "| * * |", "+-------+", }, { "+-------+", "| * * |", "| * |", "| * * |", "+-------+", }, { "+-------+", "| * * |", "| * * |", "| * * |", "+-------+", }, { "+-------+", "| * * |", "| * * * |", "| * * |", "+-------+", }, { "+-------+", "| * * * |", "| * * |", "| * * * |", "+-------+", }, { "+-------+", "| * * * |", "| * * * |", "| * * * |", "+-------+", }, }; DrawEnd(pips, x, y) Pips pips; int x, y; { int row; for (row = 0; row < DOMINO_MINOR_HEIGHT; row++) bcopy (&picture[pips][row][0], &screen[y + row][x], DOMINO_MINOR_WIDTH); } kgames-2.2/kdominos/computer.c000066400000000000000000000035241416764561500164740ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" int PlayLevel = 10; int MakeFirstPlay (DominoPtr source, DominoPtr target, Direction dir, Direction orientation, pointer data) { PlayPtr play = (PlayPtr) data; play->source = source; play->target = target; play->dir = dir; play->orientation = orientation; return FALSE; } int FindPlay (DominoPtr *player, PlayPtr play) { DominoPtr source; int ret = FALSE; play->player = player; for (source = *player; source; source = source->peer[LinkPeer]) { if (!FindPlays (board, source, MakeFirstPlay, (pointer) play)) { ret = TRUE; break; } } return ret; } kgames-2.2/kdominos/connect.c000066400000000000000000000023071416764561500162650ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" kgames-2.2/kdominos/domino.c000066400000000000000000000713611416764561500161270ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include "Dominos.h" # include # include # include # include # include # include # include # include # include # include # include # include # include "domino.h" # include "Dominos-res.h" # include # include "dominos-svg.h" # include "kgames.h" Widget toplevel; Widget frame; Widget scroll_h; Widget corner; Widget scroll_v; Widget porthole; Widget board_w; Widget player_porthole; Widget player_scrollbar; Widget player_w; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget computerCount; Widget draw; Widget zoom_in; Widget zoom_out; Widget score_w[MAX_PLAYERS]; Widget drag; int total_score[MAX_PLAYERS]; int last_score[MAX_PLAYERS]; char *player_names[MAX_PLAYERS] = { "You", "I" }; int game_over; static void ComputerMove (void); static void MakeLastPlayerVisible (void); static void GameOver (void); static void UndoGameOver (void); static int YesOrNo (Widget original, char *prompt); static int MakeFirstMove (void); typedef struct _dominosResources { int animationSpeed; String saveFile; } DominosResources, *DominosResourcesPtr; DominosResources dominosResources; static int Count (DominoPtr domino) { int c = 0; for (; domino; domino = domino->peer[LinkPeer]) c++; return c; } #define DISPLAY_BOARD 1 #define DISPLAY_PLAYER 2 #define DISPLAY_COMPUTER 4 static void DisplayDominos (int changes) { int count; if (changes & DISPLAY_PLAYER) DominosSetDominos (player_w, &player[0]); if (changes & DISPLAY_COMPUTER) { count = Count (player[1]); Message (computerCount, "I have %d domino%s.", count, count != 1 ? "s" : ""); } if (changes & DISPLAY_BOARD) DominosSetDominos (board_w, &board); } static void MakeMove (DominoPtr *player, DominoPtr source, DominoPtr target, Direction dir, Direction orientation) { if (game_over) return; PlayerMove (player, source, target, dir, orientation); if (!*player) GameOver (); } static int MakeDraw (DominoPtr *player) { if (game_over) return FALSE; if (!PlayerDraw (player, TRUE)) { GameOver (); return FALSE; } return TRUE; } static int PlayEdgeFunc (DominoPtr source, DominoPtr target, Direction dir, Direction orientation, pointer data) { PlayPtr play = (PlayPtr) data; if (target == play->target && source == play->source && (play->dist == 0 || play->dir == dir)) { MakeMove (play->player, source, target, dir, orientation); return FALSE; } return TRUE; } static Bool Play (DominoPtr *player, DominoPtr domino, DominoPtr target, Direction dir, int dist) { PlayRec play; if (!board) { PlayerFirstMove (player, domino); DisplayDominos (DISPLAY_PLAYER|DISPLAY_BOARD); if (!game_over) ComputerMove (); return TRUE; } else { play.player = player; play.source = domino; play.target = target; play.dist = dist; play.dir = dir; if (!FindPlays (board, domino, PlayEdgeFunc, (pointer) &play)) { DisplayDominos (DISPLAY_PLAYER|DISPLAY_BOARD); if (!game_over) ComputerMove (); return TRUE; } } return FALSE; } static void ComputerMove (void) { PlayRec play; if (game_over) return; MessageStart (); for (;;) { if (FindPlay (&player[1], &play)) { MessageAppend ("I play %dx%d.", play.source->pips[0], play.source->pips[1]); MessageEnd (message); MakeMove (&player[1], play.source, play.target, play.dir, play.orientation); DisplayDominos (DISPLAY_COMPUTER|DISPLAY_BOARD); break; } MessageAppend ("I draw. "); if (!PlayerDraw (&player[1], TRUE)) { MessageEnd (message); DisplayDominos (DISPLAY_COMPUTER); GameOver (); break; } } } static void DisplayScores (void) { int i; for (i = 0; i < NumPlayers; i++) { Message (score_w[i], "%s have %d point%s.", player_names[i], total_score[i], total_score[i] == 1 ? "" : "s"); } } static void Score (void) { int scores[MAX_PLAYERS]; int i; int best, best_i; DominoPtr domino; int score; best = 1000; best_i = -1; for (i = 0; i < NumPlayers; i++) { scores[i] = 0; for (domino = player[i]; domino; domino = domino->peer[LinkPeer]) scores[i] += domino->pips[0] + domino->pips[1]; if (scores[i] < best || (scores[i] == 0 && player[i] == NULL)) { best = scores[i]; best_i = i; } } score = 0; for (i = 0; i < NumPlayers; i++) { if (i != best_i) score += scores[i]; last_score[i] = 0; } score -= scores[best_i]; Message (message, "%s win, score %d", player_names[best_i], score); total_score[best_i] += score; last_score[best_i] = score; DisplayScores (); } static void Draw (void) { MakeDraw (&player[0]); DisplayDominos (DISPLAY_PLAYER); MakeLastPlayerVisible (); } static void Hint (void) { PlayRec play; if (game_over) { Message (message, "Game over."); } else if (FindPlay (&player[0], &play)) { Message (message, "Play %dx%d on %dx%d.", play.source->pips[0], play.source->pips[1], play.target->pips[0], play.target->pips[1]); } else { Message (message, "Draw."); } } static void GameOver (void) { game_over = TRUE; Score (); } static void UndoGameOver (void) { int i; if (!game_over) return; game_over = FALSE; for (i = 0; i < NumPlayers; i++) total_score[i] -= last_score[i]; DisplayScores (); } static void NewGame (void) { if (!game_over) { if (!YesOrNo (toplevel, "Abandon game in progress?")) return; } do { ResetGame (); DisplayDominos (DISPLAY_COMPUTER|DISPLAY_PLAYER|DISPLAY_BOARD); } while (!MakeFirstMove ()); game_over = FALSE; } static void Save (void) { FILE *f; int i; f = fopen (dominosResources.saveFile, "w"); if (!f) return; WriteDominos (f, pile); for (i = 0; i < NumPlayers; i++) { WriteDominos (f, player[i]); } WriteDominos (f, board); WriteScores (f, total_score, NumPlayers); WriteInt (f, game_over); fclose (f); } static int Restore (void) { FILE *f; int i; DominoPtr new_pile; DominoPtr new_player[MAX_PLAYERS]; DominoPtr new_board; int new_score[MAX_PLAYERS]; int new_game_over; f = fopen (dominosResources.saveFile, "r"); if (!f) return FALSE; new_pile = ReadDominos (f); if (DominoErrno) { fclose (f); return FALSE; } for (i = 0; i < NumPlayers; i++) { new_player[i] = ReadDominos (f); if (DominoErrno) { fclose (f); return FALSE; } } new_board = ReadDominos (f); if (DominoErrno) { fclose (f); return FALSE; } ReadScores (f, new_score, NumPlayers); if (DominoErrno) { fclose (f); return FALSE; } ReadInt (f, &new_game_over); if (DominoErrno) new_game_over = FALSE; fclose (f); DisposeGame (); pile = new_pile; for (i = 0; i < NumPlayers; i++) { player[i] = new_player[i]; total_score[i] = new_score[i]; } board = new_board; game_over = new_game_over; DisplayScores (); if (game_over) NewGame (); else DisplayDominos (DISPLAY_COMPUTER|DISPLAY_PLAYER|DISPLAY_BOARD); return TRUE; } static void GetSize (Widget widget, Dimension *w, Dimension *h) { Arg args[2]; XtSetArg (args[0], XtNwidth, w); XtSetArg (args[1], XtNheight, h); XtGetValues (widget, args, 2); } static void Center (Widget original, Widget new) { Arg args[2]; Dimension center_width, center_height; Dimension prompt_width, prompt_height; Position source_x, source_y, dest_x, dest_y; /* * place the widget in the center of the "parent" */ GetSize (new, &prompt_width, &prompt_height); GetSize (original, ¢er_width, ¢er_height); source_x = (int)(center_width - prompt_width) / 2; source_y = (int)(center_height - prompt_height) / 3; XtTranslateCoords (original, source_x, source_y, &dest_x, &dest_y); XtSetArg (args[0], XtNx, dest_x); XtSetArg (args[1], XtNy, dest_y); XtSetValues (new, args, 2); } static int yn_done, yn_answer; static void YesFunc (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; yn_answer = 1; yn_done = 1; } static void NoFunc (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; yn_answer = 0; yn_done = 1; } static int YesOrNo (Widget original, char *prompt) { Arg args[3]; XEvent event; Widget shell, dialog, label; XtSetArg (args[0], XtNmappedWhenManaged, FALSE); shell = XtCreateApplicationShell ("yesOrNo", transientShellWidgetClass, args, ONE); dialog = XtCreateManagedWidget ("yesOrNoDialog", layoutWidgetClass, shell, NULL, ZERO); label = XtCreateManagedWidget ("yesOrNoLabel", klabelWidgetClass, dialog, NULL, ZERO); XkwDialogAddButton (dialog, "yesOrNoOk", YesFunc, NULL); XkwDialogAddButton (dialog, "yesOrNoNo", NoFunc, NULL); XtSetArg (args[0], XtNlabel, prompt); XtSetValues (label, args, 1); XtRealizeWidget (shell); if (XtIsRealized (original)) { Center (original, shell); XtSetKeyboardFocus (original, dialog); } else { Dimension prompt_width, prompt_height; Position x, y; GetSize (shell, &prompt_width, &prompt_height); x = (XtScreen (shell)->width - (int) prompt_width) / 2; y = (XtScreen (shell)->height - (int) prompt_height) / 3; XtSetArg (args[0], XtNx, x); XtSetArg (args[1], XtNy, y); XtSetValues (shell, args, 2); } XtMapWidget (shell); yn_done = 0; while (!yn_done) { XtNextEvent (&event); XtDispatchEvent (&event); } XtSetKeyboardFocus (original, (Widget) None); XtDestroyWidget (shell); return yn_answer; } void FileError (char *s) { char label[1024]; sprintf (label, "%s: %s", dominosResources.saveFile, s); YesOrNo (toplevel, label); } static void Quit (void) { if (YesOrNo (toplevel, "Save game?")) Save (); exit (0); } static void Undo (void) { DominoPtr *p; if (!undoList) { Message (message, "Nothing to undo."); return; } if (game_over) UndoGameOver (); Message (message, "Undo."); do { p = undoList->player; PlayerUndo (); } while (undoList && p != &player[0]); if (!undoList) MakeFirstMove (); DisplayDominos (DISPLAY_COMPUTER|DISPLAY_PLAYER|DISPLAY_BOARD); } static int MakeFirstMove (void) { DominoPtr max_domino; DominoPtr domino; DominoPtr *max_player; int i; max_domino = 0; max_player = 0; for (i = 0; i < NumPlayers; i++) { for (domino = player[i]; domino; domino = domino->peer[LinkPeer]) { if (IsDouble (domino)) { if (!max_domino || domino->pips[0] > max_domino->pips[0]) { max_domino = domino; max_player = &player[i]; } } } } if (max_domino) { game_over = FALSE; PlayerFirstMove (max_player, max_domino); i = DISPLAY_BOARD; if (max_player != &player[1]) i |= DISPLAY_PLAYER; else i |= DISPLAY_COMPUTER; DisplayDominos (i); if (max_player != &player[1]) ComputerMove (); DisposeUndoList (); return TRUE; } return FALSE; } static void SetScrollbar(Widget w, Position p, Dimension child, Dimension parent) { double pos = -(double) p / ((double) child - (double) parent); XkwScrollbarSetThumb(w, pos, (double) parent / (double) child); } static void UpdateScrollbars(Widget child, Position x, Position y, Dimension child_width, Dimension child_height, Dimension parent_width, Dimension parent_height) { if (child == player_w) { SetScrollbar(player_scrollbar, x, child_width, parent_width); } if (child == board_w) { SetScrollbar(scroll_h, x, child_width, parent_width); SetScrollbar(scroll_v, y, child_height, parent_height); } } /* Called when scrollbar is moved */ static void ScrollbarCallback (Widget w, XtPointer closure, XtPointer data) { Widget child = (Widget) closure; double pos = *((double *) data); Arg args[4]; Position child_x, child_y; Dimension child_width, child_height; Dimension parent_width, parent_height; XtOrientation orientation; /* child geometry */ XtSetArg(args[0], XtNx, &child_x); XtSetArg(args[1], XtNy, &child_y); XtSetArg(args[2], XtNwidth, &child_width); XtSetArg(args[3], XtNheight, &child_height); XtGetValues(child, args, 4); /* parent geometry */ XtSetArg(args[0], XtNwidth, &parent_width); XtSetArg(args[1], XtNheight, &parent_height); XtGetValues(XtParent(child), args, 2); /* scrollbar direction */ XtSetArg(args[0], XtNorientation, &orientation); XtGetValues(w, args, 1); Dimension parent_length, child_length; Position child_position, new_child_position; if (orientation == XtorientVertical) { parent_length = parent_height; child_position = child_y; child_length = child_height; } else { parent_length = parent_width; child_position = child_x; child_length = child_width; } if (pos == XkwScrollbarPageDown) new_child_position = child_position - parent_length * 0.75; else if (pos == XkwScrollbarPageUp) new_child_position = child_position + parent_length * 0.75; else new_child_position = ((double) parent_length - (double) child_length) * pos; if (new_child_position < (Position) (parent_length - child_length)) new_child_position = (Position) (parent_length - child_length); if (new_child_position > 0) new_child_position = 0; if (new_child_position != child_position) { if (orientation == XtorientVertical) child_y = new_child_position; else child_x = new_child_position; Arg args[2]; XtSetArg(args[0], XtNx, child_x); XtSetArg(args[1], XtNy, child_y); XtSetValues(child, args, 2); UpdateScrollbars(child, child_x, child_y, child_width, child_height, parent_width, parent_height); } } /* Called when porthole has moved */ static void PortholeCallback(Widget w, XtPointer closure, XtPointer data) { Widget child = (Widget) data; Arg args[4]; Position child_x, child_y; Dimension child_width, child_height; Dimension parent_width, parent_height; (void) w; (void) closure; /* child geometry */ XtSetArg(args[0], XtNx, &child_x); XtSetArg(args[1], XtNy, &child_y); XtSetArg(args[2], XtNwidth, &child_width); XtSetArg(args[3], XtNheight, &child_height); XtGetValues(child, args, 4); /* parent geometry */ XtSetArg(args[0], XtNwidth, &parent_width); XtSetArg(args[1], XtNheight, &parent_height); XtGetValues(XtParent(child), args, 2); UpdateScrollbars(child, child_x, child_y, child_width, child_height, parent_width, parent_height); } static void MakeLastPlayerVisible (void) { Arg args[10]; Cardinal n; Dimension player_width, porthole_width; Position x; n = 0; XtSetArg (args[n], XtNwidth, &player_width); n++; XtGetValues (player_w, args, n); n = 0; XtSetArg (args[n], XtNwidth, &porthole_width); n++; XtGetValues (player_porthole, args, n); x = porthole_width - player_width; if (x < 0) { n = 0; XtSetArg (args[n], XtNx, x); n++; XtSetValues (player_w, args, n); } } static void Zoom(double ratio) { Arg args[1]; Dimension size; XtSetArg(args[0], XtNsize, &size); XtGetValues(board_w, args, 1); size = (Dimension) (size * ratio + 0.5); XtSetArg(args[0], XtNsize, size); XtSetValues(board_w, args, 1); MakeLastPlayerVisible(); } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void DrawCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Draw (); } static void ZoomInCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Zoom (1.25); } static void ZoomOutCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Zoom (0.8); } static void HintCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Hint (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static int selected_player; static DominoPtr selected_domino; static DominoPtr drag_domino_ptr; static DominoRec drag_domino; static void TranslateCoords(Widget from, Widget to, Position *x, Position *y) { Position to_x, to_y; Position from_x, from_y; XtTranslateCoords(to, 0, 0, &to_x, &to_y); XtTranslateCoords(from, 0, 0, &from_x, &from_y); *x += from_x - to_x; *y += from_y - to_y; } static void Drag (Widget child, XEvent *event) { Dimension width, height; Arg arg[2]; XtSetArg(arg[0], XtNwidth, &width); XtSetArg(arg[1], XtNheight, &height); XtGetValues(drag, arg, 2); Position x = event->xmotion.x - width / 2; Position y = event->xmotion.y - height / 2; TranslateCoords(child, frame, &x, &y); XtWidgetGeometry request = { .x = x, .y = y, .stack_mode = Above, .request_mode = CWX | CWY | CWStackMode }; XtMakeGeometryRequest(drag, &request, NULL); } static void StartDrag (Widget child, XEvent *event) { drag_domino.pips[0] = selected_domino->pips[0]; drag_domino.pips[1] = selected_domino->pips[1]; drag_domino_ptr = &drag_domino; DominosSetDominos(drag, &drag_domino_ptr); Drag(child, event); XtMapWidget(drag); } static void StopDrag (void) { XtUnmapWidget(drag); } static void PlayerCallback (Widget w, XtPointer closure, XtPointer data) { DominosInputPtr input = (DominosInputPtr) data; (void) w; (void) closure; switch (input->action) { case DominosActionStart: if (input->domino && input->distance == 0) { selected_player = (intptr_t) closure; selected_domino = input->domino; selected_domino->hide = True; DisplayDominos(DISPLAY_PLAYER); StartDrag(w, &input->event); } break; case DominosActionDrag: Drag(w, &input->event); break; default: StopDrag(); if (selected_domino) { selected_domino->hide = False; DisplayDominos(DISPLAY_PLAYER); selected_domino = NULL; } break; } } static void BoardCallback (Widget w, XtPointer closure, XtPointer data) { DominosInputPtr input = (DominosInputPtr) data; (void) w; (void) closure; switch (input->action) { case DominosActionStop: StopDrag(); if (selected_domino) { selected_domino->hide = False; if (!Play (&player[selected_player], selected_domino, input->domino, input->direction, input->distance)) DisplayDominos(DISPLAY_PLAYER); selected_domino = NULL; } break; default: StopDrag(); if (selected_domino) { selected_domino->hide = False; DisplayDominos(DISPLAY_PLAYER); selected_domino = NULL; } break; } } static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void HintAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Hint (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void DrawAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Draw (); } static void ZoomInAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Zoom (1.25); } static void ZoomOutAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Zoom (0.8); } static void YesAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; yn_answer = 1; yn_done = 1; } static void NoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; yn_answer = 0; yn_done = 0; } XtActionsRec actions[] = { { "dominosUndo", UndoAction, }, { "dominosNewGame", NewGameAction, }, { "dominosQuit", QuitAction, }, { "dominosHint", HintAction, }, { "dominosRestore", RestoreAction, }, { "dominosSave", SaveAction, }, { "dominosDraw", DrawAction, }, { "dominosYes", YesAction, }, { "dominosNo", NoAction, }, { "dominosZoomIn", ZoomInAction }, { "dominosZoomOut", ZoomOutAction }, }; struct menuEntry { char *name; void (*function)(Widget, XtPointer, XtPointer); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(DominosResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, { "saveFile", "SaveFile", XtRString, sizeof (String), offset(saveFile), XtRString, NULL}, }; XrmOptionDescRec options[] = { { "-size", "*Dominos.size", XrmoptionSepArg, NULL, }, }; static void makeDefaultSaveFile (void) { if (!dominosResources.saveFile || !*dominosResources.saveFile) { char path[1024]; sprintf (path, "%s/%s", getenv ("HOME"), ".dominos"); dominosResources.saveFile = malloc (strlen (path) + 1); strcpy (dominosResources.saveFile, path); } } int main (int argc, char **argv) { Atom wm_delete_window; int i; int restored; Arg arg[1]; toplevel = XkwInitialize("Dominos", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&dominosResources, resources, XtNumber (resources), NULL, 0); makeDefaultSaveFile (); AnimateSetSpeed (dominosResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: dominosQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, HintCallback, NULL); draw = XtCreateManagedWidget ("draw", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(draw, XtNcallback, DrawCallback, NULL); zoom_in = XtCreateManagedWidget ("zoom_in", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(zoom_in, XtNcallback, ZoomInCallback, NULL); zoom_out = XtCreateManagedWidget ("zoom_out", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(zoom_out, XtNcallback, ZoomOutCallback, NULL); for (i = 0; i < NumPlayers; i++) { char foo[32]; sprintf (foo, "score%d", i); score_w[i] = XtCreateManagedWidget(foo, klabelWidgetClass, menuBar, NULL, ZERO); } porthole = XtCreateManagedWidget("porthole", kportholeWidgetClass, frame, NULL, ZERO); scroll_h = XtCreateManagedWidget("scroll_h", kscrollbarWidgetClass, frame, NULL, ZERO); corner = XtCreateManagedWidget("corner", ksimpleWidgetClass, frame, NULL, ZERO); scroll_v = XtCreateManagedWidget("scroll_v", kscrollbarWidgetClass, frame, NULL, ZERO); board_w = XtCreateManagedWidget ("board", dominosWidgetClass, porthole, NULL, 0); XtAddCallback(board_w, XtNinputCallback, BoardCallback, NULL); XtAddCallback (porthole, XtNcallback, PortholeCallback, NULL); XtAddCallback(scroll_h, XtNcallback, ScrollbarCallback, (XtPointer) board_w); XtAddCallback(scroll_v, XtNcallback, ScrollbarCallback, (XtPointer) board_w); player_porthole = XtCreateManagedWidget("player_porthole", kportholeWidgetClass, frame, NULL, ZERO); player_scrollbar = XtCreateManagedWidget("player_scrollbar", kscrollbarWidgetClass, frame, NULL, ZERO); player_w = XtCreateManagedWidget ("player", dominosWidgetClass, player_porthole, NULL, 0); XtAddCallback (player_porthole, XtNcallback, PortholeCallback, NULL); XtAddCallback (player_scrollbar, XtNcallback, ScrollbarCallback, (XtPointer) player_w); XtAddCallback(player_w, XtNinputCallback, PlayerCallback, NULL); XtSetArg(arg[0], XtNwantForward, FALSE); drag = XtCreateManagedWidget("drag", dominosWidgetClass, frame, arg, 1); XtSetMappedWhenManaged(drag, False); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); computerCount = XtCreateManagedWidget ("computerCount", klabelWidgetClass, frame, NULL, ZERO); srandom (getpid () ^ time ((long *) 0)); restored = Restore(); MessageStart(); MessageAppend("Keith's Dominos, Version " KGAMES_VERSION_STRING); if (restored) MessageAppend(" (Resuming existing game)"); MessageEnd(message); if (!restored) { game_over = True; NewGame (); DisplayScores (); } XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetIcon(toplevel, svg_dominos); XtMainLoop (); return 0; } kgames-2.2/kdominos/domino.h000066400000000000000000000101041416764561500161200ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #ifndef _DOMINOS_H_ #define _DOMINOS_H_ #include #include #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif typedef unsigned char Pips; typedef struct _domino *DominoPtr; typedef enum _Direction { North = 0, East = 1, South = 2, West = 3 } Direction; typedef int Player; typedef struct _domino { Pips pips[2]; Direction orientation; Bool hide; DominoPtr peer[4]; } DominoRec; #define LinkPeer East #include #define New(type) (type *) malloc (sizeof (type)) #define Dispose(p) free ((char *) (p)) #define Some(type,n) (type *) malloc ((n) * sizeof (type)) #define More(type,p,n) ((type *) ((p) ? realloc (p, (n) * sizeof (type)) : Some(type,n))) #define MAX_DOMINO_PIP 9 #define PLAYER_START 7 #define MAX_PLAYERS 16 extern int NumPlayers; extern DominoPtr pile, player[], board; typedef struct _Rect { int x1, y1, x2, y2; } RectRec, *RectPtr; typedef struct _Play { DominoPtr *player; DominoPtr source, target; int dist; Direction dir; Direction orientation; } PlayRec, *PlayPtr; typedef struct _Undo *UndoPtr; typedef struct _Undo { UndoPtr next; DominoPtr *player; DominoPtr *dest; DominoPtr *source; DominoPtr domino; Direction orientation; } UndoRec; extern UndoPtr undoList; DominoPtr MakeDomino(Pips a, Pips b); DominoPtr InitDominos (Pips max); DominoPtr MixDominos (DominoPtr dominos); DominoPtr PickDomino (DominoPtr *dominos); void DisposeDominos (DominoPtr domino); DominoPtr ReadDominos (FILE *file); void WriteDominos (FILE *file, DominoPtr d); void WriteScores (FILE *file, int *scores, int num); int ReadScores (FILE *file, int *scores, int num); void WriteInt (FILE *file, int i); int ReadInt (FILE *file, int *i); void FileError (char *s); extern int DominoErrno; int TraverseDominos (DominoPtr d, int (*func)(DominoPtr, pointer), pointer data); int FindPlays (DominoPtr board, DominoPtr domino, int (*func)(DominoPtr, DominoPtr, Direction, Direction, pointer), pointer data); void DisposeGame (void); void ResetGame (void); int PlayerDraw(DominoPtr *p, int remember); DominoPtr * PlayerExtract (DominoPtr *p, DominoPtr source); int PlayerMove (DominoPtr *p, DominoPtr source, DominoPtr target, Direction dir, Direction orientation); void PlayerFirstMove (DominoPtr *p, DominoPtr source); int PlayerUndo (void); void DisposeUndoList (void); int IsDouble(DominoPtr d); Direction OtherDir (Direction dir); int CanUseEdge (DominoPtr d, Direction dir, Direction orientation); Pips EdgePips (DominoPtr d, Direction dir, Direction orientation); int CanPlay (DominoPtr source, DominoPtr target, Direction dir, Direction orientation); int MakeFirstPlay (DominoPtr source, DominoPtr target, Direction dir, Direction orientation, pointer data); int FindPlay (DominoPtr *player, PlayPtr play); #endif /* _DOMINOS_H_ */ kgames-2.2/kdominos/file.c000066400000000000000000000114231416764561500155520ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include "domino.h" static void WriteIndent (FILE *file, int level) { while (level--) putc (' ', file); } static void WriteDomino (FILE *file, DominoPtr d, int level) { Direction dir; WriteIndent (file, level); fprintf (file, "("); if (d) { fprintf (file, "%d %d %d", d->pips[0], d->pips[1], d->orientation); fprintf (file, "\n"); for (dir = North; dir <= West; dir++) WriteDomino (file, d->peer[dir], level + 1); WriteIndent (file, level); } fprintf (file, ")\n"); } void WriteDominos (FILE *file, DominoPtr d) { WriteDomino (file, d, 0); } #define TOKEN_EOF -1 #define TOKEN_OP 0 #define TOKEN_CP 1 #define TOKEN_NUMBER 2 #define STATE_BEGIN 0 #define STATE_DIGIT 1 #define MAX_TOKEN 256 static char DominoToken[MAX_TOKEN]; int DominoErrno; static void syntax (void) { if (!DominoErrno) FileError ("Syntax error in file"); DominoErrno = 1; } static int LexDomino (FILE *file) { int c; int state = STATE_BEGIN; char *tokenp = DominoToken; for (;;) { c = getc (file); switch (state) { case STATE_BEGIN: switch (c) { case EOF: return TOKEN_EOF; case '(': return TOKEN_OP; case ')': return TOKEN_CP; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': state = STATE_DIGIT; *tokenp++ = c; break; case ' ': case '\t': case '\n': break; default: syntax (); return TOKEN_EOF; } break; case STATE_DIGIT: switch (c) { case '(': case ')': case ' ': case '\t': case '\n': ungetc (c, file); /* fall through */ case EOF: *tokenp = '\0'; return TOKEN_NUMBER; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (tokenp >= DominoToken + sizeof DominoToken - 1) { syntax (); return TOKEN_EOF; } *tokenp++ = c; break; default: syntax (); return TOKEN_EOF; } } } } static DominoPtr ReadDomino (FILE *file) { DominoPtr d = 0; Direction dir; Pips pips[2]; int i; switch (LexDomino (file)) { case TOKEN_OP: break; default: syntax (); return 0; } for (i = 0; i < 2; i++) { switch (LexDomino (file)) { case TOKEN_NUMBER: pips[i] = atoi(DominoToken); break; case TOKEN_CP: if (i == 0) return 0; /* fall through */ default: syntax (); return 0; } } d = MakeDomino (pips[0], pips[1]); switch (LexDomino (file)) { case TOKEN_NUMBER: d->orientation = atoi (DominoToken); break; default: syntax (); DisposeDominos (d); return 0; } for (dir = North; dir <= West; dir++) d->peer[dir] = ReadDomino (file); switch (LexDomino (file)) { case TOKEN_CP: return d; default: syntax (); DisposeDominos (d); return 0; } } DominoPtr ReadDominos (FILE *file) { DominoErrno = 0; return ReadDomino (file); } void WriteScores (FILE *file, int *scores, int num) { int i; for (i = 0; i < num; i++) fprintf (file, "%d ", scores[i]); fprintf (file, "\n"); } int ReadScores (FILE *file, int *scores, int num) { int i; for (i = 0; i < num; i++) { switch (LexDomino (file)) { case TOKEN_NUMBER: scores[i] = atoi(DominoToken); break; default: syntax (); return 0; } } return num; } void WriteInt (FILE *file, int i) { fprintf (file, "%d\n", i); } int ReadInt (FILE *file, int *i) { switch (LexDomino (file)) { case TOKEN_NUMBER: *i = atoi (DominoToken); return TRUE; default: syntax (); return FALSE; } } kgames-2.2/kdominos/find.c000066400000000000000000000051721416764561500155570ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" typedef struct _findRec { DominoPtr domino; int (*func)(DominoPtr, DominoPtr, Direction, Direction, pointer); pointer data; } FindRec, *FindPtr; static int ForEachEdge (DominoPtr d, Direction dir, FindPtr f) { Direction orientation; for (orientation = North; orientation <= West; orientation++) if (CanPlay (f->domino, d, dir, orientation)) if (!(*f->func) (f->domino, d, dir, orientation, f->data)) return FALSE; return TRUE; } static int FindEdge (DominoPtr d, Direction search_dir, FindPtr f) { Direction dir; if (IsDouble (d)) { for (dir = North; dir <= West; dir++) if (dir != OtherDir(search_dir)) { if (d->peer[dir]) { if (!FindEdge (d->peer[dir], dir, f)) return FALSE; } else { if (!ForEachEdge (d, dir, f)) return FALSE; } } return TRUE; } else { if (d->peer[search_dir]) return FindEdge (d->peer[search_dir], search_dir, f); return ForEachEdge (d, search_dir, f); } } int FindPlays (DominoPtr board, DominoPtr domino, int (*func)(DominoPtr, DominoPtr, Direction, Direction, pointer), pointer data) { FindRec f; Direction dir; f.domino = domino; f.func = func; f.data = data; for (dir = North; dir <= West; dir++) if (IsDouble (board) || dir == board->orientation || dir == OtherDir(board->orientation)) { if (!FindEdge (board, dir, &f)) return FALSE; } return TRUE; } kgames-2.2/kdominos/game.c000066400000000000000000000121611416764561500155440ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" int NumPlayers = 2; DominoPtr pile; DominoPtr player[MAX_PLAYERS]; DominoPtr board; UndoPtr undoList; void DisposeGame (void) { Player p; if (pile) { DisposeDominos(pile); pile = 0; } for (p = 0; p < NumPlayers; p++) if(player[p]) { DisposeDominos(player[p]); player[p] = 0; } if (board) { DisposeDominos(board); board = 0; } if (undoList) DisposeUndoList (); } void ResetGame (void) { Player p; int i; DisposeGame (); pile = InitDominos(MAX_DOMINO_PIP); pile = MixDominos(pile); for (p = 0; p < NumPlayers; p++) for (i = 0; i < PLAYER_START; i++) PlayerDraw (&player[p], FALSE); } int PlayerDraw(DominoPtr *p, int remember) { DominoPtr d; DominoPtr *prev; UndoPtr undo; d = PickDomino(&pile); if (!d) return FALSE; for (prev = p; *prev; prev = &(*prev)->peer[LinkPeer]) /*SUPPRESS 530*/ ; if (remember) { undo = New(UndoRec); if (!undo) return FALSE; undo->player = p; undo->next = undoList; undoList = undo; undo->dest = prev; undo->source = &pile; undo->domino = d; undo->orientation = d->orientation; } *prev = d; return TRUE; } DominoPtr * PlayerExtract (DominoPtr *p, DominoPtr source) { while (*p != source) p = &(*p)->peer[LinkPeer]; *p = source->peer[LinkPeer]; source->peer[LinkPeer] = 0; return p; } int PlayerMove (DominoPtr *p, DominoPtr source, DominoPtr target, Direction dir, Direction orientation) { UndoPtr undo; undo = New(UndoRec); if (!undo) return FALSE; undo->next = undoList; undoList = undo; undo->player = p; undo->dest = &target->peer[dir]; undo->domino = source; undo->orientation = source->orientation; undo->source = PlayerExtract (p, source); target->peer[dir] = source; if (IsDouble (source)) { orientation = target->orientation + 1; if (orientation > West) orientation = North; } source->orientation = orientation; return TRUE; } void PlayerFirstMove (DominoPtr *p, DominoPtr source) { UndoPtr undo; undo = New (UndoRec); if (!undo) return; undo->next = undoList; undoList = undo; undo->player = p; undo->dest = &board; undo->source = PlayerExtract (p, source); undo->domino = source; undo->orientation = source->orientation; board = source; source->orientation = East; } int PlayerUndo (void) { UndoPtr undo; undo = undoList; if (!undo) return FALSE; undoList = undo->next; *undo->dest = 0; undo->domino->peer[LinkPeer] = *undo->source; *undo->source = undo->domino; undo->domino->orientation = undo->orientation; Dispose (undo); return TRUE; } void DisposeUndoList (void) { UndoPtr undo; while (undoList) { undo = undoList; undoList = undo->next; Dispose (undo); } } int IsDouble(DominoPtr d) { return d->pips[0] == d->pips[1]; } Direction OtherDir (Direction dir) { switch (dir) { case North: return South; case South: return North; case East: return West; default: case West: return East; } } int CanUseEdge (DominoPtr d, Direction dir, Direction orientation) { if (IsDouble (d)) return TRUE; if (dir == orientation || dir == OtherDir(orientation)) return TRUE; return FALSE; } Pips EdgePips (DominoPtr d, Direction dir, Direction orientation) { if (IsDouble (d)) return d->pips[0]; if (dir == orientation) return d->pips[0]; if (dir == OtherDir(orientation)) return d->pips[1]; return (Pips) -1; } int CanPlay (DominoPtr source, DominoPtr target, Direction dir, Direction orientation) { if (target->peer[dir]) return FALSE; if (!CanUseEdge (target, dir, target->orientation)) return FALSE; if (!CanUseEdge (source, OtherDir(dir), orientation)) return FALSE; if (EdgePips (source, OtherDir(dir), orientation) != EdgePips (target, dir, target->orientation)) return FALSE; return TRUE; } kgames-2.2/kdominos/kdominos-icon.5c000077500000000000000000000057701416764561500175040ustar00rootroot00000000000000#!/usr/bin/env nickle autoimport Cairo; real size = 60; real inset = size / 20; real radius = size / 10; real line_width = size / 25; real pip_size = size / 15; real pip_off = size / 5; real minor_size = size; real major_size = size * 2; real M_PI = pi; void set_pips_color(cairo_t cr) { set_source_rgba(cr, 1, 1, 1, 1); } void set_face_color(cairo_t cr) { set_source_rgba(cr, 0, 0, 0, 1); } void draw_rounded_rect(cairo_t cr, real width, real height, real radius) { move_to(cr, radius, 0); /* top */ line_to(cr, width - radius, 0); /* top right */ arc(cr, width - radius, radius, radius, -M_PI/2, 0); /* right */ line_to(cr, width, height - radius); /* bottom right */ arc(cr, width - radius, height - radius, radius, 0, M_PI/2); /* bottom */ line_to(cr, radius, height); /* bottom left */ arc(cr, radius, height - radius, radius, M_PI/2, M_PI); /* left */ line_to(cr, 0, radius); /* top left */ arc(cr, radius, radius, radius, M_PI, M_PI * 3 / 2); } void outline_domino(cairo_t cr, real width, real height) { set_pips_color(cr); set_line_width(cr, line_width); move_to(cr, 0, height / 2); line_to(cr, width, height/2); draw_rounded_rect(cr, width, height, radius); stroke(cr); } void fill_domino(cairo_t cr) { real width = minor_size - inset * 2; real height = major_size - inset * 2; save(cr); set_face_color(cr); translate(cr, inset, inset); draw_rounded_rect(cr, width, height, radius); fill(cr); outline_domino(cr, width, height); restore(cr); } void draw_pip(cairo_t cr, real x, real y, real radius) { arc(cr, x, y, radius, 0, pi * 2); fill(cr); } void draw_pips(cairo_t cr, int p, bool flip) { real off_x, off_y; real half_x, half_y; real radius = pip_size; set_pips_color(cr); off_x = pip_off; off_y = pip_off; half_x = 0; half_y = off_y; if (flip) { half_x = off_x; half_y = 0; off_x = -off_x; } if ((p & 1) != 0) { draw_pip(cr, 0, 0, radius); p = p - 1; } switch (p) { case 8: draw_pip (cr, - half_x, - half_y, radius); draw_pip (cr, half_x, half_y, radius); /* fall through */ case 6: draw_pip (cr, - half_y, - half_x, radius); draw_pip (cr, half_y, half_x, radius); /* fall through */ case 4: draw_pip (cr, off_x, - off_y, radius); draw_pip (cr, - off_x, off_y, radius); /* fall through */ case 2: draw_pip (cr, - off_x, - off_y, radius); draw_pip (cr, off_x, off_y, radius); } } void draw_domino(cairo_t cr, int[2] pips) { real off_x, off_y; bool flip = false; fill_domino(cr); off_x = minor_size / 2; off_y = minor_size / 2; save(cr); translate(cr, off_x, off_y); draw_pips(cr, pips[0], flip); restore(cr); if (!flip) off_y = major_size / 2 + minor_size / 2; else off_x = major_size / 2 + minor_size / 2; save(cr); translate(cr, off_x, off_y); draw_pips(cr, pips[1], flip); restore(cr); } void doit() { int[2] pips = { 4, 2 }; cairo_t cr = new_svg("kdominos.svg", major_size, major_size); translate(cr, (major_size - minor_size) / 2, 0); draw_domino(cr, pips); show_page(cr); destroy(cr); } doit(); kgames-2.2/kdominos/kdominos.6000066400000000000000000000004631416764561500164030ustar00rootroot00000000000000.TH KDOMINOS 6 "1992" "Kgames 1.0" .SH NAME kdominos \- X window dominos game against the computer .SH SYNOPSIS .B kdominos .SH DESCRIPTION .I Kdominos brings up a window for a dominos game against the computer. Drag dominos into position on the board or click one of the controls. .SH AUTHOR Keith Packard kgames-2.2/kdominos/kdominos.desktop.in000066400000000000000000000003741416764561500203150ustar00rootroot00000000000000[Desktop Entry] Name=KDominos GenericName=Dominos Game Comment=Play Dominos against the computer Keywords=game;board Exec=@BINDIR@/kdominos Icon=@ICONDIR@/kdominos.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kdominos/kdominos.svg000066400000000000000000000034551416764561500170410ustar00rootroot00000000000000 kgames-2.2/kdominos/make-dominos-svg000066400000000000000000000006261416764561500175750ustar00rootroot00000000000000#!/bin/bash dir=`dirname $0` case $# in 2) ;; *) echo "usage: $0 kdominos-svg.c kdominos-svg.h" exit 1 ;; esac ( echo '#include "'"$2"'"' file="$dir"/kdominos.svg echo "const char svg_dominos[]" = sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/ "/' -e 's/$/\\n"/' "$file" echo " ;"; echo "" ) > "$1" ( echo "extern const char svg_dominos[];" ) > "$2" kgames-2.2/kdominos/meson.build000066400000000000000000000041331416764561500166310ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # srcs_dominos = [ 'computer.c', 'connect.c', 'domino.c', 'Dominos.c', 'file.c', 'find.c', 'game.c', 'util.c', ] ad_file = configure_file(input: 'Dominos.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) make_dominos_svg = find_program('make-dominos-svg') dominos_files = custom_target('svg-dominos', output : ['dominos-svg.c', 'dominos-svg.h'], command : [make_dominos_svg, '@OUTPUT0@', '@OUTPUT1@']) install_data('kdominos.svg', install_dir : svg_icon_dir) executable('kdominos', srcs_dominos, res_files, dominos_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kdominos.6') configure_file(input: 'kdominos.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kdominos/util.c000066400000000000000000000065341416764561500156170ustar00rootroot00000000000000/* * $NCDId$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ #include "domino.h" DominoPtr MakeDomino(Pips a, Pips b) { DominoPtr domino; domino = New(DominoRec); domino->hide = FALSE; domino->pips[0] = a; domino->pips[1] = b; domino->peer[North] = 0; domino->peer[East] = 0; domino->peer[South] = 0; domino->peer[West] = 0; domino->orientation = North; return domino; } DominoPtr InitDominos (Pips max) { Pips r, c; DominoPtr dominos, d, *prev; prev = &dominos; for (r = 0; r <= max; r++) for (c = r; c <= max; c++) { *prev = d = MakeDomino(r, c); prev = &d->peer[LinkPeer]; } return dominos; } typedef struct _DominoMix { int value; DominoPtr domino; } DominoMixRec, *DominoMixPtr; static int MixCompare (const void *av, const void *bv) { const DominoMixRec *a = av; const DominoMixRec *b = bv; return a->value - b->value; } DominoPtr MixDominos (DominoPtr dominos) { int numDominos; DominoPtr d; DominoMixPtr mix, m; int i; numDominos = 0; for (d = dominos; d; d = d->peer[LinkPeer]) numDominos++; m = mix = Some(DominoMixRec, numDominos); for (d = dominos; d; d = d->peer[LinkPeer]) { m->value = random (); m->domino = d; m++; } qsort ((char *) mix, numDominos, sizeof *mix, MixCompare); m = mix; dominos = m->domino; for (i = 0; i < numDominos; i++) { d = m->domino; if (i < numDominos - 1) d->peer[LinkPeer] = m[1].domino; else d->peer[LinkPeer] = 0; m++; } Dispose (mix); return dominos; } DominoPtr PickDomino (DominoPtr *dominos) { DominoPtr d; d = *dominos; if (d) { *dominos = d->peer[LinkPeer]; d->peer[LinkPeer] = 0; } return d; } void DisposeDominos (DominoPtr domino) { Direction dir; for (dir = North; dir <= West; dir++) if (domino->peer[dir]) DisposeDominos(domino->peer[dir]); Dispose (domino); } int TraverseDominos (DominoPtr d, int (*func)(DominoPtr, pointer), pointer data) { Direction dir; if (!(*func) (d, data)) return FALSE; for (dir = North; dir <= West; dir++) if (d->peer[dir]) { if (!TraverseDominos (d->peer[dir], func, data)) return FALSE; } return TRUE; } kgames-2.2/kgames.directory.in000066400000000000000000000001071416764561500164430ustar00rootroot00000000000000[Desktop Entry] Encoding=UTF-8 Icon=@ICONDIR@/kgames.svg Name=Kgames kgames-2.2/kgames.menu.in000066400000000000000000000006511416764561500154070ustar00rootroot00000000000000 Applications Games Kgames KGames kgames.directory Kgames kgames-2.2/kklondike/000077500000000000000000000000001416764561500146165ustar00rootroot00000000000000kgames-2.2/kklondike/KKlondike.ad.in000066400000000000000000000030061416764561500174030ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *deck.numCols: 2 *deck.numRows: 1 *piles.numCols: 4 *piles.numRows: 1 *Cards.immediateUpdate: False *stacks.numCols: 7 *stacks.numRows: 7 *stacks.rowsHint: True *stacks.overlap: vertical *stacks.immediate_update: false *message.justify: left *message.label: Keith's Klondike, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 5 < -5 > \ pileAll \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ horizontal {\ menuBar < +inff -100% * >\ } \ 10 < -inf > \ horizontal { \ 10 < -inf > \ deck < -75% * -90% > \ 10 < +inf -inf > \ piles < -100% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ stacks < -50% * +inf -50% > \ horizontal { \ message < +inff -100% * > \ } \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *pileAll.label: Fill Piles *Command.shapeStyle: oval *frame.translations: #override \ u: klondikeUndo()\n\ n: klondikeNewGame()\n\ s: klondikeScore()\n\ ?: klondikeFindAMove() kgames-2.2/kklondike/kklondike.6000066400000000000000000000014331416764561500166610ustar00rootroot00000000000000.TH KKLONDIKE 6 "1992" "Kgames 1.0" .SH NAME kklondike \- X window klondike solitaire .SH SYNOPSIS .B kklondike .SH DESCRIPTION .I Kklondike brings up a window for a klondike solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down in alternating colors. Full or partial builds may be moved among the tableaus. Empty tableaus may be filled with Kings or with builds beginning with Kings. The top card in the discard pile may be played on tableaus or foundations. Foundations build up in suit from the Ace. .P Deal three cards onto the discard pile by clickingn the hand. Click on the empty hand to move the discards back. .P Goal: move all cards to the foundations. .SH AUTHOR Keith Packard kgames-2.2/kklondike/kklondike.desktop.in000066400000000000000000000004061416764561500205710ustar00rootroot00000000000000[Desktop Entry] Name=KKlondike GenericName=Solitaire Game Comment=Play Klondike solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kklondike Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kklondike/klondike.c000066400000000000000000000530671416764561500165750ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KKlondike-res.h" Widget toplevel; Widget frame; Widget deck; Widget piles; Widget stacks; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; Widget pileAll; #define NUM_DECK 2 #define NUM_STACKS 7 #define NUM_PILES 4 #define NUM_CARDS 52 CardStackRec deckStacks[NUM_DECK]; CardStackRec stackStacks[NUM_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardRec rawcards[NUM_CARDS]; int dealNumber; typedef struct _klondikeResources { int animationSpeed; } KlondikeResources, *KlondikeResourcesPtr; KlondikeResources klondikeResources; static void InitStacks (void) { int col; CardDisplay display; for (col = 0; col < NUM_DECK; col++) { if (col == 0) display = CardDisplayBottom; else display = CardDisplayTop; CardInitStack (&deckStacks[col], deck, CardsEmpty, False, col, display); } for (col = 0; col < NUM_STACKS; col++) { CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, CardDisplayAll); } for (col = 0; col < NUM_PILES; col++) { CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col, CardDisplayTop); } } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); deckStacks[0].first = &rawcards[0]; deckStacks[0].last = &rawcards[NUM_CARDS-1]; } #define FIRST_ROWS NUM_STACKS static void FirstDeal (void) { int row, col; for (row = 0; row < FIRST_ROWS; row++) { for (col = row; col < NUM_STACKS; col++) CardMove (&deckStacks[0], deckStacks[0].last, &stackStacks[col], False); } for (col = 0; col < NUM_STACKS; col++) CardTurn (stackStacks[col].last, CardFaceUp, False); dealNumber = 0; } static void CheckStackTop (CardStackPtr stack) { if (stack->last && stack->last->face == CardFaceDown) CardTurn (stack->last, CardFaceUp, True); } static int ComputeScore (void) { int col; int score; CardPtr card; score = 0; for (col = 0; col < NUM_PILES; col++) { for (card = pileStacks[col].first; card; card = card->next) { if (card->card.rank < CardsJack) score += (int) card->card.rank; else score += 10; } } return score; } static void DisplayStacks (void) { int col; for (col = 0; col < NUM_DECK; col++) CardDisplayStack (&deckStacks[col]); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < NUM_STACKS; col++) CardDisplayStack (&stackStacks[col]); CardsUpdateDisplay (deck); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); } /* User interface functions */ #define DEAL_COUNT 3 static void ResetDeck (void) { CardPtr c; while ((c = deckStacks[1].last)) { CardMove (&deckStacks[1], deckStacks[1].last, &deckStacks[0], True); CardTurn (deckStacks[0].last, CardFaceDown, True); } } static void Deal (void) { int deal; for (deal = 0; deal < DEAL_COUNT; deal++) { if (!deckStacks[0].last) { Message (message, "No more cards in the deck."); return; } CardMove (&deckStacks[0], deckStacks[0].last, &deckStacks[1], True); CardTurn (deckStacks[1].last, CardFaceUp, True); } } static void NewGame (void) { CardsRemoveAllCards (deck); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); InitStacks (); GenerateCards (); CardShuffle (&deckStacks[0], False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } #define MAX_SCORE 340 static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static Boolean IsLegalPilePlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (from_card->card.rank == CardsAce) { if (to_stack->last == NULL) return True; } else { if (to_stack->last != NULL && CardIsInSuitOrder (to_stack->last, from_card)) return True; } return False; } static CardStackPtr FindPilePlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = from_stack->last; else return NULL; if (from_card->next) return NULL; for (i = 0; i < NUM_PILES; i++) { to_stack = &pileStacks[i]; if (IsLegalPilePlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalRegularPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { CardPtr to_card; (void) from_stack; to_card = to_stack->last; if (to_card && CardIsInAlternatingSuitOrder (from_card, to_card)) return True; return False; } static CardStackPtr FindRegularPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) { from_card = from_stack->last; if (from_stack->widget == stacks) from_card = CardInReverseAlternatingSuitOrder (from_card); } else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (from_stack == &stackStacks[i]) continue; to_stack = &stackStacks[i]; if (IsLegalRegularPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalEmptyPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; (void) from_card; if (to_stack->last == NULL) return True; return False; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseAlternatingSuitOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (IsLegalEmptyPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (from_card && from_card->face == CardFaceDown) { Message (message, "Card not turned up."); return; } if (from_card && CardInAlternatingSuitOrder (from_card)->next != NULL) { Message (message, "Cards not in order."); return; } if (to_stack != from_stack) { if (to_stack->widget == stacks) { if (!from_card) from_card = CardInReverseAlternatingSuitOrder (from_stack->last); if (!IsLegalRegularPlay (from_stack, from_card, to_stack) && !IsLegalEmptyPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty pile.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == piles) { if (!from_card) from_card = from_stack->last; if (!IsLegalPilePlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty stack.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else { Message (message, "Can't move cards back to the deck."); return; } } else { if (!from_card && !from_stack->last) { Message (message, "No cards there."); return; } if (!(to_stack = FindPilePlay (from_stack, &from_card)) && !(to_stack = FindRegularPlay (from_stack, &from_card)) && !(to_stack = FindEmptyPlay (from_stack, &from_card))) { Message (message, "Not a valid move."); return; } } CardMove (from_stack, from_card, to_stack, True); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static Boolean AlreadyInOrder (CardPtr a, CardPtr b) { if (a && b && CardIsInAlternatingSuitOrder (a,b)) return True; return False; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[NUM_STACKS]; to_stack = NULL; for (col = 0; col < NUM_STACKS; col++) goodenough[col] = False; #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ if (goodenough[col]) continue; \ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = CardInReverseAlternatingSuitOrder (from_stack->last); \ if (!already (from_card, from_card->prev)) \ to_stack = func(from_stack, &from_card); \ else \ goodenough[col] = True; \ } \ if (!to_stack) { \ from_stack = &deckStacks[1]; \ from_card = from_stack->last; \ if (from_card) \ to_stack = func(from_stack, &from_card);\ } #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, &from_card); \ } \ if (!to_stack) { \ from_stack = &deckStacks[1]; \ from_card = from_stack->last; \ if (from_card) \ to_stack = func(from_stack, &from_card);\ } FindOneCheck (AlreadyInOrder, FindRegularPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } FindOne (FindPilePlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } if (deckStacks[0].last) { Message (message, "Deal the next hand."); } else { Message (message, "Reset the deck."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void PileAll (void) { CardStackPtr from_stack; CardPtr from_card; CardStackPtr to_stack; int col; Boolean done = False; Message (message, ""); do { to_stack = 0; FindOne (FindPilePlay); if (to_stack) { Play (from_stack, from_card, to_stack); done = True; CheckStackTop (from_stack); CardNextHistory (); DisplayStacks (); } } while (to_stack); if (!done) Message (message, "No cards to pile."); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; if (w == piles) return &pileStacks[col]; if (w == deck) return &deckStacks[col]; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; switch (input->action) { case HandActionStart: break; case HandActionClick: CardSetAnimate(True); if (stack == &deckStacks[0]) { if (!stack->last) ResetDeck (); else Deal (); CardNextHistory (); DisplayStacks (); } else { Play (stack, NULL, stack); CheckStackTop (stack); CardNextHistory (); DisplayStacks (); } break; case HandActionDrag: CardSetAnimate(False); if (startStack == &deckStacks[0] && stack == &deckStacks[1]) { if (startStack->last) { Deal (); CardNextHistory (); DisplayStacks (); } } else if (startStack == &deckStacks[1] && stack == &deckStacks[0]) { if (!stack->last) { ResetDeck (); CardNextHistory (); DisplayStacks (); } } else if (startStack->last) { CardPtr card = CardFromHandCard(input->start.private); Play (startStack, card, stack); CheckStackTop (startStack); CardNextHistory (); DisplayStacks (); } break; case HandActionExpand: Expand (stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void PileAllCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; PileAll (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void PileAllAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; PileAll (); } XtActionsRec actions[] = { { "klondikeUndo", UndoAction, }, { "klondikeNewGame", NewGameAction, }, { "klondikeScore", ScoreAction, }, { "klondikeQuit", QuitAction, }, { "klondikeFindAMove", FindAMoveAction, }, { "klondikeRestore", RestoreAction, }, { "klondikeSave", SaveAction, }, { "klondikePileAll", PileAllAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(KlondikeResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KKlondike", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&klondikeResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (klondikeResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: klondikeQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); pileAll = XtCreateManagedWidget ("pileAll", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(pileAll, XtNcallback, PileAllCallback, NULL); deck = XtCreateManagedWidget ("deck", cardsWidgetClass, frame, NULL, 0); XtAddCallback (deck, XtNinputCallback, InputCallback, NULL); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); XtAddCallback (piles, XtNinputCallback, InputCallback, NULL); stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stacks, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/kklondike/meson.build000066400000000000000000000032741416764561500167660ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KKlondike.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kklondike', 'klondike.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kklondike.6') configure_file(input: 'kklondike.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kmcarlo/000077500000000000000000000000001416764561500142735ustar00rootroot00000000000000kgames-2.2/kmcarlo/MonteCarlo.ad.in000066400000000000000000000035421416764561500172550ustar00rootroot00000000000000*Command.shapeStyle: oval *Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *wasteLabel.Background: #337744 *wasteLabel.Foreground: #fffff0 *deckCount.Background: #337744 *deckCount.Foreground: #fffff0 *cards.numCols: 5 *cards.numRows: 5 *deck.numCols: 1 *deck.numRows: 1 *deck.borderWidth: 0 *deckCount.borderWidth: 0 *deckCount.label: 27 *waste.numCols: 1 *waste.numRows: 1 *waste.borderWidth: 0 *wasteLabel.borderWidth: 0 *wasteLabel.label: Waste *cards.overlap: none *smallCards: false *cards.immediateUpdate: False *cards.rowMajor: True *message.justify: left *message.label: Keith's Monte Carlo, Version @KGAMES_VERSION@ *cards.borderWidth: 0 *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ deal \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ cards < +100% -100% * +100% -100% > \ 10 < -inf > \ vertical { \ deck < -75% * -90% > \ deckCount < +inf -inf * > \ 10 < +inf -inf > \ wasteLabel < +inf -inf * > \ waste < -75% * -90% > \ } \ 10 < -inf > \ } \ message < +inff -100% * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *Command.shapeStyle: oval *frame.translations: #override \ u: montecarloUndo()\n\ n: montecarloNewGame()\n\ s: montecarloScore()\n\ ?: montecarloBestMove() kgames-2.2/kmcarlo/kmcarlo.6000066400000000000000000000005071416764561500160140ustar00rootroot00000000000000.TH KMCARLO 6 "1992" "Kgames 1.0" .SH NAME kmcarlo \- X window monte carlo solitaire .SH SYNOPSIS .B kmcarlo .SH DESCRIPTION .I Kmcarlo brings up a window for a monte carlo solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH AUTHOR Keith Packard kgames-2.2/kmcarlo/kmcarlo.desktop.in000066400000000000000000000004051416764561500177220ustar00rootroot00000000000000[Desktop Entry] Name=KMCarlo GenericName=Solitaire Game Comment=Play Monte Carlo solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kmcarlo Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kmcarlo/mc.c000066400000000000000000000423361416764561500150460ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Dave Lemke, Network Computing Devices */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "MonteCarlo-res.h" #include "kgames.h" Widget toplevel; Widget frame; Widget cards; Widget deck; Widget deckCount; Widget waste; Widget wasteLabel; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget deal; Widget newGame; Widget undo; Widget hint; Widget score; #define NUM_DEALS 2 #define NUM_ROWS 5 #define NUM_COLS 5 #define NUM_CARDS 52 #define MAX_SCORE 52 CardStackRec cardStacks[NUM_CARDS]; CardStackRec deckStack; CardStackRec wasteStack; /* matched cards */ CardRec rawcards[NUM_CARDS]; CardStackPtr position[NUM_CARDS]; CardStackPtr fromStack; CardPtr fromCard; int currentScore; int cardsLeft; CardStackPtr hintStack; typedef struct _montecarloResources { int animationSpeed; } MonteCarloResources, *MonteCarloResourcesPtr; MonteCarloResources montecarloResources; #define min(a,b) ((a) < (b) ? (a) : (b)) #define max(a,b) ((a) > (b) ? (a) : (b)) #define ForAllCardVars int row, col; CardStackPtr stack #define ForAllCards for (row = 0, stack = cardStacks; row < NUM_ROWS; row++) \ for (col = 0; col < NUM_COLS; col++, stack++) static void InitStacks (void) { ForAllCardVars; ForAllCards { CardInitStack(stack, cards, CardsNone, True, row, CardDisplayAll); stack->basePosition = col; } CardInitStack(&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); CardInitStack(&wasteStack, (Widget) waste, CardsEmpty, False, 0, CardDisplayTop); currentScore = 0; } static void GenerateCards (void) { CardGenerateStandardDeck(rawcards); deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS - 1]; } static void SetPosition(CardStackPtr stack) { int i; i = stack->last - rawcards; position[i] = stack; } static void FirstDeal (void) { ForAllCardVars; ForAllCards { CardMove(&deckStack, deckStack.last, stack, False); SetPosition(stack); CardTurn(stack->last, CardFaceUp, False); cardsLeft--; } Message(deckCount, "%d", cardsLeft); } static int ComputeScore (void) { int score; CardPtr t; /* simple point-per-removal */ score = 0; t = wasteStack.last; while (t) { score++; t = t->prev; } return score; } static void DisplayStacks (void) { ForAllCardVars; ForAllCards CardDisplayStack(stack); CardDisplayStack(&deckStack); CardDisplayStack(&wasteStack); CardsUpdateDisplay(cards); } static Boolean MonteCarloUndo(void) { if (!CardUndo()) return False; DisplayStacks(); return True; } static void MonteCarloDo(CardStackPtr from_stack, CardStackPtr to_stack) { CardPtr card; card = from_stack->last; CardMove(from_stack, card, &wasteStack, True); card = to_stack->last; CardMove(to_stack, card, &wasteStack, True); CardNextHistory(); } /* User interface functions */ static void UnHint(void); static CardStackPtr NextStack(int r, int c) { ForAllCardVars; for (row = r; row < NUM_ROWS; row++) { for (col = c; col < NUM_COLS; col++, stack++) { stack = &cardStacks[row * NUM_COLS + col]; if (stack->last) return stack; } c = 0; /* reset for remaining rows */ } return NULL; } static CardStackPtr FirstEmpty(void) { ForAllCardVars; ForAllCards { if (!stack->last) return stack; } return NULL; } static void Deal(void) { ForAllCardVars; CardPtr card; CardStackPtr next_stack; UnHint(); stack = cardStacks; for (row = 0; row < NUM_ROWS; row++) { stack = &cardStacks[row * NUM_COLS]; for (col = 0; col < NUM_COLS; col++, stack++) { if (stack->last) continue; /* XXX otherwise space, so move it up */ next_stack = NextStack(row, col); if (next_stack) { CardMove(next_stack, next_stack->last, stack, True); } DisplayStacks(); /* i like to see them move */ } } next_stack = FirstEmpty(); while (next_stack && deckStack.last) { if ((card = deckStack.last)) { CardMove(&deckStack, card, next_stack, True); CardTurn(card, CardFaceUp, True); DisplayStacks(); /* i like to see them move */ cardsLeft--; } next_stack = FirstEmpty(); } Message(deckCount, "%d", cardsLeft); CardNextHistory(); } static void NewGame (void) { CardsRemoveAllCards(cards); fromStack = 0; fromCard = 0; hintStack = 0; cardsLeft = NUM_CARDS; InitStacks(); GenerateCards(); CardShuffle(&deckStack, False); FirstDeal(); CardInitHistory(); DisplayStacks(); Message(message, "Keith's Monte Carlo, Version " KGAMES_VERSION_STRING); } static void Undo (void) { if (!MonteCarloUndo()) { Message(message, "Nothing to undo."); return; } Message(message, "Undo."); CardSetAnimate(False); DisplayStacks(); CardSetAnimate(True); } static void Score (void) { Message(message, "Current position scores %d out of %d.", ComputeScore(), MAX_SCORE); } static void Quit(void) { exit(0); } static Bool NextTo(CardStackPtr from_stack, CardStackPtr to_stack) { if ((abs(from_stack->position - to_stack->position) > 1) || (abs(from_stack->basePosition - to_stack->basePosition) > 1)) return False; else return True; } static void Play(CardStackPtr from_stack, CardStackPtr to_stack) { CardPtr card; UnHint(); if (from_stack == to_stack) return; card = from_stack->last; if (!card) { Message(message, "Can't move spaces around."); return; } if (!to_stack->last) { Message(message, "Target is empty."); return; } if (to_stack->last->card.rank != card->card.rank) { Message(message, "%P and %P are of different ranks.", &card->card, &to_stack->last->card); return; } if (!NextTo(to_stack, from_stack)) { Message(message, "%P and %P aren't next to each other.", &card->card, &to_stack->last->card); return; } MonteCarloDo(from_stack, to_stack); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!."); } #define MAX_MOVES 16 static CardStackPtr FindMove(CardStackPtr src) { int r, c; ForAllCardVars; r = src->position; c = src->basePosition; /* test is '<', so add 2 */ for (row = max(r - 1, 0); row < min(r + 2, NUM_ROWS); row++) { for (col = max(c - 1, 0); col < min(c + 2, NUM_COLS); col++) { if ((row == r) && (col == c)) continue; stack = &cardStacks[row * NUM_COLS + col]; if (!stack->last) continue; if (src->last->card.rank == stack->last->card.rank) return stack; } } return NULL; } static void BestMove(void) { ForAllCardVars; CardStackPtr best, first; Bool seen_first = False, has_gaps = False; ForAllCards { if (!stack->last) continue; best = FindMove(stack); if (best) { Message(message, "Match %P and %P.", &stack->last->card, &best->last->card); return; } } /* see if there're any empties, and where they are in the stacks */ first = FirstEmpty(); ForAllCards { stack = &cardStacks[row * NUM_COLS + col]; if (stack != first && !seen_first) continue; seen_first = True; if (stack->last) { has_gaps = True; break; } } if (deckStack.last && first) Message(message, "Deal."); else if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!."); else if (has_gaps) Message(message, "Deal."); else Message(message, "Its all over."); } static void UnHint(void) { if (hintStack) { CardTurn(hintStack->last, CardFaceUp, True); hintStack = 0; } } static void Hint(CardStackPtr stack) { hintStack = stack; CardTurn(stack->last, CardFaceDown, True); } static void FindAMove(CardStackPtr stack) { CardStackPtr hint_stack; UnHint(); hint_stack = FindMove(stack); if (hint_stack) Hint(hint_stack); } static void Restore(void) { Message(message, "Restore not implemented"); } static void Save(void) { Message(message, "Save not implemented"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int row, int col) { if (w == cards) return &cardStacks[row * NUM_COLS + col]; if (w == deck) return &deckStack; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack, startStack; (void) w; (void) closure; stack = WidgetToStack(input->current.w, input->current.row, input->current.col); startStack = WidgetToStack(input->start.w, input->start.row, input->start.col); switch (input->action) { case HandActionStart: break; case HandActionClick: if (stack == &deckStack) { Deal(); break; } if (!startStack->last) { Message(message, "Selected space is empty."); break; } stack = FindMove(startStack); if (!stack) { Message(message, "No move."); break; } CardSetAnimate(True); Play(startStack, stack); DisplayStacks(); break; case HandActionDrag: if (stack == &deckStack || startStack == &deckStack) break; if (!startStack->last) { Message(message, "Selected space is empty."); break; } CardSetAnimate(False); Play(startStack, stack); DisplayStacks(); break; case HandActionExpand: FindAMove(stack); DisplayStacks(); break; case HandActionUnexpand: UnHint(); DisplayStacks(); break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void HintCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; BestMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void BestMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; BestMove (); } XtActionsRec actions[] = { { "montecarloUndo", UndoAction, }, { "montecarloNewGame", NewGameAction, }, { "montecarloScore", ScoreAction, }, { "montecarloQuit", QuitAction, }, { "montecarloRestore", RestoreAction, }, { "montecarloSave", SaveAction, }, { "montecarloBestMove", BestMoveAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell(name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget(entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback(entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(MonteCarloResources, field) XtResource resources[] = { {"animationSpeed", "AnimationSpeed", XtRInt, sizeof(int), offset(animationSpeed), XtRImmediate, (XtPointer) - 1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main(int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize("MonteCarlo", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources(toplevel, (XtPointer) & montecarloResources, resources, XtNumber(resources), NULL, 0); AnimateSetSpeed(montecarloResources.animationSpeed); XtAddActions(actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable("WM_PROTOCOLS: montecarloQuit()")); frame = XtCreateManagedWidget("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu(fileMenuButton, "fileMenu", fileMenuEntries, XtNumber(fileMenuEntries)); newGame = XtCreateManagedWidget("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, HintCallback, NULL); score = XtCreateManagedWidget("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); cards = XtCreateManagedWidget("cards", cardsWidgetClass, frame, NULL, 0); XtAddCallback(cards, XtNinputCallback, InputCallback, NULL); deck = XtCreateManagedWidget("deck", cardsWidgetClass, frame, NULL, 0); deckCount = XtCreateManagedWidget("deckCount", klabelWidgetClass, frame, NULL, 0); XtAddCallback(deck, XtNinputCallback, InputCallback, NULL); waste = XtCreateManagedWidget("waste", cardsWidgetClass, frame, NULL, 0); wasteLabel = XtCreateManagedWidget("wasteLabel", klabelWidgetClass, frame, NULL, 0); message = XtCreateManagedWidget("message", klabelWidgetClass, frame, NULL, 0); srandom(getpid() ^ time((long *) 0)); NewGame(); XtRealizeWidget(toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols(XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop(); } kgames-2.2/kmcarlo/meson.build000066400000000000000000000032601416764561500164360ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'MonteCarlo.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kmcarlo', 'mc.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kmcarlo.6') configure_file(input: 'kmcarlo.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kmontana/000077500000000000000000000000001416764561500144535ustar00rootroot00000000000000kgames-2.2/kmontana/KMontana.ad.in000066400000000000000000000030701416764561500170760ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *cards.numCols: 13 *cards.numRows: 4 *cards.overlap: none *smallCards: true *cards.immediateUpdate: False *cards.rowMajor: True *cards.translations: #override \ Shift: expand(hint-previous)\n\ Shift:\n\ : zoomout()\n\ :\n\ : zoomin()\n\ :\n\ : start()\n\ : expand(hint)\n\ : drag()\n\ : stop() *message.justify: left *message.label: Keith's Montana, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ deal \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ horizontal {\ menuBar < +inff -100% * >\ } \ 10 < -inf > \ cards < +100% -100% * +100% -100% > \ horizontal { \ dealDisplay < -100% * > \ message < +inff -100% * > \ } \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *deal.label: Deal *score.label: Score *hint.label: Hint *Command.shapeStyle: oval *frame.translations: #override \ u: montanaUndo()\n\ n: montanaNewGame()\n\ s: montanaScore()\n\ ?: montanaBestMove() kgames-2.2/kmontana/kmontana.6000066400000000000000000000013221416764561500163500ustar00rootroot00000000000000.TH KMONTANA 6 "1992" "Kgames 1.0" .SH NAME kmontana \- X window montana high solitaire .SH SYNOPSIS .B kmontana .SH DESCRIPTION .I Kmontana brings up a window for a montana solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card place it (if legal) in the target stack. .SH RULES Top cards of tableaus are available, and may be discarded if they have the same suit and lower rank than another available card. Empty tableaus may be filled with any available card. Aces rank high, above Kings. .P Deal four more cards by clickping the deck. Dealing is not allowed until empty tableaus have been filled (if possible). Goal: discard all cards except for the four Aces. .SH AUTHOR Keith Packard kgames-2.2/kmontana/kmontana.desktop.in000066400000000000000000000004031416764561500202600ustar00rootroot00000000000000[Desktop Entry] Name=KMontana GenericName=Solitaire Game Comment=Play Montana solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kmontana Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kmontana/meson.build000066400000000000000000000032661416764561500166240ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KMontana.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kmontana', 'montana.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kmontana.6') configure_file(input: 'kmontana.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kmontana/montana.c000066400000000000000000000535301416764561500162620ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KMontana-res.h" # include "kgames.h" Widget toplevel; Widget frame; Widget cards; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget deal; Widget dealDisplay; Widget newGame; Widget undo; Widget hint; Widget score; #define NUM_DEALS 2 #define NUM_ROWS 4 #define NUM_COLS 13 #define NUM_CARDS 52 #define MAX_SCORE 336 CardStackRec cardStacks[NUM_CARDS]; CardStackRec deckStack; CardRec rawcards[NUM_CARDS]; CardsRank maxrank[NUM_ROWS]; CardStackPtr position[NUM_CARDS]; CardStackPtr fromStack; CardPtr fromCard; int dealNumber; int currentScore; CardStackPtr hintStack; CardStackPtr emptyStacks[4]; typedef struct _montanaResources { int animationSpeed; int searchDepth; } MontanaResources, *MontanaResourcesPtr; MontanaResources montanaResources; #define ForAllCardVars int row, col; CardStackPtr stack #define ForAllCards for (row = 0, stack = cardStacks; row < NUM_ROWS; row++) \ for (col = 0; col < NUM_COLS; col++, stack++) static void InitStacks (void) { ForAllCardVars; ForAllCards { CardInitStack (stack, cards, CardsNone, True, row, CardDisplayAll); stack->basePosition = col; } CardInitStack (&deckStack, (Widget) 0, CardsNone, True, 0, CardDisplayNone); for (row = 0; row < NUM_ROWS; row++) maxrank[row] = CardsAce; currentScore = 0; } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS-1]; } static void RemoveAces (Boolean remember) { ForAllCardVars; int i; i = 0; ForAllCards { if (stack->last->card.rank == CardsAce) { CardMove (stack, stack->last, &deckStack, remember); emptyStacks[i++] = stack; } } } static void SetPosition (CardStackPtr stack) { int i; i = stack->last - rawcards; position[i] = stack; } static int ComputeScore (void); static void UnHint (void); static void FirstDeal (void) { ForAllCardVars; ForAllCards { CardMove (&deckStack, deckStack.last, stack, False); SetPosition (stack); CardTurn (stack->last, CardFaceUp, False); } RemoveAces (False); (void) ComputeScore (); } static CardStackPtr NotInOrder (int row) { CardStackPtr stack; CardPtr card; int col; CardsRank rank; CardsSuit suit; stack = &cardStacks[row * NUM_COLS]; card = stack->last; col = 0; if (card && card->card.rank == Cards2) { rank = Cards3; suit = card->card.suit; stack++; for (col = 1; col < NUM_COLS; col++, stack++, rank++) { card = stack->last; if (!card || card->card.rank != rank || card->card.suit != suit) break; } } return stack; } static int ComputeScore (void) { int row; CardStackPtr stack, notInOrder; CardPtr card; int score = 0; for (row = 0; row < NUM_ROWS; row++) { stack = &cardStacks[row * NUM_COLS]; notInOrder = NotInOrder (row); maxrank[row] = CardsAce; if (stack != notInOrder) maxrank[row] = notInOrder[-1].last->card.rank; while (stack != notInOrder) { card = stack->last; if (card->card.rank < CardsJack) score += (int) card->card.rank; else score += 10; stack++; } } currentScore = score; if (dealNumber > NUM_DEALS) score -= 100 * (dealNumber - NUM_DEALS); return score; } static void DisplayStacks (void) { ForAllCardVars; ForAllCards CardDisplayStack (stack); CardDisplayStack (&deckStack); CardsUpdateDisplay (cards); } typedef struct _emptySave { struct _emptySave *next; CardStackPtr empty; int i; } EmptySaveRec, *EmptySavePtr; EmptySavePtr emptySave; #define RankScore(r) ((r) > Cards10 ? 10 : (int) (r)) static Boolean MontanaUndo (void) { EmptySavePtr e; CardStackPtr stack; CardsRank rank; CardsSuit suit; e = emptySave; if (!e) return False; stack = e->empty; rank = stack->basePosition + 2; suit = stack->last->card.suit; if (!CardUndo()) return False; if (maxrank[stack->position] == rank) { maxrank[stack->position] = rank - 1; do { currentScore -= RankScore (rank); rank++; stack++; } while (stack->last && stack->last->card.rank == rank && stack->last->card.suit == suit); } SetPosition(emptyStacks[e->i]); emptyStacks[e->i] = e->empty; emptySave = e->next; Dispose (e); return True; } static void MontanaDo (CardStackPtr from_stack, CardStackPtr to_stack) { EmptySavePtr e; int i; CardPtr card; CardsRank rank; CardsSuit suit; CardStackPtr stack; card = from_stack->last; CardMove (from_stack, card, to_stack, True); rank = to_stack->basePosition + 2; if (rank - 1 == maxrank[to_stack->position]) { suit = card->card.suit; rank = rank; stack = to_stack; do { currentScore += RankScore (rank); rank++; stack++; } while (stack->last && stack->last->card.rank == rank && stack->last->card.suit == suit); maxrank[to_stack->position] = rank - 1; } SetPosition (to_stack); e = New(EmptySaveRec); for (i = 0; i < 4; i++) { if (emptyStacks[i] == to_stack) { e->i = i; e->empty = to_stack; e->next = emptySave; emptySave = e; emptyStacks[i] = from_stack; break; } } CardNextHistory (); } /* User interface functions */ static void ResetDealNumber (void *closure) { dealNumber = (int) (intptr_t) closure; (void) ComputeScore (); } static void CheckWin(void) { int score = ComputeScore(); if (dealNumber > NUM_DEALS) score += 100 * (dealNumber - NUM_DEALS); if (score == MAX_SCORE) Message(message, "We have a winner!"); else Message(message, ""); } static void Deal (void) { ForAllCardVars; CardPtr card; CardStackPtr notInOrder; UnHint (); if (dealNumber >= NUM_DEALS) Message (message, "No more than %d redeals allowed.", NUM_DEALS); stack = cardStacks; for (row = 0; row < NUM_ROWS; row++) { notInOrder = NotInOrder (row); col = notInOrder - stack; stack = notInOrder; for (; col < NUM_COLS; col++, stack++) { card = stack->last; if (card) CardMove (stack, card, &deckStack, True); } } CardShuffle (&deckStack, True); ForAllCards { if (!stack->last) { CardMove (&deckStack, deckStack.last, stack, True); SetPosition (stack); } } RemoveAces (True); (void) ComputeScore (); CardRecordHistoryCallback (ResetDealNumber, (char *) (intptr_t) dealNumber); ++dealNumber; Message (message, "Dealt %d of %d.", dealNumber, NUM_DEALS); Message (dealDisplay, "Deal: %d", dealNumber); CardSetAnimate (False); DisplayStacks (); CardSetAnimate (True); CardNextHistory (); CheckWin(); } static void NewGame (void) { CardsRemoveAllCards (cards); fromStack = 0; fromCard = 0; hintStack = 0; dealNumber = 0; InitStacks (); GenerateCards (); CardShuffle (&deckStack, False); FirstDeal (); CardInitHistory (); DisplayStacks (); Message (message, "Keith's Montana, Version " KGAMES_VERSION_STRING); Message (dealDisplay, "No deals."); } static void Undo (void) { if (!MontanaUndo ()) { Message (message, "Nothing to undo."); return; } Message (message, "Undo."); CardSetAnimate (False); DisplayStacks (); CardSetAnimate (True); } static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static CardStackPtr FindPlay (CardStackPtr from_stack) { ForAllCardVars; CardPtr card = from_stack->last; if (!card) return NULL; if (card->card.rank == Cards2) { for (row = 0, stack = cardStacks; row < NUM_ROWS; row++, stack += NUM_COLS) { if (!stack->last) return stack; } } else { ForAllCards { if (col < NUM_COLS - 1 && !stack[1].last && stack->last && CardIsInSuitOrder (stack->last, card)) { return stack + 1; } } } return NULL; } static CardStackPtr FindReverse (CardStackPtr to_stack) { ForAllCardVars; CardPtr card; card = to_stack->last; if (!card) return NULL; ForAllCards if (stack->last && CardIsInSuitOrder (card, stack->last)) return stack; return NULL; } static CardStackPtr FindForward (CardStackPtr from_stack) { ForAllCardVars; CardPtr card; card = from_stack->last; if (!card) return NULL; ForAllCards if (stack->last && CardIsInSuitOrder (stack->last, card)) return stack; return NULL; } static void Play (CardStackPtr from_stack, CardStackPtr to_stack) { int col; CardPtr card; UnHint (); card = from_stack->last; if (!card) { Message (message, "Can't move spaces around."); return; } if (from_stack == to_stack) { to_stack = FindPlay (from_stack); if (!to_stack) { Message (message, "No place to move %P.", &from_stack->last->card); return; } } else { col = to_stack->basePosition; if (to_stack->last) { Message (message, "Target must be empty."); return; } if (col == 0 && card->card.rank != Cards2) { Message (message, "Only deuces can be moved to column 1."); return; } if (col > 0 && !to_stack[-1].last) { Message (message, "Can't move next to an empty space."); return; } if (col > 0 && !CardIsInSuitOrder (to_stack[-1].last, card)) { Message (message, "Can't move the %P next to the %P.", &card->card, &to_stack[-1].last->card); return; } } MontanaDo (from_stack, to_stack); CheckWin(); } #define MAX_MOVES 16 static int FindAllMoves (CardStackPtr moves[MAX_MOVES][2]) { int i, j, k; CardStackPtr to_stack; CardPtr card; CardsSuit suit; j = 0; for (i = 0; i < 4; i++) { to_stack = emptyStacks[i]; if (!to_stack->basePosition) { for (suit = CardsClub; suit <= CardsSpade; suit++) { k = suit * 13 + 1; if (position[k]->basePosition) { moves[j][0] = position[k]; moves[j][1] = to_stack; /* PrintMove (moves[j]); */ j++; } } } else if ((card = to_stack[-1].last) && card->card.rank != CardsKing) { k = ((int) card->card.suit * 13) + (int) card->card.rank; moves[j][0] = position[k]; moves[j][1] = to_stack; /* PrintMove (moves[j]); */ j++; } } return j; } typedef struct _Solve { struct _Solve *next; int i; CardStackPtr moves[MAX_MOVES][2]; } SolveRec, *SolvePtr; static int Seek (SolvePtr s, int *bestp, int levels) { SolveRec ns; int i, best; int max_score, score, max_i; max_i = -1; if (levels < s->i || s->i <= 0) { max_score = currentScore; } else { levels -= s->i; max_score = -1; for (i = 0; i < s->i; i++) { MontanaDo (s->moves[i][0], s->moves[i][1]); ns.i = FindAllMoves (ns.moves); score = Seek (&ns, &best, levels); if (score > max_score) { max_score = score; max_i = i; } MontanaUndo (); } } *bestp = max_i; return max_score; } #define MAX_SEARCH 1000 static void BestMove (void) { SolveRec s; int score; int best; CardPtr card; s.i = FindAllMoves (s.moves); score = Seek (&s, &best, montanaResources.searchDepth); DisplayStacks (); if (best < 0) { Message (message, "No moves"); return; } card = s.moves[best][0]->last; if (card->card.rank == Cards2) Message (message, "Play the %P in column %d (%d)", &card->card, s.moves[best][1]->position, score); else Message (message, "Play the %P (%d)", &card->card, score); } static void UnHint (void) { if (hintStack) { CardTurn (hintStack->last, CardFaceUp, True); hintStack = 0; } } static void Hint (CardStackPtr stack) { hintStack = stack; CardTurn (stack->last, CardFaceDown, True); } static void FindAMove (CardStackPtr stack, Boolean forward) { CardStackPtr hint_stack; UnHint (); if (!forward) hint_stack = FindReverse (stack); else hint_stack = FindForward (stack); if (hint_stack) Hint (hint_stack); } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } /* Callbacks to user interface functions */ static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; int i; Boolean hintForward = True; String type = ""; (void) closure; (void) w; Message (message, ""); if (*input->num_params > 0) type = input->params[0]; stack = &cardStacks[input->current.row * NUM_COLS + input->current.col]; startStack = &cardStacks[input->start.row * NUM_COLS + input->start.col]; #define MOVE 0 #define HINT 1 #define UNHINT 2 #define SELECT 3 switch (input->action) { case HandActionStart: if (!stack->last) { i = HINT; hintForward = True; } else i = SELECT; break; case HandActionDrag: CardSetAnimate(False); i = MOVE; break; case HandActionClick: CardSetAnimate(True); if (hintStack) i = UNHINT; else i = MOVE; break; case HandActionExpand: i = HINT; if (!strcmp(type, "hint-previous")) hintForward = False; else hintForward = True; break; default: case HandActionUnexpand: i = UNHINT; break; } switch (i) { case HINT: if (!stack->last) { if (input->current.col == 0) return; stack = stack - 1; hintForward = False; } FindAMove (stack, hintForward); break; case UNHINT: UnHint (); break; case SELECT: break; case MOVE: if (startStack) Play (startStack, stack); break; } DisplayStacks (); } static void DealCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Deal (); } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void HintCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; BestMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void DealAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void BestMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; BestMove (); } XtActionsRec actions[] = { { "montanaUndo", UndoAction, }, { "montanaDeal", DealAction, }, { "montanaNewGame", NewGameAction, }, { "montanaScore", ScoreAction, }, { "montanaQuit", QuitAction, }, { "montanaRestore", RestoreAction, }, { "montanaSave", SaveAction, }, { "montanaBestMove", BestMoveAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(MontanaResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, { "searchDepth", "SearchDepth", XtRInt, sizeof (int), offset(searchDepth), XtRImmediate, (XtPointer) 40}, }; XrmOptionDescRec options[] = { { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed","*animationSpeed", XrmoptionSepArg, NULL }, { "-searchDepth", "*searchDepth", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KMontana", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&montanaResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (montanaResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: montanaQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); deal = XtCreateManagedWidget ("deal", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(deal, XtNcallback, DealCallback, NULL); dealDisplay = XtCreateManagedWidget ("dealDisplay", klabelWidgetClass, frame, NULL, ZERO); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, HintCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); cards = XtCreateManagedWidget ("cards", cardsWidgetClass, frame, NULL, 0); XtAddCallback (cards, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/kslyfox/000077500000000000000000000000001416764561500143425ustar00rootroot00000000000000kgames-2.2/kslyfox/KSlyFox-hard.ad.in000066400000000000000000000066351416764561500175420ustar00rootroot00000000000000*deck.numCols: 1 *deck.numRows: 1 *draw.numCols: 1 *draw.numRows: 1 *aces.numCols: 1 *aces.numRows: 4 !*aces.rowMajor: False *kings.numCols: 1 *kings.numRows: 4 !*kings.rowMajor: True *Cards.immediateUpdate: False *row1.numCols: 5 *row1.numRows: 1 *row1.overlap: none *row2.numCols: 5 *row2.numRows: 1 *row2.overlap: none *row3.numCols: 5 *row3.numRows: 1 *row3.overlap: none *row4.numCols: 5 *row4.numRows: 1 *row4.overlap: none *deck.translations: #override \ : select() *draw.translations: #override \ : select(source) *row1.translations: #override \ Shift: select(noop)\n\ Shift: select(expand)\n\ :: select(source)\n\ :: select(dest) *row2.translations: #override \ Shift: select(noop)\n\ Shift: select(expand)\n\ :: select(source)\n\ :: select(dest) *row3.translations: #override \ Shift: select(noop)\n\ Shift: select(expand)\n\ :: select(source)\n\ :: select(dest) *row4.translations: #override \ Shift: select(noop)\n\ Shift: select(expand)\n\ :: select(source)\n\ :: select(dest) *aces.translations: #override \ : select(source)\n\ : select(dest) *kings.translations: #override \ : select(source)\n\ : select(dest) *message.justify: left *message.label: Sly Fox (hard), Version @KGAMES_VERSION@ *row1.borderWidth: 0 *row2.borderWidth: 0 *row3.borderWidth: 0 *row4.borderWidth: 0 *deck.borderWidth: 0 *deckCount.borderWidth: 0 *draw.borderWidth: 0 *reserveCount.borderWidth: 0 *aces.borderWidth: 0 *kings.borderWidth: 0 *gameState.borderWidth: 0 *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ deal \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ -1 \ horizontal {\ -1 \ menuBar < +inff -100% * >\ -1 \ } \ 10 < -inf > \ horizontal { \ 10 < -inf > \ vertical { \ 10 < -inf > \ aces < +100% -100% * +100% -100% > \ 0 < +inf > \ } \ 30 < -inf > \ vertical { \ 10 < -inf > \ row1 < +100% -100% * +100% -100% > \ 10 < -inf > \ row2 < +100% -100% * +100% -100% > \ 10 < -inf > \ row3 < +100% -100% * +100% -100% > \ 10 < -inf > \ row4 < +100% -100% * +100% -100% > \ 10 < -inf > \ horizontal { \ vertical { \ deckCount < +100% -100% * > \ deck < +100% -100% * +100% -100% > \ } \ vertical { \ reserveCount < +100% -100% * > \ draw < +100% -100% * +100% -100% > \ } \ } \ } \ 30 < -inf > \ vertical { \ 10 < -inf > \ kings < +100% -100% * +100% -100% > \ 0 < +inf > \ } \ 10 < -inf > \ } \ horizontal { \ -1 \ gameState < +inff -100% * > \ -1 \ } \ horizontal { \ -1 \ message < +inff -100% * > \ -1 \ } \ -1 \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *deal.label: Deal *undo.label: Undo *hint.label: Hint *score.label: Score *Command.shapeStyle: oval *frame.translations: #override \ u: slyfoxUndo()\n\ n: slyfoxNewGame()\n\ s: slyfoxScore()\n\ d: slyfoxStartDeal()\n\ ?: slyfoxFindAMove() kgames-2.2/kslyfox/KSlyFox.ad.in000066400000000000000000000043051416764561500166160ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *gameState.Background: #337744 *gameState.Foreground: #fffff0 *deckCount.Background: #337744 *deckCount.Foreground: #fffff0 *reserveCount.Background: #337744 *reserveCount.Foreground: #fffff0 *aces.numRows: 4 !*aces.rowMajor: False *kings.numRows: 4 !*kings.rowMajor: True *Cards.immediateUpdate: False *Cards.rowsHint: True *row1.numCols: 5 *row1.numRows: 2 *row1.overlap: vertical *row2.numCols: 5 *row2.numRows: 2 *row2.overlap: vertical *row3.numCols: 5 *row3.numRows: 2 *row3.overlap: vertical *row4.numCols: 5 *row4.numRows: 2 *row4.overlap: vertical *message.justify: left *message.label: Sly Fox, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ deal \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ vertical {\ aces < -100% * -100% > \ 10 < +inf -inf > \ deck < -100% * -100% > \ } \ 30 < +inf -inf > \ vertical { \ row1 < -100% * +100% -100% > \ row2 < -100% * +100% -100% > \ row3 < -100% * +100% -100% > \ row4 < -100% * +100% -100% > \ horizontal { \ deckCount < -inf * > \ gameState < +inf -100% *> \ reserveCount < -inf * > \ } \ 0 < +inf > \ } \ 30 < +inf -inf > \ vertical { \ kings < -100% * -100% > \ 10 < +inf -inf > \ draw < -100% * -100% > \ } \ 10 < -inf > \ } \ message < +inf * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *deal.label: Deal *undo.label: Undo *hint.label: Hint *score.label: Score *Command.shapeStyle: oval *frame.translations: #override \ u: slyfoxUndo()\n\ n: slyfoxNewGame()\n\ s: slyfoxScore()\n\ d: slyfoxStartDeal()\n\ ?: slyfoxFindAMove() kgames-2.2/kslyfox/kslyfox.6000066400000000000000000000031771416764561500161400ustar00rootroot00000000000000.TH KSLYFOX 6 "1992" "Kgames 1.0" .SH NAME kslyfox \- X window sly fox solitaire .SH SYNOPSIS .B kslyfox .SH DESCRIPTION .I Kslyfox brings up a window for a sly fox solataire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES .P Sly Fox is a double-deck solitaire game. .P 4 Aces and 4 Kings (1 of each suit) is pulled out and used for the foundations, with the Ace piles building up in suit and the King piels building down. .P 20 cards are dealt face up in 4 rows of 5 to form the reserve. .P Any of the reserve cards can be played on the foundations, and the space formed by this is immediately filled in from the deck. .P Once no more plays can be made, cards are dealt one at a time from the deck. Each card can either be played to a foundation, or placed on one of the 20 reserve stacks. During this play, none of the reserve cards can be moved to the foundations. Once 20 cards have been added to the reserve, the reserve cards can again be played as before, except that spaces are not filled immediately, but instead left for the next deal. .P Playing the X version .P In general, clicking on a card will make it do the "right thing". Cards can also be dragged between piles. .P To change between Deal play (when the reserve cards are in play) to Reserve play (when the deck cards are being added to the reserve), select 'Deal', hit the 'd' key or click on the deck. Once 20 cards are added to the reserve stacks, the game will revert to Deal mode. .P During Reserve play, simply clicking on the destination of the card in play will place it there. .SH AUTHOR Keith Packard kgames-2.2/kslyfox/kslyfox.desktop.in000066400000000000000000000004001416764561500200330ustar00rootroot00000000000000[Desktop Entry] Name=KSlyfox GenericName=Solitaire Game Comment=Play Slyfox Solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kslyfox Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kslyfox/meson.build000066400000000000000000000031621416764561500165060ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KSlyFox.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kslyfox', 'slyfox.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kslyfox.6') configure_file(input: 'kslyfox.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kslyfox/slyfox-rules000066400000000000000000000024701416764561500167440ustar00rootroot00000000000000 Sly Fox rules Sly Fox is a double-deck solitaire game. 4 Aces and 4 Kings (1 of each suit) is pulled out and used for the foundations, with the Ace piles building up in suit and the King piels building down. 20 cards are dealt face up in 4 rows of 5 to form the reserve. Any of the reserve cards can be played on the foundations, and the space formed by this is immediately filled in from the deck. Once no more plays can be made, cards are dealt one at a time from the deck. Each card can either be played to a foundation, or placed on one of the 20 reserve stacks. During this play, none of the reserve cards can be moved to the foundations. Once 20 cards have been added to the reserve, the reserve cards can again be played as before, except that spaces are not filled immediately, but instead left for the next deal. Playing the X version In general, clicking on a card will make it do the "right thing". Cards can also be dragged between piles. To change between Deal play (when the reserve cards are in play) to Reserve play (when the deck cards are being added to the reserve), select 'Deal', hit the 'd' key or click on the deck. Once 20 cards are added to the reserve stacks, the game will revert to Deal mode. During Reserve play, simply clicking on the destination of the card in play will place it there. kgames-2.2/kslyfox/slyfox.c000066400000000000000000000654451416764561500160500ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Dave Lemke, Network Computing Devices * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "KSlyFox-res.h" Widget toplevel; Widget frame; Widget deck; Widget draw; Widget aces; Widget kings; Widget row1, row2, row3, row4; Widget message; Widget deckCount; Widget reserveCount; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget deal; Widget undo; Widget hint; Widget score; Widget gameState; #define NUM_ROWS 4 #define NUM_COLS 5 #define NUM_ACES 4 #define NUM_KINGS 4 #define NUM_CARDS 104 #define MAX_SCORE 104 CardStackRec deckStack; CardStackRec drawStack; CardStackRec tmpStack; CardStackRec stackStacks[NUM_ROWS * NUM_COLS]; CardStackRec aceStacks[NUM_ACES], kingStacks[NUM_KINGS]; CardRec rawcards[NUM_CARDS]; #define RESERVE_COUNT 20 #define GAME_DEAL 1 #define GAME_RESERVE 2 int game_state; int reserveCountNumber; #define STACK_TYPE_UNKNOWN 0 #define STACK_TYPE_ACE 1 #define STACK_TYPE_KING 2 #define STACK_TYPE_RESERVE 3 #define STACK_TYPE_DRAW 4 static int StackType(CardStackPtr stack) { if (stack->widget == row1 || stack->widget == row2 || stack->widget == row3 || stack->widget == row4) return STACK_TYPE_RESERVE; if (stack->widget == draw) return STACK_TYPE_DRAW; if (stack->widget == aces) return STACK_TYPE_ACE; if (stack->widget == kings) return STACK_TYPE_KING; return STACK_TYPE_UNKNOWN; } CardStackPtr fromStack; CardPtr fromCard; Bool initialDeal; Bool hard = False; static void ShowGameState(void); static void ShowReserveCount(void); static void ShowDealNumber(void); typedef struct _slyfoxResources { int animationSpeed; } SlyFoxResources, *SlyFoxResourcesPtr; SlyFoxResources slyfoxResources; static void InitStacks (void) { int col; int row; CardStackPtr stack; Widget w; int dt; if (hard) dt = CardDisplayTop; else dt = CardDisplaySome; for (row = 0, stack = stackStacks; row < NUM_ROWS; row++) { switch (row) { case 0: w = row1; break; case 1: w = row2; break; case 2: w = row3; break; case 3: w = row4; break; } for (col = 0; col < NUM_COLS; col++, stack++) { CardInitStack(stack, w, CardsNone, False, col, dt); stack->basePosition = 0; } } for (col = 0; col < NUM_ACES; col++) { CardInitStack(&aceStacks[col], aces, CardsEmpty, False, 0, CardDisplayTop); aceStacks[col].basePosition = col; } for (col = 0; col < NUM_KINGS; col++) { CardInitStack(&kingStacks[col], kings, CardsEmpty, False, 0, CardDisplayTop); kingStacks[col].basePosition = col; } CardInitStack(&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); CardInitStack(&drawStack, draw, CardsEmpty, False, 0, CardDisplayBottom); CardInitStack(&tmpStack, NULL, CardsEmpty, False, 0, CardDisplayBottom); } static void GenerateCards (void) { CardPtr card; card = rawcards; CardGenerateStandardDeck(card); card += 52; CardGenerateStandardDeck(card); rawcards[51].next = &rawcards[52]; rawcards[52].prev = &rawcards[51]; deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS - 1]; } static void GetKingsAndAces(void) { CardPtr card; int i, na = 0, nk = 0; CardsSuit aces_found[NUM_ACES], kings_found[NUM_KINGS]; for (i = 0; i < NUM_ACES; i++) aces_found[i] = CardsNone; for (i = 0; i < NUM_KINGS; i++) kings_found[i] = CardsNone; /* walk thru deck, pulling out aces & kings, tossing rest on tmp */ while ((card = deckStack.last)) { if (card->card.rank == CardsAce) { for (i = 0; i < na; i++) { if (aces_found[i] == card->card.suit) goto other; } if (i == na) { aces_found[na] = card->card.suit; CardMove(&deckStack, card, &aceStacks[na], False); CardTurn(card, CardFaceUp, False); na++; } } else if (card->card.rank == CardsKing) { for (i = 0; i < nk; i++) { if (kings_found[i] == card->card.suit) goto other; } if (i == nk) { kings_found[nk] = card->card.suit; CardMove(&deckStack, card, &kingStacks[nk], False); CardTurn(card, CardFaceUp, False); nk++; } } else { other: CardMove(&deckStack, card, &tmpStack, False); } } /* move tmp back to deck */ i = 0; while ((card = tmpStack.last)) { CardMove(&tmpStack, card, &deckStack, False); i++; } assert (i == 104 - NUM_ACES - NUM_KINGS); } static void AddSeen(CardStackPtr stack, uint8_t *seen) { CardPtr c; for (c = stack->first; c; c = c->next) { int i = c - rawcards; if (seen[i]) { printf("seen twice %d\n", i); assert(0); } seen[i] = 1; } } static void ValidateCards(void) { uint8_t seen[NUM_CARDS]; int s; memset(seen, '\0', sizeof(seen)); AddSeen(&deckStack, seen); AddSeen(&drawStack, seen); AddSeen(&tmpStack, seen); for (s = 0; s < NUM_ROWS * NUM_COLS; s++) AddSeen(&stackStacks[s], seen); for (s = 0; s < NUM_ACES; s++) AddSeen(&aceStacks[s], seen); for (s = 0; s < NUM_KINGS; s++) AddSeen(&kingStacks[s], seen); for (s = 0; s < NUM_CARDS; s++) if (!seen[s]) { printf("lost %d\n", s); assert(0); } } static void FirstDeal (void) { int s; CardStackPtr stack; GetKingsAndAces(); for (s = 0; s < NUM_ROWS * NUM_COLS; s++) { stack = &stackStacks[s]; CardMove(&deckStack, deckStack.last, stack, False); CardTurn(stack->last, CardFaceUp, False); } ShowDealNumber(); game_state = GAME_DEAL; ShowGameState(); reserveCountNumber = 0; ShowReserveCount(); initialDeal = True; ValidateCards(); } /* * Compute a somewhat arbitrary evaluation function for the position: * 2 point per card sitting atop next higher card in same suit * 10 per card turned face up * 15 extra for each column where all cards have been revealed * 50 per completed suit removed (note this costs 12*2 for cards in seq) * If all columns are either empty or contain completed suits, then those * suits also count 50 (including the 24 for the 12 cards that are atop * higher cards), plus an extra 2 for each suit after the first three. * Thus the only way to get 1000 points is to win with all eight suits * still in the tableau. */ static int ComputeScore (void) { int score = 0; int i; CardStackPtr stack; CardPtr card; /* * just count all the cards in the foundations. pretty wimpy, but it * works */ for (i = 0; i < NUM_ACES; i++) { stack = &aceStacks[i]; card = stack->last; while (card) { score++; card = card->prev; } } for (i = 0; i < NUM_KINGS; i++) { stack = &kingStacks[i]; card = stack->last; while (card) { score++; card = card->prev; } } return (score); } static void DisplayStacks (void) { int col; CardPtr card; CardStackPtr stack; int viscount; CardDisplayStack(&drawStack); CardDisplayStack(&deckStack); for (col = 0; col < NUM_ACES; col++) CardDisplayStack(&aceStacks[col]); for (col = 0; col < NUM_KINGS; col++) CardDisplayStack(&kingStacks[col]); for (col = 0; col < (NUM_ROWS * NUM_COLS); col++) { stack = &stackStacks[col]; if (!hard) { viscount = 0; for (card = stack->last; card;) { if (viscount++ < 6) card->shouldBeUp = True; else card->shouldBeUp = False; card = card->prev; } } CardDisplayStack(stack); } CardsUpdateDisplay(deck); CardsUpdateDisplay(draw); CardsUpdateDisplay(aces); CardsUpdateDisplay(kings); CardsUpdateDisplay(row1); CardsUpdateDisplay(row2); CardsUpdateDisplay(row3); CardsUpdateDisplay(row4); ValidateCards(); } /* User interface functions */ static void ShowGameState(void) { if (game_state == GAME_DEAL) { Message(gameState, "Game state is Deal."); } else if (game_state == GAME_RESERVE) { Message(gameState, "Game state is Reserve."); } } static void ShowReserveCount(void) { Message(reserveCount, "Played to Reserve: %d", reserveCountNumber); } static void ShowDealNumber(void) { CardPtr c; int i = 0; for (c = deckStack.first; c; c = c->next) i++; Message(deckCount, "Cards left: %d", i); } static void ResetReserveCount(void *closure) { reserveCountNumber = (int) (intptr_t) closure; ShowReserveCount(); } static void ResetGameState(void *closure) { game_state = (int) (intptr_t) closure; ShowGameState(); } static void Deal(Bool autoplay) { if (!deckStack.last) { if (!autoplay) { Message(message, "No more cards in the deck."); } return; } if (drawStack.last) { if (!autoplay) { Message(message, "Must play %P to reserve first.", &drawStack.last->card); } return; } CardMove(&deckStack, deckStack.last, &drawStack, True); CardTurn(drawStack.last, CardFaceUp, True); ShowDealNumber(); ValidateCards(); } static void FillSpace(CardStackPtr to_stack) { if (!initialDeal) /* only do this for the first deal */ return; if (!deckStack.last) return; if (to_stack->last) /* only if its a space */ return; CardMove(&deckStack, deckStack.last, to_stack, True); CardTurn(to_stack->last, CardFaceUp, True); ShowDealNumber(); ValidateCards(); } static void NewGame (void) { CardsRemoveAllCards(deck); CardsRemoveAllCards(aces); CardsRemoveAllCards(kings); CardsRemoveAllCards(row1); CardsRemoveAllCards(row2); CardsRemoveAllCards(row3); CardsRemoveAllCards(row4); CardsRemoveAllCards(draw); fromStack = 0; fromCard = 0; InitStacks(); GenerateCards(); CardShuffle(&deckStack, False); FirstDeal(); CardInitHistory(); DisplayStacks(); } static void Undo (void) { if (!CardUndo()) Message(message, "Nothing to undo."); DisplayStacks(); } static void Score (void) { Message(message, "Current position scores %d out of %d.", ComputeScore(), MAX_SCORE); } static void Quit (void) { exit(0); } CardStackPtr FindFinishPlay(CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_ACES; i++) { to_stack = &aceStacks[i]; if (to_stack->last && CardIsInSuitOrder(to_stack->last, from_card)) { return to_stack; } } for (i = 0; i < NUM_KINGS; i++) { to_stack = &kingStacks[i]; if (to_stack->last && CardIsInSuitOrder(from_card, to_stack->last)) { return to_stack; } } return NULL; } void Play(CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { int to_type = StackType(to_stack); switch (game_state) { case GAME_DEAL: if (to_stack == from_stack) { /* single click */ if (to_type == STACK_TYPE_ACE || to_type == STACK_TYPE_KING) { Message(message, "Can't move %P.", &from_card->card); return; } if ((to_stack = FindFinishPlay(from_card))) { CardMove(from_stack, from_card, to_stack, True); FillSpace(from_stack); } else { Message(message, "No place to play the %P.", &from_card->card); } } else if (to_type == STACK_TYPE_ACE) { if (CardIsInSuitOrder(to_stack->last, from_card)) { CardMove(from_stack, from_card, to_stack, True); FillSpace(from_stack); } else { Message(message, "Can't play %P on %P.", &from_card->card, &to_stack->last->card); } } else if (to_type == STACK_TYPE_KING) { if (CardIsInSuitOrder(from_card, to_stack->last)) { CardMove(from_stack, from_card, to_stack, True); FillSpace(from_stack); } else { Message(message, "Can't play %P on %P.", &from_card->card, &to_stack->last->card); } } else if (to_type == STACK_TYPE_RESERVE) { Message(message, "Can't move cards around in reserve."); } break; case GAME_RESERVE: if ((from_stack != to_stack) && (from_stack != &drawStack)) { Message(message, "Must play from waste."); return; } if (to_stack == from_stack) { from_stack = &drawStack; from_card = drawStack.last; if (to_type == STACK_TYPE_DRAW) { if (!(to_stack = FindFinishPlay(from_card))) { Message(message, "I'm not going to guess."); return; } } else if (to_type == STACK_TYPE_RESERVE) { if (!drawStack.last) { Message(message, "Deal next card first."); return; } } else if (to_type == STACK_TYPE_ACE) { if (!CardIsInSuitOrder(to_stack->last, from_card)) { Message(message, "Can't move %P onto %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_type == STACK_TYPE_KING) { if (!CardIsInSuitOrder(from_card, to_stack->last)) { Message(message, "Can't move %P onto %P.", &from_card->card, &to_stack->last->card); return; } } } assert (from_stack != to_stack); CardMove(from_stack, from_card, to_stack, True); if (to_type == STACK_TYPE_RESERVE) { CardRecordHistoryCallback(ResetReserveCount, (void *) (intptr_t) reserveCountNumber); ++reserveCountNumber; ShowReserveCount(); } if ((reserveCountNumber == RESERVE_COUNT) || (!deckStack.last && !drawStack.last)) { CardRecordHistoryCallback(ResetReserveCount, (void *) (intptr_t) reserveCountNumber); CardRecordHistoryCallback(ResetGameState, (void *) (intptr_t) game_state); reserveCountNumber = 0; game_state = GAME_DEAL; ShowGameState(); } else { Deal(True); /* place next card for them */ } break; } DisplayStacks(); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); else Message(message, ""); } static void StartDeal(void) { initialDeal = False; Message(message, ""); CardRecordHistoryCallback(ResetGameState, (void *) (intptr_t) game_state); game_state = GAME_RESERVE; ShowGameState(); Deal(False); CardNextHistory(); DisplayStacks(); } static void FindAMove (void) { int row, col; CardStackPtr stack, to_stack; CardPtr card; if (game_state == GAME_RESERVE) { Message(message, "No clue."); return; } for (row = 0, stack = stackStacks; row < NUM_ROWS; row++) { for (col = 0; col < NUM_COLS; col++, stack++) { card = stack->last; if (!card) continue; to_stack = FindFinishPlay(card); if (to_stack) { Message(message, "Move %P to %P.", &card->card, &to_stack->last->card); return; } } } if (deckStack.last) Message(message, "Time to start dealing."); else Message(message, "Its all over."); } static void Restore (void) { Message(message, "Restore not implemented"); } static void Save (void) { Message(message, "Save not implemented"); } static void Expand(CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart(); MessageAppend("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend(" %p", &card->card); t = CardInSuitOrder(card); if (t != card && t != card->next) { card = t; MessageAppend("-%p", &card->card); } } card = card->next; } MessageAppend("."); MessageEnd(message); } else Message(message, "Column is empty"); } /* Callbacks to user interface functions */ static void DeckCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; (void) w; (void) closure; (void) data; if (input->action == HandActionClick) StartDeal(); } static CardStackPtr WidgetToStack(Widget w, int row, int col) { CardStackPtr stack = NULL; if (w == row1) { stack = &stackStacks[col]; } else if (w == row2) { stack = &stackStacks[NUM_COLS + col]; } else if (w == row3) { stack = &stackStacks[2 * NUM_COLS + col]; } else if (w == row4) { stack = &stackStacks[3 * NUM_COLS + col]; } else if (w == draw) { stack = &drawStack; } else if (w == aces) { stack = &aceStacks[row]; } else if (w == kings) { stack = &kingStacks[row]; } return stack; } static void StackCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack; CardStackPtr startStack; CardPtr card; int to_type; (void) closure; stack = WidgetToStack(w, input->current.row, input->current.col); startStack = WidgetToStack(input->start.w, input->start.row, input->start.col); if (!startStack || !stack) return; to_type = StackType(stack); CardSetAnimate(True); switch (input->action) { case HandActionStart: Message(message, ""); break; case HandActionDrag: if (startStack == stack) break; CardSetAnimate(False); /* fall through ... */ case HandActionClick: if (startStack->last) card = startStack->last; else if (game_state == GAME_DEAL) { Message(message, "Selected stack is empty."); break; } else card = NULL; if (game_state == GAME_DEAL) { if (to_type == STACK_TYPE_ACE || to_type == STACK_TYPE_KING) { Message(message, "Can't move %P.", &card->card); break; } } if (card || game_state == GAME_RESERVE) { Play(startStack, card, stack); CardNextHistory(); DisplayStacks(); } break; case HandActionExpand: Expand(stack); break; case HandActionUnexpand: Message(message, ""); break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void StartDealCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; StartDeal (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void StartDealAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; StartDeal (); } XtActionsRec actions[] = { { "slyfoxUndo", UndoAction, }, { "slyfoxNewGame", NewGameAction, }, { "slyfoxScore", ScoreAction, }, { "slyfoxQuit", QuitAction, }, { "slyfoxFindAMove", FindAMoveAction, }, { "slyfoxRestore", RestoreAction, }, { "slyfoxSave", SaveAction, }, { "slyfoxStartDeal", StartDealAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell(name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget(entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback(entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(SlyFoxResources, field) XtResource resources[] = { {"animationSpeed", "AnimationSpeed", XtRInt, sizeof(int), offset(animationSpeed), XtRImmediate, (XtPointer) - 1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; char *adname = "KSlyFox"; int i; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-hard")) { adname = "KSlyFox-hard"; hard = True; } } toplevel = XkwInitialize(adname, options, XtNumber(options), &argc, argv, True, defaultResources); Arg args[1]; XtSetArg(args[0], XtNinput, True); XtSetValues(toplevel, args, ONE); XtGetApplicationResources(toplevel, (XtPointer) & slyfoxResources, resources, XtNumber(resources), NULL, 0); AnimateSetSpeed(slyfoxResources.animationSpeed); XtAddActions(actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable("WM_PROTOCOLS: slyfoxQuit()")); frame = XtCreateManagedWidget("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu(fileMenuButton, "fileMenu", fileMenuEntries, XtNumber(fileMenuEntries)); newGame = XtCreateManagedWidget("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); deal = XtCreateManagedWidget("deal", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(deal, XtNcallback, StartDealCallback, NULL); undo = XtCreateManagedWidget("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); deck = XtCreateManagedWidget("deck", cardsWidgetClass, frame, NULL, 0); XtAddCallback(deck, XtNinputCallback, DeckCallback, NULL); deckCount = XtCreateManagedWidget("deckCount", klabelWidgetClass, frame, NULL, 0); reserveCount = XtCreateManagedWidget("reserveCount", klabelWidgetClass, frame, NULL, 0); draw = XtCreateManagedWidget("draw", cardsWidgetClass, frame, NULL, 0); XtAddCallback(draw, XtNinputCallback, StackCallback, NULL); gameState = XtCreateManagedWidget("gameState", klabelWidgetClass, frame, NULL, 0); aces = XtCreateManagedWidget("aces", cardsWidgetClass, frame, NULL, 0); XtAddCallback(aces, XtNinputCallback, StackCallback, NULL); kings = XtCreateManagedWidget("kings", cardsWidgetClass, frame, NULL, 0); XtAddCallback(kings, XtNinputCallback, StackCallback, NULL); row1 = XtCreateManagedWidget("row1", cardsWidgetClass, frame, NULL, 0); XtAddCallback(row1, XtNinputCallback, StackCallback, NULL); row2 = XtCreateManagedWidget("row2", cardsWidgetClass, frame, NULL, 0); XtAddCallback(row2, XtNinputCallback, StackCallback, NULL); row3 = XtCreateManagedWidget("row3", cardsWidgetClass, frame, NULL, 0); XtAddCallback(row3, XtNinputCallback, StackCallback, NULL); row4 = XtCreateManagedWidget("row4", cardsWidgetClass, frame, NULL, 0); XtAddCallback(row4, XtNinputCallback, StackCallback, NULL); message = XtCreateManagedWidget("message", klabelWidgetClass, frame, NULL, 0); srandom(getpid() ^ time((long *) 0)); NewGame(); XtRealizeWidget(toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols(XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop(); } kgames-2.2/kspider/000077500000000000000000000000001416764561500143045ustar00rootroot00000000000000kgames-2.2/kspider/KSpider.ad.in000066400000000000000000000030551416764561500165630ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *deck.numCols: 1 *deck.numRows: 1 *piles.numCols: 8 *piles.numRows: 1 *Cards.immediateUpdate: False *stacks.numCols: 10 *stacks.numRows: 7 *stacks.rowsHint: True *stacks.overlap: vertical *stacks.immediate_update: false *frame.translations: #override \ u: spiderUndo()\n\ n: spiderNewGame()\n\ s: spiderScore()\n\ ?: spiderFindAMove() *message.justify: left *message.label: Keith's Spider, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ deck < -75% * -90% > \ 10 < +inf -inf > \ piles < -100% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ stacks < -50% * +inf -50% > \ message < +inff -100% * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *Command.shapeStyle: oval *frame.translations: #override \ u: spiderUndo()\n\ n: spiderNewGame()\n\ s: spiderScore()\n\ ?: spiderFindAMove() kgames-2.2/kspider/kspider.6000066400000000000000000000013371416764561500160400ustar00rootroot00000000000000.TH KSPIDER 6 "1992" "Kgames 1.0" .SH NAME kspider \- X window spider solitaire .SH SYNOPSIS .B kspider .SH DESCRIPTION .I Kspider brings up a window for a spider solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down regardless of suit or color. Full or partial builds in suit may be moved among the tableaus. Empty tableaus may be filled with any available build. Builds of thirteen cards, in suit from King down to Ace, may be moved to an empty discard pile. .P Deal one card onto each tableau by tapping the deck. You may not deal until all empty tableaus have been filled. .P Goal: discard all cards. .SH AUTHOR Keith Packard kgames-2.2/kspider/kspider.desktop.in000066400000000000000000000004001416764561500177370ustar00rootroot00000000000000[Desktop Entry] Name=KSpider GenericName=Solitaire Game Comment=Play Spider solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kspider Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kspider/meson.build000066400000000000000000000032611416764561500164500ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KSpider.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kspider', 'spider.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kspider.6') configure_file(input: 'kspider.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kspider/spider.c000066400000000000000000000504461416764561500157470ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KSpider-res.h" Widget toplevel; Widget frame; Widget deck; Widget piles; Widget stacks; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; #define NUM_STACKS 10 #define NUM_PILES 8 #define NUM_CARDS 104 CardStackRec deckStack; CardStackRec stackStacks[NUM_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardRec rawcards[NUM_CARDS]; CardStackPtr fromStack; CardPtr fromCard; int dealNumber; typedef struct _spiderResources { int animationSpeed; Boolean squishCards; } SpiderResources, *SpiderResourcesPtr; SpiderResources spiderResources; static void InitStacks (void) { int col; CardDisplay display; for (col = 0; col < NUM_STACKS; col++) { display = CardDisplayAll; if (spiderResources.squishCards) display = CardDisplaySome; CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, display); } for (col = 0; col < NUM_PILES; col++) { CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col, CardDisplayTop); } CardInitStack (&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); } static void GenerateCards (void) { int i; CardPtr card; card = rawcards; for (i = 0; i < 2; i++) { CardGenerateStandardDeck (card); card += 52; } rawcards[51].next = &rawcards[52]; rawcards[52].prev = &rawcards[51]; deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS-1]; } #define FIRST_ROWS 6 static void FirstDeal (void) { int row, col; for (row = 0; row < FIRST_ROWS; row++) { for (col = 0; col < NUM_STACKS; col++) { if (row == FIRST_ROWS-1 && col % 3 != 0) continue; CardMove (&deckStack, deckStack.last, &stackStacks[col], False); } } for (col = 0; col < NUM_STACKS; col++) CardTurn (stackStacks[col].last, CardFaceUp, False); dealNumber = 0; } static void CheckStackTop (CardStackPtr stack) { if (stack->last && stack->last->face == CardFaceDown) CardTurn (stack->last, CardFaceUp, True); } /* * Compute a somewhat arbitrary evaluation function for the position: * 2 point per card sitting atop next higher card in same suit * 10 per card turned face up * 15 extra for each column where all cards have been revealed * 50 per completed suit removed (note this costs 12*2 for cards in seq) * If all columns are either empty or contain completed suits, then those * suits also count 50 (including the 24 for the 12 cards that are atop * higher cards), plus an extra 2 for each suit after the first three. * Thus the only way to get 1000 points is to win with all eight suits * still in the tableau. */ static int ComputeScore (void) { int score = 0; int col; CardStackPtr stack; CardPtr card; int numPiles = 0; score = 44 * 10; /* score if all cards flipped */ for (col = 0; col < NUM_PILES; col++) if (pileStacks[col].first) score += 50; for (col = 0; col < NUM_STACKS; col++) { stack = &stackStacks[col]; if ((card = stack->first)) { if (card->face == CardFaceUp) { score += 15; if (card->card.rank == CardsKing && CardInSuitOrder (card) == stack->last && stack->last->card.rank == CardsAce) { score += 50; numPiles++; if (numPiles > 3) score += 2; card = 0; } } } else score += 15; while (card) { if (card->face == CardFaceUp) { if (card->prev && CardIsInSuitOrder (card, card->prev)) score += 2; } else score -= 10; /* still Facedown */ card = card->next; } } return (score); } static void DisplayStacks (void) { int col; CardPtr card, c; CardStackPtr stack; CardDisplayStack (&deckStack); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < NUM_STACKS; col++) { stack = &stackStacks[col]; if (spiderResources.squishCards) { for (card = stack->last; card;) { card->shouldBeUp = True; if (card->face == CardFaceDown) { while (card->prev && card->prev->face == CardFaceDown) { card->shouldBeUp = False; card = card->prev; } } else { c = CardInReverseSuitOrder (card); if (c != card) { while ((card = card->prev) != c) card->shouldBeUp = False; card->shouldBeUp = True; } } card = card->prev; } } CardDisplayStack (stack); } CardsUpdateDisplay (deck); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); } /* User interface functions */ static void ResetDealNumber (void *closure) { dealNumber = (int) (intptr_t) closure; } static void Deal (void) { int col; for (col = 0; col < NUM_STACKS; col++) { if (!deckStack.last) { Message (message, "No more cards in the deck."); return; } CardMove (&deckStack, deckStack.last, &stackStacks[col], True); CheckStackTop (&stackStacks[col]); } CardRecordHistoryCallback (ResetDealNumber, (char *) (intptr_t) dealNumber); Message (message, "Dealt hand %d of 5.", ++dealNumber); } static void NewGame (void) { CardsRemoveAllCards (deck); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); fromStack = 0; fromCard = 0; InitStacks (); GenerateCards (); CardShuffle (&deckStack, False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } static void Score (void) { Message (message, "Current position scores %d out of 1000.", ComputeScore ()); } static void Quit (void) { exit (0); } static CardStackPtr FindFinishPlay (CardStackPtr from_stack, CardPtr from_card) { int i; CardStackPtr to_stack; (void) from_stack; if (from_card->card.rank == CardsKing && CardInSuitOrder (from_card)->card.rank == CardsAce) { for (i = 0; i < NUM_PILES; i++) { to_stack = &pileStacks[i]; if (to_stack->last == NULL) return to_stack; } } return NULL; } static CardStackPtr FindInSuitPlay (CardStackPtr from_stack, CardPtr from_card) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr card; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; card = to_stack->last; if (card && CardIsInSuitOrder (from_card, card)) return to_stack; } return NULL; } static CardStackPtr FindNotInSuitPlay (CardStackPtr from_stack, CardPtr from_card) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr card; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; card = to_stack->last; if (card && CardIsInOrder (from_card, card)) return to_stack; } return NULL; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr from_card) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; (void) from_card; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (to_stack->last == NULL) return to_stack; } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (from_card->face == CardFaceDown) { Message (message, "Card not turned up."); return; } if (CardInSuitOrder (from_card)->next != NULL) { Message (message, "Cards not in order."); return; } if (to_stack != from_stack) { if (to_stack->last != NULL && ! CardIsInOrder (from_card, to_stack->last)) { Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else { if (!(to_stack = FindFinishPlay (from_stack, from_card)) && !(to_stack = FindInSuitPlay (from_stack, from_card)) && !(to_stack = FindNotInSuitPlay (from_stack, from_card)) && !(to_stack = FindEmptyPlay (from_stack, from_card))) { Message (message, "Nowhere to move the %P.", &from_card->card); return; } } CardMove (from_stack, from_card, to_stack, True); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[NUM_STACKS]; to_stack = NULL; for (col = 0; col < NUM_STACKS; col++) goodenough[col] = False; #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ if (goodenough[col]) continue; \ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = CardInReverseSuitOrder (from_stack->last); \ if (!from_card->prev || !already (from_card, from_card->prev)) \ to_stack = func(from_stack, from_card); \ else \ goodenough[col] = True; \ } #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = CardInReverseSuitOrder (from_stack->last); \ to_stack = func(from_stack, from_card); \ } FindOneCheck (CardIsInSuitOrder, FindInSuitPlay); FindOneCheck (CardIsInOrder, FindNotInSuitPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } FindOne (FindFinishPlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } if (deckStack.last) { Message (message, "Deal the next hand."); } else { Message (message, "It's all over."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; if (w == piles) return &pileStacks[col]; if (w == deck) return &deckStack; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; CardPtr card = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; switch (input->action) { case HandActionStart: break; case HandActionClick: CardSetAnimate(True); if (stack == &deckStack) { Deal (); CardNextHistory (); DisplayStacks (); } else if (stack == &deckStack) { } else if (startStack && stack && startStack->last) { card = stack->last; if (w == stacks) card = CardInReverseSuitOrder(card); if (!card) Message(message, "No card selected."); else { Play (stack, card, stack); CheckStackTop (stack); CardNextHistory (); DisplayStacks (); } } break; case HandActionDrag: CardSetAnimate(False); if (startStack == &deckStack || stack == &deckStack) break; if (startStack->last) { CardPtr card = CardFromHandCard(input->start.private); if (!card) Message(message, "No card selected."); else if (input->start.w == piles) { Message(message, "Can't move cards back from pile."); } else { Play (startStack, card, stack); CheckStackTop (startStack); CardNextHistory (); DisplayStacks (); } } break; case HandActionExpand: Expand (stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } XtActionsRec actions[] = { { "spiderUndo", UndoAction, }, { "spiderNewGame", NewGameAction, }, { "spiderScore", ScoreAction, }, { "spiderQuit", QuitAction, }, { "spiderFindAMove", FindAMoveAction, }, { "spiderRestore", RestoreAction, }, { "spiderSave", SaveAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(SpiderResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, { "squishCards", "SquishCards", XtRBoolean, sizeof (Boolean), offset(squishCards), XtRImmediate, (XtPointer) FALSE}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KSpider", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&spiderResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (spiderResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: spiderQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); deck = XtCreateManagedWidget ("deck", cardsWidgetClass, frame, NULL, 0); XtAddCallback (deck, XtNinputCallback, InputCallback, NULL); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stacks, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/ktabby/000077500000000000000000000000001416764561500141175ustar00rootroot00000000000000kgames-2.2/ktabby/KTabby.ad.in000066400000000000000000000031521416764561500162070ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *deck.numCols: 1 *deck.numRows: 1 *piles.numCols: 4 *piles.numRows: 1 *Cards.immediateUpdate: False *stacks.numCols: 4 *stacks.numRows: 7 *stacks.rowsHint: True *stacks.overlap: vertical *tail.numCols: 1 *tail.numRows: 7 *tail.rowsHint: True *tail.overlap: vertical *message.justify: left *message.label: Keith's Tabby Cat, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 5 < -5 > \ pileAll \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ piles < -100% * -90% > \ 10 < +inf -inf > \ deck < -75% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ horizontal { \ 10 < -inf > \ stacks < -50% * +inf -50% > \ 10 < +inf -inf > \ tail < -75% * +inf -50% > \ 10 < -inf > \ } \ message < +inff -100% * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *pileAll.label: Fill Piles *Command.shapeStyle: oval *frame.translations: #override \ u: tabbyUndo()\n\ n: tabbyNewGame()\n\ s: tabbyScore()\n\ ?: tabbyFindAMove() kgames-2.2/ktabby/ktabby.6000066400000000000000000000013571416764561500154700ustar00rootroot00000000000000.TH KTABBY 6 "1992" "Kgames 1.0" .SH NAME ktabby \- X window tabby cat solitaire .SH SYNOPSIS .B ktabby .SH DESCRIPTION .I Ktabby brings up a window for a tabby cat solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down, regardless of suit or color. Full or partial builds may be moved among the tableaus. Empty tableaus may be filled with any available build. Any available build may be moved to the tail, if it is empty. Available builds of thirteen cards, from King down to Ace, may be moved to an empty foundation. .P Deal one card onto each tableau by tapping on the hand. .P Goal: move all cards to the foundations. .SH AUTHOR Keith Packard kgames-2.2/ktabby/ktabby.desktop.in000066400000000000000000000004011416764561500173660ustar00rootroot00000000000000[Desktop Entry] Name=KTabby GenericName=Solitaire Game Comment=Play Tabby Cat solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/ktabby Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/ktabby/meson.build000066400000000000000000000032541416764561500162650ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KTabby.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('ktabby', 'tabby.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('ktabby.6') configure_file(input: 'ktabby.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/ktabby/tabby.c000066400000000000000000000523631416764561500153750ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KTabby-res.h" Widget toplevel; Widget frame; Widget deck; Widget piles; Widget stacks; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; Widget pileAll; Widget tail; #define NUM_DECK 1 #define NUM_STACKS 4 #define NUM_PILES 4 #define NUM_CARDS 52 CardStackRec deckStack; CardStackRec stackStacks[NUM_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardStackRec tailStack; CardRec rawcards[NUM_CARDS]; int dealNumber; typedef struct _tabbyResources { int animationSpeed; } TabbyResources, *TabbyResourcesPtr; TabbyResources tabbyResources; static void InitStacks (void) { int col; CardInitStack (&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); for (col = 0; col < NUM_STACKS; col++) { CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, CardDisplayAll); } CardInitStack (&tailStack, tail, CardsEmpty, False, 0, CardDisplayAll); for (col = 0; col < NUM_PILES; col++) { CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col, CardDisplayTop); } } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS-1]; } #define FIRST_ROWS 1 static void FirstDeal (void) { int row, col; for (row = 0; row < FIRST_ROWS; row++) { for (col = 0; col < NUM_STACKS; col++) CardMove (&deckStack, deckStack.last, &stackStacks[col], False); } for (col = 0; col < NUM_STACKS; col++) CardTurn (stackStacks[col].last, CardFaceUp, False); dealNumber = 0; } static void CheckStackTop (CardStackPtr stack) { if (stack->last && stack->last->face == CardFaceDown) CardTurn (stack->last, CardFaceUp, True); } static int ComputeScore (void) { int col; int score; CardPtr card; score = 0; for (col = 0; col < NUM_PILES; col++) { for (card = pileStacks[col].first; card; card = card->next) { if (card->card.rank < CardsJack) score += (int) card->card.rank; else score += 10; } } return score; } static void DisplayStacks (void) { int col; CardDisplayStack (&deckStack); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < NUM_STACKS; col++) CardDisplayStack (&stackStacks[col]); CardDisplayStack (&tailStack); CardsUpdateDisplay (deck); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); CardsUpdateDisplay (tail); } /* User interface functions */ #define DEAL_COUNT 3 static void Deal (void) { int col; if (!deckStack.last) { Message (message, "No more cards in the deck."); return; } for (col = 0; col < NUM_STACKS; col++) { if (!deckStack.last) break; CardMove (&deckStack, deckStack.last, &stackStacks[col], True); CardTurn (stackStacks[col].last, CardFaceUp, True); } CardNextHistory (); DisplayStacks (); } static void NewGame (void) { CardsRemoveAllCards (deck); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); CardsRemoveAllCards (tail); InitStacks (); GenerateCards (); CardShuffle (&deckStack, False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } #define MAX_SCORE 340 static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static Boolean IsLegalPilePlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (to_stack->last) return False; if (from_card->card.rank == CardsKing && CardInOrder (from_card)->card.rank == CardsAce) return True; return False; } static CardStackPtr FindPilePlay (CardStackPtr from_stack, CardPtr *from_cardp) { CardPtr from_card; int i; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_PILES; i++) { if (IsLegalPilePlay (from_stack, from_card, &pileStacks[i])) { *from_cardp = from_card; return &pileStacks[i]; } } return NULL; } static Boolean IsLegalRegularPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { CardPtr to_card; (void) from_stack; to_card = to_stack->last; if (to_card && CardIsInRingOrder (from_card, to_card)) return True; return False; } static CardStackPtr FindRegularPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseRingOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (IsLegalRegularPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static Boolean IsLegalTailPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; (void) from_card; if (to_stack->last == NULL) return True; return False; } static CardStackPtr FindTailPlay (CardStackPtr from_stack, CardPtr *from_cardp) { CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseRingOrder (from_stack->last); else return NULL; if (IsLegalTailPlay (from_stack, from_card, &tailStack)) { *from_cardp = from_card; return &tailStack; } return NULL; } static Boolean IsLegalEmptyPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; (void) from_card; if (to_stack->last == NULL) return True; return False; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr *from_cardp) { int i; int col = from_stack - stackStacks; CardStackPtr to_stack; CardPtr from_card; if (*from_cardp) from_card = *from_cardp; else if (from_stack->last) from_card = CardInReverseRingOrder (from_stack->last); else return NULL; for (i = 0; i < NUM_STACKS; i++) { if (i == col) continue; to_stack = &stackStacks[i]; if (IsLegalEmptyPlay (from_stack, from_card, to_stack)) { *from_cardp = from_card; return to_stack; } } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (from_card && from_card->face == CardFaceDown) { Message (message, "Card not turned up."); return; } if (from_card && CardInRingOrder (from_card)->next != NULL) { Message (message, "Cards not in order."); return; } if (to_stack != from_stack) { if (to_stack->widget == stacks) { if (!from_card) from_card = CardInReverseRingOrder (from_stack->last); if (!IsLegalRegularPlay (from_stack, from_card, to_stack) && !IsLegalEmptyPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty pile.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == tail) { if (!from_card) from_card = CardInReverseRingOrder (from_stack->last); if (!IsLegalTailPlay (from_stack, from_card, to_stack)) { Message (message, "Can't move the %P to the tail.", &from_card->card); return; } } else if (to_stack->widget == piles) { if (!from_card) from_card = CardInReverseRingOrder (from_stack->last); if (!IsLegalPilePlay (from_stack, from_card, to_stack)) { Message (message, "Can't move the %P to a pile.", &from_card->card); return; } } else { Message (message, "Can't move cards back to the deck."); return; } } else { if (!from_card && !from_stack->last) { Message (message, "No cards there."); return; } if (!(to_stack = FindPilePlay (from_stack, &from_card)) && !(to_stack = FindRegularPlay (from_stack, &from_card)) && !(to_stack = FindEmptyPlay (from_stack, &from_card)) && !(to_stack = FindTailPlay (from_stack, &from_card))) { Message (message, "Not a valid move."); return; } } CardMove (from_stack, from_card, to_stack, True); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); else Message(message, ""); CheckStackTop (from_stack); CardNextHistory (); DisplayStacks (); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static Boolean AlreadyInOrder (CardPtr a, CardPtr b) { if (a && b && CardIsInRingOrder (a,b)) return True; return False; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[NUM_STACKS]; to_stack = NULL; for (col = 0; col < NUM_STACKS; col++) goodenough[col] = False; #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ if (goodenough[col]) continue; \ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = CardInReverseRingOrder (from_stack->last); \ if (!already (from_card, from_card->prev)) \ to_stack = func(from_stack, &from_card); \ else \ goodenough[col] = True; \ } \ #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, &from_card); \ } \ FindOneCheck (AlreadyInOrder, FindRegularPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } FindOne (FindPilePlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } FindOne (FindTailPlay); if (to_stack) { Message (message, "Move the %P to the tail.", &from_card->card); return; } if (deckStack.last) { Message (message, "Deal."); } else { Message (message, "It's all over."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void PileAll (void) { CardStackPtr from_stack; CardPtr from_card; CardStackPtr to_stack; int col; Boolean done = False; Message (message, ""); do { to_stack = 0; FindOne (FindPilePlay); if (to_stack) { Play (from_stack, from_card, to_stack); done = True; CheckStackTop (from_stack); CardNextHistory (); DisplayStacks (); } } while (to_stack); if (!done) Message (message, "No cards to pile."); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInRingOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; if (w == piles) return &pileStacks[col]; if (w == deck) return &deckStack; if (w == tail) return &tailStack; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; switch (input->action) { case HandActionStart: break; case HandActionClick: CardSetAnimate(True); if (stack == &deckStack) Deal (); else Play(stack, NULL, stack); break; case HandActionDrag: CardSetAnimate(False); if (startStack == &deckStack) { if (&stackStacks[0] <= stack && stack < &stackStacks[NUM_STACKS]) Deal (); } else if (input->start.private) { CardPtr card = CardFromHandCard(input->start.private); Play (startStack, card, stack); } break; case HandActionExpand: Expand (stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void PileAllCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; PileAll (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void PileAllAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; PileAll (); } XtActionsRec actions[] = { { "tabbyUndo", UndoAction, }, { "tabbyNewGame", NewGameAction, }, { "tabbyScore", ScoreAction, }, { "tabbyQuit", QuitAction, }, { "tabbyFindAMove", FindAMoveAction, }, { "tabbyRestore", RestoreAction, }, { "tabbySave", SaveAction, }, { "tabbyPileAll", PileAllAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(TabbyResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KTabby", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&tabbyResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (tabbyResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: tabbyQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); pileAll = XtCreateManagedWidget ("pileAll", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(pileAll, XtNcallback, PileAllCallback, NULL); deck = XtCreateManagedWidget ("deck", cardsWidgetClass, frame, NULL, 0); XtAddCallback (deck, XtNinputCallback, InputCallback, NULL); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); XtAddCallback (piles, XtNinputCallback, InputCallback, NULL); stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stacks, XtNinputCallback, InputCallback, NULL); tail = XtCreateManagedWidget ("tail", cardsWidgetClass, frame, NULL, 0); XtAddCallback (tail, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/kthieves/000077500000000000000000000000001416764561500144655ustar00rootroot00000000000000kgames-2.2/kthieves/KThieves.ad.in000066400000000000000000000032341416764561500171240ustar00rootroot00000000000000*Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *draw.numCols: 15 *draw.colsHint: true *draw.overlap: horizontal *piles.numCols: 2 *piles.numRows: 4 *Cards.immediateUpdate: False *stacks.numCols: 10 *stacks.numRows: 10 *stacks.rowsHint: True *stacks.overlap: vertical *message.justify: left *message.label: Keith's Forty Thieves, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ vertical { \ stacks < -50% * +inf -50% > \ 10 < -inf > \ horizontal { \ vertical { \ 10 < +inf -inf > \ draw < +inf -100% * -90% > \ } \ 10 < -inf > \ vertical { \ deckCount < +inf -inf * > \ deck < -75% * -90% > \ } \ } \ } \ 10 < -inf > \ vertical { \ piles < -50% * -50% > \ 0 < +inf > \ } \ 10 < -inf > \ } \ message < +inff -100% * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *Command.shapeStyle: oval *frame.translations: #override \ u: thievesUndo()\n\ n: thievesNewGame()\n\ s: thievesScore()\n\ ?: thievesFindAMove() kgames-2.2/kthieves/kthieves.6000066400000000000000000000011621416764561500163760ustar00rootroot00000000000000.TH KTHIEVES 6 "1992" "Kgames 1.0" .SH NAME kthieves \- X window forty thieves solitaire .SH SYNOPSIS .B kthieves .SH DESCRIPTION .I Kthieves brings up a window for a forty thieves solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down in suit. Foundations build up in suit. You may move one card at a time from the discard to a tableau, from the tableau to a foundation or between tableaus. .P Deal one card onto the discard pile by clicking the deck. .P Goal: move all cards to the foundations. .SH AUTHOR Keith Packard kgames-2.2/kthieves/kthieves.desktop.in000066400000000000000000000004061416764561500203070ustar00rootroot00000000000000[Desktop Entry] Name=KThieves GenericName=Solitaire Game Comment=Play 40 Thieves solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/kthieves Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/kthieves/meson.build000066400000000000000000000032661416764561500166360ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KThieves.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('kthieves', 'thieves.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('kthieves.6') configure_file(input: 'kthieves.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/kthieves/thieves.c000066400000000000000000000455221416764561500163100ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KThieves-res.h" Widget toplevel; Widget frame; Widget deck; Widget draw; Widget piles; Widget stacks; Widget message; Widget deckCount; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; #define MAX_STACKS 104 #define DEF_NUM_STACKS 10 #define NUM_PILES 8 #define NUM_CARDS 104 #define DEF_FIRST_ROWS 4 CardStackRec deckStack; CardStackRec stackStacks[MAX_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardStackRec drawStack; CardRec rawcards[NUM_CARDS]; CardStackPtr fromStack; CardPtr fromCard; int dealNumber; typedef struct _thievesResources { int animationSpeed; Boolean squishCards; int numColumns; int numRows; } ThievesResources, *ThievesResourcesPtr; ThievesResources thievesResources; #define numStacks thievesResources.numColumns #define firstRows thievesResources.numRows static void InitStacks (void) { int col; int row; CardDisplay display; for (col = 0; col < numStacks; col++) { display = CardDisplayAll; if (thievesResources.squishCards) display = CardDisplaySome; CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, display); } for (col = 0; col < NUM_PILES; col++) { row = col >> 1; CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col & 1, CardDisplayTop); pileStacks[col].basePosition = row; } CardInitStack (&deckStack, deck, CardsEmpty, False, 0, CardDisplayBottom); CardInitStack (&drawStack, draw, CardsNone, True, 0, CardDisplayAll); } static void GenerateCards (void) { int i; CardPtr card; card = rawcards; for (i = 0; i < 2; i++) { CardGenerateStandardDeck (card); card += 52; } rawcards[51].next = &rawcards[52]; rawcards[52].prev = &rawcards[51]; deckStack.first = &rawcards[0]; deckStack.last = &rawcards[NUM_CARDS-1]; } static void FirstDeal (void) { int row, col; for (row = 0; row < firstRows; row++) { for (col = 0; col < numStacks; col++) { CardMove (&deckStack, deckStack.last, &stackStacks[col], False); CardTurn (stackStacks[col].last, CardFaceUp, False); } } dealNumber = (52 * 2) - (firstRows * numStacks); Message (deckCount, "%d", dealNumber); } /* * Score: each card played on the right counts as its face value ace ==> 1 duece ==> 2 10 ==> 10 jack ==> 11 queen ==> 12 king ==> 13 Just total up the points and that is the score. a winning game has 728 points. */ static int ComputeScore (void) { int score = 0; int col; CardStackPtr pile; CardPtr card; for (col = 0; col < NUM_PILES; col++) { pile = &pileStacks[col]; for (card = pile->first; card; card = card->next) score += CardsRankToInt (card->card.rank) + 1; } return (score); } static void DisplayStacks (void) { int col; CardPtr card, c; CardStackPtr stack; CardDisplayStack (&deckStack); CardDisplayStack (&drawStack); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < numStacks; col++) { stack = &stackStacks[col]; if (thievesResources.squishCards) { for (card = stack->last; card;) { card->shouldBeUp = True; if (card->face == CardFaceDown) { while (card->prev && card->prev->face == CardFaceDown) { card->shouldBeUp = False; card = card->prev; } } else { c = CardInReverseSuitOrder (card); if (c != card) { while ((card = card->prev) != c) card->shouldBeUp = False; card->shouldBeUp = True; } } card = card->prev; } } CardDisplayStack (stack); } CardsUpdateDisplay (deck); CardsUpdateDisplay (draw); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); } /* User interface functions */ static void ResetDealNumber (void *closure) { dealNumber = (int) (intptr_t) closure; Message (deckCount, "%d", dealNumber); } static void Deal (void) { if (!deckStack.last) { Message (message, "No more cards in the deck."); return; } CardMove (&deckStack, deckStack.last, &drawStack, True); CardTurn (drawStack.last, CardFaceUp, True); CardRecordHistoryCallback (ResetDealNumber, (char *) (intptr_t) dealNumber); Message (deckCount, "%d", --dealNumber); } static void NewGame (void) { CardsRemoveAllCards (deck); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); CardsRemoveAllCards (draw); fromStack = 0; fromCard = 0; InitStacks (); GenerateCards (); CardShuffle (&deckStack, False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } #define MAX_SCORE 728 static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static CardStackPtr FindFinishPlay (CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_PILES; i++) { to_stack = &pileStacks[i]; if ((from_card->card.rank == CardsAce && to_stack->last == NULL) || (to_stack->last && CardIsInSuitOrder (to_stack->last, from_card))) { return to_stack; } } return NULL; } static CardStackPtr FindStackPlay (CardPtr from_card) { int i; CardStackPtr to_stack; CardPtr card; for (i = 0; i < numStacks; i++) { to_stack = &stackStacks[i]; card = to_stack->last; if (card && CardIsInOrder (from_card, card)) return to_stack; } return NULL; } static CardStackPtr FindEmptyPlay (CardPtr from_card) { int i; CardStackPtr to_stack; (void) from_card; for (i = 0; i < numStacks; i++) { to_stack = &stackStacks[i]; if (to_stack->last == NULL) return to_stack; } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (to_stack != from_stack) { if (to_stack->last != NULL && ! CardIsInOrder (from_card, to_stack->last)) { Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else { if (!(to_stack = FindFinishPlay (from_card)) && !(to_stack = FindStackPlay (from_card)) && !(to_stack = FindEmptyPlay (from_card))) { Message (message, "Nowhere to move the %P.", &from_card->card); return; } } CardMove (from_stack, from_card, to_stack, True); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); } static Boolean AlreadyEmpty (CardPtr a, CardPtr b) { (void) a; return !b; } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; Boolean goodenough[MAX_STACKS]; to_stack = NULL; for (col = 0; col < numStacks; col++) goodenough[col] = False; #define FindOneInStack(from_stack,func) \ if ((from_card = (from_stack)->last)) \ to_stack = func(from_card); #define FindOneCheck(already, func) \ for (col = 0; !to_stack && col < numStacks; col++) {\ if (goodenough[col]) continue; \ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ if (!from_card->prev || !already (from_card, from_card->prev)) \ to_stack = func(from_card); \ else \ goodenough[col] = True; \ } \ if (!to_stack) { \ FindOneInStack (&drawStack,func); \ } #define FindOne(func) \ for (col = 0; !to_stack && col < numStacks; col++) {\ from_stack = &stackStacks[col]; \ FindOneInStack(from_stack,func); \ } \ if (!to_stack) { \ FindOneInStack (&drawStack,func); \ } FindOneCheck (CardIsInSuitOrder, FindStackPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOne (FindFinishPlay); if (to_stack) { Message (message, "Move the %P to the finish.", &from_card->card); return; } FindOneCheck (AlreadyEmpty, FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } if (deckStack.last) { Message (message, "Deal the next card."); } else { Message (message, "It's all over."); } } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; if (w == piles) return &pileStacks[col]; if (w == draw) return &drawStack; if (w == deck) return &deckStack; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; CardPtr card = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; CardSetAnimate(True); switch (input->action) { case HandActionStart: break; case HandActionDrag: if (startStack == stack) break; CardSetAnimate(False); /* fall through */ case HandActionClick: if (startStack == &deckStack) { if (stack == &deckStack) { Deal (); CardNextHistory (); DisplayStacks (); } } else if (stack == &deckStack) { } else { card = startStack->last; if (card) { Play (startStack, card, stack); CardNextHistory (); DisplayStacks (); } } break; case HandActionExpand: Expand (stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } XtActionsRec actions[] = { { "thievesUndo", UndoAction, }, { "thievesNewGame", NewGameAction, }, { "thievesScore", ScoreAction, }, { "thievesQuit", QuitAction, }, { "thievesFindAMove", FindAMoveAction, }, { "thievesRestore", RestoreAction, }, { "thievesSave", SaveAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(ThievesResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, { "squishCards", "SquishCards", XtRBoolean, sizeof (Boolean), offset(squishCards), XtRImmediate, (XtPointer) FALSE}, { "numColumns", "NumColumns", XtRInt, sizeof (int), offset(numColumns), XtRImmediate, (XtPointer) DEF_NUM_STACKS}, { "numRows", "NumRows", XtRInt, sizeof (int), offset(numRows), XtRImmediate, (XtPointer) DEF_FIRST_ROWS}, }; XrmOptionDescRec options[] = { { "-squish", "*squishCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL, }, { "-cols", ".numColumns", XrmoptionSepArg, NULL, }, { "-rows", ".numRows", XrmoptionSepArg, NULL, }, }; int main (int argc, char **argv) { Arg args[20]; int nargs; Atom wm_delete_window; toplevel = XkwInitialize ("KThieves", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&thievesResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (thievesResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: thievesQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); deck = XtCreateManagedWidget ("deck", cardsWidgetClass, frame, NULL, 0); deckCount = XtCreateManagedWidget ("deckCount", klabelWidgetClass, frame, NULL, 0); XtAddCallback (deck, XtNinputCallback, InputCallback, NULL); draw = XtCreateManagedWidget ("draw", cardsWidgetClass, frame, NULL, 0); XtAddCallback (draw, XtNinputCallback, InputCallback, NULL); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); nargs = 0; XtSetArg (args[nargs], XtNnumCols, numStacks); nargs++; stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, args, nargs); XtAddCallback (stacks, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/ktowers/000077500000000000000000000000001416764561500143415ustar00rootroot00000000000000kgames-2.2/ktowers/KTowers.ad.in000066400000000000000000000027111416764561500166530ustar00rootroot00000000000000*Command.shapeStyle: oval *Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *suits.numCols: 4 *suits.numRows: 1 *deck.numRows: 1 *piles.numCols: 4 *piles.numRows: 1 *Cards.immediateUpdate: False *stacks.numCols: 10 *stacks.numRows: 7 *stacks.rowsHint: True *stacks.overlap: vertical *message.justify: left *message.label: Keith's Towers, Version @KGAMES_VERSION@ *menuBar.layout: vertical { \ 5 < -5 >\ horizontal { \ 5 < -5 > \ fileMenuButton \ 5 < -5 > \ newGame \ 5 < -5 > \ undo \ 5 < -5 > \ hint \ 5 < -5 > \ score \ 5 < -5 > \ pileAll \ 0 <+inf -inf> \ } \ 5 < -5 > \ } *frame.layout: vertical {\ menuBar < +inff -100% * >\ 10 < -inf > \ horizontal { \ 10 < -inf > \ suits < -75% * -90% > \ 10 < +inf -inf > \ piles < -100% * -90% > \ 10 < -inf > \ } \ 10 < -inf > \ stacks < -50% * +inf -50% > \ message < +inff -100% * > \ } *fileMenuButton.leftBitmap: menu12 *fileMenuButton.menuName: fileMenu *fileMenuButton.label: File *fileMenuButton.shapeStyle: oval *fileMenu.save.label: Save To File *fileMenu.restore.label: Restore From File *fileMenu.quit.label: Quit *newGame.label: New Game *undo.label: Undo *hint.label: Hint *score.label: Score *pileAll.label: Fill Piles *frame.translations: #override \ u: ktowersUndo()\n\ n: ktowersNewGame()\n\ s: ktowersScore()\n\ ?: ktowersFindAMove() kgames-2.2/ktowers/ktowers.6000066400000000000000000000010721416764561500161260ustar00rootroot00000000000000.TH KTOWERS 6 "1992" "Kgames 1.0" .SH NAME ktowers \- X window towers solitaire .SH SYNOPSIS .B ktowers .SH DESCRIPTION .I Ktowers brings up a window for a towers solatiaire game. Clicking on a card moves it to the "best" legal play. Dragging a card places it (if legal) in the target stack. .SH RULES Tableaus build down in suit order. Single cards may be moved among the tableaus. Empty tableaus may be filled with Kings. Stocks hold any single card each. Foundations build up in suit from the Ace. .P Goal: move all cards to the foundations. .SH AUTHOR Keith Packard kgames-2.2/ktowers/ktowers.c000066400000000000000000000456561416764561500162230ustar00rootroot00000000000000/* * $NCD$ * * Copyright 1992 Network Computing Devices * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of NCD. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. NCD. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: Keith Packard, Network Computing Devices */ # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "KTowers-res.h" Widget toplevel; Widget frame; Widget piles; Widget stacks; Widget suits; Widget message; Widget menuBar; Widget fileMenuButton; Widget fileMenu; Widget newGame; Widget undo; Widget hint; Widget score; Widget pileAll; #define NUM_STACKS 10 #define NUM_PILES 4 #define NUM_SUITS 4 #define NUM_CARDS 52 CardStackRec stackStacks[NUM_STACKS]; CardStackRec pileStacks[NUM_PILES]; CardStackRec suitStacks[NUM_SUITS]; CardRec rawcards[NUM_CARDS]; CardStackPtr fromStack; CardPtr fromCard; typedef struct _ktowersResources { int animationSpeed; } KtowersResources, *KtowersResourcesPtr; KtowersResources ktowersResources; static void InitStacks (void) { int col; for (col = 0; col < NUM_STACKS; col++) { CardInitStack (&stackStacks[col], stacks, CardsNone, False, col, CardDisplayAll); } for (col = 0; col < NUM_PILES; col++) { CardInitStack (&pileStacks[col], piles, CardsEmpty, False, col, CardDisplayTop); } for (col = 0; col < NUM_SUITS; col++) { CardInitStack (&suitStacks[col], suits, CardsEmpty, False, col, CardDisplayTop); } } static void GenerateCards (void) { CardGenerateStandardDeck (rawcards); suitStacks[0].first = &rawcards[0]; suitStacks[0].last = &rawcards[NUM_CARDS-1]; } #define FIRST_ROWS 5 static void FirstDeal (void) { int row, col; for (row = 0; row < FIRST_ROWS; row++) { for (col = 0; col < NUM_STACKS; col++) { CardMove (&suitStacks[0], suitStacks[0].last, &stackStacks[col], False); CardTurn (stackStacks[col].last, CardFaceUp, False); } } col = 1; while (suitStacks[0].last) { CardMove (&suitStacks[0], suitStacks[0].last, &pileStacks[col], False); CardTurn (pileStacks[col].last, CardFaceUp, False); col++; } } static int ComputeScore (void) { int col; int score; CardPtr card; score = 0; for (col = 0; col < NUM_SUITS; col++) { for (card = suitStacks[col].first; card; card = card->next) { if (card->card.rank < CardsJack) score += (int) card->card.rank; else score += 10; } } return score; } static void DisplayStacks (void) { int col; for (col = 0; col < NUM_SUITS; col++) CardDisplayStack (&suitStacks[col]); for (col = 0; col < NUM_PILES; col++) CardDisplayStack (&pileStacks[col]); for (col = 0; col < NUM_STACKS; col++) CardDisplayStack (&stackStacks[col]); CardsUpdateDisplay (suits); CardsUpdateDisplay (piles); CardsUpdateDisplay (stacks); } /* User interface functions */ static void NewGame (void) { CardsRemoveAllCards (suits); CardsRemoveAllCards (piles); CardsRemoveAllCards (stacks); fromStack = 0; fromCard = 0; InitStacks (); GenerateCards (); CardShuffle (&suitStacks[0], False); FirstDeal (); CardInitHistory (); DisplayStacks (); } static void Undo (void) { if (!CardUndo ()) Message (message, "Nothing to undo."); DisplayStacks (); } #define MAX_SCORE 340 static void Score (void) { Message (message, "Current position scores %d out of %d.", ComputeScore (), MAX_SCORE); } static void Quit (void) { exit (0); } static Boolean IsLegalSuitPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (from_card->card.rank == CardsAce) { if (to_stack->last == NULL) return True; } else { if (to_stack->last != NULL && CardIsInSuitOrder (to_stack->last, from_card)) return True; } return False; } static CardStackPtr FindSuitPlay (CardStackPtr from_stack, CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_SUITS; i++) { to_stack = &suitStacks[i]; if (IsLegalSuitPlay (from_stack, from_card, to_stack)) return to_stack; } return NULL; } static Boolean IsLegalPilePlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; (void) from_card; if (to_stack->last == NULL) return True; return False; } static CardStackPtr FindPilePlay (CardStackPtr from_stack, CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_PILES; i++) { to_stack = &pileStacks[i]; if (IsLegalPilePlay (from_stack, from_card, to_stack)) return to_stack; } return NULL; } static Boolean IsLegalRegularPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { CardPtr to_card; (void) from_stack; to_card = to_stack->last; if (to_card && CardIsInSuitOrder (from_card, to_card)) return True; return False; } static CardStackPtr FindRegularPlay (CardStackPtr from_stack, CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_STACKS; i++) { to_stack = &stackStacks[i]; if (IsLegalRegularPlay (from_stack, from_card, to_stack)) return to_stack; } return NULL; } static Boolean IsLegalEmptyPlay (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { (void) from_stack; if (from_card->card.rank == CardsKing && to_stack->last == NULL) return True; return False; } static CardStackPtr FindEmptyPlay (CardStackPtr from_stack, CardPtr from_card) { int i; CardStackPtr to_stack; for (i = 0; i < NUM_STACKS; i++) { to_stack = &stackStacks[i]; if (IsLegalEmptyPlay (from_stack, from_card, to_stack)) return to_stack; } return NULL; } static void Play (CardStackPtr from_stack, CardPtr from_card, CardStackPtr to_stack) { if (!from_card) { from_card = from_stack->last; if (!from_card) { Message (message, "No cards there."); return; } } if (to_stack != from_stack) { if (to_stack->widget == stacks) { if (!IsLegalRegularPlay (from_stack, from_card, to_stack) && !IsLegalEmptyPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty pile.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == piles) { if (!IsLegalPilePlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty stack.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } else if (to_stack->widget == suits) { if (!IsLegalSuitPlay (from_stack, from_card, to_stack)) { if (!to_stack->last) Message (message, "Can't move the %P to an empty suit.", &from_card->card); else Message (message, "Can't move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } } } else { if (!(to_stack = FindSuitPlay (from_stack, from_card)) && !(to_stack = FindRegularPlay (from_stack, from_card)) && !(to_stack = FindEmptyPlay (from_stack, from_card)) && !(to_stack = FindPilePlay (from_stack, from_card))) { Message (message, "Not a valid move."); return; } } CardMove (from_stack, from_card, to_stack, True); if (ComputeScore() == MAX_SCORE) Message(message, "We have a winner!"); } static void FindAMove (void) { int col; CardStackPtr from_stack, to_stack; CardPtr from_card; to_stack = NULL; #define FindOne(func) \ for (col = 0; !to_stack && col < NUM_STACKS; col++) {\ from_stack = &stackStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, from_card); \ } \ for (col = 0; !to_stack && col < NUM_PILES; col++) {\ from_stack = &pileStacks[col]; \ if (!from_stack->last) continue; \ from_card = from_stack->last; \ to_stack = func(from_stack, from_card); \ } FindOne (FindSuitPlay); if (to_stack) { if (to_stack->last) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); } else { Message (message, "Move the %P", &from_card->card); } return; } FindOne (FindRegularPlay); if (to_stack) { Message (message, "Move the %P to the %P.", &from_card->card, &to_stack->last->card); return; } FindOne (FindEmptyPlay); if (to_stack) { Message (message, "Move the %P to column %d", &from_card->card, to_stack - stackStacks + 1); return; } FindOne (FindPilePlay); if (to_stack) { Message (message, "Move the %P to a pile.", &from_card->card); return; } Message (message, "It's all over."); } static void Restore (void) { Message (message, "Restore not implemented"); } static void Save (void) { Message (message, "Save not implemented"); } static void PileAll (void) { CardStackPtr from_stack; CardPtr from_card; CardStackPtr to_stack; int col; Boolean done = False; Message (message, ""); do { to_stack = 0; FindOne (FindSuitPlay); if (to_stack) { Play (from_stack, from_card, to_stack); done = True; CardNextHistory (); DisplayStacks (); } } while (to_stack); if (!done) Message (message, "No cards to pile."); } static void Expand (CardStackPtr stack) { CardPtr card, t; if ((card = stack->first)) { MessageStart (); MessageAppend ("Column contains:"); while (card) { if (card->face == CardFaceUp) { MessageAppend (" %p", &card->card); t = CardInSuitOrder (card); if (t != card && t != card->next) { card = t; MessageAppend ("-%p", &card->card); } } card = card->next; } MessageAppend ("."); MessageEnd (message); } else Message (message, "Column is empty"); } /* Callbacks to user interface functions */ static CardStackPtr WidgetToStack(Widget w, int col) { if (w == stacks) return &stackStacks[col]; else if (w == suits) return &suitStacks[col]; else if (w == piles) return &pileStacks[col]; return NULL; } static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; CardStackPtr stack = NULL; CardStackPtr startStack = NULL; CardPtr card = NULL; (void) closure; Message (message, ""); stack = WidgetToStack(w, input->current.col); startStack = WidgetToStack(input->start.w, input->start.col); if (!startStack || !stack) return; CardSetAnimate(True); switch (input->action) { case HandActionStart: break; case HandActionDrag: if (startStack == stack) break; CardSetAnimate(False); /* fall through */ case HandActionClick: card = startStack->last; Play (startStack, card, stack); CardNextHistory (); DisplayStacks (); break; case HandActionExpand: Expand (stack); break; case HandActionUnexpand: break; } } static void NewGameCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; NewGame (); } static void QuitCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Quit (); } static void ScoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Score (); } static void UndoCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Undo (); } static void FindAMoveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; FindAMove (); } static void RestoreCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Restore (); } static void SaveCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; Save (); } static void PileAllCallback (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; PileAll (); } /* actions to user interface functions */ static void UndoAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Undo (); } static void NewGameAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; NewGame (); } static void ScoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Score (); } static void QuitAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Quit (); } static void FindAMoveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; FindAMove (); } static void RestoreAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Restore (); } static void SaveAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Save (); } static void PileAllAction (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; PileAll (); } XtActionsRec actions[] = { { "ktowersUndo", UndoAction, }, { "ktowersNewGame", NewGameAction, }, { "ktowersScore", ScoreAction, }, { "ktowersQuit", QuitAction, }, { "ktowersFindAMove", FindAMoveAction, }, { "ktowersRestore", RestoreAction, }, { "ktowersSave", SaveAction, }, { "ktowersPileAll", PileAllAction, }, }; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; struct menuEntry fileMenuEntries[] = { { "restore", RestoreCallback, }, { "save", SaveCallback, }, { "quit", QuitCallback, }, }; static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } #define offset(field) XtOffsetOf(KtowersResources, field) XtResource resources[] = { { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) -1}, }; XrmOptionDescRec options[] = { { "-smallCards", "*Cards.smallCards", XrmoptionNoArg, "True", }, { "-squareCards", "*Cards.roundCards", XrmoptionNoArg, "False", }, { "-noanimate", "*animationSpeed", XrmoptionNoArg, "0", }, { "-animationSpeed", "*animationSpeed", XrmoptionSepArg, NULL }, }; int main (int argc, char **argv) { Atom wm_delete_window; toplevel = XkwInitialize ("KTowers", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources (toplevel, (XtPointer)&ktowersResources, resources, XtNumber (resources), NULL, 0); AnimateSetSpeed (ktowersResources.animationSpeed); XtAddActions (actions, XtNumber(actions)); XtOverrideTranslations (toplevel, XtParseTranslationTable ("WM_PROTOCOLS: ktowersQuit()")); frame = XtCreateManagedWidget ("frame", layoutWidgetClass, toplevel, NULL, 0); menuBar = XtCreateManagedWidget ("menuBar", layoutWidgetClass, frame, NULL, 0); fileMenuButton = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menuBar, NULL, ZERO); fileMenu = CreateMenu (fileMenuButton, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); newGame = XtCreateManagedWidget ("newGame", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(newGame, XtNcallback, NewGameCallback, NULL); undo = XtCreateManagedWidget ("undo", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(undo, XtNcallback, UndoCallback, NULL); hint = XtCreateManagedWidget ("hint", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(hint, XtNcallback, FindAMoveCallback, NULL); score = XtCreateManagedWidget ("score", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(score, XtNcallback, ScoreCallback, NULL); pileAll = XtCreateManagedWidget ("pileAll", kcommandWidgetClass, menuBar, NULL, ZERO); XtAddCallback(pileAll, XtNcallback, PileAllCallback, NULL); suits = XtCreateManagedWidget ("suits", cardsWidgetClass, frame, NULL, 0); XtAddCallback (suits, XtNinputCallback, InputCallback, NULL); piles = XtCreateManagedWidget ("piles", cardsWidgetClass, frame, NULL, 0); XtAddCallback (piles, XtNinputCallback, InputCallback, NULL); stacks = XtCreateManagedWidget ("stacks", cardsWidgetClass, frame, NULL, 0); XtAddCallback (stacks, XtNinputCallback, InputCallback, NULL); message = XtCreateManagedWidget ("message", klabelWidgetClass, frame, NULL, 0); srandom (getpid () ^ time ((long *) 0)); NewGame (); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom(XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XkwSetCardIcon(toplevel); XtMainLoop (); } kgames-2.2/ktowers/ktowers.desktop.in000066400000000000000000000004111416764561500200330ustar00rootroot00000000000000[Desktop Entry] Name=KTowers GenericName=Solitaire Game Comment=Play Seahaven Towers solitaire Keywords=game;card;solitaire;patience Exec=@BINDIR@/ktowers Icon=@ICONDIR@/kgames.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/ktowers/meson.build000066400000000000000000000032621416764561500165060ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'KTowers.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) executable('ktowers', 'ktowers.c', res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('ktowers.6') configure_file(input: 'ktowers.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/meson.build000066400000000000000000000100711416764561500150040ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # project('kgames', 'c', license : 'MIT', version: '2.2', default_options: [ 'bindir=games', 'datadir=share', 'warning_level=3', 'buildtype=debugoptimized', ]) c_compiler = meson.get_compiler('c') lib_m = c_compiler.find_library('m') lib_x11 = dependency('x11') lib_xmu = dependency('xmu') lib_xpm = dependency('xpm') lib_xt = dependency('xt') lib_xaw = dependency('xaw7') lib_render = dependency('xrender') lib_freetype = dependency('freetype2') lib_fontconfig = dependency('fontconfig') lib_cairo = dependency('cairo') lib_cairo_ft = dependency('cairo-ft') lib_xft = dependency('xft') lib_rsvg2 = dependency('librsvg-2.0') x_libs = [lib_xft, lib_cairo_ft, lib_rsvg2, lib_cairo, lib_fontconfig, lib_freetype, lib_render, lib_xaw, lib_xt, lib_xmu, lib_xpm, lib_x11, lib_m] prefix = get_option('prefix') datadir = get_option('datadir') bindir = get_option('bindir') svg_icon_dir = datadir / 'icons/hicolor/scalable/apps' desktop_dir = datadir / 'applications' menudir = get_option('menudir') if menudir == '' if get_option('user-menu') fs = import('fs') xdg_config_dir = fs.expanduser('~/.config') message('user-menu config_dir is ' + xdg_config_dir) else xdg_config_dir= get_option('sysconfdir') / 'xdg' endif menudir = xdg_config_dir / 'menus/applications-merged' endif message('menudir is ' + menudir) conf_data = configuration_data() conf_data.set('KGAMES_VERSION', meson.project_version(), description: 'KGames version in unquoted string form.') conf_data.set('KGAMES_VERSION_STRING', '"@0@"'.format(meson.project_version()), description: 'KGames version in quoted string form.') conf_data.set('BINDIR', prefix / bindir) conf_data.set('ICONDIR', prefix / svg_icon_dir) conf_data.set('MENUDIR', menudir) inc_dirs = ['.'] inc = include_directories(inc_dirs) c_warnings = ['-Werror=implicit-function-declaration', '-Werror=vla', '-Warray-bounds', '-Wold-style-definition', '-Wno-overlength-strings', '-fstack-protector-strong', '-Werror=format', '-Werror=format-security', '-Werror-date-time', '-D_FORTIFY_SOURCE=2', ] add_project_arguments(c_compiler.get_supported_arguments(c_warnings), language : 'c') configure_file(output : 'kgames.h', configuration: conf_data, install: false) configure_file(input: 'kgames.directory.in', output: '@BASENAME@', configuration: conf_data, install_dir : datadir / 'desktop-directories' ) configure_file(input: 'kgames.menu.in', output: '@BASENAME@', configuration: conf_data, install_dir : menudir ) subdir('Xkw') subdir('kaces') subdir('kcanfield') subdir('kcribbage') subdir('kdominos') subdir('kklondike') subdir('kmcarlo') subdir('kmontana') subdir('kslyfox') subdir('kspider') subdir('ktabby') subdir('kthieves') subdir('ktowers') subdir('xmille') subdir('xreversi') meson.add_install_script('update-menus.sh') kgames-2.2/meson_options.txt000066400000000000000000000003121416764561500162740ustar00rootroot00000000000000option('user-menu', type: 'boolean', value: true, description: 'Install menu file only for current user') option('menudir', type: 'string', description: 'Install directory for menu file') kgames-2.2/netcards/000077500000000000000000000000001416764561500144465ustar00rootroot00000000000000kgames-2.2/netcards/design000066400000000000000000000012561416764561500156460ustar00rootroot00000000000000Cards server contains rules of the games Cards clients do layout and display. Protocol consists of Cards server manipulating objects in the Cards clients, and Cards clients sending user input to the server. Rules: Keep game policy out of the Cards clients Keep hidden information out of the Cards clients Keep user interface out of the Cards server Objects: Cards Stacks Grouped or flat? Text information RO and RW and grouped (take the floor mode) Commands in catagories (i.e. list of pull down menus). Layouts. Simple association between stacks and text information boxes. client -> server Card source/dest server -> client Move cards Label cards Flip cards kgames-2.2/update-menus.sh000077500000000000000000000024101416764561500156060ustar00rootroot00000000000000#!/bin/sh # # Copyright © 2021 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # if [ "$DISPLAY" != "" ] && command -v xdg-desktop-menu > /dev/null; then xdg-desktop-menu forceupdate fi kgames-2.2/xmille/000077500000000000000000000000001416764561500141355ustar00rootroot00000000000000kgames-2.2/xmille/CHANGES000066400000000000000000000020621416764561500151300ustar00rootroot000000000000007/9/87 Dave Lemke lemke@sun.com Modified so that it works on B&W as well as color displays. Changed 'stop' and 'go' cards to be labeled. Fixed roll.c to work on Suns. Modified cardlib so the makfile would work properly on Suns, which have a new feature (by at least OS 3.3) that builds foo if foo.c exists. therefore rules of the form: ace.o: ace ace_mask ace.c which should create ace.o from ace.c, which includes ace and ace_mask, first builds ace from ace.c (with cc -o ace ace.c). this of course trashes the ace bitmap. solution was to name change all the bitmap files so there wouldn't be a corresponding .c file. there may be an easier way, but i don't know it. 7/12/88 Dana Chee dana@bellcore.com Converted X10 version to run under X11. Animated mode no longer works correctly. The X10 fonts timrom12 and timrom12b are used, and their .bdf files are included. 8/12/92 Keith Packard keithp@ncd.com Wrote three new Xt widgets and converted ui Animate mode works correctly now No fonts includes; mille now works with any fonts kgames-2.2/xmille/Mille.ad.in000066400000000000000000000112421416764561500161120ustar00rootroot00000000000000# # Color theme: # # Overall background: #337744 (green) # Passive foreground: #fffff0 # Active background: #fffff0 # Active foreground: #000000 # Accent colors: #774433 (brown), #334477 (blue) # *Foreground: #000000 *Background: #fffff0 *message.Background: #fffff0 *message.Foreground: #000000 *errors.Background: #fffff0 *errors.Foreground: #000000 *Layout.Background: #337744 *Label.Foreground: #fffff0 *Label.Background: #337744 *menuBar.Background: #337744 *MilleCards.Background: #337744 *MilleCards.internalBorderWidth: 3 *humanHand.Background: #774433 *Thermo.mercuryColor: #334477 *MilleCards.borderWidth: 0 *Label.borderWidth: 0 *Layout.borderWidth: 0 *Thermo.borderWidth: 0 *score.borderWidth: 0 *menuBar.borderWidth: 0 *Command.ShapeStyle: oval *layout.translations: #augment \n\ 1: milleReasonable(1)\n\ 2: milleReasonable(2)\n\ 3: milleReasonable(3)\n\ 4: milleReasonable(4)\n\ 5: milleReasonable(5)\n\ 6: milleReasonable(6)\n\ 7: milleReasonable(7)\n\ u,1: millePlay(1)\n\ u,2: millePlay(2)\n\ u,3: millePlay(3)\n\ u,4: millePlay(4)\n\ u,5: millePlay(5)\n\ u,6: millePlay(6)\n\ u,7: millePlay(7)\n\ d,1: milleDiscard(1)\n\ d,2: milleDiscard(2)\n\ d,3: milleDiscard(3)\n\ d,4: milleDiscard(4)\n\ d,5: milleDiscard(5)\n\ d,6: milleDiscard(6)\n\ d,7: milleDiscard(7)\n\ o: milleOrder()\n\ q: milleQuit()\n\ s: milleSave()\n\ r: milleRestore()\n\ Tab: milleDraw()\n\ p: milleDraw() *humanHand.translations: #override \n\ : stop(discard) *layout.layout: vertical {\ MenuBarBorderWidth = 0\ HumanHandBorderWidth = 0\ -$MenuBarBorderWidth \ horizontal { \ -$MenuBarBorderWidth menuBar < +inf -100% * > -$MenuBarBorderWidth \ } \ horizontal { \ vertical { \ MinPlayHeight = 20 \ MinPlayWidth = 550 \ PlayVertShrink = (100% - $MinPlayHeight) \ PlayHorzShrink = (100% - $MinPlayWidth) \ computerPlay < -$PlayHorzShrink * +1 -$PlayVertShrink > \ horizontal { \ vertical { \ computerMiles < +inf -100% * >\ horizontal { \ 0 < +inf > \ vertical { \ 0 < +inf > \ deckCount < +inf -100% * >\ deck < -100% * -100% > \ 0 < +inf > \ } \ 0 < +inf > \ } \ humanMiles < +inf -100% * > \ } \ 2 < -inf > \ vertical { \ score < +1 * +inf -1 > \ message < +inf -inf * > \ errors < +inf -inf * >\ } \ } \ humanPlay < -$PlayHorzShrink * +1 -$PlayVertShrink > \ horizontal { \ -$HumanHandBorderWidth \ humanHand < -$PlayHorzShrink * -$PlayVertShrink > \ 0 < +inf > \ } \ -$HumanHandBorderWidth \ } \ vertical { \ computerSafeties < -150% * -100% > \ computerSafetyLabel < +inf -inf * > \ 0 < +inf >\ humanSafeties < -150% * -100% > \ humanSafetyLabel < +inf -inf * >\ } \ } \ } *MenuButton.shapeStyle: oval *fileMenuButton.leftBitmap: menu12 *fileMenuButton.label: File *fileMenuButton.menuName: fileMenu *message.label: *errors.label: *fileMenu.restore.label: Restore from File *fileMenu.save.label: Save to File *fileMenu.quit.label: Quit *score*Font: monospace-12 *score.editType: edit *score.resize: both *score.translations: *score.baseTranslations: *Thermo.minimum: 0 *Thermo.maximum: 1000 *Thermo.minorStep: 25 *Thermo.majorStep: 100 *Thermo.vertical: false *Thermo.width: 500 *computerPlay.rowsHint: true *computerPlay.rows: 7 *computerSafetyLabel.label: Computer Safeties *humanPlay.rowsHint: true *humanPlay.rows: 7 *humanSafetyLabel.label: Player Safeties *yesOrNoShell.allowShellResize: true *yesOrNoOk.label: OK *yesOrNoNo.label: No *yesOrNoDialog.translations: #override\n\ y: milleYes()\n\ n: milleNo() *yesOrNoDialog.layout: vertical {\ Spacing = (50 % of height yesOrNoLabel) \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < +inf -inf > \ yesOrNoLabel \ $Spacing < +inf -inf > \ } \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < -inf > \ yesOrNoOk \ $Spacing < +inf -inf > \ yesOrNoNo \ $Spacing < -inf > \ } \ $Spacing < +inf -inf > \ } *promptedShell.allowShellResize: true *promptedValue*editType: edit *promptedOk.label: OK *promptedCancel.label: Cancel *promptedDialog.layout: vertical {\ Spacing = (20 % of height promptedLabel) \ $Spacing < +inf -inf > \ promptedLabel \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < -inf > \ promptedValue < +inf * +inf > \ $Spacing < -inf > \ } \ $Spacing < +inf -inf > \ horizontal { \ $Spacing < -inf > \ promptedOk \ $Spacing < +inf -inf > \ promptedCancel \ $Spacing < -inf > \ } \ $Spacing < +inf -inf > \ } kgames-2.2/xmille/MilleCards.c000066400000000000000000000105631416764561500163250ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include "mille.h" #include "uiXt.h" #include "card.h" #include #include #include #include #include #include #include #include #include #include "cards-svg.h" #include "MilleCardsP.h" #define SuperClass ((HandWidgetClass)&handClassRec) static void ClassInitialize(void) { XkwInitializeWidgetSet(); } static void DisplayCallback (Widget w, XtPointer closure, XtPointer data) { HandDisplayPtr display = (HandDisplayPtr) data; int card_no; struct card *card; cairo_t *cr = display->cr; (void) w; (void) closure; cairo_scale(cr, scale, scale); card_no = (int) (intptr_t) display->private; if (card_no == -2) card = &deck; else if (card_no < 0 || NUM_CARDS <= card_no) card = ␣ else card = &svg_cards[card_no]; XkwRsvgDraw(cr, WIDTH, HEIGHT, card->rsvg_handle); } static void Initialize (Widget greq, Widget gnew, Arg *args, Cardinal *count) { Arg my_args[2]; int i = 0; (void) greq; (void) args; (void) count; XtSetArg (my_args[i], XtNcardWidth, WIDTH * scale); i++; XtSetArg (my_args[i], XtNcardHeight, HEIGHT * scale); i++; XtSetValues(gnew, my_args, i); XtAddCallback (gnew, XtNdisplayCallback, DisplayCallback, (XtPointer) gnew); HandDragInit(XtParent(gnew), milleCardsWidgetClass); } static Boolean MilleCardsCardIsEmpty(Widget gw, XtPointer private) { int card_no = (int) (intptr_t) private; (void) gw; if (card_no == -2) return FALSE; return card_no < 0 || NUM_CARDS <= card_no; } MilleCardsClassRec milleCardsClassRec = { { /* core fields */ /* superclass */ (WidgetClass) SuperClass, /* class_name */ "MilleCards", /* widget_size */ sizeof(MilleCardsRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ NULL, /* num_actions */ 0, /* resources */ NULL, /* num_resources */ 0, /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ NULL, /* resize */ XtInheritResize, /* expose */ XtInheritExpose, /* set_values */ NULL, /* set_values_hook */ NULL, /* set_values_almost */ NULL, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ XtInheritTranslations, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* simple fields */ /* change_sensitive */ XtInheritChangeSensitive, #ifndef OLDXAW NULL, /* extension */ #endif }, { /* ksimple fields */ /* empty */ 0 }, { /* hand fields */ .card_is_empty = MilleCardsCardIsEmpty, }, { /* cards fields */ /* ignore */ 0 }, }; WidgetClass milleCardsWidgetClass = (WidgetClass) &milleCardsClassRec; kgames-2.2/xmille/MilleCards.h000066400000000000000000000026431416764561500163320ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _MilleCards_h #define _MilleCards_h #include typedef struct _MilleCardsRec *MilleCardsWidget; typedef struct _MilleCardsClassRec *MilleCardsWidgetClass; extern WidgetClass milleCardsWidgetClass; #endif /* _MilleMilleCards_h */ kgames-2.2/xmille/MilleCardsP.h000066400000000000000000000040231416764561500164440ustar00rootroot00000000000000/* * Copyright © 2021 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #ifndef _MilleCardsP_h #define _MilleCardsP_h #include "MilleCards.h" #include /************************************ * * Class structure * ***********************************/ /* * New fields for the MilleCards widget class record */ typedef struct _MilleCardsClass { int makes_compiler_happy; /* not used */ } MilleCardsClassPart; /* * Full class record declaration */ typedef struct _MilleCardsClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; HandClassPart hand_class; MilleCardsClassPart cards_class; } MilleCardsClassRec; extern MilleCardsClassRec cardsClassRec; /* * Full widget declaration */ typedef struct _MilleCardsRec { CorePart core; SimplePart simple; KSimplePart ksimple; HandPart hand; } MilleCardsRec; #endif /* _MilleCardsP_h */ kgames-2.2/xmille/README000066400000000000000000000013301416764561500150120ustar00rootroot00000000000000Notes on porting xmille: The bitmaps in 'cards' are set up for color and monochrome displays, using a gray stipple in monochrome to make the cards readable. You may also find the widgets included in xmille to be of general use; in particular, the Layout widget accepts TeX-esque descriptions of widget geometrys and dynamically adapts to widget resize requests and window geometry changes. No documentation for these widgets exists yet. I'll cheerfully accept bug reports in xmille, and may even be willing to maintain a current version; but as with the first version, I wash my hands of this mess by putting it into the public domain, I don't care what you do with it. August 12, 1992 keith packard keithp@ncd.com kgames-2.2/xmille/animate.c000066400000000000000000000130371416764561500157230ustar00rootroot00000000000000/* * animation */ # include "mille.h" # include "card.h" # include "uiXt.h" # include # include # include # include # include extern int iscolor; extern double scale; double animation_speed = .5; static int enabled = 1; static void do_animate (int ox, int oy, int dx, int dy); static void draw_square (int x1, int y1, int x2, int y2); static void compute_position (int player, int type, int arg, int *xp, int *yp); void animate_move (int player, int orig_type, int orig_arg, int dest_type, int dest_arg) { int ox, oy, dx, dy; if (!animation_speed || (!enabled && player == PLAYER)) return; compute_position (player, orig_type, orig_arg, &ox, &oy); compute_position (player, dest_type, dest_arg, &dx, &dy); do_animate (ox, oy, dx, dy); } void animate_enable(int enable) { enabled = enable; } # define abs(x) ((x) < 0 ? -(x) : (x)) /* * bigger numbers make it go faster */ # define accerate(v,r) ((v) + (speed/25 * (r))) #include static void msleep (int ms) { struct timespec t = { .tv_sec = ms / 1000, .tv_nsec = (long) (ms % 1000) * 1000000 }; nanosleep(&t, NULL); } static void do_animate (int ox, int oy, int dx, int dy) { double x, y; double xc, yc; int xd, yd; int xp, yp; int x1, y1, x2, y2, x3, y3, x4, y4; int ix, iy; double dist; double rx, ry; double speed; x = ox; y = oy; xd = dx - ox; yd = dy - oy; dist = sqrt ((double) xd * xd + yd * yd); rx = (double) xd / dist; ry = (double) yd / dist; speed = animation_speed * scale; xc = speed * rx; yc = speed * ry; xp = yp = -32767; XFlush (dpy); while (abs(dx - x) > abs (xc) || abs(dy - y) > abs (yc)) { ix = x; iy = y; if (xp == -32767) draw_square (ix, iy, ix + WIDTH, iy + HEIGHT); else { if (xp < ix) { x1 = xp + WIDTH; x2 = ix + WIDTH; x3 = ix; x4 = ix + WIDTH; } else if (xp > ix) { x1 = ix; x2 = xp; x3 = ix; x4 = ix + WIDTH; } else { x1 = -32767; x2 = -32767; x3 = ix; x4 = ix + WIDTH; } if (yp < iy) { y1 = iy; y2 = yp + HEIGHT; y3 = yp + HEIGHT; y4 = iy + HEIGHT; } else if (yp > iy) { y1 = yp; y2 = iy + HEIGHT; y3 = iy; y4 = yp; } else { y1 = iy; y2 = iy + HEIGHT; y3 = -32767; y4 = -32767; } if (x1 != -32767 && y1 != -32767) draw_square (x1, y1, x2, y2); if (x3 != -32767 && y3 != -32767) draw_square (x3, y3, x4, y4); if (ix < xp) { x1 = ix + WIDTH; x2 = xp + WIDTH; x3 = xp; x4 = xp + WIDTH; } else if (ix > xp) { x1 = xp; x2 = ix; x3 = xp; x4 = xp + WIDTH; } else { x1 = -32767; x2 = -32767; x3 = xp; x4 = xp + WIDTH; } if (iy < yp) { y1 = yp; y2 = iy + HEIGHT; y3 = iy + HEIGHT; y4 = yp + HEIGHT; } else if (iy > yp) { y1 = iy; y2 = yp + HEIGHT; y3 = yp; y4 = iy; } else { y1 = yp; y2 = yp + HEIGHT; y3 = -32767; y4 = -32767; } if (x1 != -32767 && y1 != -32767) draw_square (x1, y1, x2, y2); if (x3 != -32767 && y3 != -32767) draw_square (x3, y3, x4, y4); } xp = ix; yp = iy; if (abs (dx - x) > xc) x += xc; if (abs (dy - y) > yc) y += yc; xc = accerate(xc, rx); yc = accerate(yc, ry); XFlush (dpy); msleep (10); } draw_square (xp, yp, xp+WIDTH, yp+HEIGHT); XFlush (dpy); } extern Widget human_hand, deck_hand, computer_play, human_play, computer_safeties, human_safeties, layout; static void draw_square (int x1, int y1, int x2, int y2) { XFillRectangle (dpy, XtWindow(layout), xor_gc, x1, y1, x2-x1, y2-y1); } static void compute_position (int player, int type, int arg, int *xp, int *yp) { Widget w; XRectangle r; int row, col; int yForce = 0; Position x, y; Arg args[2]; switch (type) { case ANIMATE_HAND: switch (player) { case 0: w = human_hand; row = 0; col = arg; break; case 1: default: w = computer_play; yForce = -HEIGHT; break; } row = 0; col = arg; break; case ANIMATE_DECK: w = deck_hand; row = 0; col = 0; break; case ANIMATE_DISC: w = deck_hand; row = 0; col = 1; break; case ANIMATE_MILES: switch (player) { case 0: w = human_play; break; case 1: default: w = computer_play; break; } row = 0; col = (2 + C_200 - arg); break; case ANIMATE_BATTLE: switch (player) { case 0: w = human_play; break; case 1: default: w = computer_play; break; } row = 0; col = 1; break; case ANIMATE_SPEED: switch (player) { case 0: w = human_play; break; case 1: default: w = computer_play; break; } row = 0; col = 0; break; case ANIMATE_OBATTLE: switch (1-player) { case 0: w = human_play; break; case 1: default: w = computer_play; break; } row = 0; col = 1; break; case ANIMATE_OSPEED: switch (1-player) { case 0: w = human_play; break; case 1: default: w = computer_play; break; } row = 0; col = 0; break; case ANIMATE_SAFETY: switch (player) { case 0: w = human_safeties; break; case 1: default: w = computer_safeties; break; } row = arg & 1; col = (arg & 2) >> 1; break; default: w = deck_hand; row = 0; col = 0; break; } HandRectangleForPos (w, row, col, &r); XtSetArg (args[0], XtNx, &x); XtSetArg (args[1], XtNy, &y); XtGetValues (w, args, 2); *xp = r.x + x; if (yForce) *yp = yForce; else *yp = r.y + y; } kgames-2.2/xmille/background.h000066400000000000000000000000211416764561500164160ustar00rootroot00000000000000# include "fill" kgames-2.2/xmille/card-names000066400000000000000000000005461416764561500160770ustar00rootroot0000000000000025:25: 50:50: 75:75: 100:100: 200:200: Panne D'Essence:out: Crevé:flat: Accident:accident: Stop!:stop: Limite De Vitesse:speed: Essence:gas: Roue de secours:spare: Réparations:repairs: Roulez:go: Fin de limite:end: Citerne d'essence:extra: Increvable:puncture: As du volant:ace: Véhicule prioritaire:right: deck:deck:deck blank:blank:blank Icon:icon:icon kgames-2.2/xmille/card.h000066400000000000000000000000471416764561500152200ustar00rootroot00000000000000# define HEIGHT 150 # define WIDTH 100 kgames-2.2/xmille/cards/000077500000000000000000000000001416764561500152315ustar00rootroot00000000000000kgames-2.2/xmille/cards/100.c000066400000000000000000000000411416764561500156700ustar00rootroot00000000000000# define static # include "_100" kgames-2.2/xmille/cards/100.svg000066400000000000000000000161051416764561500162550ustar00rootroot00000000000000 kgames-2.2/xmille/cards/200.c000066400000000000000000000000411416764561500156710ustar00rootroot00000000000000# define static # include "_200" kgames-2.2/xmille/cards/200.svg000066400000000000000000000164041416764561500162600ustar00rootroot00000000000000 kgames-2.2/xmille/cards/25.c000066400000000000000000000000671416764561500156260ustar00rootroot00000000000000# define static # include "_25" # include "miles_mask" kgames-2.2/xmille/cards/25.svg000066400000000000000000000151641416764561500162070ustar00rootroot00000000000000 kgames-2.2/xmille/cards/50.c000066400000000000000000000000401416764561500156130ustar00rootroot00000000000000# define static # include "_50" kgames-2.2/xmille/cards/50.svg000066400000000000000000000145361416764561500162070ustar00rootroot00000000000000 kgames-2.2/xmille/cards/75.c000066400000000000000000000000401416764561500156220ustar00rootroot00000000000000# define static # include "_75" kgames-2.2/xmille/cards/75.svg000066400000000000000000000141101416764561500162020ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Accident.svg000066400000000000000000000734601416764561500174760ustar00rootroot00000000000000 kgames-2.2/xmille/cards/As du volant.svg000066400000000000000000000546241416764561500202050ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Citerne d'essence.svg000066400000000000000000000702321416764561500211700ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Crevé.svg000066400000000000000000000630741416764561500174370ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Essence.svg000066400000000000000000000352131416764561500173430ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Fin de limite.svg000066400000000000000000000522711416764561500203120ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Icon.svg000066400000000000000000000065201416764561500166450ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Increvable.svg000066400000000000000000000635031416764561500200330ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Limite De Vitesse.svg000066400000000000000000000715721416764561500211250ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Panne D'Essence.svg000066400000000000000000000554251416764561500205470ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Roue de secours.svg000066400000000000000000001076301416764561500207100ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Roulez.svg000066400000000000000000000272221416764561500172370ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Réparations.svg000066400000000000000000000736451416764561500206670ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Stop!.svg000066400000000000000000000255701416764561500167510ustar00rootroot00000000000000 kgames-2.2/xmille/cards/Véhicule prioritaire.svg000066400000000000000000001015751416764561500224500ustar00rootroot00000000000000 kgames-2.2/xmille/cards/_100000066400000000000000000000277511416764561500156270ustar00rootroot00000000000000#define _100_width 100 #define _100_height 150 static char _100_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x81, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x87, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_200000066400000000000000000000277511416764561500156300ustar00rootroot00000000000000#define _200_width 100 #define _200_height 150 static char _200_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x81, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xc3, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc1, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xc0, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xc0, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc0, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc0, 0x30, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x83, 0x1f, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x03, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_25000066400000000000000000000277461416764561500155610ustar00rootroot00000000000000#define _25_width 100 #define _25_height 150 static char _25_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xe0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xe0, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_50000066400000000000000000000277461416764561500155570ustar00rootroot00000000000000#define _50_width 100 #define _50_height 150 static char _50_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x39, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xe7, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x61, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_75000066400000000000000000000277461416764561500155660ustar00rootroot00000000000000#define _75_width 100 #define _75_height 150 static char _75_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x98, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xf8, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_accident000066400000000000000000000277701416764561500171020ustar00rootroot00000000000000#define _accident_width 100 #define _accident_height 150 static char _accident_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xfc, 0xfb, 0x1f, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x83, 0xc5, 0xe1, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x3e, 0xfe, 0xc5, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xf1, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xe0, 0x01, 0x00, 0x1e, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0x01, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xff, 0xff, 0x0f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xff, 0xff, 0x0f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x07, 0x80, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xfb, 0x7f, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xfd, 0xff, 0x3e, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x7f, 0xf8, 0x87, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_ace000066400000000000000000000277511416764561500160570ustar00rootroot00000000000000#define _ace_width 100 #define _ace_height 150 static char _ace_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xfc, 0xff, 0xff, 0x7f, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0xf8, 0xff, 0xff, 0x3f, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xf0, 0xff, 0xff, 0x1f, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xf0, 0xff, 0xff, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_blank000066400000000000000000000277541416764561500164210ustar00rootroot00000000000000#define blank_width 100 #define blank_height 150 static char blank_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/_end000066400000000000000000000277511416764561500160750ustar00rootroot00000000000000#define _end_width 100 #define _end_height 150 static char _end_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_extra000066400000000000000000000277571416764561500164600ustar00rootroot00000000000000#define _extra_width 100 #define _extra_height 150 static char _extra_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc1, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_flat000066400000000000000000000277541416764561500162600ustar00rootroot00000000000000#define _flat_width 100 #define _flat_height 150 static char _flat_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x01, 0x00, 0x1e, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0x01, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xff, 0xff, 0x0f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0x01, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_gas000066400000000000000000000277511416764561500161010ustar00rootroot00000000000000#define _gas_width 100 #define _gas_height 150 static char _gas_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_go000066400000000000000000000277461416764561500157400ustar00rootroot00000000000000#define _go_width 100 #define _go_height 150 static char _go_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_out000066400000000000000000000277511416764561500161360ustar00rootroot00000000000000#define _out_width 100 #define _out_height 150 static char _out_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_puncture000066400000000000000000000277701416764561500171750ustar00rootroot00000000000000#define _puncture_width 100 #define _puncture_height 150 static char _puncture_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xff, 0xf1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xf0, 0xff, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xf0, 0xff, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xf0, 0xff, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0f, 0xf0, 0xf9, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0xf8, 0xf9, 0x83, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xcf, 0x3f, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xcf, 0x3f, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xf9, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xf0, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xf0, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xf9, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xcf, 0x3f, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xcf, 0x3f, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xf9, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0xf8, 0xf9, 0x81, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0xff, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0xf0, 0xff, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xf0, 0xff, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xf0, 0xff, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xf0, 0xff, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xff, 0xf1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_repairs000066400000000000000000000277651416764561500170010ustar00rootroot00000000000000#define _repairs_width 100 #define _repairs_height 150 static char _repairs_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x01, 0x00, 0x1e, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0x01, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xff, 0xff, 0x0f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xfd, 0xff, 0x0e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xfb, 0x7f, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x07, 0x80, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_right000066400000000000000000000277571416764561500164520ustar00rootroot00000000000000#define _right_width 100 #define _right_height 150 static char _right_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x03, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x7b, 0x93, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x4b, 0x93, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xaf, 0x7b, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc1, 0xaf, 0x03, 0xff, 0x83, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0xaf, 0xff, 0xff, 0x01, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xaf, 0xff, 0xff, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_spare000066400000000000000000000277571416764561500164470ustar00rootroot00000000000000#define _spare_width 100 #define _spare_height 150 static char _spare_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x01, 0x00, 0x1e, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xff, 0xff, 0x1f, 0xc0, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0x01, 0x00, 0x0e, 0x80, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xff, 0xff, 0x0f, 0x80, 0x00, 0xb0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0xc0, 0xfd, 0xff, 0x0e, 0x80, 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0xfb, 0x7f, 0x1f, 0xc0, 0x00, 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe0, 0x07, 0x80, 0x1f, 0xc0, 0x00, 0x20, 0x03, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf0, 0xff, 0xff, 0x3f, 0xe0, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_speed000066400000000000000000000277571416764561500164350ustar00rootroot00000000000000#define _speed_width 100 #define _speed_height 150 static char _speed_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x81, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xe1, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3d, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3, 0x31, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x81, 0x31, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3, 0x61, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/_stop000066400000000000000000000277541416764561500163170ustar00rootroot00000000000000#define _stop_width 100 #define _stop_height 150 static char _stop_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/accident.c000066400000000000000000000001351416764561500171460ustar00rootroot00000000000000# define static # include "_accident" # include "accident_label" # include "accident_mask" kgames-2.2/xmille/cards/accident_both000066400000000000000000000300041416764561500177370ustar00rootroot00000000000000#define accident_both_width 100 #define accident_both_height 150 static char accident_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xc7, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xbb, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0x7d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0x55, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x6d, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x7d, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xc7, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xbb, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x01, 0x00, 0xde, 0xdf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xeb, 0xff, 0xff, 0x5f, 0xd7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xdd, 0x01, 0x00, 0xee, 0xba, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xde, 0xff, 0xff, 0xef, 0xbd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xdd, 0xff, 0xff, 0xef, 0xba, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0xeb, 0x07, 0x80, 0x5f, 0xd7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xfb, 0x7f, 0xdf, 0xdf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xfd, 0xff, 0x3e, 0xe7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xfb, 0xab, 0xaa, 0x7e, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xfb, 0xdb, 0xdd, 0x7e, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xfb, 0xab, 0xaa, 0x7e, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xfb, 0xfb, 0xff, 0x7e, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0x03, 0x00, 0xfe, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/accident_label000066400000000000000000000300071416764561500200650ustar00rootroot00000000000000#define accident_label_width 100 #define accident_label_height 150 static char accident_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/accident_mask000066400000000000000000000300041416764561500177360ustar00rootroot00000000000000#define accident_mask_width 100 #define accident_mask_height 150 static char accident_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x3f, 0x7c, 0xf8, 0xff, 0x03, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0xc0, 0x03, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x30, 0x00, 0x60, 0x8c, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0xc0, 0x01, 0x80, 0x41, 0x88, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x0e, 0x00, 0x2e, 0x48, 0x18, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0xf0, 0x01, 0x10, 0xb0, 0x10, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0xfc, 0x59, 0x1c, 0x11, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0xc0, 0x03, 0x4c, 0x25, 0x15, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x3c, 0x00, 0x03, 0xa2, 0x10, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x80, 0x03, 0xc0, 0xf8, 0x45, 0x0a, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x30, 0xc4, 0xc0, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x20, 0xc0, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x20, 0x80, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x34, 0x03, 0x04, 0xe0, 0x00, 0x80, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xcc, 0x7c, 0x3a, 0x1e, 0xc1, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0x80, 0xc1, 0x01, 0x3a, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x0e, 0x07, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x61, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x11, 0x10, 0xfe, 0xff, 0x21, 0x20, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x51, 0x14, 0x00, 0x00, 0xa0, 0x28, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x8a, 0x22, 0xfe, 0xff, 0x11, 0x45, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x21, 0x00, 0x00, 0x10, 0x42, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x8a, 0x22, 0x00, 0x00, 0x10, 0x45, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x52, 0x14, 0xf8, 0x7f, 0xa0, 0x28, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x04, 0x80, 0x20, 0x20, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x02, 0x00, 0xc1, 0x98, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0xe0, 0x80, 0x07, 0x78, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0x1f, 0x7f, 0xf8, 0x87, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x9f, 0x5f, 0x86, 0xff, 0x8f, 0xf8, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x61, 0xa0, 0x01, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfc, 0xff, 0x39, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0x1f, 0x07, 0x00, 0xc7, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0xe6, 0x54, 0x55, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x24, 0x22, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x54, 0xd5, 0x80, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x04, 0x80, 0x80, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0x03, 0xfc, 0xff, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/ace.c000066400000000000000000000001141416764561500161210ustar00rootroot00000000000000# define static # include "_ace" # include "ace_label" # include "ace_mask" kgames-2.2/xmille/cards/ace_both000066400000000000000000000277651416764561500167410ustar00rootroot00000000000000#define ace_both_width 100 #define ace_both_height 150 static char ace_both_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x7b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x3d, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1d, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x0e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x5e, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x3e, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0xfe, 0x6e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x9f, 0x7f, 0xdf, 0xe3, 0x87, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xe7, 0xbf, 0xbf, 0x1f, 0xcf, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xf9, 0xdf, 0x03, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x7f, 0x3e, 0xfc, 0xff, 0xff, 0x7f, 0xf8, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x9f, 0xdf, 0xfb, 0xff, 0xff, 0xbf, 0xf7, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xdf, 0xef, 0xf7, 0xff, 0xff, 0xdf, 0xef, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xdf, 0x6f, 0xf6, 0xff, 0xff, 0xdf, 0xec, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x3f, 0x60, 0x06, 0x00, 0x00, 0xc0, 0x0c, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xef, 0xf7, 0xff, 0xff, 0xdf, 0xef, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xdf, 0xfb, 0xff, 0xff, 0xbf, 0xf7, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x7f, 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xc0, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xea, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/ace_label000066400000000000000000000277701416764561500170600ustar00rootroot00000000000000#define ace_label_width 100 #define ace_label_height 150 static char ace_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/ace_mask000066400000000000000000000277651416764561500167400ustar00rootroot00000000000000#define ace_mask_width 100 #define ace_mask_height 150 static char ace_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0x01, 0x91, 0x03, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x60, 0x80, 0x20, 0x1c, 0x78, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x18, 0x40, 0x40, 0xe0, 0x30, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x06, 0x20, 0xfc, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0xc1, 0x03, 0x00, 0x00, 0x80, 0x07, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0x60, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x0f, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0xf0, 0x0f, 0x00, 0x00, 0xe0, 0x1f, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x70, 0x0e, 0x00, 0x00, 0xe0, 0x1c, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0xc0, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xfc, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0x0f, 0x00, 0x00, 0xe0, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/background.h000066400000000000000000000001101416764561500175110ustar00rootroot00000000000000# include "fill" # define HEIGHT fill_height # define WIDTH fill_width kgames-2.2/xmille/cards/blank.c000066400000000000000000000000431416764561500164610ustar00rootroot00000000000000# define static # include "_blank" kgames-2.2/xmille/cards/blank.svg000066400000000000000000000012111416764561500170340ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/000077500000000000000000000000001416764561500174205ustar00rootroot00000000000000kgames-2.2/xmille/cards/card-center/100.svg000066400000000000000000000076371416764561500204560ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/200.svg000066400000000000000000000077361416764561500204570ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/25.svg000066400000000000000000000073271416764561500204000ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/50.svg000066400000000000000000000071121416764561500203660ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/75.svg000066400000000000000000000071411416764561500203770ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Accident.svg000066400000000000000000000422311416764561500216550ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/As du volant.svg000066400000000000000000000200771416764561500223670ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Citerne d'essence.svg000066400000000000000000000156321416764561500233620ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Crevé.svg000066400000000000000000000406671416764561500216310ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Essence.svg000066400000000000000000000140261416764561500215310ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Fin de limite.svg000066400000000000000000000156701416764561500225030ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Increvable.svg000066400000000000000000000276631416764561500222310ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Limite De Vitesse.svg000066400000000000000000000202341416764561500233010ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Panne D'Essence.svg000066400000000000000000000136321416764561500227300ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/card-center/Roue de secours.svg000066400000000000000000000420471416764561500230770ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Roulez.svg000066400000000000000000000072211416764561500214230ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Réparations.svg000066400000000000000000000306411416764561500230430ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Stop!.svg000066400000000000000000000073151416764561500211350ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/Véhicle prioritaire.svg000066400000000000000000000313011416764561500244370ustar00rootroot00000000000000 kgames-2.2/xmille/cards/card-center/blank.svg000066400000000000000000000000001416764561500212160ustar00rootroot00000000000000kgames-2.2/xmille/cards/card-center/deck.svg000066400000000000000000000157441416764561500210620ustar00rootroot00000000000000 image/svg+xml kgames-2.2/xmille/cards/color.h000066400000000000000000000003241416764561500165170ustar00rootroot00000000000000/* * color.h * * definitions for standard colors */ # define BLACK_COLOR 0 # define WHITE_COLOR 1 # define RED_COLOR 2 # define GREEN_COLOR 3 # define GREY_COLOR 4 # define BLUE_COLOR 5 # define NUM_COLOR 6 kgames-2.2/xmille/cards/deck.c000066400000000000000000000001461416764561500163040ustar00rootroot00000000000000# define static # include "deck_mask" # include "deck_red" # include "deck_blue" #include "deck_both" kgames-2.2/xmille/cards/deck.svg000066400000000000000000000213061416764561500166620ustar00rootroot00000000000000 kgames-2.2/xmille/cards/deck_blue000066400000000000000000000277701416764561500171060ustar00rootroot00000000000000#define deck_blue_width 100 #define deck_blue_height 150 static char deck_blue_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x3e, 0x60, 0x0e, 0xcc, 0x01, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x1c, 0xe0, 0x01, 0x7f, 0x60, 0x1f, 0xec, 0x83, 0x3f, 0xfc, 0x01, 0x00, 0x00, 0x1c, 0xc0, 0x81, 0xc1, 0xe0, 0x31, 0x3c, 0xc6, 0x60, 0x06, 0x03, 0x00, 0x00, 0x1c, 0x80, 0x83, 0xc1, 0xe0, 0x20, 0x1c, 0x46, 0x40, 0x06, 0x02, 0x00, 0x00, 0x1c, 0x80, 0xc3, 0x80, 0x61, 0x00, 0x0c, 0xc6, 0x7f, 0xfc, 0x00, 0x00, 0x00, 0x1c, 0x80, 0xc3, 0x80, 0x61, 0x00, 0x0c, 0xc6, 0x7f, 0xf8, 0x01, 0x00, 0x00, 0x1c, 0xc0, 0xc3, 0x80, 0x61, 0x00, 0x0c, 0x46, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1c, 0xe0, 0x81, 0xc1, 0x60, 0x00, 0x0c, 0xc6, 0x00, 0x02, 0x03, 0x00, 0x00, 0xfc, 0xff, 0x81, 0xc1, 0x60, 0x00, 0x0c, 0xc6, 0x60, 0x06, 0x03, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x7f, 0x60, 0x00, 0x0c, 0x86, 0x3f, 0xfc, 0x01, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x3e, 0x60, 0x00, 0x0c, 0x06, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/deck_both000066400000000000000000000277701416764561500171130ustar00rootroot00000000000000#define deck_both_width 100 #define deck_both_height 150 static char deck_both_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfc, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf0, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf0, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xe0, 0x83, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xe0, 0x83, 0xff, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xc8, 0x89, 0xff, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xc8, 0x89, 0xff, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x98, 0x8c, 0xff, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x98, 0x8c, 0x9f, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x38, 0x8e, 0x9f, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x38, 0x8e, 0xff, 0xcf, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x78, 0x8f, 0xff, 0xcf, 0xe7, 0x1f, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0x0f, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0xe7, 0xf3, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0xf7, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0x07, 0xf0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0x07, 0xf0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0xf7, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0xe7, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0xe7, 0xf3, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0x0f, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xf8, 0x8f, 0x9f, 0xcf, 0xe7, 0x1f, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xe3, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x00, 0xff, 0xc1, 0x9f, 0xf1, 0x33, 0xfe, 0xe0, 0x07, 0xff, 0xf7, 0xfe, 0xe3, 0x1f, 0xfe, 0x80, 0x9f, 0xe0, 0x13, 0x7c, 0xc0, 0x03, 0xfe, 0xf7, 0xfe, 0xe3, 0x3f, 0x7e, 0x3e, 0x1f, 0xce, 0xc3, 0x39, 0x9f, 0xf9, 0xfc, 0xf7, 0xfe, 0xe3, 0x7f, 0x7c, 0x3e, 0x1f, 0xdf, 0xe3, 0xb9, 0xbf, 0xf9, 0xfd, 0xf7, 0xfe, 0xe3, 0x7f, 0x3c, 0x7f, 0x9e, 0xff, 0xf3, 0x39, 0x80, 0x03, 0xff, 0xf7, 0xfe, 0xe3, 0x7f, 0x3c, 0x7f, 0x9e, 0xff, 0xf3, 0x39, 0x80, 0x07, 0xfe, 0xf7, 0xfe, 0xe3, 0x3f, 0x3c, 0x7f, 0x9e, 0xff, 0xf3, 0xb9, 0xff, 0xff, 0xfc, 0xf7, 0xfe, 0xe3, 0x1f, 0x7e, 0x3e, 0x9f, 0xff, 0xf3, 0x39, 0xff, 0xfd, 0xfc, 0xf7, 0xfe, 0x03, 0x00, 0x7e, 0x3e, 0x9f, 0xff, 0xf3, 0x39, 0x9f, 0xf9, 0xfc, 0xf7, 0xfe, 0x03, 0x00, 0xff, 0x80, 0x9f, 0xff, 0xf3, 0x79, 0xc0, 0x03, 0xfe, 0xf7, 0xfe, 0x03, 0xc0, 0xff, 0xc1, 0x9f, 0xff, 0xf3, 0xf9, 0xe0, 0x07, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0}; kgames-2.2/xmille/cards/deck_mask000066400000000000000000000277701416764561500171120ustar00rootroot00000000000000#define deck_mask_width 100 #define deck_mask_height 150 static char deck_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xf0, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0}; kgames-2.2/xmille/cards/deck_red000066400000000000000000000277651416764561500167350ustar00rootroot00000000000000#define deck_red_width 100 #define deck_red_height 150 static char deck_red_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7c, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x76, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x76, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x73, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x73, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x71, 0x60, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x71, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x70, 0x00, 0x30, 0x18, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0x08, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x70, 0x60, 0x30, 0x18, 0xe0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/display.c000066400000000000000000000075361416764561500170550ustar00rootroot00000000000000# include # include "background.h" # include "color.h" struct color { char *name; int pixel; }; struct color colorMap[NUM_COLOR] = { "black", 0, "white", 0, "red", 0, "green", 0, "light gray", 0, "blue", 0, }; struct card_init { short *bits; short *mask; int color; }; extern short go_bits[], go_mask_bits[]; extern short stop_bits[], stop_mask_bits[]; extern short right_bits[], right_mask_bits[]; extern short speed_bits[], speed_mask_bits[]; extern short end_bits[], end_mask_bits[]; extern short accident_bits[], accident_mask_bits[]; extern short repairs_bits[], repairs_mask_bits[]; extern short ace_bits[], ace_mask_bits[]; extern short flat_bits[], flat_mask_bits[]; extern short spare_bits[], spare_mask_bits[]; extern short puncture_bits[], puncture_mask_bits[]; extern short out_bits[], out_mask_bits[]; extern short gas_bits[], gas_mask_bits[]; extern short extra_bits[], extra_mask_bits[]; extern short miles_mask_bits[]; extern short _25_bits[], _50_bits[], _75_bits[], _100_bits[], _200_bits[]; struct card_init card_inits[] = { { go_bits, go_mask_bits, GREEN_COLOR, }, { stop_bits, stop_mask_bits, RED_COLOR, }, { right_bits, right_mask_bits, RED_COLOR, }, { speed_bits, speed_mask_bits, RED_COLOR, }, { end_bits, end_mask_bits, GREEN_COLOR, }, { accident_bits, accident_mask_bits, RED_COLOR, }, { repairs_bits, repairs_mask_bits, GREEN_COLOR, }, { ace_bits, ace_mask_bits, BLUE_COLOR, }, { flat_bits, flat_mask_bits, RED_COLOR, }, { spare_bits, spare_mask_bits, GREEN_COLOR, }, { puncture_bits, puncture_mask_bits, BLUE_COLOR, }, { out_bits, out_mask_bits, RED_COLOR, }, { gas_bits, gas_mask_bits, GREEN_COLOR, }, { extra_bits, extra_mask_bits, BLUE_COLOR, }, { _25_bits, miles_mask_bits, BLUE_COLOR, }, { _50_bits, miles_mask_bits, BLUE_COLOR, }, { _75_bits, miles_mask_bits, BLUE_COLOR, }, { _100_bits, miles_mask_bits, BLUE_COLOR, }, { _200_bits, miles_mask_bits, BLUE_COLOR, }, }; # define NUM_CARDS (sizeof (card_inits) / sizeof (card_inits[0])) struct plane { Bitmap bits; int pixel; }; struct card { int nPlanes; struct plane planes[5]; }; struct card cards[NUM_CARDS]; Window w; # define WINDOW_WIDTH 1000 # define WINDOW_HEIGHT 700 main () { Color hardware_color, exact_color; XEvent rep; Bitmap fill; Pixmap background; Pixmap border; int i; XOpenDisplay (""); for (i = 0; i < NUM_COLOR; i++) { XGetColor (colorMap[i].name, &hardware_color, &exact_color); colorMap[i].pixel = hardware_color.pixel; } fill = XStoreBitmap (WIDTH, HEIGHT, fill_bits); for (i = 0; i < NUM_CARDS; i++) { cards[i].planes[2].bits = XStoreBitmap (WIDTH, HEIGHT, card_inits[i].bits); cards[i].planes[2].pixel = colorMap[card_inits[i].color].pixel; cards[i].planes[1].bits = XStoreBitmap (WIDTH, HEIGHT, card_inits[i].mask); cards[i].planes[1].pixel = colorMap[BLACK_COLOR].pixel; cards[i].planes[0].bits = fill; cards[i].planes[0].pixel = colorMap[WHITE_COLOR].pixel; cards[i].nPlanes = 3; } background = XMakePixmap (0, colorMap[GREY_COLOR].pixel, colorMap[WHITE_COLOR].pixel); border = XMakePixmap (0, colorMap[WHITE_COLOR].pixel, colorMap[GREY_COLOR].pixel); w = XCreateWindow (RootWindow, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 1, WhitePixmap, background); XMapWindow (w); XSelectInput (w, ExposeWindow); displayAll (); for (;;) { XNextEvent (&rep); switch (rep.type) { case ExposeWindow: displayAll (); break; } } } displayAll () { struct card *card; int x, y; int i; x = 10; y = 10; for (i = 0; i < NUM_CARDS; i++) { displayOne (&cards[i], x, y); x += WIDTH + 20; if (x + WIDTH > WINDOW_WIDTH) { x = 10; y += HEIGHT + 20; } } XFlush (); } displayOne (card, x, y) struct card *card; int x, y; { int i; for (i = 0; i < card->nPlanes; i++) { XPixFill (w, x, y, WIDTH, HEIGHT, card->planes[i].pixel, card->planes[i].bits, GXcopy, AllPlanes); } } kgames-2.2/xmille/cards/end.c000066400000000000000000000000661416764561500161450ustar00rootroot00000000000000# define static # include "_end" # include "end_mask" kgames-2.2/xmille/cards/end_both000066400000000000000000000277651416764561500167570ustar00rootroot00000000000000#define end_both_width 100 #define end_both_height 150 static char end_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xc0, 0xde, 0xf0, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xdc, 0xee, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xda, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xda, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xda, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe0, 0xd6, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xd6, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xd6, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xce, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xde, 0xee, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xc0, 0xde, 0xf0, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1f, 0x0f, 0xfc, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xee, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0x0d, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf7, 0xed, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xee, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x1f, 0xef, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0x8f, 0x2e, 0x82, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xdf, 0x64, 0xef, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xdf, 0x6a, 0xef, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xdf, 0x6e, 0xef, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0xdf, 0x6e, 0xef, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0x88, 0x2e, 0xee, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xee, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/end_mask000066400000000000000000000277651416764561500167560ustar00rootroot00000000000000#define end_mask_width 100 #define end_mask_height 150 static char end_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x3f, 0x21, 0x0f, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x23, 0x11, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x25, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x25, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x25, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x1f, 0x29, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x29, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x29, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x31, 0x21, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x21, 0x11, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x3f, 0x21, 0x0f, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0xe0, 0xf0, 0x03, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x10, 0x11, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0xf2, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x08, 0x12, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x10, 0x11, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0xe0, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x70, 0xd1, 0x7d, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x9b, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x95, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x77, 0xd1, 0x11, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/extra.c000066400000000000000000000001221416764561500165130ustar00rootroot00000000000000# define static # include "_extra" # include "extra_label" # include "extra_mask" kgames-2.2/xmille/cards/extra_both000066400000000000000000000277731416764561500173330ustar00rootroot00000000000000#define extra_both_width 100 #define extra_both_height 150 static char extra_both_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x01, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x01, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x5f, 0xab, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x5f, 0xab, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x6f, 0xab, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x6f, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0x68, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xdf, 0xff, 0xef, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xdf, 0xc1, 0xef, 0xfd, 0xff, 0x83, 0x60, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xdf, 0xbe, 0xef, 0xfd, 0xff, 0x7d, 0x5f, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x5f, 0x63, 0xef, 0xfd, 0xff, 0xc6, 0x31, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x5d, 0x00, 0x00, 0x00, 0xba, 0x2e, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xd5, 0xff, 0xff, 0xff, 0xab, 0xea, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xbb, 0xee, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xe3, 0xff, 0xff, 0xff, 0xc7, 0xf1, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbf, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xc0, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/extra_label000066400000000000000000000277761416764561500174610ustar00rootroot00000000000000#define extra_label_width 100 #define extra_label_height 150 static char extra_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/extra_mask000066400000000000000000000277731416764561500173320ustar00rootroot00000000000000#define extra_mask_width 100 #define extra_mask_height 150 static char extra_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x94, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0x97, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x00, 0x10, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x3e, 0x10, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x41, 0x10, 0xfe, 0xff, 0x83, 0xe0, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0xa0, 0x9c, 0x10, 0xfe, 0xff, 0x39, 0xce, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xbe, 0xff, 0xff, 0xff, 0x7d, 0xdf, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x6c, 0x1b, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x38, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/fill000066400000000000000000000277511416764561500161160ustar00rootroot00000000000000#define fill_width 100 #define fill_height 150 static char fill_bits[] = { 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}; kgames-2.2/xmille/cards/flat.c000066400000000000000000000001171416764561500163220ustar00rootroot00000000000000# define static # include "_flat" # include "flat_label" # include "flat_mask" kgames-2.2/xmille/cards/flat_both000066400000000000000000000277701416764561500171330ustar00rootroot00000000000000#define flat_both_width 100 #define flat_both_height 150 static char flat_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x8a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, 0xcd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xb7, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xb7, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xc7, 0xbf, 0x77, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xbb, 0xbf, 0xe7, 0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0xef, 0xdb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xcf, 0xb7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0xcf, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0xaf, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xb7, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0x56, 0xa7, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xee, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0xfe, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x01, 0x00, 0xde, 0xdf, 0xfe, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xff, 0xff, 0xdf, 0xdf, 0x7e, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, 0xd8, 0x01, 0x00, 0x6e, 0xb0, 0xbe, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xdf, 0xff, 0xff, 0xef, 0xbf, 0xde, 0x77, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, 0xd8, 0x01, 0x00, 0x6e, 0xb0, 0xee, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xff, 0xff, 0xdf, 0xdf, 0xf6, 0x6d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xff, 0xff, 0xdf, 0xdf, 0xfa, 0x6e, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0x3a, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xda, 0x6f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xda, 0x4f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd6, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xd6, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0xd6, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0x7e, 0xd5, 0xd7, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xab, 0xaa, 0x7e, 0xd5, 0xc3, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0xbe, 0xb5, 0xc0, 0x5f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xfb, 0xff, 0xbe, 0xbf, 0xc0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0x03, 0x00, 0x3e, 0x80, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/flat_label000066400000000000000000000277731416764561500172610ustar00rootroot00000000000000#define flat_label_width 100 #define flat_label_height 150 static char flat_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/flat_mask000066400000000000000000000277701416764561500171320ustar00rootroot00000000000000#define flat_mask_width 100 #define flat_mask_height 150 static char flat_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x3e, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x7e, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x71, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x75, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x61, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0x32, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0xcc, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x48, 0x03, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x48, 0x04, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x38, 0x40, 0x88, 0x08, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x40, 0x18, 0x13, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x10, 0x24, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40, 0x30, 0x48, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x20, 0xc0, 0x30, 0x70, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x20, 0x80, 0x50, 0x10, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x80, 0x48, 0x20, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x20, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x58, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0x11, 0x47, 0x00, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x01, 0x41, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0xfe, 0xff, 0x21, 0x20, 0x01, 0x81, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x20, 0x20, 0x81, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0xca, 0x27, 0xfe, 0xff, 0x91, 0x4f, 0x41, 0x90, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x10, 0x40, 0x21, 0x88, 0x00, 0x08, 0x01, 0x00, 0x00, 0xca, 0x27, 0xfe, 0xff, 0x91, 0x4f, 0x11, 0x94, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x20, 0x20, 0x09, 0x92, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x20, 0x20, 0x05, 0x91, 0x00, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0xc5, 0x90, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0x25, 0x90, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0xb0, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2c, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x29, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfc, 0xff, 0x01, 0x00, 0x29, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0x29, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x50, 0x05, 0x24, 0x22, 0x81, 0x2a, 0x28, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x50, 0x05, 0x54, 0x55, 0x81, 0x2a, 0x3c, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x50, 0x05, 0x24, 0x22, 0x41, 0x4a, 0x3f, 0xa0, 0x00, 0x08, 0x01, 0x00, 0x00, 0x50, 0x05, 0x04, 0x00, 0x41, 0x40, 0x3f, 0xf0, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0x03, 0xfc, 0xff, 0xc1, 0x7f, 0x00, 0xfc, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/gas.c000066400000000000000000000000661416764561500161510ustar00rootroot00000000000000# define static # include "_gas" # include "gas_mask" kgames-2.2/xmille/cards/gas_mask000066400000000000000000000277651416764561500167620ustar00rootroot00000000000000#define gas_mask_width 100 #define gas_mask_height 150 static char gas_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x3f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x40, 0x00, 0x08, 0x08, 0x01, 0x04, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x08, 0x08, 0x01, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x08, 0x01, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x31, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/go.c000066400000000000000000000001111416764561500157730ustar00rootroot00000000000000# define static # include "_go" # include "go_label" # include "go_mask" kgames-2.2/xmille/cards/go_label000066400000000000000000000277651416764561500167410ustar00rootroot00000000000000#define go_label_width 100 #define go_label_height 150 static char go_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/go_mask000066400000000000000000000277621416764561500166120ustar00rootroot00000000000000#define go_mask_width 100 #define go_mask_height 150 static char go_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/make-card.5c000077500000000000000000000040201416764561500173050ustar00rootroot00000000000000#!/usr/bin/nickle autoimport Cairo; void outline (cairo_t cr, real width, real height, real lw) { real radius = width / 6; save(cr); translate(cr, lw/2, lw/2); set_line_width(cr, lw); width -= lw; height -= lw; move_to(cr, 0, radius); /* top left */ arc(cr, radius, radius, radius, pi, 3 * pi / 2); /* top */ line_to(cr, width - radius, 0); /* top right */ arc(cr, width - radius, radius, radius, 3 * pi / 2, 0); /* right */ line_to(cr, width, height - radius); /* bottom right */ arc(cr, width - radius, height - radius, radius, 0, pi / 2); /* bottom */ line_to(cr, radius, height); /* bottom left */ arc(cr, radius, height - radius, radius, pi/2, pi); /* right */ line_to(cr, 0, radius); restore(cr); } void make_card(string filename, real width, real height) { string new_name = "all-" + filename; real text_pos = width / 12; cairo_t cr = new_svg(new_name, width, height); string label = String::wordsplit(filename, ".")[0]; outline(cr, width, height, width / 50); if (label == "deck") set_source_rgb(cr, 0, .8, 0); else set_source_rgb(cr, 1, 1, 1); fill(cr); if (label != "blank") { Rsvg::rsvg_t image = Rsvg::new_from_file(filename); save(cr); Rsvg::dimensions_t rsvg_dim = Rsvg::get_dimensions(image); translate(cr, (width - rsvg_dim.width) / 2, (height - rsvg_dim.height) / 2); Rsvg::render(image, cr); restore(cr); } outline(cr, width, height, width / 50); set_source_rgb(cr, 0, 0, 0); stroke(cr); if (label != "deck" && label != "blank") { set_font(cr, "ITC Benguiat Gothic Std-10:bold"); set_source_rgb(cr, 0, 0, 0); text_extents_t extents = text_extents(cr, label); move_to(cr, text_pos - extents.x_bearing, text_pos - extents.y_bearing); text_path(cr, label); fill(cr); move_to(cr, width - text_pos - extents.x_advance, height - text_pos - (extents.height + extents.y_bearing)); text_path(cr, label); fill(cr); } destroy(cr); } void main() { for (int i = 1; i < dim(argv); i++) make_card(argv[i], 100, 150); } if (dim(argv) > 1) main(); kgames-2.2/xmille/cards/meson.build000066400000000000000000000031201416764561500173670ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # cards_xmille = files([ '25.svg', '50.svg', '75.svg', '100.svg', '200.svg', 'Accident.svg', 'As du volant.svg', 'Citerne d\'essence.svg', 'Crevé.svg', 'deck.svg', 'Essence.svg', 'Fin de limite.svg', 'Increvable.svg', 'Limite De Vitesse.svg', 'Panne D\'Essence.svg', 'Réparations.svg', 'Roue de secours.svg', 'Roulez.svg', 'Stop!.svg', 'Véhicule prioritaire.svg', ]) kgames-2.2/xmille/cards/miles000066400000000000000000000277731416764561500163050ustar00rootroot00000000000000#define miles_mask_width 100 #define miles_mask_height 150 static char miles_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/miles_both000066400000000000000000000277731416764561500173210ustar00rootroot00000000000000#define miles_both_width 100 #define miles_both_height 150 static char miles_both_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xc3, 0x1f, 0xc0, 0x0f, 0xf0, 0x87, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x1f, 0xff, 0x81, 0x1f, 0xc0, 0x0f, 0xf0, 0x03, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x0f, 0xff, 0x3c, 0x9f, 0xff, 0xff, 0xf9, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0x3f, 0x9f, 0xff, 0xff, 0xf9, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0x3f, 0x9f, 0xff, 0xff, 0xfc, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0x3f, 0x9f, 0xf1, 0xff, 0xfc, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0x9f, 0x1f, 0xe0, 0x7f, 0xfe, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xcf, 0x1f, 0xc6, 0x7f, 0xfe, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xe7, 0xff, 0xcf, 0x3f, 0xff, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xf3, 0xff, 0xcf, 0x3f, 0xff, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xf9, 0xff, 0xcf, 0x9f, 0xff, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x3f, 0xff, 0xf9, 0x9f, 0xe7, 0x9f, 0xff, 0x79, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0x0f, 0xfc, 0x00, 0x1f, 0xe0, 0xcf, 0xff, 0x03, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x0f, 0xfc, 0x00, 0x7f, 0xf0, 0xcf, 0xff, 0x87, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/miles_mask000066400000000000000000000277731416764561500173200ustar00rootroot00000000000000#define miles_mask_width 100 #define miles_mask_height 150 static char miles_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/out.c000066400000000000000000000001141416764561500162000ustar00rootroot00000000000000# define static # include "_out" # include "out_label" # include "out_mask" kgames-2.2/xmille/cards/out.h000066400000000000000000000000651416764561500162120ustar00rootroot00000000000000# define static # include "out" # include "out_mask" kgames-2.2/xmille/cards/out_both000066400000000000000000000277651416764561500170200ustar00rootroot00000000000000#define out_both_width 100 #define out_both_height 150 static char out_both_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x7e, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xbe, 0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xbe, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xde, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xde, 0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xde, 0x7e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xbe, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xbe, 0xb0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x7e, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xf1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xe0, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xf8, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xc0, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0x7f, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xbf, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xbf, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x9f, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xf3, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0x9f, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0x9f, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0x3f, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xf7, 0xfe, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xce, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xb0, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xbe, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x7e, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x78, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x7e, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xbe, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xb0, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xce, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/out_label000066400000000000000000000277701416764561500171370ustar00rootroot00000000000000#define out_label_width 100 #define out_label_height 150 static char out_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/out_mask000066400000000000000000000277651416764561500170170ustar00rootroot00000000000000#define out_mask_width 100 #define out_mask_height 150 static char out_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x80, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x40, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x40, 0x00, 0x08, 0x08, 0x01, 0x04, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x08, 0x08, 0x01, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x08, 0x01, 0x04, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/outline000066400000000000000000000277461416764561500166530ustar00rootroot00000000000000#define foo_width 100 #define foo_height 150 static char foo_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/puncture.c000066400000000000000000000001341416764561500172400ustar00rootroot00000000000000# define static # include "_puncture" # include "puncture_mask" # include "puncture_label" kgames-2.2/xmille/cards/puncture_both000066400000000000000000000300041416764561500200320ustar00rootroot00000000000000#define puncture_both_width 100 #define puncture_both_height 150 static char puncture_both_bits[] = { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x07, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x38, 0xc0, 0x01, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x01, 0x00, 0x06, 0x00, 0x06, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x01, 0x80, 0x01, 0x00, 0x18, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x00, 0x40, 0x00, 0x00, 0x20, 0x00, 0xf0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x7f, 0x00, 0x30, 0x00, 0x00, 0xc0, 0x00, 0xe0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x7f, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0xe0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x3f, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0xc0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x3f, 0x00, 0x04, 0x07, 0x00, 0x0e, 0x02, 0xc0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0x82, 0x0f, 0x00, 0x1f, 0x04, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0xc1, 0x0f, 0x00, 0x3f, 0x08, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0xe1, 0x0f, 0x00, 0x7f, 0x08, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x80, 0xf0, 0x0f, 0x00, 0xff, 0x10, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x80, 0xf0, 0x0f, 0x00, 0xff, 0x10, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x40, 0xf0, 0x0f, 0x06, 0xfe, 0x20, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x40, 0xe0, 0x07, 0x06, 0x7c, 0x20, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x30, 0xc0, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x30, 0xc0, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x00, 0x06, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x00, 0x0f, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x00, 0x0f, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x00, 0x06, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x30, 0xc0, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x20, 0x00, 0x30, 0xc0, 0x00, 0x40, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x07, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xfe, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x40, 0x00, 0x00, 0x06, 0x00, 0x20, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x40, 0xe0, 0x07, 0x06, 0x7e, 0x20, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x80, 0xf0, 0x0f, 0x00, 0xff, 0x10, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x0f, 0x80, 0xf0, 0x0f, 0x00, 0xff, 0x10, 0x00, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0xf1, 0x0f, 0x00, 0xff, 0x08, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0xe1, 0x0f, 0x00, 0x7f, 0x08, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x1f, 0x00, 0xc2, 0x0f, 0x00, 0x3f, 0x04, 0x80, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x3f, 0x00, 0x82, 0x0f, 0x00, 0x1f, 0x02, 0xc0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x3f, 0x00, 0x04, 0x07, 0x00, 0x0e, 0x02, 0xc0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x7f, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0xe0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0x7f, 0x00, 0x10, 0x00, 0x00, 0xc0, 0x00, 0xe0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x00, 0x60, 0x00, 0x00, 0x20, 0x00, 0xf0, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x01, 0x80, 0x01, 0x00, 0x18, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x01, 0x00, 0x06, 0x00, 0x06, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x03, 0x00, 0x38, 0xc0, 0x01, 0x00, 0xfc, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x07, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0xff, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xfb, 0xff, 0xf7, 0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff}; kgames-2.2/xmille/cards/puncture_label000066400000000000000000000300071416764561500201600ustar00rootroot00000000000000#define puncture_label_width 100 #define puncture_label_height 150 static char puncture_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x83, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x93, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x83, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/puncture_mask000066400000000000000000000300041416764561500200310ustar00rootroot00000000000000#define puncture_mask_width 100 #define puncture_mask_height 150 static char puncture_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0x3f, 0xc0, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x07, 0x00, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xf8, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0xe0, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xfe, 0x1f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xc0, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xc0, 0xff, 0x03, 0x07, 0x00, 0x0e, 0xfc, 0x3f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0x81, 0x0f, 0x00, 0x1f, 0xf8, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0xc0, 0x0f, 0x00, 0x3f, 0xf0, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0xe0, 0x0f, 0x00, 0x7f, 0xf0, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x7f, 0xf0, 0x0f, 0x00, 0xff, 0xe0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x7f, 0xf0, 0x0f, 0x00, 0xff, 0xe0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x3f, 0xf0, 0x0f, 0x00, 0xfe, 0xc0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x3f, 0xe0, 0x07, 0x00, 0x7c, 0xc0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf8, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x3f, 0xe0, 0x07, 0x00, 0x7e, 0xc0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x7f, 0xf0, 0x0f, 0x00, 0xff, 0xe0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xf0, 0x7f, 0xf0, 0x0f, 0x00, 0xff, 0xe0, 0xff, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0xf0, 0x0f, 0x00, 0xff, 0xf0, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0xe0, 0x0f, 0x00, 0x7f, 0xf0, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0xc1, 0x0f, 0x00, 0x3f, 0xf8, 0x7f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xc0, 0xff, 0x81, 0x0f, 0x00, 0x1f, 0xfc, 0x3f, 0x00, 0x00, 0x08, 0x01, 0x00, 0xc0, 0xff, 0x03, 0x07, 0x00, 0x0e, 0xfc, 0x3f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xfe, 0x1f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0xc0, 0xff, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0xe0, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xf8, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x07, 0x00, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0x3f, 0xc0, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x00, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x04, 0x00, 0x08, 0x01, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/repairs.c000066400000000000000000000001301416764561500170340ustar00rootroot00000000000000# define static # include "_repairs" # include "repairs_label" # include "repairs_mask" kgames-2.2/xmille/cards/repairs_both000066400000000000000000000300011416764561500176270ustar00rootroot00000000000000#define repairs_both_width 100 #define repairs_both_height 150 static char repairs_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x17, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5b, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xc7, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xbb, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0x7d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0x55, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0x7d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x6d, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0x7d, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xc7, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xbb, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x01, 0x00, 0xde, 0xdf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xff, 0xff, 0xdf, 0xdf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, 0xd8, 0x01, 0x00, 0x6e, 0xb0, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xdf, 0xff, 0xff, 0xef, 0xbf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xdd, 0xfd, 0xff, 0xee, 0xba, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xee, 0xfb, 0x7f, 0xdf, 0xdd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x07, 0x80, 0xdf, 0xdf, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0x7e, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xab, 0x6a, 0x7e, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0x7e, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xfb, 0xff, 0x7e, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0x03, 0x00, 0xfe, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc5, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd6, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb5, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/repairs_label000066400000000000000000000300041416764561500177550ustar00rootroot00000000000000#define repairs_label_width 100 #define repairs_label_height 150 static char repairs_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/repairs_mask000066400000000000000000000300011416764561500176260ustar00rootroot00000000000000#define repairs_mask_width 100 #define repairs_mask_height 150 static char repairs_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x44, 0x08, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x82, 0x08, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xaa, 0x10, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x82, 0x10, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x92, 0x20, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x82, 0x20, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x38, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x20, 0xc0, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x20, 0x80, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0xfe, 0xff, 0x21, 0x20, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x20, 0x20, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xca, 0x27, 0xfe, 0xff, 0x91, 0x4f, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x10, 0x40, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x8a, 0x22, 0x02, 0x00, 0x11, 0x45, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x11, 0x04, 0x80, 0x20, 0x22, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0xf8, 0x7f, 0x20, 0x20, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfc, 0xff, 0x01, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x24, 0x22, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x54, 0x55, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x24, 0x22, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x04, 0x00, 0x81, 0x35, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xe0, 0x03, 0xfc, 0xff, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/right.c000066400000000000000000000001221416764561500165050ustar00rootroot00000000000000# define static # include "_right" # include "right_label" # include "right_mask" kgames-2.2/xmille/cards/right_both000066400000000000000000000277731416764561500173250ustar00rootroot00000000000000#define right_both_width 100 #define right_both_height 150 static char right_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x61, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x81, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xe1, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x81, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x61, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x92, 0x24, 0x49, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x92, 0x24, 0x49, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x54, 0xfc, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x54, 0x84, 0x6c, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0x57, 0xb4, 0x6c, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x00, 0x50, 0x84, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x3e, 0x50, 0xfc, 0x00, 0x7c, 0x1f, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x41, 0x50, 0x00, 0x00, 0x82, 0x20, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xa0, 0x9c, 0x50, 0x00, 0x00, 0x39, 0x4e, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xa2, 0xff, 0xff, 0xff, 0x45, 0xd1, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x54, 0x15, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x44, 0x11, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x38, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x7f, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x01, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x01, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f}; kgames-2.2/xmille/cards/right_label000066400000000000000000000277761416764561500174530ustar00rootroot00000000000000#define right_label_width 100 #define right_label_height 150 static char right_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xfd, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/right_mask000066400000000000000000000277731416764561500173240ustar00rootroot00000000000000#define right_mask_width 100 #define right_mask_height 150 static char right_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x92, 0x24, 0x49, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x92, 0x24, 0x49, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xc0, 0xdf, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x54, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x54, 0xfc, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x90, 0x54, 0x84, 0x6c, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xff, 0x57, 0xb4, 0x6c, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x00, 0x50, 0x84, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x3e, 0x50, 0xfc, 0x00, 0x7c, 0x1f, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0x20, 0x41, 0x50, 0x00, 0x00, 0x82, 0x20, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xa0, 0x9c, 0x50, 0x00, 0x00, 0x39, 0x4e, 0x08, 0x00, 0x00, 0x08, 0x01, 0x00, 0xe0, 0xa2, 0xff, 0xff, 0xff, 0x45, 0xd1, 0x0f, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x54, 0x15, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x44, 0x11, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x38, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x80, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x80, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/spare.c000066400000000000000000000001221416764561500165020ustar00rootroot00000000000000# define static # include "_spare" # include "spare_label" # include "spare_mask" kgames-2.2/xmille/cards/spare_both000066400000000000000000000277731416764561500173220ustar00rootroot00000000000000#define spare_both_width 100 #define spare_both_height 150 static char spare_both_bits[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x37, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xed, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xf5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x37, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xc7, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xbb, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xef, 0xff, 0xff, 0xdf, 0x3f, 0xff, 0x17, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xef, 0xff, 0xff, 0xdf, 0x7f, 0xff, 0x3b, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0x2b, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xfe, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0xfe, 0x67, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x01, 0x00, 0xde, 0xdf, 0xfe, 0xef, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0xff, 0xff, 0xdf, 0xdf, 0xfe, 0x2f, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x35, 0xd8, 0x01, 0x00, 0x6e, 0xb0, 0xfe, 0xb7, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xdf, 0xff, 0xff, 0xef, 0xbf, 0x7e, 0xb7, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x75, 0xdd, 0xfd, 0xff, 0xee, 0xba, 0x9e, 0x92, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xed, 0xee, 0xfb, 0x7f, 0xdf, 0xdd, 0xe6, 0x46, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xed, 0xef, 0x07, 0x80, 0xdf, 0xdf, 0x7a, 0x21, 0xfb, 0xff, 0xff, 0xff, 0xff, 0x9d, 0xf3, 0xff, 0xff, 0x3f, 0xe7, 0x5a, 0x89, 0xf3, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xfc, 0xff, 0xff, 0xff, 0xf8, 0xd6, 0xc2, 0xe1, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xd6, 0xee, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x35, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6f, 0xb5, 0xe7, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0xab, 0xf9, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0xca, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xbe, 0xc6, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0xbe, 0xcd, 0xf6, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0xfe, 0x9f, 0x7f, 0x67, 0xe8, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xab, 0x6a, 0xfe, 0x1f, 0x7e, 0xf1, 0xef, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xdb, 0xdd, 0xfe, 0x9f, 0xf8, 0x76, 0xd0, 0xff, 0xff, 0xff, 0xff, 0xaf, 0xfa, 0xfb, 0xff, 0xfe, 0x9f, 0xf3, 0x87, 0xcf, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0x03, 0x00, 0xfe, 0x0f, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8d, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf6, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8d, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x73, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; kgames-2.2/xmille/cards/spare_label000066400000000000000000000277761416764561500174500ustar00rootroot00000000000000#define spare_label_width 100 #define spare_label_height 150 static char spare_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/spare_mask000066400000000000000000000277731416764561500173210ustar00rootroot00000000000000#define spare_mask_width 100 #define spare_mask_height 150 static char spare_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x38, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x40, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x70, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x20, 0xc0, 0x00, 0xe8, 0x00, 0x08, 0x01, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x20, 0x80, 0x00, 0xc4, 0x01, 0x08, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0xd4, 0x01, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x04, 0x01, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0x01, 0x8c, 0x01, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x01, 0x98, 0x00, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0xfe, 0xff, 0x21, 0x20, 0x01, 0x10, 0x01, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0x00, 0x00, 0x20, 0x20, 0x01, 0xd0, 0x01, 0x08, 0x01, 0x00, 0x00, 0xca, 0x27, 0xfe, 0xff, 0x91, 0x4f, 0x01, 0x48, 0x03, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x10, 0x40, 0x81, 0x48, 0x02, 0x08, 0x01, 0x00, 0x00, 0x8a, 0x22, 0x02, 0x00, 0x11, 0x45, 0xe1, 0x6d, 0x03, 0x08, 0x01, 0x00, 0x00, 0x12, 0x11, 0x04, 0x80, 0x20, 0x22, 0xf9, 0xb9, 0x05, 0x08, 0x01, 0x00, 0x00, 0x12, 0x10, 0xf8, 0x7f, 0x20, 0x20, 0x7d, 0xdf, 0x04, 0x08, 0x01, 0x00, 0x00, 0x62, 0x0c, 0x00, 0x00, 0xc0, 0x18, 0x5d, 0x77, 0x0c, 0x08, 0x01, 0x00, 0x00, 0x82, 0x03, 0x00, 0x00, 0x00, 0x07, 0xd9, 0x3e, 0x1e, 0x08, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x2e, 0x11, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb0, 0xcd, 0x10, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x4d, 0x18, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x61, 0x5b, 0x06, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe1, 0x3a, 0x02, 0x08, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfc, 0xff, 0x01, 0x00, 0xc1, 0x36, 0x03, 0x08, 0x01, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0xff, 0xff, 0xc1, 0x3d, 0x09, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x24, 0x22, 0x01, 0x60, 0x80, 0x9f, 0x17, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x54, 0x55, 0x01, 0xe0, 0x81, 0x0f, 0x10, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x24, 0x22, 0x01, 0x60, 0x07, 0x89, 0x2f, 0x08, 0x01, 0x00, 0x00, 0xb0, 0x06, 0x04, 0x00, 0x01, 0x60, 0x0c, 0x78, 0x30, 0x08, 0x01, 0x00, 0x00, 0xe0, 0x03, 0xfc, 0xff, 0x01, 0xf0, 0x18, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/speed.c000066400000000000000000000000721416764561500164740ustar00rootroot00000000000000# define static # include "_speed" # include "speed_mask" kgames-2.2/xmille/cards/speed_both000066400000000000000000000277731416764561500173100ustar00rootroot00000000000000#define speed_both_width 100 #define speed_both_height 150 static char speed_both_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x73, 0xde, 0x3b, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x94, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x90, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x73, 0xce, 0x49, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x14, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x14, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x13, 0xde, 0x3b, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x70, 0xd1, 0x7d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x20, 0x9b, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x20, 0x95, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x77, 0xd1, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0x81, 0x0f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0xe1, 0x3f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x60, 0x30, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x01, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x3d, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xff, 0x30, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xc3, 0x31, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x33, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x33, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x33, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x33, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x33, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x81, 0x31, 0x60, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xc3, 0x61, 0x30, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xff, 0xe0, 0x3f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x3c, 0x80, 0x0f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/speed_mask000066400000000000000000000277731416764561500173070ustar00rootroot00000000000000#define speed_mask_width 100 #define speed_mask_height 150 static char speed_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x73, 0xde, 0x3b, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x94, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x90, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x73, 0xce, 0x49, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x14, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x14, 0x42, 0x48, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x13, 0xde, 0x3b, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x70, 0xd1, 0x7d, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x9b, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x95, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x20, 0x91, 0x10, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x84, 0x77, 0xd1, 0x11, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/cards/stop.c000066400000000000000000000001171416764561500163610ustar00rootroot00000000000000# define static # include "_stop" # include "stop_label" # include "stop_mask" kgames-2.2/xmille/cards/stop_label000066400000000000000000000277731416764561500173200ustar00rootroot00000000000000#define stop_label_width 100 #define stop_label_height 150 static char stop_label_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; kgames-2.2/xmille/cards/stop_mask000066400000000000000000000277701416764561500171710ustar00rootroot00000000000000#define stop_mask_width 100 #define stop_mask_height 150 static char stop_mask_bits[] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfe, 0xff, 0xf7, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfd, 0xff, 0xfb, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xfb, 0xff, 0xfd, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xe7, 0x7f, 0xfe, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0x1f, 0x8f, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xf0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00}; kgames-2.2/xmille/color.h000066400000000000000000000004631416764561500154270ustar00rootroot00000000000000/* * color.h * * definitions for standard colors */ # define BLACK_COLOR 0 # define WHITE_COLOR 1 # define RED_COLOR 2 # define GREEN_COLOR 3 # define GREY_COLOR 4 # define BLUE_COLOR 5 # define NUM_COLOR 6 struct color { char *name; GC gc; int pixel; }; extern struct color colorMap[NUM_COLOR]; kgames-2.2/xmille/comp.c000066400000000000000000000273441416764561500152510ustar00rootroot00000000000000/* $NetBSD: comp.c,v 1.9 2003/08/07 09:37:24 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" /* * @(#)comp.c 1.1 (Berkeley) 4/1/82 */ # define V_VALUABLE 40 void calcmove(void) { CARD card; int *value; PLAY *pp, *op; bool foundend, canstop, foundlow; int cango; unsigned int count200, badcount, nummin, nummax, diff; int curmin, curmax; CARD safe, oppos; int valbuf[HAND_SZ], count[NUM_CARDS]; bool playit[HAND_SZ]; MilleMessage(""); pp = &Player[COMP]; op = &Player[PLAYER]; safe = 0; cango = 0; canstop = FALSE; foundend = FALSE; /* Try for a Coup Forre, and see what we have. */ for (int i = 0; i < NUM_CARDS; i++) count[i] = 0; for (int i = 0; i < HAND_SZ; i++) { card = pp->hand[i]; switch (card) { case C_STOP: case C_CRASH: case C_FLAT: case C_EMPTY: if ((playit[i] = canplay(pp, op, card)) != 0) canstop = TRUE; goto norm; case C_LIMIT: if ((playit[i] = canplay(pp, op, card)) && Numseen[C_25] == Numcards[C_25] && Numseen[C_50] == Numcards[C_50]) canstop = TRUE; goto norm; case C_25: case C_50: case C_75: case C_100: case C_200: if ((playit[i] = canplay(pp, op, card)) && pp->mileage + Value[card] == End) foundend = TRUE; goto norm; default: playit[i] = canplay(pp, op, card); norm: if (playit[i]) cango++; break; case C_GAS_SAFE: case C_DRIVE_SAFE: case C_SPARE_SAFE: case C_RIGHT_WAY: if (pp->battle == opposite(card) || (pp->speed == C_LIMIT && card == C_RIGHT_WAY)) { Movetype = M_PLAY; Card_no = i; return; } ++safe; playit[i] = TRUE; break; } if (card >= 0) ++count[card]; } /* No Coup Forre. Draw to fill hand, then restart, as needed. */ if (pp->hand[0] == C_INIT && Topcard > Deck) { Movetype = M_DRAW; return; } #ifdef DEBUG if (Debug) fprintf(outf, "CALCMOVE: cango = %d, canstop = %d, safe = %d\n", cango, canstop, safe); #endif if (foundend) foundend = !check_ext(TRUE); for (int i = 0; safe && i < HAND_SZ; i++) { if (is_safety(pp->hand[i])) { if (onecard(op) || (foundend && cango && !canstop)) { #ifdef DEBUG if (Debug) fprintf(outf, "CALCMOVE: onecard(op) = %d, foundend = %d\n", onecard(op), foundend); #endif playsafe: Movetype = M_PLAY; Card_no = i; return; } oppos = opposite(pp->hand[i]); if (Numseen[oppos] == Numcards[oppos] && !(pp->hand[i] == C_RIGHT_WAY && Numseen[C_LIMIT] != Numcards[C_LIMIT])) goto playsafe; else if (!cango && (op->can_go || !pp->can_go || Topcard < Deck)) { card = (Topcard - Deck) - roll(1, 10); if ((!pp->mileage) != (!op->mileage)) card -= 7; #ifdef DEBUG if (Debug) fprintf(outf, "CALCMOVE: card = %d, DECK_SZ / 4 = %d\n", card, DECK_SZ / 4); #endif if (card < DECK_SZ / 4) goto playsafe; } safe--; playit[i] = cango; } } if (!pp->can_go && !is_repair(pp->battle)) Numneed[opposite(pp->battle)]++; redoit: foundlow = (cango || count[C_END_LIMIT] != 0 || Numseen[C_LIMIT] == Numcards[C_LIMIT] || pp->safety[S_RIGHT_WAY] != S_UNKNOWN); foundend = FALSE; count200 = pp->nummiles[C_200]; badcount = 0; curmax = -1; curmin = 101; nummin = -1; nummax = -1; value = valbuf; for (int i = 0; i < HAND_SZ; i++) { card = pp->hand[i]; if (is_safety(card) || playit[i] == (cango != 0)) { #ifdef DEBUG if (Debug) fprintf(outf, "CALCMOVE: switch(\"%s\")\n", C_name[card]); #endif switch (card) { case C_25: case C_50: diff = End - pp->mileage; /* avoid getting too close */ if (Topcard > Deck && cango && diff <= 100 && (int)diff / Value[card] > count[card] && (card == C_25 || diff % 50 == 0)) { if (card == C_50 && diff - 50 == 25 && count[C_25] > 0) goto okay; *value = 0; if (--cango <= 0) goto redoit; break; } okay: *value = (Value[card] >> 3); if (pp->speed == C_LIMIT) ++*value; else --*value; if (!foundlow && (card == C_50 || count[C_50] == 0)) { *value = (pp->mileage ? 10 : 20); foundlow = TRUE; } goto miles; case C_200: if (++count200 > 2) { *value = 0; break; } /* FALLTHROUGH */ case C_75: case C_100: *value = (Value[card] >> 3); if (pp->speed == C_LIMIT) --*value; else ++*value; miles: if (pp->mileage + Value[card] > End) *value = (End == 700 ? card : 0); else if (pp->mileage + Value[card] == End) { *value = (foundend ? card : V_VALUABLE); foundend = TRUE; } break; case C_END_LIMIT: if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN) *value = (pp->safety[S_RIGHT_WAY] == S_PLAYED ? -1 : 1); else if (pp->speed == C_LIMIT && End - pp->mileage <= 50) *value = 1; else if (pp->speed == C_LIMIT || Numseen[C_LIMIT] != Numcards[C_LIMIT]) { safe = S_RIGHT_WAY; oppos = C_LIMIT; goto repair; } else { *value = 0; --count[C_END_LIMIT]; } break; case C_REPAIRS: case C_SPARE: case C_GAS: safe = safety(card) - S_CONV; oppos = opposite(card); if (pp->safety[safe] != S_UNKNOWN) *value = (pp->safety[safe] == S_PLAYED ? -1 : 1); else if (pp->battle != oppos && (Numseen[oppos] == Numcards[oppos] || Numseen[oppos] + count[card] > Numcards[oppos])) { *value = 0; --count[card]; } else { repair: *value = Numcards[oppos] * 6; *value += Numseen[card] - Numseen[oppos]; if (!cango) *value /= (count[card]*count[card]); count[card]--; } break; case C_GO: if (pp->safety[S_RIGHT_WAY] != S_UNKNOWN) *value = (pp->safety[S_RIGHT_WAY] == S_PLAYED ? -1 : 2); else if (pp->can_go && Numgos + count[C_GO] == Numneed[C_GO]) { *value = 0; --count[C_GO]; } else { *value = Numneed[C_GO] * 3; *value += (Numseen[C_GO] - Numgos); *value /= (count[C_GO] * count[C_GO]); count[C_GO]--; } break; case C_LIMIT: if (op->mileage + 50 >= End) { *value = (End == 700 && !cango); break; } if (canstop || (cango && !op->can_go)) *value = 1; else { *value = (pp->safety[S_RIGHT_WAY] != S_UNKNOWN ? 2 : 3); safe = S_RIGHT_WAY; oppos = C_END_LIMIT; goto normbad; } break; case C_CRASH: case C_EMPTY: case C_FLAT: safe = safety(card) - S_CONV; oppos = opposite(card); *value = (pp->safety[safe]!=S_UNKNOWN ? 3 : 4); normbad: if (op->safety[safe] == S_PLAYED) *value = -1; else { *value *= Numneed[oppos] + Numseen[oppos] + 2; if (!pp->mileage || foundend || onecard(op)) *value += 5; if (op->mileage == 0 || onecard(op)) *value += 5; if (op->speed == C_LIMIT) *value -= 3; if (cango && pp->safety[safe] != S_UNKNOWN) *value += 3; if (!cango) *value /= ++badcount; } break; case C_STOP: if (op->safety[S_RIGHT_WAY] == S_PLAYED) *value = -1; else { *value = (pp->safety[S_RIGHT_WAY] != S_UNKNOWN ? 3 : 4); *value *= Numcards[C_STOP] + Numseen[C_GO]; if (!pp->mileage || foundend || onecard(op)) *value += 5; if (!cango) *value /= ++badcount; if (op->mileage == 0) *value += 5; if ((card == C_LIMIT && op->speed == C_LIMIT) || !op->can_go) *value -= 5; if (cango && pp->safety[S_RIGHT_WAY] != S_UNKNOWN) *value += 5; } break; case C_GAS_SAFE: case C_DRIVE_SAFE: case C_SPARE_SAFE: case C_RIGHT_WAY: *value = cango ? 0 : 101; break; case C_INIT: *value = 0; break; } } else *value = cango ? 0 : 101; if (card != C_INIT) { if (*value >= curmax) { nummax = i; curmax = *value; } if (*value <= curmin) { nummin = i; curmin = *value; } } #ifdef DEBUG if (Debug) debug(i, "%3d %-14s", *value, C_name[pp->hand[i]]); #endif value++; } if (!pp->can_go && !is_repair(pp->battle)) Numneed[opposite(pp->battle)]++; if (cango) { play_it: ComputerStatus("PLAY"); Movetype = M_PLAY; Card_no = nummax; } else { if (is_safety(pp->hand[nummin])) { /* NEVER discard a safety */ nummax = nummin; goto play_it; } ComputerStatus("DISCARD"); Movetype = M_DISCARD; Card_no = nummin; } ComputerCard(pp->hand[Card_no]); } /* * Return true if the given player could conceivably win with his next card. */ int onecard(const PLAY *pp) { CARD bat, spd, card; bat = pp->battle; spd = pp->speed; card = -1; if (pp->can_go || ((is_repair(bat) || bat == C_STOP || spd == C_LIMIT) && Numseen[S_RIGHT_WAY] != 0) || (bat >= 0 && Numseen[(int) safety(bat)] != 0)) switch (End - pp->mileage) { case 200: if (pp->nummiles[C_200] == 2) return FALSE; card = C_200; /* FALLTHROUGH */ case 100: case 75: if (card == -1) card = (End - pp->mileage == 75 ? C_75 : C_100); if (spd == C_LIMIT) return Numseen[S_RIGHT_WAY] == 0; /* FALLTHROUGH */ case 50: case 25: if (card == -1) card = (End - pp->mileage == 25 ? C_25 : C_50); return Numseen[card] != Numcards[card]; } return FALSE; } int canplay(const PLAY *pp, const PLAY *op, CARD card) { switch (card) { case C_200: if (pp->nummiles[C_200] == 2) break; /* FALLTHROUGH */ case C_75: case C_100: if (pp->speed == C_LIMIT) break; /* FALLTHROUGH */ case C_50: if (pp->mileage + Value[card] > End) break; /* FALLTHROUGH */ case C_25: if (pp->can_go) return TRUE; break; case C_EMPTY: case C_FLAT: case C_CRASH: case C_STOP: if (op->can_go && op->safety[safety(card) - S_CONV] != S_PLAYED) return TRUE; break; case C_LIMIT: if (op->speed != C_LIMIT && op->safety[S_RIGHT_WAY] != S_PLAYED && op->mileage + 50 < End) return TRUE; break; case C_GAS: case C_SPARE: case C_REPAIRS: if (pp->battle == opposite(card)) return TRUE; break; case C_GO: if (!pp->can_go && (is_repair(pp->battle) || pp->battle == C_STOP)) return TRUE; break; case C_END_LIMIT: if (pp->speed == C_LIMIT) return TRUE; } return FALSE; } kgames-2.2/xmille/curses_ui.c000066400000000000000000000261371416764561500163130ustar00rootroot00000000000000/* * ui.c * * curses interface routines for mille */ # include "mille.h" #undef TRUE #undef FALSE # include "ui.h" #ifdef CTRL # undef CTRL #endif #define CTRL(x) (x - 'A' + 1) #define reg register WINDOW *Board, *Miles, *Score; char *C_fmt = "%-18.18s"; /* format for printing cards */ char Initstr[100]; /* initial string for error field */ char *_cn[NUM_CARDS] = { /* Card name buffer */ "", "25", "50", "75", "100", "200", "Out of Gas", "Flat Tire", "Accident", "Stop", "Speed Limit", "Gasoline", "Spare Tire", "Repairs", "Go", "End of Limit", "Extra Tank", "Puncture Proof", "Driving Ace", "Right of Way" }, **C_name = &_cn[1]; /* Card names */ Message (string) char *string; { wmove (Score, ERR_Y, ERR_X); waddstr (Score, string); wclrtoeol (Score); } debug (pos, string, a0, a1, a2) { mvprintw (pos+6, 2, string, a0, a1, a2); } ComputerStatus (string) { mvaddstr (MOVE_Y + 1, MOVE_X, string); } void ComputerCard (int type) { mvprintw (MOVE_Y + 2, MOVE_X, "%16s", C_name[type]); } Prompt (string) char *string; { mvaddstr (MOVE_Y, MOVE_X, string); clrtoeol (); refresh (); } char * GetpromptedInput (string) char *string; { static char buf[1024]; char *sp; sp = buf; Prompt (string); leaveok (Board, FALSE); while ((*sp = readch()) != '\n') { if (*sp == _tty.sg_kill) { sp = buf; break; } else if (*sp == _tty.sg_erase) { if (--sp < buf) sp = buf; else { addch('\b'); /* * if the previous char was a control * char, cover up two characters. */ if (*sp < ' ') addch('\b'); clrtoeol(); } } else addstr(unctrl(*sp++)); refresh(); } *sp = '\0'; leaveok (Board, TRUE); return buf; } newboard() { werase(Board); werase(Score); mvaddstr(5, 0, "--HAND--"); mvaddch(6, 0, 'P'); mvaddch(7, 0, '1'); mvaddch(8, 0, '2'); mvaddch(9, 0, '3'); mvaddch(10, 0, '4'); mvaddch(11, 0, '5'); mvaddch(12, 0, '6'); mvaddstr(13, 0, "--BATTLE--"); mvaddstr(15, 0, "--SPEED--"); mvaddstr(5, 20, "--DECK--"); mvaddstr(7, 20, "--DISCARD--"); mvaddstr(13, 20, "--BATTLE--"); mvaddstr(15, 20, "--SPEED--"); wmove(Miles, 0, 0); if (winch(Miles) != '-') { werase(Miles); mvwaddstr(Miles, 0, 0, "--MILEAGE--"); mvwaddstr(Miles, 0, 41, "--MILEAGE--"); } else { wmove(Miles, 1, 0); wclrtobot(Miles); } newscore(); stdscr = Board; } newscore() { reg int i; stdscr = Score; move(0, 22); if (inch() != 'Y') { erase(); mvaddstr(0, 22, "You Comp Value"); mvaddstr(1, 2, "Milestones Played"); mvaddstr(2, 8, "Each Safety"); mvaddstr(3, 5, "All 4 Safeties"); mvaddstr(4, 3, "Each Coup Fourre"); mvaddstr(2, 37, "100"); mvaddstr(3, 37, "300"); mvaddstr(4, 37, "300"); } else { move(5, 1); clrtobot(); } for (i = 0; i < SCORE_Y; i++) mvaddch(i, 0, '|'); move(SCORE_Y - 1, 1); while (addch('_') != ERR) continue; if (WIndow == W_FULL || Finished) { mvaddstr(5, 5, "Trip Completed"); mvaddstr(6, 10, "Safe Trip"); mvaddstr(7, 5, "Delayed Action"); mvaddstr(8, 10, "Extension"); mvaddstr(9, 11, "Shut-Out"); mvaddstr(10, 21, "---- ---- -----"); mvaddstr(11, 9, "Hand Total"); mvaddstr(12, 20, "----- -----"); mvaddstr(13, 6, "Overall Total"); mvaddstr(14, 15, "Games"); mvaddstr(5, 37, "400"); mvaddstr(6, 37, "300"); mvaddstr(7, 37, "300"); mvaddstr(8, 37, "200"); mvaddstr(9, 37, "500"); } else { mvaddstr(5, 21, "---- ---- -----"); mvaddstr(6, 9, "Hand Total"); mvaddstr(7, 20, "----- -----"); mvaddstr(8, 6, "Overall Total"); mvaddstr(9, 15, "Games"); mvaddstr(11, 2, "p: pick"); mvaddstr(12, 2, "u: use #"); mvaddstr(13, 2, "d: discard #"); mvaddstr(14, 2, "w: toggle window"); mvaddstr(11, 21, "q: quit"); mvaddstr(12, 21, "o: order hand"); mvaddstr(13, 21, "s: save"); mvaddstr(14, 21, "r: reprint"); } stdscr = Board; } init_ui () { initscr(); # ifdef attron # define CA cursor_address # endif if (!CA) { printf("Sorry. Need cursor addressing to play mille\n"); exit(-1); } delwin(stdscr); stdscr = Board = newwin(BOARD_Y, BOARD_X, 0, 0); Score = newwin(SCORE_Y, SCORE_X, 0, 40); Miles = newwin(MILES_Y, MILES_X, 17, 0); #ifdef attron idlok(Board, TRUE); idlok(Score, TRUE); idlok(Miles, TRUE); #endif leaveok(Score, TRUE); leaveok(Miles, TRUE); clearok(curscr, TRUE); crmode(); noecho(); } Error (string, arg) char *string; { stdscr = Score; mvprintw (Score, ERR_Y, ERR_X, string, arg); clrtoeol (); stdscr = Board; } finish_ui () { mvcur(0, COLS - 1, LINES - 1, 0); endwin(); } update_ui () { refresh (); } Beep () { putchar ('\007'); } CARD getcard() { reg char c, c1; for (;;) { while ((c = readch()) == '\n' || c == '\r' || c == ' ') continue; if (islower(c)) c = toupper(c); if (c == _tty.sg_kill || c == _tty.sg_erase) return -1; addstr(unctrl(c)); clrtoeol(); switch (c) { case '1': case '2': case '3': case '4': case '5': case '6': c -= '0'; break; case '0': case 'P': case 'p': c = 0; break; default: putchar(''); addch('\b'); if (!isprint(c)) addch('\b'); c = -1; break; } refresh(); if (c >= 0) { while ((c1=readch()) != '\r' && c1 != '\n' && c1 != ' ') if (c1 == _tty.sg_kill) return -1; else if (c1 == _tty.sg_erase) { addch('\b'); clrtoeol(); refresh(); goto cont; } else write(0, "", 1); return c; } cont: ; } } /* * Get a yes or no answer to the given question. Saves are * also allowed. Return TRUE if the answer was yes, FALSE if no. */ getyn(prompt) reg char *prompt; { reg char c; Saved = FALSE; for (;;) { leaveok(Board, FALSE); mvaddstr(MOVE_Y, MOVE_X, prompt); clrtoeol(); refresh(); switch (c = readch()) { case 'n': case 'N': addch('N'); refresh(); leaveok(Board, TRUE); return FALSE; case 'y': case 'Y': addch('Y'); refresh(); leaveok(Board, TRUE); return TRUE; case 's': case 'S': addch('S'); refresh(); Saved = save(); continue; default: addstr(unctrl(c)); refresh(); putchar(''); break; } } } readch() { reg int cnt; static char c; for (cnt = 0; read(0, &c, 1) <= 0; cnt++) if (cnt > 100) exit(1); return c; } // Ancestral code had special debugging for the only for the author based on // his UID. This code was out of date (we have no reason to assume his UID is // correct), but we might want to keep the debugging idea protected by that // block For now, we'll just leave it memorialized like this. static int KenArnoldIsPlayer() { return FALSE; } getmove() { reg char c, *sp; static char moveprompt[] = ">>:Move:"; #ifdef EXTRAP static bool last_ex = FALSE; /* set if last command was E */ if (last_ex) { undoex(); prboard(); last_ex = FALSE; } #endif for (;;) { stand(MOVE_Y, MOVE_X, moveprompt); clrtoeol(); move(MOVE_Y, MOVE_X + sizeof moveprompt); leaveok(Board, FALSE); refresh(); while ((c = readch()) == _tty.sg_kill || c == _tty.sg_erase) continue; if (islower(c)) c = toupper(c); if (isprint(c) && !isspace(c)) { addch(c); refresh(); } switch (c) { case 'P': /* Pick */ Movetype = M_DRAW; goto ret; case 'U': /* Use Card */ case 'D': /* Discard Card */ if ((Card_no = getcard()) < 0) break; Movetype = (c == 'U' ? M_PLAY : M_DISCARD); goto ret; case 'O': /* Order */ Order = !Order; Movetype = M_ORDER; goto ret; case 'Q': /* Quit */ rub(); /* Same as a rubout */ break; case 'W': /* WIndow toggle */ WIndow = nextwin(WIndow); newscore(); prscore(TRUE); wrefresh(Score); break; case 'R': /* Redraw screen */ case CTRL('L'): clearok(curscr, TRUE); newboard(); prboard(); break; case 'S': /* Save game */ On_exit = FALSE; save(); break; case 'E': /* Extrapolate */ #ifdef EXTRAP if (last_ex) break; Finished = TRUE; if (WIndow != W_FULL) newscore(); prscore(FALSE); wrefresh(Score); last_ex = TRUE; Finished = FALSE; #else error("%c: command not implemented", c); #endif break; case '\r': /* Ignore RETURNs and */ case '\n': /* Line Feeds */ case ' ': /* Spaces */ case '\0': /* and nulls */ break; case 'Z': /* Debug code */ if (KenArnoldIsPlayer()) { if (!Debug && outf == NULL) { char buf[40]; over: mvaddstr(MOVE_Y, MOVE_X, "file: "); clrtoeol(); leaveok(Board, FALSE); refresh(); sp = buf; while ((*sp = readch()) != '\n') { if (*sp == _tty.sg_kill) goto over; else if (*sp == _tty.sg_erase) { if (--sp < buf) sp = buf; else { addch('\b'); if (*sp < ' ') addch('\b'); clrtoeol(); } } else addstr(unctrl(*sp++)); refresh(); } *sp = '\0'; leaveok(Board, TRUE); if ((outf = fopen(buf, "w")) == NULL) perror(buf); setbuf(outf, 0); } Debug = !Debug; break; } /* FALLTHROUGH */ default: error("unknown command: %s", unctrl(c)); break; } } ret: leaveok(Board, TRUE); } # define COMP_STRT 20 # define CARD_STRT 2 prboard() { reg PLAY *pp; reg int i, j, k, temp; for (k = 0; k < 2; k++) { pp = &Player[k]; temp = k * COMP_STRT + CARD_STRT; for (i = 0; i < NUM_SAFE; i++) if (pp->safety[i] == S_PLAYED) { mvaddstr(i, temp, C_name[i + S_CONV]); if (pp->coups[i]) mvaddch(i, temp - CARD_STRT, '*'); } mvprintw(14, temp, C_fmt, C_name[pp->battle]); mvprintw(16, temp, C_fmt, C_name[pp->speed]); for (i = C_25; i <= C_200; ) { reg char *name; reg int end; name = C_name[i]; temp = k * 40; end = pp->nummiles[i++]; for (j = 0; j < end; j++) mvwaddstr(Miles, i, (j << 2) + temp, name); } } prscore(TRUE); temp = CARD_STRT; pp = &Player[PLAYER]; for (i = 0; i < HAND_SZ; i++) mvprintw(i + 6, temp, C_fmt, C_name[pp->hand[i]]); mvprintw(6, COMP_STRT + CARD_STRT, "%2d", Topcard - Deck); mvprintw(8, COMP_STRT + CARD_STRT, C_fmt, C_name[Discard]); if (End == 1000) { static char ext[] = "Extension"; stand(EXT_Y, EXT_X, ext); } wrefresh(Board); wrefresh(Miles); wrefresh(Score); } /* * Put str at (y,x) in standout mode */ stand(y, x, str) reg int y, x; reg char *str; { standout(); mvaddstr(y, x, str); standend(); return TRUE; } prscore(for_real) reg bool for_real; { reg PLAY *pp; reg int x; reg char *Score_fmt = "%4d"; stdscr = Score; for (pp = Player; pp < &Player[2]; pp++) { x = (pp - Player) * 6 + 21; mvprintw(1, x, Score_fmt, pp->mileage); mvprintw(2, x, Score_fmt, pp->safescore); if (pp->safescore == 400) mvaddstr(3, x + 1, "300"); else mvaddch(3, x + 3, '0'); mvprintw(4, x, Score_fmt, pp->coupscore); if (WIndow == W_FULL || Finished) { #ifdef EXTRAP if (for_real) finalscore(pp); else extrapolate(pp); #else finalscore(pp); #endif mvprintw(11, x, Score_fmt, pp->hand_tot); mvprintw(13, x, Score_fmt, pp->total); mvprintw(14, x, Score_fmt, pp->games); } else { mvprintw(6, x, Score_fmt, pp->hand_tot); mvprintw(8, x, Score_fmt, pp->total); mvprintw(9, x, Score_fmt, pp->games); } } stdscr = Board; } FlushInput () { raw(); /* Flush input */ noraw(); } kgames-2.2/xmille/drawcard.c000066400000000000000000000007461416764561500160770ustar00rootroot00000000000000/* * drawcard.c * * display cards on the table */ # include "mille.h" # include "uiXt.h" # include "card.h" # include "cards-svg.h" static void init_card (struct card *card) { card->rsvg_handle = XkwRsvgCreate(card->svg); } static void init_cards (void) { int i; init_card (&deck); init_card (&blank); for (i = 0; i < (NUM_CARDS - 1); i++) { init_card (&svg_cards[i]); } } void init_color_cards (void) { init_cards(); } void init_mono_cards(void) { init_cards(); } kgames-2.2/xmille/end.c000066400000000000000000000074161416764561500150570ustar00rootroot00000000000000/* $NetBSD: end.c,v 1.7 2003/08/07 09:37:25 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" /* * @(#)end.c 1.1 (Berkeley) 4/1/82 */ /* * print out the score as if it was final, and add the totals for * the end-of-games points to the user who deserves it (if any). */ void finalscore(PLAY *pp) { int tot, num; num = pp - Player; for (tot = 4; tot <= 8; tot++) InScore(tot, num, " 0 "); if (pp->mileage == End) { InScore(4, num, " 400 "); tot = SC_TRIP; if (pp->nummiles[C_200] == 0) { InScore(5, num, " 300 "); tot = SC_TRIP + SC_SAFE; } if (Topcard <= Deck) { InScore (6, num, " 300 "); tot += SC_DELAY; } if (End == 1000) { InScore (7, num, " 200 "); tot += SC_EXTENSION; } if (Player[other(num)].mileage == 0) { InScore (8, num, " 500 "); tot += SC_SHUT_OUT; } pp->total += tot; pp->hand_tot += tot; } } # ifdef EXTRAP static int Last_tot[2]; /* last tot used for extrapolate */ /* * print out the score as if it was final, and add the totals for * the end-of-games points to the user who deserves it (if any). */ void extrapolate(PLAY *pp) { int x, num, tot, count; #ifdef NOTYET num = pp - Player; tot += SC_TRIP + SC_DELAY + SC_EXT; x = num * 6 + 21 + 3; for (tot = 5; tot <= 9; tot++) mvaddch(tot, x, '0'); x -= 2; pp = &Player[other(num)]; for (count = 0, tot = 0; tot < NUM_SAFE; tot++) if (pp->safety[tot] != S_PLAYED) count += SC_SAFE; mvprintw(3, x, "%3d", count); tot += count; if (count == 400) { mvaddstr(4, x, "30"); tot += SC_ALL_SAFE; } pp = &Player[num]; for (count = 0, tot = 0; tot < NUM_SAFE; tot++) if (pp->safety[tot] != S_PLAYED) count += SC_COUP / 10; mvprintw(4, x - 1, "%3d", count); tot += count; tot += 1000 - pp->mileage; mvaddstr(5, x, "40"); mvaddstr(7, x, "30"); mvaddstr(8, x, "20"); if (pp->nummiles[C_200] == 0) { mvaddstr(6, x, "30"); tot = SC_TRIP + SC_SAFE; } if (Player[other(num)].mileage == 0) { mvaddstr(9, x, "50"); tot += SC_SHUT_OUT; } pp->total += tot; pp->hand_tot += tot; Last_tot[num] = tot; #endif } void undoex(void) { PLAY *pp; int i; i = 0; for (pp = Player; pp < &Player[2]; pp++) { pp->total -= Last_tot[i]; pp->hand_tot -= Last_tot[i++]; } } # endif kgames-2.2/xmille/extern.c000066400000000000000000000121451416764561500156110ustar00rootroot00000000000000/* $NetBSD: extern.c,v 1.7 2003/08/07 09:37:25 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" /* * @(#)extern.c 1.1 (Berkeley) 4/1/82 */ bool Debug, /* set if debugging code on */ Finished, /* set if current hand is finished */ Next, /* set if changing players */ On_exit, /* set if game saved on exiting */ Order, /* set if hand should be sorted */ Saved; /* set if game just saved */ char Initstr[100]; /* initial string for error field */ const char *const C_fmt = "%-18.18s", /* format for printing cards */ *Fromfile = NULL, /* startup file for game */ *const _cn[NUM_CARDS] = { /* Card name buffer */ "", "25", "50", "75", "100", "200", "Out of Gas", "Flat Tire", "Accident", "Stop", "Speed Limit", "Gasoline", "Spare Tire", "Repairs", "Go", "End of Limit", "Extra Tank", "Puncture Proof", "Driving Ace", "Right of Way" }, *const *C_name = &_cn[1]; /* Card names */ int Card_no, /* Card number for current move */ End, /* End value for current hand */ Handstart = COMP, /* Player who starts hand */ Movetype, /* Current move type */ Play, /* Current player */ Numgos, /* Number of Go cards used by computer */ WIndow = W_SMALL, /* Current window wanted */ Numseen[NUM_CARDS]; /* Number of cards seen in current hand */ const int Value[NUM_MILES] = { /* Value of mileage cards */ 25, 50, 75, 100, 200 }, Numcards[NUM_CARDS] = { /* Number of cards in deck */ 10, /* C_25 */ 10, /* C_50 */ 10, /* C_75 */ 12, /* C_100 */ 4, /* C_200 */ 2, /* C_EMPTY */ 2, /* C_FLAT */ 2, /* C_CRASH */ 4, /* C_STOP */ 3, /* C_LIMIT */ 6, /* C_GAS */ 6, /* C_SPARE */ 6, /* C_REPAIRS */ 14, /* C_GO */ 6, /* C_END_LIMIT */ 1, /* C_GAS_SAFE */ 1, /* C_SPARE_SAFE */ 1, /* C_DRIVE_SAFE */ 1, /* C_RIGHT_WAY */ 0 /* C_INIT */ }; int Numneed[NUM_CARDS] = { /* number of cards needed per hand */ 0, /* C_25 */ 0, /* C_50 */ 0, /* C_75 */ 0, /* C_100 */ 0, /* C_200 */ 2, /* C_EMPTY */ 2, /* C_FLAT */ 2, /* C_CRASH */ 4, /* C_STOP */ 3, /* C_LIMIT */ 2, /* C_GAS */ 2, /* C_SPARE */ 2, /* C_REPAIRS */ 10, /* C_GO */ 3, /* C_END_LIMIT */ 1, /* C_GAS_SAFE */ 1, /* C_SPARE_SAFE */ 1, /* C_DRIVE_SAFE */ 1, /* C_RIGHT_WAY */ 0 /* C_INIT */ }; CARD Discard, /* Top of discard pile */ Sh_discard, /* Last discard card shown */ *Topcard; /* Pointer to next card to be picked */ const CARD Opposite[NUM_CARDS] = { /* Opposites of each card */ C_25, C_50, C_75, C_100, C_200, C_GAS, C_SPARE, C_REPAIRS, C_GO, C_END_LIMIT, C_EMPTY, C_FLAT, C_CRASH, C_STOP, C_LIMIT, C_EMPTY, C_FLAT, C_CRASH, C_STOP, C_INIT }; CARD Deck[DECK_SZ] = { /* Current deck */ C_25, C_25, C_25, C_25, C_25, C_25, C_25, C_25, C_25, C_25, C_50, C_50, C_50, C_50, C_50, C_50, C_50, C_50, C_50, C_50, C_75, C_75, C_75, C_75, C_75, C_75, C_75, C_75, C_75, C_75, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_100, C_200, C_200, C_200, C_200, C_EMPTY, C_EMPTY, C_FLAT, C_FLAT, C_CRASH, C_CRASH, C_STOP, C_STOP, C_STOP, C_STOP, C_LIMIT, C_LIMIT, C_LIMIT, C_GAS, C_GAS, C_GAS, C_GAS, C_GAS, C_GAS, C_SPARE, C_SPARE, C_SPARE, C_SPARE, C_SPARE, C_SPARE, C_REPAIRS, C_REPAIRS, C_REPAIRS, C_REPAIRS, C_REPAIRS, C_REPAIRS, C_END_LIMIT, C_END_LIMIT, C_END_LIMIT, C_END_LIMIT, C_END_LIMIT, C_END_LIMIT, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GO, C_GAS_SAFE, C_SPARE_SAFE, C_DRIVE_SAFE, C_RIGHT_WAY }; FILE *outf; PLAY Player[2]; /* Player descriptions */ kgames-2.2/xmille/fill000066400000000000000000000277511416764561500150220ustar00rootroot00000000000000#define fill_width 100 #define fill_height 150 static char fill_bits[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf1, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xf0, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0}; kgames-2.2/xmille/gray.bm000066400000000000000000000001271416764561500154170ustar00rootroot00000000000000#define gray_width 2 #define gray_height 2 static char gray_bits[] = { 0x01, 0x02}; kgames-2.2/xmille/init.c000066400000000000000000000054731416764561500152550ustar00rootroot00000000000000/* $NetBSD: init.c,v 1.9 2003/08/07 09:37:25 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include # include "mille.h" /* * @(#)init.c 1.1 (Berkeley) 4/1/82 */ void init(void) { PLAY *pp; int i, j; CARD card; memset(Numseen, 0, sizeof Numseen); Numgos = 0; for (i = 0; i < 2; i++) { pp = &Player[i]; pp->hand[0] = C_INIT; for (j = 0; j < NUM_SAFE; j++) { pp->safety[j] = S_UNKNOWN; pp->coups[j] = FALSE; } for (j = 1; j < HAND_SZ; j++) { pp->hand[j] = *--Topcard; if (i == COMP) { account(card = *Topcard); if (is_safety(card)) pp->safety[card - S_CONV] = S_IN_HAND; } } pp->mileage = 0; pp->hand_tot = 0; pp->safescore = 0; pp->coupscore = 0; pp->can_go = FALSE; pp->speed = C_INIT; pp->battle = C_INIT; pp->new_speed = FALSE; pp->new_battle = FALSE; for (j = 0; j < NUM_MILES; j++) pp->nummiles[j] = 0; } if (Order) sort(Player[PLAYER].hand); Discard = C_INIT; Finished = FALSE; End = 700; } void shuffle(void) { int i, r; CARD temp; for (i = 0; i < DECK_SZ; i++) { r = roll(1, DECK_SZ) - 1; if (r < 0 || r > DECK_SZ - 1) { fprintf(stderr, "shuffle: card no. error: %d\n", r); die(); } temp = Deck[r]; Deck[r] = Deck[i]; Deck[i] = temp; } Topcard = &Deck[DECK_SZ]; } kgames-2.2/xmille/make-cards-svg000077500000000000000000000020431416764561500166660ustar00rootroot00000000000000#!/bin/bash dir=`dirname $0` case $# in 2) ;; *) echo "usage: $0 cards.c cards.h" exit 1 ;; esac ( echo '#include "uiXt.h"' echo '#include "'"$2"'"' IFS=':' while read file name card; do file="$dir"/cards/"$file".svg echo "const char svg_$name[]" = sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/ "/' -e 's/$/\\n"/' "$file" echo " ;"; echo "" done < "$dir"/card-names echo "struct card svg_cards[] = {" while read file name card; do if [ "$card" = "" ]; then echo " { .svg = svg_$name, .label = \"$file\", .rsvg_handle = NULL },"; fi done < "$dir"/card-names echo "};" while read file name card; do if [ "$card" != "" ]; then echo "struct card $card = { .svg = svg_$name, .label = \"$file\", .rsvg_handle = NULL };"; fi done < "$dir"/card-names echo "" ) > "$1" ( echo "extern struct card svg_cards[];" IFS=':' while read file name card; do if [ "$card" != "" ]; then echo "extern struct card $card;" fi done < "$dir"/card-names ) > "$2" kgames-2.2/xmille/meson.build000066400000000000000000000044121416764561500163000ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'Mille.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) srcs_xmille = [ 'animate.c', 'comp.c', 'drawcard.c', 'end.c', 'extern.c', 'init.c', 'mille.c', 'misc.c', 'move.c', 'print.c', 'roll.c', 'save.c', 'types.c', 'uiXt.c', 'varpush.c', 'MilleCards.c', ] subdir('cards') make_cards_svg = find_program('make-cards-svg') cards_files = custom_target('xmille-svg-cards', depend_files : cards_xmille + ['card-names'], output : ['cards-svg.c', 'cards-svg.h'], command : [make_cards_svg, '@OUTPUT0@', '@OUTPUT1@']) executable('xmille', srcs_xmille, cards_files, res_files, include_directories: inc, dependencies: x_libs, link_with: [lib_xkw], install: true) install_man('xmille.6') install_data('cards/Icon.svg', rename : 'xmille.svg', install_dir : svg_icon_dir) configure_file(input: 'xmille.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/xmille/mille.c000066400000000000000000000067451416764561500154170ustar00rootroot00000000000000/* $NetBSD: mille.c,v 1.13 2003/08/07 09:37:25 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" # include # ifdef attron # include # endif /* attron */ /* * @(#)mille.c 1.3 (Berkeley) 5/10/83 */ char _sobuf[BUFSIZ]; bool restore; int main(int ac, char **av) { bool restore; /* Revoke setgid privileges */ if (setregid(getgid(), getgid()) < 0) { printf("setregid failed\n"); exit(1); } if (strcmp(av[0], "a.out") == 0) { outf = fopen("q", "w"); setbuf(outf, (char *)NULL); Debug = TRUE; } restore = FALSE; setbuf(stdout, _sobuf); Play = PLAYER; init_ui (&ac, av); switch (ac) { case 2: rest_f(av[1]); restore = TRUE; case 1: break; default: printf("usage: milles [ restore_file ]\n"); exit(1); /* NOTREACHED */ } # ifndef PROF srandom(getpid()); # else srandom(0); # endif signal(SIGINT, rub); for (;;) { if (!restore || (Player[PLAYER].total >= 5000 || Player[COMP].total >= 5000)) { if (Player[COMP].total < Player[PLAYER].total) Player[PLAYER].games++; else if (Player[COMP].total > Player[PLAYER].total) Player[COMP].games++; Player[COMP].total = 0; Player[PLAYER].total = 0; } do { if (!restore) Handstart = Play = other(Handstart); if (!restore || On_exit) { shuffle(); init(); } newboard(); if (restore) Error (Initstr); prboard(); do { domove(); if (Finished) newscore(); prboard(); } while (!Finished); check_more(); restore = On_exit = FALSE; } while (Player[COMP].total < 5000 && Player[PLAYER].total < 5000); } } /* * Routine to trap rubouts, and make sure they really want to * quit. */ void rub(int sig) { (void) sig; signal(SIGINT, SIG_IGN); if (getyn("Really? ")) die(); signal(SIGINT, rub); } /* * Time to go beddy-by */ void die(void) { signal(SIGINT, SIG_IGN); if (outf) fflush(outf); finish_ui (); exit(1); } kgames-2.2/xmille/mille.h000066400000000000000000000127251416764561500154170ustar00rootroot00000000000000# include # include # include # include # include # include # include # define TRUE 1 # define FALSE 0 /* * @(#)mille.h 1.1 (Berkeley) 4/1/82 */ typedef short CARD; /* * Miscellaneous constants */ # define HAND_SZ 7 /* number of cards in a hand */ # define DECK_SZ 101 /* number of cards in decks */ # define NUM_SAFE 4 /* number of saftey cards */ # define NUM_MILES 5 /* number of milestones types */ # define NUM_CARDS 20 /* number of types of cards */ # define PLAYER 0 # define COMP 1 # define W_SMALL 0 /* Small (initial) window */ # define W_FULL 1 /* Full (final) window */ /* * Move types */ # define M_DISCARD 0 # define M_DRAW 1 # define M_PLAY 2 # define M_ORDER 3 # define M_REASONABLE 4 /* * Scores */ # define SC_SAFETY 100 # define SC_ALL_SAFE 300 # define SC_COUP 300 # define SC_TRIP 400 # define SC_SAFE 300 # define SC_DELAY 300 # define SC_EXTENSION 200 # define SC_SHUT_OUT 500 /* * safety descriptions */ # define S_UNKNOWN 0 /* location of safety unknown */ # define S_IN_HAND 1 /* safety in player's hand */ # define S_PLAYED 2 /* safety has been played */ # define S_GAS_SAFE 0 /* Gas safety card index */ # define S_SPARE_SAFE 1 /* Tire safety card index */ # define S_DRIVE_SAFE 2 /* Driveing safety card index */ # define S_RIGHT_WAY 3 /* Right-of-Way card index */ # define S_CONV 15 /* conversion from C_ to S_ */ /* * card numbers */ # define C_INIT -1 # define C_25 0 # define C_50 1 # define C_75 2 # define C_100 3 # define C_200 4 # define C_EMPTY 5 # define C_FLAT 6 # define C_CRASH 7 # define C_STOP 8 # define C_LIMIT 9 # define C_GAS 10 # define C_SPARE 11 # define C_REPAIRS 12 # define C_GO 13 # define C_END_LIMIT 14 # define C_GAS_SAFE 15 # define C_SPARE_SAFE 16 # define C_DRIVE_SAFE 17 # define C_RIGHT_WAY 18 typedef struct { bool coups[NUM_SAFE]; bool can_go; bool new_battle; bool new_speed; short safety[NUM_SAFE]; short nummiles[NUM_MILES]; CARD hand[HAND_SZ]; CARD battle; CARD speed; int mileage; int hand_tot; int safescore; int coupscore; int total; int games; } PLAY; /* * animation constants */ # define ANIMATE # define ANIMATE_HAND 0 # define ANIMATE_DECK 1 # define ANIMATE_DISC 2 # define ANIMATE_MILES 3 # define ANIMATE_BATTLE 4 # define ANIMATE_SPEED 5 # define ANIMATE_OBATTLE 6 # define ANIMATE_OSPEED 7 # define ANIMATE_SAFETY 8 /* * macros */ # define other(x) (1 - x) # define nextplay() (Play = other(Play)) # define nextwin(x) (1 - x) # define opposite(x) (Opposite[x]) # define is_safety(x) (x >= C_GAS_SAFE) /* * externals */ extern bool Debug, Finished, Next, On_exit, Order, Saved; extern const char *const C_fmt; extern const char *Fromfile; extern const char *const *C_name; extern char Initstr[]; extern const int Value[], Numcards[]; extern const CARD Opposite[NUM_CARDS]; extern int Card_no, End, Handstart, Movetype, Numgos, Numneed[], Numseen[NUM_CARDS], Play, WIndow; extern CARD Deck[DECK_SZ], Discard, *Topcard; extern FILE *outf; extern PLAY Player[2]; /* * functions */ CARD getcard(); void VError(const char *string, va_list ap); void Error (const char *string, ...); void Prompt (char *string); void debug (int pos, char *string, int a0, int a1, int a2); bool error (const char *string, ...); char * GetpromptedInput (char *string); void MilleMessage (char *string); void stand(int y, int x, char *str); void InScore (int line, int player, char *text); void prscore(bool for_real); /* animate.c */ void animate_move (int player, int orig_type, int orig_arg, int dest_type, int dest_arg); void animate_enable (int enable); /* comp.c */ void calcmove(void); int onecard(const PLAY *pp); int canplay(const PLAY *pp, const PLAY *op, CARD card); /* drawcard.c */ /* end.c */ void finalscore(PLAY *pp); void extrapolate(PLAY *pp); void undoex(void); /* init.c */ void init(void); void shuffle(void); /* mille.c */ void rub(int sig); void die(void); /* misc.c */ bool error(const char *str, ...); bool check_ext(bool forcomp); void check_more(void); /* move.c */ void domove(void); void check_go(void); char * sprint (char * string, ...); int haspicked(const PLAY *pp); char * playcard(PLAY *pp); void account(CARD card); void sort(CARD *hand); /* print.c */ /* roll.c */ int roll(int ndie, int nsides); /* save.c */ bool save(void); bool rest_f(const char *file); bool rest(void); /* types.c */ bool is_repair(CARD card); int safety(CARD card); /* uiXt.c */ void prboard(void); void do_save (void); void do_quit (void); void getmove(void); void ComputerCard (int type); void ComputerStatus (char *string); void ComputerDistance (int distance); void ComputerSpeed (int type); void ComputerBattle (int type); void ComputerMiles (int type, int ind, int count); void EraseComputer (void); void ComputerSafety (int type, int ind); void DisplayDiscard (int type); void DisplayDeck (int numberLeft); void HumanDistance (int distance); void HumanSpeed (int type); void HumanBattle (int type); void HumanMiles (int type, int ind, int count); void EraseHuman (void); void HumanSafety (int type, int ind); void HumanHand (int type, int ind); void newboard(void); void newscore(void); void draw_board (void); void redraw_board (void); void init_ui (int *argc, char **argv); void finish_ui (void); void update_ui (void); void Beep (void); int getyn(char *prompt); void FlushInput (void); /* varpush.c */ int varpush(int file, ssize_t (*func)(int, void *, size_t)); kgames-2.2/xmille/misc.c000066400000000000000000000071171416764561500152420ustar00rootroot00000000000000/* $NetBSD: misc.c,v 1.11 2003/08/07 09:37:25 agc Exp $ */ /* * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include "mille.h" /* * @(#)misc.c 1.2 (Berkeley) 3/28/83 */ #define NUMSAFE 4 bool error(const char *str, ...) { va_list ap; va_start(ap, str); VError (str, ap); va_end(ap); Beep (); update_ui (); return FALSE; } bool check_ext(bool forcomp) { if (End == 700) if (Play == PLAYER) { if (getyn("Extension? ")) { extend: if (!forcomp) End = 1000; return TRUE; } else { done: if (!forcomp) Finished = TRUE; return FALSE; } } else { PLAY *pp, *op; int i, safe, miles; pp = &Player[COMP]; op = &Player[PLAYER]; for (safe = 0, i = 0; i < NUMSAFE; i++) if (pp->safety[i] != S_UNKNOWN) safe++; if (safe < 2) goto done; if (op->mileage == 0 || onecard(op) || (op->can_go && op->mileage >= 500)) goto done; for (miles = 0, i = 0; i < NUMSAFE; i++) if (op->safety[i] != S_PLAYED && pp->safety[i] == S_UNKNOWN) miles++; if (miles + safe == NUMSAFE) goto extend; for (miles = 0, i = 0; i < HAND_SZ; i++) if ((safe = pp->hand[i]) <= C_200) miles += Value[safe]; if (miles + (Topcard - Deck) * 3 > 1000) goto extend; goto done; } else goto done; } /* * Check to see if more games are desired. If not, and game * came from a saved file, make sure that they don't want to restore * it. Exit appropriately. */ void check_more(void) { On_exit = TRUE; if (Player[PLAYER].total >= 5000 || Player[COMP].total >= 5000) if (getyn("Another game? ")) return; else { /* * must do accounting normally done in main() */ if (Player[PLAYER].total > Player[COMP].total) Player[PLAYER].games++; else if (Player[PLAYER].total < Player[COMP].total) Player[COMP].games++; Player[COMP].total = 0; Player[PLAYER].total = 0; } else if (getyn("Another hand? ")) return; if (!Saved && getyn("Save game? ")) if (!save()) return; die(); } kgames-2.2/xmille/move.c000066400000000000000000000240551416764561500152550ustar00rootroot00000000000000/* $NetBSD: move.c,v 1.15 2004/11/05 21:30:32 dsl Exp $ */ /* * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #ifdef DEBUG #include #endif #include "mille.h" /* * @(#)move.c 1.2 (Berkeley) 3/28/83 */ void domove(void) { PLAY *pp; int i, j; bool goodplay; char *foo; pp = &Player[Play]; for (i = 0, j = 0; i < HAND_SZ; i++) if (pp->hand[i] != -1) j++; if (!j) { nextplay(); return; } if (Play == PLAYER) getmove(); else calcmove(); Next = FALSE; goodplay = TRUE; switch (Movetype) { case M_DISCARD: trydiscard: ; if (haspicked(pp)) { if (pp->hand[Card_no] == C_INIT) if (Card_no == 6) Finished = TRUE; else error("no card there"); else { if (is_safety(pp->hand[Card_no])) { error("discard a safety?"); goodplay = FALSE; break; } Discard = pp->hand[Card_no]; pp->hand[Card_no] = C_INIT; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_DISC, Discard); #endif Next = TRUE; if (Play == PLAYER) account(Discard); } } else error("must pick first"); break; case M_REASONABLE: case M_PLAY: foo = playcard(pp); if (foo) { if (Movetype == M_REASONABLE) goto trydiscard; error (foo); goodplay = FALSE; } else goodplay = TRUE; break; case M_DRAW: Card_no = 0; if (Topcard <= Deck) error("no more cards"); else if (haspicked(pp)) error("already picked"); else { pp->hand[0] = *--Topcard; #ifdef ANIMATE animate_move (Play, ANIMATE_DECK, pp->hand[0], ANIMATE_HAND, 0); #endif #ifdef DEBUG if (Debug) fprintf(outf, "DOMOVE: Draw %s\n", C_name[*Topcard]); #endif acc: if (Play == COMP) { account(*Topcard); if (is_safety(*Topcard)) pp->safety[*Topcard-S_CONV] = S_IN_HAND; } if (pp->hand[1] == C_INIT && Topcard > Deck) { Card_no = 1; pp->hand[1] = *--Topcard; #ifdef DEBUG if (Debug) fprintf(outf, "DOMOVE: Draw %s\n", C_name[*Topcard]); #endif goto acc; } pp->new_battle = FALSE; pp->new_speed = FALSE; } break; case M_ORDER: break; } /* * move blank card to top by one of two methods. If the * computer's hand was sorted, the randomness for picking * between equally valued cards would be lost */ if (Order && Movetype != M_DRAW && goodplay && pp == &Player[PLAYER]) sort(pp->hand); else for (i = 1; i < HAND_SZ; i++) if (pp->hand[i] == C_INIT) { for (j = 0; pp->hand[j] == C_INIT; j++) if (j >= HAND_SZ) { j = 0; break; } pp->hand[i] = pp->hand[j]; pp->hand[j] = C_INIT; } if (Topcard <= Deck) check_go(); if (Next) nextplay(); } /* * Check and see if either side can go. If they cannot, * the game is over */ void check_go(void) { CARD card; PLAY *pp, *op; int i; for (pp = Player; pp < &Player[2]; pp++) { op = (pp == &Player[COMP] ? &Player[PLAYER] : &Player[COMP]); for (i = 0; i < HAND_SZ; i++) { card = pp->hand[i]; if (is_safety(card) || canplay(pp, op, card)) { #ifdef DEBUG if (Debug) { fprintf(outf, "CHECK_GO: can play %s (%d), ", C_name[card], card); fprintf(outf, "is_safety(card) = %d, ", is_safety(card)); fprintf(outf, "canplay(pp, op, card) = %d\n", canplay(pp, op, card)); } #endif return; } #ifdef DEBUG else if (Debug) fprintf(outf, "CHECK_GO: cannot play %s\n", C_name[card]); #endif } } Finished = TRUE; } char * playcard(PLAY *pp) { int v; CARD card; /* * check and see if player has picked */ switch (pp->hand[Card_no]) { default: if (!haspicked(pp)) mustpick: return "must pick first"; case C_GAS_SAFE: case C_SPARE_SAFE: case C_DRIVE_SAFE: case C_RIGHT_WAY: break; } card = pp->hand[Card_no]; #ifdef DEBUG if (Debug) fprintf(outf, "PLAYCARD: Card = %s\n", C_name[card]); #endif Next = FALSE; switch (card) { case C_200: if (pp->nummiles[C_200] == 2) return "only two 200's per hand"; /* FALLTHROUGH */ case C_100: case C_75: if (pp->speed == C_LIMIT) return "limit of 50"; /* FALLTHROUGH */ case C_50: if (pp->mileage + Value[card] > End) return sprint("puts you over %d", End); /* FALLTHROUGH */ case C_25: if (!pp->can_go) return "cannot move now"; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_MILES, card); #endif pp->nummiles[card]++; v = Value[card]; pp->total += v; pp->hand_tot += v; if ((pp->mileage += v) == End) check_ext(FALSE); break; case C_GAS: case C_SPARE: case C_REPAIRS: if (pp->battle != opposite(card)) return sprint("can't play \"%s\"", C_name[card]); #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_BATTLE, card); #endif pp->battle = card; if (pp->safety[S_RIGHT_WAY] == S_PLAYED) pp->can_go = TRUE; break; case C_GO: if (pp->battle != C_INIT && pp->battle != C_STOP && !is_repair(pp->battle)) return sprint("cannot play \"Go\" on a \"%s\"", C_name[pp->battle]); #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_BATTLE, card); #endif pp->battle = C_GO; pp->can_go = TRUE; break; case C_END_LIMIT: if (pp->speed != C_LIMIT) return "not limited"; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_SPEED, card); #endif pp->speed = C_END_LIMIT; break; case C_EMPTY: case C_FLAT: case C_CRASH: case C_STOP: pp = &Player[other(Play)]; if (!pp->can_go) return "opponent cannot go"; else if (pp->safety[safety(card) - S_CONV] == S_PLAYED) protected: return "opponent is protected"; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_OBATTLE, card); #endif pp->battle = card; pp->new_battle = TRUE; pp->can_go = FALSE; pp = &Player[Play]; break; case C_LIMIT: pp = &Player[other(Play)]; if (pp->speed == C_LIMIT) return "opponent has limit"; if (pp->safety[S_RIGHT_WAY] == S_PLAYED) goto protected; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_OSPEED, card); #endif pp->speed = C_LIMIT; pp->new_speed = TRUE; pp = &Player[Play]; break; case C_GAS_SAFE: case C_SPARE_SAFE: case C_DRIVE_SAFE: case C_RIGHT_WAY: if (pp->battle == opposite(card) || (card == C_RIGHT_WAY && pp->speed == C_LIMIT)) { if (!(card == C_RIGHT_WAY && !is_repair(pp->battle))) { pp->battle = C_GO; pp->can_go = TRUE; } if (card == C_RIGHT_WAY && pp->speed == C_LIMIT) pp->speed = C_INIT; if (pp->new_battle || (pp->new_speed && card == C_RIGHT_WAY)) { pp->coups[card - S_CONV] = TRUE; pp->total += SC_COUP; pp->hand_tot += SC_COUP; pp->coupscore += SC_COUP; } } /* * if not coup, must pick first */ else if (pp->hand[0] == C_INIT && Topcard > Deck) goto mustpick; #ifdef ANIMATE animate_move (Play, ANIMATE_HAND, Card_no, ANIMATE_SAFETY, card); #endif pp->safety[card - S_CONV] = S_PLAYED; pp->total += SC_SAFETY; pp->hand_tot += SC_SAFETY; if ((pp->safescore += SC_SAFETY) == NUM_SAFE * SC_SAFETY) { pp->total += SC_ALL_SAFE; pp->hand_tot += SC_ALL_SAFE; } if (card == C_RIGHT_WAY) { if (pp->speed == C_LIMIT) pp->speed = C_INIT; if (pp->battle == C_STOP || pp->battle == C_INIT) { pp->can_go = TRUE; pp->battle = C_INIT; } if (!pp->can_go && is_repair(pp->battle)) pp->can_go = TRUE; } Next = -1; break; case C_INIT: Next = -1; return "no card there"; break; } if (pp == &Player[PLAYER]) account(card); pp->hand[Card_no] = C_INIT; Next = (Next == (bool)-1 ? FALSE : TRUE); return NULL; } char * sprint (char * string, ...) { va_list ap; static char buf[512]; va_start(ap, string); vsprintf (buf, string, ap); va_end(ap); return buf; } /* * return whether or not the player has picked */ int haspicked(const PLAY *pp) { int card; if (Topcard <= Deck) return TRUE; switch (pp->hand[Card_no]) { case C_GAS_SAFE: case C_SPARE_SAFE: case C_DRIVE_SAFE: case C_RIGHT_WAY: card = 1; break; default: card = 0; break; } return (pp->hand[card] != C_INIT); } void account(CARD card) { CARD oppos; if (card == C_INIT) return; ++Numseen[card]; if (Play == COMP) switch (card) { case C_GAS_SAFE: case C_SPARE_SAFE: case C_DRIVE_SAFE: oppos = opposite(card); Numgos += Numcards[oppos] - Numseen[oppos]; break; case C_CRASH: case C_FLAT: case C_EMPTY: case C_STOP: Numgos++; break; } } void sort(CARD *hand) { CARD *cp, *tp; CARD temp; cp = hand; hand += HAND_SZ; for ( ; cp < &hand[-1]; cp++) for (tp = cp + 1; tp < hand; tp++) if (*cp > *tp) { temp = *cp; *cp = *tp; *tp = temp; } } kgames-2.2/xmille/print.c000066400000000000000000000106561416764561500154450ustar00rootroot00000000000000/* $NetBSD: print.c,v 1.11 2003/08/07 09:37:26 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" /* * @(#)print.c 1.1 (Berkeley) 4/1/82 */ # define COMP_STRT 20 # define CARD_STRT 2 #if 0 void prboard() { PLAY *pp; int i, j, k, temp; for (k = 0; k < 2; k++) { pp = &Player[k]; temp = k * COMP_STRT + CARD_STRT; for (i = 0; i < NUM_SAFE; i++) if (pp->safety[i] == S_PLAYED && !pp->sh_safety[i]) { mvaddstr(i, temp, C_name[i + S_CONV]); if (pp->coups[i]) mvaddch(i, temp - CARD_STRT, '*'); pp->sh_safety[i] = TRUE; } show_card(14, temp, pp->battle, &pp->sh_battle); show_card(16, temp, pp->speed, &pp->sh_speed); for (i = C_25; i <= C_200; i++) { const char *name; int end; if (pp->nummiles[i] == pp->sh_nummiles[i]) continue; name = C_name[i]; temp = k * 40; end = pp->nummiles[i]; for (j = pp->sh_nummiles[i]; j < end; j++) mvwaddstr(Miles, i + 1, (j << 2) + temp, name); pp->sh_nummiles[i] = end; } } prscore(TRUE); temp = CARD_STRT; pp = &Player[PLAYER]; for (i = 0; i < HAND_SZ; i++) show_card(i + 6, temp, pp->hand[i], &pp->sh_hand[i]); mvprintw(6, COMP_STRT + CARD_STRT, "%2ld", (long)(Topcard - Deck)); show_card(8, COMP_STRT + CARD_STRT, Discard, &Sh_discard); if (End == 1000) { move(EXT_Y, EXT_X); standout(); addstr("Extension"); standend(); } wrefresh(Board); wrefresh(Miles); wrefresh(Score); } /* * show_card: * Show the given card if it is different from the last one shown */ void show_card(y, x, c, lc) int y, x; CARD c, *lc; { if (c == *lc) return; mvprintw(y, x, C_fmt, C_name[c]); *lc = c; } static char Score_fmt[] = "%4d"; void prscore(for_real) #ifdef EXTRAP bool for_real; #else bool for_real __attribute__((__unused__)); #endif { PLAY *pp; int x; stdscr = Score; for (pp = Player; pp < &Player[2]; pp++) { x = (pp - Player) * 6 + 21; show_score(1, x, pp->mileage, &pp->sh_mileage); if (pp->safescore != pp->sh_safescore) { mvprintw(2, x, Score_fmt, pp->safescore); if (pp->safescore == 400) mvaddstr(3, x + 1, "300"); else mvaddstr(3, x + 1, " 0"); mvprintw(4, x, Score_fmt, pp->coupscore); pp->sh_safescore = pp->safescore; } if (Window == W_FULL || Finished) { #ifdef EXTRAP if (for_real) finalscore(pp); else extrapolate(pp); #else finalscore(pp); #endif show_score(11, x, pp->hand_tot, &pp->sh_hand_tot); show_score(13, x, pp->total, &pp->sh_total); show_score(14, x, pp->games, &pp->sh_games); } else { show_score(6, x, pp->hand_tot, &pp->sh_hand_tot); show_score(8, x, pp->total, &pp->sh_total); show_score(9, x, pp->games, &pp->sh_games); } } stdscr = Board; } /* * show_score: * Show a score value if it is different from the last time we * showed it. */ void show_score(y, x, s, ls) int y, x; int s, *ls; { if (s == *ls) return; mvprintw(y, x, Score_fmt, s); *ls = s; } #endif kgames-2.2/xmille/roll.c000066400000000000000000000036001416764561500152500ustar00rootroot00000000000000/* $NetBSD: roll.c,v 1.7 2003/08/07 09:37:26 agc Exp $ */ /* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include # include "mille.h" /* * This routine rolls ndie nside-sided dice. * * @(#)roll.c 1.1 (Berkeley) 4/1/82 * */ int roll(int ndie, int nsides) { int tot; tot = 0; while (ndie--) tot += (random() >> 2) % nsides + 1; return tot; } kgames-2.2/xmille/save.c000066400000000000000000000073071416764561500152460ustar00rootroot00000000000000/* $NetBSD: save.c,v 1.11 2003/08/07 09:37:26 agc Exp $ */ /* * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include "mille.h" #ifndef unctrl #include "unctrl.h" #endif /* * @(#)save.c 1.2 (Berkeley) 3/28/83 */ typedef struct stat STAT; /* * This routine saves the current game for use at a later date * Returns FALSE if it couldn't be done. */ bool save(void) { char *sp, *ans; int outf; time_t *tp; char buf[80]; time_t tme; STAT junk; bool rv; sp = NULL; tp = &tme; if (Fromfile && getyn("Same file? ")) strcpy(buf, Fromfile); else { ans = GetpromptedInput ("File: "); if (!ans) return FALSE; strcpy (buf, ans); sp = buf + strlen (buf); } /* * check for existing files, and confirm overwrite if needed */ if (sp == buf || (!Fromfile && stat(buf, &junk) > -1 && getyn("Overwrite File? ") == FALSE)) return FALSE; if ((outf = creat(buf, 0644)) < 0) { error(strerror(errno)); return FALSE; } Error (buf); time(tp); /* get current time */ rv = varpush(outf, (ssize_t(*)(int, void *, size_t))write); close(outf); if (rv == FALSE) unlink(buf); return rv; } /* * This does the actual restoring. It returns TRUE if the * backup was made on exiting, in which case certain things must * be cleaned up before the game starts. */ bool rest_f(const char *file) { char *sp; int inf; char buf[80]; STAT sbuf; if ((inf = open(file, O_RDONLY)) < 0) { warn("%s", file); exit(1); } if (fstat(inf, &sbuf) < 0) { /* get file stats */ warn("%s", file); exit(1); } varpush(inf, (ssize_t (*)(int, void *, size_t))read); close(inf); strcpy(buf, ctime(&sbuf.st_mtime)); for (sp = buf; *sp != '\n'; sp++) continue; *sp = '\0'; /* * initialize some necessary values */ (void)sprintf(Initstr, "%s [%s]\n", file, buf); Fromfile = file; return !On_exit; } bool rest(void) { char buf[80]; char *ans; if (Fromfile && getyn("Same file? ")) strcpy(buf, Fromfile); else { ans = GetpromptedInput ("File: "); if (!ans) return FALSE; strcpy (buf, ans); } return rest_f(buf); } kgames-2.2/xmille/table.c000066400000000000000000000006561416764561500153770ustar00rootroot00000000000000# define DEBUG /* * @(#)table.c 1.1 (Berkeley) 4/1/82 */ # include "mille.h" void main(void) { printf(" %16s -> %5s %5s %4s %s\n", "Card", "cards", "count", "need", "opposite"); for (int i = 0; i < NUM_CARDS - 1; i++) { int count = 0; for (int j = 0; j < DECK_SZ; j++) if (Deck[j] == i) count++; printf("%2d %16s -> %5d %5d %4d %s\n", i, C_name[i], Numcards[i], count, Numneed[i], C_name[opposite(i)]); } } kgames-2.2/xmille/types.c000066400000000000000000000011251416764561500154440ustar00rootroot00000000000000# include "mille.h" /* * @(#)types.c 1.1 (Berkeley) 4/1/82 */ bool is_repair(CARD card) { return card == C_GAS || card == C_SPARE || card == C_REPAIRS || card == C_INIT; } int safety(CARD card) { switch (card) { case C_EMPTY: case C_GAS: case C_GAS_SAFE: return C_GAS_SAFE; case C_FLAT: case C_SPARE: case C_SPARE_SAFE: return C_SPARE_SAFE; case C_CRASH: case C_REPAIRS: case C_DRIVE_SAFE: return C_DRIVE_SAFE; case C_GO: case C_STOP: case C_RIGHT_WAY: case C_LIMIT: case C_END_LIMIT: return C_RIGHT_WAY; } /* NOTREACHED */ return 0; } kgames-2.2/xmille/ui.c000066400000000000000000000407121416764561500147220ustar00rootroot00000000000000/* * ui.c * * interface routines for mille */ # include "mille.h" # include "ui.h" # include # include "gray.bm" # include "card.h" struct color colorMap[NUM_COLOR] = { "black", 0, 0, "white", 0, 0, "red", 0, 0, "green", 0, 0, "light gray", 0, 0, "blue", 0, 0, }; const char *const C_fmt = "%-18.18s"; /* format for printing cards */ char Initstr[100]; /* initial string for error field */ char *_cn[NUM_CARDS] = { /* Card name buffer */ "", "25", "50", "75", "100", "200", "Out of Gas", "Flat Tire", "Accident", "Stop", "Speed Limit", "Gasoline", "Spare Tire", "Repairs", "Go", "End of Limit", "Extra Tank", "Puncture Proof", "Driving Ace", "Right of Way", }; char **C_name = &_cn[1]; /* Card names */ Display *dpy; int screen; Window xwindow; Pixmap fill; Button QUIT, SAVE; Window qwindow, swindow; XFontStruct *font; GC text_gc; GC xor_gc; Region null, mine; int iscolor; struct safety_offset safety_offsets[4] = { 0, 0, WIDTH+PAD_CARD, 0, 0, HEIGHT+PAD_CARD, WIDTH+PAD_CARD, HEIGHT+PAD_CARD, }; char * prune (orig, max) char *orig; { static char buf[512]; int len; char c; len = strlen (orig); if (XTextWidth (font, orig, len) < max) return orig; strcpy (buf, orig); do { buf[--len] = '\0'; } while (len > 0 && XTextWidth (font, buf, len) >= max); return buf; } Message (string) char *string; { string = prune (string, MESS_W); displayString (MESS_X, MESS_Y, string); } void Error (char *string, ...) { va_list ap; char buf[512]; char *o; va_start(string, ap); vsprintf (buf, string, ap); va_end(ap); o = prune (buf, ERROR_W); displayString (ERROR_X, ERROR_Y, o); } Prompt (string) char *string; { string = prune (string, PROMPT_W); displayString (PROMPT_X, PROMPT_Y, string); } debug (pos, string, a0, a1, a2) { } ComputerStatus (string) { /* char buffer[512]; sprintf (buffer, "I %-10.10s", string); XDrawImageString (dpy, xwindow, text_gc, COMP_CARD_TX, COMP_CARD_TY, buffer, strlen(buffer)); */ } ComputerCard (type) int type; { /* displayCard (type, COMP_CARD_X, COMP_CARD_Y);*/ } static int computer_distance = 0; ComputerDistance (distance) { displayDistance (COMP_DIST_X, COMP_DIST_Y, distance, DIST_WIDTH, DIST_HEIGHT); computer_distance = distance; } EraseComputerDistance () { computer_distance = 0; } RedisplayComputerDistance () { displayDistance (COMP_DIST_X, COMP_DIST_Y, computer_distance, DIST_WIDTH, DIST_HEIGHT); } ComputerSpeed (type) { displayCard (type, COMP_PLAY_X, COMP_PLAY_Y); } ComputerBattle (type) { displayCard (type, COMP_PLAY_X + WIDTH + PAD_CARD, COMP_PLAY_Y); } static int computer_miles_count[5]; ComputerMiles (type, index, count) { while (computer_miles_count[index] < count) { displayCard (type, COMP_PLAY_X + (WIDTH + PAD_CARD) * (index + 2), COMP_PLAY_Y + (MILE_OFFSET * computer_miles_count[index])); ++computer_miles_count[index]; } } EraseComputerMiles () { int i; for (i = 0; i < 5; i++) computer_miles_count[i] = 0; } ComputerSafety (type, index) { displayCard (type, COMP_SAFE_X + safety_offsets[index].x, COMP_SAFE_Y + safety_offsets[index].y); } DisplayDiscard (type) { displayCard (type, DISCARD_X, DISCARD_Y); } DisplayDeck (numberLeft) { char buffer[512]; sprintf (buffer, "Cards: %3d ", numberLeft); displayString (DECK_TX, DECK_TY, buffer); } static int human_distance = 0; HumanDistance (distance) { displayDistance (HUM_DIST_X, HUM_DIST_Y, distance, DIST_WIDTH, DIST_HEIGHT); human_distance = distance; } EraseHumanDistance () { human_distance = 0; } RedisplayHumanDistance () { displayDistance (HUM_DIST_X, HUM_DIST_Y, human_distance, DIST_WIDTH, DIST_HEIGHT); } HumanSpeed (type) { displayCard (type, HUM_PLAY_X, HUM_PLAY_Y); } HumanBattle (type) { displayCard (type, HUM_PLAY_X + WIDTH + PAD_CARD, HUM_PLAY_Y); } static int human_miles_count[5]; HumanMiles (type, index, count) { while (human_miles_count[index] < count) { displayCard (type, HUM_PLAY_X + (WIDTH + PAD_CARD) * (index + 2), HUM_PLAY_Y + (MILE_OFFSET * human_miles_count[index])); ++human_miles_count[index]; } } EraseHumanMiles () { int i; for (i = 0; i < 5; i++) human_miles_count[i] = 0; } HumanSafety (type, index) { displayCard (type, HUM_SAFE_X + safety_offsets[index].x, HUM_SAFE_Y + safety_offsets[index].y); } HumanHand (type, index) int type, index; { displayCard (type, HUM_HAND_X + (WIDTH + PAD_CARD) * index, HUM_HAND_Y); } displayDistance (x, y, value, width, height) { XFillRectangle (dpy, xwindow, colorMap[BLUE_COLOR].gc, x, y, (value * width) / 1000, height); } eraseDistance (x, y, value, width, height) { XClearArea (dpy, xwindow, x, y, (value * width) / 1000, height, TRUE); } char * GetpromptedInput (string) char *string; { extern char *co_prompted (); return co_prompted (string, xwindow); } newboard() { int i; char buffer[20]; int len; int x, y1, y2, ym1, ym2; int width; XClearWindow (dpy, xwindow); cardEraseAll (); stringsEraseAll (); EraseHumanMiles (); EraseComputerMiles (); EraseHumanDistance (); EraseComputerDistance (); cardDisplay (&deck, DECK_X, DECK_Y); draw_board (); flushEvents (xwindow, ~0); } newscore() { register int i; InScore (-1, 0, "You"); InScore (-1, 1, "Computer"); InScore (0, -1, "Milestones"); InScore (1, -1, "Safeties"); InScore (2, -1, "All 4 Safeties"); InScore (3, -1, "Coup Fourre"); InScore (4, -1, "Trip Complete"); InScore (5, -1, "Safe Trip"); InScore (6, -1, "Delayed Action"); InScore (7, -1, "Extension"); InScore (8, -1, "Shut Out"); InScore (9, -1, "Hand Total"); InScore (10, -1, "Overall Total"); InScore (11, -1, "Games"); } draw_board () { int i, x, y1, ym1, y2, ym2, width; char buffer[50]; redraw_board (); newscore (); for (i = 0; i <= 1000; i += 100) { sprintf (buffer, "%d", i); x = COMP_DIST_TX + (i * DIST_WIDTH) / 1000; y1 = COMP_DIST_TY + MESS_H; ym1 = COMP_DIST_MY + MESS_H; y2 = HUM_DIST_TY + MESS_H; ym2 = HUM_DIST_MY + MESS_H; width = XTextWidth (font, buffer, strlen(buffer)); displayString (x - width / 2, y1, buffer, strlen(buffer)); displayString (x - width / 2, y2, buffer, strlen(buffer)); } } redraw_board () { redraw_region (0, 0, WINDOW_WIDTH, WINDOW_HEIGHT); } exposeBoard (rep) XExposeEvent *rep; { XRectangle rect; rect.x = rep->x; rect.y = rep->y; rect.width = rep->width; rect.height = rep->height; XUnionRectWithRegion(&rect, mine, mine); if( rep->count == 0 ) { XClipBox(mine, &rect); XIntersectRegion(null, mine, mine); redraw_region (rect.x, rect.y, rect.width, rect.height); /*redraw_board();*/ } } redraw_region (xpos, ypos, w, h) { int x1, y1, x2, y2; int i; int ym1, ym2, x; char buffer[20]; int width; XDrawImageString (dpy, xwindow, text_gc, DISCARD_TX, DISCARD_TY, "Discard Pile", 12); RedisplayHumanDistance (); RedisplayComputerDistance (); x1 = HUM_HAND_X - PAD_CARD/2; y1 = HUM_HAND_Y - PAD_CARD/2; x2 = HUM_HAND_X + (WIDTH + PAD_CARD) * 7 - PAD_CARD/2; y2 = HUM_HAND_Y + (HEIGHT + PAD_CARD) - PAD_CARD/2; XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x1, y1, x2, y1); XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x2, y1, x2, y2); XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x2, y2, x1, y2); XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x1, y2, x1, y1); for (i = 0; i <= 1000; i += 100) { x = COMP_DIST_TX + (i * DIST_WIDTH) / 1000; y1 = COMP_DIST_TY + MESS_H; ym1 = COMP_DIST_MY + MESS_H; y2 = HUM_DIST_TY + MESS_H; ym2 = HUM_DIST_MY + MESS_H; XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x, ym1, x, ym1 + DIST_MARK); XDrawLine (dpy, xwindow, colorMap[BLACK_COLOR].gc, x, ym2, x, ym2 + DIST_MARK); } cardRedisplay (xpos, ypos, w, h); redisplayStrings (xpos, ypos, w, h); } char *font_name; char *bold_font_name; init_ui (argc, argv) int argc; char **argv; { XColor hardware_color, exact_color; XClassHint xch; XWMHints xwm; XSizeHints xsh; int i; int do_quit (), do_save (); int CmanageButton (); XGCValues gcv; Colormap def_cm; XEvent ev; char *def; extern double animation_speed; unsigned long gcmask; Pixmap grayStipple; XSetWindowAttributes winvalues; unsigned long winmask; dpy = XOpenDisplay ((char *) 0); screen = DefaultScreen(dpy); def_cm = DefaultColormap(dpy, screen); if (def = XGetDefault (dpy, argv[0], "animationSpeed")) animation_speed = ((double) atoi (def)) / 100.0; font_name = "fixed"; if (def = XGetDefault (dpy, argv[0], "font")) font_name = def; bold_font_name = "fixed"; if (def = XGetDefault (dpy, argv[0], "boldFont")) bold_font_name = def; font = XLoadQueryFont (dpy, font_name); if (DisplayCells(dpy, screen) > 2) iscolor = 1; else { iscolor = 0; grayStipple = XCreateBitmapFromData (dpy, RootWindow (dpy, screen), gray_bits, gray_width, gray_height); } for (i = 0; i < NUM_COLOR; i++) { if (!iscolor && i > WHITE_COLOR) { gcv.foreground = WhitePixel (dpy, screen); gcv.background = BlackPixel (dpy, screen); gcv.fill_style = FillOpaqueStippled; gcv.stipple = grayStipple; gcmask = GCForeground|GCBackground|GCFillStyle|GCStipple; } else { XAllocNamedColor (dpy, def_cm, colorMap[i].name, &hardware_color, &exact_color); colorMap[i].pixel = hardware_color.pixel; gcv.foreground = hardware_color.pixel; gcmask = GCForeground; } if (font) { gcv.font = font->fid; gcmask |= GCFont; } colorMap[i].gc = XCreateGC (dpy, RootWindow(dpy, screen), gcmask, &gcv); } if (iscolor) { winvalues.background_pixel = colorMap[GREY_COLOR].pixel; winvalues.border_pixel = colorMap[BLACK_COLOR].pixel; winmask = CWBackPixel|CWBorderPixel; } else { winvalues.background_pixel = colorMap[WHITE_COLOR].pixel; winvalues.border_pixel = colorMap[BLACK_COLOR].pixel; winmask = CWBackPixel|CWBorderPixel; } text_gc = colorMap[BLACK_COLOR].gc; if (iscolor) gcv.background = colorMap[GREY_COLOR].pixel; else gcv.background = colorMap[WHITE_COLOR].pixel; XChangeGC (dpy, text_gc, GCBackground, &gcv); if (!font) font = XQueryFont (dpy, text_gc->gid); gcv.foreground = colorMap[WHITE_COLOR].pixel ^ colorMap[BLACK_COLOR].pixel; gcv.function = GXxor; xor_gc = XCreateGC (dpy, RootWindow (dpy, screen), GCForeground|GCFunction, &gcv); xsh.flags = PSize | PMinSize | PMaxSize; xsh.width = xsh.min_width = xsh.max_width = WINDOW_WIDTH; xsh.height = xsh.min_height = xsh.max_height = WINDOW_HEIGHT; xwindow = XCreateWindow (dpy, RootWindow(dpy, screen), 0, 0, xsh.width, xsh.height, 1, DefaultDepth (dpy, screen), InputOutput, CopyFromParent, winmask, &winvalues); XStoreName(dpy, xwindow, "Xmille -- Version 1.1"); XSetIconName(dpy, xwindow, "Xmille"); xch.res_name = "xmille"; xch.res_class = "XMille"; XSetClassHint(dpy, xwindow, &xch); xwm.flags = InputHint | StateHint; xwm.input = True; xwm.initial_state = NormalState; XSetWMHints(dpy, xwindow, &xwm); XSetNormalHints(dpy, xwindow, &xsh); co_init (font_name, bold_font_name); QUIT = CcreateButton ("Quit", 50, colorMap[BLACK_COLOR].gc, font, colorMap[WHITE_COLOR].pixel, 1); SAVE = CcreateButton ("Save", 50, colorMap[BLACK_COLOR].gc, font, colorMap[WHITE_COLOR].pixel, 1); qwindow = CmapButton (xwindow, QUIT_X, QUIT_Y, QUIT, do_quit); swindow = CmapButton (xwindow, SAVE_X, SAVE_Y, SAVE, do_save); bindEvent (qwindow, ExposureMask|ButtonPressMask|LeaveWindowMask|ButtonReleaseMask, CmanageButton); bindEvent (swindow, ExposureMask|ButtonPressMask|LeaveWindowMask|ButtonReleaseMask, CmanageButton); XSelectInput (dpy, xwindow, ExposureMask); XMapWindow (dpy, xwindow); if (iscolor) init_color_cards (); else init_mono_cards(); for (;;) { XNextEvent (dpy, &ev); if (ev.type == Expose); break; } bindEvent (xwindow, ExposureMask, exposeBoard); mine = XCreateRegion(); null = XCreateRegion(); } finish_ui () { } update_ui () { XFlush (dpy); } Beep () { XBell (dpy, 0); } /* * Get a yes or no answer to the given question. Saves are * also allowed. Return TRUE if the answer was yes, FALSE if no. */ getyn(prompt) register char *prompt; { register char c; return co_affirm (prompt, xwindow); } static char incharacter; static int gotcharacter; static int getmove_done; mouse_event (rep) XButtonEvent *rep; { int x, y; x = rep->x; y = rep->y; if (HUM_HAND_Y <= y && y <= HUM_HAND_Y + HEIGHT && HUM_HAND_X <= x && x <= HUM_HAND_X + (WIDTH + PAD_CARD) * 7) { switch (rep->button & 0377) { case Button1: Movetype = M_PLAY; break; case Button2: Movetype = M_REASONABLE; break; case Button3: Movetype = M_DISCARD; break; } Card_no = (x - HUM_HAND_X) / (WIDTH + PAD_CARD); getmove_done = 1; return; } if (DECK_Y <= y && y <= DECK_Y + HEIGHT && DECK_X <= x && x <= DECK_X + WIDTH) { Movetype = M_DRAW; getmove_done = 1; return; } Beep (); } getmove() { getmove_done = 0; bindEvent (xwindow, ButtonPressMask, mouse_event); while (!getmove_done) { dispatch (); } unbindEvent (xwindow, ButtonPressMask); } do_save () { save (); } do_quit () { rub(); } # define COMP_STRT 20 # define CARD_STRT 2 prboard() { register PLAY *pp; register int i, j, k, temp; for (k = 0; k < 2; k++) { pp = &Player[k]; temp = k * COMP_STRT + CARD_STRT; for (i = 0; i < NUM_SAFE; i++) if (pp->safety[i] == S_PLAYED) { if (k == 0) { HumanSafety (i + S_CONV, i); } else { ComputerSafety (i + S_CONV, i); } } if (k == 0) { HumanBattle (pp->battle); HumanSpeed (pp->speed); } else { ComputerBattle (pp->battle); ComputerSpeed (pp->speed); } for (i = C_25; i <= C_200; i++) { register char *name; register int end; name = C_name[i]; temp = k * 40; end = pp->nummiles[i]; if (k == 0) HumanMiles (i, C_200-i, end); else ComputerMiles (i, C_200-i, end); } } prscore(TRUE); temp = CARD_STRT; pp = &Player[PLAYER]; for (i = 0; i < HAND_SZ; i++) { HumanHand (pp->hand[i], i); } DisplayDeck (Topcard - Deck); DisplayDiscard (Discard); if (End == 1000) { static char ext[] = "Extension"; /* stand(EXT_Y, EXT_X, ext); */ } } /* * Put str at (y,x) in standout mode */ stand(y, x, str) register int y, x; register char *str; { } InScore (line, player, text) int line, player; char *text; { displayString (SCORE_X + player * SCORE_W, SCORE_Y + SCORE_H * (line + 1), text); } struct displayedString { struct displayedString *next; int x, y; int w; char *data; }; struct displayedString *strings; displayString (x, y, string) char *string; { struct displayedString *s; for (s = strings; s; s = s->next) { if (s->x == x && s->y == y) break; } if (s) { if (!strcmp (s->data, string)) return; } else { s = (struct displayedString *) malloc (sizeof (struct displayedString)); s->x = x; s->y = y; s->data = 0; s->next = strings; strings = s; } if (s->data) { s->data = (char *) realloc (s->data, strlen (string) + 1); } else { s->data = (char *) malloc (strlen (string) + 1); } strcpy (s->data, string); s->w = XTextWidth (font, string, strlen (string)); XDrawImageString (dpy, xwindow, text_gc, s->x, s->y, s->data, strlen (s->data)); } stringsEraseAll () { struct displayedString *s, *n; for (s = strings; s; s = n) { n = s->next; free (s->data); free (s); } strings = 0; } redisplayStrings (x, y, w, h) { struct displayedString *s; int sx, sy, sw, sh; for (s = strings; s; s = s->next) { sx = s->x; sy = s->y - font->ascent; sw = s->w; sh = font->ascent + font->descent; if (x < sx + sw && y < sy + sh && sx < x + w && sy < y + h) XDrawImageString (dpy, xwindow, text_gc, s->x, s->y, s->data, strlen (s->data)); } } prscore(for_real) register bool for_real; { register PLAY *pp; register int x; register char *Score_fmt = "%4d "; char buffer[512]; ComputerDistance (Player[1].mileage); HumanDistance (Player[0].mileage); for (pp = Player; pp < &Player[2]; pp++) { x = (pp - Player) * 6 + 21; sprintf (buffer, Score_fmt, pp->mileage); InScore (0, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->safescore); InScore (1, pp - Player, buffer); if (pp->safescore == 400) InScore (2, pp - Player, " 300 "); else InScore (2, pp - Player, " 0 "); sprintf (buffer, Score_fmt, pp->coupscore); InScore (3, pp - Player, buffer); #ifdef EXTRAP if (for_real) finalscore(pp); else extrapolate(pp); #else finalscore(pp); #endif sprintf (buffer, Score_fmt, pp->hand_tot); InScore (9, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->total); InScore (10, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->games); InScore (11, pp - Player, buffer); } } FlushInput () { } kgames-2.2/xmille/ui.h000066400000000000000000000060271416764561500147300ustar00rootroot00000000000000# include # include "color.h" # include "control/control.h" extern Display *dpy; extern int screen; extern Window xwindow; extern XFontStruct *font; extern Pixmap fill; extern GC text_gc, xor_gc; # define MAXBITMAPS 4 struct card { struct card_init { char *bits; int color; } init[MAXBITMAPS]; char *label; Pixmap bits; }; extern struct card *cards; extern struct card deck; extern struct card blank; struct safety_offset { int x; int y; }; extern struct safety_offset safety_offsets[4]; # define PAD_CARD (5) # define MILE_OFFSET (5) # define PAD_TEXT (20) # define DIST_HEIGHT (15) # define DIST_WIDTH ((WIDTH + PAD_CARD) * 5 - PAD_CARD) # define DIST_MARK (4) # define COMP_HAND_X (PAD_CARD) # define COMP_HAND_Y (-HEIGHT + font->descent) # define COMP_DIST_TX (PAD_CARD + (WIDTH + PAD_CARD) * 2) # define COMP_DIST_TY (PAD_CARD) # define COMP_DIST_MX (COMP_DIST_TX) # define COMP_DIST_MY (COMP_DIST_TY + PAD_TEXT) # define COMP_DIST_X (COMP_DIST_MX) # define COMP_DIST_Y (COMP_DIST_MY + DIST_MARK + 1) # define COMP_PLAY_X PAD_CARD # define COMP_PLAY_Y (COMP_DIST_Y + DIST_HEIGHT + PAD_CARD) # define COMP_SAFE_X (COMP_PLAY_X + ((WIDTH + PAD_CARD) * 7)) # define COMP_SAFE_Y COMP_PLAY_Y # define COMP_CARD_TX PAD_CARD # define COMP_CARD_TY (COMP_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD) # define COMP_CARD_X COMP_CARD_TX # define COMP_CARD_Y (COMP_CARD_TY + PAD_TEXT) # define MESS_X (PAD_CARD) # define MESS_Y (COMP_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD + PAD_TEXT) # define MESS_W (150) # define MESS_H (font->ascent + font->descent) # define PROMPT_X MESS_X # define PROMPT_Y (MESS_Y + PAD_TEXT) # define PROMPT_W (MESS_W) # define PROMPT_H (MESS_H) # define ERROR_X PROMPT_X # define ERROR_Y (PROMPT_Y + PAD_TEXT) # define ERROR_W (MESS_W) # define ERROR_H (MESS_H) # define QUIT_X (MESS_X) # define QUIT_Y (ERROR_Y + PAD_TEXT + PAD_CARD) # define SAVE_X (QUIT_X + 75) # define SAVE_Y (QUIT_Y) # define DISCARD_TX (MESS_X + MESS_W + PAD_CARD) # define DISCARD_TY (MESS_Y - PAD_TEXT) # define DISCARD_X (DISCARD_TX) # define DISCARD_Y (DISCARD_TY + PAD_TEXT) # define DECK_TX (DISCARD_X + WIDTH + PAD_CARD) # define DECK_TY (DISCARD_TY) # define DECK_X (DECK_TX) # define DECK_Y (DISCARD_Y) # define SCORE_W (150) # define SCORE_H (font->ascent + font->descent) # define SCORE_N 13 # define SCORE_X (DECK_X + WIDTH + PAD_CARD + SCORE_W) # define SCORE_Y (DECK_TY) # define HUM_DIST_TX (COMP_DIST_TX) # define HUM_DIST_TY (SCORE_Y + SCORE_N * SCORE_H + PAD_CARD) # define HUM_DIST_MX (HUM_DIST_TX) # define HUM_DIST_MY (HUM_DIST_TY + PAD_TEXT) # define HUM_DIST_X (HUM_DIST_MX) # define HUM_DIST_Y (HUM_DIST_MY + DIST_MARK + 1) # define HUM_PLAY_X PAD_CARD # define HUM_PLAY_Y (HUM_DIST_Y + DIST_HEIGHT + PAD_CARD) # define HUM_SAFE_X (HUM_PLAY_X + ((WIDTH + PAD_CARD) * 7)) # define HUM_SAFE_Y (HUM_PLAY_Y) # define HUM_HAND_X PAD_CARD # define HUM_HAND_Y (HUM_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD) # define WINDOW_WIDTH (HUM_SAFE_X + (WIDTH + PAD_CARD) * 2) # define WINDOW_HEIGHT (HUM_HAND_Y + HEIGHT + PAD_CARD) kgames-2.2/xmille/uiXt.c000066400000000000000000000622241416764561500152400ustar00rootroot00000000000000/* * ui.c * * interface routines for mille */ # include "mille.h" # include "uiXt.h" # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include "gray.bm" # include "cards-svg.h" # include "Mille-res.h" # include "MilleCards.h" # include "card.h" struct color colorMap[NUM_COLOR] = { { "black", 0, 0, }, { "white", 0, 0, }, { "red", 0, 0, }, { "green", 0, 0, }, { "light gray", 0, 0, }, { "blue", 0, 0, }, }; Display *dpy; int screen; Pixmap fill; XFontStruct *font, *backFont; GC text_gc; GC xor_gc; Widget toplevel; Widget layout; Widget menu_bar; Widget file_menu_button; Widget file_menu; Widget computer_play; Widget computer_miles; Widget computer_safeties; Widget computer_safety_label; Widget deck_count; Widget deck_hand; Widget score; Widget message, errors, prompt; Widget quit_button, save_button; Widget human_miles; Widget human_hand; Widget human_play; Widget human_safeties; Widget human_safety_label; double scale = 2.0; Widget yes_or_no_shell; Widget yes_or_no_dialog; Widget yes_or_no_label; Widget prompted_shell; Widget prompted_dialog; Widget prompted_value; Widget prompted_label; #define NUM_COLS_IN_MILES 5 #define SPEED_CARD 0 #define BATTLE_CARD 1 #define MILES_OFFSET 2 #define NUM_COLS_IN_PLAY NUM_COLS_IN_MILES + MILES_OFFSET #define NUM_COLS_IN_HAND HAND_SZ typedef struct recordHand { XtPointer card; int type; } RecordHandRec, *RecordHandPtr; struct menuEntry { char *name; void (*function)(Widget w, XtPointer closure, XtPointer data); }; RecordHandRec humanHandCards[NUM_COLS_IN_HAND]; RecordHandRec humanPlayCards[2]; int humanMiles[NUM_COLS_IN_MILES]; RecordHandRec humanSafeties[4]; RecordHandRec computerPlayCards[2]; int computerMiles[NUM_COLS_IN_MILES]; RecordHandRec computerSafeties[4]; #define DECK_DRAW 0 #define DECK_DISCARD 1 RecordHandRec deckCards[2]; static int getmove_done; static void DoRestore (Widget w, XtPointer closure, XtPointer data); static void DoSave (Widget w, XtPointer closure, XtPointer data); static void DoQuit (Widget w, XtPointer closure, XtPointer data); static struct menuEntry fileMenuEntries[] = { { "restore", DoRestore, }, { "save", DoSave, }, { "quit", DoQuit, }, }; int iscolor; void MilleMessage (char *string) { Message (message, "%s", string); } void VError(const char *string, va_list ap) { MessageV(errors, string, ap); } void Error (const char *string, ...) { va_list ap; va_start(ap, string); VError(string, ap); va_end(ap); } void Prompt (char *string) { (void) string; #ifdef NOTDEF displayString (prompt, string); #endif } /* void debug (int pos, char *string, int a0, int a1, int a2) { } */ static int yn_done, yn_answer; static void YesFunc (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; yn_answer = 1; yn_done = 1; } static void NoFunc (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; yn_answer = 0; yn_done = 1; } void ComputerCard (int type) { (void) type; /* displayCard (type, COMP_CARD_X, COMP_CARD_Y);*/ } void ComputerStatus (char *string) { (void) string; /* char buffer[512]; sprintf (buffer, "I %-10.10s", string); */ } void ComputerDistance (int distance) { Arg arg[1]; XtSetArg (arg[0], XtNcurrent, distance); XtSetValues (computer_miles, arg, 1); } static void UpdateCard (Widget w, RecordHandPtr array, int ind, int col, int row, int type) { if (type == -1) { if (array[ind].card) { HandRemoveCard (w, array[ind].card); array[ind].card = NULL; } } else if (!array[ind].card || type != array[ind].type) { if (array[ind].card) HandReplaceCard (w, array[ind].card, (XtPointer) (intptr_t) type, XkwHandDefaultOffset); else array[ind].card = HandAddCard (w, (XtPointer) (intptr_t) type, row, col, XkwHandDefaultOffset); } array[ind].type = type; } void ComputerSpeed (int type) { UpdateCard (computer_play, computerPlayCards, SPEED_CARD, SPEED_CARD, 0, type); } void ComputerBattle (int type) { UpdateCard (computer_play, computerPlayCards, BATTLE_CARD, BATTLE_CARD, 0, type); } void ComputerMiles (int type, int ind, int count) { while (computerMiles[ind] < count) { HandAddCard (computer_play, (XtPointer) (intptr_t) type, InsertRow, ind + MILES_OFFSET, XkwHandDefaultOffset); ++computerMiles[ind]; } } void EraseComputer (void) { int i; for (i = 0; i < NUM_COLS_IN_MILES; i++) computerMiles[i] = 0; for (i = 0; i < 2; i++) computerPlayCards[i].card = 0; HandRemoveAllCards (computer_play); for (i = 0; i < 4; i++) computerSafeties[i].card = 0; HandRemoveAllCards (computer_safeties); ComputerDistance (0); } void ComputerSafety (int type, int ind) { int row, col; row = ind & 1; col = (ind & 2) >> 1; UpdateCard (computer_safeties, computerSafeties, ind, col, row, type); } void DisplayDiscard (int type) { UpdateCard (deck_hand, deckCards, DECK_DISCARD, DECK_DISCARD, 0, type); } void DisplayDeck (int numberLeft) { Message(deck_count, "Cards: %d", numberLeft); } void HumanDistance (int distance) { Arg arg[1]; XtSetArg (arg[0], XtNcurrent, distance); XtSetValues (human_miles, arg, 1); } void HumanSpeed (int type) { UpdateCard (human_play, humanPlayCards, SPEED_CARD, SPEED_CARD, 0, type); } void HumanBattle (int type) { UpdateCard (human_play, humanPlayCards, BATTLE_CARD, BATTLE_CARD, 0, type); } void HumanMiles (int type, int ind, int count) { while (humanMiles[ind] < count) { HandAddCard (human_play, (XtPointer) (intptr_t) type, InsertRow, ind + MILES_OFFSET, XkwHandDefaultOffset); ++humanMiles[ind]; } } void EraseHuman (void) { int i; for (i = 0; i < NUM_COLS_IN_MILES; i++) humanMiles[i] = 0; for (i = 0; i < 2; i++) humanPlayCards[i].card = 0; HandRemoveAllCards (human_play); for (i = 0; i < NUM_COLS_IN_HAND; i++) humanHandCards[i].card = 0; HandRemoveAllCards (human_hand); for (i = 0; i < 4; i++) humanSafeties[i].card = 0; HandRemoveAllCards (human_safeties); HumanDistance (0); } void HumanSafety (int type, int ind) { int row, col; row = ind & 1; col = (ind & 2) >> 1; UpdateCard (human_safeties, humanSafeties, ind, col, row, type); } void HumanHand (int type, int ind) { UpdateCard (human_hand, humanHandCards, ind, ind, 0, type); } void newboard(void) { EraseHuman (); EraseComputer (); } void newscore(void) { int i; char c; InScore (-1, 0, " You"); InScore (-1, 1, "Computer"); c = XkwPadUnderline; for (i = 20; i < 48; i++) XkwPadAttributes (score, 0, i, &c, 1); InScore (0, -1, "Milestones"); InScore (1, -1, "Safeties"); InScore (2, -1, "All 4 Safeties"); InScore (3, -1, "Coup Fourre"); InScore (4, -1, "Trip Complete"); InScore (5, -1, "Safe Trip"); InScore (6, -1, "Delayed Action"); InScore (7, -1, "Extension"); InScore (8, -1, "Shut Out"); InScore (9, -1, "Hand Total"); InScore (10, -1, "Overall Total"); InScore (11, -1, "Games"); XkwPadUpdate (score); } void draw_board (void) { } void redraw_board (void) { } typedef struct _milleResources { XFontStruct *font; XFontStruct *backFont; int animationSpeed; Boolean color; Boolean clipCards; } MilleResources, *MilleResourcesPtr; MilleResources milleResources; #define offset(field) XtOffsetOf(MilleResources, field) #define COLOR_UNSET 10 XtResource resources[] = { { XtNfont, XtCFont, XtRFontStruct, sizeof (XFontStruct *), offset (font), XtRString, XtDefaultFont}, { "backFont", XtCFont, XtRFontStruct, sizeof (XFontStruct *), offset (backFont), XtRString, XtDefaultFont}, { "animationSpeed", "AnimationSpeed", XtRInt, sizeof (int), offset(animationSpeed), XtRImmediate, (XtPointer) 20}, { "color", "Color", XtRBoolean, sizeof (Boolean), offset(color), XtRImmediate, (XtPointer) COLOR_UNSET }, { "clipCards", "ClipCards", XtRBoolean, sizeof (Boolean), offset(clipCards), XtRImmediate, (XtPointer) TRUE}, }; static void yes_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) e; (void) p; (void) n; YesFunc (w, (XtPointer) NULL, (XtPointer) NULL); } static void no_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) e; (void) p; (void) n; NoFunc (w, (XtPointer) NULL, (XtPointer) NULL); } static void noop_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; } static void card_action(String *p, Cardinal *n, int m) { if (*n == 1) { Movetype = m; Card_no = atoi (*p) - 1; getmove_done = 1; } else { Beep (); } } static void discard_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; card_action (p, n, M_DISCARD); } static void draw_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Movetype = M_DRAW; getmove_done = 1; } static void play_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; card_action (p, n, M_PLAY); } static void reasonable_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; card_action (p, n, M_REASONABLE); } static void order_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; Order = !Order; Movetype = M_ORDER; getmove_done = 1; } static void quit_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; DoQuit (w, (XtPointer) 0, (XtPointer) 0); } static void save_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; DoSave (w, (XtPointer) 0, (XtPointer) 0); } static void restore_action (Widget w, XEvent *e, String *p, Cardinal *n) { (void) w; (void) e; (void) p; (void) n; DoRestore (w, (XtPointer) 0, (XtPointer) 0); } XtActionsRec actions[] = { { "milleYes", yes_action, }, { "milleNo", no_action, }, { "milleCancel", no_action, }, { "Noop", noop_action, }, { "milleDiscard", discard_action, }, { "milleDraw", draw_action, }, { "millePlay", play_action, }, { "milleReasonable", reasonable_action, }, { "milleOrder", order_action, }, { "milleQuit", quit_action, }, { "milleSave", save_action, }, { "milleRestore", restore_action, }, }; static void InputCallback (Widget w, XtPointer closure, XtPointer data) { HandInputPtr input = (HandInputPtr) data; String arg = ""; (void) w; (void) closure; if (*input->num_params > 0) arg = input->params[0]; switch (input->action) { default: break; case HandActionClick: animate_enable(1); if (input->start.w == human_hand) { if (strcmp(arg, "discard") == 0) Movetype = M_DISCARD; else Movetype = M_REASONABLE; getmove_done = 1; Card_no = input->start.col; } else if (input->start.w == deck_hand) { Movetype = M_DRAW; getmove_done = 1; Card_no = input->start.col; } break; case HandActionDrag: if (input->start.w == input->current.w) break; animate_enable(0); if (input->start.w == human_hand) { if (input->current.w == human_miles || input->current.w == human_play || input->current.w == human_safeties) { Movetype = M_PLAY; getmove_done = 1; Card_no = input->start.col; } else if (input->current.w == deck_hand) { Movetype = M_DISCARD; getmove_done = 1; Card_no = input->start.col; } break; } else if (input->start.w == deck_hand) { if (input->current.w == human_hand) { Movetype = M_DRAW; getmove_done = 1; Card_no = input->start.col; } } } } static Widget make_hand (char *name, Widget parent, int rows, int cols, Bool overlap_rows) { Widget hand; Arg args[20]; Cardinal i = 0; int display_x, display_y; XtSetArg (args[i], XtNcardWidth, WIDTH * scale); i++; XtSetArg (args[i], XtNcardHeight, HEIGHT * scale); i++; XtSetArg (args[i], XtNnumRows, rows); i++; XtSetArg (args[i], XtNnumCols, cols); i++; XtSetArg (args[i], XtNinternalBorderWidth, WIDTH * scale / 20); i++; if (!overlap_rows) { XtSetArg (args[i], XtNrowOffset, HEIGHT * scale + WIDTH * scale/20); i++; } else { XtSetArg (args[i], XtNrowOffset, WIDTH * scale/20); i++; } XtSetArg (args[i], XtNcolOffset, WIDTH * scale + WIDTH * scale/20); i++; display_x = 0; display_y = 0; if (rows == 1) display_x = 8; else display_y = 8; XtSetArg (args[i], XtNdisplayX, display_x); i++; XtSetArg (args[i], XtNdisplayY, display_y); i++; XtSetArg (args[i], XtNdisplayWidth, WIDTH * scale - display_x * 2); i++; XtSetArg (args[i], XtNdisplayHeight, HEIGHT * scale - display_y * 2); i++; hand = XtCreateManagedWidget (name, milleCardsWidgetClass, parent, args, i); XtAddCallback (hand, XtNinputCallback, InputCallback, NULL); return hand; } static void DoRestore (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; rest(); prboard(); } static void DoSave (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; save (); } static void DoQuit (Widget w, XtPointer closure, XtPointer data) { (void) w; (void) closure; (void) data; rub (0); } static Widget CreateMenu (Widget parent, char *name, struct menuEntry *entries, int count) { Widget menu; Widget entry; int i; menu = XtCreatePopupShell (name, ksimpleMenuWidgetClass, parent, NULL, ZERO); for (i = 0; i < count; i++) { entry = XtCreateManagedWidget (entries[i].name, ksmeBSBObjectClass, menu, NULL, ZERO); XtAddCallback (entry, XtNcallback, entries[i].function, NULL); } return menu; } int clip_cards; void init_ui (int *argc, char **argv) { XColor hardware_color, exact_color; int i; XGCValues gcv; Colormap def_cm; extern double animation_speed; unsigned long gcmask; Pixmap grayStipple = None; Arg arg[2]; Visual *visual; toplevel = XkwInitialize ("Mille", 0, 0, argc, argv, True, defaultResources); Arg args[1]; XtSetArg(args[0], XtNinput, True); XtSetValues(toplevel, args, ONE); dpy = XtDisplay (toplevel); screen = DefaultScreen(dpy); def_cm = DefaultColormap(dpy, screen); visual = DefaultVisual(dpy, screen); XtGetApplicationResources (toplevel, (XtPointer)&milleResources, resources, XtNumber (resources), NULL, 0); XtAddActions (actions, XtNumber(actions)); animation_speed = milleResources.animationSpeed; clip_cards = milleResources.clipCards; font = milleResources.font; backFont = milleResources.backFont; if (milleResources.color == COLOR_UNSET) { iscolor = TRUE; if (visual->map_entries < 3) iscolor = FALSE; } else iscolor = milleResources.color; if (!iscolor) { grayStipple = XCreateBitmapFromData (dpy, RootWindow (dpy, screen), gray_bits, gray_width, gray_height); } for (i = 0; i < NUM_COLOR; i++) { if (!iscolor && i > WHITE_COLOR) { gcv.foreground = WhitePixel (dpy, screen); gcv.background = BlackPixel (dpy, screen); gcv.fill_style = FillOpaqueStippled; gcv.stipple = grayStipple; gcmask = GCForeground|GCBackground|GCFillStyle|GCStipple; } else { XAllocNamedColor (dpy, def_cm, colorMap[i].name, &hardware_color, &exact_color); colorMap[i].pixel = hardware_color.pixel; gcv.foreground = hardware_color.pixel; gcmask = GCForeground; } if (font) { gcv.font = font->fid; gcmask |= GCFont; } colorMap[i].gc = XCreateGC (dpy, RootWindow(dpy, screen), gcmask, &gcv); } text_gc = colorMap[BLACK_COLOR].gc; if (iscolor) gcv.background = colorMap[GREY_COLOR].pixel; else gcv.background = colorMap[WHITE_COLOR].pixel; XChangeGC (dpy, text_gc, GCBackground, &gcv); if (!font) font = XQueryFont (dpy, XGContextFromGC (text_gc)); if (!backFont) backFont = font; gcv.foreground = colorMap[WHITE_COLOR].pixel ^ colorMap[BLACK_COLOR].pixel; gcv.function = GXxor; gcv.subwindow_mode = IncludeInferiors; xor_gc = XCreateGC (dpy, RootWindow (dpy, screen), GCForeground|GCFunction|GCSubwindowMode, &gcv); if (iscolor) init_color_cards (); else init_mono_cards(); layout = XtCreateManagedWidget ("layout", layoutWidgetClass, toplevel, NULL, (Cardinal) 0); menu_bar = XtCreateManagedWidget ("menuBar", boxWidgetClass, layout, NULL, ZERO); file_menu_button = XtCreateManagedWidget ("fileMenuButton", kmenuButtonWidgetClass, menu_bar, NULL, ZERO); file_menu = CreateMenu (file_menu_button, "fileMenu", fileMenuEntries, XtNumber (fileMenuEntries)); computer_play = make_hand ("computerPlay", layout, 3, 7, True); computer_miles = XtCreateManagedWidget ("computerMiles", thermoWidgetClass, layout, NULL, ZERO); computer_safeties = make_hand ("computerSafeties", layout, 2, 2, False); computer_safety_label = XtCreateManagedWidget ("computerSafetyLabel", klabelWidgetClass, layout, NULL, ZERO); deck_count = XtCreateManagedWidget ("deckCount", klabelWidgetClass, layout, NULL, ZERO); deck_hand = make_hand ("deck", layout, 1, 2, False); XtSetArg (arg[0], XtNnumRows, 13); XtSetArg (arg[1], XtNnumCols, 48); score = XtCreateManagedWidget ("score", padWidgetClass, layout, arg, TWO); HandAddCard (deck_hand, (XtPointer) -2, 0, 0, XkwHandDefaultOffset); message = XtCreateManagedWidget ("message", klabelWidgetClass, layout, NULL, ZERO); errors = XtCreateManagedWidget ("errors", klabelWidgetClass, layout, NULL, ZERO); human_miles = XtCreateManagedWidget ("humanMiles", thermoWidgetClass, layout, NULL, ZERO); human_play = make_hand ("humanPlay", layout, 3, 7, True); human_hand = make_hand ("humanHand", layout, 1, 7, False); human_safeties = make_hand ("humanSafeties", layout, 2, 2, False); human_safety_label = XtCreateManagedWidget ("humanSafetyLabel", klabelWidgetClass, layout, NULL, ZERO); newscore (); prscore (FALSE); XtRealizeWidget (toplevel); XkwSetIcon(toplevel, icon.svg); yes_or_no_shell = XtCreatePopupShell ("yesOrNo", transientShellWidgetClass, toplevel, NULL, ZERO); yes_or_no_dialog = XtCreateManagedWidget ("yesOrNoDialog", layoutWidgetClass, yes_or_no_shell, NULL, ZERO); yes_or_no_label = XtCreateManagedWidget ("yesOrNoLabel", klabelWidgetClass, yes_or_no_dialog, NULL, ZERO); XkwDialogAddButton (yes_or_no_dialog, "yesOrNoOk", YesFunc, NULL); XkwDialogAddButton (yes_or_no_dialog, "yesOrNoNo", NoFunc, NULL); XtRealizeWidget (yes_or_no_shell); prompted_shell = XtCreatePopupShell ("prompted", transientShellWidgetClass, toplevel, NULL, ZERO); XtSetArg (arg[0], XtNvalue, ""); prompted_dialog = XtCreateManagedWidget ("promptedDialog", layoutWidgetClass, prompted_shell, arg, ONE); prompted_label = XtCreateManagedWidget ("promptedLabel", klabelWidgetClass, prompted_dialog, NULL, ZERO); prompted_value = XtCreateManagedWidget ("promptedValue", ktextLineWidgetClass, prompted_dialog, NULL, ZERO); XtAddCallback(prompted_value, XtNcallback, YesFunc, NULL); XkwDialogAddButton (prompted_dialog, "promptedOk", YesFunc, NULL); XkwDialogAddButton (prompted_dialog, "promptedCancel", NoFunc, NULL); XtRealizeWidget (prompted_shell); } static void DisplayText (Widget w, int row, int col, char *text) { XkwPadText (w, row, col, text, strlen (text)); } void finish_ui (void) { } void update_ui (void) { XFlush (dpy); } void Beep (void) { XBell (dpy, 0); } /* * Get a yes or no answer to the given question. Saves are * also allowed. Return TRUE if the answer was yes, FALSE if no. */ static void Center (Widget original, Widget new) { Arg args[2]; Dimension center_width, center_height; Dimension prompt_width, prompt_height; Position source_x, source_y, dest_x, dest_y; /* * place the widget in the center of the "parent" */ XtSetArg (args[0], XtNwidth, ¢er_width); XtSetArg (args[1], XtNheight, ¢er_height); XtGetValues (original, args, 2); XtSetArg (args[0], XtNwidth, &prompt_width); XtSetArg (args[1], XtNheight, &prompt_height); XtGetValues (new, args, 2); source_x = (int)(center_width - prompt_width) / 2; source_y = (int)(center_height - prompt_height) / 3; XtTranslateCoords (original, source_x, source_y, &dest_x, &dest_y); XtSetArg (args[0], XtNx, dest_x); XtSetArg (args[1], XtNy, dest_y); XtSetValues (new, args, 2); } int getyn(char *prompt) { Arg args[1]; XEvent event; XtSetArg (args[0], XtNlabel, prompt); XtSetValues (yes_or_no_label, args, 1); Center (toplevel, yes_or_no_shell); XtMapWidget (yes_or_no_shell); XtSetKeyboardFocus (toplevel, yes_or_no_dialog); yn_done = 0; while (!yn_done) { XtNextEvent (&event); XtDispatchEvent (&event); } XtSetKeyboardFocus (toplevel, (Widget) None); XtUnmapWidget (yes_or_no_shell); return yn_answer; } char * GetpromptedInput (char *string) { Arg args[1]; XEvent event; char *value; XtSetArg (args[0], XtNlabel, string); XtSetValues (prompted_label, args, 1); Center (toplevel, prompted_shell); XtMapWidget (prompted_shell); XtSetKeyboardFocus (prompted_dialog, prompted_value); XtSetKeyboardFocus (toplevel, prompted_value); yn_done = 0; while (!yn_done) { XtNextEvent (&event); XtDispatchEvent (&event); } XtSetKeyboardFocus (toplevel, (Widget) None); XtUnmapWidget (prompted_shell); if (yn_answer) { XtSetArg(args[0], XtNstring, &value); XtGetValues (prompted_value, args, ONE); return value; } else return NULL; } void getmove(void) { XEvent event; getmove_done = 0; while (!getmove_done) { XtNextEvent (&event); XtDispatchEvent (&event); } MilleMessage (""); Error ("", ""); } void do_save (void) { save (); } void do_quit (void) { rub(0); } # define COMP_STRT 20 # define CARD_STRT 2 void prboard(void) { PLAY *pp; for (int k = 0; k < 2; k++) { pp = &Player[k]; for (int i = 0; i < NUM_SAFE; i++) if (pp->safety[i] == S_PLAYED) { if (k == 0) { HumanSafety (i + S_CONV, i); } else { ComputerSafety (i + S_CONV, i); } } if (k == 0) { HumanBattle (pp->battle); HumanSpeed (pp->speed); } else { ComputerBattle (pp->battle); ComputerSpeed (pp->speed); } for (int i = C_25; i <= C_200; i++) { int end; end = pp->nummiles[i]; if (k == 0) HumanMiles (i, C_200-i, end); else ComputerMiles (i, C_200-i, end); } } prscore(TRUE); pp = &Player[PLAYER]; for (int i = 0; i < HAND_SZ; i++) { HumanHand (pp->hand[i], i); } DisplayDeck (Topcard - Deck); DisplayDiscard (Discard); if (End == 1000) { /* stand(EXT_Y, EXT_X, ext); */ } } /* * Put str at (y,x) in standout mode */ void stand(int y, int x, char *str) { (void) y; (void) x; (void) str; } void InScore (int line, int player, char *text) { DisplayText (score, line + 1, 20 + player * 20, text); #ifdef NOTDEF displayString (SCORE_X + player * SCORE_W, SCORE_Y + SCORE_H * (line + 1), text); #endif } void prscore(bool for_real) { PLAY *pp; const char Score_fmt[] = "%4d "; char buffer[512]; (void) for_real; ComputerDistance (Player[1].mileage); HumanDistance (Player[0].mileage); for (pp = Player; pp < &Player[2]; pp++) { sprintf (buffer, Score_fmt, pp->mileage); InScore (0, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->safescore); InScore (1, pp - Player, buffer); if (pp->safescore == 400) InScore (2, pp - Player, " 300 "); else InScore (2, pp - Player, " 0 "); sprintf (buffer, Score_fmt, pp->coupscore); InScore (3, pp - Player, buffer); #ifdef EXTRAP if (for_real) finalscore(pp); else extrapolate(pp); #else finalscore(pp); #endif sprintf (buffer, Score_fmt, pp->hand_tot); InScore (9, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->total); InScore (10, pp - Player, buffer); sprintf (buffer, Score_fmt, pp->games); InScore (11, pp - Player, buffer); } XkwPadUpdate (score); } void FlushInput (void) { } kgames-2.2/xmille/uiXt.h000066400000000000000000000063661416764561500152520ustar00rootroot00000000000000# include # include "color.h" # include extern Display *dpy; extern int screen; extern Window xwindow; extern XFontStruct *font, *backFont; extern Pixmap fill; extern GC text_gc, xor_gc; extern double scale; # define MAXBITMAPS 4 struct card { const char *svg; const char *label; RsvgHandle *rsvg_handle; }; extern struct card *cards; extern struct card deck; extern struct card blank; struct safety_offset { int x; int y; }; extern struct safety_offset safety_offsets[4]; # define PAD_CARD (5) # define MILE_OFFSET (5) # define PAD_TEXT (20) # define DIST_HEIGHT (15) # define DIST_WIDTH ((WIDTH + PAD_CARD) * 5 - PAD_CARD) # define DIST_MARK (4) # define COMP_HAND_X (PAD_CARD) # define COMP_HAND_Y (-HEIGHT + font->descent) # define COMP_DIST_TX (PAD_CARD + (WIDTH + PAD_CARD) * 2) # define COMP_DIST_TY (PAD_CARD) # define COMP_DIST_MX (COMP_DIST_TX) # define COMP_DIST_MY (COMP_DIST_TY + PAD_TEXT) # define COMP_DIST_X (COMP_DIST_MX) # define COMP_DIST_Y (COMP_DIST_MY + DIST_MARK + 1) # define COMP_PLAY_X PAD_CARD # define COMP_PLAY_Y (COMP_DIST_Y + DIST_HEIGHT + PAD_CARD) # define COMP_SAFE_X (COMP_PLAY_X + ((WIDTH + PAD_CARD) * 7)) # define COMP_SAFE_Y COMP_PLAY_Y # define COMP_CARD_TX PAD_CARD # define COMP_CARD_TY (COMP_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD) # define COMP_CARD_X COMP_CARD_TX # define COMP_CARD_Y (COMP_CARD_TY + PAD_TEXT) # define MESS_X (PAD_CARD) # define MESS_Y (COMP_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD + PAD_TEXT) # define MESS_W (150) # define MESS_H (font->ascent + font->descent) # define PROMPT_X MESS_X # define PROMPT_Y (MESS_Y + PAD_TEXT) # define PROMPT_W (MESS_W) # define PROMPT_H (MESS_H) # define ERROR_X PROMPT_X # define ERROR_Y (PROMPT_Y + PAD_TEXT) # define ERROR_W (MESS_W) # define ERROR_H (MESS_H) # define QUIT_X (MESS_X) # define QUIT_Y (ERROR_Y + PAD_TEXT + PAD_CARD) # define SAVE_X (QUIT_X + 75) # define SAVE_Y (QUIT_Y) # define DISCARD_TX (MESS_X + MESS_W + PAD_CARD) # define DISCARD_TY (MESS_Y - PAD_TEXT) # define DISCARD_X (DISCARD_TX) # define DISCARD_Y (DISCARD_TY + PAD_TEXT) # define DECK_TX (DISCARD_X + WIDTH + PAD_CARD) # define DECK_TY (DISCARD_TY) # define DECK_X (DECK_TX) # define DECK_Y (DISCARD_Y) # define SCORE_W (150) # define SCORE_H (font->ascent + font->descent) # define SCORE_N 13 # define SCORE_X (DECK_X + WIDTH + PAD_CARD + SCORE_W) # define SCORE_Y (DECK_TY) # define HUM_DIST_TX (COMP_DIST_TX) # define HUM_DIST_TY (SCORE_Y + SCORE_N * SCORE_H + PAD_CARD) # define HUM_DIST_MX (HUM_DIST_TX) # define HUM_DIST_MY (HUM_DIST_TY + PAD_TEXT) # define HUM_DIST_X (HUM_DIST_MX) # define HUM_DIST_Y (HUM_DIST_MY + DIST_MARK + 1) # define HUM_PLAY_X PAD_CARD # define HUM_PLAY_Y (HUM_DIST_Y + DIST_HEIGHT + PAD_CARD) # define HUM_SAFE_X (HUM_PLAY_X + ((WIDTH + PAD_CARD) * 7)) # define HUM_SAFE_Y (HUM_PLAY_Y) # define HUM_HAND_X PAD_CARD # define HUM_HAND_Y (HUM_PLAY_Y + HEIGHT + 6 * MILE_OFFSET + PAD_CARD) # define WINDOW_WIDTH (HUM_SAFE_X + (WIDTH + PAD_CARD) * 2) # define WINDOW_HEIGHT (HUM_HAND_Y + HEIGHT + PAD_CARD) void displayCard (Display *d, Window w, int card, int x, int y, XRectangle *clip); void init_mono_cards(void); void init_color_cards (void); void drawIm (Display *d, Window w, struct card *c, int x, int y, XRectangle *clip); kgames-2.2/xmille/varpush.c000066400000000000000000000030301416764561500157650ustar00rootroot00000000000000/* * Copyright (c) 1982, 1993 * The Regents of the University of California. All rights reserved. */ # include "mille.h" /* * @(#)varpush.c 1.1 (Berkeley) 4/1/82 */ /* * push variables around via the routine func() on the file * channel file. func() is either read or write. */ int varpush(int file, ssize_t (*func)(int, void *, size_t)) { int temp; int fail = 0; if ((*func)(file, &Debug, sizeof Debug) != sizeof Debug) fail++; if ((*func)(file, &Finished, sizeof Finished) != sizeof Finished) fail++; if ((*func)(file, &Order, sizeof Order) != sizeof Order) fail++; if ((*func)(file, &End, sizeof End) != sizeof End) fail++; if ((*func)(file, &On_exit, sizeof On_exit) != sizeof On_exit) fail++; if ((*func)(file, &Handstart, sizeof Handstart) != sizeof Handstart) fail++; if ((*func)(file, &Numgos, sizeof Numgos) != sizeof Numgos) fail++; if ((*func)(file, Numseen, sizeof Numseen) != sizeof Numseen) fail++; if ((*func)(file, &Play, sizeof Play) != sizeof Play) fail++; if ((*func)(file, &WIndow, sizeof WIndow) != sizeof WIndow) fail++; if ((*func)(file, Deck, sizeof Deck) != sizeof Deck) fail++; if ((*func)(file, &Discard, sizeof Discard) != sizeof Discard) fail++; if ((*func)(file, Player, sizeof Player) != sizeof Player) fail++; if (func == (ssize_t (*)(int, void *, size_t)) read) { if (read(file, &temp, sizeof temp) != sizeof temp) fail++; Topcard = &Deck[temp]; } else { temp = Topcard - Deck; if (write(file, &temp, sizeof temp) != sizeof temp) fail++; } if (fail) return FALSE; return TRUE; } kgames-2.2/xmille/xmille.6000066400000000000000000000014241416764561500155170ustar00rootroot00000000000000.TH XMILLE 6 "July 1988" "X Version 11" .SH NAME xmille \- X window mille bourne game .SH SYNOPSIS .B xmille .RI [ restore-file ] .SH DESCRIPTION .I Xmille brings up a window for a mille bourne game. When selecting one of your cards, the left button plays the card, the right button discards the card and the middle button chooses whichever is appropriate, first trying to play the card, and then discarding it. .PP .I Xmille also has a keyboard interface. The cards in the hand are numbered from 1 to 7; type a number and if the card is playable it is played, otherwise it is discarded. To force a discard, type 'd' before the card number. Type any other key to draw a card from the pile. There are more commands. .SH AUTHOR Keith Packard .br Dave Lemke .br Dana Chee .SH "SEE ALSO" kgames-2.2/xmille/xmille.desktop.in000066400000000000000000000003711416764561500174300ustar00rootroot00000000000000[Desktop Entry] Name=XMille GenericName=Board Game Comment=Play Mille Bornes against the computer Keywords=game;board Exec=@BINDIR@/xmille Icon=@ICONDIR@/xmille.svg StartupNotify=false Terminal=false Type=Application Categories=Game;CardGame;Kgames kgames-2.2/xreversi/000077500000000000000000000000001416764561500145125ustar00rootroot00000000000000kgames-2.2/xreversi/.gitignore000066400000000000000000000001141416764561500164760ustar00rootroot00000000000000edges.out genedge makeedge xreversi makeedge.c xreversi._man y.tab.h ulex.c kgames-2.2/xreversi/Reversi.ad.in000066400000000000000000000034161416764561500170500ustar00rootroot00000000000000*Command.shapeStyle: oval *Background: #fffff0 *menuBar.Background: #337744 *Cards.Background: #337744 *frame.Background: #337744 *reversi.Background: #337744 *borderWidth: 0 *SimpleMenu.borderWidth: 1 *Command.borderWidth: 1 *Toggle.borderWidth: 1 *reversi.width: 600 *reversi.height: 600 *reversi.borderWidth: 0 *error.justify: left *error.borderWidth: 0 *error.Label: XReversi Version @KGAMES_VERSION@ *quit.Label: Quit *hint.Label: Hint *undo.Label: Undo *restart.Label: Restart *playerLabel.Label: Computer Plays: *playerLabel.borderWidth: 0 *playWhite.Label: White *playBlack.Label: Black *playBoth.Label: Both *playNeither.Label: Neither *levelLabel.Label: level: *levelLabel.borderWidth: 0 *levelValue.borderWidth: 0 *turn.borderWidth: 0 *layout.layout: horizontal { \ reversi < +inff -100% * +inff -100% > \ vertical { \ 10 < +10 -100% > \ horizontal { \ 5 < +inf -100% > \ quit \ 5 < +inf -100% > \ hint \ 5 < +inf -100% > \ undo \ 5 < +inf -100% > \ restart \ 5 < +inf -100% > \ } \ 10 < +10 -100% > \ horizontal { \ 5 < -100% > \ vertical { \ horizontal { \ playerLabel \ 0 < +inf > \ } \ 10 < +10 - 100% > \ horizontal { \ playWhite \ 5 < +inf -100% > \ playBlack \ 5 < +inf -100% > \ playBoth \ 5 < +inf -100% > \ playNeither \ } \ } \ 5 < +inf -100% > \ } \ 10 < +10 -100% > \ horizontal { \ 5 < -100% > \ vertical { \ 0 < +inf > \ levelLabel \ 0 < +inf > \ } \ 10 < -100% > \ levelValue \ 5 < +inf -100% > \ } \ 10 < +10 -100% > \ horizontal { \ 5 < -100% > \ turn \ 5 < +inf -100% > \ } \ error < +inff -100% * +0 -0 > \ 10 < +1000 -100% > \ } \ } kgames-2.2/xreversi/Reversi.c000066400000000000000000000223221416764561500162760ustar00rootroot00000000000000/*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ /* * Reversi.c - Reversi widget * */ #include #include #include #include #include #include #include #include "ReversiP.h" /**************************************************************** * * Full class record constant * ****************************************************************/ /* Private Data */ #define STONE_WIDTH 0.75 #define offset(field) XtOffsetOf(ReversiRec, field) static XtResource resources[] = { {XtNstoneCallback, XtCStoneCallback, XtRCallback, sizeof (XtPointer), offset(reversi.callbacks), XtRCallback, (XtPointer) NULL}, {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel), offset(core.background_pixel), XtRString, "green"}, {XtNbackgroundColor, XtCBackground, XtRRenderColor, sizeof(XRenderColor), offset(ksimple.background), XtRString, "green"}, {XtNwhite, XtCForeground, XtRRenderColor, sizeof(XRenderColor), offset(reversi.white), XtRString, "white"}, {XtNblack, XtCForeground, XtRRenderColor, sizeof(XRenderColor), offset(reversi.black), XtRString, "black"}, {XtNgrid, XtCForeground, XtRRenderColor, sizeof (XRenderColor), offset(reversi.grid), XtRString, "black"}, }; #define superclass (&ksimpleClassRec) /**************************************************************** * * Private Procedures * ****************************************************************/ static void ClassInitialize(void) { XkwInitializeWidgetSet(); } /* ARGSUSED */ static void Initialize(Widget request, Widget new, Arg *args, Cardinal *count) { ReversiWidget rw = (ReversiWidget) new; int x, y; (void) request; (void) args; (void) count; if (rw->core.width == 0) rw->core.width = 100; if (rw->core.height == 0) rw->core.height = 100; for (y = 0; y < BOARD_HEIGHT; y++) for (x = 0; x < BOARD_HEIGHT; x++) { rw->reversi.board[x][y] = StoneNone; rw->reversi.animate[x][y].state = AnimateNone; } } /* Initialize */ /* * Repaint the widget window */ static void PaintEntry (ReversiWidget rw, cairo_t *cr, int x, int y) { ReversiStone value; switch (rw->reversi.animate[x][y].state) { case AnimateNone: value = rw->reversi.board[x][y]; break; case AnimateA: value = rw->reversi.animate[x][y].A; break; case AnimateB: value = rw->reversi.animate[x][y].B; break; default: return; } switch (value) { case StoneBlack: XkwSetSource(cr, &rw->reversi.black); cairo_arc(cr, x + 0.5, y + 0.5, STONE_WIDTH / 2, 0, M_PI * 2); break; case StoneWhite: XkwSetSource(cr, &rw->reversi.white); cairo_arc(cr, x + 0.5, y + 0.5, STONE_WIDTH / 2, 0, M_PI * 2); break; default: XkwSetSource(cr, &rw->ksimple.background); cairo_rectangle(cr, x + 0.1, y + 0.1, 0.8, 0.8); break; } cairo_fill(cr); } static void PaintGrid (ReversiWidget rw, cairo_t *cr) { int i; XkwSetSource(cr, &rw->reversi.grid); for (i = 1; i < BOARD_HEIGHT; i++) { cairo_move_to(cr, i, 0); cairo_line_to(cr, i, BOARD_WIDTH); } for (i = 1; i < BOARD_WIDTH; i++) { cairo_move_to(cr, 0, i); cairo_line_to(cr, BOARD_HEIGHT, i); } cairo_stroke(cr); } static cairo_t * draw_begin(ReversiWidget w, Region region) { cairo_t *cr = XkwDrawBegin((Widget) w, region); cairo_scale(cr, w->core.width / 8, w->core.height / 8); cairo_set_line_width(cr, 0.025); return cr; } /* ARGSUSED */ static void Redisplay(Widget w, XEvent *event, Region region) { ReversiWidget rw = (ReversiWidget) w; int x, y; if (!XtIsRealized(w)) return; (void) event; (void) region; cairo_t *cr = draw_begin(rw, region); PaintGrid (rw, cr); for (y = 0; y < BOARD_HEIGHT; y++) for (x = 0; x < BOARD_WIDTH; x++) PaintEntry (rw, cr, x, y); XkwDrawEnd(w, region, cr); } /* * Set specified arguments into widget */ /* ARGSUSED */ static Boolean SetValues(Widget current, Widget request, Widget new, Arg *args, Cardinal *count) { (void) current; (void) request; (void) new; (void) args; (void) count; return False; } void XkwReversiSetSpot ( Widget w, int x, int y, ReversiStone value ) { ReversiWidget rw = (ReversiWidget) w; if (rw->reversi.animate[x][y].state != AnimateNone) { XtRemoveTimeOut (rw->reversi.animate[x][y].timeout); rw->reversi.animate[x][y].state = AnimateNone; } rw->reversi.board[x][y] = value; } void XkwReversiUpdate(Widget w) { Redisplay(w, NULL, NULL); } static void DoAnimate (XtPointer closure, XtIntervalId *interval) { Animate *a = (Animate *) closure; (void) interval; if (a->togo == 0) { a->state = AnimateNone; a->timeout = 0; } else { --a->togo; if (a->state == AnimateA) a->state = AnimateB; else a->state = AnimateA; a->timeout = XtAddTimeOut (a->delay, DoAnimate, (XtPointer) a); } Redisplay((Widget) a->rw, NULL, NULL); } void XkwReversiAnimateSpot (Widget w, int x, int y, ReversiStone A, ReversiStone B, unsigned long delay, int repeat) { ReversiWidget rw = (ReversiWidget) w; Animate *a; a = &rw->reversi.animate[x][y]; if (a->state != AnimateNone) { XtRemoveTimeOut (a->timeout); } a->state = AnimateNone; if (repeat == 0) { Redisplay(w, NULL, NULL); return; } a->delay = delay; a->togo = repeat - 1; a->x = x; a->y = y; a->rw = rw; a->A = A; a->B = B; a->state = AnimateA; if (!(a->timeout = XtAddTimeOut (delay, DoAnimate, (XtPointer) a))) a->state = AnimateNone; Redisplay(w, NULL, NULL); } static void Select (Widget w, XEvent *event, String *params, Cardinal *num_params) { ReversiWidget rw = (ReversiWidget) w; int x, y; double dx, dy; int rx, ry; ReversiMove move; (void) params; (void) num_params; switch (event->type) { case ButtonPress: case ButtonRelease: x = event->xbutton.x; y = event->xbutton.y; break; case MotionNotify: x = event->xmotion.x; y = event->xmotion.y; break; default: return; } dx = (double) x * 8 / rw->core.width; dy = (double) y * 8 / rw->core.height; move.x = rx = dx; move.y = ry = dy; if (0 <= rx && rx < BOARD_WIDTH && 0 <= ry && ry < BOARD_HEIGHT) XtCallCallbackList ((Widget) rw, rw->reversi.callbacks, (XtPointer) &move); } static XtActionsRec actions[] = { {"select", Select}, }; static char defaultTranslations[] = ": select()"; ReversiClassRec reversiClassRec = { { /* core_class fields */ /* superclass */ (WidgetClass) superclass, /* class_name */ "Reversi", /* widget_size */ sizeof(ReversiRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ XtInheritRealize, /* actions */ actions, /* num_actions */ XtNumber (actions), /* resources */ resources, /* num_resources */ XtNumber(resources), /* xrm_class */ NULLQUARK, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ NULL, /* resize */ XtInheritResize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ defaultTranslations, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL }, { /* simple class */ /* change_sensitive */ XtInheritChangeSensitive, /* extension */ NULL, /* ksimple */ }, { 0, }, { /* reversi class */ /* foo */ 0, } }; WidgetClass reversiWidgetClass = (WidgetClass)&reversiClassRec; kgames-2.2/xreversi/Reversi.h000066400000000000000000000057521416764561500163130ustar00rootroot00000000000000/* * $XConsortium: Reversi.h,v 1.24 89/07/21 01:48:51 kit Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XkwReversi_h #define _XkwReversi_h /*********************************************************************** * * Reversi Widget * ***********************************************************************/ #include /* Resources: Name Class RepType Default Value ---- ----- ------- ------------- background Background Pixel XtDefaultBackground bitmap Pixmap Pixmap None border BorderColor Pixel XtDefaultForeground borderWidth BorderWidth Dimension 1 cursor Cursor Cursor None destroyCallback Callback XtCallbackList NULL font Font XFontStruct* XtDefaultFont foreground Foreground Pixel XtDefaultForeground height Height Dimension text height insensitiveBorder Insensitive Pixmap Gray mappedWhenManaged MappedWhenManaged Boolean True sensitive Sensitive Boolean True width Width Dimension text width x Position Position 0 y Position Position 0 */ #define XtNwhite "white" #define XtNblack "black" #define XtNgrid "grid" typedef enum _ReversiStone { StoneWhite, StoneBlack, StoneNone } ReversiStone; extern WidgetClass reversiWidgetClass; typedef struct _ReversiMove { int x, y; } ReversiMove, *ReversiMovePtr; typedef struct _ReversiClassRec *ReversiWidgetClass; typedef struct _ReversiRec *ReversiWidget; #define XtNstoneCallback "stoneCallback" #define XtCStoneCallback "StoneCallback" void XkwReversiSetSpot (Widget, int, int, ReversiStone); void XkwReversiUpdate(Widget); void XkwReversiAnimateSpot (Widget w, int x, int y, ReversiStone A, ReversiStone B, unsigned long delay, int repeat); #endif /* _XkwReversi_h */ kgames-2.2/xreversi/ReversiP.h000066400000000000000000000057421416764561500164320ustar00rootroot00000000000000/* * $XConsortium: ReversiP.h,v 1.24 89/06/08 18:05:01 swick Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ /* * ReversiP.h - Private definitions for Reversi widget * */ #ifndef _ReversiP_h #define _ReversiP_h /*********************************************************************** * * Reversi Widget Private Data * ***********************************************************************/ #include "Reversi.h" #include "transform.h" #include /* New fields for the Reversi widget class record */ typedef struct {int foo;} ReversiClassPart; /* Full class record declaration */ typedef struct _ReversiClassRec { CoreClassPart core_class; SimpleClassPart simple_class; KSimpleClassPart ksimple_class; ReversiClassPart reversi_class; } ReversiClassRec; extern ReversiClassRec reversiClassRec; typedef enum _AnimateState { AnimateNone, AnimateA, AnimateB } AnimateState; typedef struct _Animate { AnimateState state; ReversiStone A, B; ReversiWidget rw; int x, y; unsigned long delay; int togo; XtIntervalId timeout; } Animate; #define BOARD_WIDTH 8 #define BOARD_HEIGHT 8 /* New fields for the Reversi widget record */ typedef struct { /* resources */ XRenderColor white; XRenderColor black; XRenderColor grid; XtCallbackList callbacks; /* private state */ ReversiStone board[BOARD_WIDTH][BOARD_HEIGHT]; Animate animate[BOARD_WIDTH][BOARD_HEIGHT]; } ReversiPart; /**************************************************************** * * Full instance record declaration * ****************************************************************/ typedef struct _ReversiRec { CorePart core; SimplePart simple; KSimplePart ksimple; ReversiPart reversi; } ReversiRec; #endif /* _XawReversiP_h */ kgames-2.2/xreversi/corners.c000066400000000000000000000110461416764561500163330ustar00rootroot00000000000000/* * cornerscores.c */ # include "revers.h" scoreT cornerscores[4][4][4][4] = { { { { -20, /* O O O O */ 0, /* O O O - */ 10, /* O O O * */ 0, /* ignore */ }, { -20, /* O O - O */ 0, /* O O - - */ -10, /* O O - * */ 0, /* ignore */ }, { -20, /* O O * O */ 0, /* O O * - */ 20, /* O O * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { -20, /* O - O O */ 0, /* O - O - */ -10, /* O - O * */ 0, /* ignore */ }, { -20, /* O - - O */ 0, /* O - - - */ -10, /* O - - * */ 0, /* ignore */ }, { -20, /* O - * O */ 0, /* O - * - */ 20, /* O - * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { -20, /* O * O O */ 0, /* O * O - */ 20, /* O * O * */ 0, /* ignore */ }, { -20, /* O * - O */ 0, /* O * - - */ 10, /* O * - * */ 0, /* ignore */ }, { -20, /* O * * O */ 0, /* O * * - */ 10, /* O * * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, }, { { { 40, /* - O O O */ 0, /* - O O - */ -40, /* - O O * */ 0, /* ignore */ }, { 40, /* - O - O */ 0, /* - O - - */ -40, /* - O - * */ 0, /* ignore */ }, { 40, /* - O * O */ 0, /* - O * - */ -40, /* - O * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { 40, /* - - O O */ 0, /* - - O - */ -40, /* - - O * */ 0, /* ignore */ }, { 40, /* - - - O */ 0, /* - - - - */ -40, /* - - - * */ 0, /* ignore */ }, { 40, /* - - * O */ 0, /* - - * - */ -40, /* - - * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { 40, /* - * O O */ 0, /* - * O - */ -40, /* - * O * */ 0, /* ignore */ }, { 40, /* - * - O */ 0, /* - * - - */ -40, /* - * - * */ 0, /* ignore */ }, { 40, /* - * * O */ 0, /* - * * - */ -40, /* - * * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, }, { { { -20, /* * O O O */ 0, /* * O O - */ 20, /* * O O * */ 0, /* ignore */ }, { -10, /* * O - O */ 0, /* * O - - */ 20, /* * O - * */ 0, /* ignore */ }, { -10, /* * O * O */ 0, /* * O * - */ 20, /* * O * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { -10, /* * - O O */ 0, /* * - O - */ 20, /* * - O * */ 0, /* ignore */ }, { -10, /* * - - O */ 0, /* * - - - */ 20, /* * - - * */ 0, /* ignore */ }, { -10, /* * - * O */ 0, /* * - * - */ 20, /* * - * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { -10, /* * * O O */ 0, /* * * O - */ 20, /* * * O * */ 0, /* ignore */ }, { -10, /* * * - O */ 0, /* * * - - */ 20, /* * * - * */ 0, /* ignore */ }, { -10, /* * * * O */ 0, /* * * * - */ 20, /* * * * * */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, }, { { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, { 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ 0, /* ignore */ }, } } }; kgames-2.2/xreversi/count.c000066400000000000000000000003771416764561500160150ustar00rootroot00000000000000/* * count.c * * count up the board */ # include "revers.h" int count (int player, boardT board) { register int x, y, count; count = 0; for (x = 1; x <= SIZE; x++) for (y = 1; y <= SIZE; y++) count += board[x][y]; return count * player; } kgames-2.2/xreversi/display.c000066400000000000000000000130331416764561500163230ustar00rootroot00000000000000/* * display.c */ # include "revers.h" # include # include # define toscrx(x) ((x) * 5 - 1) # define toscry(y) ((y) * 3 - 2) # define LINEX (toscrx(10)-2) # define LINEY (toscry(5)+1) static helpShown; #include extern int stty (), gtty (); extern int wmove (), printw (), wrefresh (), waddch (); extern int werase (), endwin (), wgetch (), wdelch (), wclrtoeol (); extern int write (); void dispInit () { register int i; initscr (); savetty(); noecho (); crmode (); helpShown = 0; for (i = 1; i <= SIZE; i++) { move (toscry(i), 0); printw ("%c", i-1+'a'); move (toscry(i), toscrx(SIZE + 1)); printw ("%c", i-1+'a'); move (0, toscrx(i)); printw ("%1d", i); } if (baudrate() > B1200) dispGrid(); else refresh (); } void dispGrid () { register int i, j; for (i = 1; i <= SIZE; i++) { for (j = 1; j <= SIZE + 1; j++) { if (i <= SIZE) { move (toscry(i)+1, toscrx(j)-2); addch ('|'); move (toscry(i), toscrx(j)-2); addch ('|'); move (toscry(i)-1, toscrx(j)-2); } if (j <= SIZE) { if (i == 1) printw ("+-%1d--", j); else addstr ("+----"); } else addstr ("+"); } } refresh (); } void dispNoGrid (void) { register int i, j; for (i = 1; i <= SIZE; i++) { for (j = 1; j <= SIZE + 1; j++) { move (toscry(i)+1, toscrx(j)-2); addch (' '); move (toscry(i), toscrx(j)-2); addch (' '); move (toscry(i)-1, toscrx(j)-2); if (j <= SIZE) { if (i == 1) printw (" %1d ", j); else addstr (" "); } else addstr (" "); } } refresh (); } void dispEnd () { clearok(stdscr, 1); erase (); refresh (); resetty(); endwin (); exit (0); } boardT old; void dispOne (); void display (board) boardT board; { register int i,j; extern int showScore; for (i = 1; i <= SIZE; i++) for (j = 1; j <= SIZE; j++) if (board[i][j] != old[i][j]) { dispOne (i, j, board[i][j]); old[i][j] = board[i][j]; } refresh (); if (showScore) dispScore (board); } void dispOne (x, y, who) int x, y; int who; { move (toscry (y), toscrx (x)); switch (who) { case BLACK: addstr ("/\\"); break; case WHITE: addstr ("**"); break; case EMPTY: addstr (" "); break; } move (toscry(y) + 1, toscrx (x)); switch (who) { case BLACK: addstr ("\\/"); break; case WHITE: addstr ("**"); break; case EMPTY: addstr (" "); break; } } void dispScore (boardT board) { register int i,j; register int ws, bs; ws = bs = 0; for (i = 1; i <= SIZE; i++) for (j = 1; j <= SIZE; j++) switch (board[i][j]) { case WHITE: ws++; break; case BLACK: bs++; break; } move (LINEY - 3, LINEX); printw ("white: %-2d black: %-2d", ws, bs); refresh (); } void dispNoScore () { move (LINEY - 3, LINEX); clrtoeol (); refresh (); } static char *helpText[] = { "y, x [no] grid", "[no] help hint", "play quit", "restart record", "replay save", "[no] score undo", "level", "white|black first", "white|black second", 0, }; void dispTurn (player) int player; { static displayed = EMPTY; if (displayed == player) return; move (LINEY-1, LINEX); switch (player) { case WHITE: addstr ("white's turn"); break; case BLACK: addstr ("black's turn"); break; case EMPTY: clrtoeol (); } displayed = player; refresh (); } void dispHelp (void) { register int i; register char **h; if (helpShown) return; i = 0; for (h = helpText; *h; ++h) { move (i, LINEX); addstr (*h); ++i; } move (LINEY+4, LINEX); printw ("white pieces are **"); move (LINEY+5, LINEX+18); printw ("**"); move (LINEY+7, LINEX); printw ("black pieces are /\\"); move (LINEY+8, LINEX+18); printw ("\\/"); refresh (); ++helpShown; } void dispNoHelp (void) { register int i; register char **h; if (!helpShown) return; i = 0; for (h = helpText; *h; ++h) { move (i, LINEX); clrtoeol (); ++i; } move (LINEY+4, LINEX); clrtoeol (); move (LINEY+5, LINEX+18); clrtoeol (); move (LINEY+7, LINEX); clrtoeol (); move (LINEY+8, LINEX+18); clrtoeol (); refresh (); helpShown = 0; } static char lexbuf[256]; static char *lexpnt; void readLine (void) { int ch, x, y; move (LINEY, LINEX); addstr ("-> "); loop: x = LINEX+3; y = LINEY; move (y, x); clrtoeol (); refresh (); lexpnt = lexbuf; for (;;) { ch = getch (); if (ch == -1) ch = '\004'; *lexpnt++ = ch; if (isprint (ch)) { addch (ch); ++x; refresh (); } else switch (ch) { case '\f': clearok (stdscr, 1); case '\030': case '\025': goto loop; case '\004': *lexpnt++ = -1; case '\r': case '\n': move (LINEY+1, LINEX); refresh (); *lexpnt++ = '\0'; goto done; case '\b': if (lexpnt >= lexbuf + 2) { lexpnt -= 2; --x; move (y,x); delch (); refresh (); } else --lexpnt; break; default: --lexpnt; write (1, "\007", 1); break; } } done: lexpnt = lexbuf; dispError (""); } int lexgetc () { int c; extern int yylineno; c = *lexpnt++; if (c == -1) c = 4; c &= 0177; if (c == '\r') c = '\n'; if (c == '\n') ++yylineno; return c; } void lexungetc (c) int c; { --lexpnt; } void dispError (s) char *s; { move (LINEY+1, LINEX); clrtoeol (); addstr (s); refresh (); } void dispMove (x, y, player) int x, y; int player; { char ebuf[80]; sprintf (ebuf, "I move to %c %d\n", y-1+'a', x); dispError (ebuf); } void dispHint (x, y, player) int x, y; int player; { char buf[80]; sprintf (buf, "I suggest %c %d", y-1+'a', x); dispError (buf); } kgames-2.2/xreversi/fini.c000066400000000000000000000011501416764561500156000ustar00rootroot00000000000000/* * fini.c * * count up score and display winner */ # include "revers.h" # include void fini (boardT board) { register int x,y; register int wscore, bscore; char sbuf[80]; wscore = bscore = 0; for (x = 1; x <= SIZE; x++) for (y = 1; y <= SIZE; y++) if (board[x][y] == WHITE) ++wscore; else if (board[x][y] == BLACK) ++bscore; if (wscore > bscore) sprintf (sbuf, "white wins %d to %d.", wscore, bscore); else if (bscore > wscore) sprintf (sbuf, "black wins %d to %d.", bscore, wscore); else sprintf (sbuf, "tie game %d to %d.", wscore, bscore); dispError (sbuf); } kgames-2.2/xreversi/game.c000066400000000000000000000120601416764561500155660ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include #include #include #include "revers.h" boardT board, saveBoard; int saved; int savePlayer; int atend; int atbegin; int level; int player; extern int maxlev, movex, movey; int x, y; int com; int gotsignal; char sbuf[80]; char ebuf[80]; int sdebug = 0, mdebug = 0; int record = 0; FILE *rfile; int first = WHITE; int defcom = BLACK; int showScore = 1; struct move saveGame[64]; struct move *saveP; static void caught (int sig) { (void) sig; gotsignal++; signal (SIGINT, caught); } int main (int argc, char **argv) { signal (SIGINT, caught); level = 2; dispInit (argc, argv); srandom (time(NULL)); while (*++argv && **argv == '-') { while (*++*argv) { switch (**argv) { case 'b': defcom = BLACK; break; case 'w': defcom = WHITE; break; case '1': if (!*++*argv) continue; if (**argv == WHITE) first = WHITE; else first = BLACK; break; case 'g': dispGrid (); break; case 's': showScore = 1; } } } do { if (rfile) fclose (rfile); rfile = 0; player = first; com = defcom; atend = 0; atbegin = 1; setup (); saved = 0; saveP = saveGame; display (board); if (*argv) { replay (*argv); ++argv; } } while (playGame()); dispEnd (); return 0; } void setup (void) { register int i,j; for (i = 1; i <= SIZE; i++) for (j = 1; j <= SIZE; j++) board[i][j] = 0; board[4][4] = WHITE; board[4][5] = BLACK; board[5][4] = BLACK; board[5][5] = WHITE; } void replay (char *file) { int x, y, p; if (rfile) fclose (rfile); if ((rfile = fopen (file, "r")) == NULL) { sprintf (ebuf, "could not open %s", file); dispError (ebuf); return; } while (fscanf (rfile, "%d: %d, %d\n", &p, &x, &y) == 3) { if (x == -1 && y == -1) { player = p; continue; } if (!hasmove (player, board)) { player = -player; if (!hasmove (player, board)) return; } if (p != player) { sprintf (ebuf, "not %s's turn\n", player == WHITE? "white":"black"); dispError (ebuf); return; } if (!legal (p, x, y, board)) { sprintf(ebuf, "illegal move: %d, %d\n", x, y); dispError (ebuf); return; } move (p, x, y, board); atbegin = 0; player = -player; display (board); } fclose (rfile); rfile = 0; } void domove (int x, int y) { if (1 <= x && x <= SIZE && 1 <= y && y <= SIZE && legal (player, x, y, board)) { copy (saveBoard, board); savePlayer = player; ++saved; move (player, x, y, board); atbegin = 0; if (record) fprintf (rfile, "%d: %d,%d\n", player, x, y); saveP->x = x; saveP->y = y; saveP->p = player; ++saveP; player = -player; display (board); } else { sprintf (ebuf, "illegal move: %c %d", y+'a'-1, x); dispError (ebuf); } } void checkInput (void) { if (!atend) { loop: ; dispTurn (player); if (!hasmove (player, board)) { if (!hasmove (-player, board)) { fini (board); if (com == 0) com = BLACK; ++atend; dispTurn (EMPTY); return; } else { if (player == WHITE) dispError ("white has no move"); else dispError ("black has no move"); player = -player; } } if (com == 0 || com == player) { dispError ("thinking..."); if (computer (player, board, level)) { atbegin = 0; display (board); dispMove (movex, movey, player); saveP->x = movex; saveP->y = movey; saveP->p = player; ++saveP; if (record) fprintf (rfile, "%d: %d,%d\n", player, movex, movey); player = -player; if (gotsignal && com != 0) gotsignal = 0; } if (gotsignal && com == 0) { com = -player; gotsignal = 0; } goto loop; } } } void undo (void) { if (saved) { copy (board, saveBoard); player = savePlayer; saved = 0; display (board); } } void doHint (void) { if (hasmove (player, board)) { hint (player, board, level); dispHint (movex, movey, player); } } kgames-2.2/xreversi/genedge.c000066400000000000000000000016631416764561500162620ustar00rootroot00000000000000/* * generate preliminary edge score array */ #include char board[9]; int main (int argc, char ** argv) { if (argc > 1) stdout = freopen(argv[1], "w", stdout); register int i; for (board[1] = -1; board[1] <= 2; board[1]++) for (board[2] = -1; board[2] <= 2; board[2]++) for (board[3] = -1; board[3] <= 2; board[3]++) for (board[4] = -1; board[4] <= 2; board[4]++) for (board[5] = -1; board[5] <= 2; board[5]++) for (board[6] = -1; board[6] <= 2; board[6]++) for (board[7] = -1; board[7] <= 2; board[7]++) for (board[8] = -1; board[8] <= 2; board[8]++) { for (i = 1; i <= 8; i++) { if (board[i] == 2) break; } if (i == 9) { for (i = 1; i <= 8; i++) { switch (board[i]) { case 0: printf (" -"); break; case -1: printf (" O"); break; case 1: printf (" *"); break; } } printf ("\n"); } else { printf ("?\n"); } } return 0; } kgames-2.2/xreversi/hasmove.c000066400000000000000000000004171416764561500163220ustar00rootroot00000000000000/* * hasmove.c * * figure out if player has move in board */ # include "revers.h" int hasmove (int player, boardT board) { register int x,y; for (x = 1; x <= SIZE; x++) for (y = 1; y <= SIZE; y++) if (legal (player, x, y, board)) return 1; return 0; } kgames-2.2/xreversi/make-xreversi-svg000077500000000000000000000007661416764561500200300ustar00rootroot00000000000000#!/bin/bash dir=`dirname $0` case $# in 2) ;; *) echo "usage: $0 cards.c cards.h" exit 1 ;; esac ( echo '#include "'"$2"'"' for f in xreversi.svg; do file="$dir"/"$f" name=`basename $f .svg` echo "const char svg_$name[]" = sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' -e 's/^/ "/' -e 's/$/\\n"/' "$file" echo " ;"; echo "" done echo "" ) > "$1" ( for f in xreversi.svg; do name=`basename $f .svg` echo "extern const char svg_$name[];" done ) > "$2" kgames-2.2/xreversi/makeedge.y000066400000000000000000000233711416764561500164540ustar00rootroot00000000000000%{ int score; extern int position; char line[80]; #include #include static int yylex (void); static int yyerror (char *s); static int yywrap (void); static void output (int score, char *comment); static void flush_output (void); %} %union { struct { int width; int position; int base; } field; int ival; } %type line whites blacks empties oempties %type type1 type2 otype3e type3e type3 otype4 type4 type4.w type4.b %token WHITE BLACK EMPTY IGNORE %token NL %% lines : lines line { output ($2.base, line); } | lines ignore { output (0, "ignore"); } | ; ignore : IGNORE NL ; line : whites type1 NL { $$.base = 20 * $1.width + $2.base; } | blacks type2 NL { $$.base = -20 * $1.width + $2.base; } | EMPTY type3 NL { $$.base = $2.base; } | EMPTY empties otype4 NL { $$.base = $3.base; } ; type1 : blacks whites empties otype4 { $$.base = $4.base; switch ($2.position) { case 7: $$.base -= ($2.width + $1.width+1) * 15; break; default: if ($3.width == 1) $$.base -= ($1.width + $2.width+1) * 15; else $$.base += ($2.width - $1.width) * 20; break; } $$.position = $4.position; $$.width = $1.width + $2.width + $3.width; } | blacks whites type1 { $$.base = $3.base; $$.base -= ($1.width - $2.width) * 20; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | blacks empties otype4 { $$.base = ($1.width + 1) * 15 + $3.base; $$.width = $1.width + $2.width + $3.width; $$.position = $3.position; } | blacks { $$ = $1; $$.base = - $1.width * 20; } | empties otype4 { $$.position = $2.position; $$.width = $1.width+$2.width; $$.base = $2.base; } | { $$.position = position; $$.width = 0; $$.base = 0; } ; type2 : whites blacks empties otype4 { $$.base = $4.base; switch ($2.position) { case 7: $$.base += ($2.width + $1.width+1) * 15; break; default: if ($3.width == 1) $$.base += ($1.width + $2.width+1) * 15; else $$.base -= ($2.width - $1.width) * 20; break; } $$.position = $4.position; $$.width = $1.width + $2.width + $3.width + $4.width; } | whites blacks type2 { $$.base = $3.base; $$.base += ($1.width - $2.width) * 20; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | whites empties otype4 { $$.base = - ($1.width + 1) * 15 + $3.base; $$.width = $1.width + $2.width + $3.width; $$.position = $3.position; } | whites { $$ = $1; $$.base = $1.width * 20; } | empties otype4 { $$.position = $2.position; $$.width = $1.width+$2.width; $$.base = $2.base; } | { $$.position = 0; $$.width = 0; $$.base = 0; } ; otype4 : type4 { $$ = $1; } | { $$.position = position; $$.width = 0; $$.base = 0; } ; whites : whites WHITE { $$.position = $2.position; $$.width = $1.width + $2.width; $$.base = $1.base + $2.base; } | WHITE { $$ = $1; } ; blacks : blacks BLACK { $$.position = $2.position; $$.width = $1.width + $2.width; $$.base = $1.base + $2.base; } | BLACK { $$ = $1; } ; empties : empties EMPTY { $$.position = $2.position; $$.width = $1.width + $2.width; $$.base = $1.base + $2.base; } | EMPTY { $$ = $1; } ; otype3e : type3e { $$ = $1; } | { $$.position = position; $$.width = 0; $$.base = 0; } ; type3 : whites EMPTY whites oempties otype3e { $$.base = -($1.width + $3.width + 2) * 15 + $5.base; $$.width = $1.width + $2.width + $3.width + $4.width + $5.width; $$.position = $5.position; } | blacks EMPTY blacks oempties otype3e { $$.base = ($1.width + $3.width + 2) * 15 + $5.base; $$.width = $1.width + $2.width + $3.width + $4.width + $5.width; $$.position = $5.position; } | type3e ; type3e : whites blacks type2 { $$.base = -15 * ($1.width + $2.width + 1); $$.width = $1.width + $2.width + $3.width; $$.position = $3.position; } | blacks whites type1 { $$.base = 15 * ($1.width + $2.width + 1); $$.width = $1.width + $2.width + $3.width; $$.position = $3.position; } | whites empties otype3e { if ($1.position - $1.width == 1) { switch ($1.width) { case 1: $$.base = -30; break; case 6: $$.base = -20; break; case 2: $$.base = -15; break; case 3: $$.base = -10; break; case 4: $$.base = -5; break; case 5: $$.base = 10; break; default: yyerror ("weirdo"); break; } } else { $$.base = $1.base; } $$.base += $3.base; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | blacks empties otype3e { if ($1.position - $1.width == 1) { switch ($1.width) { case 1: $$.base = 30; break; case 6: $$.base = 20; break; case 2: $$.base = 15; break; case 3: $$.base = 10; break; case 4: $$.base = 5; break; case 5: $$.base = -10; break; default: yyerror ("weirdo"); break; } } else { $$.base = $1.base; } $$.base += $3.base; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | whites { $$.base = 20 * $1.width; $$.position = $1.position; $$.width = $1.width; } | blacks { $$.base = -20 * $1.width; $$.position = $1.position; $$.width = $1.width; } ; type4 : whites EMPTY whites oempties otype4 { if ($4.position == 8) { $$.base = -($1.width + $3.width + 2) * 15; } else { $$.base = 0; if ($1.position - $1.width + 1 == 3) $$.base = $1.width * 15; else $$.base = $1.base; if ($3.position == 6) $$.base += $3.width * 15; else $$.base += $3.base; $$.base += $5.base; } $$.width = $1.width + $2.width + $3.width + $4.width + $5.width; $$.position = $5.position; } | whites empties otype4 { if ($1.position - $1.width + 1 == 3) $$.base = $1.width * 15 + $3.base; else if ($1.position == 6) $$.base = $1.width * 15 + $3.base; else $$.base = $1.base + $3.base; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | blacks EMPTY blacks oempties otype4 { if ($4.position == 8) { $$.base = ($1.width + $3.width + 2) * 15; } else { $$.base = 0; if ($1.position - $1.width + 1 == 3) $$.base = -$1.width * 15; else $$.base = $1.base; if ($3.position == 6) $$.base += -$3.width * 15; else $$.base += $3.base; $$.base += $5.base; } $$.width = $1.width + $2.width + $3.width + $4.width + $5.width; $$.position = $5.position; } | blacks empties otype4 { if ($1.position - $1.width + 1 == 3) $$.base = -$1.width * 15 + $3.base; else if ($1.position == 6) $$.base = -$1.width * 15 + $3.base; else $$.base = $1.base + $3.base; $$.position = $3.position; $$.width = $1.width + $2.width + $3.width; } | whites { $$.base = 20 * $1.width; $$.position = $1.position; $$.width = $1.width; } | blacks { $$.base = -20 * $1.width; $$.position = $1.position; $$.width = $1.width; } | type4.w { $$ = $1; } | type4.b { $$ = $1; } ; type4.w : whites blacks oempties otype4 { if ($2.position == 8) $$.base = - ($1.width + $2.width + 1) * 15; else if ($3.position == 8 && $3.width == 1) $$.base = ($1.width + $2.width + 1) * 10; else $$.base = $1.base + $2.base + $4.base; $$.position = $4.position; $$.width = $1.width + $2.width + $3.width + $4.width; } ; type4.b : blacks whites oempties otype4 { if ($2.position == 8) $$.base = ($1.width + $2.width + 1) * 15; else if ($3.position == 8 && $3.width == 1) $$.base = - ($1.width + $2.width + 1) * 10; else $$.base = $1.base + $2.base + $4.base; $$.position = $4.position; $$.width = $1.width + $2.width + $3.width + $4.width; } ; oempties: empties { $$ = $1; } | { $$.position = position; $$.width = 0; $$.base = 0; } ; %% # include int verbose; int main (int argc, char **argv) { int ret; if (argc > 1) stdin = freopen(argv[1], "r", stdin); printf("#include \"revers.h\"\n"); printf("#pragma GCC diagnostic ignored \"-Wmissing-braces\"\n"); printf("scoreT edgescores [4][4][4][4][4][4][4][4] = {\n"); ret = yyparse (); flush_output (); printf("};\n"); return ret; } char *lp = line; static int yyerror (char *s) { fprintf (stderr, "%s in %s\n", s, line); return 0; } static int yywrap (void) { return 1; } int position = 1; int base[] = { 0, 20, -30, 15, -5, -5, 15, -30, 20, 0 }; static int yylex (void) { (void) yywrap; if (*lp == '\0') { if (fgets (line, 80, stdin) == 0) { return -1; } else { lp = line; } } for (;;) { switch (*lp++) { case ' ': case '\t': break; case '\n': lp[-1] = '\0'; position = 1; return NL; case 'O': yylval.field.base = - base[yylval.field.position = position++]; yylval.field.width = 1; return BLACK; case '*': yylval.field.base = base[yylval.field.position = position++]; yylval.field.width = 1; return WHITE; case '-': yylval.field.base = 0; yylval.field.position = position++; yylval.field.width = 1; return EMPTY; case '?': return IGNORE; } } } #define MAX_COLUMNS 8 int column; static void output (int score, char *comment) { if (verbose) printf ("\t%5d,\t/*%s */\n", score, comment); else { printf ("%d,", score); if (++column == MAX_COLUMNS) { printf ("\n"); column = 0; } } } static void flush_output (void) { if (!verbose && column) printf ("\n"); } kgames-2.2/xreversi/meson.build000066400000000000000000000054341416764561500166620ustar00rootroot00000000000000# # Copyright © 2020 Keith Packard # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that copyright # notice and this permission notice appear in supporting documentation, and # that the name of the copyright holders not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. The copyright holders make no representations # about the suitability of this software for any purpose. It is provided "as # is" without express or implied warranty. # # THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, # INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO # EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR # CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, # DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # ad_file = configure_file(input: 'Reversi.ad.in', output: '@BASENAME@', configuration: conf_data, install: false) res_files = res_gen.process(ad_file) srcs_reversi = [ 'corners.c', 'count.c', 'fini.c', 'game.c', 'hasmove.c', 'minmax.c', 'move.c', 'Reversi.c', 'transform.c', 'xreversi.c', ] genedge = executable('genedge', 'genedge.c', install: false) bison_gen = generator(bison, output : ['@BASENAME@.c', '@BASENAME@.h'], arguments : [ '-o', '@OUTPUT0@', '--defines=@OUTPUT1@', '-p', 'LayYY', '@INPUT@']) makeedge_files = bison_gen.process('makeedge.y') makeedge = executable('makeedge', makeedge_files, install: false) edges_in = custom_target('edges.in', output : ['edges.in'], capture: true, command : [genedge]) edges_c = custom_target('edges.c', input : edges_in, output : 'edges.c', capture: true, command : [makeedge, '@INPUT@']) make_xreversi_svg = find_program('make-xreversi-svg') icon_files = custom_target('xreversi-icon', depend_files : 'xreversi.svg', output : ['xreversi-svg.c', 'xreversi-svg.h'], command : [make_xreversi_svg, '@OUTPUT0@', '@OUTPUT1@']) executable('xreversi', srcs_reversi, edges_c, res_files, icon_files, include_directories: inc, dependencies: [x_libs], link_with: [lib_xkw], install: true) install_man('xreversi.6') install_data('xreversi.svg', install_dir : svg_icon_dir) configure_file(input: 'xreversi.desktop.in', output: '@BASENAME@', configuration: conf_data, install_dir : desktop_dir) kgames-2.2/xreversi/minmax.c000066400000000000000000000155751416764561500161640ustar00rootroot00000000000000/* * minmax.c */ # include "revers.h" # include # include # include # include int maxlev, movex, movey; /* * this defines the order in which the board * is searched for the best move. It is * here to shorten the time to best move, * this increasing the chance of hitting * a good trimming point as well as * increasing the possibility of making * a reasonable move when an interrupt is * caught. */ short morder[64][2] = { { 1,1, }, { 1,8, }, { 8,1, }, { 8,8, }, { 1,3, }, { 1,6, }, { 3,1, }, { 3,8, }, { 6,1, }, { 6,8, }, { 8,3, }, { 8,6, }, { 3,3, }, { 3,6, }, { 6,3, }, { 6,6, }, { 1,4, }, { 1,5, }, { 4,1, }, { 4,8, }, { 5,1, }, { 5,8, }, { 8,4, }, { 8,5, }, { 3,4, }, { 3,5, }, { 4,3, }, { 4,6, }, { 5,3, }, { 5,6, }, { 6,4, }, { 6,5, }, { 2,3, }, { 2,6, }, { 3,2, }, { 3,7, }, { 6,2, }, { 6,7, }, { 7,3, }, { 7,6, }, { 2,4, }, { 2,5, }, { 4,2, }, { 4,7, }, { 5,2, }, { 5,7, }, { 7,4, }, { 7,5, }, { 1,2, }, { 1,7, }, { 2,1, }, { 2,8, }, { 7,1, }, { 7,8, }, { 8,2, }, { 8,7, }, { 2,2, }, { 2,7, }, { 7,2, }, { 7,7, }, { 4,4, }, { 4,5, }, { 5,4, }, { 5,5, }, }; jmp_buf stopsearch; #undef MDEBUG /* turn on minmax debugging */ #ifdef MDEBUG FILE *debug; #endif #ifdef pdp11 # define NOMOVE (-32100) #else # define NOMOVE (-300000) #endif void copy(boardT next, boardT board) { memcpy(next, board, sizeof(boardT)); } /* * this is the base score matrix - note that only * the center 16 squares are used. */ boardT base = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, { 0, 0, 0, 3, 1, 1, 3, 0, 0, 0, }, { 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, }, { 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, }, { 0, 0, 0, 3, 1, 1, 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, 0, }, }; # define bget(b, x, y) *(((boardE *) (b)) + ((((x) << 2) + x) << 1) + (y)) scoreT edgemod[10][3] = { { 0, 0, 0, }, { 0, 0, 0, }, { 0, 0, 0, }, { 5, -10, 5, }, { 5, -5, 5, }, { 5, -5, 5, }, { 5, -10, 5, }, { 0, 0, 0, }, { 0, 0, 0, }, { 0, 0, 0, }, }; extern scoreT cornerscores[4][4][4][4]; # define cornersc(a,b,c,d) cornerscores[a+1][b+1][c+1][d+1]; extern scoreT edgescores[4][4][4][4][4][4][4][4]; # define edgesc(a,b,c,d,e,f,g,h) edgescores[a+1][b+1][c+1][d+1][e+1]\ [f+1][g+1][h+1]; int computer (int player, boardT board, int level) { #ifdef MDEBUG if (!debug) debug = fopen ("debug", "w"); #endif maxlev = level; movex = movey = -1; seek (player, board, 0, 1, -NOMOVE); if (movex == -1 || movey == -1) return 0; #ifdef MDEBUG fprintf (debug, "player %d move to %d, %d\n", player, movex, movey); fflush (debug); #endif move (player, movex, movey, board); return 1; } int hint (int player, boardT board, int level) { #ifdef MDEBUG if (!debug) debug = fopen ("debug", "w"); #endif maxlev = level; seek (player, board, 0, 1, -NOMOVE); #ifdef MDEBUG fprintf (debug, "player %d hint %d, %d\n", player, movex, movey); fflush (debug); #endif if (movex == -1 || movey == -1) return 0; return 1; } extern int offsets[]; int seek (int player, boardT board, int level, int moved, int best) { boardT next; int x, y; int max; int bestx, besty; int moves, j; extern int gotsignal; register int opponent = -player; max = NOMOVE; moves = 0; for (j = 0; j < 60; j++) { x = morder[j][0]; y = morder[j][1]; if (gotsignal) return 0; { register boardE *m; boardE *b; b = & board[x][y]; if (*b == EMPTY) { #define CheckMove(off) if (*(m=b+(off)) == opponent) { \ do \ m += off; \ while (*m == opponent); \ if (*m == player) \ goto goodmove; \ } CheckMove(-11) CheckMove(-10) CheckMove(-9) CheckMove(-1) CheckMove(1) CheckMove(9) CheckMove(10) CheckMove(11) } continue; } goodmove: ; { int s; copy (next, board); /* * moved is set if we come from * a command, not if the previous * level resulted in no move */ if (moved && level == 0 && movex == -1) { movex = x; movey = y; } move (player, x, y, next); ++moves; if (level >= maxlev) { /* * score this board - this * is extracted from score.c and * inserted here for speed */ register int i; register boardE *bo, *ba; bo = (boardE *) next; s = edgesc (bget(bo,1,1),bget(bo,1,2), bget(bo,1,3),bget(bo,1,4), bget(bo,1,5),bget(bo,1,6), bget(bo,1,7),bget(bo,1,8)); s += edgesc (bget(bo,8,1),bget(bo,8,2), bget(bo,8,3),bget(bo,8,4), bget(bo,8,5),bget(bo,8,6), bget(bo,8,7),bget(bo,8,8)); s += edgesc (bget(bo,1,1),bget(bo,2,1), bget(bo,3,1),bget(bo,4,1), bget(bo,5,1),bget(bo,6,1), bget(bo,7,1),bget(bo,8,1)); s += edgesc (bget(bo,1,8),bget(bo,2,8), bget(bo,3,8),bget(bo,4,8), bget(bo,5,8),bget(bo,6,8), bget(bo,7,8),bget(bo,8,8)); s += cornersc (bget(bo,1,1),bget(bo,1,2), bget(bo,2,1),bget(bo,2,2)); s += cornersc (bget(bo,1,8),bget(bo,1,7), bget(bo,2,8),bget(bo,2,7)); s += cornersc (bget(bo,8,1),bget(bo,8,2), bget(bo,7,1),bget(bo,7,2)); s += cornersc (bget(bo,8,8),bget(bo,8,7), bget(bo,7,8),bget(bo,7,7)); for (i = 3; i <= 6; i++) { s += bget(bo,2,i) * edgemod[i][bget(bo,1,i)+1]; s += bget(bo,7,i) * edgemod[i][bget(bo,8,i)+1]; s += bget(bo,i,2) * edgemod[i][bget(bo,i,1)+1]; s += bget(bo,i,7) * edgemod[i][bget(bo,i,8)+1]; } for (i = 3; i <= 6; i++) { bo = &next[i][3]; ba = &base[i][3]; s += *bo++ * *ba++; s += *bo++ * *ba++; s += *bo++ * *ba++; s += *bo++ * *ba++; } s *= player; } else s = seek (-player, next, level+1, 1, -max); #ifdef MDEBUG fprintf (debug, "%.*s l %d %d,%d %d\n", level+1, " ", level, x, y, s); #endif if (s >= max) { /* * try to make the game appear random * by choosing among equal moves * randomly */ if (s == max && (random() >> 3) & 01) continue; if (s > best) return -s; bestx = x; besty = y; if (level == 0) { movex = bestx; movey = besty; } max = s; } } } if (moves == 0) { if (moved) { #ifdef MDEBUG fprintf (debug, " no move but not using count, level %d\n", level); #endif max = seek (-player, board, level, 0, -best); } else { #ifdef MDEBUG fprintf (debug, " using count, level %d\n", level); #endif #ifdef pdp11 max = count (player, board) * 500; #else max = count (player, board) * 1000; #endif } #ifdef MDEBUG fprintf (debug, "%.*s l %d no move %d\n", level+1, " ", level, max); #endif return - max; } return -max; } kgames-2.2/xreversi/move.c000066400000000000000000000015351416764561500156300ustar00rootroot00000000000000/* * move.c * * move player to x,y in board */ # include "revers.h" int offsets[] = { -11, -10, -9, -1, 1, 9, 10, 11, 0 }; void move (int player, int x, int y, boardT board) { register boardE *b, *m; register int *o, i; b = & board[x][y]; *b = player; player = -player; for (o = offsets; (i = *o++) != 0;) { if (b[i] == player) { m = b+i; while (*m == player) m += i; if (*m == -player) { while (m != b) { *m = -player; m -= i; } } } } } int legal (int player, int x, int y, boardT board) { register int i; register boardE *m; register boardE *b; register int *o; b = & board[x][y]; player = -player; if (*b == EMPTY) { for (o = offsets; (i = *o++) != 0;) { if (*(m=b+i) == player) { do m += i; while (*m == player); if (*m == -player) return 1; } } } return 0; } kgames-2.2/xreversi/revers.h000066400000000000000000000024721416764561500161760ustar00rootroot00000000000000/* * revers.h * * include file for game program */ #include # define SIZE 8 typedef char boardE; typedef short scoreT; typedef boardE boardT[SIZE+2][SIZE+2]; typedef boardT *boardP; struct move { int p, x, y; }; # define EMPTY 0 # define WHITE 1 # define BLACK -1 int legal (int player, int x, int y, boardT board); int hasmove (int player, boardT board); void dispError (char *s); void dispInit(int argc, char **argv); void dispGrid (void); void fini (boardT board); int computer (int player, boardT board, int level); int seek (int player, boardT board, int level, int moved, int best); void move (int player, int x, int y, boardT board); int hint (int player, boardT board, int level); int seek (int player, boardT board, int level, int moved, int best); int count (int player, boardT board); void setup (void); void display (boardT board); void replay (char *file); int playGame (void); void dispEnd (void); void dispTurn (int player); void dispMove (int x, int y, int player); void dispHint (int x, int y, int player); void dispHelp (void); extern void dispNoGrid (void); void dispScore (boardT board); void dispNoScore (void); void dispNoHelp (void); void copy(boardT next, boardT board); void doHint (void); void undo (void); void domove (int x, int y); void checkInput (void); kgames-2.2/xreversi/transform.c000066400000000000000000000053071416764561500166760ustar00rootroot00000000000000/* * transformed coordinate system objects for X */ # include # include # include "transform.h" static XPoint * TranslatePoints ( TPoint *points, int n_points, Transform *t, int mode) { XPoint *xpoints; int i; double xoff = 0.0, yoff = 0.0; xpoints = (XPoint *) malloc (n_points * sizeof (*xpoints)); if (!xpoints) return 0; for (i = 0; i < n_points; i++) { xpoints[i].x = Xx(points[i].x + xoff, points[i].y + yoff, t); xpoints[i].y = Xy(points[i].x + xoff, points[i].y + yoff, t); if (mode == CoordModePrevious) { xoff += points[i].x; yoff += points[i].y; } } return xpoints; } void TFillPolygon ( Display *dpy, Drawable d, GC gc, Transform *t, TPoint *points, int n_points, int shape, int mode) { XPoint *xpoints; xpoints = TranslatePoints (points, n_points, t, mode); if (xpoints) { XFillPolygon (dpy, d, gc, xpoints, n_points, shape, CoordModeOrigin); free (xpoints); } } void TDrawArc ( Display *dpy, Drawable d, GC gc, Transform *t, double x, double y, double width, double height, int angle1, int angle2) { int xx, xy, xw, xh; xx = Xx(x,y,t); xy = Xy(x,y,t); xw = Xwidth (width, height, t); xh = Xheight (width, height, t); if (xw < 0) { xx += xw; xw = -xw; } if (xh < 0) { xy += xh; xh = -xh; } XDrawArc (dpy, d, gc, xx, xy, xw, xh, angle1, angle2); } void TFillArc ( Display *dpy, Drawable d, GC gc, Transform *t, double x, double y, double width, double height, int angle1, int angle2) { int xx, xy, xw, xh; xx = Xx(x,y,t); xy = Xy(x,y,t); xw = Xwidth (width, height, t); xh = Xheight (width, height, t); if (xw < 0) { xx += xw; xw = -xw; } if (xh < 0) { xy += xh; xh = -xh; } XFillArc (dpy, d, gc, xx, xy, xw, xh, angle1, angle2); } void TDrawLine ( Display *dpy, Drawable d, GC gc, Transform *t, double x1, double y1, double x2, double y2) { int xx1, xy1, xx2, xy2; xx1 = Xx(x1,y1,t); xy1 = Xy(x1,y1,t); xx2 = Xx(x2,y2,t); xy2 = Xy(x2,y2,t); XDrawLine (dpy, d, gc, xx1, xy1, xx2, xy2); } void TClearArea ( Display *dpy, Drawable d, Transform *t, double x, double y, double width, double height, int exposures) { int xx, xy, xw, xh; xx = Xx(x,y,t); xy = Xy(x,y,t); xw = Xwidth (width, height, t); xh = Xheight (width, height, t); XClearArea (dpy, d, xx, xy, xw, xh, exposures); } void SetTransform ( Transform *t, int xx1, int xx2, int xy1, int xy2, double tx1, double tx2, double ty1, double ty2) { t->mx = ((double) xx2 - xx1) / (tx2 - tx1); t->bx = ((double) xx1) - t->mx * tx1; t->my = ((double) xy2 - xy1) / (ty2 - ty1); t->by = ((double) xy1) - t->my * ty1; } kgames-2.2/xreversi/transform.h000066400000000000000000000031701416764561500166770ustar00rootroot00000000000000/* * header file for transformed coordinate system. No rotations * supported, as elipses cannot be rotated in X. */ typedef struct _transform { double mx, bx; double my, by; } Transform; typedef struct _TPoint { double x, y; } TPoint; typedef struct _TRectangle { double x, y, width, height; } TRectangle; # define Xx(x,y,t) ((int)((t)->mx * (x) + (t)->bx + 0.5)) # define Xy(x,y,t) ((int)((t)->my * (y) + (t)->by + 0.5)) # define Xwidth(w,h,t) ((int)((t)->mx * (w) + 0.5)) # define Xheight(w,h,t) ((int)((t)->my * (h) + 0.5)) # define Tx(x,y,t) ((((double) (x)) - (t)->bx) / (t)->mx) # define Ty(x,y,t) ((((double) (y)) - (t)->by) / (t)->my) # define Twidth(w,h,t) (((double) (w)) / (t)->mx) # define Theight(w,h,t) (((double) (h)) / (t)->my) void TFillPolygon ( Display *dpy, Drawable d, GC gc, Transform *t, TPoint *points, int n_points, int shape, int mode); void TDrawArc ( Display *dpy, Drawable d, GC gc, Transform *t, double x, double y, double width, double height, int angle1, int angle2); void TFillArc ( Display *dpy, Drawable d, GC gc, Transform *t, double x, double y, double width, double height, int angle1, int angle2); void SetTransform ( Transform *t, int xx1, int xx2, int xy1, int xy2, double tx1, double tx2, double ty1, double ty2); void TClearArea ( Display *dpy, Drawable d, Transform *t, double x, double y, double width, double height, int exposures); void TDrawLine ( Display *dpy, Drawable d, GC gc, Transform *t, double x1, double y1, double x2, double y2); kgames-2.2/xreversi/ulex.l000066400000000000000000000027571416764561500156570ustar00rootroot00000000000000%{ /* * ulex.l * * lexer for the user interface */ # include "y.tab.h" extern int yylval; extern char sbuf[]; extern int yywrap (); extern int yylook (); extern int atoi (); extern int fprintf (); extern int lexgetc (); extern int lexungetc(); int yylex (); int yylook (); int yyback (); extern int _flsbuf (); int yyinput (); int yyoutput (); void yyunput (); #undef input #define input() lexgetc() #undef unput #define unput(c) lexungetc(c) %} %% [ \t] ; \004 return EOG; black { yylval = -1; return BL; } both return BOTH; computer return COMPUTER; debug return DEBUG; file return FILEe; first return FIRST; from return FROM; game return GAME; grid return GRID; help return HELP; hint return HINT; human return HUMAN; into return INTO; level return LEVEL; me return HUMAN; move return MOVE; new return NEW; neither return NEITHER; no return NO; nogrid return NOGRID; nohelp return NOHELP; noscore return NOSCORE; none return NONE; play return PLAY; quit return QUIT; record return RECORD; replay return REPLAY; restart return RESTART; save return SAVE; score return SCORE; second return SECOND; to return TO; undo return UNDO; white { yylval = 1; return WH; } you return COMPUTER; \n return NL; [0-9]+ { yylval = atoi (yytext); return NUMBER; } [a-h] { yylval = *yytext; return LETTER; } [A-H] { yylval = *yytext + 'a' - 'A'; return LETTER; } "," return COMMA; ";" return SEMI; \"[^"]*\" { strcpy (sbuf, yytext+1); sbuf[yyleng-2]='\0'; return STRING; } . return ERR; kgames-2.2/xreversi/user.y000066400000000000000000000070731416764561500156710ustar00rootroot00000000000000%{ /* * user interface */ # include "revers.h" # include # include extern boardT board, saveBoard; extern int saved; extern int savePlayer; extern int atend; extern int atbegin; extern int level; extern int player; extern int maxlev, movex, movey; extern int x, y; extern int com; extern int gotsignal; extern char sbuf[80]; extern char ebuf[80]; extern int sdebug, mdebug; extern int record; extern FILE *rfile; extern int first; extern int defcom; extern int showScore; extern struct move saveGame[64]; extern struct move *saveP; extern int yylex (); extern void free (); extern void readLine (); %} %token MOVE LEVEL COMPUTER UNDO HINT PLAY %token RECORD REPLAY SAVE %token RESTART NEW GAME QUIT %token GRID NOGRID HELP NOHELP SCORE NOSCORE %token DEBUG EVAL %token FROM INTO TO FILEe NO %token NUMBER LETTER COMMA NL STRING SEMI EOG ERR %token WH BL HUMAN BOTH NEITHER NONE FIRST SECOND %% game : game commands NL prompt | prompt ; prompt : { checkInput (); readLine (); } ; commands: commands SEMI command | command | error oerror { dispHelp (); } ; command : | EOG { YYACCEPT; } | omove LETTER ocomma NUMBER { domove ($4, $2 - 'a' + 1); } | omove NUMBER ocomma LETTER { domove ($2, $4 - 'a' + 1); } | DEBUG STRING { register char *s; register int v; v = 1; for (s = sbuf; *s; ++s) switch (*s) { case 'm': mdebug = v; break; case 's': sdebug = v; break; case '!': v = !v; break; } } | GRID { dispGrid (); } | NO GRID { dispNoGrid (); } | NOGRID { dispNoGrid (); } | SCORE { showScore = 1; dispScore (board); } | NOSCORE { showScore = 0; dispNoScore (); } | NO SCORE { showScore = 0; dispNoScore (); } | LEVEL NUMBER { level = $2; } | LEVEL oerror { sprintf (ebuf, "current level is %d", level); dispError (ebuf); } | PLAY whichp { if ($2 == WHITE || $2 == BLACK) defcom = $2; com = $2; } | PLAY oerror { dispError ("play (white black both none)"); } | whichp FIRST { if ($1 == WHITE || $1 == BLACK) first = $1; if (atbegin) player = first; } | FIRST oerror { dispError ("(white black you me) first"); } | whichp SECOND { if ($1 == WHITE || $1 == BLACK) first = - $1; if (atbegin) player = first; } | SECOND oerror { dispError ("(white black you me) second"); } | HELP { dispHelp (); } | NOHELP { dispNoHelp (); } | NO HELP { dispNoHelp (); } | QUIT { YYACCEPT; } | UNDO { undo (); } | NEW ogame eoc { YYABORT; } | RESTART eoc { YYABORT; } | RECORD ointo ofile STRING { } | RECORD oerror { dispError ("record \"file\""); } | REPLAY ofrom ofile STRING { replay (sbuf); } | REPLAY oerror { dispError ("replay \"file\""); } | SAVE ointo ofile STRING { /*save (sbuf) */; } | SAVE oerror { dispError ("save \"file\""); } | HINT { doHint (); } ; eoc : SEMI | NL ; omove : MOVE | ; ogame : GAME | ; ocomma : COMMA | ; oerror : oerror error { yyerrok; } | oerror ERR | ; ointo : TO | INTO | ; ofrom : FROM | ; ofile : FILEe | ; whichp : WH { $$ = WHITE; } | BL { $$ = BLACK; } | COMPUTER { $$ = com==WHITE?WHITE:BLACK; } | HUMAN { $$ = com==WHITE?BLACK:WHITE; } | BOTH { $$ = 0; } | none { $$ = 2; } ; none : NONE | NEITHER ; %% int yyerror (s) char *s; { dispError (s); return 1; } int yywrap () { return 1; } int playGame () { int yyparse (); return yyparse (); } kgames-2.2/xreversi/xreversi-icon.5c000077500000000000000000000023711416764561500175460ustar00rootroot00000000000000#!/usr/bin/env nickle autoimport Cairo; real size = 64; real width = size; real height = size; real board_width = 2; real board_height = 2; real stone_width = 0.75; real M_PI = pi; void set_back_color(cairo_t cr) { set_source_rgba(cr, .2, .4{6}, .2{6}, 1); } void set_white_color(cairo_t cr) { set_source_rgba(cr, 1, 1, 1, 1); } void set_black_color(cairo_t cr) { set_source_rgba(cr, 0, 0, 0, 1); } void set_grid_color(cairo_t cr) { set_black_color(cr); } void draw_begin(cairo_t cr) { scale(cr, width / board_width, height / board_height); set_line_width(cr, 0.04); } void draw_stone(cairo_t cr, int x, int y) { arc(cr, x + 0.5, y + 0.5, stone_width / 2, 0, pi * 2); fill(cr); } void draw_grid(cairo_t cr) { set_grid_color(cr); for (int i = 0; i <= board_height; i++) { move_to(cr, i, 0); line_to(cr, i, board_width); } for (int i = 0; i <= board_width; i++) { move_to(cr, 0, i); line_to(cr, board_height, i); } stroke(cr); } void doit() { cairo_t cr = new_svg("xreversi.svg", width, height); draw_begin(cr); set_back_color(cr); paint(cr); draw_grid(cr); set_white_color(cr); draw_stone(cr, 0, 0); draw_stone(cr, 1, 1); set_black_color(cr); draw_stone(cr, 1, 0); draw_stone(cr, 0, 1); show_page(cr); destroy(cr); } doit(); kgames-2.2/xreversi/xreversi.6000066400000000000000000000003331416764561500164470ustar00rootroot00000000000000.TH KREVERSI 6 "1992" "Kgames 1.0" .SH NAME kreversi \- X window reversi game .SH SYNOPSIS .B kreversi .SH DESCRIPTION .I Kreversi brings up a window for a game of reversi against the computer. .SH AUTHOR Keith Packard kgames-2.2/xreversi/xreversi.c000066400000000000000000000241161416764561500165310ustar00rootroot00000000000000/* * Copyright © 2020 Keith Packard * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that copyright * notice and this permission notice appear in supporting documentation, and * that the name of the copyright holders not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no representations * about the suitability of this software for any purpose. It is provided "as * is" without express or implied warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "Reversi.h" #include #include "revers.h" #include "Reversi-res.h" #include "xreversi-svg.h" static Widget topLevel, layout, reversi, error; static Widget quit, hint_button, undoButton, restart; static Widget playerLabel, playWhite, playBlack, playBoth, playNeither; static Widget levelLabel, levelValue; static Widget turn; static void DoSetLevel (Widget w, XtPointer closure, XtPointer call_data); /* Command line options table. Only resources are entered here...there is a pass over the remaining options after XtParseCommand is let loose. */ typedef struct _Xreversi { int animateTimeout; int animateRepeat; } Xreversi; Xreversi app_resources; #define offset(field) XtOffset(Xreversi*, field) static XtResource resources[] = { {"animateTimeout", "AnimateTimeout", XtRInt, sizeof (int), offset (animateTimeout), XtRImmediate, (char *) 150}, {"animateRepeat", "AnimateRepeat", XtRInt, sizeof (int), offset (animateRepeat), XtRImmediate, (char *) 4}, }; static XrmOptionDescRec options[] = { {"-animate", "*animateTimeout", XrmoptionSepArg, NULL} }; static Widget MakeCommandButton(Widget box, char *name, XtCallbackProc function) { Widget w = XtCreateManagedWidget(name, kcommandWidgetClass, box, NULL, ZERO); if (function != NULL) XtAddCallback(w, XtNcallback, function, (caddr_t) NULL); return w; } static Widget MakeRadioButton ( Widget parent, char *name, XtCallbackProc callback, int value, Widget group) { Arg args[2]; Widget button; Cardinal n; n = 0; XtSetArg (args[n], XtNradioData, (caddr_t) (intptr_t) value); n++; if (group) { XtSetArg (args[n], XtNradioGroup, (caddr_t) (intptr_t) group); n++; } button = XtCreateManagedWidget (name, ktoggleWidgetClass, parent, args, n); if (callback != NULL) XtAddCallback (button, XtNcallback, callback, (caddr_t) NULL); return button; } static Widget MakeStringBox(Widget parent, String name, String string) { Arg args[5]; Cardinal numargs = 0; Widget StringW; XtSetArg(args[numargs], XtNstring, string); numargs++; StringW = XtCreateManagedWidget(name, ktextLineWidgetClass, parent, args, numargs); XtAddCallback (StringW, XtNeditCallback, DoSetLevel, (caddr_t) NULL); return(StringW); } static void waitForServer(Boolean yield); extern int com, defcom; extern int level; int UIdone, UIret; static void DoQuit (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; dispError (""); UIdone = 1; UIret = 0; } static void DoHint (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; dispError (""); doHint (); } static void DoUndo (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; dispError (""); undo (); } static void DoRestart (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; dispError (""); UIdone = 1; UIret = 1; } #define PLAY_WHITE 1 #define PLAY_BLACK 2 #define PLAY_BOTH 3 #define PLAY_NEITHER 4 static void DoPlay (Widget w, XtPointer closure, XtPointer call_data) { int current; (void) w; (void) closure; (void) call_data; current = (intptr_t) XkwKToggleGetCurrent (playWhite); switch (current) { case PLAY_WHITE: defcom = WHITE; com = WHITE; break; case PLAY_BLACK: defcom = BLACK; com = BLACK; break; case PLAY_BOTH: com = 0; break; case PLAY_NEITHER: com = 2; break; } } static void SetPlay (void) { int current, should_be = 0; current = (intptr_t) XkwKToggleGetCurrent (playWhite); switch (com) { case WHITE: should_be = PLAY_WHITE; break; case BLACK: should_be = PLAY_BLACK; break; case 0: should_be = PLAY_BOTH; break; case 2: should_be = PLAY_NEITHER; break; } if (current != should_be) { XkwKToggleSetCurrent (playWhite, (caddr_t) (intptr_t) should_be); } } static void DoMove (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; ReversiMovePtr move = (ReversiMovePtr) call_data; dispError (""); domove (move->x + 1, move->y + 1); } static char levelString[100]; static Bool levelChanged; static void DoSetLevel (Widget w, XtPointer closure, XtPointer call_data) { (void) w; (void) closure; (void) call_data; levelChanged = TRUE; } static void DoSetLevelAction (Widget w, XEvent *event, String *string, Cardinal *num) { (void) event; (void) string; (void) num; DoSetLevel(w, NULL, NULL); } static void SetLevel (void) { Arg args[1]; char *value; int newlevel; levelChanged = FALSE; XtSetArg (args[0], XtNstring, &value); XtGetValues (levelValue, args, 1); if (sscanf (value, "%d", &newlevel) == 1) level = newlevel; } XtActionsRec xreversi_actions[] = { { "SetLevel", DoSetLevelAction, }, }; void dispInit(int argc, char **argv) { topLevel = XkwInitialize("Reversi", options, XtNumber(options), &argc, argv, True, defaultResources); XtGetApplicationResources(topLevel, &app_resources, resources, XtNumber(resources), NULL, 0); XtAppAddActions (XtWidgetToApplicationContext (topLevel), xreversi_actions, XtNumber (xreversi_actions)); layout = XtCreateManagedWidget ( "layout", layoutWidgetClass, topLevel, NULL, ZERO); reversi = XtCreateManagedWidget( "reversi", reversiWidgetClass, layout, NULL, ZERO ); XtAddCallback (reversi, XtNstoneCallback, DoMove, (caddr_t) NULL); error = XtCreateManagedWidget ( "error", klabelWidgetClass, layout, NULL, ZERO ); quit = MakeCommandButton (layout, "quit", DoQuit); hint_button = MakeCommandButton (layout, "hint", DoHint); undoButton = MakeCommandButton (layout, "undo", DoUndo); restart = MakeCommandButton (layout, "restart", DoRestart); playerLabel = XtCreateManagedWidget ("playerLabel", klabelWidgetClass, layout, NULL, ZERO); playWhite = MakeRadioButton (layout, "playWhite", DoPlay, PLAY_WHITE, (Widget) NULL); playBlack = MakeRadioButton (layout, "playBlack", DoPlay, PLAY_BLACK, playWhite); playBoth = MakeRadioButton (layout, "playBoth", DoPlay, PLAY_BOTH, playWhite); playNeither = MakeRadioButton (layout, "playNeither", DoPlay, PLAY_NEITHER, playWhite); SetPlay (); levelLabel = XtCreateManagedWidget ( "levelLabel", klabelWidgetClass, layout, NULL, ZERO); sprintf (levelString, "%d", level); levelValue = MakeStringBox (layout, "levelValue", levelString); XtSetKeyboardFocus (layout, levelValue); turn = XtCreateManagedWidget ("turn", klabelWidgetClass, layout, NULL, ZERO); XtRealizeWidget(topLevel); XkwSetIcon(topLevel, svg_xreversi); } int playGame (void) { UIdone = 0; while (!UIdone) { checkInput (); SetPlay (); waitForServer(True); } return UIret; } void display (boardT board) { int i, j; ReversiStone stone; for (i = 1; i <= SIZE; i++) for (j = 1; j <= SIZE; j++) { switch (board[i][j]) { case BLACK: stone = StoneBlack; break; case WHITE: stone = StoneWhite; break; default: stone = StoneNone; break; } XkwReversiSetSpot (reversi, i-1, j-1, stone); } XkwReversiUpdate(reversi); XFlush (XtDisplay (topLevel)); } void dispError (char *s) { Arg args[1]; XtSetArg (args[0], XtNlabel, s); XtSetValues (error, args, 1); waitForServer(False); } void dispGrid (void) { } void dispEnd (void) { } static void waitForServer(Boolean yield) { XSync (XtDisplay (topLevel), False); while (yield || XtPending ()) { XEvent event; XtNextEvent (&event); XtDispatchEvent (&event); if (levelChanged) SetLevel (); yield = False; } } void dispTurn (int player) { static char turnString[100]; static int oldPlayer = 100; Arg args[1]; SetPlay (); if (player != oldPlayer) { if (player == EMPTY) sprintf (turnString, "Game over"); else sprintf (turnString, "%s's turn", player == WHITE ? "white" : "black"); XtSetArg (args[0], XtNlabel, turnString); XtSetValues (turn, args, 1); oldPlayer = player; } waitForServer (False); } void dispMove (int x, int y, int player) { ReversiStone A, B; if (player == WHITE) A = StoneWhite; else A = StoneBlack; B = StoneNone; XkwReversiAnimateSpot (reversi, x - 1, y - 1, A, B, (unsigned long) app_resources.animateTimeout, app_resources.animateRepeat); dispError (""); } void dispHint (int x, int y, int player) { dispMove (x, y, player); } kgames-2.2/xreversi/xreversi.desktop.in000066400000000000000000000003751416764561500203660ustar00rootroot00000000000000[Desktop Entry] Name=XReversi GenericName=Reversi Game Comment=Play Reversi against the computer Keywords=game;board Exec=@BINDIR@/xreversi Icon=@ICONDIR@/xreversi.svg StartupNotify=false Terminal=false Type=Application Categories=Game;BoardGame;Kgames kgames-2.2/xreversi/xreversi.svg000066400000000000000000000027361416764561500171120ustar00rootroot00000000000000