[Back to STRINGS SWAG index] [Back to Main SWAG index] [Original]

    (*
        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
    [encoded data, 5712 characters]
    ***** 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 *****

[Back to STRINGS SWAG index] [Back to Main SWAG index] [Original]