billr@saab.CNA.TEK.COM (Bill Randle) (07/27/90)
Submitted-by: Jeroen Houttuin <houttuin@ethz.uucp>
Posting-number: Volume 11, Issue 4
Archive-name: xbd/Part02
#! /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", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 2)."
# Contents: bitmap/blob.bits bitmap/blob2.bits bitmap/boulder.bits
# bitmap/diamond.bits bitmap/diamond2.bits bitmap/diamond3.bits
# bitmap/eater.bits bitmap/eater2.bits bitmap/exit3.bits
# bitmap/explosion.bits bitmap/gold.bits bitmap/grass.bits
# bitmap/grey.bits bitmap/lmonster.bits bitmap/nucbal.bits
# bitmap/player.bits bitmap/player.old bitmap/player2.bits
# bitmap/player2.old bitmap/rmonster.bits bitmap/space.bits
# bitmap/steel.bits bitmap/stone.bits bitmap/wall.bits
# bitmap/wall2.bits default levels/bdlev001 levels/bdlev002
# levels/bdlev003 levels/bdlev004 levels/bdlev005 levels/bdlev006
# levels/bdlev007 levels/bdlev008 levels/bdlev009 levels/bdlev010
# levels/bdlev011 levels/bdlev012 levels/bdlev013 levels/bdlev014
# levels/bdlev016 levels/bdlev017 levels/bdlev018 levels/bdlev019
# levels/bdlev020 scores
# Wrapped by billr@saab on Thu Jul 26 16:05:56 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'bitmap/blob.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/blob.bits'\"
else
echo shar: Extracting \"'bitmap/blob.bits'\" \(919 characters\)
sed "s/^X//" >'bitmap/blob.bits' <<'END_OF_FILE'
X#define blob_width 32
X#define blob_height 32
X#define blob_x_hot -1
X#define blob_y_hot -1
Xstatic char blob_bits[] = {
X 0xd3, 0x24, 0xbe, 0xff, 0x0f, 0x8c, 0xb5, 0xff, 0xef, 0xf3, 0x7d, 0x00,
X 0x6e, 0xfe, 0x05, 0xf6, 0x7c, 0x03, 0xe0, 0x05, 0x03, 0x41, 0x3e, 0x02,
X 0x0e, 0xfc, 0x01, 0x78, 0x90, 0x07, 0xf0, 0xcb, 0xc1, 0x19, 0xff, 0xff,
X 0x86, 0xe0, 0x07, 0x00, 0xff, 0xff, 0x12, 0x00, 0x11, 0xc2, 0xff, 0xd1,
X 0x11, 0xd0, 0xe8, 0xef, 0xec, 0x0b, 0x24, 0xec, 0x44, 0xfe, 0x01, 0x01,
X 0xd2, 0xca, 0x3e, 0x88, 0x00, 0x00, 0x60, 0x3c, 0xbe, 0x03, 0x4b, 0x89,
X 0xff, 0x3b, 0x00, 0x80, 0x00, 0xe4, 0xff, 0xfe, 0xff, 0xfb, 0x7b, 0x77,
X 0x83, 0x87, 0xc0, 0x83, 0x00, 0x07, 0x0c, 0xf8, 0xf9, 0xfc, 0x80, 0x37,
X 0xcc, 0xf8, 0xf7, 0x2d, 0x4e, 0xf1, 0xb6, 0x2b, 0x7c, 0x86, 0x7f, 0x60,
X 0x01, 0x60, 0x00, 0x7d, 0xe4, 0x1e, 0xfc, 0x23, 0xf8, 0xe7, 0xc0, 0x1f,
X 0x06, 0xdc, 0x07, 0x80, 0x8f, 0x04, 0x7d, 0xf2};
END_OF_FILE
if test 919 -ne `wc -c <'bitmap/blob.bits'`; then
echo shar: \"'bitmap/blob.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/blob.bits'
fi
if test -f 'bitmap/blob2.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/blob2.bits'\"
else
echo shar: Extracting \"'bitmap/blob2.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/blob2.bits' <<'END_OF_FILE'
X#define blob2_width 32
X#define blob2_height 32
X#define blob2_x_hot -1
X#define blob2_y_hot -1
Xstatic char blob2_bits[] = {
X 0xce, 0x03, 0x5f, 0x43, 0xf4, 0xf8, 0xfd, 0x89, 0x1c, 0xae, 0x07, 0x3f,
X 0x80, 0x3f, 0x08, 0xbc, 0xb8, 0x40, 0xe2, 0x39, 0x5f, 0xfe, 0x01, 0x70,
X 0xb2, 0xff, 0xff, 0xdb, 0xff, 0x47, 0xfe, 0x7b, 0x03, 0x11, 0x00, 0x4f,
X 0x00, 0x18, 0x20, 0xf0, 0x58, 0xe1, 0x87, 0x00, 0x7f, 0x3c, 0x1f, 0x3c,
X 0x00, 0x8e, 0x35, 0xe0, 0x80, 0xe7, 0xff, 0x03, 0x79, 0x7f, 0x58, 0x0e,
X 0xfb, 0x1f, 0xc1, 0xff, 0xaf, 0xc0, 0x11, 0x86, 0xf8, 0x01, 0x00, 0x1e,
X 0xbf, 0x0e, 0x5f, 0xee, 0xf0, 0x73, 0x80, 0xfb, 0x04, 0x7e, 0xfe, 0x3a,
X 0x00, 0xe0, 0xf7, 0x81, 0xe3, 0x01, 0x00, 0x08, 0x3e, 0x46, 0xfb, 0xe3,
X 0x0f, 0x49, 0x40, 0x98, 0x14, 0x3f, 0x31, 0xe7, 0xf4, 0xcf, 0xf5, 0x3c,
X 0x7e, 0xb8, 0xfe, 0x03, 0x03, 0xe0, 0x1a, 0xf8, 0x80, 0x83, 0xbb, 0x3e,
X 0xf3, 0x8f, 0xfc, 0xc3, 0x71, 0x0e, 0x02, 0x80};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/blob2.bits'`; then
echo shar: \"'bitmap/blob2.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/blob2.bits'
fi
if test -f 'bitmap/boulder.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/boulder.bits'\"
else
echo shar: Extracting \"'bitmap/boulder.bits'\" \(934 characters\)
sed "s/^X//" >'bitmap/boulder.bits' <<'END_OF_FILE'
X#define boulder_width 32
X#define boulder_height 32
X#define boulder_x_hot -1
X#define boulder_y_hot -1
Xstatic char boulder_bits[] = {
X 0xff, 0x47, 0x91, 0xff, 0x7f, 0x02, 0xa8, 0xfe, 0x5f, 0x18, 0x00, 0xfc,
X 0x2f, 0x18, 0x02, 0xf8, 0x17, 0x00, 0x10, 0xf0, 0x2b, 0x80, 0x00, 0xe2,
X 0x57, 0x55, 0x85, 0xc1, 0xab, 0xaa, 0x0a, 0xe1, 0x15, 0x15, 0x15, 0x90,
X 0xab, 0x2a, 0xaa, 0x80, 0x55, 0x5d, 0x55, 0xc1, 0xaa, 0xaa, 0xaa, 0x82,
X 0xd5, 0x55, 0x55, 0x05, 0xaa, 0xaa, 0x8a, 0x82, 0x55, 0x5d, 0x14, 0x05,
X 0xaa, 0xaa, 0x2a, 0x8a, 0x77, 0x55, 0x55, 0x55, 0xea, 0xaa, 0xa2, 0xaa,
X 0xdf, 0x55, 0x55, 0x55, 0xae, 0xaa, 0xea, 0xaa, 0xd5, 0x5d, 0xd5, 0x55,
X 0xaf, 0xaa, 0xaa, 0xaa, 0x7d, 0xd5, 0x55, 0xd5, 0xeb, 0xab, 0xab, 0xaa,
X 0xdf, 0x5f, 0x55, 0xd5, 0xaf, 0xae, 0xba, 0xea, 0xff, 0x75, 0xf5, 0xf5,
X 0xbf, 0xef, 0xaa, 0xfa, 0xff, 0xdf, 0x75, 0xfd, 0xff, 0xbf, 0xae, 0xfe,
X 0xff, 0x57, 0xd5, 0xff, 0xff, 0xaf, 0xea, 0xff};
END_OF_FILE
if test 934 -ne `wc -c <'bitmap/boulder.bits'`; then
echo shar: \"'bitmap/boulder.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/boulder.bits'
fi
if test -f 'bitmap/diamond.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/diamond.bits'\"
else
echo shar: Extracting \"'bitmap/diamond.bits'\" \(934 characters\)
sed "s/^X//" >'bitmap/diamond.bits' <<'END_OF_FILE'
X#define diamond_width 32
X#define diamond_height 32
X#define diamond_x_hot -1
X#define diamond_y_hot -1
Xstatic char diamond_bits[] = {
X 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xbf, 0xfd, 0xff, 0xff, 0x1f, 0xf8, 0xff,
X 0xff, 0x0f, 0xf0, 0xff, 0xff, 0xf7, 0xef, 0xff, 0xff, 0xfb, 0xdf, 0xff,
X 0xff, 0xfd, 0xbf, 0xff, 0xff, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0xfe,
X 0xbf, 0xff, 0xff, 0xfd, 0x1f, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xf7,
X 0x07, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0xfd, 0xff, 0xff, 0xbf,
X 0xfe, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xff, 0xff, 0xbf,
X 0xfb, 0xff, 0xff, 0xcf, 0x07, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xf0,
X 0x1f, 0x00, 0x00, 0xf8, 0xbf, 0xff, 0xff, 0xfd, 0x7f, 0x00, 0x00, 0xfe,
X 0xff, 0x00, 0x00, 0xff, 0xff, 0xfd, 0xbf, 0xff, 0xff, 0x03, 0xc0, 0xff,
X 0xff, 0xf7, 0xef, 0xff, 0xff, 0xef, 0xf7, 0xff, 0xff, 0x1f, 0xf8, 0xff,
X 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x7f, 0xfe, 0xff};
END_OF_FILE
if test 934 -ne `wc -c <'bitmap/diamond.bits'`; then
echo shar: \"'bitmap/diamond.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/diamond.bits'
fi
if test -f 'bitmap/diamond2.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/diamond2.bits'\"
else
echo shar: Extracting \"'bitmap/diamond2.bits'\" \(939 characters\)
sed "s/^X//" >'bitmap/diamond2.bits' <<'END_OF_FILE'
X#define diamond2_width 32
X#define diamond2_height 32
X#define diamond2_x_hot -1
X#define diamond2_y_hot -1
Xstatic char diamond2_bits[] = {
X 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xbf, 0xfd, 0xff, 0xff, 0xdf, 0xfb, 0xff,
X 0xff, 0xef, 0xf7, 0xff, 0xff, 0x07, 0xe0, 0xff, 0xff, 0xfb, 0xdf, 0xff,
X 0xff, 0x01, 0x80, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0x7f, 0xff, 0xff, 0xfe,
X 0x3f, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0xf8, 0xef, 0xff, 0xff, 0xf7,
X 0xf7, 0xff, 0xff, 0xef, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80,
X 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0x01, 0x00, 0x00, 0x80,
X 0xfb, 0xff, 0xff, 0xdf, 0x07, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xf0,
X 0xdf, 0xff, 0xff, 0xfb, 0x3f, 0x00, 0x00, 0xfc, 0x7f, 0xff, 0xff, 0xfe,
X 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff, 0xfb, 0xdf, 0xff,
X 0xff, 0x07, 0xe0, 0xff, 0xff, 0xef, 0xf7, 0xff, 0xff, 0xdf, 0xfb, 0xff,
X 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x7f, 0xfe, 0xff};
END_OF_FILE
if test 939 -ne `wc -c <'bitmap/diamond2.bits'`; then
echo shar: \"'bitmap/diamond2.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/diamond2.bits'
fi
if test -f 'bitmap/diamond3.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/diamond3.bits'\"
else
echo shar: Extracting \"'bitmap/diamond3.bits'\" \(939 characters\)
sed "s/^X//" >'bitmap/diamond3.bits' <<'END_OF_FILE'
X#define diamond3_width 32
X#define diamond3_height 32
X#define diamond3_x_hot -1
X#define diamond3_y_hot -1
Xstatic char diamond3_bits[] = {
X 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xbf, 0xfd, 0xff, 0xff, 0x1f, 0xf8, 0xff,
X 0xff, 0x0f, 0xf0, 0xff, 0xff, 0x07, 0xe0, 0xff, 0xff, 0xfb, 0xdf, 0xff,
X 0xff, 0x01, 0x80, 0xff, 0xff, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0xfe,
X 0x3f, 0x00, 0x00, 0xfc, 0xdf, 0xff, 0xff, 0xfb, 0x0f, 0x00, 0x00, 0xf0,
X 0x07, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x80,
X 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x7f, 0x01, 0x00, 0x00, 0x80,
X 0x03, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0xe0, 0x0f, 0x00, 0x00, 0xf0,
X 0xdf, 0xff, 0xff, 0xfb, 0x3f, 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0xfe,
X 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff, 0xfb, 0xdf, 0xff,
X 0xff, 0x07, 0xe0, 0xff, 0xff, 0x0f, 0xf0, 0xff, 0xff, 0x1f, 0xf8, 0xff,
X 0xff, 0xbf, 0xfd, 0xff, 0xff, 0x7f, 0xfe, 0xff};
END_OF_FILE
if test 939 -ne `wc -c <'bitmap/diamond3.bits'`; then
echo shar: \"'bitmap/diamond3.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/diamond3.bits'
fi
if test -f 'bitmap/eater.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/eater.bits'\"
else
echo shar: Extracting \"'bitmap/eater.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/eater.bits' <<'END_OF_FILE'
X#define eater_width 32
X#define eater_height 32
X#define eater_x_hot -1
X#define eater_y_hot -1
Xstatic char eater_bits[] = {
X 0xff, 0x0f, 0xf0, 0xff, 0xff, 0x61, 0xc1, 0xff, 0x7f, 0x08, 0x02, 0xff,
X 0x1f, 0x04, 0x00, 0xfe, 0x1f, 0x52, 0x50, 0xfc, 0x0f, 0x09, 0x00, 0xf9,
X 0x8f, 0x1a, 0x10, 0xf0, 0x87, 0x40, 0x4d, 0xe2, 0x63, 0x2c, 0x30, 0xe2,
X 0x13, 0x9f, 0x79, 0xc4, 0x51, 0x3f, 0xfc, 0x81, 0xa1, 0x33, 0xfc, 0x82,
X 0x21, 0x73, 0xce, 0x80, 0x81, 0x3e, 0xcd, 0xa2, 0x41, 0xb8, 0xfe, 0x84,
X 0x11, 0x01, 0x64, 0x81, 0x41, 0xc8, 0x1b, 0x8a, 0x11, 0x52, 0xca, 0x80,
X 0x49, 0xc5, 0x6e, 0x8a, 0xf1, 0xff, 0xff, 0x8f, 0x39, 0x1f, 0xf1, 0x8b,
X 0x59, 0x4f, 0xc6, 0xa5, 0x51, 0xa6, 0xd1, 0x89, 0xa1, 0x1f, 0xca, 0xa0,
X 0x31, 0xac, 0xd0, 0x8a, 0x51, 0xa9, 0x44, 0x94, 0x11, 0x00, 0xb5, 0x88,
X 0xc1, 0x40, 0x00, 0x92, 0x05, 0x02, 0xf4, 0x80, 0x39, 0x62, 0xf8, 0xa1,
X 0x7d, 0xf7, 0xfc, 0xb9, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/eater.bits'`; then
echo shar: \"'bitmap/eater.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/eater.bits'
fi
if test -f 'bitmap/eater2.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/eater2.bits'\"
else
echo shar: Extracting \"'bitmap/eater2.bits'\" \(929 characters\)
sed "s/^X//" >'bitmap/eater2.bits' <<'END_OF_FILE'
X#define eater2_width 32
X#define eater2_height 32
X#define eater2_x_hot -1
X#define eater2_y_hot -1
Xstatic char eater2_bits[] = {
X 0xff, 0x0f, 0xf8, 0xff, 0xff, 0x01, 0xc0, 0xff, 0x7f, 0xa8, 0x08, 0xff,
X 0x3f, 0x1c, 0x00, 0xfe, 0x9f, 0x52, 0x50, 0xfc, 0x0f, 0x41, 0x00, 0xf8,
X 0x8f, 0x1a, 0x12, 0xf0, 0x87, 0x40, 0xc8, 0xe2, 0x63, 0x2e, 0xb2, 0xe2,
X 0x13, 0x9f, 0xf9, 0xc4, 0xd9, 0x39, 0x9d, 0xc9, 0xa9, 0xb9, 0x9c, 0x86,
X 0x21, 0x7f, 0xfe, 0x98, 0x89, 0x3e, 0xfd, 0xaa, 0x79, 0xb8, 0xfe, 0x94,
X 0x51, 0x21, 0x64, 0x81, 0xc5, 0xc8, 0x1b, 0x98, 0x11, 0x52, 0xca, 0x80,
X 0x49, 0xc5, 0x6e, 0x8a, 0xf5, 0xff, 0xff, 0x9f, 0xb9, 0x55, 0xd5, 0x9b,
X 0xd9, 0x55, 0xd5, 0xb7, 0xdd, 0xa7, 0xea, 0x8b, 0xa5, 0xbf, 0xfa, 0x87,
X 0x3d, 0xff, 0xff, 0x8f, 0x7d, 0xef, 0xdf, 0x97, 0x2d, 0xc6, 0xf7, 0x8b,
X 0xfd, 0x47, 0xf0, 0x83, 0x29, 0x02, 0x06, 0x81, 0x41, 0x40, 0x01, 0x9d,
X 0x75, 0xf3, 0x2c, 0xb8, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 929 -ne `wc -c <'bitmap/eater2.bits'`; then
echo shar: \"'bitmap/eater2.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/eater2.bits'
fi
if test -f 'bitmap/exit3.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/exit3.bits'\"
else
echo shar: Extracting \"'bitmap/exit3.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/exit3.bits' <<'END_OF_FILE'
X#define exit3_width 32
X#define exit3_height 32
X#define exit3_x_hot -1
X#define exit3_y_hot -1
Xstatic char exit3_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0x61, 0x18, 0x63, 0x80, 0xef, 0x7b, 0xef, 0xbf,
X 0xef, 0x7b, 0xef, 0xbf, 0xfd, 0x7b, 0xff, 0xf7, 0xfd, 0x7b, 0xff, 0xf7,
X 0xfd, 0x7b, 0xff, 0xf7, 0xfd, 0x7b, 0xff, 0xf7, 0xfd, 0x7b, 0xe3, 0xf7,
X 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x77, 0xef, 0xf7,
X 0xfd, 0x77, 0xef, 0xf7, 0xe1, 0x7f, 0xef, 0xf7, 0xef, 0xbf, 0xef, 0xf7,
X 0xef, 0xdf, 0xef, 0xf7, 0xfd, 0xbf, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7,
X 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7,
X 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7,
X 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7, 0xfd, 0x7b, 0xef, 0xf7,
X 0xfd, 0x7b, 0xef, 0xf7, 0xe1, 0x7b, 0xef, 0xf7, 0xef, 0x7b, 0xef, 0xf7,
X 0xef, 0x7b, 0xef, 0xf7, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/exit3.bits'`; then
echo shar: \"'bitmap/exit3.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/exit3.bits'
fi
if test -f 'bitmap/explosion.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/explosion.bits'\"
else
echo shar: Extracting \"'bitmap/explosion.bits'\" \(890 characters\)
sed "s/^X//" >'bitmap/explosion.bits' <<'END_OF_FILE'
X#define explosion_width 32
X#define explosion_height 32
Xstatic char explosion_bits[] = {
X 0xff, 0xff, 0xb7, 0x7f, 0xee, 0xb9, 0xb7, 0xbc, 0xcd, 0xf3, 0xdf, 0xbe,
X 0xdf, 0xb5, 0x7b, 0xff, 0xff, 0xf1, 0xbb, 0xef, 0x9f, 0xe7, 0xdf, 0xf7,
X 0x7e, 0xaf, 0x6e, 0x7e, 0xfc, 0xef, 0x66, 0xbf, 0xeb, 0xbb, 0xd2, 0xcf,
X 0xdf, 0xdf, 0xfa, 0xef, 0x7f, 0xdf, 0xf7, 0xfd, 0xff, 0xdc, 0x3e, 0xfe,
X 0xf9, 0xf3, 0x39, 0xfb, 0xcf, 0x1f, 0xdc, 0xbd, 0x3b, 0x19, 0xf9, 0xd4,
X 0x7d, 0x5f, 0xbf, 0xfe, 0xff, 0x53, 0x54, 0xff, 0xbf, 0x39, 0xb7, 0xa9,
X 0xfd, 0xbe, 0x7d, 0xbf, 0xde, 0xbe, 0xfb, 0x70, 0x7f, 0xdf, 0xd7, 0xcf,
X 0xb7, 0x8f, 0xcf, 0xbf, 0xbf, 0x5d, 0xde, 0x7c, 0xfb, 0xdd, 0x7d, 0xfa,
X 0xff, 0xcd, 0xfb, 0xe7, 0xe7, 0xc4, 0xef, 0xfc, 0xfb, 0xf6, 0xee, 0xf7,
X 0xfd, 0xf6, 0x1b, 0x8f, 0x7c, 0xdf, 0x77, 0x7e, 0x8e, 0xdb, 0xef, 0xfe,
X 0xe7, 0xdb, 0xff, 0xf7, 0xff, 0xfb, 0xcf, 0xef};
END_OF_FILE
if test 890 -ne `wc -c <'bitmap/explosion.bits'`; then
echo shar: \"'bitmap/explosion.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/explosion.bits'
fi
if test -f 'bitmap/gold.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/gold.bits'\"
else
echo shar: Extracting \"'bitmap/gold.bits'\" \(319 characters\)
sed "s/^X//" >'bitmap/gold.bits' <<'END_OF_FILE'
X#define gold_width 16
X#define gold_height 16
X#define gold_x_hot -1
X#define gold_y_hot -1
Xstatic char gold_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x60, 0x03, 0xb0, 0x06, 0x50, 0x05,
X 0xb0, 0x06, 0x60, 0x03, 0xc0, 0x01, 0x00, 0x00};
END_OF_FILE
if test 319 -ne `wc -c <'bitmap/gold.bits'`; then
echo shar: \"'bitmap/gold.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/gold.bits'
fi
if test -f 'bitmap/grass.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/grass.bits'\"
else
echo shar: Extracting \"'bitmap/grass.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/grass.bits' <<'END_OF_FILE'
X#define grass_width 32
X#define grass_height 32
X#define grass_x_hot -1
X#define grass_y_hot -1
Xstatic char grass_bits[] = {
X 0x5c, 0x55, 0x55, 0x55, 0xda, 0xfa, 0xeb, 0xfe, 0x55, 0x10, 0x00, 0x45,
X 0x29, 0xee, 0xea, 0xaa, 0xd5, 0x55, 0x51, 0xdd, 0xfa, 0xaa, 0xe2, 0xac,
X 0x77, 0x5d, 0x55, 0x15, 0xaa, 0xe7, 0xa2, 0xaa, 0x57, 0x75, 0x4b, 0xd8,
X 0xaa, 0xeb, 0xa2, 0xaa, 0x76, 0x55, 0x5d, 0x4f, 0xca, 0xb8, 0xea, 0xaa,
X 0x77, 0x55, 0x47, 0xd0, 0xab, 0xeb, 0xba, 0xea, 0x75, 0x45, 0x5f, 0x55,
X 0xab, 0xab, 0xba, 0xea, 0x5f, 0x5d, 0x55, 0x47, 0xaa, 0xeb, 0x3b, 0xab,
X 0xd5, 0x1f, 0x75, 0x55, 0xe6, 0xca, 0xab, 0xee, 0x55, 0x55, 0x55, 0x55,
X 0xea, 0xab, 0xea, 0xaa, 0x57, 0xf5, 0x55, 0x69, 0xae, 0xab, 0xba, 0x98,
X 0x55, 0x7d, 0xdd, 0x5d, 0xee, 0xba, 0xaa, 0xba, 0x5f, 0xd5, 0x75, 0x55,
X 0xab, 0xaa, 0xaa, 0xef, 0xd7, 0x57, 0x55, 0x1f, 0xff, 0xbe, 0xab, 0xbf,
X 0x5f, 0xf5, 0x5f, 0xd5, 0xfe, 0xab, 0xfe, 0x7f};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/grass.bits'`; then
echo shar: \"'bitmap/grass.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/grass.bits'
fi
if test -f 'bitmap/grey.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/grey.bits'\"
else
echo shar: Extracting \"'bitmap/grey.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/grey.bits' <<'END_OF_FILE'
X#define grass_width 32
X#define grass_height 32
X#define grass_x_hot -1
X#define grass_y_hot -1
Xstatic char grass_bits[] = {
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
X 0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
X 0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/grey.bits'`; then
echo shar: \"'bitmap/grey.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/grey.bits'
fi
if test -f 'bitmap/lmonster.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/lmonster.bits'\"
else
echo shar: Extracting \"'bitmap/lmonster.bits'\" \(939 characters\)
sed "s/^X//" >'bitmap/lmonster.bits' <<'END_OF_FILE'
X#define lmonster_width 32
X#define lmonster_height 32
X#define lmonster_x_hot -1
X#define lmonster_y_hot -1
Xstatic char lmonster_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
X 0x38, 0x00, 0x00, 0x1c, 0xb8, 0xff, 0xff, 0x1d, 0xb8, 0xff, 0xff, 0x1d,
X 0xb8, 0x01, 0x80, 0x1d, 0xb8, 0x01, 0x80, 0x1d, 0xb8, 0xf9, 0x9f, 0x1d,
X 0xb8, 0xf9, 0x9f, 0x1d, 0xb8, 0x19, 0x98, 0x1d, 0xb8, 0x19, 0x98, 0x1d,
X 0xb8, 0x19, 0x98, 0x1d, 0xb8, 0x19, 0x98, 0x1d, 0xb8, 0x19, 0x98, 0x1d,
X 0xb8, 0x19, 0x98, 0x1d, 0xb8, 0xf9, 0x9f, 0x1d, 0xb8, 0xf9, 0x9f, 0x1d,
X 0xb8, 0x01, 0x80, 0x1d, 0xb8, 0x01, 0x80, 0x1d, 0xb8, 0xff, 0xff, 0x1d,
X 0xb8, 0xff, 0xff, 0x1d, 0x38, 0x00, 0x00, 0x1c, 0xf8, 0xff, 0xff, 0x1f,
X 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00,
X 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 939 -ne `wc -c <'bitmap/lmonster.bits'`; then
echo shar: \"'bitmap/lmonster.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/lmonster.bits'
fi
if test -f 'bitmap/nucbal.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/nucbal.bits'\"
else
echo shar: Extracting \"'bitmap/nucbal.bits'\" \(929 characters\)
sed "s/^X//" >'bitmap/nucbal.bits' <<'END_OF_FILE'
X#define nucbal_width 32
X#define nucbal_height 32
X#define nucbal_x_hot -1
X#define nucbal_y_hot -1
Xstatic char nucbal_bits[] = {
X 0xff, 0x1f, 0xf0, 0xff, 0xff, 0x03, 0x80, 0xff, 0xff, 0x00, 0x00, 0xfe,
X 0x7f, 0x00, 0xc0, 0xfc, 0x3f, 0x07, 0xc0, 0xf9, 0x9f, 0x0f, 0xe0, 0xf3,
X 0xcf, 0x0f, 0xe0, 0xe7, 0xc7, 0x1f, 0xf0, 0xcf, 0xe7, 0x1f, 0xf0, 0xcf,
X 0xf3, 0x3f, 0xf8, 0x9f, 0xf3, 0x3f, 0xf8, 0x9f, 0xf3, 0x7f, 0xfc, 0xbf,
X 0xf9, 0x7f, 0xfc, 0x3f, 0xf9, 0xff, 0xfe, 0x3f, 0xf9, 0x7f, 0xfc, 0x3f,
X 0xf9, 0x0f, 0xf1, 0x3f, 0xf9, 0x03, 0xc1, 0x3f, 0x79, 0x80, 0x03, 0x3f,
X 0x09, 0x80, 0x03, 0x3c, 0x03, 0xc0, 0x07, 0x90, 0x03, 0xc0, 0x07, 0x80,
X 0x03, 0xe0, 0x0f, 0x80, 0x07, 0xf0, 0x0f, 0xc0, 0x07, 0xf0, 0x1f, 0xc0,
X 0x0f, 0xf8, 0x1f, 0xe0, 0x1f, 0xf8, 0x3f, 0xf0, 0x3f, 0xfc, 0x3f, 0xf8,
X 0x7f, 0xfc, 0x7f, 0xfc, 0xff, 0xf0, 0x1f, 0xfe, 0xff, 0x03, 0x80, 0xff,
X 0xff, 0x1f, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 929 -ne `wc -c <'bitmap/nucbal.bits'`; then
echo shar: \"'bitmap/nucbal.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/nucbal.bits'
fi
if test -f 'bitmap/player.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/player.bits'\"
else
echo shar: Extracting \"'bitmap/player.bits'\" \(929 characters\)
sed "s/^X//" >'bitmap/player.bits' <<'END_OF_FILE'
X#define player_width 32
X#define player_height 32
X#define player_x_hot -1
X#define player_y_hot -1
Xstatic char player_bits[] = {
X 0x7f, 0xf5, 0x57, 0xfd, 0xbf, 0xea, 0xab, 0xfa, 0x5f, 0x55, 0x55, 0xf5,
X 0xaf, 0xaa, 0xaa, 0xfa, 0x5f, 0x55, 0x55, 0xf5, 0xab, 0xaf, 0xfa, 0xea,
X 0xd5, 0xdf, 0xfd, 0xd5, 0xab, 0xef, 0xfb, 0xaa, 0x55, 0x55, 0x55, 0xd5,
X 0xab, 0xaa, 0xaa, 0xea, 0x5f, 0x5d, 0x5d, 0xfd, 0xbf, 0xfa, 0xaf, 0xfe,
X 0xff, 0xf5, 0x55, 0xff, 0xff, 0xef, 0xaa, 0xff, 0xff, 0xf7, 0xfd, 0xff,
X 0xab, 0xaa, 0xaa, 0xea, 0x41, 0x55, 0x55, 0xc5, 0xa3, 0xff, 0xff, 0x8a,
X 0x55, 0x01, 0x40, 0xc5, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x03, 0xe0, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0xea, 0xff, 0xff, 0xd7, 0xf5, 0xff,
X 0xff, 0xeb, 0xeb, 0xff, 0xff, 0xf5, 0xf7, 0xff, 0xff, 0xf1, 0xeb, 0xff,
X 0x1f, 0xf8, 0x07, 0xfe, 0x1f, 0xf8, 0x07, 0xfe};
END_OF_FILE
if test 929 -ne `wc -c <'bitmap/player.bits'`; then
echo shar: \"'bitmap/player.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/player.bits'
fi
if test -f 'bitmap/player.old' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/player.old'\"
else
echo shar: Extracting \"'bitmap/player.old'\" \(929 characters\)
sed "s/^X//" >'bitmap/player.old' <<'END_OF_FILE'
X#define player_width 32
X#define player_height 32
X#define player_x_hot -1
X#define player_y_hot -1
Xstatic char player_bits[] = {
X 0xff, 0x07, 0xe0, 0xff, 0xff, 0x07, 0xe0, 0xff, 0xff, 0x00, 0x00, 0xff,
X 0xff, 0xf7, 0xdf, 0xff, 0xff, 0x93, 0xc9, 0xff, 0xff, 0xf3, 0xcf, 0xff,
X 0xff, 0xa3, 0xcd, 0xff, 0xff, 0x6f, 0xe6, 0xff, 0xff, 0xdf, 0xf3, 0xff,
X 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x05, 0x80, 0xff,
X 0xff, 0x78, 0x7e, 0xff, 0xff, 0x3e, 0x7c, 0xff, 0xff, 0x3e, 0x7c, 0xfe,
X 0xff, 0x3e, 0xec, 0xfe, 0xff, 0x3a, 0xcc, 0xfe, 0xff, 0x3a, 0xdc, 0xfe,
X 0x7f, 0x3a, 0xdc, 0xfe, 0x7f, 0x39, 0xdc, 0xfe, 0xbf, 0x72, 0xae, 0xfe,
X 0x3f, 0xe4, 0xa7, 0xfc, 0xbf, 0x0d, 0x38, 0xfe, 0x3f, 0xec, 0x7b, 0xfc,
X 0xbf, 0xef, 0x73, 0xfc, 0xff, 0x6f, 0xf6, 0xfd, 0xff, 0xa7, 0xf6, 0xff,
X 0xff, 0xbb, 0xe6, 0xff, 0x3f, 0x98, 0x0c, 0xff, 0x7f, 0xcf, 0x79, 0xff,
X 0x7f, 0xe6, 0xb3, 0xff, 0xff, 0xf0, 0xc7, 0xff};
END_OF_FILE
if test 929 -ne `wc -c <'bitmap/player.old'`; then
echo shar: \"'bitmap/player.old'\" unpacked with wrong size!
fi
# end of 'bitmap/player.old'
fi
if test -f 'bitmap/player2.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/player2.bits'\"
else
echo shar: Extracting \"'bitmap/player2.bits'\" \(934 characters\)
sed "s/^X//" >'bitmap/player2.bits' <<'END_OF_FILE'
X#define player2_width 32
X#define player2_height 32
X#define player2_x_hot -1
X#define player2_y_hot -1
Xstatic char player2_bits[] = {
X 0x7f, 0xf5, 0x57, 0xfd, 0xbf, 0xea, 0xab, 0xfa, 0x5f, 0x55, 0x55, 0xf5,
X 0xaf, 0xaa, 0xaa, 0xfa, 0x5f, 0x55, 0x55, 0xf5, 0xab, 0xaa, 0xaa, 0xea,
X 0xd5, 0xdf, 0xf5, 0xd7, 0xab, 0xee, 0xeb, 0xaa, 0x55, 0x55, 0x55, 0xd5,
X 0xab, 0xaa, 0xaa, 0xea, 0x5f, 0x5d, 0x5d, 0xfd, 0xbf, 0xfa, 0xaf, 0xfe,
X 0xff, 0xd5, 0x55, 0xff, 0xff, 0xaf, 0xaa, 0xff, 0xff, 0xd7, 0xfd, 0xff,
X 0xab, 0xaa, 0xaa, 0xea, 0x41, 0x55, 0x55, 0xc5, 0xa3, 0xff, 0xff, 0x8a,
X 0x55, 0x01, 0x40, 0xc5, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0x03, 0xe0, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0xea, 0xff, 0xff, 0xd7, 0xf5, 0xff,
X 0xff, 0xeb, 0xeb, 0xff, 0xff, 0xf5, 0xf7, 0xff, 0x1f, 0xf1, 0xeb, 0xff,
X 0x1f, 0xf8, 0x07, 0xfe, 0xff, 0xfb, 0x07, 0xfe};
END_OF_FILE
if test 934 -ne `wc -c <'bitmap/player2.bits'`; then
echo shar: \"'bitmap/player2.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/player2.bits'
fi
if test -f 'bitmap/player2.old' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/player2.old'\"
else
echo shar: Extracting \"'bitmap/player2.old'\" \(934 characters\)
sed "s/^X//" >'bitmap/player2.old' <<'END_OF_FILE'
X#define player2_width 32
X#define player2_height 32
X#define player2_x_hot -1
X#define player2_y_hot -1
Xstatic char player2_bits[] = {
X 0xff, 0x07, 0xe0, 0xff, 0xff, 0x07, 0xe0, 0xff, 0xff, 0x00, 0x00, 0xff,
X 0xff, 0xf7, 0xdf, 0xff, 0xff, 0xf3, 0xcf, 0xff, 0xff, 0xf3, 0xcf, 0xff,
X 0xff, 0x63, 0xcf, 0xff, 0xff, 0x6f, 0xe4, 0xff, 0xff, 0xdf, 0xf3, 0xff,
X 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0x05, 0x80, 0xff,
X 0xff, 0x78, 0x7e, 0xff, 0xff, 0x3e, 0x7c, 0xff, 0xff, 0x3e, 0x7c, 0xfe,
X 0xff, 0x3e, 0xec, 0xfe, 0xff, 0x3a, 0xcc, 0xfe, 0xff, 0x3a, 0xdc, 0xfe,
X 0x7f, 0x3a, 0xdc, 0xfe, 0x7f, 0x39, 0xdc, 0xfe, 0xbf, 0x72, 0xae, 0xfe,
X 0x3f, 0xe4, 0xa7, 0xfc, 0xbf, 0x0d, 0x38, 0xfe, 0x3f, 0xec, 0x7b, 0xfc,
X 0xbf, 0xef, 0x73, 0xfc, 0xff, 0x6f, 0xf6, 0xfd, 0xff, 0xa7, 0xf6, 0xff,
X 0xff, 0xbb, 0xe6, 0xff, 0x3f, 0x98, 0xcc, 0xff, 0x7f, 0xcf, 0xb9, 0xff,
X 0x7f, 0xe6, 0x33, 0xff, 0xff, 0xf0, 0x0f, 0xfc};
END_OF_FILE
if test 934 -ne `wc -c <'bitmap/player2.old'`; then
echo shar: \"'bitmap/player2.old'\" unpacked with wrong size!
fi
# end of 'bitmap/player2.old'
fi
if test -f 'bitmap/rmonster.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/rmonster.bits'\"
else
echo shar: Extracting \"'bitmap/rmonster.bits'\" \(939 characters\)
sed "s/^X//" >'bitmap/rmonster.bits' <<'END_OF_FILE'
X#define rmonster_width 32
X#define rmonster_height 32
X#define rmonster_x_hot -1
X#define rmonster_y_hot -1
Xstatic char rmonster_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff, 0x9f, 0xf1, 0xff, 0xff, 0x8f,
X 0xe1, 0xff, 0xff, 0x87, 0xc1, 0xff, 0xff, 0x83, 0x81, 0xff, 0xff, 0x81,
X 0x01, 0xff, 0xff, 0x80, 0x01, 0xfe, 0x7f, 0x80, 0x11, 0xfc, 0x3f, 0x88,
X 0x31, 0xf8, 0x1f, 0x8c, 0x71, 0xf0, 0x0f, 0x8e, 0xd1, 0xe0, 0x07, 0x8b,
X 0x91, 0xc1, 0x83, 0x89, 0x11, 0x83, 0xc1, 0x88, 0x11, 0x06, 0x60, 0x88,
X 0x11, 0x0c, 0x30, 0x88, 0x11, 0x0c, 0x30, 0x88, 0x11, 0x06, 0x60, 0x88,
X 0x11, 0x83, 0xc1, 0x88, 0x91, 0xc1, 0x83, 0x89, 0xd1, 0xe0, 0x07, 0x8b,
X 0x71, 0xf0, 0x0f, 0x8e, 0x31, 0xf8, 0x1f, 0x8c, 0x11, 0xfc, 0x3f, 0x88,
X 0x01, 0xfe, 0x7f, 0x80, 0x01, 0xff, 0xff, 0x80, 0x81, 0xff, 0xff, 0x81,
X 0xc1, 0xff, 0xff, 0x83, 0xe1, 0xff, 0xff, 0x87, 0xf1, 0xff, 0xff, 0x8f,
X 0xf9, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0xff};
END_OF_FILE
if test 939 -ne `wc -c <'bitmap/rmonster.bits'`; then
echo shar: \"'bitmap/rmonster.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/rmonster.bits'
fi
if test -f 'bitmap/space.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/space.bits'\"
else
echo shar: Extracting \"'bitmap/space.bits'\" \(885 characters\)
sed "s/^X//" >'bitmap/space.bits' <<'END_OF_FILE'
X#define space_width 32
X#define space_height 32
Xstatic char space_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
X };
END_OF_FILE
if test 885 -ne `wc -c <'bitmap/space.bits'`; then
echo shar: \"'bitmap/space.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/space.bits'
fi
if test -f 'bitmap/steel.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/steel.bits'\"
else
echo shar: Extracting \"'bitmap/steel.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/steel.bits' <<'END_OF_FILE'
X#define steel_width 32
X#define steel_height 32
X#define steel_x_hot -1
X#define steel_y_hot -1
Xstatic char steel_bits[] = {
X 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
X 0xfe, 0xff, 0xff, 0x1f, 0xfe, 0xff, 0xff, 0x1f, 0xf6, 0xff, 0xff, 0x1f,
X 0xe6, 0xff, 0xff, 0x1f, 0x66, 0xe0, 0x07, 0x1e, 0xe6, 0xe0, 0x0f, 0x1e,
X 0xe6, 0xe7, 0x7f, 0x1e, 0xe6, 0xe6, 0x6f, 0x1e, 0xe6, 0xe4, 0x4f, 0x1e,
X 0xe6, 0xef, 0xff, 0x1e, 0xe6, 0xff, 0xff, 0x1f, 0xe6, 0xff, 0xff, 0x1f,
X 0xe6, 0xff, 0xff, 0x1f, 0xe6, 0xff, 0xff, 0x1f, 0xe6, 0xff, 0xff, 0x1f,
X 0xe6, 0xff, 0xff, 0x1f, 0x66, 0xe0, 0x07, 0x1e, 0xe6, 0xe0, 0x0f, 0x1e,
X 0xe6, 0xe7, 0x7f, 0x1e, 0xe6, 0xe6, 0x6f, 0x1e, 0xe6, 0xe4, 0x4f, 0x1e,
X 0xe6, 0xef, 0xff, 0x1e, 0xe6, 0xff, 0xff, 0x1f, 0xe6, 0xff, 0xff, 0x1f,
X 0x06, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x30, 0xfe, 0xff, 0xff, 0x3f,
X 0xfe, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/steel.bits'`; then
echo shar: \"'bitmap/steel.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/steel.bits'
fi
if test -f 'bitmap/stone.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/stone.bits'\"
else
echo shar: Extracting \"'bitmap/stone.bits'\" \(324 characters\)
sed "s/^X//" >'bitmap/stone.bits' <<'END_OF_FILE'
X#define stone_width 16
X#define stone_height 16
X#define stone_x_hot -1
X#define stone_y_hot -1
Xstatic char stone_bits[] = {
X 0x1f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f,
X 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xff, 0xff,
X 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf8};
END_OF_FILE
if test 324 -ne `wc -c <'bitmap/stone.bits'`; then
echo shar: \"'bitmap/stone.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/stone.bits'
fi
if test -f 'bitmap/wall.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/wall.bits'\"
else
echo shar: Extracting \"'bitmap/wall.bits'\" \(875 characters\)
sed "s/^X//" >'bitmap/wall.bits' <<'END_OF_FILE'
X#define wall_width 32
X#define wall_height 32
Xstatic char wall_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00,
X 0x81, 0x00, 0x81, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x08, 0x10, 0x08,
X 0x08, 0x08, 0x10, 0x08, 0x08, 0x08, 0x10, 0x08, 0xff, 0xff, 0xff, 0xff,
X 0x81, 0x00, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00,
X 0xff, 0xff, 0xff, 0xff, 0x08, 0x08, 0x10, 0x10, 0x08, 0x08, 0x10, 0x10,
X 0x08, 0x08, 0x10, 0x10, 0xff, 0xff, 0xff, 0xff, 0x41, 0x00, 0x02, 0x01,
X 0x41, 0x00, 0x02, 0x01, 0x41, 0x00, 0x02, 0x01, 0xff, 0xff, 0xff, 0xff,
X 0x04, 0x10, 0x20, 0x20, 0x04, 0x10, 0x20, 0x20, 0x04, 0x10, 0x20, 0x20,
X 0xff, 0xff, 0xff, 0xff, 0x41, 0x40, 0x00, 0x02, 0x41, 0x40, 0x00, 0x02,
X 0x41, 0x40, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x10, 0x08, 0x10, 0x10,
X 0x10, 0x08, 0x10, 0x10, 0x10, 0x08, 0x10, 0x10};
END_OF_FILE
if test 875 -ne `wc -c <'bitmap/wall.bits'`; then
echo shar: \"'bitmap/wall.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/wall.bits'
fi
if test -f 'bitmap/wall2.bits' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'bitmap/wall2.bits'\"
else
echo shar: Extracting \"'bitmap/wall2.bits'\" \(924 characters\)
sed "s/^X//" >'bitmap/wall2.bits' <<'END_OF_FILE'
X#define wall2_width 32
X#define wall2_height 32
X#define wall2_x_hot -1
X#define wall2_y_hot -1
Xstatic char wall2_bits[] = {
X 0xff, 0xff, 0xff, 0xff, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00, 0x81, 0x00,
X 0x81, 0x00, 0x81, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x08, 0x10, 0x08,
X 0x08, 0x08, 0x10, 0x08, 0x08, 0x08, 0x10, 0x08, 0xff, 0xff, 0xff, 0xff,
X 0x81, 0x00, 0x81, 0x00, 0x01, 0x00, 0x00, 0x00, 0x21, 0xba, 0xeb, 0x00,
X 0x6f, 0xab, 0x28, 0xfe, 0xa8, 0xaa, 0x28, 0x10, 0x28, 0xaa, 0x28, 0x10,
X 0x28, 0xba, 0x2a, 0x10, 0x2f, 0xaa, 0x2a, 0xfe, 0x21, 0xaa, 0x2a, 0x00,
X 0x21, 0xaa, 0x2a, 0x00, 0x21, 0xaa, 0xeb, 0x00, 0x0f, 0x00, 0x00, 0xff,
X 0x04, 0x10, 0x20, 0x20, 0x04, 0x10, 0x20, 0x20, 0x04, 0x10, 0x20, 0x20,
X 0xff, 0xff, 0xff, 0xff, 0x41, 0x40, 0x00, 0x02, 0x41, 0x40, 0x00, 0x02,
X 0x41, 0x40, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x10, 0x08, 0x10, 0x10,
X 0x10, 0x08, 0x10, 0x10, 0x10, 0x08, 0x10, 0x10};
END_OF_FILE
if test 924 -ne `wc -c <'bitmap/wall2.bits'`; then
echo shar: \"'bitmap/wall2.bits'\" unpacked with wrong size!
fi
# end of 'bitmap/wall2.bits'
fi
if test -f 'default' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'default'\"
else
echo shar: Extracting \"'default'\" \(956 characters\)
sed "s/^X//" >'default' <<'END_OF_FILE'
X26 35 15 12 0 0 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XS b b e bp S
XS www www w w w ww www www S
XS wrw wrw w w w w w w wrw S
XS www w w w w w w w ww www S
XS wrw wpw w w wn wrw w wwe S
XS wwwewwwlwww www ww www wnw S
XS S
XS bb bb S
XS gwww bwwwwwb wwwww w w S
XS wl w gw wg w w w S
XS w w w e w w w w S
XS wB wg w E w w w w S
XS wBB wg w w w w w S
XS wBB wg w w w w w S
XSgbg wBB wg w rw w wp w S
XSglg wBBBwg wwwww wwwwwl wwwww S
XSglg wBBBwg w rw w w w S
XSggg w wg w rew w w w S
XSglg w wg wgggw w w w S
XSgeg w w w w w w w S
XSgbg we w w w w w w S
XSg g gwww rw w wwwww w w S
XSg g S
XSgeg n pe n n ES
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 956 -ne `wc -c <'default'`; then
echo shar: \"'default'\" unpacked with wrong size!
fi
# end of 'default'
fi
if test -f 'levels/bdlev001' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev001'\"
else
echo shar: Extracting \"'levels/bdlev001'\" \(957 characters\)
sed "s/^X//" >'levels/bdlev001' <<'END_OF_FILE'
X26 35 9 18 10 30 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSpbb gdg g g g g gggggggggggggggS
XSggbb gdg g g bg g gggggggggggggggS
XSwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwggS
XSg ggg b g gd bgg b g g gS
XSg gg gbbgg g gg gb gbbgb g b S
XS gdbg g gggg bgbbggbbb g bggS
XSg ggbd g ggbg ggbbbgbbbS
XSg gWwwwwwwwwwwwwwwwwwwwwwwwwwwwwww
XSg bbgb gdgbbgd gggb b gb gggS
XSgbbgdgg gg bb gg g gggbggggbbdbggS
XSggggbg ggggbbggg gg gg gggggggbgS
XS g g ggbbdgbgdgggggggggggggggS
XSwwwwwwwwwwwwwwwwwwwwwwwwwwwwwgg gS
XSg dbg g ggggggbggbgb gggS
XSgd gg gbg gg g gdggggggggbgbgb gS
XS g wwwwwwwwwwwwwwwwwwwwwwwwwwww
XS ggg gdgbg g ggg ggggggggggdS
XSwww gg dgbg g ggggggggggggggggggS
XSE wggggbggg ggbgbggggbgg ggg bb gS
XSbbwggg gggggggbdbgbggggggggg ggggS
XSgbwwwwwwwwwwwwwwwwwwwwwwwwwwwgggbS
XSgbbgggggg gg b bdggggS
XSgbggdgggbggbbggbb b bbgb ggbbgbS
XSgg ggggbgbgggbbggbbgbbgbbggdbgggS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 957 -ne `wc -c <'levels/bdlev001'`; then
echo shar: \"'levels/bdlev001'\" unpacked with wrong size!
fi
# end of 'levels/bdlev001'
fi
if test -f 'levels/bdlev002' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev002'\"
else
echo shar: Extracting \"'levels/bdlev002'\" \(337 characters\)
sed "s/^X//" >'levels/bdlev002' <<'END_OF_FILE'
X15 20 14 30 10 30 200
XSSSSSSSSSSSSSSSSSSSS
XSp S
XSgb d S
XSgggwb d S
XSww wwgwb d S
XSww ww wwgwb d S
XSSw ww ww wwgwb d S
XSww ww ww ww wwgwb S
XSww ww ww ww ww wwgS
XSwS ww ww ww ww ww S
XSww ww ww ww ww ww S
XSEw ww ww ww ww ww S
XSwwrwwrwwrwwrwwrwwrS
XSwwwwwwwwwwwwwwwwwwS
XSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 337 -ne `wc -c <'levels/bdlev002'`; then
echo shar: \"'levels/bdlev002'\" unpacked with wrong size!
fi
# end of 'levels/bdlev002'
fi
if test -f 'levels/bdlev003' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev003'\"
else
echo shar: Extracting \"'levels/bdlev003'\" \(958 characters\)
sed "s/^X//" >'levels/bdlev003' <<'END_OF_FILE'
X26 35 13 20 10 30 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XS d w g g gwg g w wg gg w ggggwg lS
XSgg gbggdggwggg w w g b g bbb S
XSg gwbbg gggg b b gggwgggggwgg S
XSd dwlbgbggwg gwgwggggbwg ggwgdgS
XSwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwS
XSgg w g g wg g w w ggg w gggw gdS
XSg wgg g wgg bgggggggw b bb gS
XSbggdbgbg gbgg bwgwg gg ggbbwg dS
XSbbgwbbbbbbwbbbbwgwl gwbb gdwgdgS
XSwwwwwwwwwwwwwwwwgwwwwwwwwwwwwwwwwS
XSdg wggggggwg gwgwg g w wgggS
XSg bg ggggggg bg ggg gw gg gw S
XS dbwbg gwggggwg ggg b g gb d S
XSdbbwbbgl wggg wgwggggbwbg gbwb dS
XSwwwwwwwwwwwwwwwwgwwwwwwwwwwwwwwwwS
XSg wgg gggw g wgwg gg w g ggwgggS
XS g bgg g ggg wgggg gwggggg gggS
XSg gwggggg wgg bgwgg gg ggggwgggS
XSgdgwgl gdwggggwgwgggggwdggggw dgS
XSwwwwwwwwwwwwwwwwgwwwwwwwwwwwwwwwwS
XSgggwg gwgbg wgwg w gg gwgggS
XSggdb glggwgbg gg g ggwgggggwgggS
XSgggwg g gdbgbg pwggbggg ggggbgggS
XSgggwd bbwdbg Ewggbdgwg ggdwd bS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 958 -ne `wc -c <'levels/bdlev003'`; then
echo shar: \"'levels/bdlev003'\" unpacked with wrong size!
fi
# end of 'levels/bdlev003'
fi
if test -f 'levels/bdlev004' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev004'\"
else
echo shar: Extracting \"'levels/bdlev004'\" \(957 characters\)
sed "s/^X//" >'levels/bdlev004' <<'END_OF_FILE'
X26 35 5 100 5 15 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSbdbbdbdbbbbbdbbdddddbbbddbdbdddbbS
XSdgbbbbgbbdbbgbddddbdbbbbbbdbbdbbbS
XSgbdggbgdbgbbgdbdbbbbddbdbbbbbbbdbS
XSdgggdgdgbgbbggbbbbbbbbbbbbdddbbbbS
XSgdbdgdbgdgbbdggbbdddbddbbdbbbdddgS
XSggggggbbgbdggddgddbbbdbgddggggdggS
XSgdgbdgbdggdgbggggggggggdbgdddggggS
XSgdbgddgdgbdgddbddggdgbdddggggbddbS
XSddgdbbbgbdgdggdgdgdbbggbddgdbbbdbS
XSggbwwwwwgwwwwwgbgbdwwwwwgwwwwwbgbS
XSdgbw wdgdgdw wbdbS
XSbddw wgddbgw wdddS
XSgbgw Ep wdgbgdw wdddS
XSdddw wbdgddw wdddS
XSbbbw wggddgw wdddS
XSbdbw wdgggdw wddbS
XSgbbw wbdbdbw wdbbS
XSdgbwggWgggWggwdbdbbw wdddS
XSgdgw wbbdbdw wddbS
XSgdgw wbdbdbw wbdbS
XSbddw wwwwwww wbdbS
XSbdbw wbdbS
XSdbbw wbbddbw wbbdS
XSdbdwwwwwwwwwwwdddbdwwwwwwwwwwwbddS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 957 -ne `wc -c <'levels/bdlev004'`; then
echo shar: \"'levels/bdlev004'\" unpacked with wrong size!
fi
# end of 'levels/bdlev004'
fi
if test -f 'levels/bdlev005' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev005'\"
else
echo shar: Extracting \"'levels/bdlev005'\" \(957 characters\)
sed "s/^X//" >'levels/bdlev005' <<'END_OF_FILE'
X26 35 9 35 10 30 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSbgggggEgggggbpggbBbbggggggbgggggbS
XSgbgggggggbggggggBBbbggggggbggggbgS
XSggbggggggbgggggggggggbgbggbgggbbbS
XSgggggggggbggggggggggggbbgggggggggS
XSgggggbggggbggggggggggggbgggggggggS
XSgggggbgggggggbggggggggggbggggggggS
XSgbggbbggggggbbgggggbggggbgggggbbgS
XSggggggggbbggbbggggbbggggbbggggbbgS
XSgggggggbbbggbggbgbbbbgggbggggggbgS
XSgbbggggbggggggbbgggggbggggggggggbS
XSgbgggggbggggggggggggggggggbggggggS
XSgggggggggggggggggggbggggbbbggbgggS
XSggggggggggggggggggbbggggggbggbgggS
XSbbggggggbbbggbggggggggggggggggbggS
XSbbggbggggbbggbggbgggbgggggggggbggS
XSbgggbggggbggbbggggggbbgggbgggbgbgS
XSbggggggggbgggbgbgggggbggbbgggggggS
XSgggggbbgbbgggbggbggggbggbbbggggggS
XSggbgggbggbggbbggggggbbbgbgbgggggbS
XSggbgwwwwwwwwwwwwwwwwwwwwwwwwwggggS
XSggggr r r r r r r r r r r r rgbggS
XSbgggbbbbbbbbbbbbbbbbbbbbbbbbbggggS
XSggggggggggggggggggggggggggggggbggS
XSggggggggggggggggggggggggggggbggggS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 957 -ne `wc -c <'levels/bdlev005'`; then
echo shar: \"'levels/bdlev005'\" unpacked with wrong size!
fi
# end of 'levels/bdlev005'
fi
if test -f 'levels/bdlev006' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev006'\"
else
echo shar: Extracting \"'levels/bdlev006'\" \(959 characters\)
sed "s/^X//" >'levels/bdlev006' <<'END_OF_FILE'
X26 35 14 4 100 200 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSpggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggg gggg gggg ggggl gggggS
XSgggg gggg ggggl gggg gggggS
XSgggg dlggggld gggg d gggg d gggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggg gggg gggg ggggl gggggS
XSgggg gggg ggggl gggg gggggS
XSgggg dlggggld gggg d gggg d gggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSggggggggggggggggggggggggggggggggES
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 959 -ne `wc -c <'levels/bdlev006'`; then
echo shar: \"'levels/bdlev006'\" unpacked with wrong size!
fi
# end of 'levels/bdlev006'
fi
if test -f 'levels/bdlev007' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev007'\"
else
echo shar: Extracting \"'levels/bdlev007'\" \(959 characters\)
sed "s/^X//" >'levels/bdlev007' <<'END_OF_FILE'
X26 35 14 4 100 200 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSwwwwwwwbgbggggbgggggggggggwwwwwwwS
XS ggbggbgggggbggbgggg S
XSdl gggggggggggggggggbgl dS
XSwwwwwwwgggbgbgbggbggggggbgwwwwwwwS
XSwwwwwwwbggggbgggggggggggggwwwwwwwS
XS ggbgbbgggggggbgbggg S
XSdl gbbggggbbggggggggggl dS
XSwwwwwwwgggggggggggbgggggggwwwwwwwS
XSwwwwwwwgggggbgggggggbggbggwwwwwwwS
XS ggggggggbbggbgggggg S
XSdl gbbgbgbggggggggggggl dS
XSwwwwwwwgggggggggggggggbgggwwwwwwwS
XSwwwwwwwgbgggbggbgbgbggggggwwwwwwwS
XS ggggbggbgbgggggggbg S
XSdl gbggggggggggbggggggl dS
XSwwwwwwwggggggbggggggggbgggwwwwwwwS
XSwwwwwwwggbbggggggbbgggggggwwwwwwwS
XSggggggggggggggggbbggbgbggggggggggS
XSggbgggggggbbgbggggggggggbggggggggS
XSggbgbggggbggggggbggggggggggggggggS
XSggggggggbggggggglggg gggggggbgggS
XSgggggggbgggggbggggggl ggbggggggggS
XSggpggbggggggggbgggbggggggggggggggS
XSggggbggbggggggggggggggggggggggggES
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 959 -ne `wc -c <'levels/bdlev007'`; then
echo shar: \"'levels/bdlev007'\" unpacked with wrong size!
fi
# end of 'levels/bdlev007'
fi
if test -f 'levels/bdlev008' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev008'\"
else
echo shar: Extracting \"'levels/bdlev008'\" \(958 characters\)
sed "s/^X//" >'levels/bdlev008' <<'END_OF_FILE'
X26 35 15 50 10 20 150
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggwwwwwwwwwwwwggggggggggggS
XSgggggggggwBBBBB ggggggggggggS
XSgggggggggwwwwwwwwwwwwggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSggggggggggggggggggrrrggggggggggggS
XSggggggggggggggggggrrrggggggggggggS
XSggggggggggggggggggrrrggggggggggggS
XSggggggggggggggggggrrrggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggpES
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 958 -ne `wc -c <'levels/bdlev008'`; then
echo shar: \"'levels/bdlev008'\" unpacked with wrong size!
fi
# end of 'levels/bdlev008'
fi
if test -f 'levels/bdlev009' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev009'\"
else
echo shar: Extracting \"'levels/bdlev009'\" \(958 characters\)
sed "s/^X//" >'levels/bdlev009' <<'END_OF_FILE'
X26 35 12 10 25 25 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSgggggggggggggggggggggggggggggggggS
XSpggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggw w w w w wgbbbbbbbbbbbbbbbgS
XSgggggw w w w w wgggggggggggggggggS
XSgggggwlwlwlwlwlwgggggggggggggggggS
XSgggggwdwdwdwdwdwgggggggggggggggggS
XSgggggwwwwwwwwwwwgggggggggggggggggS
XSgggggwdwdwdwdwdwgggggggggggggggggS
XSgggggwgwgwgwgwgwgggggggggggggggggS
XSgggggwlwlwlwlwlwgggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggw w w w w wgggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSggggggggggggggggggggggggggggggggES
XSgggggggggggggggggggggggggggggggggS
XSgggggggggggggggggggggggggggggggggS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 958 -ne `wc -c <'levels/bdlev009'`; then
echo shar: \"'levels/bdlev009'\" unpacked with wrong size!
fi
# end of 'levels/bdlev009'
fi
if test -f 'levels/bdlev010' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev010'\"
else
echo shar: Extracting \"'levels/bdlev010'\" \(958 characters\)
sed "s/^X//" >'levels/bdlev010' <<'END_OF_FILE'
X26 35 11 25 10 30 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSbgbggggbgbgggpgbgbgbgggbg b dggbS
XSggglb ggg g ggg gbgg ggggbbggg gS
XSdgbgg gg bg gg ggg gbbgdbdbS
XSSSSSSSSg bgg gggg g ggb gSSSSSSSS
XS ggbggggbgbgg ggg g gbg gggg S
XS g g gg bb g b gggggbgg g S
XSlbdgbbgblbgbbg gbbgbgg gg gg gl S
XSEgbgggggbg ggbg ggbglg gbbggggbddS
XSSSSSSSSggbggbg b bg bgggggSSSSSSSS
XSgbbggbgb g ggg ggg gbbg g g ggggbS
XS bg gggbggg b gbb ggbg ggg ggg S
XSggb gggg g gg ggbgbg bgbbg gbgggS
XSggbgg lgbggg gg g g gbgggbbgbgggS
XSbbbg ggbgg g b gg g ggggbggggg g S
XSgggg gbggbg gg g gb ggggg ggS
XS gbgl gg gg ggb ggbg gl g b bgS
XSbggggggg b bgb ggg bg bggg glggS
XSg g gbgbggggbg g gg g gggg ggS
XSg lgggbggg gbg ggg bgbgbgbggggggS
XS gb gg g g gg gggg gg gggbgS
XSgggggg g gggggg g g gggggbggS
XSbggb gggg g B Bgggl ggb g bbggS
XSgg gb g gggg BBBB gggg gggg gbggS
XSbggbgg gggglgBBBBBBBgg g g gbggg S
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 958 -ne `wc -c <'levels/bdlev010'`; then
echo shar: \"'levels/bdlev010'\" unpacked with wrong size!
fi
# end of 'levels/bdlev010'
fi
if test -f 'levels/bdlev011' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev011'\"
else
echo shar: Extracting \"'levels/bdlev011'\" \(959 characters\)
sed "s/^X//" >'levels/bdlev011' <<'END_OF_FILE'
X26 35 15 12 50 250 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XS S Sl S
XS SSS S S S S SSS S
XS S dS S SSS S Sd S S
XS S SSS S SlS S SSS S S
XSd S rSSS S dS
XSSSSSSSSSSS S S SSSSSSSSSSS
XS S
XS S
XS SSS S S SSS S
XS Sl S SSSSS SSSSS S Sl S
XS S S d S S S
Xd S Sl E Sl S d
XS S S SSSSSSSSSSSSS S S S
XS S S S S S
XS S S d S S S
XSSSSSS SSSSSS S SSSSSS SSSSSS
XS S
XSl S
XS S SSSSSSSSSS SSSSSSSSSS S S
XS S S S S S
XS S S S S S
XS S S SSSSSSS SSSSSSS S S S
XS S S S S S S S
XSd S S dS p Sd S S dS
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 959 -ne `wc -c <'levels/bdlev011'`; then
echo shar: \"'levels/bdlev011'\" unpacked with wrong size!
fi
# end of 'levels/bdlev011'
fi
if test -f 'levels/bdlev012' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev012'\"
else
echo shar: Extracting \"'levels/bdlev012'\" \(335 characters\)
sed "s/^X//" >'levels/bdlev012' <<'END_OF_FILE'
X15 20 15 75 5 15 64
XSSSSSSSSSSSSSSSSSSSS
XSbbbbbbbbbbbbbbbbbbS
XSggggggwwwwwwwwwwwwS
XSggggggbbgggrggrggrS
XSggggggwwwgggggggggS
XSggggggwwwgggggggggS
XSggggggwwwrgBBBBBgeS
XSgggggpwwwggBBBBBggS
XSgww wwwwwrggBeBBggS
XS wwwwwwwwwwwS
XS wwwwwwwwwwwS
XS w gggbBBBBBBBS
XS wwwwE S
XSr wwwww e S
XSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 335 -ne `wc -c <'levels/bdlev012'`; then
echo shar: \"'levels/bdlev012'\" unpacked with wrong size!
fi
# end of 'levels/bdlev012'
fi
if test -f 'levels/bdlev013' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev013'\"
else
echo shar: Extracting \"'levels/bdlev013'\" \(959 characters\)
sed "s/^X//" >'levels/bdlev013' <<'END_OF_FILE'
X26 35 15 4 100 300 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSggggggggggggggggggggggggggggggddlS
XSgwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwS
XSgwwwb glS
XSgwbwg g S
XSgwggw SS SSS S S SS SSS g S
XSgwgww S S S SS S S S S ggS
XSgwgww wg S SSS S SS SS SS glS
XSgwgww wg S S S S S S S S g S
XSgwgww wg SS S SbS S SS SSS g S
XSgwgww wg ggg ggS
XSgwggw wg ggg glS
XSgwwwwwwg b g S
XSgwwwwwwgggggggggggg g S
XSgwwwwwwwwwgwwww wwwww Sg S
XSgWwwwwwww wwww wwwww Sg S
XSgwwwwwww wwSSw SSSwS S SSS SggS
XSgwwwwww wwwS S S SwSS S S SglS
XSgwwwww wwwwS S S SwS SS SS Sg S
XSgwwww wwwwwS S S SwS S S g S
XSgwww wwwwwwSSw SSSwS S SSS Sg S
XSgww wwwwwwwwww wwwww ggS
XSgw wwwwwwwwwgwpwwwww glS
XSgw wwwwwwwwwwgwwwwwww g S
XSdw wwdggggggggggdWwww g S
XSSSSSSESSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 959 -ne `wc -c <'levels/bdlev013'`; then
echo shar: \"'levels/bdlev013'\" unpacked with wrong size!
fi
# end of 'levels/bdlev013'
fi
if test -f 'levels/bdlev014' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev014'\"
else
echo shar: Extracting \"'levels/bdlev014'\" \(227 characters\)
sed "s/^X//" >'levels/bdlev014' <<'END_OF_FILE'
X12 16 15 15 10 100 200
XSSSSSSSSSSSSSSdS
XSbbbSbdbdbdSdbbS
XSbSd bbdbSb bdbS
XSb dbbdSd dbSbbS
XSdbdSdb bSdd ddS
XSddbddbdd bSdbbS
XSSbbdSdbddb dddS
XS dbb bbdSddSbSS
XSbSdbdbdd bb b S
XSdbdbbdbbSdbSdbS
XSbbdpSdbd bb bbS
XSSSSSSSSSSSSSSES
END_OF_FILE
if test 227 -ne `wc -c <'levels/bdlev014'`; then
echo shar: \"'levels/bdlev014'\" unpacked with wrong size!
fi
# end of 'levels/bdlev014'
fi
if test -f 'levels/bdlev016' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev016'\"
else
echo shar: Extracting \"'levels/bdlev016'\" \(192 characters\)
sed "s/^X//" >'levels/bdlev016' <<'END_OF_FILE'
X10 16 15 17 30 30 200
Xwwwwwwwwwwwwwwww
XwlllllllllllgbEw
Xwblllllllllgbdgw
XwpdlllllllgbdgSw
XwddblllllgbdgSww
Xw ddblllgbdgSwww
XwwSddbllbdgSwwww
XwwwSddbbdgSwwwww
XwwwwSdddgSwwwwww
Xwwwwwwwwwwwwwwww
END_OF_FILE
if test 192 -ne `wc -c <'levels/bdlev016'`; then
echo shar: \"'levels/bdlev016'\" unpacked with wrong size!
fi
# end of 'levels/bdlev016'
fi
if test -f 'levels/bdlev017' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev017'\"
else
echo shar: Extracting \"'levels/bdlev017'\" \(165 characters\)
sed "s/^X//" >'levels/bdlev017' <<'END_OF_FILE'
X4 35 15 66 8 100 200
XSdbgdgddgdbgddgbdgdddgbdgdgdbgddgdS
XEgddbgbdddggbddgbgdbddgddbddgddgddS
XpggdgdgbdbddgbddgdbggddbdgdgddbgdbS
XSddgdddgggdddggdddgdgbdggdbgdbgdbgS
END_OF_FILE
if test 165 -ne `wc -c <'levels/bdlev017'`; then
echo shar: \"'levels/bdlev017'\" unpacked with wrong size!
fi
# end of 'levels/bdlev017'
fi
if test -f 'levels/bdlev018' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev018'\"
else
echo shar: Extracting \"'levels/bdlev018'\" \(957 characters\)
sed "s/^X//" >'levels/bdlev018' <<'END_OF_FILE'
X26 35 15 64 8 25 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XSp b b b b b b bb g b gbg g S
XSg ggggggbgbb bgbbbgb bggdbgg dbgS
XSgdggbdbdgb gbbdbdb bbdgb ggggb g S
XS gbdg bgdgbgbbbbgbbbbbgbdb dggg gS
XSgbgbbbbdgbbbgbgbdgbgd gbbbbgdb bgS
XSgbgggbbbbgbbbbg bbdg bbgbggddd b S
XSgb bdbgggdgdb bggbb g bdb bb gdbgS
XSgbbdgbbb b bbdbbgbd g gdbgbbggbgS
XSggbbgbdgbggbgggbgbbggbbbdbbgbggg S
XS bggbbgdgbdbg ddbgddbbbbgbbbd bbgS
XSgdgb bgbbbbbggbEggbgbbgdbgb ggdb S
XS b ggbgbgggbbbbgbbbb gb gbbbbgbbgS
XS gbdgbgbbbbbbb bbbbgbgbgbbdgbggbgS
XS bggbdgbb b gbg gdbbdb ggdbdgb S
XSgbggdbgbbgg bb bgd bbbbbgbgb bggS
XSgggd bbbgbgbggggbdbgbdbgb dggbgbgS
XS gbgbbbgbdbbg bbbbgd bbgbgbb ggggS
XSgbg gggg gb bbbdgb g gbbbbgdg d S
XSgggbbb bbgbggdggdbgdb dgd g gbgbgS
XSgdgbdbgdbdb b b bb bggbbgbdgg b gS
XSgbbgdgbbbgbbbbg gdb dbbgbgg ggdggS
XSgbgbgbgbgbgbggbgdbbggggbgbd g bggS
XSg gggdbgb bbgbg gb bbgbgbgb d gS
XSgdg bgggggbb g gggggggdggbgdgggggS
XSSSSSSSSSSSSSSSSSSSdSSSSSSSSSSSSSSS
END_OF_FILE
if test 957 -ne `wc -c <'levels/bdlev018'`; then
echo shar: \"'levels/bdlev018'\" unpacked with wrong size!
fi
# end of 'levels/bdlev018'
fi
if test -f 'levels/bdlev019' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev019'\"
else
echo shar: Extracting \"'levels/bdlev019'\" \(439 characters\)
sed "s/^X//" >'levels/bdlev019' <<'END_OF_FILE'
X26 15 15 13 25 100 200
XSSSSSSSSSSSSSSS
XSgb dw S
XSgwwwwwwwwwwwwS
XSggwpbblbdd ewS
XSgwwgwwwwggggwS
XSggggwwwwggggwS
XSgwwgggggggggwS
XSgwwwgwwwwwwwwS
XSgw wwwbbbb wBS
XSgwgwwwbbwgww S
XSgwggbgbww w S
XSgwwgwgww w S
XSgwwgwgw ww BS
XSgwwnwgw ww S
XSgwwwwgw w Be S
XSn wgw wB SS
XS wwwwgw wB BBS
XS wggggw w BS
XS wgbwww wS S
XS wgwww w e S
XS wgww ww e SS
XSlwdww wwB B S
XS wgww w S
XS wgww w e S
XS ggWwlwB SBES
XSSSSSSSSSSSSSSS
END_OF_FILE
if test 439 -ne `wc -c <'levels/bdlev019'`; then
echo shar: \"'levels/bdlev019'\" unpacked with wrong size!
fi
# end of 'levels/bdlev019'
fi
if test -f 'levels/bdlev020' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'levels/bdlev020'\"
else
echo shar: Extracting \"'levels/bdlev020'\" \(956 characters\)
sed "s/^X//" >'levels/bdlev020' <<'END_OF_FILE'
X26 35 15 12 0 0 200
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
XS E S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS p S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS S
XS b b b b b b b S
XSwgwgwgwgwgwgwgwwwwwwwwwwwwwwwwwwwS
XSnl nl nl nl nl S
XSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
END_OF_FILE
if test 956 -ne `wc -c <'levels/bdlev020'`; then
echo shar: \"'levels/bdlev020'\" unpacked with wrong size!
fi
# end of 'levels/bdlev020'
fi
if test -f 'scores' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'scores'\"
else
echo shar: Extracting \"'scores'\" \(459 characters\)
sed "s/^X//" >'scores' <<'END_OF_FILE'
X4820 1 9 276 houttuin
X2690 4 7 276 houttuin
X2450 14 16 276 houttuin
X2370 1 4 276 ean
X2000 9 11 276 houttuin
X1904 17 18 276 houttuin
X1800 6 8 276 houttuin
X1460 2 4 276 houttuin
X1310 2 4 276 root
X1260 2 4 276 houttuin
X1230 16 16 276 root
X1210 4 5 276 houttuin
X1190 2 2 276 houttuin
X1140 14 15 276 houttuin
X1110 2 3 276 houttuin
X1050 14 15 276 houttuin
X1050 14 14 276 houttuin
X1000 17 17 276 houttuin
X970 1 3 276 houttuin
X825 19 20 276 houttuin
END_OF_FILE
if test 459 -ne `wc -c <'scores'`; then
echo shar: \"'scores'\" unpacked with wrong size!
fi
# end of 'scores'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked both 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