#! /bin/sh
## This is a shell archive. Remove anything before this line, then unpack
## it by saving it into a file and typing "sh file". To overwrite existing
## files, type "sh file -c". You can also feed this as standard input via
## unshar, or by typing "sh <file". If this archive is complete, you will
## see the following message at the end:

# "End of archive 3 (of 3)."
# Contents: bMine.xbm bMineSm.xbm bSafe.xbm bSafeSm.xbm e0.xbm
# e0Sm.xbm e1.xbm e1Sm.xbm e2.xbm e2Sm.xbm e3.xbm e3Sm.xbm e4.xbm
# e4Sm.xbm e5.xbm e5Sm.xbm e6.xbm e6Sm.xbm e7.xbm e7Sm.xbm e8.xbm
# e8Sm.xbm hMine.xbm hMineSm.xbm mine.xbm mineSm.xbm pl0.xbm
# pl0Sm.xbm pl1.xbm pl1Sm.xbm pl2.xbm pl2Sm.xbm pl3.xbm pl3Sm.xbm
# pl4.xbm pl4Sm.xbm pl5.xbm pl5Sm.xbm pl6.xbm pl6Sm.xbm pl7.xbm
# pl7Sm.xbm pl8.xbm pl8Sm.xbm safe.xbm safeSm.xbm
# Wrapped by jimmc@ss on Mon Sep 10 09:43:11 1990


PATH=/bin:/usr/bin:/usr/ucb ; export PATH

if test -f bMine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bMine.xbm\"
else
echo shar: Extracting \"bMine.xbm\" \(741 characters\)
sed "s/^X//" >bMine.xbm <<'END_OF_bMine.xbm'
X#define badmine_width 32
X#define badmine_height 32
Xstatic char badmine_bits[] = {
X 0x00,0x00,0x00,0x00,0xf8,0xff,0xff,0x1f,0xf0,0xff,0xff,0x0f,0xe2,0xff,0xff,
X 0x47,0x46,0xfe,0xff,0x63,0x0e,0xfd,0xff,0x71,0x1e,0xcf,0xff,0x78,0x3a,0xda,
X 0x7f,0x7c,0x46,0xf4,0x3f,0x7e,0x5e,0xf8,0x1f,0x7f,0x7e,0xf9,0x8f,0x7f,0x7e,
X 0xff,0xcf,0x7f,0xfa,0x38,0xf8,0x7f,0xc6,0x10,0xe0,0x7f,0xfe,0x20,0xc0,0x7f,
X 0xfe,0x21,0x80,0x7f,0xfe,0x23,0x00,0x7f,0xfe,0x1d,0x00,0x7f,0xfe,0x00,0x00,
X 0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,0x00,0x7e,0xfe,0x00,
X 0x00,0x7e,0xfe,0x01,0x00,0x7f,0x3e,0x01,0x00,0x7f,0x1e,0x03,0x80,0x79,0x8e,
X 0x07,0xc0,0x71,0xc6,0x0f,0xe0,0x63,0xe2,0x3f,0xf8,0x47,0xf0,0xff,0xff,0x0f,
X 0xf8,0xff,0xff,0x1f,0x00,0x00,0x00,0x00};
END_OF_bMine.xbm
if test 741 -ne `wc -c <bMine.xbm`; then
echo shar: \"bMine.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f bMineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bMineSm.xbm\"
else
echo shar: Extracting \"bMineSm.xbm\" \(359 characters\)
sed "s/^X//" >bMineSm.xbm <<'END_OF_bMineSm.xbm'
X#define badmineSmall_width 16
X#define badmineSmall_height 16
X#define badmineSmall_x_hot -1
X#define badmineSmall_y_hot -1
Xstatic char badmineSmall_bits[] = {
X 0x00, 0x00, 0x7e, 0x7f, 0xb2, 0x5f, 0xf6, 0x6d, 0xce, 0x76, 0xd2, 0x7b,
X 0xbe, 0x7b, 0x36, 0x7c, 0x3a, 0x78, 0x1e, 0x70, 0x1e, 0x70, 0x0e, 0x70,
X 0x36, 0x68, 0x7a, 0x5c, 0xfe, 0x7f, 0x00, 0x00};
END_OF_bMineSm.xbm
if test 359 -ne `wc -c <bMineSm.xbm`; then
echo shar: \"bMineSm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f bSafe.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bSafe.xbm\"
else
echo shar: Extracting \"bSafe.xbm\" \(741 characters\)
sed "s/^X//" >bSafe.xbm <<'END_OF_bSafe.xbm'
X#define badsafe_width 32
X#define badsafe_height 32
Xstatic char badsafe_bits[] = {
X 0x00,0x00,0x00,0x00,0xf8,0xff,0xff,0x1f,0xf0,0xff,0xff,0x0f,0xe2,0xff,0xff,
X 0x47,0xc6,0xff,0xff,0x63,0x8e,0xff,0xff,0x71,0x1e,0xff,0xff,0x78,0x3e,0xfe,
X 0x7f,0x7c,0x7e,0xfc,0x3f,0x7e,0xfe,0xf8,0x1f,0x7f,0xfe,0xf1,0x8f,0x7f,0xfe,
X 0xf3,0xcd,0x7f,0xfe,0xff,0xfd,0x7f,0xfe,0xc7,0xed,0x7f,0xfe,0xbb,0xf5,0x7f,
X 0xfe,0xbb,0xf9,0x7f,0xfe,0xbb,0xf9,0x7f,0xfe,0xbb,0xf5,0x7f,0xfe,0xbb,0xed,
X 0x7f,0xfe,0xc7,0xdd,0x7f,0xfe,0xff,0xff,0x7f,0xfe,0xf9,0x9f,0x7f,0xfe,0xf8,
X 0x1f,0x7f,0x7e,0xfc,0x3f,0x7e,0x3e,0xfe,0x7f,0x7c,0x1e,0xff,0xff,0x78,0x8e,
X 0xff,0xff,0x71,0xc6,0xff,0xff,0x63,0xe2,0xff,0xff,0x47,0xf0,0xff,0xff,0x0f,
X 0xf8,0xff,0xff,0x1f,0x00,0x00,0x00,0x00};
END_OF_bSafe.xbm
if test 741 -ne `wc -c <bSafe.xbm`; then
echo shar: \"bSafe.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f bSafeSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"bSafeSm.xbm\"
else
echo shar: Extracting \"bSafeSm.xbm\" \(359 characters\)
sed "s/^X//" >bSafeSm.xbm <<'END_OF_bSafeSm.xbm'
X#define badsafeSmall_width 16
X#define badsafeSmall_height 16
X#define badsafeSmall_x_hot -1
X#define badsafeSmall_y_hot -1
Xstatic char badsafeSmall_bits[] = {
X 0x00, 0x00, 0xfe, 0x7f, 0xfa, 0x5f, 0xf6, 0x6f, 0xee, 0x47, 0xde, 0x43,
X 0xbe, 0x41, 0x7e, 0x70, 0x7e, 0x79, 0xa6, 0x7c, 0x4e, 0x7a, 0x1e, 0x77,
X 0xb6, 0x6f, 0xba, 0x5f, 0xfe, 0x7f, 0x00, 0x00};
END_OF_bSafeSm.xbm
if test 359 -ne `wc -c <bSafeSm.xbm`; then
echo shar: \"bSafeSm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e0.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e0.xbm\"
else
echo shar: Extracting \"e0.xbm\" \(732 characters\)
sed "s/^X//" >e0.xbm <<'END_OF_e0.xbm'
X#define zero_width 32
X#define zero_height 32
Xstatic char zero_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x82,0x83,0xaa,0x55,0x41,0x44,0x95,0xa9,0x42,0x84,0xaa,0x55,0x41,0x46,0x95,
X 0xa9,0x42,0x85,0xaa,0x55,0xc1,0x44,0x95,0xa9,0x42,0x84,0xaa,0x55,0x41,0x44,
X 0x95,0xa9,0x82,0x83,0xaa,0x55,0x01,0x40,0x95,0xa9,0x02,0x80,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e0.xbm
if test 732 -ne `wc -c <e0.xbm`; then
echo shar: \"e0.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e0Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e0Sm.xbm\"
else
echo shar: Extracting \"e0Sm.xbm\" \(344 characters\)
sed "s/^X//" >e0Sm.xbm <<'END_OF_e0Sm.xbm'
X#define zeroSmall_width 16
X#define zeroSmall_height 16
X#define zeroSmall_x_hot -1
X#define zeroSmall_y_hot -1
Xstatic char zeroSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x49, 0xa2, 0x45, 0x92, 0x49, 0xa2, 0x85, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e0Sm.xbm
if test 344 -ne `wc -c <e0Sm.xbm`; then
echo shar: \"e0Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e1.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e1.xbm\"
else
echo shar: Extracting \"e1.xbm\" \(729 characters\)
sed "s/^X//" >e1.xbm <<'END_OF_e1.xbm'
X#define one_width 32
X#define one_height 32
Xstatic char one_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x82,0xa0,0xaa,0x55,0xc1,0x40,0x95,0xa9,0xa2,0xa0,0xaa,0x55,0x81,0x40,0x95,
X 0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,0x95,0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,
X 0x95,0xa9,0xe2,0xa3,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e1.xbm
if test 729 -ne `wc -c <e1.xbm`; then
echo shar: \"e1.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e1Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e1Sm.xbm\"
else
echo shar: Extracting \"e1Sm.xbm\" \(339 characters\)
sed "s/^X//" >e1Sm.xbm <<'END_OF_e1Sm.xbm'
X#define oneSmall_width 16
X#define oneSmall_height 16
X#define oneSmall_x_hot -1
X#define oneSmall_y_hot -1
Xstatic char oneSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x09, 0xa1,
X 0x05, 0x91, 0x09, 0xa1, 0x05, 0x91, 0x09, 0xa1, 0x05, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e1Sm.xbm
if test 339 -ne `wc -c <e1Sm.xbm`; then
echo shar: \"e1Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e2.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e2.xbm\"
else
echo shar: Extracting \"e2.xbm\" \(729 characters\)
sed "s/^X//" >e2.xbm <<'END_OF_e2.xbm'
X#define two_width 32
X#define two_height 32
Xstatic char two_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,
X 0xa9,0x02,0xa1,0xaa,0x55,0x81,0x40,0x95,0xa9,0x42,0xa0,0xaa,0x55,0x21,0x40,
X 0x95,0xa9,0xe2,0xa3,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e2.xbm
if test 729 -ne `wc -c <e2.xbm`; then
echo shar: \"e2.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e2Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e2Sm.xbm\"
else
echo shar: Extracting \"e2Sm.xbm\" \(339 characters\)
sed "s/^X//" >e2Sm.xbm <<'END_OF_e2Sm.xbm'
X#define twoSmall_width 16
X#define twoSmall_height 16
X#define twoSmall_x_hot -1
X#define twoSmall_y_hot -1
Xstatic char twoSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x09, 0xa1, 0x85, 0x90, 0x49, 0xa0, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e2Sm.xbm
if test 339 -ne `wc -c <e2Sm.xbm`; then
echo shar: \"e2Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e3.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e3.xbm\"
else
echo shar: Extracting \"e3.xbm\" \(735 characters\)
sed "s/^X//" >e3.xbm <<'END_OF_e3.xbm'
X#define three_width 32
X#define three_height 32
Xstatic char three_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,
X 0xa9,0x82,0xa1,0xaa,0x55,0x01,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e3.xbm
if test 735 -ne `wc -c <e3.xbm`; then
echo shar: \"e3.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e3Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e3Sm.xbm\"
else
echo shar: Extracting \"e3Sm.xbm\" \(349 characters\)
sed "s/^X//" >e3Sm.xbm <<'END_OF_e3Sm.xbm'
X#define threeSmall_width 16
X#define threeSmall_height 16
X#define threeSmall_x_hot -1
X#define threeSmall_y_hot -1
Xstatic char threeSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x05, 0x92, 0xc9, 0xa3, 0x05, 0x92, 0x09, 0xa2, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e3Sm.xbm
if test 349 -ne `wc -c <e3Sm.xbm`; then
echo shar: \"e3Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e4.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e4.xbm\"
else
echo shar: Extracting \"e4.xbm\" \(732 characters\)
sed "s/^X//" >e4.xbm <<'END_OF_e4.xbm'
X#define four_width 32
X#define four_height 32
Xstatic char four_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0x02,0x82,0xaa,0x55,0x01,0x43,0x95,0xa9,0x82,0x82,0xaa,0x55,0x41,0x42,0x95,
X 0xa9,0x22,0x82,0xaa,0x55,0x21,0x42,0x95,0xa9,0xe2,0x87,0xaa,0x55,0x01,0x42,
X 0x95,0xa9,0x02,0x82,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e4.xbm
if test 732 -ne `wc -c <e4.xbm`; then
echo shar: \"e4.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e4Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e4Sm.xbm\"
else
echo shar: Extracting \"e4Sm.xbm\" \(344 characters\)
sed "s/^X//" >e4Sm.xbm <<'END_OF_e4Sm.xbm'
X#define fourSmall_width 16
X#define fourSmall_height 16
X#define fourSmall_x_hot -1
X#define fourSmall_y_hot -1
Xstatic char fourSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x49, 0xa2,
X 0x45, 0x92, 0x49, 0xa2, 0xc5, 0x93, 0x09, 0xa2, 0x05, 0x92, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e4Sm.xbm
if test 344 -ne `wc -c <e4Sm.xbm`; then
echo shar: \"e4Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e5.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e5.xbm\"
else
echo shar: Extracting \"e5.xbm\" \(732 characters\)
sed "s/^X//" >e5.xbm <<'END_OF_e5.xbm'
X#define five_width 32
X#define five_height 32
Xstatic char five_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xe2,0xa3,0xaa,0x55,0x21,0x40,0x95,0xa9,0x22,0xa0,0xaa,0x55,0xe1,0x41,0x95,
X 0xa9,0x02,0xa2,0xaa,0x55,0x01,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e5.xbm
if test 732 -ne `wc -c <e5.xbm`; then
echo shar: \"e5.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e5Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e5Sm.xbm\"
else
echo shar: Extracting \"e5Sm.xbm\" \(344 characters\)
sed "s/^X//" >e5Sm.xbm <<'END_OF_e5Sm.xbm'
X#define fiveSmall_width 16
X#define fiveSmall_height 16
X#define fiveSmall_x_hot -1
X#define fiveSmall_y_hot -1
Xstatic char fiveSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x45, 0x90, 0xc9, 0xa1, 0x05, 0x92, 0x09, 0xa2, 0xc5, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e5Sm.xbm
if test 344 -ne `wc -c <e5Sm.xbm`; then
echo shar: \"e5Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e6.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e6.xbm\"
else
echo shar: Extracting \"e6.xbm\" \(729 characters\)
sed "s/^X//" >e6.xbm <<'END_OF_e6.xbm'
X#define six_width 32
X#define six_height 32
Xstatic char six_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa0,0xaa,0x55,0x21,0x40,0x95,
X 0xa9,0xe2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e6.xbm
if test 729 -ne `wc -c <e6.xbm`; then
echo shar: \"e6.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e6Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e6Sm.xbm\"
else
echo shar: Extracting \"e6Sm.xbm\" \(339 characters\)
sed "s/^X//" >e6Sm.xbm <<'END_OF_e6Sm.xbm'
X#define sixSmall_width 16
X#define sixSmall_height 16
X#define sixSmall_x_hot -1
X#define sixSmall_y_hot -1
Xstatic char sixSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x49, 0xa0,
X 0x45, 0x90, 0x49, 0xa0, 0xc5, 0x93, 0x49, 0xa2, 0xc5, 0x93, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e6Sm.xbm
if test 339 -ne `wc -c <e6Sm.xbm`; then
echo shar: \"e6Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e7.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e7.xbm\"
else
echo shar: Extracting \"e7.xbm\" \(735 characters\)
sed "s/^X//" >e7.xbm <<'END_OF_e7.xbm'
X#define seven_width 32
X#define seven_height 32
Xstatic char seven_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xe2,0xa3,0xaa,0x55,0x21,0x42,0x95,0xa9,0x02,0xa2,0xaa,0x55,0x01,0x41,0x95,
X 0xa9,0x02,0xa1,0xaa,0x55,0x01,0x41,0x95,0xa9,0x82,0xa0,0xaa,0x55,0x81,0x40,
X 0x95,0xa9,0x82,0xa0,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e7.xbm
if test 735 -ne `wc -c <e7.xbm`; then
echo shar: \"e7.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e7Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e7Sm.xbm\"
else
echo shar: Extracting \"e7Sm.xbm\" \(349 characters\)
sed "s/^X//" >e7Sm.xbm <<'END_OF_e7Sm.xbm'
X#define sevenSmall_width 16
X#define sevenSmall_height 16
X#define sevenSmall_x_hot -1
X#define sevenSmall_y_hot -1
Xstatic char sevenSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0xc9, 0xa3,
X 0x05, 0x92, 0x09, 0xa1, 0x05, 0x91, 0x89, 0xa0, 0x85, 0x90, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e7Sm.xbm
if test 349 -ne `wc -c <e7Sm.xbm`; then
echo shar: \"e7Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e8.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e8.xbm\"
else
echo shar: Extracting \"e8.xbm\" \(735 characters\)
sed "s/^X//" >e8.xbm <<'END_OF_e8.xbm'
X#define eight_width 32
X#define eight_height 32
Xstatic char eight_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,
X 0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,
X 0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x01,0x40,0x95,0xa9,
X 0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,0x95,
X 0xa9,0xc2,0xa1,0xaa,0x55,0x21,0x42,0x95,0xa9,0x22,0xa2,0xaa,0x55,0x21,0x42,
X 0x95,0xa9,0xc2,0xa1,0xaa,0x55,0x01,0x40,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,
X 0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,
X 0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,0x55,0x55,0x55,0x95,0xa9,0xaa,0xaa,0xaa,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_e8.xbm
if test 735 -ne `wc -c <e8.xbm`; then
echo shar: \"e8.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f e8Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"e8Sm.xbm\"
else
echo shar: Extracting \"e8Sm.xbm\" \(349 characters\)
sed "s/^X//" >e8Sm.xbm <<'END_OF_e8Sm.xbm'
X#define eightSmall_width 16
X#define eightSmall_height 16
X#define eightSmall_x_hot -1
X#define eightSmall_y_hot -1
Xstatic char eightSmall_bits[] = {
X 0xff, 0xff, 0x01, 0x80, 0x55, 0x95, 0xa9, 0xaa, 0x05, 0x90, 0x89, 0xa1,
X 0x45, 0x92, 0x89, 0xa1, 0x45, 0x92, 0x49, 0xa2, 0x85, 0x91, 0x09, 0xa0,
X 0x55, 0x95, 0xa9, 0xaa, 0x01, 0x80, 0xff, 0xff};
END_OF_e8Sm.xbm
if test 349 -ne `wc -c <e8Sm.xbm`; then
echo shar: \"e8Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f hMine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"hMine.xbm\"
else
echo shar: Extracting \"hMine.xbm\" \(750 characters\)
sed "s/^X//" >hMine.xbm <<'END_OF_hMine.xbm'
X#define hiddenmine_width 32
X#define hiddenmine_height 32
Xstatic char hiddenmine_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x81,0x01,0x00,0x80,0xa1,0x02,0x00,0x80,0x21,0x30,0x00,0x80,0x05,0x24,
X 0x00,0x80,0x39,0x09,0x00,0x80,0xa1,0x00,0x00,0x80,0x81,0x00,0x00,0x80,0x81,
X 0x00,0x00,0x80,0x05,0xc7,0x07,0x80,0x39,0xef,0x1f,0x80,0x01,0xdf,0x3f,0x80,
X 0x01,0xde,0x7f,0x80,0x01,0xdc,0xff,0x80,0x01,0x62,0xfc,0x80,0x01,0x3f,0xf8,
X 0x81,0x01,0x1f,0xf0,0x81,0x01,0x0f,0xe0,0x81,0x01,0x0f,0xe0,0x81,0x01,0x0f,
X 0xe0,0x81,0x01,0x1e,0xf0,0x80,0x01,0x3e,0xf8,0x80,0x01,0x7c,0x7c,0x80,0x01,
X 0xf8,0x3f,0x80,0x01,0xf0,0x1f,0x80,0x01,0xc0,0x07,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_hMine.xbm
if test 750 -ne `wc -c <hMine.xbm`; then
echo shar: \"hMine.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f hMineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"hMineSm.xbm\"
else
echo shar: Extracting \"hMineSm.xbm\" \(273 characters\)
sed "s/^X//" >hMineSm.xbm <<'END_OF_hMineSm.xbm'
X#define hiddenmineSmall_width 16
X#define hiddenmineSmall_height 16
Xstatic char hiddenmineSmall_bits[] = {
X 0xff,0xff,0x81,0x80,0x49,0x80,0x01,0x82,0x21,0x81,0x2d,0x80,0x41,0x80,0xc9,
X 0x83,0xc5,0x87,0xe1,0x8e,0x61,0x8c,0xe1,0x8e,0xc1,0x87,0x81,0x83,0x01,0x80,
X 0xff,0xff};
END_OF_hMineSm.xbm
if test 273 -ne `wc -c <hMineSm.xbm`; then
echo shar: \"hMineSm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f mine.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mine.xbm\"
else
echo shar: Extracting \"mine.xbm\" \(732 characters\)
sed "s/^X//" >mine.xbm <<'END_OF_mine.xbm'
X#define mine_width 32
X#define mine_height 32
Xstatic char mine_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x81,0x01,0x00,0x80,0xa1,0x02,0x00,0x80,0x21,0x30,0x00,0x80,0x05,0x24,
X 0x00,0x80,0x39,0x09,0x00,0x80,0xa1,0x00,0x00,0x80,0x81,0x00,0x00,0x80,0x81,
X 0x00,0x00,0x80,0x05,0xc7,0x07,0x80,0x39,0xef,0x1f,0x80,0x01,0xdf,0x3f,0x80,
X 0x01,0xde,0x7f,0x80,0x01,0xdc,0xff,0x80,0x01,0xe2,0xff,0x80,0x01,0xff,0xff,
X 0x81,0x01,0xff,0xff,0x81,0x01,0xff,0xff,0x81,0x01,0xff,0xff,0x81,0x01,0xff,
X 0xff,0x81,0x01,0xfe,0xff,0x80,0x01,0xfe,0xff,0x80,0x01,0xfc,0x7f,0x80,0x01,
X 0xf8,0x3f,0x80,0x01,0xf0,0x1f,0x80,0x01,0xc0,0x07,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_mine.xbm
if test 732 -ne `wc -c <mine.xbm`; then
echo shar: \"mine.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f mineSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"mineSm.xbm\"
else
echo shar: Extracting \"mineSm.xbm\" \(255 characters\)
sed "s/^X//" >mineSm.xbm <<'END_OF_mineSm.xbm'
X#define mineSmall_width 16
X#define mineSmall_height 16
Xstatic char mineSmall_bits[] = {
X 0xff,0xff,0x81,0x80,0x49,0x80,0x01,0x82,0x21,0x81,0x2d,0x80,0x41,0x80,0xc9,
X 0x83,0xc5,0x87,0xe1,0x8f,0xe1,0x8f,0xe1,0x8f,0xc1,0x87,0x81,0x83,0x01,0x80,
X 0xff,0xff};
END_OF_mineSm.xbm
if test 255 -ne `wc -c <mineSm.xbm`; then
echo shar: \"mineSm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl0.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl0.xbm\"
else
echo shar: Extracting \"pl0.xbm\" \(738 characters\)
sed "s/^X//" >pl0.xbm <<'END_OF_pl0.xbm'
X#define plZero_width 32
X#define plZero_height 32
Xstatic char plZero_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,0x80,0x01,0x04,0x10,
X 0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x90,0x81,0x01,0x04,0x50,0x81,0x01,0x04,
X 0x30,0x81,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0xe0,0x80,0x81,
X 0x20,0x00,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl0.xbm
if test 738 -ne `wc -c <pl0.xbm`; then
echo shar: \"pl0.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl0Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl0Sm.xbm\"
else
echo shar: Extracting \"pl0Sm.xbm\" \(261 characters\)
sed "s/^X//" >pl0Sm.xbm <<'END_OF_pl0Sm.xbm'
X#define plZeroSmall_width 16
X#define plZeroSmall_height 16
Xstatic char plZeroSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0xa4,0x71,0xa4,0x71,0xa4,0x89,0x98,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl0Sm.xbm
if test 261 -ne `wc -c <pl0Sm.xbm`; then
echo shar: \"pl0Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl1.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl1.xbm\"
else
echo shar: Extracting \"pl1.xbm\" \(735 characters\)
sed "s/^X//" >pl1.xbm <<'END_OF_pl1.xbm'
X#define plOne_width 32
X#define plOne_height 32
Xstatic char plOne_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x40,
X 0x80,0x01,0x04,0x60,0x80,0x01,0x04,0x50,0x80,0x01,0x04,0x40,0x80,0x01,0x04,
X 0x40,0x80,0x01,0x0a,0x40,0x80,0x01,0x11,0x40,0x80,0x01,0x11,0x40,0x80,0x81,
X 0x20,0xf0,0x81,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl1.xbm
if test 735 -ne `wc -c <pl1.xbm`; then
echo shar: \"pl1.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl1Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl1Sm.xbm\"
else
echo shar: Extracting \"pl1Sm.xbm\" \(258 characters\)
sed "s/^X//" >pl1Sm.xbm <<'END_OF_pl1Sm.xbm'
X#define plOneSmall_width 16
X#define plOneSmall_height 16
Xstatic char plOneSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x90,0x25,0x91,0x21,0x90,0x71,0x90,0x71,0x90,0x89,0x90,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl1Sm.xbm
if test 258 -ne `wc -c <pl1Sm.xbm`; then
echo shar: \"pl1Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl2.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl2.xbm\"
else
echo shar: Extracting \"pl2.xbm\" \(735 characters\)
sed "s/^X//" >pl2.xbm <<'END_OF_pl2.xbm'
X#define plTwo_width 32
X#define plTwo_height 32
Xstatic char plTwo_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x00,0x81,0x01,0x04,
X 0x80,0x80,0x01,0x0a,0x40,0x80,0x01,0x11,0x20,0x80,0x01,0x11,0x10,0x80,0x81,
X 0x20,0xf0,0x81,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl2.xbm
if test 735 -ne `wc -c <pl2.xbm`; then
echo shar: \"pl2.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl2Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl2Sm.xbm\"
else
echo shar: Extracting \"pl2Sm.xbm\" \(258 characters\)
sed "s/^X//" >pl2Sm.xbm <<'END_OF_pl2Sm.xbm'
X#define plTwoSmall_width 16
X#define plTwoSmall_height 16
Xstatic char plTwoSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0x90,0x71,0x88,0x71,0x84,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl2Sm.xbm
if test 258 -ne `wc -c <pl2Sm.xbm`; then
echo shar: \"pl2Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl3.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl3.xbm\"
else
echo shar: Extracting \"pl3.xbm\" \(741 characters\)
sed "s/^X//" >pl3.xbm <<'END_OF_pl3.xbm'
X#define plThree_width 32
X#define plThree_height 32
Xstatic char plThree_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x00,0x81,0x01,0x04,
X 0xc0,0x80,0x01,0x0a,0x00,0x81,0x01,0x11,0x00,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl3.xbm
if test 741 -ne `wc -c <pl3.xbm`; then
echo shar: \"pl3.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl3Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl3Sm.xbm\"
else
echo shar: Extracting \"pl3Sm.xbm\" \(264 characters\)
sed "s/^X//" >pl3Sm.xbm <<'END_OF_pl3Sm.xbm'
X#define plThreeSmall_width 16
X#define plThreeSmall_height 16
Xstatic char plThreeSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0xa1,0x21,0xbc,0x71,0xa0,0x71,0xa0,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl3Sm.xbm
if test 264 -ne `wc -c <pl3Sm.xbm`; then
echo shar: \"pl3Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl4.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl4.xbm\"
else
echo shar: Extracting \"pl4.xbm\" \(738 characters\)
sed "s/^X//" >pl4.xbm <<'END_OF_pl4.xbm'
X#define plFour_width 32
X#define plFour_height 32
Xstatic char plFour_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x80,
X 0x80,0x01,0x04,0xc0,0x80,0x01,0x04,0xa0,0x80,0x01,0x04,0x90,0x80,0x01,0x04,
X 0x88,0x80,0x01,0x0a,0x88,0x80,0x01,0x11,0xf8,0x81,0x01,0x11,0x80,0x80,0x81,
X 0x20,0x80,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl4.xbm
if test 738 -ne `wc -c <pl4.xbm`; then
echo shar: \"pl4.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl4Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl4Sm.xbm\"
else
echo shar: Extracting \"pl4Sm.xbm\" \(261 characters\)
sed "s/^X//" >pl4Sm.xbm <<'END_OF_pl4Sm.xbm'
X#define plFourSmall_width 16
X#define plFourSmall_height 16
Xstatic char plFourSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xa4,0x25,0xa5,0x21,0xa4,0x71,0xbc,0x71,0xa0,0x89,0xa0,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl4Sm.xbm
if test 261 -ne `wc -c <pl4Sm.xbm`; then
echo shar: \"pl4Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl5.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl5.xbm\"
else
echo shar: Extracting \"pl5.xbm\" \(738 characters\)
sed "s/^X//" >pl5.xbm <<'END_OF_pl5.xbm'
X#define plFive_width 32
X#define plFive_height 32
Xstatic char plFive_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xf0,
X 0x81,0x01,0x04,0x10,0x80,0x01,0x04,0x10,0x80,0x01,0x04,0xf0,0x80,0x01,0x04,
X 0x00,0x81,0x01,0x0a,0x00,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl5.xbm
if test 738 -ne `wc -c <pl5.xbm`; then
echo shar: \"pl5.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl5Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl5Sm.xbm\"
else
echo shar: Extracting \"pl5Sm.xbm\" \(261 characters\)
sed "s/^X//" >pl5Sm.xbm <<'END_OF_pl5Sm.xbm'
X#define plFiveSmall_width 16
X#define plFiveSmall_height 16
Xstatic char plFiveSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0x85,0x21,0x9c,0x71,0xa0,0x71,0xa0,0x89,0x9c,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl5Sm.xbm
if test 261 -ne `wc -c <pl5Sm.xbm`; then
echo shar: \"pl5Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl6.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl6.xbm\"
else
echo shar: Extracting \"pl6.xbm\" \(735 characters\)
sed "s/^X//" >pl6.xbm <<'END_OF_pl6.xbm'
X#define plSix_width 32
X#define plSix_height 32
Xstatic char plSix_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x80,0x01,0x04,0x10,0x80,0x01,0x04,
X 0xf0,0x80,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl6.xbm
if test 735 -ne `wc -c <pl6.xbm`; then
echo shar: \"pl6.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl6Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl6Sm.xbm\"
else
echo shar: Extracting \"pl6Sm.xbm\" \(258 characters\)
sed "s/^X//" >pl6Sm.xbm <<'END_OF_pl6Sm.xbm'
X#define plSixSmall_width 16
X#define plSixSmall_height 16
Xstatic char plSixSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x84,0x25,0x85,0x21,0x84,0x71,0xbc,0x71,0xa4,0x89,0xbc,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl6Sm.xbm
if test 258 -ne `wc -c <pl6Sm.xbm`; then
echo shar: \"pl6Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl7.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl7.xbm\"
else
echo shar: Extracting \"pl7.xbm\" \(741 characters\)
sed "s/^X//" >pl7.xbm <<'END_OF_pl7.xbm'
X#define plSeven_width 32
X#define plSeven_height 32
Xstatic char plSeven_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xf0,
X 0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x00,0x81,0x01,0x04,0x80,0x80,0x01,0x04,
X 0x80,0x80,0x01,0x0a,0x80,0x80,0x01,0x11,0x40,0x80,0x01,0x11,0x40,0x80,0x81,
X 0x20,0x40,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl7.xbm
if test 741 -ne `wc -c <pl7.xbm`; then
echo shar: \"pl7.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl7Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl7Sm.xbm\"
else
echo shar: Extracting \"pl7Sm.xbm\" \(264 characters\)
sed "s/^X//" >pl7Sm.xbm <<'END_OF_pl7Sm.xbm'
X#define plSevenSmall_width 16
X#define plSevenSmall_height 16
Xstatic char plSevenSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0xbc,0x25,0xa1,0x21,0x90,0x71,0x90,0x71,0x88,0x89,0x88,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl7Sm.xbm
if test 264 -ne `wc -c <pl7Sm.xbm`; then
echo shar: \"pl7Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl8.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl8.xbm\"
else
echo shar: Extracting \"pl8.xbm\" \(741 characters\)
sed "s/^X//" >pl8.xbm <<'END_OF_pl8.xbm'
X#define plEight_width 32
X#define plEight_height 32
Xstatic char plEight_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x0e,
X 0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,0x11,0x00,0x80,0x01,
X 0x0e,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,
X 0x81,0x3f,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0x00,0x80,0x01,0x04,0xe0,
X 0x80,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x81,0x01,0x04,0x10,0x81,0x01,0x04,
X 0xe0,0x80,0x01,0x0a,0x10,0x81,0x01,0x11,0x10,0x81,0x01,0x11,0x10,0x81,0x81,
X 0x20,0xe0,0x80,0x41,0x40,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_pl8.xbm
if test 741 -ne `wc -c <pl8.xbm`; then
echo shar: \"pl8.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f pl8Sm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"pl8Sm.xbm\"
else
echo shar: Extracting \"pl8Sm.xbm\" \(264 characters\)
sed "s/^X//" >pl8Sm.xbm <<'END_OF_pl8Sm.xbm'
X#define plEightSmall_width 16
X#define plEightSmall_height 16
Xstatic char plEightSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x21,0x80,0x71,0x80,0x71,0x80,0x21,0x80,0x21,0x80,0xf9,
X 0x98,0x25,0xa5,0x21,0x98,0x71,0xa4,0x71,0xa4,0x89,0x98,0x89,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_pl8Sm.xbm
if test 264 -ne `wc -c <pl8Sm.xbm`; then
echo shar: \"pl8Sm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f safe.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"safe.xbm\"
else
echo shar: Extracting \"safe.xbm\" \(732 characters\)
sed "s/^X//" >safe.xbm <<'END_OF_safe.xbm'
X#define safe_width 32
X#define safe_height 32
Xstatic char safe_bits[] = {
X 0xff,0xff,0xff,0xff,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,
X 0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,
X 0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,
X 0x00,0x02,0x80,0x01,0x00,0x02,0x80,0x01,0x38,0x12,0x80,0x01,0x44,0x0a,0x80,
X 0x01,0x44,0x06,0x80,0x01,0x44,0x06,0x80,0x01,0x44,0x0a,0x80,0x01,0x44,0x12,
X 0x80,0x01,0x38,0x22,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,
X 0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,
X 0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,0x01,0x00,0x00,0x80,
X 0x01,0x00,0x00,0x80,0xff,0xff,0xff,0xff};
END_OF_safe.xbm
if test 732 -ne `wc -c <safe.xbm`; then
echo shar: \"safe.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

if test -f safeSm.xbm -a "${1}" != "-c" ; then
echo shar: Will not over-write existing file \"safeSm.xbm\"
else
echo shar: Extracting \"safeSm.xbm\" \(255 characters\)
sed "s/^X//" >safeSm.xbm <<'END_OF_safeSm.xbm'
X#define safeSmall_width 16
X#define safeSmall_height 16
Xstatic char safeSmall_bits[] = {
X 0xff,0xff,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0xb0,0x01,0xb8,0x01,0xbc,0x01,
X 0x8e,0x01,0x86,0x19,0x83,0xb1,0x81,0xe1,0x80,0x41,0x80,0x41,0x80,0x01,0x80,
X 0xff,0xff};
END_OF_safeSm.xbm
if test 255 -ne `wc -c <safeSm.xbm`; then
echo shar: \"safeSm.xbm\" unpacked with wrong size!


fi
# end of overwriting check
fi

echo shar: End of archive 3 \(of 3\).
cp /dev/null ark3isdone