(*
    TURBO PASCAL LIBRARY 2.0
    STRINGS unit: Extended string-handling routines
*)

UNIT STRINGS;

{ THESE FILES ARE XX34 AT THE BOTTOM OF THE LISTING }

{$L SUCASE}
{$L SUTRIM}
{$L SUPAD}
{$L SUTRUNC}
{$L SUCNVRT}
{$L SUMISC}

{$V-}

INTERFACE

TYPE
    FormatConfigRec =   RECORD
                            Fill,               { Symbol for padding }
                            Currency,           { Floating currency sign }
                            Overflow,           { Overflow indicator }
                            FracSep:    CHAR;   { Int/frac seperator }
                        END;


CONST
    UCaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    LCaseLetters = 'abcdefghijklmnopqrstuvwxyz';
    Letters = UCaseLetters+LCaseLetters;
    DecDigits = '0123456789';
    HexDigits = '0123456789ABCDEF';
    OctDigits = '01234567';
    BinDigits = '01';

    { Format symbol record }
    FormatConfig: FormatConfigRec =
            (Fill: '*'; Currency: '$'; Overflow: '?'; FracSep: '-');



FUNCTION LoCase(ch: CHAR): CHAR;
FUNCTION UpperCase(s: STRING): STRING;
FUNCTION LowerCase(s: STRING): STRING;
FUNCTION DuplChar(ch: CHAR; count: BYTE): STRING;
FUNCTION DuplStr(s: STRING; count: BYTE): STRING;
FUNCTION TrimL(s: STRING): STRING;
FUNCTION TrimR(s: STRING): STRING;
FUNCTION PadL(s: STRING; width: BYTE): STRING;
FUNCTION PadR(s: STRING; width: BYTE): STRING;
FUNCTION TruncL(s: STRING; width: BYTE): STRING;
FUNCTION TruncR(s: STRING; width: BYTE): STRING;
FUNCTION JustL(s: STRING; width: BYTE): STRING;
FUNCTION JustR(s: STRING; width: BYTE): STRING;
FUNCTION JustC(s: STRING; width: BYTE): STRING;
FUNCTION Precede(s,target: STRING): STRING;
FUNCTION Follow(s,target: STRING): STRING;
FUNCTION Break(VAR s: STRING; d: STRING): STRING;
FUNCTION Span(VAR s: STRING; d: STRING): STRING;
FUNCTION Replace(s,srch,repl: STRING): STRING;
FUNCTION Remove(s,srch: STRING): STRING;
FUNCTION StripBit7(s: STRING): STRING;
FUNCTION FileSpecDefault(s,path,name,extn: STRING): STRING;
FUNCTION HexStr(n: WORD; count: BYTE): STRING;
FUNCTION OctStr(n: WORD; count: BYTE): STRING;
FUNCTION BinStr(n: WORD; count: BYTE): STRING;
FUNCTION Format(n: REAL; form: STRING): STRING;


IMPLEMENTATION

USES
    DOS;


FUNCTION LoCase(ch: CHAR): CHAR; EXTERNAL;
FUNCTION UpperCase(s: STRING): STRING; EXTERNAL;
FUNCTION LowerCase(s: STRING): STRING; EXTERNAL;
FUNCTION DuplChar(ch: CHAR; count: BYTE): STRING; EXTERNAL;


FUNCTION DuplStr(s: STRING; count: BYTE): STRING;

    VAR
        ds: STRING;
        i:  BYTE;

    BEGIN
        ds:='';
        FOR i:=1 TO count DO
            ds:=CONCAT(ds,s);
        DuplStr:=ds;
    END;


FUNCTION TrimL(s: STRING): STRING; EXTERNAL;
FUNCTION TrimR(s: STRING): STRING; EXTERNAL;
FUNCTION PadL(s: STRING; width: BYTE): STRING; EXTERNAL;
FUNCTION PadR(s: STRING; width: BYTE): STRING; EXTERNAL;
FUNCTION TruncL(s: STRING; width: BYTE): STRING; EXTERNAL;
FUNCTION TruncR(s: STRING; width: BYTE): STRING; EXTERNAL;


FUNCTION JustL(s: STRING; width: BYTE): STRING;

    BEGIN
        JustL:=PadR(TruncR(TrimL(TrimR(s)),width),width);
    END;


FUNCTION JustR(s: STRING; width: BYTE): STRING;

    BEGIN
        JustR:=PadL(TruncL(TrimL(TrimR(s)),width),width);
    END;


FUNCTION JustC(s: STRING; width: BYTE): STRING;

    BEGIN
        s:=TruncR(TrimL(TrimR(s)),width);
        IF LENGTH(s)>=width THEN
            JustC:=s
        ELSE
            JustC:=PadR(CONCAT(DuplChar(#32,(width-LENGTH(s)) DIV 2),s),width);
    END;


FUNCTION Precede(s,target: STRING): STRING;

    VAR
        i:  BYTE;

    BEGIN
        i:=POS(target,s);
        IF i=0 THEN             { Return entire string if target not found }
            Precede:=s
        ELSE
            Precede:=COPY(s,1,i-1);
    END;


FUNCTION Follow(s,target: STRING): STRING;

    VAR
        i:  BYTE;

    BEGIN
        i:=POS(target,s);
        IF i=0 THEN             { Return null string if target not found }
            Follow:=''
        ELSE
            Follow:=COPY(s,i+LENGTH(target),255);
    END;


FUNCTION Break(VAR s: STRING; d: STRING): STRING;

    VAR
        i,j:    BYTE;
        f:      BOOLEAN;

    BEGIN
        i:=0;                                   { Index to input string }
        f:=FALSE;                               { Set when delim. found }
        WHILE (i<LENGTH(s)) AND (NOT(f)) DO     { For each char. in input }
            BEGIN
                INC(i);
                j:=1;                           { Index to delim. string }
                WHILE (j<=LENGTH(d)) AND (NOT(f)) DO { Scan for each delim. }
                    IF s[i]=d[j] THEN
                        f:=TRUE
                    ELSE
                        INC(j);
            END;
        IF NOT(f) THEN
            INC(i);
        Break:=COPY(s,1,i-1);           { Return sub-string up to delimiter }
        s:=COPY(s,i,255);               { and remove from the input string }
    END;


FUNCTION Span(VAR s: STRING; d: STRING): STRING;

    VAR
        i,j:    BYTE;
        f:      BOOLEAN;

    BEGIN
        i:=0;                               { Index to input string }
        f:=FALSE;
        WHILE (i<LENGTH(s)) AND (NOT(f)) DO { For each char. in input }
            BEGIN
                INC(i);
                FOR j:=1 TO LENGTH(d) DO    { Check for specified chars. }
                    IF s[i]=d[j] THEN
                        f:=TRUE;
                f:=NOT(f);
            END;
        IF NOT(f) THEN
            INC(i);
        Span:=COPY(s,1,i-1);                { Return span of specified chrs }
        s:=COPY(s,i,255);                   { and remove from the input }
    END;



FUNCTION Replace(s,srch,repl: STRING): STRING;

    VAR
        i,j:    BYTE;
        f:      BOOLEAN;

    BEGIN
        IF LENGTH(srch)>LENGTH(repl) THEN       { Ignore search chrs. }
            srch[0]:=CHR(LENGTH(repl));         { without replacements }
        FOR i:=1 TO LENGTH(s) DO                { For each char. in input }
            BEGIN
                j:=1;
                f:=FALSE;                       { Scan all search characters }
                WHILE (j<=LENGTH(srch)) AND (NOT(f)) DO
                    IF s[i]=srch[j] THEN
                        BEGIN
                            s[i]:=repl[j];      { Replace if found }
                            f:=TRUE;
                        END
                    ELSE
                        INC(j);
            END;
        Replace:=s;
    END;


FUNCTION Remove(s,srch: STRING): STRING;

    VAR
        i,j:    BYTE;

    BEGIN
        FOR i:=1 TO LENGTH(srch) DO     { For each search character }
            REPEAT
                j:=POS(srch[i],s);      { Repeat search in input string & }
                IF j<>0 THEN            { delete if found until no more }
                    DELETE(s,j,1);
            UNTIL j=0;
        Remove:=s;
    END;


FUNCTION StripBit7(s: STRING): STRING; EXTERNAL;


FUNCTION FileSpecDefault(s,path,name,extn: STRING): STRING;

    VAR
        d:  DirStr;
        n:  NameStr;
        e:  ExtStr;

    BEGIN
        FSplit(s,d,n,e);        { Split file spec. into path, name, & ext. }
        IF LENGTH(d)=0 THEN     { For each field, add default if none }
            d:=path;
        IF LENGTH(n)=0 THEN
            n:=name;
        IF LENGTH(e)=0 THEN
            e:=extn;
        FileSpecDefault:=CONCAT(d,n,e);
    END;


FUNCTION HexStr(n: WORD; count: BYTE): STRING; EXTERNAL;
FUNCTION OctStr(n: WORD; count: BYTE): STRING; EXTERNAL;
FUNCTION BinStr(n: WORD; count: BYTE): STRING; EXTERNAL;


FUNCTION Format(n: REAL; form: STRING): STRING;

    VAR
        s1,s2:                  STRING;
        width,dp,sign,i,j:      BYTE;
        pad,currency:           CHAR;
        blank,zero,left,paren,
        comma,adjust,reduce:    BOOLEAN;
        x:                      INTEGER;


    { Reduce fraction to lowest possible denominator }

    PROCEDURE ReduceFraction(VAR num,denom: BYTE);

        VAR
            i:  BYTE;

        BEGIN
            FOR i:=denom DOWNTO 2 DO
                IF ((num MOD i)=0) AND ((denom MOD i)=0) THEN
                    BEGIN
                        num:=num DIV i;
                        denom:=denom DIV i;
                    END;
        END;  { ReduceFraction }


    BEGIN  { Format }
        form:=UpperCase(form);
        s1:=Break(form,CONCAT(DecDigits,':'));      { Get leading options }
        IF POS('A',s1)<>0 THEN                      { Absolute value, no sign }
            n:=ABS(n);
        blank:=POS('B',s1)<>0;                      { Blank if zero }
        zero:=POS('Z',s1)<>0;                       { Zero-fill/zero-show }
        left:=POS('L',s1)<>0;                       { Left justify }
        comma:=(POS(',',s1)<>0) OR (POS('C',s1)<>0);    { Commas }
        reduce:=POS('R',s1)=0;                      { No reduction }
        paren:=POS('P',s1)<>0;                      { Negative in parenth. }
        IF POS('+',s1)<>0 THEN                      { Check leading + }
            sign:=1
        ELSE
            sign:=0;
        IF POS('*',s1)<>0 THEN                      { Set fill character }
            pad:='*'
        ELSE
            IF POS('F',s1)<>0 THEN
                pad:=FormatConfig.Fill
            ELSE
                pad:=' ';
        IF POS('$',s1)<>0 THEN                      { Set currency symbol }
            currency:=FormatConfig.Currency
        ELSE
            currency:=#0;
        s1:=Break(form,CONCAT('+- ',#9));           { Get width:decimals }
        IF POS('-',form)<>0 THEN                    { Check trailing +/- sign }
            sign:=3;
        IF POS('+',form)<>0 THEN                    
            sign:=2;

        s2:=Follow(s1,':');             { s2 is decimals }
        s1:=Precede(s1,':');            { s1 is width }
        VAL(s1,width,x);
        IF x<>0 THEN                    { Default width 12 }
            width:=12;
        IF COPY(s2,1,1)='/' THEN        { Use vulgar fractions }
            BEGIN
                n:=ABS(n);                          { Force absolute value }
                sign:=0;                            { Disable sign display }
                DELETE(s2,1,1);
                VAL(s2,i,x);
                IF (x<>0) OR (i<2) OR (i>99) THEN   { Default resolution 1/2 }
                    i:=2;
                j:=ROUND(FRAC(n)/(1.0/i));          { Calculate fraction }
                adjust:=(j=i);                      { Allow for rounding }
                IF adjust THEN
                    j:=0;
                IF reduce THEN                      { Reduce fraction }
                    ReduceFraction(j,i);
                STR(j,s1);
                STR(i,s2);
                IF j=0 THEN                         { Format fraction }
                    s2:=DuplChar(pad,6)
                ELSE
                    BEGIN
                        s2:=CONCAT(s1,'/',s2);
                        IF (INT(n)=0) AND NOT(zero) THEN
                            s2:=CONCAT(pad,s2)
                        ELSE
                            s2:=CONCAT(FormatConfig.FracSep,s2);
                        s2:=CONCAT(s2,DuplChar(pad,6-LENGTH(s2)));
                    END;
                IF (INT(n)=0) AND NOT(zero) AND (j<>0) THEN
                    s1:=s2
                ELSE
                    BEGIN                           { Format integral part }
                        IF adjust THEN
                            STR(INT(n)+1:0:0,s1)
                        ELSE
                            STR(INT(n):0:0,s1);
                        s1:=CONCAT(s1,s2);
                    END;
                zero:=FALSE;                        { Disable zero-fill }
            END
        ELSE
            BEGIN                       { Use decimal fractions }
                VAL(s2,dp,x);               { Get number of decimal places }
                IF x<>0 THEN                { Default to zero decimals }
                    dp:=0;
                STR(ABS(n):0:dp,s1);
            END;

        IF comma THEN                   { Insert commas if necessary }
            BEGIN
                s2:=Span(s1,DecDigits);
                i:=(LENGTH(s2)-1) DIV 3;    { i is no. of commas to insert }
                FOR j:=1 TO i DO
                    INSERT(',',s2,LENGTH(s2)-(j-1)-(j*3-1));
                s1:=CONCAT(s2,s1);
            END;
        IF currency<>#0 THEN            { Add floating currency symbol }
            s1:=CONCAT(currency,s1);
        IF paren THEN                   { Add signs as required }
            BEGIN
                IF n<0 THEN
                    s1:=CONCAT('(',s1,')')
                ELSE
                    IF NOT(left) THEN
                        s1:=CONCAT(s1,' ');
            END
        ELSE
            CASE sign OF
                0:  IF n<0 THEN                 { Leading - }
                        s1:=CONCAT('-',s1);
                1:  IF n<0 THEN                 { Leading + }
                        s1:=CONCAT('-', s1)
                    ELSE
                        s1:=CONCAT('+',s1);
                2:  IF n<0 THEN                 { Trailing + }
                        s1:=CONCAT(s1,'-')
                    ELSE
                        s1:=CONCAT(s1,'+');
                3:  IF n<0 THEN                 { Trailing - }
                        s1:=CONCAT(s1,'-')
                    ELSE
                        IF NOT(left) THEN
                            s1:=CONCAT(s1,' ');
            END;
        WITH FormatConfig DO
            IF LENGTH(s1)>width THEN            { Check for field overflow }
                Format:=DuplChar(Overflow,width)
            ELSE
                IF blank AND
                (LENGTH(Remove(s1,CONCAT('0. ()+-*',Fill,Currency)))=0) THEN
                    Format:=DuplChar(#32,width) { Blank if rounded=zero }
                ELSE
                    IF zero THEN                { Pad field to width }
                        BEGIN
                            s2:=Break(s1,DecDigits);
                            Format:=CONCAT(s2,DuplChar('0',
                                        width-(LENGTH(s2)+LENGTH(s1))),s1);
                        END
                    ELSE
                        IF left THEN
                            Format:=CONCAT(s1,DuplChar(pad,width-LENGTH(s1)))
                        ELSE
                            Format:=CONCAT(DuplChar(pad,width-LENGTH(s1)),s1);
    END;  { Format }


END.

(*

The following contains the ASM and OBJ files needed for this unit.

Do the following :

1.  Cut the code out to another file.  Call it STRASM.XX
2.  Execute -> XX3401 D STRASM.XX.  The file STRASM.ZIP will be created.
3.  Unzip to have OBJ and ASM files needed.

------------------    CUT HERE --------------------------

*XX3401-007122-160793--68--85-58879------STRASM.ZIP--1-OF--2
I2g1--E++U+6+BRwjVcn7M7VxU6++1wC+++8++++IpJ1EJB39Y3HHSpLHLCPA-0xSwPz
MGyRh3CGgRpC1gsZTAKa6kC1QCAaYkBpZ6G46+cWbTHL3m360EXWBeRqcggmW5qvSfjv
N-z-oyKjDQo-JwKuWU-NaeRuLq-qA-aDqZzeEINUGyBvYaMVXS4CLiMF4Mz46qVXKXsm
0viq9Fykvpbq+gxvzRjSfffUnb-se2kzn9fvPnH9tbMusv3pln0PixVQf2nPVpD5Avey
8gPfJT4xXiTQgTg-QUcSg0GdhMMgLSlXIs4puteSS2HCeLXYuLFdCpbPiawtBW-OAj-q
SpBkgJGxRw76W0stMf0x0R7UmoU8X272Tt-oTwgFmDQwj+wW2XASHqHImBFnx16iVysQ
kr39eqp+ictUEFWYVCJd1A5ZNIem18tGSUQN0vOrzM1udbxD5EnqytFV10fekiWf0UMd
SyeS1AOaFOvTwcl-S+Il9H0174F-pALud+ZvT6makt5CxWHSud0rso5hDNggNLbKVQqH
d33Is2IRXnXcz2b5sOJUhcwxXqGAdeFJ9Zbj0WFBIWDDx9ghNBe48thfDdbDBDaO5oro
SHOjNjxRzR1TuVZ9kzWOIm8s2NGAFsxXhZBnpyRoirgftvBcT3T-fdFBH5VVF7z1JFfQ
2IVc41CGxYQm72e-10m2m36A9Y9UyVuQOyvvksgeYghV0xwthjW7knX7OkMYQ8O+Axdk
owZ32wv2QuC2cnYPkhCFoQyCXdFnP3roH4eNu5tJecX2pym4nulgx1TJACV9FJx8sq2B
yVQTZSGVCgBy3Sff+tDQ3dzonJYpYlzYIDUqH00WB0bJ6MyWFqvO6sQQstaoOg2u286s
L9eab+Gv0JRH2+OoOnMQvCSkRYawJRicjGT4mL7+ioG4fI5Zc2oWgSxUHLOtWVh-u0Sj
q3lmLJHnAmVspq54G7cBL50iJCh8yv4f8mxEDAE7SMbWBKjChTXoJT3S3SzTJvkRTucp
NSHj3SzgXlJjxpxfzsTWhLKZJfnqzuTWDNMdMT4Sjzs3I2g1--E++U+6+BNwjVfCAxyp
EUA++0cC+++8++++IpJIIYZB9Y3HHSpLHKzPC-0x-z-za2i-LOkGl5MGcD6Z2eZBJB0G
EAehqw+5BOMP6PPYZSGUuOwjeExLAGYtKTGoK3pcYC9AawTVSz62LXvVXBcy--N13U5W
qhGWbq3oRXssIRvAsUpwLIT7MkuPR9ZPww57s+ECrr71scVltfYVg70urUonhLgDRkPK
XRk6JpT4Q1lGpxzNfWT5sIXaFHtqqejAiNYuLUWTT6fJjFNXguZs5n3HPZFT69ucbqZ+
nKnW6Z2KROT28+Qeoujoz1rnICXuLZYfUHxmgmvznyN5-uJf5WrXt3h1nmd9Bt+LaNWG
OQf2PI1IFqIuWyfEgZgtqc4uBjIzEfJag+1INk8A3v1PWhnFzOC+2KosPBAs8LXKbEZf
C0CMJITW4ZUS-kEVVHgvyCheIKQ8N3WlpqEi30b2mLNLv4hKkXZJC5kMPbWyO6Rna6b9
QCaiu6i50CtVNqu661dqF5VvLV4Ghv8gST8hS60jnkLLRFJaBbEz2vUFb7TZbpNkarVl
+aXS1FAFkm9ewhmbpT8hUKvJNRR1BNBRQBVXj8ofCyqhf+40WM46BVF8hwyEfif1zJIK
pi1yUCNTt5VxHGtuUAIfG5PfRIBJ4LZk6XMBnHSHbj1j-RkzF3ZofqpkB8oiWIKAwIVT
s+CLxmHBedifeOcK8+3kp7jUjKOjtnFvlqK7crO7q8YDYbGJu8seJ+MgyTrNmqPJxOYT
pBa45NGZgiSDYTOVfcbRyXEgHvD2DatXNu3zt5U2xWEh4jltYKNQBYtJUteo6EBd4cgu
UKnJncEH09AcmJQwUsljcXVNWZzdOewRgUFHozMCAyzgyQ6sD6+7g-9iOwEVe1XLGaWn
dVBmucHZS84OUyDVE4T8oZdTsJfo1OtJN34wvfQh0jzPpiyn9FPWLXysMys0SUnaW9AQ
gMuKEczVe26TcQP0i42OnPL-diYHVsfZRNGzo7nzihlTe57zL7tPQeyex820hoIAikj3
k-gFyw4nh3z039qzv7TAjamjYQna+sNpTg1g9ySyPQsUszzgsckjilgFRnPWzbP842yF
E3T+BgrX6YuHTqArtJTFzanmYet9wzSv+hKski3T7X5DR4sVtiLoHp-9+kEI++6+0+1J
T9sOCDOSb+E1++-g1E++0E+++3BJI2329Y3HHSpLLKyPA-FxfxHzQ3waPFe9aYme7f77
-NiZP+sUaumdeXnEs9Gc8KFweBizbloUHMAVKPjhOHn2kiOSSyu5vp44wDHl7xFokHAM
AUUEquE4jMF-vyHsODR99kUVmxAcjc5v70mKzDXcy+VqsKmTK48RC9MDn8SqAq8umbHL
o1B4oUtCHvLyyo5nz7JdCr9h1uFPt47fytFNcv5Zy51VIhmoBFWPXALrWCbGgDY-QILo
H23eMV6PGL8MOD8LGiTBp5mSCAWrLIQ4Gi-pdZSV1y2V0jBP5Ql9rrdHvrOaxW58Pq57
Up0yL0y1y0u1D63glSTF6i7VWGV7G37DE8W9paEAece2bQjJx7dbMzQPZ4QOwu1t165l
56eJc-XAvq0F-jQQJYYItnlhxsEJyGGMZSKmBGl9-NtDsQforbuMJNsw0GhgRKP9g8Bs
JSFJOVFkJUa5Ry5uUxYqbAJoj6N9Wfk9fos2aacGtLHKGAF6709ZrkiStLId-2RVo+GP
ifE2CxTESITGdtfUdYfuJwtLA2xKDm3NpAm1A2ltZXLV2A4ehgPAP4snrqIah1x1wBAU
nVMwVGKDPoG6axGpls47Nd1qC9M9KO2eUVVvJH+0erbwlGnjzBYNuOhtgvh6i3f62YYb
5nyJPhjwpRkhdZyNota4G+AkHp7Sko4EpLIEPnp3MWTa6rwZEFEgtnq6YtuguSDh3aJh
NqQEPL0Wu0-eSNqZfBZLPe7shzpZ5bJJylABYnoBrHcao5FnPxzh8PQAEDXg041HVqIR
CxfEQwjKeEOA+cjmP7qC6+t3ETAWXRhFJ3CGKjtuDKpCLgj-bYcAdOPh3knu-kEXHsBc
SMVWIDWj45x1AMVqlSnNQmuBZ7HhARKa7th-CxLER9xUR2wyqo4JoXpPaFsbcGHxSw7o
qAozuC9zGwrSoWTw6bq82y+zwXGcfij9Z8aAu6YqRIcHJYiHIxlTWsHjuh8yRbmyCZqY
IQurbCpFdwAbTAdj6Z5fB5j7U8Se+PzvhoDgAxLU3zhmylREGkA23++0++U+ormy4jzr
Jb1n+U++GEk+++g+++-HJJFGJIt19Y3HHSpKoKfPA-Fx1yETvghUMqtNAUX14Omqv0Ii
WaoYNohLwa+GdHJfvAmK4RjLHsdgG0AtvI9rBfw6R8JnnvauCj6M5bz7b9UFl+t31UMQ
iAEVBn0wTBTjOGj9CZyZb253mmmzUqqlfVxMjxTjkT586A4y4CRVY+-BG--CeBqtzrVr
v2nYNVWBfA5vcFtztEOV5+R1aFh3bbwMdTtYtcQ7T6q6dyxp87rDl5d2PPZFLs+XIERe
61JrQM02B16D2PPq+t5txHdx3e2YW26Z4ADfmau8A6OTqNfTqy1S7DuPRjPdGaz8MUgD
PAC-3p1hq0fPN4mhk0E1FSe+96bEbcZ1H2fcJ6tifARaoFREAMj4c5xXc6l1jFD2ohJr
kGjRAhUJKQtNqNr7AxEHSpERJq1Rij5P1oghImlVlJuP-Z7qZixerVH2+CQfC2z-1MN9
AtlDPKwDJxHw33tP04Sllljdx0OW20LvIPC8hoQVC681RP-3F-HMp58arPYEhatdg1EI
LSPOuvxc4i8-tLQe5pdotoBH0lbm-G3eGez521NQ4XFHjS-U0lbYLPhej9f0+n+qnLKx
rI4q+OvuCWjmTSamYepDZVshX51--j80Kv+eRfzO8t7KY6YWJENu1LguXIUWGEvvDIbJ
DXGBiR8+3dNXnVYKZp-gM5KTZia8gv8GHRHcALWMsrZhSrS6IDqcSbhEQM3Q5VF3obl2
A6ac0xrT40UjGhOqhSeD2urq57rJdR8MthL4R9qjoS7PQyvjxGXlMtaiYzIMY1kyzGd8
i2DdQOHCnyEWPQnYNQFDxiB6xoQzx49HimJTbiRsCbYdHmyniziHdYvUjuaza8YPnEp5
rVArusHvCcjnrTtjLtMnb9spPcEh-lipYQRtDec1IE6zbKDpfHTL3MB1A2WfYmxT-vwX
DnjqvFP+dzOh3mkhVAymlTN3x68H9XQoGov8R+SzKJZQB37JapHbS49GiCqV4kvzVFgG
rEqDzuH3D1Ktd7WLorw+I2g1--E++U+6+B7wjVfA7sv1RkA++3QG+++9++++IpJ1HZNG
J0t-IorhK3pjqnMITEyEzr-T0amMKjUXG+fZdF8ZK-dYGF1ZnJqF-wKaMu2C4J-IajHL
ZlGJn7Pcf5KlPYCa3xcGRLXisPrbGXe5rGCTNKs0eMCF2o2IidaHjMTFaw5lILRaLBxQ
2TtOgBSJs0KxVUKXRsFL7OBkktPpVVkT5Fx-3nzA6pyCgnXA+SRN42ykzJJMLOHIaGUU
C1qpViBFzzcfBsnJC-kd5WXlzCqfq7xAzHW5rtDAuxzfM1mPmjY6qyf4zcEcYTdU+uaN
4sI66D1bAXUfEPYO7-AtaCFEEOXnTLYjNX58kmG4UBlXkS2bOXRYnuIqBFIqiCxnzqSv
pP-zToN2nGagmToPsCGKYsdEIEWZ83g-VN70evLwqo10MZrkMW4YvceE1a49OdOUVdWH
aS94UFfRh5xhajk4yde3IyUTts07UDdKwWYK5q53Wlg0humYYgZyB1GrDfXd9uSLzGbn
FBB4UMI0ss6HiO0CKQe+tjhLwTEePmyB27wMLs7UPPMqM7s-9D8l-UgPgC5UgUiKeaX-
lvML8XlKWxhOhDinbtmQzw299moIxEEJX7BR4BUESWrKTPFToTkDBPtv3soBZS-tXxnF
r8WZteu7Psde8sruO1XrbgaDm-eQ-APwK7Qf+LT3dWOkMbn95MuD7CqVPI-ntdNd9tlM
lyD6lGuAWoq9uaAH0mbid6OIk98w9cLwhLbcsvKddj14+mASOdB1EXcMVS3nye-dycHa
aB5KFBK6384dP+T2ahRkMRVKJsxGbx5yPJImb+KBWWBvNuAGvA9ysn534V7ObmR1AFEY
0WPB1gwhIv5V65gghasevmE+eoKvJZhkNDbBOoJ7YfOm1Aq-HFUg4J-mjtD7eXeq-Icp
XB5kAXxjldCyWTelZlvM-t83y6syk-OWq-nK05EHyvwFj8-4ADf54w5sFnO0grxR6zVO
zxJZzI6AS5G++LTBungAq0rdLljkyJs5jWddkFyA3ZlLydqbvvrunS43SixzlWtDziOy
wKFZSvp34wdbkhYDQSuipqsNm7uWpUNmJHPqhmUsTqUAL7-848GBoRCnelYiLA5EIXHd
BN4mzCadX-cy3MEhbVARzeHPyBunJATaqnANcU8E9AgJI96UJJJkEkTlz-qKCsyPryGO
JsecGgg1z97fC6xyqTpy6gxXYsz8wyfo3p-9+kEI++6+0+1MT9sOuigk5cM0+++a0E++
0U+++3BJHIZHEmt-IorBJh3ian+ITMyITvUjYneBHIoq7FBt8FWOA1a+A8ndeXtEuUOo
***** END OF XX-BLOCK *****


*XX3401-007122-160793--68--85-04457------STRASM.ZIP--2-OF--2
106kojPrgu328HN7JKbGz56Zv5hwvj2xBpb+mlJ4USa-Pl-YMA0C4FX-9IkzLMt5zNDf
f2fcPVTbh8Uf86iONHahs3TlKCzcS1ESEFzO0P5BMyEu6N+kQBkZoQz-x23wMmYkM1PH
7dybwjsvor33b2k3-SFNxj2igNRfqkrVlUggCRQU73fnwsXc6Z2yU1qi0Z4EWYng6++f
wX3O4M5KZCSPHXUL94HhfWALVMvbUZLjRmWBGvV6IVp2vU8GcguN1iNhO9zLbsKG6IFa
ZgGAEg9nssHFIhnIIHVE0nnIr4U28htY7O9dmrhfvnioSlflEJs967F-jMS8lQZDS0fX
LlHqFNMrF0HZPB8mRfEvozwkiPnjczYW3KmWKkuk+ceOvKj4kQggrkunAnMBrilSMfTY
v-cZ6Qj-k162kccK6835H-VSj4dKZ-HWeaCsczaKdT1kVx3VaUVf-ZP0VKKQJoyoTCP8
8oQP4KTXhEy8JVdOmRjToCO5W3RLS57Keuw1KbJRB8FLMDgbtSaYCKd5kIQzvXTDVu3y
0ymkWJzY5fNRmpQB3129njW9g19PalaPkoLJSSa2eR0ClWKYqHPxK7GDL6i5X25l-1FC
odQ8RMot5Vqgzbwtffj7IgkfP9Ji7AuESpcrKYEbXFinz7ENztKt2RPiW5Cj226oP7jR
yMwzmFiActk-zDcnAy-UqdDaDr9ZJDM0xeknhsUWQzeP5Hh8ygZmfHNWPLuxIe4cKjch
Qyyan-VxlSBVfnKte5SUfU8qWh82H8dVcKfUJkuGjXKvER9zKw0z2xK+sRzPyT6LI2g1
--E++U+6++ZxjVeTUjEtok++++U-+++8++++IpJ1EJB39Yx0GajUMS+81bJq15PJQknq
bRuVkA1+237OZ7Gjs3VQb7ePZ7BOd8+EZZdIb7aTdq0cNq1MoG52sD1mSgoy8GFxdVrA
E24TOIkA1-bHq-VMbDpRL3pbg1AsF12kAH6SbW1+kA16uSATvVc2oa58k3+nUFQclCPX
1y61fJk8IF6O2+-F+iHBuq-VQ3X2C53-5+AX+oBoN6GBMl4PHJEt2sx0MD1doCsrQYT9
q6vIQTrdsX3uiyElrlePF8-wJHaHmjpJXnv7lttWMQ0a04s6H33h3x1J7E-EGkA23++0
++U+15qy4XV5qhLL++++yE++++c+++-HJJFGGIoiHo78Oy-Vs+cC1EbmxBJn1DMhvp-U
M4+68Gp8mZRk90tCnIr8GGpGI+V99GfCnAxHABEnACnc247kS5ahNdwIYXul1aOUcAwo
7UO4X4Zg10nCzWuifXDM4FmG4NUM4LRBs43UM4E38TM-4bwBkEomNa0Mqw50s906QS80
R+N4-cPEvXRmFwjMXhFlzSayjuPfVB3Pxuu9XoLKq0WIgBVkZf9xCzLcwqjKJTxCTZuW
pW2i5ri8-Ib9rmsScvSDSNYzkdGnDzeepg5vaUB6i15zz9k2fDt03x0N7E-EGkA23++0
++U+1rqy4ifHluP7++++vE++++Y+++-HJJ--F0tDEYdfs4PU1+sBQ5HFQknqTR0VkA1+
237OZ7Gjs3VQb7ePZ7BOd8+EZZdIb7aTdq0cNq1MoG56sD1mOgoy8MGqVUtac7XDB0M4
VcldP+kgnjsifesnq-YQcVaM4-YDHS-aM4-Y+Ofp+Fdi1yQ3uH2kQ5SkA1UgMdms67u-
YM2VhDiBrB2mXWBpDBpyP2NjiyzzKPCeus9JWH7ChEtyfFAP31ujuXdZxDPn2jbMIql6
efhsU6cjCU9JTps0paZp0e9Z32U9KD579e1XGU-EGkA23++0++U+2bqy4ibgE-T8++++
vE++++g+++-HJJFGJIt19Yx0GajUNS+C1Uo70jJnpbAAxZLhI4-UM+Ud9If8Jr+g9YvB
HQd79J7E02gh8gvAnpAkp1AkvCUENb-sSPZablGmliARn2-FbqZA1+kNoxUMK7nxLJlR
Nv+nC+EnA12mbdf+mw1+m+NKvECoc+K75uH9k-1MkQ9Ug6Vlsc7k-YM4Vh1iBr75mnWC
pD3oiv2NDSbWALffxgTeM-39xw5L9Bcba1yiuXvlaCbn2jbMIql6WjygALfGvQRaxBPe
F-3Hpkap1Ztri8eC9e11GU-EGkA23++0++U+3Lqy4i0NFEo5+E++9k2+++g+++-HJIBC
JZ7I9Yx0GaqDAIX1M--4jnw7GR24-rLdx+z3AGGCsd+O+kcpVGMB1fcI+Ude6R3BWcjo
pmmuZ6vWq2Zk3l3-QJCbfbKmuW-C1cdLeh1-tS+Rvr5QbctFjy7sMHYk0jtGLb++kItQ
fT30YYGPpMoctXmAsaGxhgIhkvG246Txz9-vYFgCPsFAqq7H+hOO8VGbBCyu9ErqDWH4
KYQukBGtFQwDmWi+AS+3RtaM1hM5L560MUgc0ULq8HgyCE+18iZfuebHPqaMiOuDH+bx
8GRzTdofuJJy94jCngGGcfIPbQRScxBxKPpHzUYayc3AUNMpzxHrMTLLauHYn0HtjdR6
rtRh4fTRXvuMCOHLhbw+I2g1--E++U+6+-ZxjVfyc8wEm++++BE++++8++++IpJBGJB1
9Yx0GajUMS+81jLp15PKQknqPSxEM4-U00YhGgdLQ0kiHgpBmYYhIZ+6GmoengnDIn1I
An1gu--WQ5VtcqOT376yZEtac81DB0M4VcldP+kgnjsifesnq-YQn-aM4-aTHF-UM41Y
1+s7wUlkwUklZq7Ua18-5mX2sF6OsCDgsFU2h7GpUsL-MF5Xl+LK16kA185RPsvIQLKv
gTpNpLL0uCpXpasrXgyfMYylU4HYXdOl+KKvS6nSzZbma4qBGjqeFvzYEN65is+i8+2+
I2g-+VE+3++0++U+prmy4XAZUa5q+U++Dks+++c++++++++++E+U+++++++++3BJEo3H
FGt-IopEGk203++I++6+0+1KT9sOnXDThI61+++e1U++0U+++++++++-+0+++++S+k++
IpJIIYZB9Y3HHJ-9+E6I+-E++U+6+BJwjVcsxduQ-+A++4kB+++7++++++++++2+6+++
+6U4++-HJJ--F0t-IopEGk203++I++6+0+1HT9sOzzRKQDA0++-71+++0k+++++++++-
+0++++0n0E++IpJIIZJCEmt-IopEGk203++I++6+0+1GT9sOn0SCkrQ1++-L2U++0k++
+++++++-+0++++1D1+++IpJ1HZNGJ0t-IopEGk203++I++6+0+1MT9sOuigk5cM0+++a
0E++0U+++++++++-+0++++-j2+++IpJBGJB19Y3HHJ-9+E6I+-E++U+6++ZxjVeTUjEt
ok++++U-+++8++++++++++2+6++++-oH++-HJIB-IoIiHo78I2g-+VE+3++0++U+15qy
4XV5qhLL++++yE++++c++++++++++E+U++++4-E++3BJJ377HGtDEYdEGk203++I++6+
0++DTPsOuhD5dgY+++1h++++0E+++++++++-+0+++++L3E++IpJEEIEiHo78I2g-+VE+
3++0++U+2bqy4ibgE-T8++++vE++++g++++++++++E+U++++-lM++3BJJ37JHYAiHo78
I2g-+VE+3++0++U+3Lqy4i0NFEo5+E++9k2+++g++++++++++E+U++++yVM++3BJEotK
IZEiHo78I2g-+VE+3++0++U+4Lqy4juUfl16++++p+++++c++++++++++E+U++++8VU+
+3BJHIZHEmtDEYdEGkI4++++++k+1+0W+U++4VY+++++
***** END OF XX-BLOCK *****