----------- 1. Twee basic programma's aangemaakt om LZW te bestuderen & uit te testen & leren te begrijpen.

 Ŀ
   LZW_KOMP.BAS                                                                                                                
 ͵
   CLS                                                                                                                         
   PRINT " VoorBeeldTestProgramma I.V.M. LZW Kompressie "                                                                      
   PRINT " -------------------------------------------- "                                                                      
   OPEN "test.LZW" FOR OUTPUT AS #1                                                                                            
   DIM stringtable$(1000)                                                                                                      
   codestream$ = ""                                                                                                            
   INPUT "Charstream (te kompressen string ...) "; charstream$                                                                 
   PRINT " > Te compressen : "; charstream$                                                                                    
   OPEN "test.kar" FOR OUTPUT AS #2                                                                                            
   PRINT #2, charstream$                                                                                                       
   CLOSE 2                                                                                                                     
   FOR ascii = 0 TO 255                                                                                                        
   stringtable$(ascii) = CHR$(ascii)                                                                                           
   NEXT ascii                                                                                                                  
   stringtablemax = 255                                                                                                        
                                                                                                                               
   C$ = ""                                                                                                                     
   FOR x = 1 TO LEN(charstream$)                                                                                               
   K$ = MID$(charstream$, x, 1)                                                                                                
   A$ = C$ + K$: PRINT " > [.c.]K = "; A$                                                                                      
                                                                                                                               
   flag = 0                                                                                                                    
   FOR t = 0 TO stringtablemax                                                                                                 
   IF stringtable$(t) = A$ THEN flag = 1                                                                                       
   NEXT t                                                                                                                      
   IF flag = 1 THEN                                                                                                            
                           C$ = A$                                                                                             
               END IF                                                                                                          
   IF flag = 0 THEN                                                                                                            
                           stringtablemax = stringtablemax + 1                                                                 
                           stringtable$(stringtablemax) = A$                                                                   
                           FOR t = 0 TO stringtablemax                                                                         
                           IF stringtable$(t) = C$ THEN codestream$ = codestream$ + STR$(t): PRINT #1, t                       
                           NEXT t                                                                                              
                           C$ = K$                                                                                             
               END IF                                                                                                          
   NEXT x                                                                                                                      
                           FOR t = 0 TO stringtablemax                                                                         
                           IF stringtable$(t) = C$ THEN codestream$ = codestream$ + STR$(t): PRINT #1, t                       
                           NEXT t                                                                                              
                           PRINT " > GeKompreste codestream : "; codestream$                                                   
   CLOSE 1                                                                                                                     
   SYSTEM                                                                                                                      
 
 Ŀ
   LZW_DEKO.BAS                                                                                                                
 ͵
   PRINT " VoorBeeldTestProgramma I.V.M. LZW DeKompressie "                                                                    
   PRINT " ---------------------------------------------- "                                                                    
   charstream$ = ""                                                                                                            
   DIM stringtable$(1000)                                                                                                      
   FOR ascii = 0 TO 255                                                                                                        
   stringtable$(ascii) = CHR$(ascii)                                                                                           
   NEXT ascii                                                                                                                  
   stringtablemax = 255                                                                                                        
                                                                                                                               
   OPEN "test.LZW" FOR INPUT AS #1                                                                                             
   DIM codestream(200)                                                                                                         
   lus = 0                                                                                                                     
   DO                                                                                                                          
   INPUT #1, codestream(lus): lus = lus + 1                                                                                    
   IF EOF(1) THEN codestream(lus) = -1: EXIT DO                                                                                
   LOOP                                                                                                                        
                                                                                                                               
   x = 0                                                                                                                       
   code = codestream(x)                                                                                                        
   charstream$ = stringtable$(code)                                                                                            
   step5:                                                                                                                      
   old = code                                                                                                                  
   x = x + 1: code = codestream(x)                                                                                             
   IF code = -1 THEN GOTO stoppen                                                                                              
   IF code > stringtablemax THEN                                                                                               
                                   stringtablemax = stringtablemax + 1                                                         
                                   c$ = stringtable$(old) + LEFT$(stringtable$(old), 1)                                        
                                   stringtable$(stringtablemax) = c$                                                           
                                   charstream$ = charstream$ + c$                                                              
                                   GOTO step5                                                                                  
                            END IF                                                                                             
   IF code <= stringtablemax THEN                                                                                              
                                   stringtablemax = stringtablemax + 1                                                         
                                   c$ = stringtable$(old) + LEFT$(stringtable$(code), 1)                                       
                                   stringtable$(stringtablemax) = c$                                                           
                                   charstream$ = charstream$ + stringtable$(code)                                              
                                   GOTO step5                                                                                  
                             END IF                                                                                            
   stoppen:                                                                                                                    
   CLOSE 1                                                                                                                     
   OPEN "test.kar" FOR INPUT AS #1                                                                                             
   INPUT #1, fi$                                                                                                               
   PRINT fi$                                                                                                                   
   PRINT charstream$                                                                                                           
   CLOSE 1                                                                                                                     
   SYSTEM                                                                                                                      
 

----------- 2. LZW_KOMP.BAS omgevormt om zo beter om te kunnen zetten naar ASM ; Later een Assembler(Test)Versie gemaakt.

 Ŀ
   LZW_KOM2.BAS                                                                                                                
 ͵
   ' K$ = Steeds gelijk aan n BYTE                                                                                           
   ' CX = DW ; Bv. 12Bits in goede inplem. Kontrole inbouwen !                                                                 
                                                                                                                               
   CLS                                                                                                                         
   PRINT " VoorBeeldTestProgramma I.V.M. LZW Kompressie "                                                                      
   PRINT " -QBASIC (ASM)------------------------------- "                                                                      
   OPEN "test.LZW" FOR OUTPUT AS #1                                                                                            
   DIM stringtable$(5000), stringtable(5000)                                                                                   
   codestream$ = ""                                                                                                            
   INPUT "Charstream (te kompressen string ...) "; charstream$                                                                 
   PRINT " > Te compressen : "; charstream$                                                                                    
   OPEN "test.kar" FOR OUTPUT AS #2                                                                                            
   PRINT #2, charstream$                                                                                                       
   CLOSE 2                                                                                                                     
   stringtablemax = 255                                            ' Aantal items reeds in tabel                               
   cx = -1                                                         ' -1 = &H0FFF = Leeg !                                      
                                                                                                                               
   DO                                                                                                                          
   x = x + 1: k$ = MID$(charstream$, x, 1): PRINT "Gelezen : "; k$: IF k$ = "" THEN EXIT DO                                    
                                                                                                                               
   flag = 0                                                                                                                    
   FOR t = 0 TO stringtablemax                                                                                                 
   IF t > 255 THEN IF stringtable(t) = cx THEN IF k$ = stringtable$(t) THEN flag = 1: cx = t: t = stringtablemax * 2           
   IF t < 256 THEN IF cx = -1 THEN IF k$ = CHR$(t) THEN flag = 1: cx = t: t = stringtablemax * 2                               
   NEXT t                                                                                                                      
   IF flag = 0 THEN                                                                                                            
                           stringtablemax = stringtablemax + 1                                                                 
                           stringtable$(stringtablemax) = k$                                                                   
                           stringtable(stringtablemax) = cx                                                                    
                           codestream$ = codestream$ + STR$(cx): PRINT #1, cx                                                  
                           cx = ASC(k$)                                                                                        
               END IF                                                                                                          
                                                                                                                               
   LOOP                                                                                                                        
                                                                                                                               
                           codestream$ = codestream$ + STR$(cx): PRINT #1, cx                                                  
                           PRINT " > GeKompreste codestream : "; codestream$                                                   
   CLOSE 1                                                                                                                     
   CLOSE 2                                                                                                                     
   SYSTEM                                                                                                                      
 
 Ŀ
   LZW_KOMP.ASM                                                                                                                
 ͵
                           .model small                                                                                        
                           .code                                                                                               
                           .286                                                                                                
                                                                                                                               
   Include                 Include.INC                                     ; Asm-ToolBox : Wagemakers Jan                      
                                                                                                                               
   Start:                                                                                                                      
                           @Init                                           ; Programma voorbereiden                            
                           mov ah,3ch                                      ; Maak een bestand aan met als ....                 
                           mov dx,offset bestand_uit                       ; .... Bestandsnaam 'bestand_uit'                   
                           xor cx,cx                                       ; Attrib.                                           
                           int 21h                                                                                             
                           mov bestand_uit_H,ax                            ; File-Handle onthouden !                           
                           mov ax,3d00h                                    ; Open bestand ; Read only                          
                           mov dx,offset bestand                           ; Bestandsnaam                                      
                           xor cx,cx                                       ; Attrib.                                           
                           int 21h                                                                                             
                           mov bestand_H,ax                                ; File-Handle onthouden !                           
                           mov dx,0FFFFh                                   ; DX = [.c.] = Leeg                                 
   lus:                                                                                                                        
                           push dx                                         ; PAS : DX wordt gebruikt , dus eerst bewaren !     
                           mov ah,3fh                                      ; Lees van bestand                                  
                           mov bx,bestand_h                                ; Bestands_Handle                                   
                           mov cx,1                                        ; Aantal bytes te lezen                             
                           mov dx,offset Kstring                           ; Buffer voor data ; K$ ; Basic                     
                           int 21h                                                                                             
                           cmp ax,0                                        ; EOF bereikt ?                                     
                           pop dx                                          ; Orig. DX terug ophalen                            
                           jne Niet_EOF                                                                                        
                           jmp EOF                                          ; End Of File (Einde Van Bestand (EVB))            
   Niet_EOF:                                                                                                                   
                           mov flag,0                                      ; Reset FLAG                                        
                           mov cx,0                                        ; = t van for_next_lus !                            
   for_t:                                                                                                                      
                           cmp cx,255                                                                                          
                           ja T_Is_Groter_Dan_255                                                                              
                           cmp dx,0FFFFh                                   ; Is [.c.] Leeg ?                                   
                           jne T_algemeen                                  ; Nee , doe dan niets !                             
                           cmp cl,Kstring                                  ; Is het karakter = CX (Cl want CX < 255 !)         
                           jne T_algemeen                                  ; Nee , doe dan niets !                             
                           mov flag,1                                      ; Set Flag                                          
                           mov dx,cx                                       ; [.c.] = gevonden [.c.]                            
                           jmp next_t                                      ; EN.... GEVONDEN IS STOPPEN !                      
   T_Is_Groter_Dan_255:                                                                                                        
                           mov bx,cx                                                                                           
                           add bx,cx                                                                                           
                           add bx,cx                                       ; bx = 3 * cx                                       
                           add bx,offset StringTable                       ; BASIC : Stringtable(StringTable_Max)              
                           cmp dx,ds:[bx]                                  ; [.c.] in stringtable ?                            
                           jne T_algemeen                                                                                      
                           add bx,2                                        ; BASIC : Stringtable$(StringTable_Max)             
                           mov al,kstring                                                                                      
                           cmp al,ds:[bx]                                  ; K in stringtable ?                                
                           jne T_algemeen                                                                                      
                           mov flag,1                                                                                          
                           mov dx,cx                                       ; [.c.] = gevonden [.c.]                            
                           jmp next_t                                                                                          
   T_algemeen:                                                                                                                 
                           inc cx                                          ; Verhoog teller                                    
                           cmp cx,stringtable_max                          ; Einde van [BASIC] For Next Lus bereikt ?          
                           jna for_t                                                                                           
   next_t:                                                                                                                     
                           cmp flag,0                                                                                          
                           jne jump_lus                                                                                        
                           inc stringtable_max                                                                                 
                           mov bx,stringtable_max                                                                              
                           add bx,stringtable_max                                                                              
                           add bx,stringtable_max                          ; bx = 3 * stringtable_max                          
                           add bx,offset StringTable                       ; BASIC : Stringtable(StringTable_Max)              
                           mov ds:[bx],dx                                  ; [.c.] Bewaren                                     
                           add bx,2                                        ; BASIC : Stringtable$(StringTable_Max)             
                           mov al,kstring                                  ; K Bewaren                                         
                           mov ds:[bx],al                                  ; ==> [.c.]K is dus volledig bewaard                
                           call add_codestream                                                                                 
                           xor dh,dh                                                                                           
                           mov dl,kstring                                                                                      
   jump_lus:                                                                                                                   
                           jmp lus                                                                                             
   EOF:                                                                                                                        
                           call add_codestream                                                                                 
                           mov bx,bestand_H                                ; File-Handle inlezen                               
                           mov ah,3eh                                      ; Bestand sluiten                                   
                           int 21h                                                                                             
                           mov bx,bestand_uit_H                            ; File-Handle inlezen                               
                           mov ah,3eh                                      ; Bestand sluiten                                   
                           int 21h                                                                                             
                           @Exit                                           ; Einde van het programma                           
                                                                                                                               
   Add_codestream          PROC                                                                                                
                           pusha                                                                                               
                           mov buffer,dx                                   ; Zet te schrijven bytes(2) in buffer               
                           mov ah,40h                                      ; "Write"                                           
                           mov bx,Bestand_uit_h                            ; File_Handle                                       
                           mov cx,2                                        ; Aantal te schrijven Bytes ....                    
                           mov dx,offset buffer                            ; Buffer met te schrijven data                      
                           int 21h                                                                                             
                           popa                                                                                                
                           RET                                                                                                 
   Add_codestream          ENDP                                                                                                
                                                                                                                               
                           .data                                                                                               
                                                                                                                               
   Flag                    db 0                                                                                                
   Bestand_uit             db "LZW_TEST.LZW",0                                                                                 
   Bestand_uit_H           dw 0                                                                                                
   Bestand                 db "LZW_IN.TXT",0                                                                                   
   Bestand_H               dw 0                                                                                                
   StringTable_Max         dw 255                                                                                              
   Kstring                 db 0                                                                                                
   Buffer                  dw 0                                                                                                
   StringTable             db 12288 dup(0)                                                                                     
                                                                                                                               
                           .stack                                                                                              
                                                                                                                               
                           END START                                                                                           
 

----------- 3. LZW_DEKO.BAS omgevormt om zo beter om te kunnen zetten naar ASM ; Later een Assembler(Test)Versie gemaakt.

 Ŀ
   LZW_DEK2.BAS                                                                                                                
 ͵
   PRINT " VoorBeeldTestProgramma I.V.M. LZW DeKompressie "                                                                    
   PRINT " ---------------------------------------------- "                                                                    
   charstream$ = ""                                                                                                            
   DIM stringtable$(1000), stringtable(1000)                                                                                   
   stringtablemax = 255                                                                                                        
                                                                                                                               
   OPEN "LZW_uit.txt" FOR BINARY AS #2                                                                                         
   OPEN "LZW_test.LZW" FOR BINARY AS #1                                                                                        
   DIM codestream(200)                                                                                                         
   lus = 0                                                                                                                     
   a$ = " "                                                                                                                    
   DO                                                                                                                          
   GET #1, , a$: codestream(lus) = ASC(a$)                                                                                     
   GET #1, , a$: codestream(lus) = codestream(lus) + ASC(a$) * 256                                                             
   lus = lus + 1                                                                                                               
   IF EOF(1) THEN codestream(lus) = -1: EXIT DO                                                                                
   LOOP                                                                                                                        
                                                                                                                               
   x = 0                                                                                                                       
   DX = codestream(x)                                                                                                          
   x$ = CHR$(DX): PUT #2, , x$                                                                                                 
   step5:                                                                                                                      
   AX = DX                                                                                                                     
   x = x + 1: DX = codestream(x)                                                                                               
   IF DX = -1 THEN GOTO stoppen                                                                                                
   IF DX > stringtablemax THEN                                                                                                 
                                   stringtablemax = stringtablemax + 1                                                         
                                   stringtable(stringtablemax) = AX                                                            
                                   CX = AX                                                                                     
                                   teller = 0                                                                                  
                                   GOSUB maakstring                                                                            
                                                                                                                               
                                   x$ = CHR$(CX): PUT #2, , x$                                                                 
                                                                                                                               
                                   GOTO step5                                                                                  
                            END IF                                                                                             
   IF DX <= stringtablemax THEN                                                                                                
                                   stringtablemax = stringtablemax + 1                                                         
                                   stringtable(stringtablemax) = AX                                                            
                                   CX = DX                                                                                     
                                   teller = 0                                                                                  
                                   GOSUB maakstring                                                                            
                                                                                                                               
                                   GOTO step5                                                                                  
                             END IF                                                                                            
   stoppen:                                                                                                                    
   CLOSE 1                                                                                                                     
   CLOSE 2                                                                                                                     
   SYSTEM                                                                                                                      
                                                                                                                               
   maakstring:                                                                                                                 
   lus2:                                                                                                                       
                                   IF CX > 255 THEN                                                                            
                                                   buffer(teller) = ASC(stringtable$(CX))                                      
                                                   teller = teller + 1                                                         
                                                   CX = stringtable(CX)                                                        
                                                   GOTO lus2                                                                   
                                               END IF                                                                          
                                   stringtable$(stringtablemax) = CHR$(CX)                                                     
                                                                                                                               
                                   x$ = CHR$(CX): PUT #2, , x$                                                                 
                                   FOR t = teller - 1 TO 0 STEP -1                                                             
                                       x$ = CHR$(buffer(t)): PUT #2, , x$                                                      
                                   NEXT t                                                                                      
                                                                                                                               
   RETURN                                                                                                                      
 
 Ŀ
   LZW_DEKO.ASM                                                                                                                
 ͵
                           .model small                                                                                        
                           .code                                                                                               
                           .286                                                                                                
                                                                                                                               
   Include                 Include.INC                                     ; Asm-ToolBox : Wagemakers Jan                      
                                                                                                                               
   Start:                                                                                                                      
                           @Init                                           ; Programma voorbereiden                            
                           mov ax,3d00h                                    ; Open - Read only                                  
                           mov dx,offset LZW_Bestand                       ; Bestandsnaam                                      
                           xor cx,cx                                       ; Attrib.                                           
                           int 21H                                                                                             
                           mov LZW_Bestand_H,ax                            ; File-Handle onthouden.                            
                           mov ah,3ch                                      ; Create file                                       
                           xor cx,cx                                       ; Attrib.                                           
                           mov dx,offset Bestand                           ; BestandsNaam                                      
                           int 21h                                                                                             
                           mov Bestand_H,ax                                ; File-Handle onthouden.                            
                           call Read_LZW                                   ; Lees van LZW_BESTAND (Waarde komt in DX)          
                           cmp dx,0ffffh                                   ; EOF ?                                             
                           jne x1                                                                                              
                           jmp stoppen                                                                                         
   x1:                                                                                                                         
                           call Write_uit                                  ; Schrijf naar uitgepakt bestand (Buffer_LZW)       
   step5:                                                                                                                      
                           mov ax,dx                                       ; old = code                                        
                           call Read_LZW                                   ; Lees !                                            
                           cmp dx,0ffffh                                   ; EOF ?                                             
                           jne x2                                                                                              
                           jmp stoppen                                                                                         
   x2:                                                                                                                         
                           cmp dx,stringtable_max                          ; dx > stringtable_max ?                            
                           pushf                                                                                               
                           inc stringtable_max                             ; verhoog stringtable_max                           
                           mov bx,stringtable_max                                                                              
                           add bx,stringtable_max                                                                              
                           add bx,stringtable_max                          ; bx = 3 * stringtable_max                          
                           add bx,offset StringTable                       ; BASIC : Stringtable(StringTable_Max)              
                           mov ds:[bx],ax                                  ; OLD bewaren                                       
                           popf                                                                                                
                           ja dx_is_grootst                                                                                    
                           mov cx,dx                                       ; cx = code                                         
                           call maakstring                                                                                     
                           jmp step5                                                                                           
   dx_is_grootst:                                                                                                              
                           mov cx,ax                                       ; cx = old                                          
                           call maakstring                                                                                     
                           mov buffer_LZW,cx                               ; En schrijf cx (cl dus ; ch = 0) naar ....         
                           call Write_Uit                                  ; .... het uiteindelijke bestand!                   
                           jmp step5                                                                                           
   stoppen:                                                                                                                    
                           mov ah,3eH                                      ; close                                             
                           mov bx,Bestand_H                                                                                    
                           int 21h                                                                                             
                           mov ah,3eH                                      ; close                                             
                           mov bx,LZW_Bestand_H                                                                                
                           int 21h                                                                                             
                           @Exit                                           ; Einde van het programma                           
                                                                                                                               
   MaakString              PROC                                                                                                
                           mov di,offset buffer_tel                                                                            
   lus2:                                                                                                                       
                           cmp cx,255                                      ; is cx > 255                                       
                           jna cx_is_low                                                                                       
                           mov bx,cx                                                                                           
                           add bx,cx                                                                                           
                           add bx,cx                                       ; = 3 * cx                                          
                           add bx,offset StringTable                       ; BASIC : Stringtable(cx)                           
                           add bx,2                                        ; Voor stringtable$                                 
                           push ax                                                                                             
                           mov al,ds:[bx]                                  ; AL = ASC(stringtable$(cx))                        
                           mov ds:[di],al                                  ; buffer(teller) = asc(stringtable$(cx))            
                           pop ax                                                                                              
                           inc di                                          ; Verhoog buffer_Tel oftewel teller = teller + 1    
                           sub bx,2                                        ; Voor stringtable                                  
                           mov cx,ds:[bx]                                                                                      
                           jmp lus2                                                                                            
   cx_is_low:                                                                                                                  
                           pusha                                                                                               
                           mov di,stringtable_Max                                                                              
                           add di,stringtable_Max                                                                              
                           add di,stringtable_Max                          ; di = 3 * stringtablemax                           
                           add di,offset StringTable                       ; BASIC : Stringtable(StringTable_Max)              
                           add di,2                                        ; Voor stringtable$                                 
                           mov ds:[di],cl                                  ; stringtable$(stringtablemax) = CHR$(CX)           
                           mov buffer_LZW,cx                               ; En schrijf cx (cl dus ; ch = 0) naar ....         
                           call Write_Uit                                  ; .... het uiteindelijke bestand!                   
                           popa                                                                                                
   for_t:                                                                                                                      
                           cmp di,offset buffer_tel                        ; Begin van Buffer_tel bereikt ?                    
                           je next_t                                                                                           
                           dec di                                          ; Verlaag buffer_Teller (for t = teller - 1 ...)    
                           mov cl,ds:[di]                                  ; Haal byte uit buffer                              
                           mov buffer_LZW,cx                               ; En schrijf cx (cl dus ; ch = 0) naar ....         
                           call Write_Uit                                  ; .... het uiteindelijke bestand!                   
                           jmp for_t                                                                                           
   next_t:                                                                                                                     
                           RET                                                                                                 
   MaakString              ENDP                                                                                                
                                                                                                                               
   Read_LZW                PROC                                                                                                
                           pusha                                                                                               
                           mov ah,3fh                                      ; Lees van bestand                                  
                           mov bx,LZW_Bestand_H                            ; Bestands_Handle                                   
                           mov cx,2                                        ; 2Bytes te lezen want steeds als DW geschreven !   
                           mov dx,offset Buffer_LZW                        ; Buffer waar data komt te staan                    
                           int 21h                                                                                             
                           cmp ax,0                                        ; EOF - EVB (Einde van bestand ?)                   
                           jne x3                                                                                              
                           mov Buffer_LZW,0ffffh                           ; EVB - Kode doorgeven !                            
   x3:                                                                                                                         
                           popa                                                                                                
                           mov dx,Buffer_LZW                               ; DX = Ingelezen code !                             
                           RET                                                                                                 
   Read_LZW                ENDP                                                                                                
                                                                                                                               
   Write_uit               PROC                                                                                                
                           pusha                                                                                               
                           mov ah,40h                                      ; Schrijf naar bestand                              
                           mov bx,Bestand_H                                ; Bestands_Handle                                   
                           mov cx,1                                        ; 1Byte te schrijven                                
                           mov dx,offset Buffer_LZW                        ; Buffer ; wat te schrijven                         
                           int 21h                                                                                             
                           popa                                                                                                
                           RET                                                                                                 
   Write_uit               ENDP                                                                                                
                                                                                                                               
                           .data                                                                                               
                                                                                                                               
   StringTable_Max         dw 255                                                                                              
   LZW_Bestand             db "LZW_TEST.LZW",0                                                                                 
   Bestand                 db "LZW_UIT.TXT",0                                                                                  
   LZW_Bestand_H           dw 0                                                                                                
   Bestand_H               dw 0                                                                                                
   Buffer_LZW              dw 0                                                                                                
   Buffer_Tel              db 4096 dup(0)                                  ; Is deze waarde wel goed ?                         
   StringTable             db 12288 dup(0)                                                                                     
                                                                                                                               
                           .stack                                                                                              
                                                                                                                               
                           END START                                                                                           
 

Dit alles werkt zo ongeveer maar :
        - Er is overflow van de CODETABLE mogelijk
        - Verspillende weggeschreven (16Bits), moet met een variabel aantal bits weggesaved worden.
