, Pascal, bijdragen lzh uitvoering: Douglas Weber, eenheden, liuzhou;   {% +, b, D, E, F, I +, L, n, O, R, s, V) (* * * * * * * * * * * * * * lzhuf,,  . C 1   * op basis van de Engelse versie, Japan versie 29-nov-1988,   * door sommige nieuw code okumura,   * * * * * * * - huffman gecodeerd haruyasu vormen,   * bewerken en de vertaling in het Engels van de noodzakelijke vertaling van   kenji, * * * * * * * C In de turbo Pascal Douglas Weber 2 /18 /91,   * bijwerking en Bug TP versie 4 /29 /91 (het spijt me..),   * * * * * * *) { ,         deze eenheid waardoor gebruikers gegevens gebruikt in combinatie met commpress,       Nieuw - en aangepaste huffman gecodeerd of, omgekeerd, uitpakken,       gegevens eerder door deze eenheid samengeperst,           veel opties, gegevens worden gecomprimeerd,       decompressie uit /naar,         in feite het verzoek door de "je lzhpack " procedures; 2 programma,     parameters vormen en' getproctype en' en' putproctype en' (zie hieronder), op elke manier zou worden Als een aanvaarding van    ,' de drie parameters en gedrag; blockread en' /' blockwrite en',     procedure.Je' getproctype en' de procedures moeten de gegevens terug,     worden geperst, en je' putproctype en' de procedures moeten doen,     - gegevens (bijvoorbeeld, zet het in een dossier).Als je het moet weten, maar als je wil,     bij deze gegevens in   bytes),   - gegevens (de oorspronkelijke, door de omvang van de niet - #) is terug en 39; bytes_written en',     getbytesproc = programma (VAR Dta; nbytes: woorden var bytes_got;: Het woord);  ,   Dta is een herinnering plaatsen, terug     informatie moet beginnen.Is dat nbytes bytes.Het werkelijke aantal bytes,     terug moet door de bytes_got (als er niet meer gegevens dan 0,     wordt terugbetaald),     putbytesproc = programma (VAR); nbytes: woorden, var bytes_got: het woord);     boven, naast de eis van de programma 's is de dumping uit de gegevens,     met gegevens, wat nou,         " lzhunpack " in feite is het tegenovergestelde van hetzelfde ding.Het programma van eisen,     parameters en de aard van de' putproctype en' /' getproctype en', waarin de     als ouder.En' getproctype en' moet het opvragen van gegevens - methode,     " lzhpack "(meer) aan de algemene eisen     uitpakken, en' putproctype en' moeten aanvaarden dat bij de gegevens en iets doen,     het.Je moet ook bij de gegevens van de omvang van de in de oorspronkelijke door de    , doen we dat niet, dan zou een negatieve resultaten,           niet' procedures voor de parameters niet vergeten en' getproctype en' /' putproctype en',     procedures moeten in', de opstelling van de nationale #; f + 39; om een ramp te voorkomen.,} {opmerking: alle grote structuur van de gegevens bij de verdeling van deze routine,     nodig van de reactor, en laat de voltooiing.Dus wanneer het niet in gebruik is,     geheugen het vereiste minimum.Echter, deze eenheden worden gebruikt 34K,    ... Ruimte, en bij het gebruik van 400 bytes, Stack.}，接口类型，  putbytesproc =程序（VAR DTA；nbytes：单词；VAR bytes_put：字）；，  getbytesproc =程序（VAR DTA；nbytes：单词；VAR bytes_got：字）；，程序lzhpack（VAR bytes_written：LongInt；，                      其中：getbytesproc；，                      putbytes：putbytesproc）；，程序lzhunpack（文字大小：LongInt；，                    其中：getbytesproc；，                    putbytes：putbytesproc）；，实施，const，  exit_ok = 0；，  exit_failed = 1；}，{  LZSS算法参数，  n = 4096；} {字符串缓冲区的大小，  F = 60；{大小of look-ahead buffer },   THRESHOLD = 2;,   NUL = N; { end of tree's node },   { Huffman coding parameters },   N_Char = (256 - THRESHOLD + F);,   { Character code (:= 0..N_Char-1) },   T = (N_Char * 2 - 1); { Size of table },   R = (T - 1); { root position },   { update when cumulative frequency },   { reaches to this value },   MAX_FREQ = $8000;, {,  * Tables For encoding/decoding upper 6 bits of,  * sliding dictionary Pointer,  },   { encoder table },   p_len : Array[0..63] of Byte =,   ($03, $04, $04, $04, $05, $05, $05, $05,,    $05, $05, $05, $05, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $08, $08, $08, $08, $08, $08, $08, $08,,    $08, $08, $08, $08, $08, $08, $08, $08);,   p_code : Array[0..63] of Byte =,   ($00, $20, $30, $40, $50, $58, $60, $68,,    $70, $78, $80, $88, $90, $94, $98, $9C,,    $A0, $A4, $A8, $AC, $B0, $B4, $B8, $BC,,    $C0, $C2, $C4, $C6, $C8, $CA, $CC, $CE,,    $D0, $D2, $D4, $D6, $D8, $DA, $DC, $DE,,    $E0, $E2, $E4, $E6, $E8, $EA, $EC, $EE,,    $F0, $F1, $F2, $F3, $F4, $F5, $F6, $F7,,    $F8, $F9, $FA, $FB, $FC, $FD, $FE, $FF);,   { decoder table },   d_code : Array[0..255] of Byte =,   ($00, $00, $00, $00, $00, $00, $00, $00,,    $00, $00, $00, $00, $00, $00, $00, $00,,    $00, $00, $00, $00, $00, $00, $00, $00,,    $00, $00, $00, $00, $00, $00, $00, $00,,    $01, $01, $01, $01, $01, $01, $01, $01,,    $01, $01, $01, $01, $01, $01, $01, $01,,    $02, $02, $02, $02, $02, $02, $02, $02,,    $02, $02, $02, $02, $02, $02, $02, $02,,    $03, $03, $03, $03, $03, $03, $03, $03,,    $03, $03, $03, $03, $03, $03, $03, $03,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $08, $08, $08, $08, $08, $08, $08, $08,,    $09, $09, $09, $09, $09, $09, $09, $09,,    $0A, $0A, $0A, $0A, $0A, $0A, $0A, $0A,,    $0B, $0B, $0B, $0B, $0B, $0B, $0B, $0B,,    $0C, $0C, $0C, $0C, $0D, $0D, $0D, $0D,,    $0E, $0E, $0E, $0E, $0F, $0F, $0F, $0F,,    $10, $10, $10, $10, $11, $11, $11, $11,,    $12, $12, $12, $12, $13, $13, $13, $13,,    $14, $14, $14, $14, $15, $15, $15, $15,,    $16, $16, $16, $16, $17, $17, $17, $17,,    $18, $18, $19, $19, $1A, $1A, $1B, $1B,,    $1C, $1C, $1D, $1D, $1E, $1E, $1F, $1F,,    $20, $20, $21, $21, $22, $22, $23, $23,,    $24, $24, $25, $25, $26, $26, $27, $27,,    $28, $28, $29, $29, $2A, $2A, $2B, $2B,,    $2C, $2C, $2D, $2D, $2E, $2E, $2F, $2F,,    $30, $31, $32, $33, $34, $35, $36, $37,,    $38, $39, $3A, $3B, $3C, $3D, $3E, $3F);,   d_len : Array[0..255] of Byte =,   ($03, $03, $03, $03, $03, $03, $03, $03,,    $03, $03, $03, $03, $03, $03, $03, $03,,    $03, $03, $03, $03, $03, $03, $03, $03,,    $03, $03, $03, $03, $03, $03, $03, $03,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $04, $04, $04, $04, $04, $04, $04, $04,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $05, $05, $05, $05, $05, $05, $05, $05,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $06, $06, $06, $06, $06, $06, $06, $06,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $07, $07, $07, $07, $07, $07, $07, $07,,    $08, $08, $08, $08, $08, $08, $08, $08,,    $08, $08, $08, $08, $08, $08, $08, $08);,   getbuf : Word = 0;,   getlen : Byte = 0;,   putlen : Byte = 0;,   putbuf : Word = 0;,   TextSize : LongInt = 0;,   codesize : LongInt = 0;,   printcount : LongInt = 0;,   match_position : Integer = 0;,   match_length : Integer = 0;, Type,   FreqType = Array[0..T] of Word;,   FreqPtr = ^FreqType;,   PntrType = Array[0..pred(T + N_Char)] of Integer;,   pntrPtr = ^PntrType;,   SonType = Array[0..pred(T)] of Integer;,   SonPtr = ^SonType;,   TextBufType = Array[0..N + F - 2] of Byte;,   TBufPtr = ^TextBufType;,   WordRay = Array[0..N] of Integer;,   WordRayPtr = ^WordRay;,   BWordRay = Array[0..N + 256] of Integer;,   BWordRayPtr = ^BWordRay;, Var,   Text_buf : TBufPtr;,   lson, dad : WordRayPtr;,   rson : BWordRayPtr;,   freq : FreqPtr; { cumulative freq table }, {,  * pointing parent nodes.,  * area [T..(T + N_Char - 1)] are Pointers For leaves,  },   prnt : pntrPtr;,   { pointing children nodes (son[], son[] + 1)},   son : SonPtr;,   Procedure InitTree; { Initializing tree },   Var,     i : Integer;,   begin,     For i := N + 1 to N + 256 do,       rson^[i] := NUL; { root },     For i := 0 to N do,       dad^[i] := NUL; { node },   end;,   Procedure InsertNode(R : Integer); { Inserting node to the tree },   Var,     tmp, i, p, cmp : Integer;,     key : TBufPtr;,     c : Word;,   begin,    CMP：= 1；，    关键：=“text_buf ^ [R]，    ；P：=成功（N）+关键^ [ 0 ]；，    人^ [R]：=空；，    lson ^ [R]：=空；，    match_length：= 0；，    而match_length <；F做的，      开始，        如果（CMP >；= 0）然后，          开始，            如果（人^ [P] <；>；NUL）然后，              P =人^ [P]，            别的，              开始，                人^ [P]：= R；，                爸爸^ [R]：= P；，                退出；，              结束；结束，          ，        别的，          开始，            如果（lson ^ [P] <；>；NUL）然后，              P = lson ^ [P]，            别的，              开始，                lson ^ [P]：= R；，                爸爸^ [R]：= P；，                退出；，              结束；结束，          ；，        我：= 0；，        CMP：= 0；同时，        （<；f）和（CMP = 0）做的，          开始，            公司（我）；，            CMP：=关键^ [我] - text_buf ^ [ P +我]；，          端；，        如果（我>；阈值）然后，          开始，            TMP：= PRED（（R P）和泼尼松（N））；，            如果（我>；match_length）然后，              开始，                match_position：= TMP；，                match_length：=我；，              结束；如果，            （match_length <；f）和（我= match_length）然后，              开始，                C = TMP；，                如果（C <；match_position）然后，                  match_position：= C；，              端；，          结束；结束，      ；{ }而真做，    爸爸^ [R]：=爸爸^ [P]；，    lson ^ [R]：= lson ^ [P]；，    人^ [R]：=人^ [P]；，    爸爸^ [ lson ^ [P] ]：= R；，    爸爸^ [人^ [P] ]：= R；，    如果（人^ [爸爸^ [P] ] = p) then,       rson^[dad^[p]] := R,     else,       lson^[dad^[p]] := R;,     dad^[p] := NUL; { remove p },   end;,   Procedure DeleteNode(p : Integer); { Deleting node from the tree },   Var,     q : Integer;,   begin,     if (dad^[p] = NUL) then,       Exit; { unregistered },     if (rson^[p] = NUL) then,       q := lson^[p],     else if (lson^[p] = NUL) then,       q := rson^[p],     else,       begin,         q := lson^[p];,         if (rson^[q] <> NUL) then,           begin,             Repeat,               q := rson^[q];,             Until (rson^[q] = NUL);,             rson^[dad^[q]] := lson^[q];,             dad^[lson^[q]] := dad^[q];,             lson^[q] := lson^[p];,             dad^[lson^[p]] := q;,           end;,         rson^[q] := rson^[p];,         dad^[rson^[p]] := q;,       end;,     dad^[q] := dad^[p]; , ,     if (rson^[dad^[p]] = p) then,       rson^[dad^[p]] := q,     else,       lson^[dad^[p]] := q;,     dad^[p] := NUL;,   end;,   { Huffman coding parameters },   Function GetBit(GetBytes : GetBytesProc) : Integer; { get one bit },   Var,     i : Byte;,     i2 : Integer;,     result : Word;,   begin,     而（getlen <；= 8），      开始，        getBytes（我，1，结果，        ）；如果结果= 1，          I2：=我，        I2 = 0；，其他：        getbuf：= getbuf或（I2 SHL（8—getlen））；，        公司（getlen，8）；最后，      ；，    I2：= getbuf；，    getbuf：= getbuf SHL 1；，    DEC（getlen）；，    中的getbit：=整数（（I2 <；0），  ）；结束；，  功能getbyte（其中：getbytesproc）：整数；{ }得到一个字节，  VaR，    J：字节；，    我，结果：单词；，  开始，    而（getlen <；= 8），      开始，        getBytes（J，1，结果，        ）；如果结果= 1，          我：= J，        ELSe,           i := 0;,         getbuf := getbuf or (i shl (8 - getlen));,         inc(getlen, 8);,       end;,     i := getbuf;,     getbuf := getbuf shl 8;,     dec(getlen, 8);,     GetByte := Integer(i shr 8);,   end;,   Procedure Putcode(l : Integer; c : Word;,                     PutBytes : PutBytesProc); { output c bits },   Var,     Temp : Byte;,     Got : Word;,   begin,     putbuf := putbuf or (c shr putlen);,     inc(putlen, l);,     if (putlen >= 8) then,       begin,         Temp := putbuf shr 8;,         PutBytes(Temp, 1, Got);,         dec(putlen, 8);,         if (putlen >= 8) then,           开始，            温度：=罗（putbuf）；，            putbytes（温度，1，有            公司（codesize）；，，2）；，            DEC（putlen，8）；，            putbuf：= C SHL（L putlen）；最后，          ，        别的，          开始，            putbuf：= putbuf SHL 8；，            公司（codesize）；最后，          ；，      结束；结束，  ；，  {初始化频率树}，  程序starthuff；，  VaR，    I、J：整数；，  开始，    我：= 0（n_char PRED）做的，      开始，        频率^ [我]：= 1；，        儿子^ [我]：= I + T；，        中和^ [我]：T =我；，      ENd;,     i := 0;,     j := N_Char;,     While (j <= R) do,       begin,         freq^[j] := freq^[i] + freq^[i + 1];,         son^[j] := i;,         prnt^[i] := j;,         prnt^[i + 1] := j;,         inc(i, 2);,         inc(j);,       end;,     freq^[T] := $ffff;,     prnt^[R] := 0;,   end;,   { reConstruct freq tree },   Procedure reConst;,   Var,     i, j, k, tmp : Integer;,     F, l : Word;,   begin,     { halven cumulative freq For leaf nodes },     j := 0;,     For i := 0 to pred(T) do,       begin,         if (son^[i] >= T) then,           begin,             freq^[j] := succ(freq^[i]) div 2; {@@ Bug Fix MOD -> div @@},             son^[j] := son^[i];,             inc(j);,           end;,       end;,     { make a tree : first, connect children nodes },     i := 0;,     j := N_Char;,     While (j < T) do,       begin,         k := succ(i);,         F := freq^[i] + freq^[k];,         freq^[j] := F;,         k := pred(j);,         While F < freq^[k] do,           dec(k);,         inc(k);,         l := (j - k) shl 1;,         tmp := succ(k);,         move(freq^[k], freq^[tmp], l);,         freq^[k] := F;,         move(son^[k], son^[tmp], l);,         儿子^ [K]：=我；，        公司（I，2）；，        公司（J）；最后，      ；，    {连接父节点}，    我：= 0 PRED（T）做的，      开始，        K =儿子^ [我]；如果，        （K >；= T）然后，          开始，            中和^ [K]：=我；，          结束，        别的，          开始，            中和^ [K]：=我；，            中和^ [成功]（K）：=我；，          端；最后，      ；，  端；，  {更新频率树}，  程序更新（C：整数）；，  VaR，    I，J，K，L：整数；，  开始，    如果（频率^ [R] = max_freq）然后，      开始，        ，重建；最后，         ； c := prnt^[c + T];,     Repeat,       inc(freq^[c]);,       k := freq^[c];,       { swap nodes to keep the tree freq-ordered },       l := succ(c);,       if (k > freq^[l]) then,         begin,           While (k > freq^[l]) do,             inc(l);,           dec(l);,           freq^[c] := freq^[l];,           freq^[l] := k;,           i := son^[c];,           prnt^[i] := l;,           if (i < T) then prnt^[succ(i)] := l;,           j := son^[l];,           son^[l] := i;,           prnt^[j] := c;,           if (j < T) then prnt^[succ(j)] := c;,           son^[c] := j;,           c := l;,         end;,       c := prnt^[c];,     Until (c = 0); { Repeat it Until reaching the root },   end;, Var,   code, len : Word;,   Procedure EncodeChar(c : Word; PutBytes : PutBytesProc);,   Var,     i : Word;,     j, k : Integer;,   begin,     i := 0;,     j := 0;,     k := prnt^[c + T];,     { search connections from leaf node to the root },     Repeat,       i := i shr 1;,  {,         if node's address is odd, output 1,         else output 0,         },       if Boolean(k and 1) then inc(i, $8000);,       inc(j);,       k := prnt^[k];,     Until (k = R);,     Putcode(j, i, PutBytes);,     code := i;,     len := j;,     update(c);,   end;,   Procedure EncodePosition(c : Word; PutBytes : PutBytesProc);,   Var,     i, j : Word;,   begin,     { output upper 6 bits With encoding },     i := c shr 6;,     j := p_code[i];,     Putcode(p_len[i], j shl 8, PutBytes);,     { output lower 6 bits directly },     Putcode(6, (c and $3f) shl 10, PutBytes);,   end;,   Procedure Encodeend(PutBytes : PutBytesProc);,   Var,     Temp : Byte;,     Got : Word;,   begin,     if Boolean(putlen) then,       begin,         Temp := lo(putbuf shr 8);,         PutBytes(Temp, 1, Got);,         inc(codesize);,       end;,   end;,   Function DecodeChar(GetBytes : GetBytesProc) : Integer;,   Var,     c : Word;,   begin,     c := son^[R];,     {,      * start searching tree from the root to leaves.,      * choose node #(son[]) if input bit = 0,      * else choose #(son[]+1) (input bit = 1),     },     While (c < T) do,       begin,         c := c + GetBit(GetBytes);,         c := son^[c];,       end;,     c := c - T;,     update(c);,     DecodeChar := Integer(c);,   end;,   Function DecodePosition(GetBytes : GetBytesProc) : Word;,   Var,     i, j, c : Word;,   begin,     { decode upper 6 bits from given table },     i := GetByte(GetBytes);,     c := Word(d_code[i] shl 6);,     j := d_len[i];,     { input lower 6 bits directly },     dec(j, 2);,     While j <> 0 do,       begin,         i := (i shl 1) + GetBit(GetBytes);,         dec(j);,       end;,     DecodePosition := c or i and $3f;,   end;,   { Compression },   Procedure InitLZH;,   begin,     getbuf := 0;,     getlen := 0;,     putlen := 0;,     putbuf := 0;,     TextSize := 0;,     codesize := 0;,     printcount := 0;,     match_position := 0;,     match_length := 0;,     new(lson);,     new(dad);,     new(rson);,     new(Text_buf);,     new(freq);,     new(prnt);,     new(son);,   end;,   Proc作为endlzh；，  开始，    处置（儿子）；，    处理（PRNT）；，    处理（频率），    处置；（text_buf）；（人），    处置；处置，    （爸爸），    处置；（lson）；，  ，  lzhpack（程序结束；无功bytes_written：LongInt；，                        其中：getbytesproc；，                        putbytes：putbytesproc）；，  VaR，    CT：字节；，    我，莱恩，R，S，last_match_length：整数；，    有：单词；，  开始，    initlzh；，    文字大小：= 0；{倒带扫描}，    starthuff；，    inittree；，    ：= 0；，    R = N F；，    fillchar（text_buf ^ [ 0 ]，R，和# 39；与# 39；），    Len：= 0；，    有：= 1；同时，    （Len <；f）和（有<；>；0）做的，      开始，        getBytes（CT，1，得到了）；如果有，        <；>；0，          开始，            text_buf ^ [ R + Len ]：= CT；，            公司（LEN）；最后，          ；，      端；，    文字大小：=透镜；，    我：= 1 F做的，      insertnode（R I）；，    insertnode（R）；，    重复，      如果（match_length >然后，        ；len）match_length：=透镜；，      如果（match_length <；=阈值）然后，        开始，          match_length：= 1；，          encodechar（text_buf ^ [R]，putbytes）；最后，        ，      别的，        开始，          encodechar（255 + match_length阈值，putbytes）；，          encodeposition（match_position，putbytes）；最后，        ；，      last_match_length：= match_length；，      我：= 0；，      有：= 1；同时，      （我<；last_match_length）和（有<；>；0）做的，        开始，          getBytes（CT，1，得到了）；如果有，          <；>；0，            开始，              deletenode（S）；，              text_buf ^ [的]：= CT；，              如果（S <；PRED（f））然后，                text_buf ^ [ S + N ]：= CT；，              ：=成功（S）和泼尼松（N），   ；           R =成功（R）和泼尼松（N）；，              insertnode（R）；，              公司（我）；最后，            ；，        端；，      公司（文字大小、我），而（我      ；<；last_match_length）做的，        开始，          公司（我）；，          deletenode（S）；，          ：=成功（S）和泼尼松（N）；，          R：=成功（R）和泼尼松（N）；，          DEC（Len）；，          如果布尔（LEN）然后insertnode（R），        端；，；    直到（Len <；= 0）；，    encodeend（putbytes）；，    endlzh；，    bytes_written：=文字大小；，  端；，  程序lzhunpack（LongInt；，             文字大小：         其中：getbytesproc；，                      putbytes：putbytesproc）；，  VaR，    C，I，J，K，R：整数；，    C2：字节；，    计数：LongInt；，    ：词；，  开始，    initlzh；，    starthuff；，    R：= N F；，    fillchar（text_buf ^ [ 0 ]，R，和# 39；与# 39；）；，    计数：= 0；同时，    计数<；文字大小做的，      开始，        C = decodechar（字节数组）；，        如果（C <；256）然后，          开始，            C2：=罗（C）；，            putbytes（C2、1、放）；，            text_buf ^ [R]：= C；，            公司（R）；，            R = R和Pred（N），    ；        公司（计数）；最后，          ，        别的，          开始，            我：=（R -成功（decodeposition（字节数组）））和泼尼松（N）；，            J：= C - 255 +阈值；，            K：= 0 PRED（J）做的，              开始，                C = text_buf ^ [（我+ K）和泼尼松（N）]；，                C2：=罗（C）；，                putbytes（C2、1、放）；，                text_buf ^ [R]：= C；，                公司（R）；，                R = R和PRED（N）；，                公司（计数）；最后，              ；，          ，    结束；    eindigt;    ,     endlzh;,  ,   voorbij, voorbij.