[net.micro.amiga] UUENCODED MY.LIB

dillon@CORY.BERKELEY.EDU (Matt Dillon) (11/07/86)

	I just realized I didn't fix the bug with xputc(), so don't use
the routine.  Thanks all of you who have messaged me bugs you've found!


				-Matt


#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
#	doc.txt
#	my.lib.uue
# This archive created: Fri Nov  7 00:03:33 1986
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'doc.txt'" '(19348 characters)'
if test -f 'doc.txt'
then
	echo shar: "will not over-write existing file 'doc.txt'"
else
cat << \!Funky!Stuff! > 'doc.txt'

MY.LIB COMPILATION

   - 32 bit Lattice C  OR  32 bit Manx C (i.e. +l option) It has not
     been tested under Manx, but since the assembly routines do not use
     the frame pointer (Lattice and Manx use different FP's), I see no
     problems.

   - Compile Each .C module with stack checking DISABLED (this is an option
     with lattice, I don't know about manx)

   - Assemble each .ASM module

   - JOIN ALL the .O modules together to create the library.  Under MANX,
     you might have to use Manx's support programs to create the library.

   - When linking in MY.LIB, link it BEFORE Amiga.lib.  It can go before or
     after any other libraries, but remember that if MY.LIB has priority
     (comes before) LC.LIB, some of LC.LIB's functions are replaced
     (string functions, etc...).  Additionaly, MY.LIB contains the function
     FPRINTF for FILEHANDLES (the fprintf in LC.LIB and MAnx's library is
     for the respective STDIO routines).  Also read the docs on malloc() and
     free() under MY.LIB



MY.LIB DOCUMENTATION OF COMMANDS:

XSTDIO:

   fi     = xopen(name, mode, bufsize)
   result = xasync(fi, command)
            xclose(fi)
        c = xgetc(fi)
            xputc(fi, c)
   actual = xread(fi, buf, n)
     bool = xwrite(fi, buf, n)
     bool = xsetbuf(fi, bufsize)
       fi = xattach(FileHandle, bufsize)
       fh = xdetach(fi)
 position = xtell(fi)
   newpos = xseek(fi, offset, mode)    mode= -1/0/1
     bool = xputs(fi, buf)             Note: adds \n
   nchars = xgets(fi, buf, max)        Replaces \n with \0. nchars includes \0
      buf = gets(buf)
            puts(buf)
     bool = xflush(fi)
            xprintf(fi, ctlstring, args...)     xstdio file pointer
            fprintf(fh, ctlstring, args...)     AmigaDos file handle

STRING:
      len = strlen(str)
      dst = strcpy(dst, src)
      dst = strcat(dst, src)
   result = strcmp(s1, s2)              result: -1 s1<s2  0 s1=s2  1 s1>s2

      dst = strncpy(dst, src, max)      max doesn't include \0
      dst = strncat(dst, src, max)      max doesn't include \0
      dst = strncmp(dst, src, max)

MEMORY:

      str = malloc(bytes)               (a hack.. is wasteful)
            free(str)
            free_memory()               must be called on exit if you use
                                         malloc().

            bzero(ptr, bytes)
            bmov(src, dst, bytes)       handles both src<dst and src>dst
            bset(ptr, bytes, char)

MISC:
      val = atoi(str)
     bool = openlibs(mask)              see xmisc.h for bitmap of mask
            closelibs(mask)             may give argument '-1' to close all
     bool = wildcmp(wild, name)
            check32()                   exits if not compiled w/32 bit ints
            io_open()                   See below for calling parameters
            io_close()                  See below for calling parameters

     bool = checkbreak()                check if break pressed
            resetbreak()                reset 'break-pressed' signal.

            mountrequest(bool)          disable/enable requestors for
                                        unmounted filing system accesses.


CAPSULE SUMMARY OF XSTDIO:

   The xstdio routines provide the programmer (read 'us') with buffered
   and asyncronous file support.  With xstdio, you generally have better
   control over your file-pointers than the original stdio.  The
   disadvantage to xstdio is that its error reporting mechanism hasn't
   been fully developed as yet.

   Please note that the xstdio file pointers (I denote them as 'FI') are
   not in anyway compatible with stdio file pointers.

   For your safety, you should not access an xstdio file pointer's file
   handle directly.  Especially when you are using the asyncronous write
   utility (see xasync()), the file pointer's file handle is placed in a
   precarious position and should only be accessed through xstdio routines.

   The XSTDIO routines provide the programmer with buffered file I/O much
   like STDIO routines.  XSTDIO routines offer better control over your
   enviroment, but lack in error reporting for some functions.  The
   XSTDIO routines also have the ability to double-buffer writes.

   XSTDIO routines use a File Pointer (fi), but are NOT compatible
   with STDIO routines.

Implimentation Notes:
   My implimentation of xprintf() and fprintf() uses the stack to hold
   the output buffer... 256 bytes.  Therefore, the eventual output
   string of a given xprintf() or fprintf() call cannot be larger than
   255 bytes.  I've heard that it can't be larger anyway due to
   restrictions on RawDoFmt(), but am not sure.

   The xstdio puts() exists to correct a problem with AMIGA.LIB's puts().
   Namely, the latter crashes on outputs larger than 255 bytes for no
   good reason.


--------------------------------------------------------------------------

   fi = xopen(name, access, bufsize)

      FILE *fi;         returned file pointer
      char *name;       file name to open
      char *access;     access modes "r", "r+", "w", "w+"
      int  bufsize;     requested buffer size, in bytes

      "r"   -read           (fail if non-existant)
      "r+"  -read and write (fail if non-existant)
      "w"   -write          (create if non-existant, truncate if exists)
      "w+"  -append         (create if non-existant, seek to end if exists)

      The minimum buffer size is 1 (calling w/ 0 is actually 1).  It is
      suggested that you use buffer sizes of at least 512 bytes.  For
      example, if you xopen() with a bufsize of 1 and write out a 20K
      block, it will be written 1 byte at a time.

      NULL is returned on error.


   result = xasync(fi, operation)

      int result;       -result of operation (depends)
      FILE *fi;         -file pointer
      int operation;    -operation

      operation = -1    -returns boolean whether async. is on or off.
                  0     -turns async OFF
                  1     -turns async-writes ON
                  2     -reserved
                  3     -(internal) waits for async. operation to complete
                  4     -(internal) don't call with this operation.

      usually one calls xasync() with operation 0 or 1 to turn off or
      on asyncronous write mode.  When ON, another buffer of the same
      size is allocated to provide the double buffering asyncronous-writes
      need.  When on, any write operation which causes the buffer to
      flush to the disk will be done asyncronously (e.g. will return before
      disk operation is complete).  This is only useful if you are not
      writing to the disk at full speed.  Since the writes are only double-
      buffered, writing at full speed WILL cause momentary block conditions
      just like normal writing.  A good use for asyncronous writes is the
      capture function of a modem program.

      Future revisions of the library will also have an asyncronous READ
      capability.



   fi = xattach(fh, bufsize)

      FILE *fi;         -return file pointer
      FileHandle fh;    -source AmigaDOS file handle
      int bufsize;      -buffering size (like xopen()).

      This routine will attempt to attach a file pointer to a file handle.
      If it succedes, any further I/O should be through XSTDIO functions
      and the file pointer rather than AmigaDOS functions through the
      File Handle.

      fi returns NULL if the buffer could not be allocated.


   fh = xdetach(fi)

      FileHandle fh;    -file handle
      FILE *fi;         -file pointer

      This call deallocates the XSTDIO file pointer and returns a properly
      Seek'd file handle.  It ALWAYS works.


   bool  = xsetbuf(fi, newbufsize)

      int bool;            -did the operatio work?
      FILE *fi;            -file pointer
      int newbufsize;      -new buffer size.

      This operation resizes a file pointer's buffer(s).  If it fails, the
      original buffer(s) are still in place.  Remember that if xasync() is
      on for that file pointer, the actual allocated memory is twice the
      requested buffer size.


   chars =  xgets(fi, buf, n)

      int chars;     -# bytes in buffer INCLUDING the termination \0.
      FILE *fi;      -file handle to get data from.
      char *buf;     -buffer to place data in
      int n;         -maximum buffer size allowed.

      This routine will retrieve a string from the file pointer until it
      reaches the end of file or a newline '\n'.  The newline is REPLACED
      by a \0 before the function returns.

      The End Of File occurs when 'chars' is 0.


   bool  = xputs(fi, buf);

      int bool;      -did the operation work?
      FILE *fi;      -file pointer
      char *buf;     -\0 terminated string

      xputs() writes the specified string to the specified file pointer.
      The \0 in the string is replaced with a newline '\n' in the output.


   c  = xgetc(fi);

      int c;         -returned char or -1
      FILE *fi;      -file pointer

      xgets() gets a single character from a file pointer.  -1 is returned
      on EOF or error.


   bool  = xputc(fi, c);

      int bool;      -did it work?
      FILE *fi;      -file pointer
      char c;        -character to write

      output a single character to a file.  NOTE: Since files are buffered,
      you may not get an error until the buffer is flushed.


   actual = xread(fi, buf, n);

      int actual;    -actual bytes read or 0
      FILE *fi;      -file pointer
      char *buf;     -buffer to read into
      int n;         -max # bytes to read

      0 is returned on EOF or error.  Attempt to read n bytes into a buffer.
      The actual number read is returned.


   bool = xwrite(fi, buf, n);

      int bool;      -did the operation work?
      FILE *fi;      -file pointer
      char *buf;     -buffer
      int n;         -bytes to write

      Note that xwrite() returns a bool, not the actual number bytes
      written.


   bool = xflush(fi);

      int bool;      -sucess?
      FILE *fi;      -file ptr;

      FILE is returned only if the buffer was modified AND the Write()
      failed.


   newpos = xseek(fi, offset, which);

      int newpos;    -NEW position AFTER xseek.
      FILE *fi;      -file pointer
      int offset;    -offset relative to 'which'
      int which;     -AMIGA conventions  -1(start)  0(current)  1(end)


   pos = xtell(fi);

      int pos;
      FILE *fi;

      Self evident: returns the current seek position.  Note that this
      may not reflect the actual Seek() position of the underlying file
      handle.


   xclose(fi);

      FILE *fi;

      close the file pointer AND the underlying file handle.  You may pass
      this routine a NULL without ill-effects.


   xprintf(fi, cs, arg, arg ... )

      FILE *fi;
      char *cs;

      Uses AMIGA.LIB's RawDoFmt.  This version of printf outputs to a
      file pointer.  xprintf() dies with large output strings (>255), so
      don't be too fancy.  Also note that RawDoFmt is not a full fledged
      printf, but should do what you want.


   fprintf(fh, cs, arg, arg ... )

      long fh;
      char *cs;

      Same thing as xprintf() except works on AmigaDos File Handles.


   ptr = gets(buf)

      char *ptr;
      char *buf;

      gets() uses Input() to get the next line from the programs STDIN.
      NULL is returned on EOF or error.

      This is rather a slow function, since data is read one-byte-at-a-time.
      It works fine for user-input, but if your program expects STDIN to
      be a file, you may want to xattach() Input() to a file-pointer and
      use xgets().


   bool = puts(str)

      int bool;
      char *str;

      Output the \0 terminated string to STDOUT, replacing the \0 with
      a newline (\n).  Unlike AMIGA.LIB's puts(), this one allows
      strings of any size.


---------------------------------------------------------------------------


result   = atoi(str)

      int result;    -resulting integer
      char *str;     -source string

      atoi() converts ascii-decimal integers into integers, stopping at
      the first illegal character.


#include <xmisc.h>
bool     = openlibs(libs_mask)

      int bool;         -if all the libraries were openned
      int libs_mask;    -mask of all libraries to open.

      openlibs() is an easy way of openning several run-time libraries at
      once.  If you have this call in your code, global definitions for
      all of the amiga's standard libraries will be automatically
      included.  You specify a mask of libraries to open (see xmisc.h for
      mask #defines).  If all the libraries could be openned, TRUE is
      returned.  If one or more could not be openned, FALSE is returned on
      the ones that were able to be openned are closed.


closelibs(libs_mask)

      int libs_mask;

      close the specified libraries.  Only open libraries will be closed.
      Thus, you can say:  closelibs(-1); to close all the libraries.


bool = wildcmp(wild, name)

      int bool;
      char *wild;
      char *name;

      wildcmp() returns TRUE of the wildcard-name matches a normal
      string-name:

         TRUE = wildcmp("abcd?f", "abcdef");
         TRUE = wildcmp("abc*x",  "abcd.e.f.x");
         FALSE= wildcmp("ab??",   "ab");

      The wildcard name may consist of any number of '*'s and '?'s.


check32()
      Checks to see if the program was compiled using 32-bit ints.  If
      not, gives an error message and exit()'s.


checkbreak()
resetbreak()
      checkbreak() returns true (1) if ^C has been pressed.  Once ^C has
      been pressed, checkbreak() will always return true until you call
      resetbreak() to reset the signal. (checkbreak() does not reset the
      signal).


mountrequest(bool)
      turn on or off automatic system requestors when your program accesses
      unmounted prefixes:

      TRUE (default) -system will prompt user to place correct disk
                      in drive via a requestor when program accesses
                      unmounted file.

      FALSE          -if a given file path is not mounted, an error is
                      returned to the program rather than prompting the
                      user.

      WARNING:  Do not exit the program while mountrequest() is set to
      FALSE... bad things might happen.

      NOTE: You can call mountrequest() with it's current state without
      harm.  That is, you can call mountrequest(TRUE) when it is already
      TRUE, and mountrequest(FALSE) when it is already false.



io_open()
io_close()


  long
  io_open(device_name, unit, flags, &rreq, &wwreq, req_size, spec1, spec2)

    char *device_name          -the device name (ex: "serial.device")
    int   unit                 -unit #
    int   flags                -OpenDevice flags
    struct IOxxxxxx *rreq      -address of pointer (will be filled in)
    struct IOxxxxxx *wreq      -address of pointer (will be filled in)
    int   req_size             -size of above structures
    long  spec1,spec2          -special arguments for preinitialization
                                 (depends on the device your openning)

    EXAMPLE:
    ----------------------
    typedef struct IOExtSer SIO;

    #define SERFLAGS (SERF_XDISABLED | SERF_SHARED)
    SIO *srr, *swr;
    long mask;

    mask = io_open("serial.device",0,0,&srr,&swr,sizeof(SIO),SERFLAGS,0);
                   ...
    io_close(srr, swr, sizeof(SIO));

    ----------------------

    The structure for rreq and wreq depend on the device you are openning.
    You must be sure to specify the correct size.

    Some devices, such as the serial device, require certain fields inside
    their IO structures to be initialized before the OpenDevice().  Since
    io_open() Allocates these structures for you, these extra parameters
    must be passed to io_open() via SPEC1 and SPEC2 in the arguments list
    as outlined below:
                     SPEC1              SPEC2
    console.device   window pointer     window structure size
    parallel.device  parallel flags     0
    serial.device    serial flags       0
    **ALL OTHERS**   0                  0

    note on audio device:  You must ADCMD_ALLOCATE and ADCMD_FREE
    manually.

    You also pass io_open() the address of two pointers (e.g. **x).  These
    will be filled in by io_open() to result in a READ and WRITE request
    structure, each with it's own reply port, and with it's io_Command
    fields initialized to CMD_READ and CMD_WRITE, respectively.  You may
    specify a NULL for the **WRITE request structure instead of a
    **wreq.  This will result in only a READ request structure being
    set up.

    You do not have to use the structures for only CMD_READ and CMD_WRITE,
    of course, you can use them for any io command.

    a signal MASK with one bit set is returned.  This is the signal bit
    for the read-request structure (if rreq was NULL, then it is the
    signal for the write-request structure).  an example mask:
     00000000001000000000000000000000 in binary.

    0 is returned if the open fails.


  io_close(rreq, wreq, size)

       specify 0 for the wreq if it doesn't exist (e.g. you passed a
       NULL for it in the io_open() ).




----------------------------------------------------------------------------
memory routines.  These are not quite automatic.  You must call the
routine 'free_memory()' just before you exit if you use 'malloc'.
The binary-zero/set/mov routines are written in assembly for speed.


ptr = malloc(bytes);

   char *ptr;        -pointer to buffer
   int bytes;        -#bytes to allocate

   NULL is returned if the allocation failed.  The pointer returned is on
   32-bit boundries (e.g. longword).


free(ptr)

   char *ptr;

   Free a malloc'd space.  Call only with pointer's you have
   malloc'd.


free_memory()

   Must be called before you exit to free ALL mallocs that have occured .


bzero(s, n)

   char *s;
   int n;

   Zero n bytes starting at s.


bset(s, n, v)

   char *s;    -start address
   int n;      -# bytes
   int v;      -fill value

   Set a memory area to 'v'.


bmov(s, d, n)

   char *s;    -source
   char *d;    -dest
   int n;      -# bytes

   Move from source to destination. bmov() will properly do a forward or
   reverse move depending on where s and d are relative to each other.


--------------------------------------------------------------------------
String routines.  Exactly as normal STDIO routines.


len   = strlen(str)

   int len;
   char *str;

   return the length of the string.


dest = strcpy(dest, source)

   char *source, *dest;

   string copy.  source and destination must be disjunct.


dest = strncpy(dest, source, maxchars)

   char *dest, *source;
   int maxchars;

   Copy no more than maxchars bytes.  This does NOT include the \0.


dest = strcat(dest, source)

   Place the source after the destination.  Source and where source will
   be placed on destination must be disjuct.


dest = strncat(dest, source, n)

   Same as strcat, but no more than n chars will be copied, \0 NOT included.


result = strcmp(source, dest)

   Compare the source with the destination.  Result is:

   -1    source < dest
   0     source = dest
   1     source > dest


result = strncmp(source, dest, n)

   Same as strcmp, but a maximum of n chars are compared.


!Funky!Stuff!
fi  # end of overwriting check
echo shar: "extracting 'my.lib.uue'" '(17491 characters)'
if test -f 'my.lib.uue'
then
	echo shar: "will not over-write existing file 'my.lib.uue'"
else
cat << \!Funky!Stuff! > 'my.lib.uue'
begin 644 my.lib
M```#YP````)X<V5E:RYQ`````^@````!=&5X=````^D````]3E;_]$CG#P0J
M;@`(+BX`#"PN`!`,A@````%L4"H'2H9F!-JM`!P@+0`,T(60K0`<*`!M&+BM
M`!!N$BM$``PK10`<(`5,WR#P3EY.=2\-3KD`````6(]P_R\`+P4O+0`(3KD`
M````3^\`#&`>+PU.N0````!8CW`"+P`O!R\M``A.N0````!/[P`,+6T`'/_T
M<``O`"\`+RT`"$ZY`````$_O``PK0``<*T``&"`M`!RPKO_T;#(B+0`4XH$M
M0/_TD($K0``<;`1"K0`<+PU.N0````!8CR`N__20K0`<*T``#"MN__0`'"`M
M`!Q,WR#P3EY.=0```^^!```#7WAF;'5S:%]W86ET`````@```'````!0@0``
M`E]3965K`````````P```)P```""````8H$```)?>&9I;&)U9@````$```#0
M`0```E]X<V5E:P````````````````/R```#\@```^@````!9&%T80```^H`
M```````#\@```_(```/H`````G5D871A```````#ZP````````/R```#\@``
M`^<````#<F%M.GAC;&]S90`````#Z`````%T97AT```#Z0```!I.5@``2.<`
M!"IN``B[_`````!G3"\-3KD`````6(]*K0`$9PP@;0`$0J<O#4Z04(]*K0`(
M9PPO+0`(3KD`````6(\O+0`4+RT`(DZY`````%"/<"HO`"\-3KD`````4(],
MWR``3EY.=0```^^!```"7WAF;'5S:``````!````&($```)?0VQO<V4`````
M``$````\@0```E]&<F5E365M`````@```%H```!,`0```E]X8VQO<V4`````
M``````````/R```#\@```^@````!9&%T80```^H````````#\@```_(```/H
M`````G5D871A```````#ZP````````/R```#\@```^<````#<F%M.GAA<WEN
M8P`````#Z`````%T97AT```#Z0```'U.5O_\2.<!!"IN``@@+@`,!(#_____
M;0``\`R`````!FP``.;E@$[["`)@```68```)&```%Q@``#08```JF```+9*
ME5;`1`!(@$C`3-\@@$Y>3G5*E6<N+PUA``"V6(\O%4ZY`````%B/+RT`%"\M
M`"9.N0````!0CW``*H`K0``F*T``!'`!3-\@@$Y>3G5*E69(<``O`"\`3KD`
M````4(\N`$J'9RI"IR\M`!1.N0````!0CRM``"9*@&84+P=.N0````!8CW``
M3-\@@$Y>3G4JAT'Z_RHK2``$<`%,WR"`3EY.=2\-82A8CW`!3-\@@$Y>3G4O
M#6$``&A8CW`!3-\@@$Y>3G5P`$S?((!.7DYU3E8``$CG``0J;@`(2I5G.!`M
M`"`(```!9RXO%4ZY`````%B/+Q5.N0````!8CW)$+P$O`$ZY`````%"/$"T`
M(`(`__T;0``@3-\@`$Y>3G5.5O_P2.<`/"IN``@@+0`(Y8`D0"\\``$``'!$
M+P!.N0````!0CR9`($O0_``4(`@G0``*)TL`%"=5`!AP5R=``!P@2]#\`"@H
M2"BJ`"0I;0`B``0I;0`,``@O#6$`_U)8CR\++RH`"$ZY`````%"/$"T`(```
M``(;0``@(&T`(BMM`"8`(BM(`"9,WSP`3EY.=0```^^!```#7T1E;&5T95!O
M<G0``````@```,(```!D@0```E]&<F5E365M`````@```4@```!T@0```U]#
M<F5A=&50;W)T``````$```"<@0```U]!;&QO8TUE;0````````(```&"````
ML($```-?5V%I=%!O<G0````````!```!,($```)?1V5T37-G``````$```$Z
M@0```E]0=71-<V<``````0```<P!```"7WAA<WEN8P```````````````_(`
M``/R```#Z`````%D871A```#Z@````````/R```#\@```^@````"=61A=&$`
M``````/K`````````_(```/R```#YP````)R86TZ9G)E90```^@````!=&5X
M=````^D````13E;__$CG``1*K@`(9RX@;@`(D/P`#"`(*D`@;0`$(E4@B4J5
M9P@@52%M``0`!"\M``@O#4ZY`````%"/3-\@`$Y>3G4```/O@0```E]&<F5E
M365M`````0```#8!```"7V9R964``````````````````_(```/R```#Z```
M``%D871A```#Z@````````/R```#\@```^@````"=61A=&$```````/K````
M`````_(```/R```#YP````)R86TZ9V5T<P```^@````!=&5X=````^D````:
M3E;_^$CG`P0J;@`(?@!.N0`````L`"!-T<=P`2\`+P@O!DZY`````$_O``Q*
M@&<:4H<@!U.`($W1P!`0#```#6<(#```"F;.3G%*AV<.(`=3@"!-T<!"$"!-
M8`*1R"`(3-\@P$Y>3G4```/O@0```E]);G!U=````````0```!"!```"7U)E
M860````````!````)`$```)?9V5T<P`````````````````#\@```_(```/H
M`````61A=&$```/J`````````_(```/R```#Z`````)U9&%T80```````^L`
M```````#\@```_(```/G`````W)A;3IX<V5T8G5F`````^@````!=&5X=```
M`^D````X3E;_]$CG`3PJ;@`(+BX`#`R'`````6P"?@$O#4ZY`````%B/0J<O
M!TZY`````%"/*$"7RR1M``2U_`````!G#D*G+P=.N0````!0CR9`N?P`````
M9UBU_`````!G"+?\`````&=(M?P`````9QIP`R\`+PU.DE"/+RT`%"\M`"9.
MN0````!0CR\M`!0O+0`B3KD`````4(\K3``B*TL`)BM'`!1P`4S?/(!.7DYU
MN?P`````9PPO!R\,3KD`````4(^W_`````!G#"\'+PM.N0````!0CW``3-\\
M@$Y>3G4```/O@0```E]X9FQU<V@``````0```!Z!```#7T%L;&]C365M````
M`````@```$8````J@0```E]&<F5E365M````!````-````"\````D@```((!
M```"7WAS971B=68``````````````_(```/R```#Z`````%D871A```#Z@``
M``````/R```#\@```^@````"=61A=&$```````/K`````````_(```/R```#
MYP````````/I````!B!O``0B+P`,("\`"&<```@0P5.`9OI.=0```^\!```"
M7V)S970``````````````````_(```/G`````W)A;3IC:&5C:S,R`````^@`
M```!=&5X=````^D````,3E;__'``4X`M0/_\4H!G'$AY`````$ZY`````%B/
M+SP``,-03KD`````6(].7DYU```#[`````$````!````$@````````/O@0``
M`E]P=71S`````````0```!B!```"7V5X:70````````!````)@$```)?8VAE
M8VLS,@`````````````#\@```_(```/H`````61A=&$```/J````"4U54U0@
M0D4@0T]-4$E,140@5TE42"`S,BUB:70@24Y4)W,A`````_(```/R```#Z```
M``)U9&%T80```````^L````````#\@```_(```/G`````G)A;3IP=71S```#
MZ`````%T97AT```#Z0```!E.5O_X2.<#`$ZY`````"X`+RX`"$ZY`````%B/
M+``O!B\N``@O!TZY`````$_O``RPAF8D<`$O`$AY`````"\'3KD`````3^\`
M#$J`9PIP`4S?`,!.7DYU<`!,WP#`3EY.=0`````#[`````$````!````.@``
M``````/O@0```E]/=71P=70``````0````J!```"7W-T<FQE;@`````!````
M%H$```)?5W)I=&4```````(```!"````*`$```)?<'5T<P``````````````
M```#\@```_(```/H`````61A=&$```/J`````0H```````/R```#\@```^@`
M```"=61A=&$```````/K`````````_(```/R```#YP````````/I````'4ZY
M````(DZY`````&````Y.N0```").N0````!/[P$,3G4@3Y_\```!#"Z0+V@`
M"``$0^\`$"])``A(YP`^)DE#Z``0(&@`#"1\````<"QY`````$ZN```F;P`<
M2AMF_)?O`!Q3BR]+`"!,WWP`3G46P$YU```#[`````,`````````2@```!(`
M```"`````````^\!```"7V9P<FEN=&8````0`0```E]X<')I;G1F`````($`
M``)?4WES0F%S90````$```!0@0```E]7<FET90```````0```!B!```"7WAW
M<FET90`````!````"(,```-?3%9/4F%W1&]&;70````!````5@````````/R
M```#YP````-R97-E=&)R96%K+G$```/H`````71E>'0```/I````!2\\```0
M`$*G3KD`````4(].=0`````#[X$```-?4V5T4VEG;F%L```````!````"@$`
M``-?<F5S971B<F5A:P```````````````_(```/R```#Z`````%D871A```#
MZ@````````/R```#\@```^@````"=61A=&$```````/K`````````_(```/R
M```#YP````````/I````!B!O``1*&&;\D>\`!)'\`````2`(3G4``````^\!
M```"7W-T<FQE;@```````````````_(```/G`````W)A;3IS=')N8W!Y````
M`^@````!=&5X=````^D````.3E;__$CG`1PJ;@`(*&X`#"XN`!`F34H49Q`@
M!U.'2H!G"!J44HQ2C6#L0A52C2`+3-\X@$Y>3G4```/O`0```E]S=')N8W!Y
M``````````````/R```#\@```^@````!9&%T80```^H````````#\@```_(`
M``/H`````G5D871A```````#ZP````````/R```#\@```^<````#<F%M.GAR
M96%D```````#Z`````%T97AT```#Z0```!Q.5O_X2.<'#"IN``@H;@`,+BX`
M$'H`("T`$)"M``PL`+R';P(L!TJ&9R8@;0`BT>T`#"\&+PPO"$ZY`````$_O
M``S9QIZ&VH;=K0`<W:T`#$J'9Q`O#4ZY`````%B/2H!G`F"R(`5,WS#@3EY.
M=0`````#[X$```)?8FUO=@````````$````Z@0```E]X9FEL8G5F`````0``
M`%@!```"7WAR96%D`````````````````_(```/R```#Z`````%D871A```#
MZ@````````/R```#\@```^@````"=61A=&$```````/K`````````_(```/R
M```#YP````````/I````#"!O``0B;P`(("\`#&<``!ZSR&<``!AO```.T<#3
MP!,@4X!F^DYU$MA3@&;Z3G4``````^\!```"7V)M;W8`````````````````
M`_(```/G`````W)A;3IS=')N8VUP`````^@````!=&5X=````^D````93E8`
M`$CG`0PJ;@`(*&X`#"XN`!!*AV<T2A5G,$H49RQ3AQ`5$A2P`60*</],WS"`
M3EY.=1`5$A2P`6,*<`%,WS"`3EY.=5*-4HQ@R$J'9P@0%1(4L`%FRG``3-\P
M@$Y>3G4``````^\!```"7W-T<FYC;7```````````````_(```/R```#Z```
M``%D871A```#Z@````````/R```#\@```^@````"=61A=&$```````/K````
M`````_(```/R```#YP````-R86TZ>&1E=&%C:`````/H`````71E>'0```/I
M````$TY6__Q(YP$$*FX`""\-3KD`````6(\N+0`(("T`')"M`!A"IR\`+P=.
MN0````!/[P`,0JT`""\-3KD`````6(\@!TS?((!.7DYU``````/O@0```E]X
M9FQU<V@``````0```!"!```"7U-E96L````````!````*H$```)?>&-L;W-E
M``````$````Z`0```E]X9&5T86-H``````````````/R```#\@```^@````!
M9&%T80```^H````````#\@```_(```/H`````G5D871A```````#ZP``````
M``/R```#\@```^<````$<F%M.F9R965?;65M;W)Y`````^@````!=&5X=```
M`^D````.3E;__$CG``1*N0````!G'B!Y`````"I0+R@`""\(3KD`````4(\C
MS0````!@VDS?(`!.7DYU``````/L`````P````(````H````$@````H`````
M```#[X$```)?1G)E94UE;0````$````@`0```U]F<F5E7VUE;6]R>0``````
M```````#\@```_(```/H`````61A=&$```/J`````````_(```/R```#Z```
M``)U9&%T80```````^L````!```#[P$```-?06QL8U]B87-E````````````
M`````_(```/R```#YP````-R86TZ;6%L;&]C``````/H`````71E>'0```/I
M````&4Y6__Q(YP`$("X`"`:`````#$*G+P!.N0````!0CRI`2KD`````9PH@
M>0`````A30`$*KD`````*WP```````0@+@`(!H`````,*T``""/-`````"!-
MT/P`#"`(3-\@`$Y>3G4```/O@0```U]!;&QO8TUE;0````````$````8@0``
M`U]!;&QC7V)A<V4```````4```!0````.@```#0````J````(@$```)?;6%L
M;&]C```````````````#\@```_(```/H`````61A=&$```/J`````````_(`
M``/R```#Z`````)U9&%T80```````^L````````#\@```_(```/G````````
M`^D````&(&\`!")O``@@"$H89OQ3B!#99OQ.=0`````#[P$```)?<W1R8V%T
M```````````````#\@```^<````"<F%M.F%T;VD```/H`````71E>'0```/I
M````&TY6__A(YR,$*FX`"'X`?``0%0P``"!F!%*-8/00%0P``"UF!%*-?`$0
M%0P``#!M)@P``#EN("`'(@?C@20'YX+2@A052()(PE*-TH($@0```#`N`6#2
M2H9G!B`'1(!@`B`'3-\@Q$Y>3G4``````^\!```"7V%T;VD`````````````
M`````_(```/R```#Z`````%D871A```#Z@````````/R```#\@```^@````"
M=61A=&$```````/K`````````_(```/R```#YP````1R86TZ8VQO<V5L:6)S
M```````#Z`````%T97AT```#Z0```!%.5O_\2.<`!$OY`````$IN``IG)@@N
M````"V<02I5G#"\53KD`````6(]"E3`N``KB2%B-/4``"F#43-\@`$Y>3G4`
M`````^^!```"7T=F>$)A<V4````!````"H$```1?0VQO<V5,:6)R87)Y````
M`````0```"0!```#7V-L;W-E;&EB<P````````````````/R```#\@```^@`
M```!9&%T80```^H````````#\@```_(```/H`````G5D871A```````#ZP``
M``````/R```#\@```^<````#<F%M.G=I;&1C;7`````#Z`````%T97AT```#
MZ0```$-.5O^T2.<`#"IN``@H;@`,0J[_M$H49@9*%6<``.00%4B`2,`,@```
M`#]G``"6#(`````J9@``H`RN````"/^T9AA(>0````!.N0````!8CW``3-\P
M`$Y>3G4@+O^TYX`MC0BX+8P(O%*N_[12C6"D4Z[_M$JN_[1K%B`N_[3G@"!V
M"+P0$$H`9@93KO^T8.1*KO^T:@IP`$S?,`!.7DYU("[_M.>`('8(N%*(*D@@
M=@B\4H@MB`B\*$A2KO^T8`#_5$H49BA*KO^T9J1P`$S?,`!.7DYU$!02%;`!
M9Q!*KO^T9HQP`$S?,`!.7DYU2A1G`E*,2A5G`/\<4HU@`/\6<`%,WS``3EY.
M=0`````#[`````$````!````1`````````/O@0```E]P=71S`````````0``
M`$H!```"7W=I;&1C;7```````````````_(```/R```#Z`````%D871A```#
MZ@````94;V\@;6%N>2!L979E;',@;V8@)RHG``````/R```#\@```^@````"
M=61A=&$```````/K`````````_(```/R```#YP````-C:&5C:V)R96%K+G$`
M``/H`````71E>'0```/I````"'``+P`O`$ZY`````%"/`H```!``5L%$`4B!
M2,$@`4YU```#[X$```-?4V5T4VEG;F%L```````!````"`$```-?8VAE8VMB
M<F5A:P```````````````_(```/R```#Z`````%D871A```#Z@````````/R
M```#\@```^@````"=61A=&$```````/K`````````_(```/R```#YP````-R
M86TZ>&9I;&)U9@````/H`````71E>'0```/I````)$Y6__A(YP,$*FX`""PM
M``@O#4ZY`````%B/("T`&"(M`!RR@&<2DH!"IR\!+P9.N0````!/[P`,+RT`
M%"\M`"(O!DZY`````$_O``PN`$J';B0@+0`<*T``&'+_+P$O`"\&3KD`````
M3^\`#'``3-\@P$Y>3G4@!RM``!`B+0`<TH`K00`8<`%,WR#`3EY.=0```^^!
M```#7WAF;'5S:%]W86ET`````0```!2!```"7U-E96L````````"````9```
M`#"!```"7U)E860````````!````1`$```)?>&9I;&)U9@`````````````#
M\@```_(```/H`````61A=&$```/J`````````_(```/R```#Z`````)U9&%T
M80```````^L````````#\@```_(```/G`````W)A;3IX871T86-H`````^@`
M```!=&5X=````^D````F3E;__$CG``0,K@````$`#&P&<`$M0``,+SP``0``
M<"HO`$ZY`````%"/*D"[_`````!G6"`N``PK0``40J<O`$ZY`````%"/*T``
M(DJ`9RX@+@`(*T``"'``+P`O`"\M``A.N0````!/[P`,*T``'"M``!@@#4S?
M(`!.7DYU<"HO`"\-3KD`````4(]P`$S?(`!.7DYU``````/O@0```U]!;&QO
M8TUE;0````````(```!"````)($```)?4V5E:P````````$```!D@0```E]&
M<F5E365M`````0```(8!```"7WAA='1A8V@``````````````_(```/R```#
MZ`````%D871A```#Z@````````/R```#\@```^@````"=61A=&$```````/K
M`````````_(```/R```#YP````-R86TZ>&9L=7-H``````/H`````71E>'0`
M``/I````/DY6__1(YP<$*FX`"'H!$"T`(`@```!G``"4("T`')"M``PN`"`M
M`!BPAV<L2JT`!&<.(&T`!'`#+P`O#4Z04(\@!Y"M`!A"IR\`+RT`"$ZY````
M`$_O``Q*E6<4(&T`!'`$+P`O#4Z04(\L+0`,8!@O+0`,+RT`(B\M``A.N0``
M``!/[P`,+``@+0`,L(9G"'H`2H9J`GP`(`?0ABM``!@0+0`@`@#__AM``"!P
M`"M``!`K0``,(`5,WR#@3EY.=4Y6__Q(YP$`+RX`"&$`_S)8CRX`(&X`"$JH
M``1G#B)H``1P`R\`+PA.D5"/(`=,WP"`3EY.=0`````#[X$```)?4V5E:P``
M``````$```!0@0```E]7<FET90```````0```'X!```"7WAF;'5S:```````
M`0```U]X9FQU<VA?=V%I=````,`````````#\@```_(```/H`````61A=&$`
M``/J`````````_(```/R```#Z`````)U9&%T80```````^L````````#\@``
M`_(```/G`````V]P96YL:6)S+G$``````^@````!=&5X=````^D````E3E;_
MM$CG``Q+^0````!)^0```(IP`#`N``HM0/^T2FX`"F=0""X````+9S@O%$AN
M_[A.N0````!0CTAY````RDAN_[A.N0````!0CTJ59A1"ITAN_[A.N0````!0
MCRJ`2H!G&C`N``KB2%B-6(P]0``*8*IP`4S?,`!.7DYU+R[_M$ZY`````%B/
M<`!,WS``3EY.=0```^P````"`````0```#P````0`````0````(````*````
M`````^^!```"7W-T<F-P>0`````!````-($```)?<W1R8V%T``````$```!&
M@0```U]/<&5N3&EB<F%R>0````$```!8@0```U]C;&]S96QI8G,```````$`
M``"$`0```U]O<&5N;&EB<P`````````````````#\@```_(```/H`````61A
M=&$```/J````-6=R87!H:6-S`&EN='5I=&EO;@!E>'!A;G-I;VX`9&ES:V9O
M;G0`=')A;G-L871O<@!I8V]N`&UA=&AF9G``;6%T:'1R86YS`&UA=&AI965E
M9&]U8F)A<P!M871H:65E97-I;F=B87,`;&%Y97)S`&-L:7-T`'!O=&=O`'1I
M;65R`'@Q-0!X,38````````````)````$P```!T````F````,0```#8````^
M````2````%@```!H````;P```'4```![````@0```(4N;&EB<F%R>0`````#
M[````!`````!````Q@```,(```"^````N@```+8```"R````K@```*H```"F
M````H@```)X```":````E@```)(```".````B@````````/R```#\@```^@`
M```"=61A=&$```````/K````$````^\!```"7T=F>$)A<V4``````0``!%])
M;G1U:71I;VY"87-E```````$`0``!%]%>'!A;G-I;VY"87-E```````(`0``
M!%]$:7-K9F]N=$)A<V4````````,`0``!%]4<F%N<VQA=&]R0F%S90`````0
M`0```U])8V]N0F%S90```````!0!```#7TUA=&A"87-E````````&`$```1?
M36%T:%1R86YS0F%S90``````'`$```5?36%T:$EE965$;W5B0F%S0F%S90``
M`"`!```%7TUA=&A)965E4VEN9T)A<T)A<V4````D`0```U],87EE<G-"87-E
M`````"@!```#7T-L:7-T0F%S90``````+`$```-?4&]T9V]"87-E```````P
M`0```U]4:6UE<D)A<V4``````#0!```#7WAF:6QL97(Q-0``````.`$```-?
M>&9I;&QE<C$V```````\`````````_(```/R```#YP````-R86TZ>&=E=&,`
M``````/H`````71E>'0```/I````#$Y6__YP`2\`2&[__R\N``A.N0````!/
M[P`,2H!G"G``$"[__TY>3G5P_TY>3G4``````^^!```"7WAR96%D```````!
M````$@$```)?>&=E=&,````````````````#\@```_(```/H`````61A=&$`
M``/J`````````_(```/R```#Z`````)U9&%T80```````^L````````#\@``
M`_(```/G`````W)A;3IX=&5L;````````^@````!=&5X=````^D````$3E8`
M`"!N``@@*``<3EY.=0```^\!```"7WAT96QL`````````````````_(```/R
M```#Z`````%D871A```#Z@````````/R```#\@```^@````"=61A=&$`````
M``/K`````````_(```/R```#YP````1M;W5N=')E<75E<W0N<0`````#Z```
M``%T97AT```#Z0```!9.5O_\2.<`!$*G3KD`````6(\J0$JN``AF&"!\____
M_R)M`+BSR&<**T@`N"/)`````$JN``AG%B!\_____R)M`+BSR&8(*WD`````
M`+A,WR``3EY.=0`````#[`````(````"````2````"X````````#[X$```-?
M1FEN9%1A<VL````````!````#`$```1?;6]U;G1R97%U97-T````````````
M``````/R```#\@```^@````!9&%T80```^H````````#\@```_(```/H````
M`G5D871A```````#ZP````$```/R```#\@```^<````#<F%M.GAP=71C````
M```#Z`````%T97AT```#Z0````A.5O_^<`$O`$AN__\O+@`(3KD`````3^\`
M#$Y>3G4``````^^!```"7WAW<FET90`````!````$@$```)?>'!U=&,`````
M```````````#\@```_(```/H`````61A=&$```/J`````````_(```/R```#
MZ`````)U9&%T80```````^L````````#\@```_(```/G`````6EO+G$```/H
M`````71E>'0```/I````N4Y6__QP`"!N``@P*``<,7P``@`<(6X`#``H(6X`
M$``D+P@M0/_\3KD`````6(\@+O_\(&X`"#%``!P@*``@3EY.=4Y6__QP`"!N
M``@P*``<,7P``P`<(6X`#``H(6X`$``D+P@M0/_\3KD`````6(\@+O_\(&X`
M"#%``!P@*``@3EY.=4Y6_^R1R"\(+P@M2/_\+4C_^"U(__0M2/_P3KD`````
M4(\M0/_\2H!G``$\+SP``0`!+RX`'$ZY`````%"/+4#_]$J`9P`!($JN`!AG
M-'``+P`O`$ZY`````%"/+4#_^$J`9P`!`B\\``$``2\N`!Q.N0````!0CRU`
M__!*@&<``.9*K@`@9V1(>0`````O+@`(80`!E%"/2H!G#"!N__0@+@`@$4``
M3TAY````#B\N``AA``%T4(]*@&<,(&[_]"`N`"`10``U2'D````>+RX`"&$`
M`510CTJ`9Q`@;O_T(6X`(``H(6X`)``D(&[_]"%N__P`#B\N`!`O""\N``PO
M+@`(3KD`````3^\`$"U`_^Q*@&902JX`&&<F(&[_]")N__!P'Q+84<C__"!N
M__`A;O_X``XQ?``#`!PB;@`8(H@@;O_T,7P``@`<(FX`%"*(<``@;O_\$"@`
M#W(!X:$@`4Y>3G5*KO_\9PPO+O_\3KD`````6(]*KO_X9PPO+O_X3KD`````
M6(]*KO_T9Q`O+@`<+R[_]$ZY`````%"/2J[_\&<0+RX`'"\N__!.N0````!0
MCW``3EY.=4Y6``!*K@`(9S(O+@`(3KD`````6(\@;@`(2J@`#F<,+R@`#DZY
M`````%B/+RX`$"\N``A.N0````!0CTJN``QG)B!N``Q*J``.9PPO*``.3KD`
M````6(\O+@`0+RX`#$ZY`````%"/3EY.=4Y6``!(YP`,*FX`""AN``P0%1(4
ML`%F%H`!2@!F"G`!3-\P`$Y>3G52C5*,8.)P`$S?,`!.7DYU```#[`````,`
M```!```!3@```2X```$.`````````^^!```"7T1O24\````````"````:@``
M`"B!```#7T-R96%T95!O<G0``````@```-H```"@@0```U]!;&QO8TUE;0``
M``````(```#V````O($```-?3W!E;D1E=FEC90`````!```!BH$```-?1&5L
M971E4&]R=``````$```"D@```F8```((```!]H$```)?1G)E94UE;0````0`
M``*B```"=@```C0```(>@0```U]#;&]S941E=FEC90````$```)0`0```E]I
M;U]R96%D``````$```-?:6]?=W)I=&4```````!"`0```E]I;U]O<&5N````
MA`$```-?:6]?8VQO<V4```````)``0```E]S8VUP```````"K`````````/R
M```#\@```^@````!9&%T80```^H````,<V5R:6%L+F1E=FEC90!P87)A;&QE
M;"YD979I8V4`8V]N<V]L92YD979I8V4````````#\@```_(```/H`````G5D
M871A```````#ZP````````/R```#\@```^<````````#Z0````4@;P`$(F\`
M"!#99OP@+P`$3G4``````^\!```"7W-T<F-P>0```````````````_(```/G
M`````W)A;3IX9V5T<P```````^@````!=&5X=````^D````>3E;__$CG`PPJ
M;@`(*&X`#"XN`!!3AWP`O(=L2B`M``RPK0`09AHO#4ZY`````%B/2H!F#$(4
M<`!,WS#`3EY.=2!,T<8@+0`,4JT`#")M`"+3P!`1$(!2K0`<$!`,```*9P12
MAF"R($S1QD(0(`92@$S?,,!.7DYU```#[X$```)?>&9I;&)U9@````$````J
M`0```E]X9V5T<P````````````````/R```#\@```^@````!9&%T80```^H`
M```````#\@```_(```/H`````G5D871A```````#ZP````````/R```#\@``
M`^<````#<F%M.GAW<FET90`````#Z`````%T97AT```#Z0```"1.5O_\2.<#
M#"IN``@H;@`,+BX`$"`M`!20K0`,L(=M`B`'+``@;0`BT>T`#"\&+P@O#$ZY
M`````$_O``R>AMG&W:T`'"`&(BT`#-"!*T``#"(M`!"R@&P$*T``$!`M`"``
M```!&T``($J'9QHO#4ZY`````%B/+`!*AF:8<`!,WS#`3EY.=7`!3-\PP$Y>
M3G4```/O@0```E]B;6]V`````````0```#2!```"7WAF;'5S:``````!````
M<`$```)?>'=R:71E```````````````#\@```_(```/H`````61A=&$```/J
M`````````_(```/R```#Z`````)U9&%T80```````^L````````#\@```_(`
M``/G`````````^D````%(&\`!"`O``AG```(0AA3@&;Z3G4```/O`0```E]B
M>F5R;P````````````````/R```#YP````-R86TZ>&]P96X```````/H````
M`71E>'0```/I````2$Y6__1(YP,<*FX`""AN``Q\``RN`````0`0;`9P`2U`
M`!`O/``!``!P*B\`3KD`````4(\F0+?\`````&<``-80%`P``')F%BX\```#
M[1`L``$,```K9@8N/````^T0%`P``'=F."X\```#[A`L``$,```K9B@O/```
M`^TO#4ZY`````%"/+`!*AF<2<`$O`$*G+P9.N0````!/[P`,2H9F#B\'+PU.
MN0````!0CRP`2H9G2"=&``@@+@`0)T``%$*G+P!.N0````!0CR=``")*@&<<
M<``O`"\`+P9.N0````!/[P`,)T``'"=``!A@)"\&3KD`````6(].<7`J+P`O
M"TZY`````%"/<`!,WSC`3EY.=2`+3-\XP$Y>3G4``````^^!```#7T%L;&]C
M365M`````````@```,8````N@0```E]/<&5N`````````@```*@```"`@0``
M`E]3965K`````````@```-X```"6@0```E]#;&]S90```````0```/2!```"
M7T9R965-96T````!```!!`$```)?>&]P96X````````````````#\@```_(`
M``/H`````61A=&$```/J`````````_(```/R```#Z`````)U9&%T80``````
M`^L````````#\@```_(```/G`````W)A;3IX<'5T<P```````^@````!=&5X
M=````^D````43E8``"\N``Q.N0````!8CR\`+RX`#"\N``A.N0````!/[P`,
M2H!G(G`!+P!(>0`````O+@`(3KD`````3^\`#$J`9P9P`4Y>3G5P`$Y>3G4`
M``/L`````0````$````N`````````^^!```"7W-T<FQE;@`````!````"H$`
M``)?>'=R:71E``````(````X````'`$```)?>'!U=',````````````````#
M\@```_(```/H`````61A=&$```/J`````0H```````/R```#\@```^@````"
M=61A=&$```````/K`````````_(```/R```#YP````-R86TZ<W1R;F-A=```
M``/H`````71E>'0```/I````$$Y6__Q(YP$<*FX`""AN``PN+@`0)DU*%6<$
M4HU@^$H49Q`@!U.'2H!G"!J44HQ2C6#L0A52C2`+3-\X@$Y>3G4```/O`0``
M`E]S=')N8V%T``````````````/R```#\@```^@````!9&%T80```^H`````
M```#\@```_(```/H`````G5D871A```````#ZP````````/R```#\@```^<`
M```#<F%M.G-T<F-M<``````#Z`````%T97AT```#Z0```!5.5@``2.<`#"IN
M``@H;@`,2A5G+DH49RH0%1(4L`%D"G#_3-\P`$Y>3G40%1(4L`%C"G`!3-\P
M`$Y>3G52C5*,8,X0%1(4L`%FSG``3-\P`$Y>3G4```/O`0```E]S=')C;7``
M``````````````/R```#\@```^@````!9&%T80```^H````````#\@```_(`
?``/H`````G5D871A```````#ZP````````/R```#\NH`
`
end
!Funky!Stuff!
fi  # end of overwriting check
exit 0
#	End of shell archive