🚀 go-pugleaf

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# If this archive is complete, you will see the following message at the end:
#		"End of archive 5 (of 5)."
# Contents:  Cmap.h Makefile bitmaps/arcOp.xbm bitmaps/boxOp.xbm
#   bitmaps/brushOp.xbm bitmaps/checkmark.xbm bitmaps/clineOp.xbm
#   bitmaps/defspray.xbm bitmaps/eraseOp.xbm bitmaps/fboxOp.xbm
#   bitmaps/fillOp.xbm bitmaps/fovalOp.xbm bitmaps/fpolyOp.xbm
#   bitmaps/lineOp.xbm bitmaps/ovalOp.xbm bitmaps/paintA.xbm
#   bitmaps/paintB.xbm bitmaps/paintC.xbm bitmaps/paintD.xbm
#   bitmaps/paintE.xbm bitmaps/paintF.xbm bitmaps/paintG.xbm
#   bitmaps/paintH.xbm bitmaps/paintI.xbm bitmaps/paintJ.xbm
#   bitmaps/paintK.xbm bitmaps/pattern3.xbm bitmaps/pattern7.xbm
#   bitmaps/pattern8.xbm bitmaps/pattern9.xbm bitmaps/polyOp.xbm
#   bitmaps/sprayOp.xbm bitmaps/textOp.xbm
# Wrapped by koblas@bananajr on Thu Jul  9 14:00:25 1992
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Cmap.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Cmap.h'\"
else
echo shar: Extracting \"'Cmap.h'\" \(931 characters\)
sed "s/^X//" >'Cmap.h' <<'END_OF_FILE'
X/* +-------------------------------------------------------------------+ */
X/* | Copyright 1992, David Koblas.                                     | */
X/* |   Permission to use, copy, modify, and distribute this software   | */
X/* |   and its documentation for any purpose and without fee is hereby | */
X/* |   granted, provided that the above copyright notice appear in all | */
X/* |   copies and that both that copyright notice and this permission  | */
X/* |   notice appear in supporting documentation.  This software is    | */
X/* |   provided "as is" without express or implied warranty.           | */
X/* +-------------------------------------------------------------------+ */
X
Xtypedef struct {
X	int		readonly;
X	Display		*display;
X	Colormap	cmap;
X	void		*htable;
X	void		*list;
X	int		nalloc;
X	int		size;
X} Cmap;
X
XCmap *CreateCmap(Widget w);
Xint   CmapAlloc(Cmap *map, XColor *color);
XCmap *CmapFind(Widget w, Colormap cmap);

END_OF_FILE
echo shar: NEWLINE appended to \"'Cmap.h'\"
if test 932 -ne `wc -c <'Cmap.h'`; then
    echo shar: \"'Cmap.h'\" unpacked with wrong size!
fi
# end of 'Cmap.h'
fi
if test -f 'Makefile' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Makefile'\"
else
echo shar: Extracting \"'Makefile'\" \(565 characters\)
sed "s/^X//" >'Makefile' <<'END_OF_FILE'
XXPSRC = main.c Menu.c Operation.c Graphic.c Undo.c Misc.c \
X	FileName.c ReadWritePNM.c FontSelect.c libpnmrw.c \
X	Pattern.c Hash.c Cmap.c FatbitsEdit.c Event.c
X
XOPSRC = PencilOp.c BoxOp.c LineOp.c CircleOp.c EraseOp.c \
X	BrushOp.c FontOp.c ArcOp.c PolyOp.c FillOp.c \
X	SelectBoxOp.c SelectAreaOp.c
X
XXPWID = Paint.c Colormap.c
X
XCFLAGS = -g -ansi
X
XOBJ   = $(XPSRC:.c=.o) $(XPWID:.c=.o) $(OPSRC:.c=.o)
X
Xxpaint: $(OBJ)
X	$(CC) $(CFLAGS) -o $@ $(OBJ) -lXaw -lXmu -lXext -lXt -lX11 -lm
X
Xclean: 
X	rm -f $(OBJ) xpaint
X
Xkit:
X	makekit README *.[ch] Makefile bitmaps bitmaps/*

END_OF_FILE
echo shar: NEWLINE appended to \"'Makefile'\"
if test 566 -ne `wc -c <'Makefile'`; then
    echo shar: \"'Makefile'\" unpacked with wrong size!
fi
# end of 'Makefile'
fi
if test -f 'bitmaps/arcOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/arcOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/arcOp.xbm'\" \(878 characters\)
sed "s/^X//" >'bitmaps/arcOp.xbm' <<'END_OF_FILE'
X#define arcOp_width 32
X#define arcOp_height 32
Xstatic char arcOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x60, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
X   0x00, 0xf8, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00,
X   0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x30, 0x00,
X   0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x80, 0x01,
X   0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
X   0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06,
X   0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c,
X   0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/arcOp.xbm'\"
if test 879 -ne `wc -c <'bitmaps/arcOp.xbm'`; then
    echo shar: \"'bitmaps/arcOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/arcOp.xbm'
fi
if test -f 'bitmaps/boxOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/boxOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/boxOp.xbm'\" \(878 characters\)
sed "s/^X//" >'bitmaps/boxOp.xbm' <<'END_OF_FILE'
X#define boxOp_width 32
X#define boxOp_height 32
Xstatic char boxOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x1f,
X   0xf0, 0xff, 0xff, 0x1f, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18,
X   0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18,
X   0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18,
X   0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18,
X   0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18,
X   0x30, 0x00, 0x00, 0x18, 0xf0, 0xff, 0xff, 0x1f, 0xf0, 0xff, 0xff, 0x1f,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/boxOp.xbm'\"
if test 879 -ne `wc -c <'bitmaps/boxOp.xbm'`; then
    echo shar: \"'bitmaps/boxOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/boxOp.xbm'
fi
if test -f 'bitmaps/brushOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/brushOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/brushOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/brushOp.xbm' <<'END_OF_FILE'
X#define brushOp_width 32
X#define brushOp_height 32
Xstatic char brushOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00,
X   0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x07,
X   0xf0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x07,
X   0xb0, 0x6d, 0xdb, 0x06, 0xb0, 0x6d, 0xdb, 0x06, 0xb0, 0x6d, 0xdb, 0x06,
X   0xb0, 0x6d, 0xdb, 0x06, 0xb0, 0x6d, 0xdb, 0x06, 0xb0, 0x6d, 0xdb, 0x06,
X   0xb0, 0x6d, 0xdb, 0x06, 0xb0, 0x6d, 0xdb, 0x06, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/brushOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/brushOp.xbm'`; then
    echo shar: \"'bitmaps/brushOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/brushOp.xbm'
fi
if test -f 'bitmaps/checkmark.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/checkmark.xbm'\"
else
echo shar: Extracting \"'bitmaps/checkmark.xbm'\" \(290 characters\)
sed "s/^X//" >'bitmaps/checkmark.xbm' <<'END_OF_FILE'
X#define checkmark_width 16
X#define checkmark_height 16
Xstatic char checkmark_bits[] = {
X   0x00, 0xc0, 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x0e,
X   0x00, 0x0e, 0x00, 0x07, 0x80, 0x03, 0x83, 0x03, 0xcf, 0x01, 0xdf, 0x01,
X   0xfc, 0x01, 0xf8, 0x00, 0xf0, 0x00, 0xe0, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/checkmark.xbm'\"
if test 291 -ne `wc -c <'bitmaps/checkmark.xbm'`; then
    echo shar: \"'bitmaps/checkmark.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/checkmark.xbm'
fi
if test -f 'bitmaps/clineOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/clineOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/clineOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/clineOp.xbm' <<'END_OF_FILE'
X#define clineOp_width 32
X#define clineOp_height 32
Xstatic char clineOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x38, 0x00,
X   0x00, 0x00, 0x44, 0x00, 0x40, 0x00, 0x84, 0x01, 0xc0, 0x00, 0x02, 0x02,
X   0x20, 0x01, 0x02, 0x04, 0x20, 0x01, 0x01, 0x18, 0x20, 0x02, 0x01, 0x20,
X   0x10, 0x84, 0x00, 0x00, 0x10, 0x88, 0x00, 0x00, 0x10, 0x48, 0x00, 0x00,
X   0x10, 0x50, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
X   0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/clineOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/clineOp.xbm'`; then
    echo shar: \"'bitmaps/clineOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/clineOp.xbm'
fi
if test -f 'bitmaps/defspray.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/defspray.xbm'\"
else
echo shar: Extracting \"'bitmaps/defspray.xbm'\" \(287 characters\)
sed "s/^X//" >'bitmaps/defspray.xbm' <<'END_OF_FILE'
X#define defspray_width 16
X#define defspray_height 16
Xstatic char defspray_bits[] = {
X   0x00, 0x00, 0x20, 0x04, 0x00, 0x01, 0x00, 0x00, 0x20, 0x08, 0x00, 0x41,
X   0x04, 0x00, 0x00, 0x20, 0x40, 0x04, 0x10, 0x40, 0x00, 0x08, 0x08, 0x02,
X   0x80, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/defspray.xbm'\"
if test 288 -ne `wc -c <'bitmaps/defspray.xbm'`; then
    echo shar: \"'bitmaps/defspray.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/defspray.xbm'
fi
if test -f 'bitmaps/eraseOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/eraseOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/eraseOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/eraseOp.xbm' <<'END_OF_FILE'
X#define eraseOp_width 32
X#define eraseOp_height 32
Xstatic char eraseOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x01,
X   0x02, 0x00, 0x00, 0x03, 0xba, 0x13, 0x3b, 0x05, 0x8a, 0xaa, 0x08, 0x09,
X   0x9a, 0x39, 0x19, 0x11, 0x8a, 0x2a, 0x0a, 0x11, 0xba, 0xaa, 0x39, 0x11,
X   0x02, 0x00, 0x00, 0x11, 0x02, 0x00, 0x00, 0x11, 0xfe, 0xff, 0xff, 0x11,
X   0x04, 0x00, 0x00, 0x12, 0x08, 0x00, 0x00, 0x14, 0x10, 0x00, 0x00, 0x18,
X   0xe0, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/eraseOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/eraseOp.xbm'`; then
    echo shar: \"'bitmaps/eraseOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/eraseOp.xbm'
fi
if test -f 'bitmaps/fboxOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/fboxOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/fboxOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/fboxOp.xbm' <<'END_OF_FILE'
X#define fboxOp_width 32
X#define fboxOp_height 32
Xstatic char fboxOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07,
X   0xf0, 0xff, 0xff, 0x07, 0x30, 0x00, 0x00, 0x06, 0xb0, 0xaa, 0xaa, 0x06,
X   0x30, 0x00, 0x00, 0x06, 0x70, 0x55, 0x55, 0x07, 0x30, 0x00, 0x00, 0x06,
X   0xb0, 0xaa, 0xaa, 0x06, 0x30, 0x00, 0x00, 0x06, 0x70, 0x55, 0x55, 0x07,
X   0x30, 0x00, 0x00, 0x06, 0xb0, 0xaa, 0xaa, 0x06, 0x30, 0x00, 0x00, 0x06,
X   0x70, 0x55, 0x55, 0x07, 0x30, 0x00, 0x00, 0x06, 0xb0, 0xaa, 0xaa, 0x06,
X   0xf0, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/fboxOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/fboxOp.xbm'`; then
    echo shar: \"'bitmaps/fboxOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/fboxOp.xbm'
fi
if test -f 'bitmaps/fillOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/fillOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/fillOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/fillOp.xbm' <<'END_OF_FILE'
X#define fillOp_width 32
X#define fillOp_height 32
Xstatic char fillOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
X   0x00, 0x75, 0x00, 0x00, 0x00, 0xab, 0x01, 0x00, 0x80, 0x55, 0x1f, 0x00,
X   0x80, 0xaa, 0x3a, 0x00, 0x40, 0x55, 0x3d, 0x00, 0xc0, 0xaa, 0x2a, 0x00,
X   0x60, 0x55, 0x65, 0x00, 0xa0, 0xaa, 0x66, 0x00, 0x50, 0x55, 0x63, 0x00,
X   0xb0, 0xaa, 0xc2, 0x00, 0x48, 0x55, 0xc1, 0x00, 0xb8, 0xaa, 0xc1, 0x00,
X   0x70, 0xd5, 0xc0, 0x00, 0xc0, 0xaa, 0xc0, 0x00, 0x00, 0x57, 0xc0, 0x00,
X   0x00, 0x6c, 0xc0, 0x00, 0x00, 0x30, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x00,
X   0x00, 0x00, 0xfc, 0x01, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00, 0xff, 0x0f,
X   0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/fillOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/fillOp.xbm'`; then
    echo shar: \"'bitmaps/fillOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/fillOp.xbm'
fi
if test -f 'bitmaps/fovalOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/fovalOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/fovalOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/fovalOp.xbm' <<'END_OF_FILE'
X#define fovalOp_width 32
X#define fovalOp_height 32
Xstatic char fovalOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0x58, 0x35, 0x00,
X   0x00, 0x06, 0xc0, 0x00, 0x00, 0xab, 0xaa, 0x01, 0x80, 0x00, 0x00, 0x02,
X   0x80, 0x55, 0x55, 0x03, 0x40, 0x00, 0x00, 0x04, 0xc0, 0xaa, 0xaa, 0x06,
X   0x40, 0x00, 0x00, 0x04, 0x40, 0x55, 0x55, 0x05, 0x80, 0x00, 0x00, 0x02,
X   0x80, 0xaa, 0xaa, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x56, 0xd5, 0x00,
X   0x00, 0x18, 0x30, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/fovalOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/fovalOp.xbm'`; then
    echo shar: \"'bitmaps/fovalOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/fovalOp.xbm'
fi
if test -f 'bitmaps/fpolyOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/fpolyOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/fpolyOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/fpolyOp.xbm' <<'END_OF_FILE'
X#define fpolyOp_width 32
X#define fpolyOp_height 32
Xstatic char fpolyOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c,
X   0x00, 0x0c, 0x00, 0x0f, 0x00, 0x34, 0x80, 0x08, 0x00, 0x6a, 0xc0, 0x0a,
X   0x00, 0x82, 0x30, 0x10, 0x00, 0x55, 0x5b, 0x15, 0x00, 0x01, 0x04, 0x10,
X   0x80, 0xaa, 0xaa, 0x1a, 0x80, 0x00, 0x00, 0x10, 0x40, 0x55, 0x55, 0x15,
X   0x40, 0x00, 0x00, 0x10, 0xa0, 0xaa, 0xaa, 0x1a, 0x20, 0x00, 0x00, 0x10,
X   0xf0, 0x55, 0x55, 0x35, 0x00, 0x3f, 0x00, 0x20, 0x00, 0xc0, 0xaf, 0x2a,
X   0x00, 0x00, 0xf0, 0x23, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/fpolyOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/fpolyOp.xbm'`; then
    echo shar: \"'bitmaps/fpolyOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/fpolyOp.xbm'
fi
if test -f 'bitmaps/lineOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/lineOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/lineOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/lineOp.xbm' <<'END_OF_FILE'
X#define lineOp_width 32
X#define lineOp_height 32
Xstatic char lineOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
X   0xf0, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00,
X   0x80, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
X   0x00, 0x3c, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00,
X   0x00, 0xe0, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00,
X   0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x3c, 0x00,
X   0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xe0, 0x01,
X   0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x0f,
X   0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/lineOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/lineOp.xbm'`; then
    echo shar: \"'bitmaps/lineOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/lineOp.xbm'
fi
if test -f 'bitmaps/ovalOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/ovalOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/ovalOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/ovalOp.xbm' <<'END_OF_FILE'
X#define ovalOp_width 32
X#define ovalOp_height 32
Xstatic char ovalOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x0f, 0x00,
X   0x00, 0x1c, 0x70, 0x00, 0x00, 0x03, 0x80, 0x01, 0x80, 0x00, 0x00, 0x02,
X   0x40, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x10,
X   0x10, 0x00, 0x00, 0x10, 0x08, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x20,
X   0x08, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x20, 0x10, 0x00, 0x00, 0x10,
X   0x10, 0x00, 0x00, 0x10, 0x20, 0x00, 0x00, 0x08, 0x40, 0x00, 0x00, 0x04,
X   0x80, 0x00, 0x00, 0x02, 0x00, 0x03, 0x80, 0x01, 0x00, 0x1c, 0x70, 0x00,
X   0x00, 0xe0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/ovalOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/ovalOp.xbm'`; then
    echo shar: \"'bitmaps/ovalOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/ovalOp.xbm'
fi
if test -f 'bitmaps/paintA.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintA.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintA.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintA.xbm' <<'END_OF_FILE'
X#define paintA_width 16
X#define paintA_height 16
Xstatic char paintA_bits[] = {
X   0x00, 0x00, 0xc0, 0x07, 0xf0, 0x1f, 0xf8, 0x3f, 0xf8, 0x3f, 0xfc, 0x7f,
X   0xfc, 0x7f, 0xfc, 0x7f, 0xfc, 0x7f, 0xfc, 0x7f, 0xf8, 0x3f, 0xf8, 0x3f,
X   0xf0, 0x1f, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintA.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintA.xbm'`; then
    echo shar: \"'bitmaps/paintA.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintA.xbm'
fi
if test -f 'bitmaps/paintB.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintB.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintB.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintB.xbm' <<'END_OF_FILE'
X#define paintB_width 16
X#define paintB_height 16
Xstatic char paintB_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x1f,
X   0xf0, 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xe0, 0x0f, 0xc0, 0x07,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintB.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintB.xbm'`; then
    echo shar: \"'bitmaps/paintB.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintB.xbm'
fi
if test -f 'bitmaps/paintC.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintC.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintC.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintC.xbm' <<'END_OF_FILE'
X#define paintC_width 16
X#define paintC_height 16
Xstatic char paintC_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintC.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintC.xbm'`; then
    echo shar: \"'bitmaps/paintC.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintC.xbm'
fi
if test -f 'bitmaps/paintD.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintD.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintD.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintD.xbm' <<'END_OF_FILE'
X#define paintD_width 16
X#define paintD_height 16
Xstatic char paintD_bits[] = {
X   0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x20, 0x00,
X   0x40, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x08,
X   0x00, 0x10, 0x00, 0x20, 0x00, 0x40, 0x00, 0x80};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintD.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintD.xbm'`; then
    echo shar: \"'bitmaps/paintD.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintD.xbm'
fi
if test -f 'bitmaps/paintE.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintE.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintE.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintE.xbm' <<'END_OF_FILE'
X#define paintE_width 16
X#define paintE_height 16
Xstatic char paintE_bits[] = {
X   0x00, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08, 0x00, 0x04,
X   0x00, 0x02, 0x00, 0x01, 0x80, 0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x00,
X   0x08, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintE.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintE.xbm'`; then
    echo shar: \"'bitmaps/paintE.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintE.xbm'
fi
if test -f 'bitmaps/paintF.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintF.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintF.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintF.xbm' <<'END_OF_FILE'
X#define paintF_width 16
X#define paintF_height 16
Xstatic char paintF_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintF.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintF.xbm'`; then
    echo shar: \"'bitmaps/paintF.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintF.xbm'
fi
if test -f 'bitmaps/paintG.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintG.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintG.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintG.xbm' <<'END_OF_FILE'
X#define paintG_width 16
X#define paintG_height 16
Xstatic char paintG_bits[] = {
X   0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
X   0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01,
X   0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintG.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintG.xbm'`; then
    echo shar: \"'bitmaps/paintG.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintG.xbm'
fi
if test -f 'bitmaps/paintH.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintH.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintH.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintH.xbm' <<'END_OF_FILE'
X#define paintH_width 16
X#define paintH_height 16
Xstatic char paintH_bits[] = {
X   0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
X   0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x80};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintH.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintH.xbm'`; then
    echo shar: \"'bitmaps/paintH.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintH.xbm'
fi
if test -f 'bitmaps/paintI.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintI.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintI.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintI.xbm' <<'END_OF_FILE'
X#define paintI_width 16
X#define paintI_height 16
Xstatic char paintI_bits[] = {
X   0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04,
X   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x10, 0x00,
X   0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintI.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintI.xbm'`; then
    echo shar: \"'bitmaps/paintI.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintI.xbm'
fi
if test -f 'bitmaps/paintJ.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintJ.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintJ.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintJ.xbm' <<'END_OF_FILE'
X#define paintJ_width 16
X#define paintJ_height 16
Xstatic char paintJ_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintJ.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintJ.xbm'`; then
    echo shar: \"'bitmaps/paintJ.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintJ.xbm'
fi
if test -f 'bitmaps/paintK.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/paintK.xbm'\"
else
echo shar: Extracting \"'bitmaps/paintK.xbm'\" \(281 characters\)
sed "s/^X//" >'bitmaps/paintK.xbm' <<'END_OF_FILE'
X#define paintK_width 16
X#define paintK_height 16
Xstatic char paintK_bits[] = {
X   0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
X   0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
X   0x80, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/paintK.xbm'\"
if test 282 -ne `wc -c <'bitmaps/paintK.xbm'`; then
    echo shar: \"'bitmaps/paintK.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/paintK.xbm'
fi
if test -f 'bitmaps/pattern3.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/pattern3.xbm'\"
else
echo shar: Extracting \"'bitmaps/pattern3.xbm'\" \(887 characters\)
sed "s/^X//" >'bitmaps/pattern3.xbm' <<'END_OF_FILE'
X#define pattern3_width 32
X#define pattern3_height 32
Xstatic char pattern3_bits[] = {
X   0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44,
X   0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88,
X   0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44,
X   0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88,
X   0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44,
X   0x22, 0x22, 0x22, 0x22, 0x11, 0x11, 0x11, 0x11, 0x88, 0x88, 0x88, 0x88,
X   0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/pattern3.xbm'\"
if test 888 -ne `wc -c <'bitmaps/pattern3.xbm'`; then
    echo shar: \"'bitmaps/pattern3.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/pattern3.xbm'
fi
if test -f 'bitmaps/pattern7.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/pattern7.xbm'\"
else
echo shar: Extracting \"'bitmaps/pattern7.xbm'\" \(887 characters\)
sed "s/^X//" >'bitmaps/pattern7.xbm' <<'END_OF_FILE'
X#define pattern7_width 32
X#define pattern7_height 32
Xstatic char pattern7_bits[] = {
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x44, 0x44, 0x44, 0x44,
X   0x88, 0x88, 0x88, 0x88, 0x44, 0x44, 0x44, 0x44, 0x22, 0x22, 0x22, 0x22,
X   0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/pattern7.xbm'\"
if test 888 -ne `wc -c <'bitmaps/pattern7.xbm'`; then
    echo shar: \"'bitmaps/pattern7.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/pattern7.xbm'
fi
if test -f 'bitmaps/pattern8.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/pattern8.xbm'\"
else
echo shar: Extracting \"'bitmaps/pattern8.xbm'\" \(887 characters\)
sed "s/^X//" >'bitmaps/pattern8.xbm' <<'END_OF_FILE'
X#define pattern8_width 32
X#define pattern8_height 32
Xstatic char pattern8_bits[] = {
X   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
X   0xff, 0xff, 0xff, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
X   0x10, 0x10, 0x10, 0x10, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01,
X   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff,
X   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
X   0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
X   0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0x10, 0x10, 0x10, 0x10,
X   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0xff, 0xff, 0xff,
X   0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
X   0xff, 0xff, 0xff, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
X   0x10, 0x10, 0x10, 0x10, 0xff, 0xff, 0xff, 0xff};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/pattern8.xbm'\"
if test 888 -ne `wc -c <'bitmaps/pattern8.xbm'`; then
    echo shar: \"'bitmaps/pattern8.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/pattern8.xbm'
fi
if test -f 'bitmaps/pattern9.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/pattern9.xbm'\"
else
echo shar: Extracting \"'bitmaps/pattern9.xbm'\" \(887 characters\)
sed "s/^X//" >'bitmaps/pattern9.xbm' <<'END_OF_FILE'
X#define pattern9_width 32
X#define pattern9_height 32
Xstatic char pattern9_bits[] = {
X   0x1c, 0x1c, 0x1c, 0x1c, 0x22, 0x22, 0x22, 0x22, 0x41, 0x41, 0x41, 0x41,
X   0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x22, 0x22, 0x22, 0x22,
X   0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0xc1, 0xc1, 0xc1, 0xc1,
X   0x22, 0x22, 0x22, 0x22, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
X   0x14, 0x14, 0x14, 0x14, 0x22, 0x22, 0x22, 0x22, 0xc1, 0xc1, 0xc1, 0xc1,
X   0x00, 0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x22, 0x22, 0x22, 0x22,
X   0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,
X   0x22, 0x22, 0x22, 0x22, 0x1c, 0x1c, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00,
X   0xc1, 0xc1, 0xc1, 0xc1, 0x22, 0x22, 0x22, 0x22, 0x14, 0x14, 0x14, 0x14,
X   0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x22, 0x22, 0x22, 0x22,
X   0xc1, 0xc1, 0xc1, 0xc1, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/pattern9.xbm'\"
if test 888 -ne `wc -c <'bitmaps/pattern9.xbm'`; then
    echo shar: \"'bitmaps/pattern9.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/pattern9.xbm'
fi
if test -f 'bitmaps/polyOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/polyOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/polyOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/polyOp.xbm' <<'END_OF_FILE'
X#define polyOp_width 32
X#define polyOp_height 32
Xstatic char polyOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x01, 0x20, 0x01,
X   0x00, 0x07, 0x18, 0x02, 0x80, 0x18, 0x04, 0x02, 0x80, 0x60, 0x03, 0x02,
X   0x80, 0x80, 0x00, 0x02, 0x40, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 0x04,
X   0x20, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04,
X   0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x08,
X   0x08, 0x00, 0x00, 0x08, 0xf8, 0x03, 0x00, 0x10, 0x00, 0xfc, 0x3f, 0x10,
X   0x00, 0x00, 0xc0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/polyOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/polyOp.xbm'`; then
    echo shar: \"'bitmaps/polyOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/polyOp.xbm'
fi
if test -f 'bitmaps/sprayOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/sprayOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/sprayOp.xbm'\" \(884 characters\)
sed "s/^X//" >'bitmaps/sprayOp.xbm' <<'END_OF_FILE'
X#define sprayOp_width 32
X#define sprayOp_height 32
Xstatic char sprayOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00,
X   0x00, 0x00, 0x54, 0x00, 0x00, 0x98, 0x40, 0x00, 0x00, 0xb8, 0x14, 0x03,
X   0x00, 0x08, 0x10, 0x00, 0x00, 0x88, 0x05, 0x01, 0x00, 0x1c, 0x44, 0x00,
X   0x00, 0x22, 0x50, 0x00, 0x00, 0x41, 0x00, 0x00, 0x80, 0x80, 0x20, 0x01,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00,
X   0x80, 0x80, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x80, 0xff, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/sprayOp.xbm'\"
if test 885 -ne `wc -c <'bitmaps/sprayOp.xbm'`; then
    echo shar: \"'bitmaps/sprayOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/sprayOp.xbm'
fi
if test -f 'bitmaps/textOp.xbm' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bitmaps/textOp.xbm'\"
else
echo shar: Extracting \"'bitmaps/textOp.xbm'\" \(881 characters\)
sed "s/^X//" >'bitmaps/textOp.xbm' <<'END_OF_FILE'
X#define textOp_width 32
X#define textOp_height 32
Xstatic char textOp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x80, 0x10, 0x00,
X   0x00, 0x80, 0x10, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00, 0x40, 0x20, 0x00,
X   0x00, 0x40, 0x20, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00, 0x20, 0x40, 0x00,
X   0x00, 0x20, 0x40, 0x00, 0x00, 0x20, 0x40, 0x00, 0x00, 0x20, 0x40, 0x00,
X   0x00, 0xf0, 0xff, 0x00, 0x00, 0x10, 0x80, 0x00, 0x00, 0x10, 0x80, 0x00,
X   0x00, 0x10, 0x80, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01,
X   0x00, 0x08, 0x00, 0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x04, 0x00, 0x02,
X   0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

END_OF_FILE
echo shar: NEWLINE appended to \"'bitmaps/textOp.xbm'\"
if test 882 -ne `wc -c <'bitmaps/textOp.xbm'`; then
    echo shar: \"'bitmaps/textOp.xbm'\" unpacked with wrong size!
fi
# end of 'bitmaps/textOp.xbm'
fi
echo shar: End of archive 5 \(of 5\).
cp /dev/null ark5isdone
MISSING=""
for I in 1 2 3 4 5 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 5 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
-- 
name : David Koblas                        domain: koblas@mips.com
quote: If you have sex in your car, does that make it a recreational vehicle?