Article 2756 of comp.sources.unix:
Submitted-By: mik@cs.su.oz.au (Michael Koelling)
Posting-Number: Volume 29, Issue 96
Archive-Name: red-96/part01

Red runs under Unix and X Windows.  You need X Windows, Motif and a C++
compiler to install and run Red.

Red has not been ported to many platforms yet.  It has been tested on
Solaris 2.4, Solaris 2.5, SunOS4, and Linux. (Compiled on all systems with
g++)

Red's features include:

    Graphical interface 
    Full mouse and key support 
    40 step undo (and redo) 
    User-definable key bindings 
    Automatic backup creation 
    Cut/paste exchange with other X Windows applications 
    On-line function list, help and manual 

	mik@cs.su.oz.au (Michael Koelling)

#!/bin/sh
# This is a shell archive (produced by GNU sharutils 4.1).
# To extract the files from this archive, save it to some FILE, remove
# everything before the `!/bin/sh' line above, then type `sh FILE'.
#
# Made on 1996-05-13 00:12 PDT by <vixie@gw.home.vix.com>.
# Source directory was `/tmp_mnt/bb/bb1/CSU/New'.
#
# Existing files will *not* be overwritten unless `-c' is specified.
#
# This is part 1 of a multipart archive.                                   
# Do not concatenate these parts, unpack them in order with `/bin/sh'.     
#
touch -am 1231235999 $$.touch >/dev/null 2>&1
if test ! -f 1231235999 && test -f $$.touch; then
  shar_touch=touch
else
  shar_touch=:
  echo
  echo 'WARNING: not restoring timestamps.  Consider getting and'
  echo "installing GNU \`touch', distributed in GNU File Utilities..."
  echo
fi
rm -f 1231235999 $$.touch
#
if test -r _sharseq.tmp; then
  echo 'Must unpack archives in sequence!'
  echo Please unpack part `cat _sharseq.tmp` next
  exit 1
fi
# ============= Red/Bitmaps/alpha.xbm ==============
if test ! -d 'Red'; then
  echo 'x - creating directory Red'
  mkdir 'Red'
fi
if test ! -d 'Red/Bitmaps'; then
  echo 'x - creating directory Red/Bitmaps'
  mkdir 'Red/Bitmaps'
fi
if test -f 'Red/Bitmaps/alpha.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/alpha.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/alpha.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/alpha.xbm' &&
X#define alpha_width 32
X#define alpha_height 14
Xstatic char alpha_bits[] = {
X   0x00, 0xc6, 0x03, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, 0x07, 0x03, 0x00,
X   0x80, 0x86, 0x01, 0x00, 0x80, 0x86, 0x01, 0x00, 0x40, 0x86, 0x0f, 0x07,
X   0x40, 0xc6, 0x9d, 0x0f, 0x20, 0xc6, 0xd8, 0x09, 0xe0, 0xc7, 0xd8, 0x08,
X   0x10, 0x66, 0xf8, 0x00, 0x10, 0x66, 0xec, 0x00, 0x08, 0x66, 0xee, 0x08,
X   0x18, 0xef, 0xe7, 0x07, 0xbe, 0xdf, 0xc3, 0x03};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/alpha.xbm' &&
  chmod 0640 'Red/Bitmaps/alpha.xbm' ||
  echo 'restore of Red/Bitmaps/alpha.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/alpha.xbm'`"
  test 428 -eq "$shar_count" ||
    echo "Red/Bitmaps/alpha.xbm: original size 428, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/alpha_disab.xbm ==============
if test -f 'Red/Bitmaps/alpha_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/alpha_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/alpha_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/alpha_disab.xbm' &&
X#define alpha_disab_width 32
X#define alpha_disab_height 14
Xstatic char alpha_disab_bits[] = {
X   0x00, 0x44, 0x01, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x05, 0x01, 0x00,
X   0x80, 0x82, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x82, 0x0a, 0x02,
X   0x40, 0x44, 0x15, 0x05, 0x20, 0x82, 0x88, 0x08, 0x40, 0x45, 0x50, 0x00,
X   0x00, 0x22, 0xa8, 0x00, 0x10, 0x44, 0x44, 0x00, 0x08, 0x22, 0xaa, 0x08,
X   0x10, 0x45, 0x45, 0x05, 0xaa, 0x8a, 0x82, 0x02};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/alpha_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/alpha_disab.xbm' ||
  echo 'restore of Red/Bitmaps/alpha_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/alpha_disab.xbm'`"
  test 446 -eq "$shar_count" ||
    echo "Red/Bitmaps/alpha_disab.xbm: original size 446, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrow.xbm ==============
if test -f 'Red/Bitmaps/arrow.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrow.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrow.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrow.xbm' &&
X#define arrow_width 32
X#define arrow_height 14
Xstatic char arrow_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x80, 0x1f,
X   0x00, 0x00, 0x80, 0x7f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x80, 0x7f,
X   0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x80, 0x01,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrow.xbm' &&
  chmod 0640 'Red/Bitmaps/arrow.xbm' ||
  echo 'restore of Red/Bitmaps/arrow.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrow.xbm'`"
  test 428 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrow.xbm: original size 428, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrow_disab.xbm ==============
if test -f 'Red/Bitmaps/arrow_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrow_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrow_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrow_disab.xbm' &&
X#define arrow_disab_width 32
X#define arrow_disab_height 14
Xstatic char arrow_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x15,
X   0x00, 0x00, 0x80, 0x2a, 0x55, 0x55, 0x55, 0x55, 0x00, 0x00, 0x80, 0x2a,
X   0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x00, 0x01,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrow_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/arrow_disab.xbm' ||
  echo 'restore of Red/Bitmaps/arrow_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrow_disab.xbm'`"
  test 446 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrow_disab.xbm: original size 446, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrowhead_down.xbm ==============
if test -f 'Red/Bitmaps/arrowhead_down.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrowhead_down.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrowhead_down.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrowhead_down.xbm' &&
X#define arrowhead_down_width 9
X#define arrowhead_down_height 9
Xstatic char arrowhead_down_bits[] = {
X   0xfe, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x00, 0x38, 0x00, 0x38, 0x00,
X   0x38, 0x00, 0x10, 0x00, 0x10, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrowhead_down.xbm' &&
  chmod 0640 'Red/Bitmaps/arrowhead_down.xbm' ||
  echo 'restore of Red/Bitmaps/arrowhead_down.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrowhead_down.xbm'`"
  test 216 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrowhead_down.xbm: original size 216, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrowhead_left.xbm ==============
if test -f 'Red/Bitmaps/arrowhead_left.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrowhead_left.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrowhead_left.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrowhead_left.xbm' &&
X#define arrowhead_left_width 9
X#define arrowhead_left_height 9
Xstatic char arrowhead_left_bits[] = {
X   0x00, 0x00, 0x00, 0x01, 0xe0, 0x01, 0xfc, 0x01, 0xff, 0x01, 0xfc, 0x01,
X   0xe0, 0x01, 0x00, 0x01, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrowhead_left.xbm' &&
  chmod 0640 'Red/Bitmaps/arrowhead_left.xbm' ||
  echo 'restore of Red/Bitmaps/arrowhead_left.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrowhead_left.xbm'`"
  test 216 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrowhead_left.xbm: original size 216, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrowhead_right.xbm ==============
if test -f 'Red/Bitmaps/arrowhead_right.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrowhead_right.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrowhead_right.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrowhead_right.xbm' &&
X#define arrowhead_right_width 9
X#define arrowhead_right_height 9
Xstatic char arrowhead_right_bits[] = {
X   0x00, 0x00, 0x01, 0x00, 0x0f, 0x00, 0x7f, 0x00, 0xff, 0x01, 0x7f, 0x00,
X   0x0f, 0x00, 0x01, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrowhead_right.xbm' &&
  chmod 0640 'Red/Bitmaps/arrowhead_right.xbm' ||
  echo 'restore of Red/Bitmaps/arrowhead_right.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrowhead_right.xbm'`"
  test 219 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrowhead_right.xbm: original size 219, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/arrowhead_up.xbm ==============
if test -f 'Red/Bitmaps/arrowhead_up.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/arrowhead_up.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/arrowhead_up.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/arrowhead_up.xbm' &&
X#define arrowhead_up_width 9
X#define arrowhead_up_height 9
Xstatic char arrowhead_up_bits[] = {
X   0x10, 0x00, 0x10, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x7c, 0x00,
X   0x7c, 0x00, 0x7c, 0x00, 0xfe, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/arrowhead_up.xbm' &&
  chmod 0640 'Red/Bitmaps/arrowhead_up.xbm' ||
  echo 'restore of Red/Bitmaps/arrowhead_up.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/arrowhead_up.xbm'`"
  test 210 -eq "$shar_count" ||
    echo "Red/Bitmaps/arrowhead_up.xbm: original size 210, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/blue.coloricon ==============
if test -f 'Red/Bitmaps/blue.coloricon' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/blue.coloricon (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/blue.coloricon (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/blue.coloricon' &&
X! XPM2  
X64 64 6 1
X  c #CCCCCCCCCCCC
X. c #2D2D5B5BE5E5
XX c #5B5B7E7EE5E5
Xo c #26264C4CBFBF
XO c #FFFFFFFFFFFF
X+ c #000000000000
X                                                                
X                                                                
X                                                                
X                                                                
X                                                                
X                                                      .. ..     
X                                                     .XX.o      
X                                 .                 ...XXoo.     
X                               ..o                ...OXXoX.     
X                              ...o               ...OOXoX....   
X                            .....    ..         ......o..O..o.  
X                           ...O.o.  ...        ..XX.XX..O+. o   
X                           ..O.oo ....o       ..XXXX..O+++OO. . 
X                          ..O..o...X.o       ..XXX..O++++++O..o 
X                         ...XXo..XXX.o      .XXXXXO+++++++OO.o  
X                        ...XXooXXXX.o.     .XX.XX+++++++OOOoo   
X                 OOOO   ...XXXXXXX......  ...OO.O++++++OOOXX    
X              O+++++++O...XXXXXXX..X........O++OO+++++OOXX.     
X            O++++++++++O...XXX.XX.oXXOOO....+++OO+++OOOX..      
X          O+++++++++++++O..XXXXX..XXX+++OO.X+++OO+++OOX++OO     
X        +++++++++OOO++++O...XXX..XXXX+++OOXX+++OO+++O+++++OO    
X      +++++++++OOOOOO+++O.......XXXXX+++OOXX+++OO+++++++++OO    
X      ++++++OOOOO   X+++O.OOO. .XXX..+++OOXX+++OO+++++++OOOO    
X       +++++OOO    XX+++O.+++OOXXX..+++OOOXX+++OO+++++OOO       
X       OO+++OO    XX++++O++++OO.XX.X+++OOXXX+++OO++++OO   ++O   
X       OO+++OO   XX +++OO+++OO..X.oX+++OOXXX+++OOX+++OO ++++OO  
X         +++OO   X ++++O.+++OO.XX.XX+++OOXX++++OOX++++++++++OO  
X         +++OO  XX++++OO.+++OO.X.oXX+++OOXX++++OOX++++++++++OO  
X         +++OO XX++++OO..+++OO...XXX+++OOXX++++OOX+++++++OOOOO  
X         +++OO +++++OO...+++OOXooXXX+++OO.X+++++OOX+++OOOOOOO   
X         +++O+++++OOO....+++OO.oXXXX+++OOO++++++OOXOOOOOOO      
X         +++++++++++++O..+++OO.XXXXX++++O+++O+++OOXOOOO         
X         ++++++++++++++O.+++OO.XX.XX++++++++OOOOOO              
X         ++++++++++++++O.+++OOXXXXXXO++++++OOOOOX               
X         ++++OOOOOO+++++O+++OOXXX+OOX++++OOOOXXXX               
X        ++++OOOOOOOO++++O+++OOX+++OOXXOOOOOOXXXo                
X        +++OOXXXXXXO++++O+++OO++++OOXXXOOOOXX.o                 
X        +++OOXXXXXXX++++O+++++++++OOXXXXXXXXoo                  
X        +++OOXXXXoXX+++OO+++++++OOOOXXXXXXXoo                   
X        +++OOXXooXX++++OO+++++OOOOXXX..XXXXo                    
X        +++OOXXoXXX++++OOO++OOOOOXXX.XXXXXo                     
X       +++OOXoooXX++++OOXX+OOOXXXX..XXXXX.o                     
X      .+++OOXoXXX+++++OOXXOOXXXXX..XXXXX.o                      
X      .+++OOXXX++++++OOXXXOXXXXX..oXXXX.o                       
X      ++++OOX+++++++OO.XXXXXXXX.ooXXXXXo                        
X      +++O+++++++++OO.XX.XXXXXXooXXX.X.o                        
X     .+++++++++++OOO.XX. ..XX.oXXXXOX..                         
X     +++++++++OOOOO.XX.o   ..ooXX.O.Xoo                         
X   +++++++++OOOOO..XX.o   .o . XXO.XX.                          
X   +++++++OOOO....XX..   .o   ..XXX..                           
X   ++++OOOOO....XoXXo    .    .o..X.o                           
X   OOOOOO...XXX.o.X.     .   .o  ...                            
X   OOOOXXX.XX..o..Xo             ..o                            
X   .XXXX...XX.oO..o             .o.                             
X  .XXX..oXXX..O...o             ..                              
X  .....oXXXXooXX.o              .                               
X  .. .ooXX..oXX..o                                              
X  .  .o.X......X.o                                              
X       ... .  .Xo                                               
X       ...   ..oo                                               
X        .                                                       
X                                                                
X                                                                
X                                                                
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/blue.coloricon' &&
  chmod 0640 'Red/Bitmaps/blue.coloricon' ||
  echo 'restore of Red/Bitmaps/blue.coloricon failed'
  shar_count="`wc -c < 'Red/Bitmaps/blue.coloricon'`"
  test 4287 -eq "$shar_count" ||
    echo "Red/Bitmaps/blue.coloricon: original size 4287, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/blue_icon.xbm ==============
if test -f 'Red/Bitmaps/blue_icon.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/blue_icon.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/blue_icon.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/blue_icon.xbm' &&
X#define blue_icon_width 48
X#define blue_icon_height 48
Xstatic char blue_icon_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x0f, 0x00, 0x00,
X   0x80, 0x00, 0x00, 0x08, 0x00, 0x00, 0x80, 0x00, 0x00, 0x08, 0x00, 0x00,
X   0x80, 0x00, 0x00, 0x08, 0x00, 0x00, 0x80, 0x00, 0x00, 0x08, 0xe0, 0x3f,
X   0x80, 0x00, 0x00, 0x08, 0x22, 0x20, 0x80, 0x00, 0x00, 0x08, 0x26, 0x20,
X   0x80, 0x00, 0x00, 0x08, 0x2e, 0x20, 0x80, 0x00, 0x00, 0xf8, 0x3f, 0x20,
X   0x80, 0x00, 0x00, 0x08, 0x2e, 0x20, 0x80, 0x00, 0x00, 0x08, 0x26, 0x20,
X   0x80, 0x00, 0x00, 0x08, 0x22, 0x20, 0x80, 0x00, 0x00, 0x08, 0x20, 0x20,
X   0x80, 0x00, 0x00, 0x08, 0x20, 0x20, 0x80, 0xff, 0xff, 0x0f, 0xe0, 0x3f,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x80, 0x1f, 0x00, 0x00,
X   0x00, 0xf8, 0x80, 0x0f, 0x00, 0x00, 0x00, 0xf8, 0x80, 0x0f, 0x00, 0x00,
X   0x00, 0xec, 0x80, 0x1b, 0x00, 0x00, 0x00, 0xf6, 0x80, 0x37, 0x00, 0x00,
X   0x00, 0x9b, 0x80, 0x6c, 0x00, 0x00, 0x80, 0x0d, 0x00, 0xd8, 0x00, 0x00,
X   0xfc, 0xff, 0x0f, 0xfc, 0xff, 0x0f, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0x04, 0x00, 0x08,
X   0x04, 0x00, 0x08, 0x04, 0x00, 0x08, 0xfc, 0xff, 0x0f, 0xfc, 0xff, 0x0f,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/blue_icon.xbm' &&
  chmod 0640 'Red/Bitmaps/blue_icon.xbm' ||
  echo 'restore of Red/Bitmaps/blue_icon.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/blue_icon.xbm'`"
  test 1889 -eq "$shar_count" ||
    echo "Red/Bitmaps/blue_icon.xbm: original size 1889, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/blue_icon.xbm~ ==============
if test -f 'Red/Bitmaps/blue_icon.xbm~' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/blue_icon.xbm~ (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/blue_icon.xbm~ (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/blue_icon.xbm~' &&
X#define blue_icon__width 64
X#define blue_icon_height 48
Xstatic unsigned char blue_icon_bits[] = {
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
X  0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff,
X  0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X  };
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/blue_icon.xbm~' &&
  chmod 0640 'Red/Bitmaps/blue_icon.xbm~' ||
  echo 'restore of Red/Bitmaps/blue_icon.xbm~ failed'
  shar_count="`wc -c < 'Red/Bitmaps/blue_icon.xbm~'`"
  test 2471 -eq "$shar_count" ||
    echo "Red/Bitmaps/blue_icon.xbm~: original size 2471, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/blue_icon64x48.xbm ==============
if test -f 'Red/Bitmaps/blue_icon64x48.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/blue_icon64x48.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/blue_icon64x48.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/blue_icon64x48.xbm' &&
X#define blue_icon_width 64
X#define blue_icon_height 48
Xstatic char blue_icon_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, 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, 0x7f, 0x00, 0x00,
X   0xf0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff,
X   0xff, 0x7f, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff,
X   0xf7, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xf7, 0x1f, 0x00, 0xf0,
X   0xff, 0x7f, 0xff, 0xff, 0xf7, 0xdd, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff,
X   0xf7, 0xd9, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff, 0xf7, 0xd1, 0xff, 0xf7,
X   0xff, 0x7f, 0xff, 0xff, 0x07, 0xc0, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff,
X   0xf7, 0xd1, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff, 0xf7, 0xd9, 0xff, 0xf7,
X   0xff, 0x7f, 0xff, 0xff, 0xf7, 0xdd, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff,
X   0xf7, 0xdf, 0xff, 0xf7, 0xff, 0x7f, 0xff, 0xff, 0xf7, 0xdf, 0xff, 0xf7,
X   0xff, 0x7f, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff,
X   0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xe0, 0x7f, 0xe0, 0xff, 0xff, 0xff,
X   0xff, 0xff, 0xe0, 0x7f, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x7f,
X   0xf0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xe2, 0x7f, 0xe4, 0xff, 0xff, 0xff,
X   0xff, 0x3f, 0xe1, 0x7f, 0xc8, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xec, 0x7f,
X   0x93, 0xff, 0xff, 0xff, 0xff, 0x4f, 0xfe, 0xff, 0x27, 0xff, 0xff, 0xff,
X   0x1f, 0x00, 0x00, 0xfe, 0x03, 0x00, 0xf0, 0xff, 0xdf, 0xff, 0xff, 0xfe,
X   0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff,
X   0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe,
X   0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff,
X   0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe,
X   0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff,
X   0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe,
X   0xfb, 0xff, 0xf7, 0xff, 0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff,
X   0xdf, 0xff, 0xff, 0xfe, 0xfb, 0xff, 0xf7, 0xff, 0x1f, 0x00, 0x00, 0xfe,
X   0x03, 0x00, 0xf0, 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, 0xff, 0xff, 0xff, 0xff};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/blue_icon64x48.xbm' &&
  chmod 0640 'Red/Bitmaps/blue_icon64x48.xbm' ||
  echo 'restore of Red/Bitmaps/blue_icon64x48.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/blue_icon64x48.xbm'`"
  test 2489 -eq "$shar_count" ||
    echo "Red/Bitmaps/blue_icon64x48.xbm: original size 2489, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/changed.xbm ==============
if test -f 'Red/Bitmaps/changed.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/changed.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/changed.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/changed.xbm' &&
X#define changed_width 35
X#define changed_height 35
Xstatic char changed_bits[] = {
X   0xff, 0xff, 0xff, 0xff, 0x07, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
X   0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00,
X   0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0xc1,
X   0xff, 0x7f, 0x00, 0x04, 0x41, 0x00, 0x40, 0x30, 0x04, 0x41, 0x00, 0x40,
X   0x78, 0x04, 0x41, 0x00, 0x40, 0x3c, 0x04, 0x41, 0xfe, 0x43, 0x1e, 0x04,
X   0x41, 0x00, 0x40, 0x0f, 0x04, 0x41, 0x00, 0xc0, 0x07, 0x04, 0x41, 0x00,
X   0xe0, 0x03, 0x04, 0x41, 0xfe, 0xf3, 0x01, 0x04, 0x41, 0x00, 0xf8, 0x00,
X   0x04, 0x41, 0x00, 0x7c, 0x00, 0x04, 0x41, 0x00, 0x5e, 0x00, 0x04, 0x41,
X   0xfe, 0x41, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40,
X   0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04,
X   0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00,
X   0x40, 0x00, 0x04, 0xc1, 0xff, 0x7f, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00,
X   0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01,
X   0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
X   0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0x07};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/changed.xbm' &&
  chmod 0640 'Red/Bitmaps/changed.xbm' ||
  echo 'restore of Red/Bitmaps/changed.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/changed.xbm'`"
  test 1178 -eq "$shar_count" ||
    echo "Red/Bitmaps/changed.xbm: original size 1178, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/continue.xbm ==============
if test -f 'Red/Bitmaps/continue.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/continue.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/continue.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/continue.xbm' &&
X#define continue_width 48
X#define continue_height 48
Xstatic char continue_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x00, 0x00, 0x04, 0x82, 0x01, 0x00,
X   0x00, 0x00, 0x0a, 0x85, 0x03, 0x00, 0x00, 0x00, 0x14, 0x8a, 0x07, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x0f, 0x00, 0x00, 0x00, 0x14, 0x8a, 0x1f, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x00,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x00, 0x00, 0x85, 0xe2, 0xff, 0xff, 0x01,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x03, 0x00, 0x85, 0xe2, 0xff, 0xff, 0x07,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x0f, 0x00, 0x85, 0xe2, 0xff, 0xff, 0x1f,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x0f, 0x00, 0x85, 0xe2, 0xff, 0xff, 0x07,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x03, 0x00, 0x85, 0xe2, 0xff, 0xff, 0x01,
X   0x80, 0x4a, 0xe5, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x3f, 0x00, 0x00, 0x00, 0x14, 0x8a, 0x1f, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x0f, 0x00, 0x00, 0x00, 0x14, 0x8a, 0x07, 0x00,
X   0x00, 0x00, 0x0a, 0x85, 0x03, 0x00, 0x00, 0x00, 0x04, 0x82, 0x01, 0x00,
X   0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x09, 0x00, 0x00,
X   0x10, 0x02, 0x00, 0x01, 0x00, 0x00, 0x10, 0x70, 0x9a, 0xab, 0x49, 0x06,
X   0x10, 0x88, 0x26, 0x69, 0x4a, 0x09, 0x10, 0x88, 0x22, 0x29, 0x4a, 0x0f,
X   0x10, 0x88, 0x22, 0x29, 0x4a, 0x01, 0x10, 0x8a, 0x22, 0x29, 0x4a, 0x09,
X   0xe0, 0x71, 0x22, 0x2b, 0x72, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/continue.xbm' &&
  chmod 0640 'Red/Bitmaps/continue.xbm' ||
  echo 'restore of Red/Bitmaps/continue.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/continue.xbm'`"
  test 1886 -eq "$shar_count" ||
    echo "Red/Bitmaps/continue.xbm: original size 1886, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/continue_disab.xbm ==============
if test -f 'Red/Bitmaps/continue_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/continue_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/continue_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/continue_disab.xbm' &&
X#define continue_disab_width 48
X#define continue_disab_height 48
Xstatic char continue_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x00,
X   0x00, 0x00, 0x0a, 0x85, 0x02, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x05, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x0a, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x15, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x00,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x00, 0x00, 0x85, 0x42, 0x55, 0x55, 0x01,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x02, 0x00, 0x85, 0x42, 0x55, 0x55, 0x05,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x0a, 0x00, 0x85, 0x42, 0x55, 0x55, 0x15,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x0a, 0x00, 0x85, 0x42, 0x55, 0x55, 0x05,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x02, 0x00, 0x85, 0x42, 0x55, 0x55, 0x01,
X   0x80, 0x4a, 0xa5, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x2a, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x15, 0x00,
X   0x00, 0x00, 0x2a, 0x95, 0x0a, 0x00, 0x00, 0x00, 0x14, 0x0a, 0x05, 0x00,
X   0x00, 0x00, 0x0a, 0x85, 0x02, 0x00, 0x00, 0x00, 0x04, 0x02, 0x01, 0x00,
X   0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x08, 0x00, 0x00,
X   0x10, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50, 0x8a, 0xaa, 0x08, 0x02,
X   0x10, 0x88, 0x04, 0x41, 0x40, 0x01, 0x00, 0x00, 0x22, 0x28, 0x0a, 0x0a,
X   0x10, 0x88, 0x00, 0x01, 0x40, 0x01, 0x00, 0x02, 0x22, 0x28, 0x0a, 0x08,
X   0x40, 0x21, 0x00, 0x01, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/continue_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/continue_disab.xbm' ||
  echo 'restore of Red/Bitmaps/continue_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/continue_disab.xbm'`"
  test 1904 -eq "$shar_count" ||
    echo "Red/Bitmaps/continue_disab.xbm: original size 1904, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/darrow.xbm ==============
if test -f 'Red/Bitmaps/darrow.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/darrow.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/darrow.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/darrow.xbm' &&
X#define darrow_width 32
X#define darrow_height 14
Xstatic char darrow_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00,
X   0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0xe0, 0x07, 0xff, 0xff, 0xff, 0x1f,
X   0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x00, 0xe0, 0x7f,
X   0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x01,
X   0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/darrow.xbm' &&
  chmod 0640 'Red/Bitmaps/darrow.xbm' ||
  echo 'restore of Red/Bitmaps/darrow.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/darrow.xbm'`"
  test 431 -eq "$shar_count" ||
    echo "Red/Bitmaps/darrow.xbm: original size 431, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/darrow_disab.xbm ==============
if test -f 'Red/Bitmaps/darrow_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/darrow_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/darrow_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/darrow_disab.xbm' &&
X#define darrow_disab_width 32
X#define darrow_disab_height 14
Xstatic char darrow_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x01, 0x00, 0x00, 0xa0, 0x02, 0x55, 0x55, 0x55, 0x15,
X   0x00, 0x00, 0xa0, 0x2a, 0x00, 0x00, 0x40, 0x55, 0x00, 0x00, 0xa0, 0x2a,
X   0x55, 0x55, 0x55, 0x15, 0x00, 0x00, 0xa0, 0x02, 0x00, 0x00, 0x40, 0x01,
X   0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/darrow_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/darrow_disab.xbm' ||
  echo 'restore of Red/Bitmaps/darrow_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/darrow_disab.xbm'`"
  test 449 -eq "$shar_count" ||
    echo "Red/Bitmaps/darrow_disab.xbm: original size 449, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/debug_icon.xbm ==============
if test -f 'Red/Bitmaps/debug_icon.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/debug_icon.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/debug_icon.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/debug_icon.xbm' &&
X#define debug_icon_width 48
X#define debug_icon_height 48
Xstatic char debug_icon_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x3f, 0x00,
X   0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x02, 0x00, 0x00, 0x00, 0xc0, 0x00,
X   0x02, 0x00, 0x00, 0xff, 0xc1, 0x01, 0xe2, 0xe7, 0xc7, 0xff, 0xc7, 0x01,
X   0x02, 0x00, 0xf0, 0x01, 0xdf, 0x01, 0x02, 0x00, 0x78, 0xfe, 0xf8, 0x01,
X   0x82, 0x5f, 0x9f, 0x01, 0xf7, 0x01, 0x02, 0x00, 0x66, 0x00, 0xc8, 0x01,
X   0x02, 0x00, 0x1a, 0x00, 0xb0, 0x01, 0xe2, 0x0f, 0x87, 0xc0, 0xc0, 0x01,
X   0x02, 0x80, 0x03, 0x31, 0x80, 0x03, 0x02, 0x80, 0x01, 0x3e, 0x80, 0x03,
X   0x82, 0xff, 0x01, 0x3e, 0x80, 0x03, 0x02, 0xc0, 0x01, 0x3e, 0x80, 0x07,
X   0x02, 0xc0, 0x31, 0x1e, 0x03, 0x07, 0x02, 0xf8, 0xf8, 0xff, 0x07, 0x07,
X   0x02, 0xc0, 0xc8, 0xf7, 0x04, 0x07, 0x02, 0xc0, 0x80, 0x7b, 0x00, 0x07,
X   0x02, 0xf8, 0xe0, 0xfb, 0x0b, 0x07, 0x02, 0xc0, 0xf8, 0xfb, 0x0f, 0x07,
X   0x02, 0x80, 0x99, 0x7b, 0x00, 0x03, 0x82, 0xf7, 0x81, 0x7b, 0x00, 0x03,
X   0x02, 0x80, 0xe2, 0xfb, 0x80, 0x03, 0x02, 0x00, 0x73, 0xf7, 0x83, 0x01,
X   0x82, 0xff, 0x0f, 0x1e, 0xc6, 0x01, 0x02, 0x00, 0x0b, 0x00, 0xe0, 0x03,
X   0x02, 0x00, 0x36, 0x00, 0xf8, 0x05, 0x02, 0xf8, 0xff, 0x00, 0xf6, 0x0b,
X   0x02, 0x00, 0x30, 0xff, 0xd9, 0x15, 0x02, 0x00, 0xe0, 0x01, 0xcf, 0x2b,
X   0x02, 0xf8, 0xfd, 0xff, 0xc7, 0x57, 0x02, 0x00, 0x00, 0xff, 0xc0, 0xad,
X   0x02, 0x00, 0x00, 0x00, 0xc0, 0x59, 0x82, 0xf7, 0x00, 0x00, 0xc0, 0xb1,
X   0x02, 0x00, 0x00, 0x00, 0xc0, 0x61, 0x02, 0x00, 0x00, 0x00, 0xc0, 0xc1,
X   0xe2, 0x7d, 0x00, 0x00, 0xc0, 0x81, 0x02, 0x00, 0x00, 0x00, 0xc0, 0x01,
X   0x02, 0x00, 0x00, 0x00, 0xc0, 0x01, 0x02, 0x00, 0x00, 0x00, 0xe0, 0x01,
X   0xfc, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/debug_icon.xbm' &&
  chmod 0640 'Red/Bitmaps/debug_icon.xbm' ||
  echo 'restore of Red/Bitmaps/debug_icon.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/debug_icon.xbm'`"
  test 1892 -eq "$shar_count" ||
    echo "Red/Bitmaps/debug_icon.xbm: original size 1892, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/debug_icon64x48.xbm ==============
if test -f 'Red/Bitmaps/debug_icon64x48.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/debug_icon64x48.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/debug_icon64x48.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/debug_icon64x48.xbm' &&
X#define debug_icon_width 64
X#define debug_icon_height 48
Xstatic char debug_icon_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
X   0xff, 0x07, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
X   0x40, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x40, 0x00, 0x00, 0xe0,
X   0x3f, 0x38, 0x00, 0x00, 0x40, 0xfc, 0xfc, 0xf8, 0xff, 0x38, 0x00, 0x00,
X   0x40, 0x00, 0x00, 0x3e, 0xe0, 0x3b, 0x00, 0x00, 0x40, 0x00, 0x00, 0xcf,
X   0x1f, 0x3f, 0x00, 0x00, 0x40, 0xf0, 0xeb, 0x33, 0xe0, 0x3e, 0x00, 0x00,
X   0x40, 0x00, 0xc0, 0x0c, 0x00, 0x39, 0x00, 0x00, 0x40, 0x00, 0x40, 0x03,
X   0x00, 0x36, 0x00, 0x00, 0x40, 0xfc, 0xe1, 0x10, 0x18, 0x38, 0x00, 0x00,
X   0x40, 0x00, 0x70, 0x20, 0x06, 0x70, 0x00, 0x00, 0x40, 0x00, 0x30, 0xc0,
X   0x07, 0x70, 0x00, 0x00, 0x40, 0xf0, 0x3f, 0xc0, 0x07, 0x70, 0x00, 0x00,
X   0x40, 0x00, 0x38, 0xc0, 0x07, 0xf0, 0x00, 0x00, 0x40, 0x00, 0x38, 0xc6,
X   0x63, 0xe0, 0x00, 0x00, 0x40, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x00, 0x00,
X   0x40, 0x00, 0x18, 0xf9, 0x9e, 0xe0, 0x00, 0x00, 0x40, 0x00, 0x18, 0x70,
X   0x0f, 0xe0, 0x00, 0x00, 0x40, 0x00, 0x1f, 0x7c, 0x7f, 0xe1, 0x00, 0x00,
X   0x40, 0x00, 0x18, 0x7f, 0xff, 0xe1, 0x00, 0x00, 0x40, 0x00, 0x30, 0x73,
X   0x0f, 0x60, 0x00, 0x00, 0x40, 0xf0, 0x3e, 0x70, 0x0f, 0x60, 0x00, 0x00,
X   0x40, 0x00, 0x50, 0x7c, 0x1f, 0x70, 0x00, 0x00, 0x40, 0x00, 0x60, 0xee,
X   0x7e, 0x30, 0x00, 0x00, 0x40, 0xf0, 0xff, 0xc1, 0xc3, 0x38, 0x00, 0x00,
X   0x40, 0x00, 0x60, 0x01, 0x00, 0x7c, 0x00, 0x00, 0x40, 0x00, 0xc0, 0x06,
X   0x00, 0xbf, 0x00, 0x00, 0x40, 0x00, 0xff, 0x1f, 0xc0, 0x7e, 0x01, 0x00,
X   0x40, 0x00, 0x00, 0xe6, 0x3f, 0xbb, 0x02, 0x00, 0x40, 0x00, 0x00, 0x3c,
X   0xe0, 0x79, 0x05, 0x00, 0x40, 0x00, 0xbf, 0xff, 0xff, 0xf8, 0x0a, 0x00,
X   0x40, 0x00, 0x00, 0xe0, 0x1f, 0xb8, 0x15, 0x00, 0x40, 0x00, 0x00, 0x00,
X   0x00, 0x38, 0x2b, 0x00, 0x40, 0xf0, 0x1e, 0x00, 0x00, 0x38, 0x56, 0x00,
X   0x40, 0x00, 0x00, 0x00, 0x00, 0x38, 0xac, 0x00, 0x40, 0x00, 0x00, 0x00,
X   0x00, 0x38, 0x58, 0x01, 0x40, 0xbc, 0x0f, 0x00, 0x00, 0x38, 0xb0, 0x02,
X   0x40, 0x00, 0x00, 0x00, 0x00, 0x38, 0x60, 0x05, 0x40, 0x00, 0x00, 0x00,
X   0x00, 0x38, 0xc0, 0x0a, 0x40, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x80, 0x15,
X   0x80, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x0b, 0x80, 0xff, 0xff, 0xff,
X   0xff, 0x1f, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/debug_icon64x48.xbm' &&
  chmod 0640 'Red/Bitmaps/debug_icon64x48.xbm' ||
  echo 'restore of Red/Bitmaps/debug_icon64x48.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/debug_icon64x48.xbm'`"
  test 2492 -eq "$shar_count" ||
    echo "Red/Bitmaps/debug_icon64x48.xbm: original size 2492, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/tmp.xbm ==============
if test -f 'Red/Bitmaps/tmp.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/tmp.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/tmp.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/tmp.xbm' &&
X#define tmp_width 48
X#define tmp_height 48
Xstatic char tmp_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x03, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x0f, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0x10, 0x00,
X   0x00, 0xfc, 0xff, 0x3f, 0x10, 0x00, 0x00, 0xfc, 0xff, 0x7f, 0x10, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x10, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x11, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x13, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x17, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x13, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x11, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x10, 0x00, 0x00, 0xfc, 0xff, 0x7f, 0x10, 0x00,
X   0x00, 0xfc, 0xff, 0x3f, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x0f, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x03, 0x10, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x10, 0x00,
X   0x00, 0x00, 0xe0, 0x00, 0x10, 0x00, 0x00, 0x00, 0x60, 0x00, 0x10, 0x00,
X   0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/tmp.xbm' &&
  chmod 0640 'Red/Bitmaps/tmp.xbm' ||
  echo 'restore of Red/Bitmaps/tmp.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/tmp.xbm'`"
  test 1871 -eq "$shar_count" ||
    echo "Red/Bitmaps/tmp.xbm: original size 1871, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/edit_icon.xbm ==============
if test -f 'Red/Bitmaps/edit_icon.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/edit_icon.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/edit_icon.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/edit_icon.xbm' &&
X#define edit_icon_width 48
X#define edit_icon_height 48
Xstatic char edit_icon_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x03,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x00, 0x00, 0x0c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x7e, 0x7e, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0xf8, 0xf5, 0x2e, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0xfe, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0xf8, 0xdf, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x80, 0xbf, 0xff, 0x01, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x80, 0xdf, 0xef, 0x03, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x78, 0x0f, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0xf8, 0xdf, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x80, 0x7f, 0x0f, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x80, 0xdf, 0xfb, 0x03, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x78, 0x0f, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0xde, 0x07, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1c,
X   0x20, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x1e,
X   0xc0, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x0f,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/edit_icon.xbm' &&
  chmod 0640 'Red/Bitmaps/edit_icon.xbm' ||
  echo 'restore of Red/Bitmaps/edit_icon.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/edit_icon.xbm'`"
  test 1889 -eq "$shar_count" ||
    echo "Red/Bitmaps/edit_icon.xbm: original size 1889, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/edit_icon64x48.xbm ==============
if test -f 'Red/Bitmaps/edit_icon64x48.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/edit_icon64x48.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/edit_icon64x48.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/edit_icon64x48.xbm' &&
X#define edit_icon_width 64
X#define edit_icon_height 48
Xstatic char edit_icon_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, 0xff, 0x0f, 0x00, 0x00,
X   0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0x77, 0x60, 0xe0, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x81, 0x42, 0xf4, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0x77, 0xc0, 0xff, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x01, 0xc8, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x1f, 0x10, 0x80, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x1f, 0x08, 0x04, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x21, 0xfc, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x01, 0xc8, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x1f, 0x20, 0xfc, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x1f, 0x08, 0x01, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0x21, 0xfc, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0x77, 0x08, 0xfe, 0xff, 0xff, 0xf8, 0xff,
X   0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff,
X   0xff, 0xff, 0xf8, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0x7f, 0xf8, 0xff,
X   0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00,
X   0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/edit_icon64x48.xbm' &&
  chmod 0640 'Red/Bitmaps/edit_icon64x48.xbm' ||
  echo 'restore of Red/Bitmaps/edit_icon64x48.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/edit_icon64x48.xbm'`"
  test 2489 -eq "$shar_count" ||
    echo "Red/Bitmaps/edit_icon64x48.xbm: original size 2489, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/error.xbm ==============
if test -f 'Red/Bitmaps/error.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/error.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/error.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/error.xbm' &&
X#define error_width 14
X#define error_height 14
Xstatic char error_bits[] = {
X   0x00, 0x03, 0x80, 0x01, 0xc0, 0x00, 0x60, 0x00, 0x30, 0x0f, 0xf8, 0x07,
X   0x3c, 0x03, 0x80, 0x01, 0xc0, 0x00, 0x64, 0x00, 0x34, 0x00, 0x1c, 0x00,
X   0x1c, 0x00, 0x7c, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/error.xbm' &&
  chmod 0640 'Red/Bitmaps/error.xbm' ||
  echo 'restore of Red/Bitmaps/error.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/error.xbm'`"
  test 254 -eq "$shar_count" ||
    echo "Red/Bitmaps/error.xbm: original size 254, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/exec.xbm ==============
if test -f 'Red/Bitmaps/exec.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/exec.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/exec.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/exec.xbm' &&
X#define exec_width 14
X#define exec_height 14
Xstatic char exec_bits[] = {
X   0x00, 0x00, 0x80, 0x00, 0x80, 0x01, 0x80, 0x03, 0x80, 0x07, 0xfe, 0x0f,
X   0xd4, 0x1f, 0xaa, 0x1f, 0xfe, 0x0f, 0x80, 0x07, 0x80, 0x03, 0x80, 0x01,
X   0x80, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/exec.xbm' &&
  chmod 0640 'Red/Bitmaps/exec.xbm' ||
  echo 'restore of Red/Bitmaps/exec.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/exec.xbm'`"
  test 251 -eq "$shar_count" ||
    echo "Red/Bitmaps/exec.xbm: original size 251, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/longline.xbm ==============
if test -f 'Red/Bitmaps/longline.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/longline.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/longline.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/longline.xbm' &&
X#define longline_width 8
X#define longline_height 9
Xstatic char longline_bits[] = {
X   0x00, 0x18, 0x38, 0x7f, 0xff, 0x7f, 0x38, 0x18, 0x00};
SHAR_EOF
  $shar_touch -am 0512222596 'Red/Bitmaps/longline.xbm' &&
  chmod 0640 'Red/Bitmaps/longline.xbm' ||
  echo 'restore of Red/Bitmaps/longline.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/longline.xbm'`"
  test 141 -eq "$shar_count" ||
    echo "Red/Bitmaps/longline.xbm: original size 141, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/noarrow.xbm ==============
if test -f 'Red/Bitmaps/noarrow.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/noarrow.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/noarrow.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/noarrow.xbm' &&
X#define noarrow_width 32
X#define noarrow_height 16
Xstatic char noarrow_bits[] = {
X   0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x07, 0x00,
X   0x00, 0x80, 0x63, 0x00, 0x00, 0xc0, 0xe1, 0x01, 0x00, 0xe0, 0xe0, 0x07,
X   0xff, 0xff, 0xff, 0x1f, 0x00, 0x38, 0xe0, 0x7f, 0x00, 0x1c, 0xe0, 0xff,
X   0x00, 0x0e, 0xe0, 0x7f, 0xff, 0xff, 0xff, 0x1f, 0x80, 0x03, 0xe0, 0x07,
X   0xc0, 0x01, 0xe0, 0x01, 0xe0, 0x00, 0x60, 0x00, 0x70, 0x00, 0x00, 0x00,
X   0x38, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/noarrow.xbm' &&
  chmod 0640 'Red/Bitmaps/noarrow.xbm' ||
  echo 'restore of Red/Bitmaps/noarrow.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/noarrow.xbm'`"
  test 485 -eq "$shar_count" ||
    echo "Red/Bitmaps/noarrow.xbm: original size 485, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/red_logo.xbm ==============
if test -f 'Red/Bitmaps/red_logo.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/red_logo.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/red_logo.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/red_logo.xbm' &&
X#define red_logo_width 66
X#define red_logo_height 66
Xstatic char red_logo_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0a, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0xa0, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x50, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0xaa, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0x54, 0x55, 0x01, 0x00, 0x1e, 0x00,
X   0x00, 0xf8, 0x3f, 0xaa, 0xaa, 0x02, 0x00, 0x1e, 0x00, 0x00, 0xfe, 0x7f,
X   0x55, 0x55, 0x05, 0x00, 0x1e, 0x00, 0x00, 0x7f, 0xfe, 0xaa, 0xaa, 0x0a,
X   0x00, 0x1e, 0x00, 0x00, 0x1f, 0xf8, 0x55, 0x55, 0x15, 0x00, 0x1e, 0x00,
X   0x80, 0x0f, 0xf0, 0xab, 0xaa, 0x2a, 0x00, 0x1e, 0x00, 0x80, 0x07, 0xf0,
X   0x55, 0x55, 0x55, 0x7c, 0x1e, 0x00, 0x80, 0x07, 0xe8, 0xa9, 0xbe, 0xaa,
X   0xfe, 0x1e, 0x00, 0x80, 0x07, 0xf4, 0x55, 0xff, 0x55, 0xff, 0x1f, 0x00,
X   0xc0, 0x03, 0xea, 0xe9, 0xff, 0xab, 0xff, 0x1f, 0x00, 0xc0, 0x03, 0xf5,
X   0xf5, 0xff, 0xd3, 0xff, 0x1f, 0x00, 0xc0, 0x83, 0xea, 0xe9, 0xe7, 0xeb,
X   0x9f, 0x1f, 0x00, 0xc0, 0x43, 0xf5, 0xf5, 0xd3, 0xd3, 0x0f, 0x1f, 0x00,
X   0xc0, 0xa3, 0xea, 0xf9, 0xa9, 0xeb, 0x07, 0x1e, 0x00, 0xc0, 0x53, 0xf5,
X   0xfd, 0xd4, 0xf3, 0x43, 0x1e, 0x00, 0xc0, 0xa3, 0xea, 0x79, 0xaa, 0xeb,
X   0xa3, 0x1e, 0x00, 0xc0, 0x53, 0xf5, 0x7d, 0xd5, 0xf3, 0x51, 0x1f, 0x00,
X   0xc0, 0xa3, 0xea, 0x3d, 0xaa, 0xfb, 0xa9, 0x1e, 0x00, 0xc0, 0x53, 0xf5,
X   0x3d, 0xd5, 0xf3, 0x54, 0x1f, 0x00, 0xc0, 0xa3, 0xfa, 0xbd, 0xea, 0xfb,
X   0xa8, 0x1e, 0x00, 0xc0, 0x53, 0xf5, 0x3c, 0xd5, 0x7b, 0x54, 0x1f, 0x00,
X   0xe0, 0xa3, 0xfa, 0xbc, 0xea, 0x7b, 0xaa, 0x1e, 0x00, 0xd0, 0x53, 0xf5,
X   0x3c, 0xf5, 0x79, 0x54, 0x1f, 0x00, 0xe8, 0xa3, 0xfa, 0xbc, 0xfa, 0x79,
X   0xaa, 0x9e, 0x00, 0xd4, 0x53, 0xf5, 0x3c, 0xfd, 0x7d, 0x54, 0x1f, 0x01,
X   0xea, 0xa3, 0xfa, 0xbe, 0xfe, 0x3c, 0xaa, 0x9e, 0x03, 0xd7, 0x53, 0x7d,
X   0x3e, 0x7f, 0x3c, 0x55, 0x9f, 0x03, 0xee, 0xa3, 0x7a, 0xbe, 0x3f, 0x3e,
X   0xaa, 0x9e, 0x01, 0xdc, 0x53, 0x7d, 0xfe, 0x1f, 0x3d, 0x55, 0x9f, 0x00,
X   0xf8, 0xa3, 0x3e, 0xfe, 0x8f, 0x3e, 0xaa, 0x1e, 0x00, 0xf0, 0x53, 0x3f,
X   0xff, 0x47, 0x3d, 0x55, 0x1f, 0x00, 0xe0, 0xa3, 0x3e, 0xfe, 0xa3, 0x3e,
X   0xaa, 0x1e, 0x00, 0xc0, 0x53, 0x1f, 0xff, 0x51, 0x3d, 0x55, 0x1f, 0x00,
X   0xc0, 0xa3, 0x9f, 0xfe, 0xa8, 0x3e, 0xaa, 0x1f, 0x00, 0xc0, 0x53, 0x0f,
X   0x7f, 0x54, 0x3d, 0xd5, 0x1f, 0x00, 0xc0, 0xa3, 0x8f, 0x3e, 0xaa, 0x3e,
X   0xea, 0x1f, 0x00, 0xc0, 0xd3, 0x47, 0x3d, 0x55, 0x3d, 0xf5, 0x1e, 0x00,
X   0xc0, 0xe3, 0xaf, 0xbe, 0xaa, 0x3e, 0x7a, 0x1e, 0x00, 0xc0, 0xf3, 0x4f,
X   0x3d, 0x55, 0x7d, 0x3d, 0x1e, 0x00, 0xc0, 0xff, 0x9f, 0xbe, 0xaa, 0x7a,
X   0x1e, 0x1e, 0x00, 0xc0, 0xff, 0x3f, 0x3d, 0x55, 0x7d, 0x0e, 0x1f, 0x00,
X   0xc0, 0xff, 0x3f, 0xbe, 0xaa, 0x7b, 0x86, 0x1f, 0x00, 0xc0, 0x3f, 0x7f,
X   0x3c, 0xd5, 0xfb, 0x80, 0x1f, 0x00, 0xc0, 0x1f, 0xfe, 0x78, 0xea, 0xfb,
X   0xc0, 0x1f, 0x00, 0xc0, 0x0f, 0xfc, 0x79, 0xf4, 0xf9, 0xe0, 0x1f, 0x00,
X   0xc0, 0x07, 0xf8, 0xfb, 0xea, 0xf8, 0xf0, 0x1f, 0x00, 0xc0, 0x07, 0xf0,
X   0xf7, 0xf5, 0xf8, 0xf9, 0x1f, 0x00, 0xc0, 0x07, 0xf0, 0xef, 0xff, 0xf0,
X   0xff, 0x1f, 0x00, 0xc0, 0x07, 0xe0, 0xdf, 0x7f, 0xf6, 0x7f, 0x1e, 0x00,
X   0xc0, 0x07, 0xc0, 0xdf, 0x3f, 0xf6, 0x3f, 0x1e, 0x00, 0xc0, 0x07, 0x80,
X   0xdf, 0x1f, 0xe3, 0x1f, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x20, 0xc0, 0x01,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0xf5, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0xb8, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x70, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1e, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x03, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/red_logo.xbm' &&
  chmod 0640 'Red/Bitmaps/red_logo.xbm' ||
  echo 'restore of Red/Bitmaps/red_logo.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/red_logo.xbm'`"
  test 3800 -eq "$shar_count" ||
    echo "Red/Bitmaps/red_logo.xbm: original size 3800, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/saved.xbm ==============
if test -f 'Red/Bitmaps/saved.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/saved.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/saved.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/saved.xbm' &&
X#define saved_width 35
X#define saved_height 35
Xstatic char saved_bits[] = {
X   0xff, 0xff, 0xff, 0xff, 0x07, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00,
X   0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00,
X   0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0xc1,
X   0xff, 0x7f, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40,
X   0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0xfe, 0x43, 0x00, 0x04,
X   0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00,
X   0x40, 0x00, 0x04, 0x41, 0xfe, 0x43, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00,
X   0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41,
X   0xfe, 0x43, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40,
X   0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0xfe, 0x43, 0x00, 0x04,
X   0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00, 0x40, 0x00, 0x04, 0x41, 0x00,
X   0x40, 0x00, 0x04, 0xc1, 0xff, 0x7f, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00,
X   0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01,
X   0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
X   0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0x07};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/saved.xbm' &&
  chmod 0640 'Red/Bitmaps/saved.xbm' ||
  echo 'restore of Red/Bitmaps/saved.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/saved.xbm'`"
  test 1172 -eq "$shar_count" ||
    echo "Red/Bitmaps/saved.xbm: original size 1172, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/step.xbm ==============
if test -f 'Red/Bitmaps/step.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/step.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/step.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/step.xbm' &&
X#define step_width 48
X#define step_height 48
Xstatic char step_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x00, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x03, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x0f, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0x30, 0x00,
X   0x00, 0xfc, 0xff, 0x3f, 0x30, 0x00, 0x00, 0xfc, 0xff, 0x7f, 0x30, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x30, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x31, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x33, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x37, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x33, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x31, 0x00,
X   0x00, 0xfc, 0xff, 0xff, 0x30, 0x00, 0x00, 0xfc, 0xff, 0x7f, 0x30, 0x00,
X   0x00, 0xfc, 0xff, 0x3f, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x0f, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x03, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x01, 0x30, 0x00,
X   0x00, 0x00, 0xe0, 0x00, 0x30, 0x00, 0x00, 0x00, 0x60, 0x00, 0x30, 0x00,
X   0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x23, 0x00, 0x00, 0x00,
X   0x00, 0x40, 0x24, 0x00, 0x00, 0x00, 0x00, 0x40, 0x70, 0xa6, 0x01, 0x00,
X   0x00, 0x80, 0x23, 0x69, 0x02, 0x00, 0x00, 0x00, 0x24, 0x2f, 0x02, 0x00,
X   0x00, 0x40, 0x24, 0x21, 0x02, 0x00, 0x00, 0x40, 0x24, 0x69, 0x02, 0x00,
X   0x00, 0x80, 0x63, 0xa6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/step.xbm' &&
  chmod 0640 'Red/Bitmaps/step.xbm' ||
  echo 'restore of Red/Bitmaps/step.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/step.xbm'`"
  test 1874 -eq "$shar_count" ||
    echo "Red/Bitmaps/step.xbm: original size 1874, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/step_disab.xbm ==============
if test -f 'Red/Bitmaps/step_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/step_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/step_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/step_disab.xbm' &&
X#define step_disab_width 48
X#define step_disab_height 48
Xstatic char step_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x00, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x01, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x02, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x05, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x0a, 0x20, 0x00,
X   0x00, 0x54, 0x55, 0x15, 0x10, 0x00, 0x00, 0xa8, 0xaa, 0x2a, 0x20, 0x00,
X   0x00, 0x54, 0x55, 0x55, 0x10, 0x00, 0x00, 0xa8, 0xaa, 0xaa, 0x20, 0x00,
X   0x00, 0x54, 0x55, 0x55, 0x11, 0x00, 0x00, 0xa8, 0xaa, 0xaa, 0x22, 0x00,
X   0x00, 0x54, 0x55, 0x55, 0x11, 0x00, 0x00, 0xa8, 0xaa, 0xaa, 0x20, 0x00,
X   0x00, 0x54, 0x55, 0x55, 0x10, 0x00, 0x00, 0xa8, 0xaa, 0x2a, 0x20, 0x00,
X   0x00, 0x54, 0x55, 0x15, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x0a, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x05, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x02, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x01, 0x10, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x40, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x40, 0x50, 0xa2, 0x00, 0x00,
X   0x00, 0x80, 0x22, 0x41, 0x00, 0x00, 0x00, 0x00, 0x04, 0x2a, 0x02, 0x00,
X   0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x40, 0x04, 0x28, 0x02, 0x00,
X   0x00, 0x80, 0x22, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/step_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/step_disab.xbm' ||
  echo 'restore of Red/Bitmaps/step_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/step_disab.xbm'`"
  test 1892 -eq "$shar_count" ||
    echo "Red/Bitmaps/step_disab.xbm: original size 1892, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/step_into.xbm ==============
if test -f 'Red/Bitmaps/step_into.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/step_into.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/step_into.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/step_into.xbm' &&
X#define step_into_width 48
X#define step_into_height 48
Xstatic char step_into_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x07, 0x00, 0x00, 0x00,
X   0xc0, 0xff, 0x07, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x07, 0x00, 0x00, 0x00,
X   0xc0, 0xff, 0x07, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x07, 0x08, 0x00, 0x03,
X   0xc0, 0xff, 0x07, 0x18, 0x00, 0x03, 0xc0, 0xff, 0x07, 0x38, 0x00, 0x03,
X   0xc0, 0xff, 0x07, 0x78, 0x00, 0x03, 0x00, 0xf0, 0x07, 0xf8, 0x00, 0x03,
X   0x00, 0xf0, 0x07, 0xf8, 0x01, 0x03, 0x00, 0xf0, 0x07, 0xf8, 0x03, 0x03,
X   0x00, 0xf0, 0xff, 0xff, 0x07, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x0f, 0x03,
X   0x00, 0xf0, 0xff, 0xff, 0x1f, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x3f, 0x03,
X   0x00, 0xf0, 0xff, 0xff, 0x7f, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x3f, 0x03,
X   0x00, 0xf0, 0xff, 0xff, 0x1f, 0x03, 0x00, 0xf0, 0xff, 0xff, 0x0f, 0x03,
X   0x00, 0x00, 0x00, 0xf8, 0x07, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x03,
X   0x00, 0x00, 0x00, 0xf8, 0x01, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x03,
X   0x00, 0x00, 0x00, 0x78, 0x00, 0x03, 0x00, 0x00, 0x00, 0x38, 0x00, 0x03,
X   0x00, 0x00, 0x00, 0x18, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x04, 0x00, 0x10, 0x20, 0x00,
X   0x88, 0x04, 0x00, 0x10, 0x20, 0x00, 0x08, 0xce, 0x34, 0x50, 0x73, 0x06,
X   0x70, 0x24, 0x4d, 0xd0, 0x24, 0x09, 0x80, 0xe4, 0x45, 0x50, 0x24, 0x09,
X   0x88, 0x24, 0x44, 0x50, 0x24, 0x09, 0x88, 0x24, 0x4d, 0x50, 0x24, 0x09,
X   0x70, 0xcc, 0x34, 0x50, 0x64, 0x06, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/step_into.xbm' &&
  chmod 0640 'Red/Bitmaps/step_into.xbm' ||
  echo 'restore of Red/Bitmaps/step_into.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/step_into.xbm'`"
  test 1889 -eq "$shar_count" ||
    echo "Red/Bitmaps/step_into.xbm: original size 1889, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/step_into_disab.xbm ==============
if test -f 'Red/Bitmaps/step_into_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/step_into_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/step_into_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/step_into_disab.xbm' &&
X#define step_into_disab_width 48
X#define step_into_disab_height 48
Xstatic char step_into_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x55, 0x05, 0x00, 0x00, 0x00,
X   0x80, 0xaa, 0x02, 0x00, 0x00, 0x00, 0x40, 0x55, 0x05, 0x00, 0x00, 0x00,
X   0x80, 0xaa, 0x02, 0x00, 0x00, 0x00, 0x40, 0x55, 0x05, 0x00, 0x00, 0x01,
X   0x80, 0xaa, 0x02, 0x08, 0x00, 0x02, 0x40, 0x55, 0x05, 0x10, 0x00, 0x01,
X   0x80, 0xaa, 0x02, 0x28, 0x00, 0x02, 0x00, 0x50, 0x05, 0x50, 0x00, 0x01,
X   0x00, 0xa0, 0x02, 0xa8, 0x00, 0x02, 0x00, 0x50, 0x05, 0x50, 0x01, 0x01,
X   0x00, 0xa0, 0xaa, 0xaa, 0x02, 0x02, 0x00, 0x50, 0x55, 0x55, 0x05, 0x01,
X   0x00, 0xa0, 0xaa, 0xaa, 0x0a, 0x02, 0x00, 0x50, 0x55, 0x55, 0x15, 0x01,
X   0x00, 0xa0, 0xaa, 0xaa, 0x2a, 0x02, 0x00, 0x50, 0x55, 0x55, 0x15, 0x01,
X   0x00, 0xa0, 0xaa, 0xaa, 0x0a, 0x02, 0x00, 0x50, 0x55, 0x55, 0x05, 0x01,
X   0x00, 0x00, 0x00, 0xa8, 0x02, 0x02, 0x00, 0x00, 0x00, 0x50, 0x01, 0x01,
X   0x00, 0x00, 0x00, 0xa8, 0x00, 0x02, 0x00, 0x00, 0x00, 0x50, 0x00, 0x01,
X   0x00, 0x00, 0x00, 0x28, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x01,
X   0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x04, 0x00, 0x00, 0x20, 0x00,
X   0x88, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x44, 0x14, 0x00, 0x22, 0x02,
X   0x20, 0x20, 0x08, 0x50, 0x04, 0x01, 0x00, 0x44, 0x45, 0x00, 0x20, 0x08,
X   0x88, 0x20, 0x00, 0x50, 0x04, 0x01, 0x00, 0x04, 0x45, 0x00, 0x20, 0x08,
X   0x20, 0x88, 0x20, 0x50, 0x44, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/step_into_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/step_into_disab.xbm' ||
  echo 'restore of Red/Bitmaps/step_into_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/step_into_disab.xbm'`"
  test 1907 -eq "$shar_count" ||
    echo "Red/Bitmaps/step_into_disab.xbm: original size 1907, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/stipple.xbm ==============
if test -f 'Red/Bitmaps/stipple.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/stipple.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/stipple.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/stipple.xbm' &&
X#define stipple_width 7
X#define stipple_height 7
Xstatic char stipple_bits[] = {
X   0x4f, 0x67, 0x73, 0x79, 0x7c, 0x3e, 0x1f};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/stipple.xbm' &&
  chmod 0640 'Red/Bitmaps/stipple.xbm' ||
  echo 'restore of Red/Bitmaps/stipple.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/stipple.xbm'`"
  test 126 -eq "$shar_count" ||
    echo "Red/Bitmaps/stipple.xbm: original size 126, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/stop.colpix ==============
if test -f 'Red/Bitmaps/stop.colpix' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/stop.colpix (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/stop.colpix (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/stop.colpix' &&
X! XPM2  
X16 16 2 1
X  c #FFFFFFFFFFFF
X. c #E5E52D2D2D2D
X    ........    
X   ..........   
X  ............  
X .............. 
X................
X................
X...  .  .  .  ..
X... .. ..  .  ..
X.... . ..  . ...
X...  . ..  . ...
X................
X................
X .............. 
X  ............  
X   ..........   
X    ........    
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/stop.colpix' &&
  chmod 0640 'Red/Bitmaps/stop.colpix' ||
  echo 'restore of Red/Bitmaps/stop.colpix failed'
  shar_count="`wc -c < 'Red/Bitmaps/stop.colpix'`"
  test 327 -eq "$shar_count" ||
    echo "Red/Bitmaps/stop.colpix: original size 327, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/stop.xbm ==============
if test -f 'Red/Bitmaps/stop.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/stop.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/stop.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/stop.xbm' &&
X#define stop_width 14
X#define stop_height 14
Xstatic char stop_bits[] = {
X   0xf8, 0x07, 0xfc, 0x0f, 0xfe, 0x1f, 0xff, 0x3f, 0xff, 0x3f, 0x93, 0x24,
X   0xdb, 0x24, 0xd7, 0x34, 0xd3, 0x34, 0xff, 0x3f, 0xff, 0x3f, 0xfe, 0x1f,
X   0xfc, 0x0f, 0xf8, 0x07};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/stop.xbm' &&
  chmod 0640 'Red/Bitmaps/stop.xbm' ||
  echo 'restore of Red/Bitmaps/stop.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/stop.xbm'`"
  test 251 -eq "$shar_count" ||
    echo "Red/Bitmaps/stop.xbm: original size 251, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/terminate.xbm ==============
if test -f 'Red/Bitmaps/terminate.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/terminate.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/terminate.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/terminate.xbm' &&
X#define terminate_width 48
X#define terminate_height 48
Xstatic char terminate_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00,
X   0x00, 0x80, 0x03, 0xc0, 0x01, 0x00, 0x00, 0xc0, 0x07, 0xe0, 0x03, 0x00,
X   0x00, 0xe0, 0x0f, 0xf0, 0x07, 0x00, 0x00, 0xf0, 0x1f, 0xf8, 0x0f, 0x00,
X   0x00, 0xf8, 0x3f, 0xfc, 0x1f, 0x00, 0x00, 0xf0, 0x7f, 0xfe, 0x0f, 0x00,
X   0x00, 0xe0, 0xff, 0xff, 0x07, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x03, 0x00,
X   0x00, 0x80, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
X   0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00,
X   0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00,
X   0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x01, 0x00,
X   0x00, 0xc0, 0xff, 0xff, 0x03, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x07, 0x00,
X   0x00, 0xf0, 0x7f, 0xfe, 0x0f, 0x00, 0x00, 0xf8, 0x3f, 0xfc, 0x1f, 0x00,
X   0x00, 0xf0, 0x1f, 0xf8, 0x0f, 0x00, 0x00, 0xe0, 0x0f, 0xf0, 0x07, 0x00,
X   0x00, 0xc0, 0x07, 0xe0, 0x03, 0x00, 0x00, 0x80, 0x03, 0xc0, 0x01, 0x00,
X   0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x01, 0x40, 0x00,
X   0x10, 0x00, 0x00, 0x00, 0x40, 0x00, 0x10, 0x53, 0x37, 0x35, 0xe7, 0x0c,
X   0x90, 0x34, 0x49, 0x4d, 0x48, 0x12, 0x90, 0x17, 0x49, 0x45, 0x4e, 0x1e,
X   0x90, 0x10, 0x49, 0x45, 0x49, 0x02, 0x90, 0x14, 0x49, 0x45, 0x49, 0x12,
X   0x10, 0x13, 0x49, 0x45, 0xd6, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/terminate.xbm' &&
  chmod 0640 'Red/Bitmaps/terminate.xbm' ||
  echo 'restore of Red/Bitmaps/terminate.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/terminate.xbm'`"
  test 1889 -eq "$shar_count" ||
    echo "Red/Bitmaps/terminate.xbm: original size 1889, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Bitmaps/terminate_disab.xbm ==============
if test -f 'Red/Bitmaps/terminate_disab.xbm' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Bitmaps/terminate_disab.xbm (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Bitmaps/terminate_disab.xbm (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Bitmaps/terminate_disab.xbm' &&
X#define terminate_disab_width 48
X#define terminate_disab_height 48
Xstatic char terminate_disab_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
X   0x00, 0x80, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40, 0x05, 0x40, 0x01, 0x00,
X   0x00, 0xa0, 0x0a, 0xa0, 0x02, 0x00, 0x00, 0x50, 0x15, 0x50, 0x05, 0x00,
X   0x00, 0xa8, 0x2a, 0xa8, 0x0a, 0x00, 0x00, 0x50, 0x55, 0x54, 0x05, 0x00,
X   0x00, 0xa0, 0xaa, 0xaa, 0x02, 0x00, 0x00, 0x40, 0x55, 0x55, 0x01, 0x00,
X   0x00, 0x80, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x00, 0x00,
X   0x00, 0x00, 0xaa, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x54, 0x15, 0x00, 0x00,
X   0x00, 0x00, 0xa8, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0x00, 0x00,
X   0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x55, 0x55, 0x01, 0x00,
X   0x00, 0x80, 0xaa, 0xaa, 0x02, 0x00, 0x00, 0x40, 0x55, 0x55, 0x05, 0x00,
X   0x00, 0xa0, 0x2a, 0xaa, 0x0a, 0x00, 0x00, 0x50, 0x15, 0x54, 0x15, 0x00,
X   0x00, 0xa0, 0x0a, 0xa8, 0x0a, 0x00, 0x00, 0x40, 0x05, 0x50, 0x05, 0x00,
X   0x00, 0x80, 0x02, 0xa0, 0x02, 0x00, 0x00, 0x00, 0x01, 0x40, 0x01, 0x00,
X   0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x40, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x51, 0x22, 0x20, 0x44, 0x04,
X   0x80, 0x20, 0x41, 0x45, 0x08, 0x02, 0x10, 0x15, 0x08, 0x00, 0x44, 0x14,
X   0x80, 0x00, 0x41, 0x45, 0x09, 0x02, 0x10, 0x14, 0x08, 0x00, 0x40, 0x10,
X   0x00, 0x02, 0x41, 0x45, 0x80, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SHAR_EOF
  $shar_touch -am 0512222696 'Red/Bitmaps/terminate_disab.xbm' &&
  chmod 0640 'Red/Bitmaps/terminate_disab.xbm' ||
  echo 'restore of Red/Bitmaps/terminate_disab.xbm failed'
  shar_count="`wc -c < 'Red/Bitmaps/terminate_disab.xbm'`"
  test 1907 -eq "$shar_count" ||
    echo "Red/Bitmaps/terminate_disab.xbm: original size 1907, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= Red/Blue ==============
if test -f 'Red/Blue' && test X"$1" != X"-c"; then
  echo 'x - skipping Red/Blue (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting Red/Blue (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'Red/Blue' &&
X### general settings
X
XBlue.manBrowser: netscape
XBlue.manURL:	 http://www.cs.su.oz.au/~mik/red-manual/red-main-page.html
XBlue.motd1:	
XBlue.motd2:	
X
X# good for labtam:
X#Blue.editFont:	lucidasanstypewriter-12
X#Blue.editFont:	lucidasanstypewriter-14
X#Blue.editFont:	lucidasanstypewriter-bold-12
X#Blue.editFont:	lucidasanstypewriter-bold-14
X# good for NCD
X#Blue.editFont:	8x13
X#Blue.editFont:	8x13bold
X#Blue.editFont:	9x15
X
XBlue.editFont:	8x13
XBlue*infoFont:	*Helvetica-Bold-R-Normal*-12-*
X
X*menuBar*fontList:		*Helvetica-Bold-R-Normal*-14-*
X*menuBar.marginHeight:		0
X*toolBar*fontList:		*Helvetica-Bold-R-Normal*-12-*
X
XBackground: 			gray75
X*scrollBar.width:		22
X*scrolledWindow.shadowThickness:2
X*VertScrollBar.width:		18
X*HorScrollBar.height:		18
X*indicatorSize:			18
X
X*buttonArea*fontList:		*Helvetica-Bold-R-Normal*-14-*
X*buttonArea*marginHeight:	4
X*buttonArea*marginWidth:	4
X*buttonArea.marginWidth:	0
X*buttonArea.marginHeight:	0
X*buttonArea.packing:		XmPACK_COLUMN
X*buttonArea*shadowThickness:	2
X*buttonArea*DefaultButtonShadowThickness:	1
X
X*Spacing:			0
X
X#### settings for PROJECT WINDOW ####
X
XBlue.width:	1000
XBlue.height:	750
XBlue.minWidth:	400
XBlue.minHeight:	330
X#Blue.iconPixmap:	/usr/staff/mik/blue/source/Bitmaps/blue_icon.xbm
X
XBlue*drawArea.background: 	gray90
XBlue*viewArea.background: 	gray80
XBlue*topShadowColor:		gray90
XBlue*bottomShadowColor: 	gray40
X
XBlue*selectColor: 		IndianRed4
X
XBlue*toolBar*marginHeight:	4
XBlue*toolBar*marginWidth:	0
XBlue*toolBar.marginHeight:	0
XBlue*show.alignment:		XmALIGNMENT_BEGINNING
XBlue*inheritButton.alignment:	XmALIGNMENT_BEGINNING
XBlue*usesButton.alignment:	XmALIGNMENT_BEGINNING
X
XBlue*objectPopup*fontList:	*Helvetica-Bold-R-Normal*-12-*
XBlue*objectPopup.background:	gray80
XBlue*objectPopup.remove.fontList:	*Helvetica-Bold*-12-*
XBlue*objectPopup.remove.foreground:	IndianRed4
XBlue*objectPopup.inspect.fontList:	*Helvetica-Bold*-12-*
XBlue*objectPopup.inspect.foreground:	IndianRed4
X
XBlue*viewArea*marginHeight: 0
X
XBlue*newButton.labelString: 	New Class
XBlue*darrButton.labelType: 	XmPIXMAP
XBlue*darrButton.labelPixmap: 	/usr/staff/mik/blue/source/Bitmaps/darrow.xbm
XBlue*darrButton.labelInsensitivePixmap: /usr/staff/mik/blue/source/Bitmaps/darrow_disab.xbm
XBlue*arrButton.labelType: 	XmPIXMAP
XBlue*arrButton.labelPixmap: 	/usr/staff/mik/blue/source/Bitmaps/arrow.xbm
XBlue*arrButton.labelInsensitivePixmap: /usr/staff/mik/blue/source/Bitmaps/arrow_disab.xbm
XBlue*alphaButton.labelType: 	XmPIXMAP
XBlue*alphaButton.labelPixmap: 	/usr/staff/mik/blue/source/Bitmaps/alpha.xbm
XBlue*alphaButton.labelInsensitivePixmap: /usr/staff/mik/blue/source/Bitmaps/alpha_disab.xbm
XBlue*editButton.labelString: 	Edit Class
XBlue*compileButton.labelString:	Compile
XBlue*createButton.labelString: 	Create...
X
XBlue*inhToggle.labelType: 	XmPIXMAP
XBlue*inhToggle.labelPixmap: 	/usr/staff/mik/blue/source/Bitmaps/darrow.xbm
XBlue*inhToggle.labelInsensitivePixmap: /usr/staff/mik/blue/source/Bitmaps/darrow_disab.xbm
XBlue*usesToggle.labelType: 	XmPIXMAP
XBlue*usesToggle.labelPixmap: 	/usr/staff/mik/blue/source/Bitmaps/arrow.xbm
XBlue*usesToggle.labelInsensitivePixmap: /usr/staff/mik/blue/source/Bitmaps/arrow_disab.xbm
X
XBlue*viewArea.borderWidth:	1
X
X#Blue*objectWidget.translations: <Btn1Down>: Arm() \n\
X#				<Btn1Up>: Activate()
X
X
X# menus...
X
XBlue*New.labelString: New...
X
XBlue*Open.labelString: Open...
XBlue*Open.acceleratorText: Alt-o
XBlue*Open.accelerator: Meta<Key>o:
X
XBlue*Close.acceleratorText: Alt-w
XBlue*Close.accelerator: Meta<Key>w:
X
XBlue*Save.acceleratorText: Alt-s
XBlue*Save.accelerator: Meta<Key>s:
X
XBlue*SaveAs.labelString: Save As...
X
XBlue*Print.labelString: Print...
XBlue*Print.acceleratorText: Alt-p
XBlue*Print.accelerator: Meta<Key>p:
X
XBlue*Quit.labelString: Exit
X
XBlue*Undo.acceleratorText: Alt-z
XBlue*Undo.accelerator: Meta<Key>z:
X
XBlue*NewClass.labelString: New Class...
XBlue*NewClass.acceleratorText: Alt-n
XBlue*NewClass.accelerator: Meta<Key>n:
X
XBlue*RemoveClass.labelString: Remove Class...
X
XBlue*AddClass.labelString: Class Browser...
XBlue*AddClass.acceleratorText: Alt-b
XBlue*AddClass.accelerator: Meta<Key>b:
X
XBlue*AddInhArrow.labelString: Add Inheritance Arrow...
XBlue*AddInhArrow.acceleratorText: Alt-i
XBlue*AddInhArrow.accelerator: Meta<Key>i:
X
XBlue*RemoveInhArrow.labelString: Remove Inheritance Arrow...
XBlue*RemoveInhArrow.acceleratorText: Shift-Alt-i
XBlue*RemoveInhArrow.accelerator: Shift Meta<Key>i:
X
XBlue*AddUsesArrow.labelString: Add Uses Arrow...
XBlue*AddUsesArrow.acceleratorText: Alt-u
XBlue*AddUsesArrow.accelerator: Meta<Key>u:
X
XBlue*RemoveUsesArrow.labelString: Remove Uses Arrow...
XBlue*RemoveUsesArrow.acceleratorText: Shift-Alt-u
XBlue*RemoveUsesArrow.accelerator: Shift Meta<Key>u:
X
XBlue*GlobalView.labelString: Global View
XBlue*GlobalView.acceleratorText: Alt-g
XBlue*GlobalView.accelerator: Meta<Key>g:
X
X#Blue*Compile.labelString: Compile
XBlue*Compile.acceleratorText: Alt-c
XBlue*Compile.accelerator: Meta<Key>c:
X
XBlue*CompileClass.labelString: Compile Selected
XBlue*CompileClass.acceleratorText: Shift-Alt-c
XBlue*CompileClass.accelerator: Shift Meta<Key>c:
X
XBlue*EditSource.labelString: Edit Source...
XBlue*EditSource.acceleratorText: Alt-e
XBlue*EditSource.accelerator: Meta<Key>e:
X
XBlue*CreateInstance.labelString: Create Instance...
XBlue*CreateInstance.acceleratorText: Alt-k
XBlue*CreateInstance.accelerator: Meta<Key>k:
X
XBlue*NoteBook.labelString: Note Book...
XBlue*NoteBook.acceleratorText: Alt-d
XBlue*NoteBook.accelerator: Meta<Key>d:
X
XBlue*ChangeLog.labelString: Change Log...
XBlue*ChangeLog.acceleratorText: Alt-l
XBlue*ChangeLog.accelerator: Meta<Key>l:
X
XBlue*DoTest.labelString: Run Predefined Tests...
XBlue*DoTest.acceleratorText: Alt-t
XBlue*DoTest.accelerator: Meta<Key>t:
X
XBlue*SubmitProject.labelString: Submit...
X
XBlue*IOShowHide.labelString: Show Window...
XBlue*IOShowHide.acceleratorText: Alt-v
XBlue*IOShowHide.accelerator: Meta<Key>v:
X
XBlue*IOClear.labelString: Clear
X
XBlue*IOFormat.labelString: Format
X
XBlue*IORecord.labelString: Record
X
XBlue*IOPrint.labelString: Print Recording
X
XBlue*Preferences.labelString: Preferences...
XBlue*Colours.labelString: Set Colours...
XBlue*Fonts.labelString: Set Fonts...
XBlue*CompilerOptions.labelString: Compiler Options...
X
X
X#### SETTINGS FOR EDITOR WINDOW ####
X
XRed.width:	696
XRed.height:	500
XRed.minWidth:	400
XRed.minHeight:	260
X
XRed*savedLabel.labelString:	not saved
XRed*statusArea.borderWidth:	1
X
XRed.iconPixmap:		/usr/staff/mik/blue/source/Bitmaps/edit_icon.xbm
XRed*editArea.background: 	white
XRed*infoArea.background:	gray90
XRed*statusArea.background:	gray90
XRed*topShadowColor:		gray90
XRed*bottomShadowColor: 		gray40
X
XRed*selectColor: 		IndianRed3
X
XRed*toolBar*marginHeight:	4
XRed*toolBar*marginWidth:	4
XRed*toolBar.marginWidth:	0
XRed*toolBar.marginHeight:	0
X
XRed*savedLabel.fontList: 	*helvetica*bold*11*
X
X# menus...
X
XRed*New.acceleratorText: Alt-n
XRed*Open.acceleratorText: Alt-o
XRed*Save.acceleratorText: Alt-s
XRed*Close.acceleratorText: Alt-w
XRed*Print.acceleratorText: Alt-p
XRed*Undo.acceleratorText: Alt-z
XRed*Cut.acceleratorText: Alt-x
XRed*Paste.acceleratorText: Alt-v
XRed*Interface.acceleratorText: Alt-i
XRed*FindItem.acceleratorText: Alt-f
XRed*FindNextItem.acceleratorText: Alt-g
XRed*ReplaceItem.acceleratorText: Alt-r
XRed*GotoLineItem.acceleratorText: F5
XRed*ShowLineItem.acceleratorText: F6
XRed*Compile.acceleratorText: Alt-c
XRed*GotoErrItem.acceleratorText: Alt-e
XRed*SetBreakItem.acceleratorText: Ctrl-b
XRed*ClearBreakItem.acceleratorText: Shift-Ctrl-b
XRed*WatchItem.acceleratorText: Ctrl-v
XRed*PrintVarItem.acceleratorText: Ctrl-p
XRed*Step.acceleratorText: Ctrl-s
XRed*StepIntoItem.acceleratorText: Shift-Ctrl-s
XRed*Continue.acceleratorText: Ctrl-u
XRed*Terminate.acceleratorText: Ctrl-t
X
X#Red*PrefItem.acceleratorText: Alt-
XRed*KeyItem.acceleratorText: Alt-k
XRed*DescribeItem.acceleratorText: Alt-d
X
XRed*Open.labelString: Open...
XRed*FindItem.labelString: Find...
XRed*FindNextItem.labelString: Find Next
XRed*ReplaceItem.labelString: Replace...
XRed*GotoLineItem.labelString: Goto Line...
XRed*ShowLineItem.labelString: Show Line Number
XRed*GotoErrItem.labelString: Goto Error
XRed*SetBreakItem.labelString: Set Breakpoint
XRed*ClearBreakItem.labelString: Clear Breakpoint
XRed*WatchItem.labelString: Watch Variable
XRed*PrintVarItem.labelString: Print Variable
XRed*StepIntoItem.labelString: Step Into
XRed*PrefItem.labelString: Preferences...
XRed*KeyItem.labelString: Key Bindings...
XRed*DescribeItem.labelString: Describe Key...
XRed*ManualItem.labelString: Manual...
X
X
X#### SETTINGS FOR CONTROLLER ####
X
Xmachine.title:		Execution Controls
Xmachine.geometry:	-10-10
X
X
X#### SETTINGS FOR TEXT TERMINAL ####
X
XTerminal*TextArea.background: white
XTerminal.geometry:	      -10+10
X
X
X#### SETTINGS FOR DIALOGS ####
X
X*OkButton.labelString:		Ok
X*CancelButton.labelString:	Cancel
X*HelpButton.labelString:	Help
X
X##  HELP DIALOG ##
X
XBlue*DialogHelp.dialogTitle:		Red: Help
XBlue*DialogHelp*fontList:		*Helvetica-Bold-R-Normal*-14-*
XRed*DialogHelp.dialogTitle:		Red: Help
XRed*DialogHelp*fontList:		*Helvetica-Bold-R-Normal*-14-*
X
X##  ERROR DIALOG ##
X
XBlue*DialogError.dialogTitle:		Red: Error
XBlue*DialogError*fontList:		*Helvetica-Bold-R-Normal*-14-*
XRed*DialogError.dialogTitle:		Red: Error
XRed*DialogError*fontList:		*Helvetica-Bold-R-Normal*-14-*
X
X##  QUESTION DIALOG ##
X
XBlue*DialogQuestion.dialogTitle:	Red: Question
XBlue*DialogQuestion*fontList:		*Helvetica-Bold-R-Normal*-14-*
XRed*DialogQuestion.dialogTitle:		Red: Question
XRed*DialogQuestion*fontList:		*Helvetica-Bold-R-Normal*-14-*
X
X##  FILE SELECTION DIALOG ##
X
XBlue*DialogFileSelection.dialogTitle:	Red: File Selection
XBlue*DialogFileSelection*fontList:	*Helvetica-Bold-R-Normal*-14-*
XBlue*DialogFileSelection*textColumns:  	50
XBlue*DialogFileSelection*XmList.background:	LightYellow
XBlue*DialogFileSelection*XmTextField.background:LightYellow
X
X##  FIND DIALOG ##
X
XBlue*DialogFind*fontList:			*Helvetica-Bold-R-Normal*-14-*
XBlue*DialogFind*LineBreakButton.labelString:	Line Break
XBlue*DialogFind*LineBreakButton.fontList:	*Helvetica-Bold-R-Normal*-12-*
XBlue*DialogFind*TabButton.labelString:		Tab
SHAR_EOF
  : || echo 'restore of Red/Blue failed'
fi
echo 'End of archive part 1'
echo 'File Red/Blue is continued in part 2'
echo 2 > _sharseq.tmp
exit 0


