From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1L3LD9-0005Kx-8l for qemu-devel@nongnu.org; Thu, 20 Nov 2008 20:53:31 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1L3LD6-0005JF-6p for qemu-devel@nongnu.org; Thu, 20 Nov 2008 20:53:29 -0500 Received: from [199.232.76.173] (port=52835 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1L3LD5-0005JC-UT for qemu-devel@nongnu.org; Thu, 20 Nov 2008 20:53:28 -0500 Received: from web27203.mail.ukl.yahoo.com ([217.146.182.93]:31937) by monty-python.gnu.org with smtp (Exim 4.60) (envelope-from ) id 1L3LD3-0005QW-M0 for qemu-devel@nongnu.org; Thu, 20 Nov 2008 20:53:27 -0500 Date: Fri, 21 Nov 2008 01:53:20 +0000 (GMT) From: Salvatore Lionetti Subject: Re: [Qemu-devel] PowerPC 4xx enhacement In-Reply-To: MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="0-956278597-1227232400=:53603" Message-ID: <169263.53603.qm@web27203.mail.ukl.yahoo.com> Reply-To: qemu-devel@nongnu.org List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Hollis Blanchard Cc: qemu-devel@nongnu.org --0-956278597-1227232400=:53603 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Source modified =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D - code factoring for ppc405GPr, ppc405EP, ppc405GPe - reorganization in i2c code, with possibility of board customization callb= ack - new board added for 'DHT Walnut board', fw in pc-bios/walnut_uboot.bin - cfi flash now support 'buffer mode', write N {byte, halfword, word} conse= cutively. - emac/mal now work with vlan mode Board Walnut: =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D http://elinux.org/DHT-Walnut-Flameman CPU PowerPC 405 GPe running at 266Mhz LAN On-chip 405GP ethernet, namely emac/mal ROM 512k of boot flash, AMD 29LV040B PID eeprom via i2c Full Tested (eth, flash, pid) =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D - u-boot 1.1.6 on walnut board (with few patch, see ppc405_board.c) - OSE on proprietary NSN 4G radio module - Can anyone test ref405ep and taihu? P.S: I've tryed to have patch for bin file but no luck Since i can not version file, does diff support binary file?does attachment= work? Index: Makefile.target =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- Makefile.target=09(revision 5720) +++ Makefile.target=09(working copy) @@ -679,7 +679,7 @@ # NewWorld PowerMac OBJS+=3D unin_pci.o ppc_chrp.o # PowerPC 4xx boards -OBJS+=3D pflash_cfi02.o ppc4xx_devs.o ppc405_uc.o ppc405_boards.o +OBJS+=3D pflash_cfi02.o emac.o ppc4xx_devs.o ppc405_uc.o ppc405_boards.o endif ifeq ($(TARGET_BASE_ARCH), mips) OBJS+=3D mips_r4k.o mips_jazz.o mips_malta.o mips_mipssim.o Index: osdep.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- osdep.c=09(revision 5720) +++ osdep.c=09(working copy) @@ -32,6 +32,7 @@ #include #include #endif +#include =20 #include "qemu-common.h" #include "sysemu.h" @@ -310,3 +311,49 @@ fcntl(fd, F_SETFL, f | O_NONBLOCK); } #endif + +void *qemu_mmap(void * start, size_t length, int prot, int flags, int fd, = off_t offset) { +=09void *ret; +#ifndef _WIN32 +=09ret =3D mmap(start, length, prot, flags, fd, offset); +#else +=09{ /* TO TEST!!! */ +=09=09static char name[15]; +=09=09static char ind=3D0; +=09=09HANDLE fd_map; +=09=09LPVOID fd_buf; +=09=09char* buf; + +=09=09assert(fd!=3DINVALID_HANDLE_VALUE); + +=09=09snprintf(name, 15, "qemu_mmap%d", ind++); +=09=09fd_map =3D CreateFileMapping(fd, +=09=09=09=09=09 NULL, /* Security attr */ +=09=09=09=09=09 PAGE_READWRITE, +=09=09=09=09=09 0, TOTAL_SIZE, +=09=09=09=09=09 name); + +=09=09fd_buf =3D MapViewOfFile(fd_map, +=09=09=09=09 FILE_MAP_ALL_ACCESS, +=09=09=09=09 0, 0, /* Offset */ +=09=09=09=09 TOTAL_SIZE); +=09=09assert(fd_buf); +=09=09ret =3D fd_buf; + +=09} +#endif +=09return ret; +} +int qemu_munmap(void *start, size_t length) { +=09int ret; +#ifndef _WIN32 +=09ret =3D munmap(start, length); +#else +=09{ /* TO TEST!!! */ +=09=09UnmapViewOfFile(start); +=09=09/*CloseHandle(fd_map); +=09=09CloseHandle(fd);*/ +=09} +#endif +=09return ret; +} Index: target-ppc/machine.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- target-ppc/machine.c=09(revision 5720) +++ target-ppc/machine.c=09(working copy) @@ -8,6 +8,7 @@ qemu_register_machine(&prep_machine); qemu_register_machine(&ref405ep_machine); qemu_register_machine(&taihu_machine); + qemu_register_machine(&walnut_machine); } =20 void cpu_save(QEMUFile *f, void *opaque) Index: qemu-common.h =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- qemu-common.h=09(revision 5720) +++ qemu-common.h=09(working copy) @@ -152,4 +152,11 @@ /* Force QEMU to stop what it's doing and service IO */ void qemu_service_io(void); =20 +/* KR function prototype. */ +typedef size_t KRHandler(int fd, char* buf, size_t size); + +/* mmap like function + * (cygwin seem !have aio yet so no linux env under Winzozz) */ +void *qemu_mmap(void * start, size_t length, int prot, int flags, int fd, = off_t offset); +int qemu_munmap(void *start, size_t length); #endif Index: hw/ppc405_boards.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/ppc405_boards.c=09(revision 5720) +++ hw/ppc405_boards.c=09(working copy) @@ -206,7 +206,7 @@ #ifdef DEBUG_BOARD_INIT printf("%s: register cpu\n", __func__); #endif - env =3D ppc405ep_init(ram_bases, ram_sizes, 33333333, &pic, &sram_offs= et, + env =3D ppc405xp_init("405ep", ram_bases, ram_sizes, 33333333, &pic, &= sram_offset, kernel_filename =3D=3D NULL ? 0 : 1); /* allocate SRAM */ #ifdef DEBUG_BOARD_INIT @@ -353,7 +353,6 @@ printf("bdloc %016lx %s\n", (unsigned long)bdloc, (char *)(phys_ram_base + bdloc)); } - QEMUMachine ref405ep_machine =3D { .name =3D "ref405ep", .desc =3D "ref405ep", @@ -361,6 +360,349 @@ .ram_require =3D (128 * 1024 * 1024 + 4096 + 512 * 1024 + BIOS_SIZE) |= RAMSIZE_FIXED, }; =20 +/*=20 + * Walnut board + * + * Starting point from official uboot 1.1.6 with following patch: + * - compilation error: cmd_bootm.c:470 manually expand #if + * - mac address not in nvram: include/configs/walnut.h add "ethaddr=3D52:= 54:00:12:34:56\0" in CONFIG_EXTRA_ENV_SETTING + * - remove trailer from recv packet(fcs?): cpu/ppc4xx/4xx_enet.c:1478 cal= l NetReceive with 'length' as 2nd parameter. + */ +/* Addedum related to 405GP: is it only for such device? */ +static target_ulong walnut_dcr_read (void *opaque, int dcrn) +{ +=09target_ulong ret=3D0; +=09switch (dcrn) { +=09=09case 0xAA: /* CPCO_ECR */ +=09=09=09break; +=09=09case 0xB0: /* CPC0_PLLMR */ +=09=09=09/* |--> {ForwardA, Backward} D= ivisor +=09=09=09 * ---- |--> Opb +=09=09=09 * ---> | x2 |-|--> ExtBus +=09=09=09 * ---- | ---- +=09=09=09 * CPU ---> | /4 | ---> PLB ------------> PCI +=09=09=09 * Clock ---- +=09=09=09 */ +=09=09=09ret =3D -2 << 29;/* Forward divisor is 2 =09*/ +=09=09=09ret |=3D 2 << 25; /* Backward divisor is 2 =09*/ +=09=09=09ret |=3D 3 << 17; /* Cpu/Plb is 4 =09=09*/ +=09=09=09ret |=3D 0 << 13; /* Pci/Plb is 1 =09=09*/ +=09=09=09ret |=3D 0 << 11; /* ExtBus/Plb is 2 =09=09*/ +=09=09=09ret |=3D 1 << 15; /* Opb/Plb is 2=09=09=09*/ +=09=09=09break; +=09=09case 0xB1: /* CPC0_CR0 */ +=09=09=09break; +=09=09case 0xB2: /* CPC0_CR1 */ +=09=09=09break; +=09=09case 0xB4: /* CPC0_PSR: For same uP model, could be different! */ +=09=09=09break; +=09=09default: +=09=09=09break; +=09} +/*=09printf("walnut_dcr [%x] =3D> %x\n", dcrn, ret);*/ +=09return ret; +} +static void walnut_dcr_write (void *opaque, int dcrn, target_ulong val) +{ +/*=09printf("walnut_dcr [%x] <=3D %x\n", dcrn, val);*/ +} + +/*=20 + * I2C Customization + * + * A file. + */ +static char PID_content[128]; /* If no file present */ +static uint32_t PID_cursor; +size_t PID_read(int addr, char *buf, size_t len) { +=09int ret; +=09ret =3D len; +=09if (len+PID_cursor>128) +=09=09len =3D 128 - PID_cursor; +=09memcpy(buf, &PID_content[PID_cursor], len); + +#if 0 +=09{ +=09int i; +=09printf("PID_Read dev(%x) len %d offs %d =3D>(", addr, ret, PID_cursor); +=09for (i=3D0; i0) { +=09=09PID_cursor =3D buf[0]; +=09=09len--; +=09=09if (len>0) { +=09=09=09if (len+PID_cursor>128) +=09=09=09=09len =3D 128 - PID_cursor; +=09=09=09memcpy(&PID_content[PID_cursor], buf+1, len); +=09=09} +=09} +#if 0 +=09{ +=09int i; +=09printf("PID_Write dev(0x%x) len %d, off %d <=3D(", addr, ret, PID_curso= r); +=09for (i=3D0; i=3D0) { /*"r+b"= );*/ +=09=09int n =3D read(PID_fd, PID_content, 128); +=09=09if (n<0) { +=09=09=09printf("Error reading file pid.bin (ret %d)\n", n);=20 +=09=09} else if (n<128) { +=09=09=09printf("Warning reading file pid.bin: only %d/128 bytes loaded\n"= , n); +=09=09} +=09=09close(PID_fd); +=09} +=09if (PID_fd<0) { +=09=09/* Built in eeprom */ +=09=09printf("Warning using builtin pid content!\n"); +=09=09PID_content[2]=09=3D 4; /* Magic word, use sdram */ +=09=09PID_content[3]=09=3D 12; /* Row word, use sdram */ +=09=09PID_content[4]=09=3D 10; /* Col word, use sdram */ +=09=09PID_content[5]=09=3D 1; /* 1 bank */ +=09=09PID_content[6]=09=3D 32; /* Module width */ +=09=09PID_content[31]=09=3D 0x10; /* How many 4MB is long */ +=09=09PID_content[127]=3D 0 | 2 /* Cas latency */; +=09} + +=09readF =3D &PID_read; +=09writeF =3D &PID_write; + } + /* allocate SRAM */ +#ifdef DEBUG_BOARD_INIT + printf("%s: register SRAM at offset %08lx\n", __func__, sram_offset); +#endif + /* Last 48 (max 128) bytes) used for bd info */ + sram_size =3D 8 * 1024; + cpu_register_physical_memory(0x40000000, sram_size, + sram_offset | IO_MEM_RAM); + /* allocate and load BIOS */ +#ifdef DEBUG_BOARD_INIT + printf("%s: register BIOS\n", __func__); +#endif + bios_offset =3D sram_offset + sram_size; + fl_idx =3D 0; +#ifdef USE_FLASH_BIOS + index =3D drive_get_index(IF_PFLASH, 0, fl_idx); + if (index !=3D -1) { + bios_size =3D bdrv_getlength(drives_table[index].bdrv); + fl_sectors =3D (bios_size + 65535) >> 16; +#ifdef DEBUG_BOARD_INIT + printf("Register parallel flash %d size " ADDRX " at offset %08lx = " + " addr " ADDRX " '%s' %d\n", + fl_idx, bios_size, bios_offset, -bios_size, + bdrv_get_device_name(drives_table[index].bdrv), fl_sectors)= ; +#endif + pflash_cfi02_register((uint32_t)(-bios_size), bios_offset, + drives_table[index].bdrv, 65536, fl_sectors,= 1, + 2, 0x0001, 0x22DA, 0x0000, 0x0000, 0x555, 0x= 2AA); + fl_idx++; + } else +#endif + { + char buf[1024]; + ram_addr_t flash_offset; +=09target_ulong flash_size; +=09 +=09flash_offset =3D bios_offset; +=09flash_size =3D 512*1024; +#ifdef DEBUG_BOARD_INIT + printf("Load BIOS from file\n"); +#endif + if (bios_name =3D=3D NULL) + bios_name =3D BIOS_FILENAME; + snprintf(buf, sizeof(buf), "%s/%s", bios_dir, bios_name); + bios_size =3D get_image_size(buf); + if (bios_size < 0 || bios_size > BIOS_SIZE) { + fprintf(stderr, "qemu: could not load PowerPC bios '%s'\n", bu= f); + exit(1); + } + bios_size =3D (bios_size + 0xfff) & ~0xfff; +#ifdef DEBUG_BOARD_INIT + printf("Loading bios@" ADDRX " %d bytes\n", (uint32_t)(-bios_size)= , bios_size); +#endif +#if 1 + pflash_cfi02_register((uint32_t)(-flash_size), flash_offset, + NULL, 65536 /*sector len*/, flash_size/65536= /* nblocks */, 1, + 1 /* width */, 0x0001/* AMD */, 0x4F/* Am29L= V040B */, 0x0000, 0x0000, 0x555/* unlock addrs */, 0x2AA); +#else + cpu_register_physical_memory((uint32_t)(-flash_size), + flash_size, flash_offset | IO_MEM_ROM= ); +#endif + + bios_size =3D load_image_targphys(buf, (-bios_size), BIOS_SIZE/* m= ax sz */); + if (bios_size < 0 || bios_size > BIOS_SIZE) { + fprintf(stderr, "qemu: could not load PowerPC bios '%s'\n", bu= f); + exit(1); + } +=09bios_size =3D flash_size; + } + bios_offset +=3D bios_size; + /* Register FPGA */ +#ifdef DEBUG_BOARD_INIT + printf("%s: register FPGA\n", __func__); +#endif + ref405ep_fpga_init(0xF0300000); + /* Register NVRAM */ +#ifdef DEBUG_BOARD_INIT + printf("%s: register NVRAM\n", __func__); +#endif + m48t59_init(NULL, 0xF0000000, 0, 8192, 8); + /* Load kernel */ + linux_boot =3D (kernel_filename !=3D NULL); + if (0) { +#ifdef DEBUG_BOARD_INIT + printf("%s: load kernel\n", __func__); +#endif + memset(&bd, 0, sizeof(bd)); + bd.bi_memstart =3D 0x00000000; + bd.bi_memsize =3D ram_size; + bd.bi_flashstart =3D -bios_size; + bd.bi_flashsize =3D -bios_size; + bd.bi_flashoffset =3D 0; + bd.bi_sramstart =3D 0xFFF00000; + bd.bi_sramsize =3D sram_size; + bd.bi_bootflags =3D 0; + bd.bi_intfreq =3D 133333333; + bd.bi_busfreq =3D 33333333; + bd.bi_baudrate =3D 115200; + bd.bi_s_version[0] =3D 'Q'; + bd.bi_s_version[1] =3D 'M'; + bd.bi_s_version[2] =3D 'U'; + bd.bi_s_version[3] =3D '\0'; + bd.bi_r_version[0] =3D 'Q'; + bd.bi_r_version[1] =3D 'E'; + bd.bi_r_version[2] =3D 'M'; + bd.bi_r_version[3] =3D 'U'; + bd.bi_r_version[4] =3D '\0'; + bd.bi_procfreq =3D 133333333; + bd.bi_plb_busfreq =3D 33333333; + bd.bi_pci_busfreq =3D 33333333; + bd.bi_opbfreq =3D 33333333; + bdloc =3D ppc405_set_bootinfo(env, &bd, 0x00000001); + env->gpr[3] =3D bdloc; + kernel_base =3D KERNEL_LOAD_ADDR; + /* now we can load the kernel */ + kernel_size =3D load_image(kernel_filename, phys_ram_base + kernel= _base); + if (kernel_size < 0) { + fprintf(stderr, "qemu: could not load kernel '%s'\n", + kernel_filename); + exit(1); + } + printf("Load kernel size " TARGET_FMT_ld " at " TARGET_FMT_lx + " %02x %02x %02x %02x\n", kernel_size, kernel_base, + *(char *)(phys_ram_base + kernel_base), + *(char *)(phys_ram_base + kernel_base + 1), + *(char *)(phys_ram_base + kernel_base + 2), + *(char *)(phys_ram_base + kernel_base + 3)); + /* load initrd */ + if (initrd_filename) { + initrd_base =3D INITRD_LOAD_ADDR; + initrd_size =3D load_image(initrd_filename, + phys_ram_base + initrd_base); + if (initrd_size < 0) { + fprintf(stderr, "qemu: could not load initial ram disk '%s= '\n", + initrd_filename); + exit(1); + } + } else { + initrd_base =3D 0; + initrd_size =3D 0; + } + env->gpr[4] =3D initrd_base; + env->gpr[5] =3D initrd_size; + ppc_boot_device =3D 'm'; + if (kernel_cmdline !=3D NULL) { + len =3D strlen(kernel_cmdline); + bdloc -=3D ((len + 255) & ~255); + memcpy(phys_ram_base + bdloc, kernel_cmdline, len + 1); + env->gpr[6] =3D bdloc; + env->gpr[7] =3D bdloc + len; + } else { + env->gpr[6] =3D 0; + env->gpr[7] =3D 0; + } + env->nip =3D KERNEL_LOAD_ADDR; + } else { + env->nip =3D 0xFFFFFFFC; + } +#ifdef DEBUG_BOARD_INIT + printf("%s: Done\n", __func__); +#endif + /*printf("bdloc %016lx %s\n", + (unsigned long)bdloc, (char *)(phys_ram_base + bdloc));*/ +} +QEMUMachine walnut_machine =3D { + .name =3D "walnut", + .desc =3D "DHT Walnut board, based on ppc405GPe", + .init =3D walnut_init, + .ram_require =3D (128 * 1024 * 1024 + 4096 + 512 * 1024 + BIOS_SIZE) |= RAMSIZE_FIXED, +}; + /*************************************************************************= ****/ /* AMCC Taihu evaluation board */ /* - PowerPC 405EP processor @@ -530,7 +872,7 @@ #ifdef DEBUG_BOARD_INIT printf("%s: register cpu\n", __func__); #endif - env =3D ppc405ep_init(ram_bases, ram_sizes, 33333333, &pic, &bios_offs= et, + env =3D ppc405xp_init("405ep", ram_bases, ram_sizes, 33333333, &pic, &= bios_offset, kernel_filename =3D=3D NULL ? 0 : 1); /* allocate and load BIOS */ #ifdef DEBUG_BOARD_INIT Index: hw/emac.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/emac.c=09(revision 0) +++ hw/emac.c=09(revision 0) @@ -0,0 +1,797 @@ +/* + * QEMU EMAC emulation + * + * Copyright (c) 2008, Lionetti Salvatore salvatorelionetti@yahoo.it + * + * Permission is hereby granted, free of charge, to any person obtaining a= copy + * of this software and associated documentation files (the "Software"), t= o deal + * in the Software without restriction, including without limitation the r= ights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or se= ll + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included= in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS= OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY= , + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OT= HER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING= FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN + * THE SOFTWARE. + */ + +/* This module provide an emulation for ethernet onchip controller on ppc4= xx cpu. + * Tested on + * - emulator of a NSN proprietary board, for 4G + * - walnut board/u-boot-1.1.6 (whith some patch) + * + * TODO: + * - >1 {tx, rx} channel=20 + * - can_receive() and buffer_full() too simple. + */ +#include "hw.h" +#include "ppc.h" +#include "ppc405.h" +#include "pc.h" +#include "qemu-timer.h" +#include "sysemu.h" +#include "net.h" + +/*#define DEBUG_EMAC*/ +#ifdef DEBUG_EMAC +#define DPRINT(fmt, args...) \ + do { printf("%" PRIu64 " %s: " fmt , qemu_get_clock(rt_clock), __func_= _, ##args); } while (0) +#else +#define DPRINT(fmt, args...) +#endif=20 + +/*=20 + * Redefined because if !exist, linker gives a warning but produce qemu, + * but on execution this call cause problem + * (could be cygwin & mingw cohesistence?) + */ +#if (defined(WORDS_BIGENDIAN) && defined(TARGET_WORDS_BIGENDIAN)) || ((!de= fined(WORDS_BIGENDIAN) && !defined(TARGET_WORDS_BIGENDIAN))) +#if 0 +static unsigned long int htonl(unsigned long int hostlong); +static unsigned short int htons(unsigned short int hostshort); +#endif +static unsigned long int ntohl(unsigned long int ing) { +=09return ing; +} +static unsigned short int ntohs(unsigned short int ing) { +=09return ing; +} +#else +static unsigned long int ntohl(unsigned long int ing) { +=09unsigned char tmp; +=09unsigned char* tmpp =3D (unsigned char*)&ing; +=09tmp=3Dtmpp[0]; tmpp[0]=3Dtmpp[3]; tmpp[3]=3Dtmp; +=09tmp=3Dtmpp[1]; tmpp[1]=3Dtmpp[2]; tmpp[2]=3Dtmp; +=09return *(unsigned long int*)tmpp; +} +static unsigned short int ntohs(unsigned short int ing) { +=09return ((ing&0xFF)<<8) | ((ing&0xFF00)>>8); +} +#endif + +/* qemu initialization: + * + * parse command line:=09call net_client_init() for each -net, either for = {if, collision domain} options. + * =09=09=09=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=09=09=09=09=09=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + * =09=09=09IF MAC=3D...=09<=3D=3D=3D=3D Vlan{Id,Ptr} =3D=3D=3D=3D>=09COLL= ISION DOMAIN (mean N-1 other IF MAC=3D...) + * =09=09=09=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =09=09=09=09=09=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + * =09=09=09=09-net nic[,...]:=09fill field onto nd_table[] {MAC(cl|auto),= model, vlanPtr=3Df(vlanId)} + * =09=09=09=09=09=09vlanPtr=3Df(vlanId)->guest++ + * =09=09=09=09-net tap[,...]: vlanPtr=3Df(vlanId)->host ++ + * =09=09=09=09=09=09tap_win32_init(vlanPtr, "ifname=3Dtap..."): + * =09=09=09=09=09=09=09qemu_new_vlan_client(vlanPtr,tap_receive, tap* opa= que)=09=09RECV + * =09=09=09=09=09=09=09qemu_add_wait_object(tap_sem, tap_w32_send, tap* o= paque)=09SEND + * =09=09=09 + * =09=09=09For each vlan created, + * =09=09=09=09exit if no GUEST & some HOST + * =09=09=09=09warn if some GUEST & no HOST + * =09=09=09=09=09=09=09=09=09=09=09 =20 + * start machine:=09Es ppc (also pc use n2000) call machine->init(): + * =09=09=09isa_ne2000_init(base, irqno, &nd_table[i]) + * =09=09=09=09register_ioport_write(base + ..., ne2000_asic_ioport_write,= opaque NE2000State*);=09SEND + * =09=09=09=09qemu_new_vlan_client(nd->vlan, ne2000_receive, ne2000_can_r= eceive, opaque NE2000State*) RECV + * + * Done!!! + * + * qemu runtime scenario: + * + * packet send from HOST:=09a signal (after exec() cycle) is sent to tap_s= em =3D> tap_w32_send() =3D> tap_win32_read() + * =09=09=09=09if some bytes returned =3D> qemu_send_packet() =3D> send to= all 'client' (better peer) of + * =09=09=09=09such vlan, different from itself =3D> ne2000_receive() + * + * packet send from GUEST:=09in machine code we call qemu_send_packet() = =3D> (prec) =3D> tap_receive() =3D> tap_w32_write() + * + * + * So onto VLAN actors always call qemu_send_packet() that dispatch packet= to all peer attached to same vlan. + * + */ +/* PPC405 layer 2, reversed MII mode: + * + * Register@0xEF600000 already mapped. + * Configuration RW: + * + * Read(ind, data): + * =09[EMAC0_STACR] <=3D (STACR_STAC_R | ind) + *=09[EMAC0_STACR] & STACR_OC must goes to 0 + *=09[EMAC0_STACR] =3D> >>16 =3D> data + * + * Write(ind, data) + * =09[EMAC0_STACR] <=3D (STACR_STAC_W | ind | data<<16) + * =09[EMAC0_STACR] & STACR_OC must goes to 0 + * + * Physical access: + * Read(ind_phy, ind_reg, data) + * =09[EMAC0_STACR] <=3D (STACR_STAC_W | TANTOS_REG_MIIAC | (ind_reg&0x1F = | OP_READ | (ind_phy&0x1F)<<5))>>16 + * =09[EMAC0_STACR] & STACR_OC must goes to 0 + *=09 + *=09Verify: + *=09[EMAC0_STACR] <=3D (STACR_STAC_R | TANTOS_REG_MIIRD) + * =09[EMAC0_STACR] & STACR_OC must goes to 0 + * =09[EMAC0_STACR] =3D> data + * =09data & STACR_PHYE should be 0 + * =09data=3Ddata>>16 + * + * Tantos Stub Layer: (needed?) + * + * From mal we need + * - MAL0_TXCTPxR + * - MAL0_RXCTPxR + * - MAL0_RCBS0 + */ +/* TODO: need interaction between device! + * very difficult since all struct is in .c file */ +extern uint32_t txctpr[4]; +extern uint32_t rxctpr[2]; +extern uint32_t rcbs[2]; +extern uint32_t *rxeobisr; /* With namespace, use & to automatize correlat= ion.*/ +extern uint32_t *txeobisr; +// For PPC405 +#define EMAC0_BASE 0xEF600800 +#define EMAC0_STACR_DISP 0x35 +#define EMAC0_STACR (EMAC0_BASE + EMAC0_STACR_DISP) /* 4 byte address= ing */ +#define STACR_OC 0x00008000 /* Occupied flag */ +#define STACR_PHYE 0x00004000 +#define STACR_STAC_W 0x00002000 +#define STACR_STAC_R 0x00001000 + +#define TANTOS_REG_MIIAC 0x120 /// TANTOS3G MII indirect acess reg= isters +#define TANTOS_REG_MIIWD 0x121 +#define TANTOS_REG_MIIRD 0x122 +#define OP_WRITE=090x0400 +#define OP_READ=09=090x0800 +#define MBUSY =09=090x8000 + +/* WORDS_BIGENDIAN =3D FALSE su HOST i386, GUEST ppc + * per cui e' l'architetura HOST + */ +struct EmacMalRxDes { +#ifndef WORDS_BIGENDIAN + union { +=09 struct { /* Mal */ +=09=09 unsigned int emac1_nu=09: 2; +=09=09 unsigned int bit5_intr=09: 1; +=09=09 unsigned int bit4_first=09: 1; +=09=09 unsigned int bit3_last=09: 1; +=09=09 unsigned int bit2_contm=09: 1; +=09=09 unsigned int bit1_wrap=09: 1; +=09=09 unsigned int bit0_empty=09: 1; +=09=09 unsigned int emac2_nu=09: 8;=20 +=09 } __attribute__ ((packed)) mal; +=09 struct { /* Status: Read access, error cause */ +=09=09 unsigned int bit7_pausepacket=09: 1; +=09=09 unsigned int bit6_overrun=09=09: 1; +=09=09 unsigned int mal_nu=09=09=09: 6; +=09=09 unsigned int bit15_inrange=09=09: 1; +=09=09 unsigned int bit14_outrange=09=09: 1; +=09=09 unsigned int bit13_longpacket=09: 1; +=09=09 unsigned int bit12_fcs=09=09: 1; +=09=09 unsigned int bit11_alignment=09: 1; +=09=09 unsigned int bit10_shortevent=09: 1; +=09=09 unsigned int bit9_runtpacket=09: 1; +=09=09 unsigned int bit8_badpacket=09=09: 1; +=09 } __attribute__ ((packed)) emac_errstatus; + } __attribute__ ((packed)); +#else +#error "Host endianism BUG: To Test!!!" +#endif + unsigned short len; + unsigned char* buf; +} __attribute__ ((packed)); /* Host endianism, to be converted */ + +struct EmacMalTxDes { +#ifndef WORDS_BIGENDIAN + /* IN A HALF-WORD (16bits) + * position=09=09position + * in bitfield=09in value + * from high=09from MSb + * =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D + * 0=09=098 + * 1=09=099 + * 2=09=0910 + * 3=09=0911 + * 4=09=0912 + * 5=09=0913 + * 6=09=0914 + * 7=09=0915 + * 8=09=090 + * 9=09=091 + * 10=09=092 + * 11=09=093 + * 12=09=094 + * 13=09=095 + * 14=09=096 + * 15=09=097 + * + * =3D=3D=3DHOST LE, TARGET BE=3D=3D=3D + * IN A BYTE (8bits) + * + * IN A HALF-WORD (16bits) + * 0-7=09=098-15 + * 8-15=09=090-7 + */ + union { +=09 struct { /* Mal */ +=09=09 unsigned int emac1_nu=09: 2; +=09=09 unsigned int bit5_intr=09: 1; +=09=09 unsigned int bit4_resv=09: 1; +=09=09 unsigned int bit3_last=09: 1; +=09=09 unsigned int bit2_contm=09: 1; +=09=09 unsigned int bit1_wrap=09: 1; +=09=09 unsigned int bit0_ready=09: 1; +=09=09 unsigned int emac2_nu=09: 8;=20 +=09 } __attribute__ ((packed)) mal; +=09 struct { /* Status: Read access, error cause */ +=09=09 unsigned int bit7_badpacket=09=09: 1; +=09=09 unsigned int bit6_badfsc=09=09: 1; +=09=09 unsigned int mal_nu=09=09=09: 6; +=09=09 unsigned int bit15_sqe=09=09: 1; +=09=09 unsigned int bit14_underrun=09=09: 1; +=09=09 unsigned int bit13_singlecoll=09: 1; +=09=09 unsigned int bit12_multiplecoll=09: 1; +=09=09 unsigned int bit11_latecoll=09=09: 1; +=09=09 unsigned int bit10_excessivecoll=09: 1; +=09=09 unsigned int bit9_excessivedeferral : 1; +=09=09 unsigned int bit8_lossofcarrier=09: 1; +=09 } __attribute__ ((packed)) emac_errorstatus; +=09 struct { /* Control: Write access */ +=09=09 unsigned int bit7_generatepad=09: 1; +=09=09 unsigned int bit6_generatefcs=09: 1; +=09=09 unsigned int mal_nu=09=09=09: 6; +=09=09 unsigned int emac_nu=09=09: 4; +=09=09 unsigned int bit11_vlantag_replace=09: 1; +=09=09 unsigned int bit10_vlantag_insert=09: 1; +=09=09 unsigned int bit9_sourceaddr_insert=09: 1; +=09=09 unsigned int bit8_sourceaddr_replace: 1; +=09 } __attribute__ ((packed)) emac_control; + }; +#else +#error "Host endianism BUG: To Test!!!" +#endif + unsigned short len; + unsigned char* buf; +}__attribute__ ((packed)); /* Host endianism, to be converted */ + +/* Controlo Register definition */ +struct EmacRegs { +#if 0 +#ifndef WORDS_BIGENDIAN +=09struct Emac0_mr0 { +=09=09unsigned int ; +=09} __attribute__((packed));=20 +#else +#error "Host endianism BUG: To Test!!!" +#endif +#else +=09/* 0 */ +=09uint32_t mr0; +=09uint32_t mr1; +=09uint32_t tmr0; +=09uint32_t tmr1; +=09uint32_t rmr; +=09uint32_t isr; +=09uint32_t isre; +=09uint32_t iahr; +=09uint32_t ialr; +=09uint32_t vtpid; +=09/* 10 */ +=09uint32_t vtci; +=09uint32_t ptr; +=09uint32_t iaht1; +=09uint32_t iaht2; +=09uint32_t iaht3; +=09uint32_t iaht4; +=09uint32_t gaht1; +=09uint32_t gaht2; +=09uint32_t gaht3; +=09uint32_t gaht4; +=09/* 20 */ +=09uint32_t lsah; +=09uint32_t lsal; +=09uint32_t ipgvr; +=09uint32_t stacr; +=09uint32_t trtr; +=09uint32_t rwmr; +=09uint32_t octx; +=09uint32_t ocrx; +=09/* 28 reg */ + +#define RSTA mr0 & 0x20000000=20 +#define TXEN mr0 & 0x10000000=20 +#define RXEN mr0 & 0x08000000=20 +#endif=09 +} __attribute__ ((packed)); + +typedef struct ppc4xx_emac_t ppc4xx_emac_t; +struct ppc4xx_emac_t { + /* Guest related */ + target_phys_addr_t base; + NICInfo nic; + /* To remove, already defined in mal */ + qemu_irq mal_irqs_txeob; + qemu_irq mal_irqs_rxeob; + qemu_irq mal_irqs_txerr; + qemu_irq mal_irqs_rxerr; + qemu_irq mal_irqs_syserr; + + struct EmacRegs reg, _reg; + + struct EmacMalTxDes* tx; + struct EmacMalRxDes* rx; + + int txPos, rxPos; + int txNum, rxNum; + + int rxLostNum, rxLostLimit; + + /* Host related */ + VLANClientState *vc; + QEMUTimer* tx_timer; +}; + +#if 0 +#define EMACMAL_EMPTY 0x8000 +#define EMACMAL_WRAP 0x8000 +#define EMACMAL_EMPTY 0x8000 +#define EMACMAL_EMPTY 0x8000 +void EmacMalDes_readFromTarget(struct EmacMalDes* host, struct EmacMalDes*= guest) { + + host->status =3D ntohs(guest->status); + host->len =3D ntohs(guest->len); + host->buf =3D htol(guest->buf); +} +void EmacMalDes_writeToTarget(struct EmacMalDes* host, struct EmacMalDes* = guest) { +} +#endif +void EmacMalRxDes_dump(struct EmacMalRxDes* des) { +#ifdef DEBUG_EMAC +=09unsigned char* tdes =3D (unsigned char*) ((unsigned char*)des - phys_ra= m_base); +=09printf("RXdes@%p=3D{len%d,buf%p,empty%d wrap%d contm %d last%d first%d = intr%d\n", +=09=09=09tdes, ntohs(des->len), (unsigned char*) ntohl((unsigned long int)= des->buf), +=09=09=09des->mal.bit0_empty, des->mal.bit1_wrap, des->mal.bit2_contm, des= ->mal.bit3_last, des->mal.bit4_first, des->mal.bit5_intr); +#endif +} +void EmacMalTxDes_dump(struct EmacMalTxDes* des) { +#ifdef DEBUG_EMAC +=09unsigned char* tdes =3D (unsigned char*)((unsigned char*)des - phys_ram= _base); +=09printf("TXdes@%p=3D{len%d,buf%p,ready%d wrap%d contm %d last%d first%d = intr%d\n", +=09=09=09tdes, ntohs(des->len), (unsigned char*)ntohl((unsigned long int)d= es->buf), +=09=09=09des->mal.bit0_ready, des->mal.bit1_wrap, des->mal.bit2_contm, des= ->mal.bit3_last, des->mal.bit4_resv, des->mal.bit5_intr); +#endif +} +#if 0 +static int emac_buffer_full(ppc4xx_emac_t *s) +{ +#if 0 + int avail, index, boundary; + + index =3D s->curpag << 8; + boundary =3D s->boundary << 8; + if (index < boundary) + avail =3D boundary - index; + else + avail =3D (s->stop - s->start) - (index - boundary); + if (avail < (MAX_ETH_FRAME_SIZE + 4)) + return 1; +#endif + return 0; +} + +static int emac_can_receive(void *opaque) +{ +#if 0 + NE2000State *s =3D opaque; + + if (s->cmd & E8390_STOP) + return 1; + return !ne2000_buffer_full(s); +#endif + return 0; +} +#endif + + +static void emac_receive(void *opaque, const uint8_t *buf, int size) +{ + ppc4xx_emac_t* emac =3D (ppc4xx_emac_t*) opaque; + + DPRINT("%d bytes\n", size); + if (emac->reg.RXEN) { + if (emac->rx->buf) { + if (size<1520) { +=09 if (emac->rx[emac->rxPos].mal.bit0_empty) { +=09 /* data is allocated with the maximum possible length, on eth =3D 1= 520Bytes +=09 * len field represent packet size.*/ +=09=09 /* We !use Continuos mode, first & last field ignored */ +=09=09 unsigned char* dstG =3D (unsigned char*) ntohl((unsigned long in= t)emac->rx[emac->rxPos].buf); +=09=09 unsigned char* dstH=3D dstG+(unsigned int)phys_ram_base; +=09=09 unsigned short size16 =3D size; +=09=09 DPRINT(" Delivery message HOST %p-> GUEST %p,pos%d\n", dstH, dst= G, emac->rxPos); +=09=09 EmacMalRxDes_dump(&emac->rx[emac->rxPos]); +=09=09 emac->reg.ocrx +=3D size16; +=09=09 memcpy(dstH, buf, size);=09 +=09=09 emac->rx[emac->rxPos].len =3D ntohs(size16); +=09=09 emac->rx[emac->rxPos].mal.bit0_empty =3D 0; +=09=09 if (emac->rx[emac->rxPos].mal.bit5_intr) { +=09=09=09 /* TODO: use appropriate channel */ +=09=09=09 *rxeobisr =3D 0xC0000000; +=09=09=09 qemu_irq_raise(emac->mal_irqs_rxeob); +=09=09 } + +=09=09 emac->rxPos +=3D (emac->rx[emac->rxPos].mal.bit1_wrap)? -(emac->= rxPos) : 1; +=09 } else { +=09=09 if (++emac->rxLostNum =3D=3D emac->rxLostLimit) { +=09=09=09 printf(" %d Message lost, board seem hung up!\n", emac->rxLos= tNum); +=09=09=09 emac->rxLostLimit*=3D10; +=09=09 } +=09 } + } else { +=09 printf(" Message size > 1520, discarding packet\n"); + } + } else { + } + } else { +=09 static int sndOrMore=3D0; +=09 if (!sndOrMore) { +=09=09 printf("emac/mal: Driver !command start yet\n"); +=09=09 sndOrMore=3D1; +=09 } + } +#if 0 +#define MIN_BUF_SIZE 60 + NE2000State *s =3D opaque; + uint8_t *p; + unsigned int total_len, next, avail, len, index, mcast_idx; + uint8_t buf1[60]; + static const uint8_t broadcast_macaddr[6] =3D + { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; + +#if defined(DEBUG_NE2000) + printf("NE2000: received len=3D%d\n", size); +#endif + + if (s->cmd & E8390_STOP || ne2000_bufstruct mal_emac_bdfer_full(s)) + return; + + /* XXX: check this */ + if (s->rxcr & 0x10) { + /* promiscuous: receive all */ + } else { + if (!memcmp(buf, broadcast_macaddr, 6)) { + /* broadcast address */ + if (!(s->rxcr & 0x04)) + return; + } else if (buf[0] & 0x01) { + /* multicast */ + if (!(s->rxcr & 0x08)) + return; + mcast_idx =3D compute_mcast_idx(buf); + if (!(s->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7)))) + return; + } else if (s->mem[0] =3D=3D buf[0] && + s->mem[2] =3D=3D buf[1] && + s->mem[4] =3D=3D buf[2] && + s->mem[6] =3D=3D buf[3] && + s->mem[8] =3D=3D buf[4] && + s->mem[10] =3D=3D buf[5]) { + /* match */ + } else { + return; + } + } + + + /* if too small buffer, then expand it */ + if (size < MIN_BUF_SIZE) { + memcpy(buf1, buf, size); + memset(buf1 + size, 0, MIN_BUF_SIZE - size); + buf =3D buf1; + size =3D MIN_BUF_SIZE; + } + + index =3D s->curpag << 8; + /* 4 bytes for header */ + total_len =3D size + 4; + /* address for next packet (4 bytes for CRC) */ + next =3D index + ((total_len + 4 + 255) & ~0xff); + if (next >=3D s->stop) + next -=3D (s->stop - s->start); + /* prepare packet header */ + p =3D s->mem + index; + s->rsr =3D ENRSR_RXOK; /* receive status */ + /* XXX: check this */ + if (buf[0] & 0x01) + s->rsr |=3D ENRSR_PHY; + p[0] =3D s->rsr; + p[1] =3D next >> 8; + p[2] =3D total_len; + p[3] =3D total_len >> 8; + index +=3D 4; + + /* write packet data */ + while (size > 0) { + if (index <=3D s->stop) + avail =3D s->stop - index; + else + avail =3D 0; + len =3D size; + if (len > avail) + len =3D avail; + memcpy(s->mem + index, buf, len); + buf +=3D len; + index +=3D len; + if (index =3D=3D s->stop) + index =3D s->start; + size -=3D len; + } + s->curpag =3D next >> 8; + + /* now we can signal we have received something */ + s->isr |=3D ENISR_RX; + ne2000_update_irq(s); +#endif +} + +void emac_ppc405_init(ppc4xx_emac_t* emac, NICInfo *nd) +{ + memcpy(&emac->nic, nd, sizeof(NICInfo)); + /* We are only be able to receive. Sending packet mean receiver action= get up */ + emac->vc =3D qemu_new_vlan_client(nd->vlan, emac_receive, + NULL/*emac_can_receive*/, emac); + + snprintf(emac->vc->info_str, sizeof(emac->vc->info_str), + "emac macaddr=3D%02x:%02x:%02x:%02x:%02x:%02x", + emac->nic.macaddr[0], + emac->nic.macaddr[1], + emac->nic.macaddr[2], + emac->nic.macaddr[3], + emac->nic.macaddr[4], + emac->nic.macaddr[5]); + printf("%s\n", emac->vc->info_str); +} + +static void ppc4xx_emac_reset (void *opaque) +{ + ppc4xx_emac_t *emac; + + emac =3D opaque; + emac->rx =3D NULL; + emac->tx =3D NULL; + emac->txPos =3D emac->rxPos =3D 0; + emac->txNum =3D emac->rxNum =3D 0; + emac->rxLostNum=3D0; + emac->rxLostLimit=3D1; + + memset(&emac->reg, 0, sizeof(emac->reg)); + emac->reg.mr0 =3D 0xC0000000; + emac->reg.tmr1 =3D 0x380F0000; + emac->reg.vtpid =3D 0x00008808; + emac->reg.ptr =3D 0x0000FFFF; + emac->reg.ipgvr =3D 0x00000004; + emac->reg.stacr =3D 0x00008000; + emac->reg.rwmr =3D 0x04001000; + + /* Now ready to issue mii control transfer */ + emac->reg.stacr =3D 0; +} +/* It looks like a lot of Linux programs assume page size + * is 4kB long. This is evil, but we have to deal with it... + * +#define TARGET_PAGE_BITS 12 + * Here we have many register. + * Do action only for reset or transmit command. + * Other will be simple configuration latched during device emulation + * es stop rx, allow pause packet. + * + * Another tip: + * When possible only implemente the read of value, since using var read/w= rite is target indep + */ +static uint32_t emac_readl (void *opaque, target_phys_addr_t addr) +{ +=09uint32_t value; +=09ppc4xx_emac_t* emac =3D (ppc4xx_emac_t*)opaque; +=09uint32_t ind =3D (addr-emac->base)>>2; +=09/* Keep in a separate way, as stackable code */ +=09if (ind>=3D28) { +=09=09printf("emac: Out of range register %d!\n", ind); +=09=09return 0; +=09} +=09value =3D ((uint32_t*)&emac->reg)[ind]; +=09DPRINT("emac: [%d] =3D> %x\n", ind, value); +=09return value/*STACR_OC*/; +} + +static void emac_writel (void *opaque, target_phys_addr_t addr, uint32_t v= alue) +{ +=09ppc4xx_emac_t* emac =3D (ppc4xx_emac_t*)opaque; +=09uint32_t ind =3D (addr-emac->base)>>2; + +/*=09printf("%s: " PADDRX " val %x\n",__func__, addr, value);*/ +=09/* Exist some common code for this? */ +=09if (ind>=3D28) { +=09=09printf("emac: Out of range register %d!\n", ind); +=09=09return; +=09} +=09switch (ind) { +=09=09case 20: +=09=09case 21: +=09=09case 26: +=09=09case 27: +=09=09=09printf("emac: Attemping to write to read only reg!"); +=09=09=09return; +=09} +=09DPRINT("emac: [%d] <=3D %x\n", ind, value); +=09/* Keep in a separate way, as stackable code */ +=09((uint32_t*)&emac->reg)[ind] =3D value; +=09if (ind=3D=3D0) { +=09=09emac->_reg.mr0 =3D value; +=09=09/* soft reset */ +=09=09if (emac->_reg.RSTA) { +=09=09=09printf("emac: soft reset commanded!\n"); +=09=09=09ppc4xx_emac_reset(emac);/* Should be protected with a semaphore, = also in emac_receive()? */ +=09=09=09value &=3D ~(emac->_reg.RSTA);=09/* Sw look for this bit go down = */ +=09=09} + +=09=09DPRINT("emac: St%s tx channel!\n", emac->_reg.TXEN?"arting":"opping"= ); +=09=09DPRINT("emac: St%s rx channel!\n", emac->_reg.RXEN?"arting":"opping"= ); + +=09=09/* Suppose the mal reg was updated, seem a good approximation */ +=09=09if (emac->_reg.TXEN && emac->tx=3D=3DNULL) { +=09=09=09int l=3D0; +=09=09=09emac->tx =3D (struct EmacMalTxDes*) (txctpr[0] + phys_ram_base); +=09=09=09do { EmacMalTxDes_dump(&emac->tx[l]); } while (!emac->tx[l].mal.b= it1_wrap && l++<50); +=09=09} +=09=09if (emac->_reg.RXEN && emac->rx=3D=3DNULL) { +=09=09=09int l=3D0; +=09=09=09emac->rx =3D (struct EmacMalRxDes*) (rxctpr[0] + phys_ram_base); +=09=09=09do { EmacMalRxDes_dump(&emac->rx[l]); } while (!emac->rx[l].mal.b= it1_wrap && l++<50); +=09=09} +=09=09/* A timer that periodically check packet to send=20 +=09=09emac->tx_timer =3D qemu_new_timer();*/ +=09} +=09if (ind=3D=3D2) { +=09=09if (value & 0xC0000000) { /* both channel */ +=09=09=09if (emac->reg.TXEN) { +=09=09=09if (emac->tx[emac->txPos].mal.bit0_ready) { +=09=09=09=09unsigned char* dstG =3D (unsigned char*) ntohl((unsigned long = int)emac->tx[emac->txPos].buf); +=09=09=09=09unsigned char* dstH=3D dstG+(unsigned int)phys_ram_base; +=09=09=09=09unsigned short size16 =3D ntohs(emac->tx[emac->txPos].len); + +=09=09=09=09DPRINT("Sending packet on pos %d\n", emac->txPos); +=09=09=09=09qemu_send_packet(emac->vc, dstH, size16); +=09=09=09=09emac->reg.octx +=3D size16; +=09=09=09=09if (emac->tx[emac->txPos].mal.bit5_intr) { +=09=09=09=09=09/* TODO: use appropriate channel */ +=09=09=09=09=09*txeobisr =3D 0xC0000000; +=09=09=09=09=09qemu_irq_raise(emac->mal_irqs_txeob); +=09=09=09=09} + +=09=09=09=09/* Clear status */ +=09=09=09=09emac->tx[emac->txPos].mal.bit0_ready =3D 0; +=09=09=09=09/* 0x808 is stucked at STACR_OC */ +=09=09=09=09emac->txPos +=3D (emac->tx[emac->txPos].mal.bit1_wrap)? -(emac= ->txPos) : 1; + +=09=09=09=09/*=20 +=09=09=09=09 * u-boot driver (no os=3D>no task) poll this bit until became= 0, +=09=09=09=09 * but in PPC405GPr User manual nothing said about this +=09=09=09=09 */ +=09=09=09=09value &=3D ~0xC0000000; +=09=09=09} else {printf("Processor goes crazy(ready bit was 0)!!! Stopping= tx\n");} +=09=09=09} else {DPRINT("Tx is disabled\n");} +=09=09} +=09} +=09if (ind=3D=3D23) { +=09=09/* PPC405GPr_UM2004 say, on page 568: +=09=09 * 'EMAC sets EMAC0_STACR[OC] =3D 0 when the EMAC0_STACR is written = to.' +=09=09 * 'EMAC then sets EMAC0_STACR[OC] =3D 1 to indicate that the data h= as been written to the PHY, or the data' +=09=09 * 'read from the PHY is valid. The device driver should poll for EM= AC0_STACR[OC] =3D 1 before issuing a new' +=09=09 * 'command, or before using data read from the PHY' +=09=09 *=20 +=09=09 * our approximation: +=09=09 * - initial condition=09=09=090 +=09=09 * - write(sw start some MII command)=091 (we end in the same cycle) +=09=09 * - read(poll status)=09=09=091 +=09=09 * - write(sw start new cmd | ...)=090 +=09=09 * +=09=09 * reg write clear (bit index is opposite then those reported by off= icial manual) +=09=09 * PHYD=09bit 31:16=09Data (RW) +=09=09 * OC=09bit 15=09=090 when this reg is addressed, 1 data written to = PHY/data readed correctly from PHY +=09=09 * PHYE=09bit 14=09=091 PhyError during read +=09=09 * STAC bit 13:12=0900 Reserved/01 Read/10 Write/11 Reserved +=09=09 * OPBC=09bit 11:10=09OPB Bus clock freq. signal EMCMDCIk +=09=09 * PCDA=09bit 9:5=09=09PHY Command destination address +=09=09 * PRA=09bit 4:0=09=09PHY Register address +=09=09 * +=09=09value &=3D ~(1<<15);*/ +=09=09value ^=3D (1<<15); +=09=09value &=3D ~(1<<14); +=09} +=09/* Keep in a separate way, as stackable code */ +=09((uint32_t*)&emac->reg)[ind] =3D value; +} +static uint32_t emac_readw (void *opaque, target_phys_addr_t addr) +{ +=09printf("Lettura a granularita' word su EMAC " PADDRX "\n",addr); +=09return 0; +} + +static void emac_writew (void *opaque, target_phys_addr_t addr, uint32_t v= alue) +{ +=09printf("Scrittura a granularita' word su EMAC " PADDRX "\n",addr); +} + +static uint32_t emac_readb (void *opaque, target_phys_addr_t addr) +{ +=09printf("Lettura a granularita' byte su EMAC " PADDRX "\n",addr); +=09return 0; +} + +static void emac_writeb (void *opaque, target_phys_addr_t addr, uint32_t v= alue) +{ +=09printf("Scrittura a granularita' byte su EMAC " PADDRX "\n",addr); +} + + +static CPUReadMemoryFunc *emac_read[] =3D { + &emac_readb, + &emac_readw, + &emac_readl, +}; + +static CPUWriteMemoryFunc *emac_write[] =3D { + &emac_writeb, + &emac_writew, + &emac_writel, +}; +void ppc4xx_emac_init (CPUState *env, ppc4xx_mmio_t *mmio, target_phys_add= r_t offset, NICInfo *nic, qemu_irq mal_irqs[4]) +{ + ppc4xx_emac_t *emac; + + emac =3D qemu_mallocz(sizeof(ppc4xx_emac_t)); + if (emac !=3D NULL) { + emac->base =3D offset; +#ifdef DEBUG_OPBA + printf("%s: offset " PADDRX "\n", __func__, offset); +#endif + ppc4xx_mmio_register(env, mmio, offset, 0x70, + emac_read, emac_write, emac); + qemu_register_reset(ppc4xx_emac_reset, emac); + +=09/* One time configuration, HOST related */ +=09emac_ppc405_init(emac, nic); + +=09emac->mal_irqs_txeob =3D mal_irqs[0]; +=09emac->mal_irqs_rxeob =3D mal_irqs[1]; +=09emac->mal_irqs_txerr =3D mal_irqs[2]; +=09emac->mal_irqs_rxerr =3D mal_irqs[3]; + +=09/* N Time configuration, GUEST related */ + ppc4xx_emac_reset(emac); + } +} Index: hw/pflash_cfi02.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/pflash_cfi02.c=09(revision 5720) +++ hw/pflash_cfi02.c=09(working copy) @@ -2,6 +2,7 @@ * CFI parallel flash with AMD command set emulation * * Copyright (c) 2005 Jocelyn Mayer + * Copyright (c) 2008 Lionetti Salvatore * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -22,7 +23,7 @@ * For now, this code can emulate flashes of 1, 2 or 4 bytes width. * Supported commands/modes are: * - flash read - * - flash write + * - flash write (also buffer mode) * - flash ID read * - sector erase * - chip erase @@ -34,14 +35,20 @@ * It does not implement software data protection as found in many real ch= ips * It does not implement erase suspend/resume commands * It does not implement multiple sectors erase + * + * Revisione done to optimize, (the next'll be mmap()), expecially for Wri= teBufferLoad command. + * Use different name for structure, so multiple device could be handed@sa= me time */ =20 #include "hw.h" #include "flash.h" #include "qemu-timer.h" #include "block.h" +#include "cpu-all.h" /* To have FLASH_LOG_CFI */ +#include "exec-all.h" /* To have loglevel */ =20 -//#define PFLASH_DEBUG +#define USE_SIMPLE_TABLE +/*#define PFLASH_DEBUG*/ #ifdef PFLASH_DEBUG #define DPRINTF(fmt, args...) \ do { \ @@ -51,7 +58,8 @@ #define DPRINTF(fmt, args...) do { } while (0) #endif =20 -struct pflash_t { +#define pflash_cfi02_t pflash_t +struct pflash_cfi02_t { BlockDriverState *bs; target_phys_addr_t base; uint32_t sector_len; @@ -60,18 +68,30 @@ int width; int wcycle; /* if 0, the flash is read normally */ int bypass; + uint32_t bytes2write; /* In buffer load mode, must remember the number= of bytes to elaborate */ + uint8_t buffer_loading; /* For buffer load mode 1 mean read nword-1 & = apply write & apply end command */ + uint32_t buffer_loading_start; + uint32_t buffer_loading_end; int ro; uint8_t cmd; uint8_t status; uint16_t ident[4]; uint16_t unlock_addr[2]; uint8_t cfi_len; - uint8_t cfi_table[0x52]; + uint8_t cfi_table[0x80]; QEMUTimer *timer; ram_addr_t off; int fl_mem; int rom_mode; void *storage; +#if 0 + /* Layer needed to optimize (driver common size) Vs (device common siz= e) + * Used by timer() & update(), update() use SIGNED!!! + * A simple way to represent a list of number. */ + int pendingW; + int fstSector; + int curSector; +#endif }; =20 static void pflash_register_memory(pflash_t *pfl, int rom_mode) @@ -88,9 +108,41 @@ pfl->chip_len, phys_offset); } =20 +static void pflash_cfi02_core_reset (void *opaque) { + struct pflash_cfi02_t *pfl =3D (struct pflash_cfi02_t*)opaque; + + pfl->bypass =3D 0; + pfl->wcycle =3D 0; + pfl->cmd =3D 0; + pfl->status =3D 0; + + pfl->bytes2write =3D 0; + pfl->buffer_loading =3D 0; + pfl->buffer_loading_start =3D 0; + pfl->buffer_loading_end =3D 0; + +/* pfl->pendingW =3D pfl->fstSector =3D curSector =3D 0; Lost current w= rite? */ + =20 + pflash_register_memory(pfl, 1); +} + +static void pflash_cfi02_reset (void *opaque) { + struct pflash_cfi02_t *pfl =3D (struct pflash_cfi02_t*)opaque; + + qemu_del_timer(pfl->timer); +#if 0 /* XXX: there should be a bit to set up read-only, + * the same way the hardware does (with WP pin). + */ + pfl->ro =3D 1; +#else + pfl->ro =3D 0; +#endif + pflash_cfi02_core_reset(pfl); + printf("Resetting cfi chip!\n"); +} static void pflash_timer (void *opaque) { - pflash_t *pfl =3D opaque; + struct pflash_cfi02_t *pfl =3D opaque; =20 DPRINTF("%s: command %02x done\n", __func__, pfl->cmd); /* Reset flash */ @@ -104,13 +156,12 @@ pfl->cmd =3D 0; } =20 -static uint32_t pflash_read (pflash_t *pfl, uint32_t offset, int width) +static uint32_t pflash_read (struct pflash_cfi02_t *pfl, uint32_t offset, = int width) { - uint32_t boff; + uint32_t boff, _boff; uint32_t ret; uint8_t *p; =20 - DPRINTF("%s: offset " TARGET_FMT_lx "\n", __func__, offset); ret =3D -1; offset -=3D pfl->base; if (pfl->rom_mode) { @@ -119,7 +170,7 @@ pflash_register_memory(pfl, 1); } offset &=3D pfl->chip_len - 1; - boff =3D offset & 0xFF; + boff =3D _boff =3D offset & 0xFF; if (pfl->width =3D=3D 2) boff =3D boff >> 1; else if (pfl->width =3D=3D 4) @@ -136,32 +187,34 @@ flash_read: /* Flash area read */ p =3D pfl->storage; + p +=3D offset; +common_read: switch (width) { case 1: - ret =3D p[offset]; + ret =3D p[0]; // DPRINTF("%s: data offset %08x %02x\n", __func__, offset, ret= ); break; case 2: #if defined(TARGET_WORDS_BIGENDIAN) - ret =3D p[offset] << 8; - ret |=3D p[offset + 1]; + ret =3D p[0] << 8; + ret |=3D p[1]; #else - ret =3D p[offset]; - ret |=3D p[offset + 1] << 8; + ret =3D p[0]; + ret |=3D p[1] << 8; #endif // DPRINTF("%s: data offset %08x %04x\n", __func__, offset, ret= ); break; case 4: #if defined(TARGET_WORDS_BIGENDIAN) - ret =3D p[offset] << 24; - ret |=3D p[offset + 1] << 16; - ret |=3D p[offset + 2] << 8; - ret |=3D p[offset + 3]; + ret =3D p[0] << 24; + ret |=3D p[1] << 16; + ret |=3D p[2] << 8; + ret |=3D p[3]; #else - ret =3D p[offset]; - ret |=3D p[offset + 1] << 8; - ret |=3D p[offset + 2] << 16; - ret |=3D p[offset + 3] << 24; + ret =3D p[0]; + ret |=3D p[1] << 8; + ret |=3D p[2] << 16; + ret |=3D p[3] << 24; #endif // DPRINTF("%s: data offset %08x %08x\n", __func__, offset, ret= ); break; @@ -199,16 +252,81 @@ break; case 0x98: /* CFI query mode */ - if (boff > pfl->cfi_len) + if (_boff > pfl->cfi_len) ret =3D 0; - else - ret =3D pfl->cfi_table[boff]; + else { +#ifndef=09USE_SIMPLE_TABLE + ret =3D pfl->cfi_table[_boff]; +#else +=09 p =3D &pfl->cfi_table[_boff]; +=09 goto common_read; +#endif +=09} break; } =20 + DPRINTF("%s: offset " TARGET_FMT_lx " value 0x%x width %d func %x\n", = __func__, _boff, ret, width, pfl->cmd); return ret; } =20 +#if 0 +/*=20 + * update flash content on disk=20 + * Act as intermediate between + * - 32B from Driver=20 + * - 512B of device + * Optimize only when length=3D=3D32 & Write only when sector is crossed + * Need a timer that commit if no more write? No if we write every 512B + * RAM is always updated=20 + */ +#define PFLASH_512BLOCK 8=09/* 0 -> sector of 512B, 1 -> sector of 1024B, = ... */ +#define PFLASH_XBLOCK=09(9 + PFLASH_512BLOCK) +#define PFLASH_XBOUND=09((1 << PFLASH_XBLOCK)-1) +static inline void pflash_update(struct pflash_cfi02_t *pfl, int offset, + int size) +{ +=09int offset_end; +=09int grouped =3D 0; /* Current version is linked with internal cache */ +=09int forcefl =3D 0; /* Force flush after all op */ + +=09if (pfl->bs) { +=09=09int _offset =3D offset; +=09=09offset =3D offset >> PFLASH_XBLOCK; + +=09=09/* Try to group sequential write +=09=09 * Stop also if found a sector bound! (so avoid timer for now) */ +=09=09if (size =3D=3D 32) { +=09=09=09forcefl =3D (((_offset+size)&PFLASH_XBOUND/*511*/)=3D=3D0); +=09=09=09if (pfl->pendingW) { +=09=09=09=09/* Try to group with previous write() */ +=09=09=09=09grouped =3D (offset =3D=3D pfl->curSector); +=09=09=09} else { +=09=09=09=09/* First write in this group */ +=09=09=09=09pfl->fstSector =3D offset; +=09=09=09=09pfl->curSector =3D offset; +=09=09=09=09pfl->pendingW =3D 1; +=09=09=09=09grouped =3D 1; +=09=09=09} +=09=09} + +=09=09/* Commit any pending write if the case. */ +=09=09if ((pfl->pendingW && !grouped) || forcefl) { +=09=09=09DPRINTF("%s: flushing sectors " TARGET_FMT_lx " ns %d\n", __func_= _, pfl->fstSector, pfl->curSector - pfl->fstSector + 1); +=09=09=09bdrv_write(pfl->bs, pfl->fstSector<storage= + (pfl->fstSector << (PFLASH_XBLOCK)), (pfl->curSector - pfl->fstSector + = 1)<<(PFLASH_512BLOCK)); +=09=09=09pfl->pendingW =3D 0; +=09=09} + +=09=09/* Current write (!in case we just do it with previous commit) */ +=09=09if (!grouped) { +=09=09=09offset_end =3D _offset + size; +=09=09=09/* round to sectors */ +=09=09=09offset_end =3D (offset_end + 511) >> 9; +=09=09=09DPRINTF("%s: flushing sectors " TARGET_FMT_lx " ns %d\n", __func_= _, offset, offset_end - offset); +=09=09=09bdrv_write(pfl->bs, offset, pfl->storage + (offset << 9), offset_= end - offset); +=09=09} +=09} +} +#endif /* update flash content on disk */ static void pflash_update(pflash_t *pfl, int offset, int size) @@ -224,7 +342,7 @@ } } =20 -static void pflash_write (pflash_t *pfl, uint32_t offset, uint32_t value, +static void pflash_write (struct pflash_cfi02_t *pfl, uint32_t offset, uin= t32_t value, int width) { uint32_t boff; @@ -232,31 +350,32 @@ uint8_t cmd; =20 cmd =3D value; - if (pfl->cmd !=3D 0xA0 && cmd =3D=3D 0xF0) { -#if 0 - DPRINTF("%s: flash reset asked (%02x %02x)\n", - __func__, pfl->cmd, cmd); + if (pfl->cmd !=3D 0xA0 && pfl->cmd !=3D 0x25 && cmd =3D=3D 0xF0) { +#if 1 + DPRINTF("%s: flash reset asked, cmd(%02x) " TARGET_FMT_lx " %x %d\= n", + __func__, pfl->cmd, (char*)offset-(char*)pfl->storage, val= ue, width); #endif goto reset_flash; } - DPRINTF("%s: offset " TARGET_FMT_lx " %08x %d %d\n", __func__, - offset, value, width, pfl->wcycle); + offset -=3D pfl->base; offset &=3D pfl->chip_len - 1; =20 - DPRINTF("%s: offset " TARGET_FMT_lx " %08x %d\n", __func__, - offset, value, width); boff =3D offset & (pfl->sector_len - 1); if (pfl->width =3D=3D 2) boff =3D boff >> 1; else if (pfl->width =3D=3D 4) boff =3D boff >> 2; + + DPRINTF("%s: offset " TARGET_FMT_lx " val %x wid %d wcycle %d\n", __fu= nc__, +=09 boff, value, width, pfl->wcycle); + switch (pfl->wcycle) { case 0: /* Set the device in I/O access mode if required */ if (pfl->rom_mode) pflash_register_memory(pfl, 0); - /* We're in read mode */ + /* We're in read mode */ check_unlock0: if (boff =3D=3D 0x55 && cmd =3D=3D 0x98) { enter_CFI_mode: @@ -265,26 +384,40 @@ pfl->cmd =3D 0x98; return; } - if (boff !=3D pfl->unlock_addr[0] || cmd !=3D 0xAA) { + if (!(boff =3D=3D pfl->unlock_addr[0] || boff =3D=3D 0x5555) || cm= d !=3D 0xAA) { DPRINTF("%s: unlock0 failed " TARGET_FMT_lx " %02x %04x\n", __func__, boff, cmd, pfl->unlock_addr[0]); goto reset_flash; } DPRINTF("%s: unlock sequence started\n", __func__); +=09pfl->wcycle++; break; case 1: /* We started an unlock sequence */ check_unlock1: - if (boff !=3D pfl->unlock_addr[1] || cmd !=3D 0x55) { + if (!(boff =3D=3D pfl->unlock_addr[1] || boff =3D=3D 0x2AAA) || cm= d !=3D 0x55) { DPRINTF("%s: unlock1 failed " TARGET_FMT_lx " %02x\n", __func_= _, boff, cmd); goto reset_flash; } DPRINTF("%s: unlock sequence done\n", __func__); +=09pfl->wcycle++; break; case 2: +=09/* Command write buffer load. */ +=09if (boff=3D=3D0 && cmd=3D=3D0x25) { +=09=09/* Wait #word - 1 on same addr */ +=09=09DPRINTF("%s: start buffer load, expect len4next write\n", __func__); +=09=09pfl->buffer_loading=3D1; +=09=09pfl->wcycle--; +=09} else if (pfl->buffer_loading) { +=09=09pfl->bytes2write=3D(value+1)<<(width>>1); +=09=09DPRINTF("%s: got %d bytes2write\n", __func__, pfl->bytes2write); +=09=09pfl->wcycle++; +=09=09break; +=09} else=20 /* We finished an unlock sequence */ - if (!pfl->bypass && boff !=3D pfl->unlock_addr[0]) { + if (!pfl->bypass && (boff !=3D pfl->unlock_addr[0] && boff !=3D 0x= 5555)) { DPRINTF("%s: command failed " TARGET_FMT_lx " %02x\n", __func_= _, boff, cmd); goto reset_flash; @@ -296,19 +429,29 @@ case 0x80: case 0x90: case 0xA0: - pfl->cmd =3D cmd; - DPRINTF("%s: starting command %02x\n", __func__, cmd); - break; + case 0x25: +=09 pfl->cmd =3D cmd; +=09 DPRINTF("%s: starting command %02x\n", __func__, cmd); +=09 break; default: DPRINTF("%s: unknown command %02x\n", __func__, cmd); goto reset_flash; } - break; +=09pfl->wcycle++; +=09break; case 3: switch (pfl->cmd) { case 0x80: /* We need another unlock sequence */ goto check_unlock0; + case 0x25: +=09 if (pfl->bytes2write=3D=3D0) { +=09=09 printf("%s: buffer mode have 0 bytes2write!\n", __func__); +=09=09 goto reset_flash; +=09 } +=09 if (!pfl->buffer_loading_start) +=09=09 pfl->buffer_loading_start=3Doffset; +=09 pfl->buffer_loading_end=3Doffset+width; case 0xA0: DPRINTF("%s: write data offset " TARGET_FMT_lx " %08x %d\n", __func__, offset, value, width); @@ -343,11 +486,24 @@ pflash_update(pfl, offset, 4); break; } - pfl->status =3D 0x00 | ~(value & 0x80); - /* Let's pretend write is immediate */ - if (pfl->bypass) - goto do_bypass; - goto reset_flash; +=09 /* In buffer load mode, status is available only after requested by= tes2write */ +=09 if (pfl->cmd!=3D0x25) { +=09=09 pfl->status =3D 0x00 | ~(value & 0x80); +=09=09 /* Let's pretend write is immediate */ +=09=09 if (pfl->bypass) +=09=09=09goto do_bypass; +=09=09 goto reset_flash; +=09 } else { +=09=09 if (pfl->bytes2write>=3Dwidth) +=09=09=09 pfl->bytes2write-=3Dwidth; +=09=09 else { +=09=09=09 printf("%s: buffer mode discarded %d bytes at end of transfer= \n",__func__,width-pfl->bytes2write); +=09=09=09 pfl->bytes2write=3D0; +=09=09 } +=09=09 if (pfl->bytes2write) +=09=09=09 pfl->wcycle--; /* Dangerous if use timer */ +=09 } +=09 break; case 0x90: if (pfl->bypass && cmd =3D=3D 0x00) { /* Unlock bypass reset */ @@ -362,6 +518,8 @@ __func__, pfl->cmd); goto reset_flash; } +=09pfl->wcycle++; +=09break; case 4: switch (pfl->cmd) { case 0xA0: @@ -370,6 +528,13 @@ return; case 0x80: goto check_unlock1; + case 0x25: +=09 DPRINTF("%s: Buffer load terminated %s (%d bytes remaining)\n", __f= unc__, !pfl->bytes2write?"Ok" : "NOK", pfl->bytes2write); +=09 /* Update written sequence=20 +=09 pflash_update(pfl, pfl->buffer_loading_start, pfl->buffer_loading_e= nd - pfl->buffer_loading_start); */ +=09 pfl->buffer_loading =3D 0; +=09 pfl->buffer_loading_start =3D 0; +=09 goto reset_flash; default: /* Should never happen */ DPRINTF("%s: invalid command state %02x (wc 4)\n", @@ -436,18 +601,15 @@ DPRINTF("%s: invalid write state (wc 7)\n", __func__); goto reset_flash; } - pfl->wcycle++; - return; =20 /* Reset flash */ reset_flash: - pfl->bypass =3D 0; - pfl->wcycle =3D 0; - pfl->cmd =3D 0; + pflash_cfi02_core_reset(pfl); return; =20 do_bypass: + DPRINTF("Requesting bypass\n"); pfl->wcycle =3D 2; pfl->cmd =3D 0; return; @@ -461,14 +623,14 @@ =20 static uint32_t pflash_readw (void *opaque, target_phys_addr_t addr) { - pflash_t *pfl =3D opaque; + struct pflash_cfi02_t *pfl =3D opaque; =20 return pflash_read(pfl, addr, 2); } =20 static uint32_t pflash_readl (void *opaque, target_phys_addr_t addr) { - pflash_t *pfl =3D opaque; + struct pflash_cfi02_t *pfl =3D opaque; =20 return pflash_read(pfl, addr, 4); } @@ -482,7 +644,7 @@ static void pflash_writew (void *opaque, target_phys_addr_t addr, uint32_t value) { - pflash_t *pfl =3D opaque; + struct pflash_cfi02_t *pfl =3D opaque; =20 pflash_write(pfl, addr, value, 2); } @@ -490,7 +652,7 @@ static void pflash_writel (void *opaque, target_phys_addr_t addr, uint32_t value) { - pflash_t *pfl =3D opaque; + struct pflash_cfi02_t *pfl =3D opaque; =20 pflash_write(pfl, addr, value, 4); } @@ -507,6 +669,7 @@ &pflash_readl, }; =20 +#ifndef USE_SIMPLE_TABLE /* Count trailing zeroes of a 32 bits quantity */ static int ctz32 (uint32_t n) { @@ -540,15 +703,15 @@ =20 return ret; } - +#endif pflash_t *pflash_cfi02_register(target_phys_addr_t base, ram_addr_t off, BlockDriverState *bs, uint32_t sector_len, int nb_blocs, int nb_mappings, int width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, - uint16_t unlock_addr0, uint16_t unlock_add= r1) +=09=09=09=09uint16_t unlock_addr0, uint16_t unlock_addr1) { - pflash_t *pfl; + struct pflash_cfi02_t *pfl; int32_t chip_len; =20 chip_len =3D sector_len * nb_blocs; @@ -558,9 +721,11 @@ total_len !=3D (32 * 1024 * 1024) && total_len !=3D (64 * 1024 * 1= 024)) return NULL; #endif - pfl =3D qemu_mallocz(sizeof(pflash_t)); + pfl =3D qemu_mallocz(sizeof(struct pflash_cfi02_t)); if (pfl =3D=3D NULL) return NULL; + + /* One time initialization, HOST related. */ pfl->storage =3D phys_ram_base + off; pfl->fl_mem =3D cpu_register_io_memory(0, pflash_read_ops, pflash_writ= e_ops, pfl); @@ -574,7 +739,7 @@ /* read the initial flash content */ bdrv_read(pfl->bs, 0, pfl->storage, chip_len >> 9); } -#if 0 /* XXX: there should be a bit to set up read-only, + #if 0 /* XXX: there should be a bit to set up read-only, * the same way the hardware does (with WP pin). */ pfl->ro =3D 1; @@ -593,6 +758,7 @@ pfl->ident[3] =3D id3; pfl->unlock_addr[0] =3D unlock_addr0; pfl->unlock_addr[1] =3D unlock_addr1; +#ifndef USE_SIMPLE_TABLE=20 /* Hardcoded CFI table (mostly from SG29 Spansion flash) */ pfl->cfi_len =3D 0x52; /* Standard "QRY" string */ @@ -621,22 +787,22 @@ pfl->cfi_table[0x1E] =3D 0x00; /* Reserved */ pfl->cfi_table[0x1F] =3D 0x07; - /* Timeout for min size buffer write (NA) */ - pfl->cfi_table[0x20] =3D 0x00; + /* Timeout for min size buffer write (16 s) */ + pfl->cfi_table[0x20] =3D 0x04; /* Typical timeout for block erase (512 ms) */ pfl->cfi_table[0x21] =3D 0x09; /* Typical timeout for full chip erase (4096 ms) */ pfl->cfi_table[0x22] =3D 0x0C; /* Reserved */ pfl->cfi_table[0x23] =3D 0x01; - /* Max timeout for buffer write (NA) */ - pfl->cfi_table[0x24] =3D 0x00; + /* Max timeout for buffer write */ + pfl->cfi_table[0x24] =3D 0x04; /* Max timeout for block erase */ pfl->cfi_table[0x25] =3D 0x0A; /* Max timeout for chip erase */ pfl->cfi_table[0x26] =3D 0x0D; /* Device size */ - pfl->cfi_table[0x27] =3D ctz32(chip_len); + pfl->cfi_table[0x27] =3D ctz32(chip_len) + 1; /* Flash device interface (8 & 16 bits) */ pfl->cfi_table[0x28] =3D 0x02; pfl->cfi_table[0x29] =3D 0x00; @@ -652,7 +818,7 @@ pfl->cfi_table[0x2E] =3D (nb_blocs - 1) >> 8; pfl->cfi_table[0x2F] =3D sector_len >> 8; pfl->cfi_table[0x30] =3D sector_len >> 16; - + =20 /* Extended */ pfl->cfi_table[0x31] =3D 'P'; pfl->cfi_table[0x32] =3D 'R'; @@ -660,7 +826,6 @@ =20 pfl->cfi_table[0x34] =3D '1'; pfl->cfi_table[0x35] =3D '0'; - pfl->cfi_table[0x36] =3D 0x00; pfl->cfi_table[0x37] =3D 0x00; pfl->cfi_table[0x38] =3D 0x00; @@ -670,6 +835,31 @@ =20 pfl->cfi_table[0x3b] =3D 0x00; pfl->cfi_table[0x3c] =3D 0x00; +#else + /* Don't know why but driver expect this=20 + * Now this table have !to be 'interpolated' basing on width. + * Moreover we were called with width =3D=3D 4. */ + pfl->cfi_len =3D 0x80; + pfl->cfi_table[0x21] =3D 'Q'; + pfl->cfi_table[0x23] =3D 'R'; + pfl->cfi_table[0x25] =3D 'Y'; + pfl->cfi_table[0x27] =3D 2;=09=09/* oam command set */ + pfl->cfi_table[0x4F] =3D 25; =09=09/* size =3D 2^x Bytes*/ + pfl->cfi_table[0x59] =3D 1;=09=09/* num of blocks */ + pfl->cfi_table[0x5b] =3D 255;=09=09/* sectors */ + pfl->cfi_table[0x61] =3D 2;=09=09/* sector size=09 */ +#endif =20 - return pfl; +#if 0 + /* Per reset initialization, GUEST related. + * + * Reset action is needed, since memory attribute is changed over the = writing process + * @reset we must@least read from flash. + * Actually we stop all started action (reset chip) + */ + pflash_cfi02_reset(pfl); + qemu_register_reset(&pflash_cfi02_reset, pfl); +#endif + =20 + return (pflash_t*)pfl; } Index: hw/ppc405_uc.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/ppc405_uc.c=09(revision 5720) +++ hw/ppc405_uc.c=09(working copy) @@ -21,6 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS = IN * THE SOFTWARE. */ +#include #include "hw.h" #include "ppc.h" #include "ppc405.h" @@ -28,13 +29,17 @@ #include "qemu-timer.h" #include "sysemu.h" #include "qemu-log.h" +#include "net.h" /* To have nd_table.h */ =20 +extern int loglevel; +extern FILE *logfile; + #define DEBUG_OPBA #define DEBUG_SDRAM -#define DEBUG_GPIO +/*#define DEBUG_GPIO*/ #define DEBUG_SERIAL #define DEBUG_OCM -//#define DEBUG_I2C +/*#define DEBUG_I2C*/ #define DEBUG_GPT #define DEBUG_MAL #define DEBUG_CLOCKS @@ -835,6 +840,8 @@ ret =3D 0x00000000; break; } +=09printf("Read ebc[%d]=3D>%x\n", ebc->addr, ret); +=09break; default: ret =3D 0x00000000; break; @@ -853,6 +860,7 @@ ebc->addr =3D val; break; case EBC0_CFGDATA: +=09printf("Write ebc[%d]=3D>%x\n", ebc->addr, val); switch (ebc->addr) { case 0x00: /* B0CR */ break; @@ -1395,7 +1403,37 @@ } =20 /*************************************************************************= ****/ -/* I2C controller */ +/*=20 + * I2C controller (SEE ALSO IN i2c.h before choice!!!) + * + * Control many device through uP resource. + * User could implement their device linked with this bus, + * specializing simple read(offset,value)/writec(offset,value) + * Only 7 bit address mode is supported. + */ +#define I2C_VER2 +/* Generic function like: + * hw/hw.h +=09* These should really be in isa.h, but are here to make pc.h happy. * +=09typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t= data); +=09typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address); + * + * cpu-all.h +=09typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, = uint32_t value); +=09typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t add= r); + * + * qemu-common.h +=09typedef void IOReadHandler(void *opaque, const uint8_t *buf, int size); +=09typedef int IOCanRWHandler(void *opaque); +=09typedef void IOHandler(void *opaque); + +=09typedef int (*DMA_transfer_handler) (void *opaque, int nchan, int pos, = int size); + + THERE !EXIST SIMPLE int read(int fd, const char* pos, int len), CREATE = IT + */ +KRHandler* readF=3DNULL; +KRHandler* writeF=3DNULL; + typedef struct ppc4xx_i2c_t ppc4xx_i2c_t; struct ppc4xx_i2c_t { target_phys_addr_t base; @@ -1415,21 +1453,82 @@ uint8_t xfrcnt; uint8_t xtcntlss; uint8_t directcntl; + + /* This is treated like a FIFO with same OPB beat (!implemented) */ + uint8_t dataLen; + uint8_t data[4]; /* This is on PPC405GPr, uP dependent */ + void* opaque; }; =20 +/*=20 + * This method simulate the insertion of a byte on the bus, + * and acquisition in uP registers. + * + * Return number of readed bytes + * FIX: Should be linked to OPB clock + */ +static uint32_t ppc4xx_i2c_pushb (ppc4xx_i2c_t *i2c, uint8_t val) +{ +=09uint32_t ret =3D 0; + +=09assert(i2c->dataLen<=3Dsizeof(i2c->data)); +=09/* Check if space */ +=09if (i2c->dataLendata)) { +=09=09i2c->data[i2c->dataLen] =3D val; +=09=09i2c->dataLen++; +=09=09/* Signal to uP that data exist */ +=09=09i2c->sts |=3D 0x20; +=09=09ret=3D1; +=09} else { +=09=09/* Signal to uP that no more space exist */ +=09=09i2c->sts |=3D 0x10; +=09} +=09/* Always read a byte, also need different read/write cursor? */ +=09return ret; +} + +static uint8_t ppc4xx_i2c_popb (ppc4xx_i2c_t *i2c) +{ +=09uint8_t ret =3D 0; + +=09assert(i2c->dataLen<=3Dsizeof(i2c->data)); +=09if (i2c->dataLen>0) { +=09=09uint8_t i; +=09=09ret =3D i2c->data[0]; +=09=09i2c->dataLen--; +=09=09for (i=3D0; i<(sizeof(i2c->data)-1); i++) +=09=09=09i2c->data[i] =3D i2c->data[i+1]; +=09} + +=09if (i2c->dataLen<=3D0) { +=09=09/* Signal to uP that no more data exist */ +=09=09i2c->sts &=3D ~0x30; +=09} +=09return ret; +} + static uint32_t ppc4xx_i2c_readb (void *opaque, target_phys_addr_t addr) { ppc4xx_i2c_t *i2c; uint32_t ret; =20 +#if 0 #ifdef DEBUG_I2C printf("%s: addr " PADDRX "\n", __func__, addr); #endif +#endif i2c =3D opaque; switch (addr - i2c->base) { case 0x00: +#ifndef I2C_VER2 =20 // i2c_readbyte(&i2c->mdata); ret =3D i2c->mdata; +#else +#ifdef DEBUG_I2C +=09printf("I2C read %x (hnd %p)\n", i2c->mdata, readF); +#endif +=09ret =3D ppc4xx_i2c_popb(i2c); +#endif break; case 0x02: ret =3D i2c->sdata; @@ -1477,9 +1576,11 @@ ret =3D 0x00; break; } +#if 0 #ifdef DEBUG_I2C printf("%s: addr " PADDRX " %02" PRIx32 "\n", __func__, addr, ret); #endif +#endif =20 return ret; } @@ -1489,14 +1590,20 @@ { ppc4xx_i2c_t *i2c; =20 +#if 0 #ifdef DEBUG_I2C printf("%s: addr " PADDRX " val %08" PRIx32 "\n", __func__, addr, valu= e); #endif +#endif i2c =3D opaque; switch (addr - i2c->base) { case 0x00: +#ifndef I2C_VER2 =20 i2c->mdata =3D value; // i2c_sendbyte(&i2c->mdata); +#else +=09ppc4xx_i2c_pushb(i2c, (char)value); +#endif break; case 0x02: i2c->sdata =3D value; @@ -1509,6 +1616,62 @@ break; case 0x06: i2c->cntl =3D value; +#ifdef I2C_VER2 +=09/* IIC0_CNTL (8bits) +=09 * ----------------- +=09 * HMT =090x80=09Halt master Transfer +=09 * AMD =090x40=09Address MoDe +=09 * TCT =090x30=09Transfer CounT +=09 * RPST=090x08=09RePeated STart +=09 * CHT =090x04=09CHain Tranfer +=09 * RW =090x02=09ReadWrite +=09 * PT=090x01=09PendingTransfer +=09 * +=09 * State/Action +=09 * HMT RPSP =09CHT =09PT +=09 * 0=09-=09-=090=09No action +=09 * 0=090=091=091=09Start, Transfer, ACK on last byte, Pause +=09 * 0=090=090=091=09=09=09NACK =09=09 , Stop +=09 * 0=091=09x=091=09=09=09=09=09 , Wait +=09 * 1=09x=09x=09x=09NACK on current byte, Stop +=09 */ +=09if (value & 0x81) { +=09=09unsigned char len, lettu, aspe; +=09=09int addr; +=09=09size_t ret; +=09=09len =3D ((value >> 4) & 3) + 1; +=09=09lettu =3D (value & 2); +=09=09aspe =3D (value & 1); +=09=09addr =3D i2c->lmadr; +=09=09ret =3D 0; +#ifdef DEBUG_I2C +=09=09printf("(I2C command len %d, %s, start %s pending transfer)\n", len,= lettu?"READING":"WRITING", aspe?"only if not":"also if"); +#endif +=09=09assert(len<=3Dsizeof(i2c->data)); +=09=09if (lettu && readF) { +=09=09=09ret =3D readF(addr, i2c->data, len); +=09=09} +=09=09if (!lettu && writeF) { +=09=09=09ret =3D writeF(addr, i2c->data, len); +=09=09} +#ifdef DEBUG_I2C +=09=09printf("User command return %d\n", ret); +#endif +=09=09/*=20 +=09=09 * on read from device =09=3D> Push bytes in uP buffer (simulate con= troller acquiring) +=09=09 * on write ...=09=09=3D> Pop bytes from uP buffer (simulate device = reading) +=09=09 */ +=09=09{ +=09=09=09unsigned int l; +=09=09=09for (l=3D0; ldata[l]) : =09/* Produce data fo= r uP */ +=09=09=09=09=09ppc4xx_i2c_popb(i2c) ;=09=09=09/* Consume data for uP */ +=09=09=09} + +=09=09} +=09} +#endif break; case 0x07: i2c->mdcntl =3D value & 0xDF; @@ -1967,6 +2130,15 @@ uint32_t rcbs[2]; }; =20 +/* TODO: need interaction between device! + * very difficult since all struct is in .c file */ +uint32_t txctpr[4]; +uint32_t rxctpr[2]; +uint32_t rcbs[2]; +uint32_t *rxeobisr; +uint32_t *txeobisr; +uint32_t *rxcasr; + static void ppc40x_mal_reset (void *opaque); =20 static target_ulong dcr_read_mal (void *opaque, int dcrn) @@ -2067,21 +2239,29 @@ mal->txcarr =3D val & 0xF0000000; break; case MAL0_TXEOBISR: - /* Read/clear */ - mal->txeobisr &=3D ~val; + /* Read/clear TODO SEPARATE CHANNEL */ +=09if (mal->txeobisr & val & 0xC0000000) { +=09=09mal->txeobisr &=3D ~val; +=09=09qemu_irq_lower(mal->irqs[0]); +=09} +=09mal->txeobisr &=3D ~val; break; case MAL0_TXDEIR: /* Read/clear */ mal->txdeir &=3D ~val; break; case MAL0_RXCASR: - mal->rxcasr =3D val & 0xC0000000; + mal->rxcasr =3D val & ~0xC0000000; /* Active Set immediately rx ch= annel */ break; case MAL0_RXCARR: mal->rxcarr =3D val & 0xC0000000; break; case MAL0_RXEOBISR: /* Read/clear */ +=09if (mal->rxeobisr & val & 0x80000000) { +=09=09mal->rxeobisr &=3D ~val; +=09=09qemu_irq_lower(mal->irqs[1]); +=09} mal->rxeobisr &=3D ~val; break; case MAL0_RXDEIR: @@ -2101,6 +2281,7 @@ idx =3D 3; update_tx_ptr: mal->txctpr[idx] =3D val; +=09txctpr[idx] =3D val; break; case MAL0_RXCTP0R: idx =3D 0; @@ -2109,6 +2290,7 @@ idx =3D 1; update_rx_ptr: mal->rxctpr[idx] =3D val; + rxctpr[idx] =3D val; break; case MAL0_RCBS0: idx =3D 0; @@ -2117,6 +2299,7 @@ idx =3D 1; update_rx_size: mal->rcbs[idx] =3D val & 0x000000FF; + rcbs[idx] =3D val & 0x000000FF; break; } } @@ -2135,6 +2318,10 @@ mal->txcasr =3D 0x00000000; mal->txdeir =3D 0x00000000; mal->txeobisr =3D 0x00000000; + + rxeobisr =3D &(mal->rxeobisr); + txeobisr =3D &(mal->txeobisr); + rxcasr =3D &(mal->rxcasr); } =20 void ppc405_mal_init (CPUState *env, qemu_irq irqs[4]) @@ -2234,6 +2421,7 @@ qemu_system_reset_request(); } =20 +/* ->halted=3D1 seem that loose memory. */ void store_40x_dbcr0 (CPUState *env, uint32_t val) { switch ((val >> 28) & 0x3) { @@ -2891,7 +3079,8 @@ } } =20 -CPUState *ppc405ep_init (target_phys_addr_t ram_bases[2], +CPUState *ppc405xp_init (const char* cpu_model, + target_phys_addr_t ram_bases[2], target_phys_addr_t ram_sizes[2], uint32_t sysclk, qemu_irq **picp, ram_addr_t *offsetp, int do_init) @@ -2906,7 +3095,9 @@ =20 memset(clk_setup, 0, sizeof(clk_setup)); /* init CPUs */ - env =3D ppc4xx_init("405ep", &clk_setup[PPC405EP_CPU_CLK], + if (!cpu_model) +=09 cpu_model =3D "405ep"; + env =3D ppc4xx_init(cpu_model, &clk_setup[PPC405EP_CPU_CLK], &tlb_clk_setup, sysclk); clk_setup[PPC405EP_CPU_CLK].cb =3D tlb_clk_setup.cb; clk_setup[PPC405EP_CPU_CLK].opaque =3D tlb_clk_setup.opaque; @@ -2970,7 +3161,11 @@ mal_irqs[2] =3D pic[13]; mal_irqs[3] =3D pic[14]; ppc405_mal_init(env, mal_irqs); - /* Ethernet */ + /* EMAC (Ethernet Media Access Controller) */ + { + =09void ppc4xx_emac_init(CPUState *env, ppc4xx_mmio_t *mmio, target_ph= ys_addr_t offset, NICInfo* nic, qemu_irq irq[4]); + =09ppc4xx_emac_init(env, mmio, 0x800, &nd_table[0], mal_irqs); + } /* Uses pic[9], pic[15], pic[17] */ /* CPU control */ ppc405ep_cpc_init(env, clk_setup, sysclk); Index: hw/ppc4xx_devs.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/ppc4xx_devs.c=09(revision 5720) +++ hw/ppc4xx_devs.c=09(working copy) @@ -26,6 +26,7 @@ #include "ppc4xx.h" #include "sysemu.h" #include "qemu-log.h" +#include "qemu-timer.h" =20 //#define DEBUG_MMIO //#define DEBUG_UNASSIGNED @@ -296,10 +297,10 @@ cr =3D uic->uicsr & uic->uicer & uic->uiccr; #ifdef DEBUG_UIC if (loglevel & CPU_LOG_INT) { - fprintf(logfile, "%s: uicsr %08" PRIx32 " uicer %08" PRIx32 + fprintf(logfile, "%s %" PRIu64 ": uicsr %08" PRIx32 " uicer %08" P= RIx32 " uiccr %08" PRIx32 "\n" " %08" PRIx32 " ir %08" PRIx32 " cr %08" PRIx32 "\n", - __func__, uic->uicsr, uic->uicer, uic->uiccr, + __func__, qemu_get_clock(rt_clock), uic->uicsr, uic->uicer= , uic->uiccr, uic->uicsr & uic->uicer, ir, cr); } #endif @@ -366,9 +367,9 @@ mask =3D 1 << (31-irq_num); #ifdef DEBUG_UIC if (loglevel & CPU_LOG_INT) { - fprintf(logfile, "%s: irq %d level %d uicsr %08" PRIx32 + fprintf(logfile, "%s %" PRIu64 ": irq %d level %d uicsr %08" PRIx3= 2 " mask %08" PRIx32 " =3D> %08" PRIx32 " %08" PRIx32 "\n", - __func__, irq_num, level, + __func__, qemu_get_clock(rt_clock), irq_num, level, uic->uicsr, mask, uic->uicsr & mask, level << irq_num); } #endif Index: hw/ppc405.h =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/ppc405.h=09(revision 5720) +++ hw/ppc405.h=09(working copy) @@ -97,7 +97,8 @@ target_phys_addr_t ram_sizes[4], uint32_t sysclk, qemu_irq **picp, ram_addr_t *offsetp, int do_init); -CPUState *ppc405ep_init (target_phys_addr_t ram_bases[2], +CPUState *ppc405xp_init (const char* cpu_model, +=09=09=09 target_phys_addr_t ram_bases[2], target_phys_addr_t ram_sizes[2], uint32_t sysclk, qemu_irq **picp, ram_addr_t *offsetp, int do_init); Index: hw/boards.h =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D --- hw/boards.h=09(revision 5720) +++ hw/boards.h=09(working copy) @@ -38,6 +38,7 @@ extern QEMUMachine heathrow_machine; extern QEMUMachine ref405ep_machine; extern QEMUMachine taihu_machine; +extern QEMUMachine walnut_machine; =20 /* mips_r4k.c */ extern QEMUMachine mips_machine; Index: pc-bios/u-boot.bin =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D Cannot display: file marked as a binary type. svn:mime-type =3D application/octet-stream Property changes on: pc-bios/u-boot.bin ___________________________________________________________________ Name: svn:mime-type + application/octet-stream =0A=0A=0A Unisciti alla community di Io fotografo e video, il nuovo co= rso di fotografia di Gazzetta dello sport:=0Ahttp://www.flickr.com/groups/i= ofotografoevideo --0-956278597-1227232400=:53603 Content-Type: application/x-gzip; name="u-boot.bin.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="u-boot.bin.gz" H4sICB0UJkkAA3UtYm9vdC5iaW4A7FsNdFR1dr9v3guZhFHC7hMjGcmLREjC iIFF+xIGmADtDh/uCfal4cPuTjZoCaCixXZW/m/mvSRGUNqdkED9iAiCo3bd 1u3Bc1yXYmh1i7Vnz+pCjqusGwQLUU4LAsesxLz+7nuTELJo3Z7utmeJ58z5 f917//f73v8jTs665k9qbph7993rtWlTp029WSv5xt1/oU2fpk0vL9e1G7Ty 8soZ0yunTyul38//dItIPPpRWjyGX/sZjPjZclpsO5PWLccRqfPpKF1Xgd+s sGWR3kySePx8ejFJoTBwsSbx2HnAkiq2yC1hS7ZizYol2uQW7CneXuSKWPMO 4j3gWAwf1iIUKyq0dMtPYpOcDkewnqtR2Hrv+7Hm977f3uj0zSWnTweP7ZLT 5/6KnN4wOU6MvHlKokCUWn4RJcoyD/jS1pXXh8zOe9Uo3fhclLbf82XkT6Tm pRM/wM+iSZU7HdqylZ7dcohWbTlHaxOpuWmsY4k3MR6ilYmNPl7vSLzu43VH wnbXuxPvfZxOOB+nU1dRXuomUlM1lI+REju/F0/dR8HUVtJSL1Jx6hCVWHdZ qlglp/U6yquE/m49O+reb1hURFTqJ7pO/DZt/VuT/x1fOnHe9z+QP2+I/FPA TVHHiPyXq/yh2y4H+UUb4LbSHvEPGF+kly7oQdGsn0A3B+R0Jh/0/i708buW //PlLYteDvYfif/Pk//p3Ze3/Je7/UfkH5F/RP4R+S9X+ct+ennLf7nbf0T+ EflH5B+Rf0T+EflH5B+Rf0T+EflH5B+Rf0T+//fy/6/8+++U2/4v/v0XcqRm d5KS+OSFOGRuT52jUOtVVN56E81orSG99T4Kt26lSOuLNL/1EEVbz9HiLVdR 9ZabyNhSQ0u33Ee3tV1F69puovVtNRRvu49E21ay2l6k5rZDtLHtHG1OnPCl 7+2dQ4B7obLTvXNv4q156aariRo/ISU5Xk4nHsfvhJwWpDzPf1uwmGhl0iL+ uwKKNVuU7NDiA2dJSyoemFtV1GFJtEMsAK5fTmO9G+tnRRXWY05rVh0FLZs0 aycVW/uh/yMUsiUqt4tohl1Ful1HYdumiL2T5tv7KWofocWNElU3FpHRWEVL G+votkabYo07aWXjflrVeITWNkm0rqmI1jdVUbypjkSTTVbTTmpu2k8bm47Q ZvCQAg/tYjl4KABPEuVhL98qIvX3Sr5vnkmLwjOfJ98dgrI3w7c1HTYPd0PO 4xKJHrbx1zbrPyZtLjm9fD5LI19dqUUm9GFuisZNTSquiJBkVn6aNhcuipvL z6dnRYjqFko0K4ZxjUYm9FER6SZz9XLVWk1krSEStGJzxULSKta4tE8yL2bl +bQJffI9pt+XXuQ4d5rQo/v3KzGLxIbz/O+PWhh0ec77vBYbPk0b9WP6h+DN ugjvfg8vc1bFZy6NzL64/wK+SM719jacyZx548Z6Ih4fafLGFzKjsApdHlKD 62vd9Y4MvIhNcNfW4Dro8Uz5z3tjQWZUvLGuIC42TYyLv50SF7umxMOW0xdr hs7+zsoXu0uqYR/NPFZdbf7kfjX53v2qaNIiehbJBp16paqFIlWNJESOnI40 U7BCcfr0o05fs5+U9mxS2IZRoqCBdGYqPlUc9anNfqevPdv9+53e0CjoZFeZ Chq6PspxRD3FxUrwQ9pa0TxdFUpJpMpyzjKv3v7k54fvs8713Ov3sP+7/kRZ RfpdFtn4MV/mmvxqvR48yaQIWq6mZCLcfZb/dgj5VglhZDiGAR/B5ibAKUvv YtjWeUQpxYU/CVjN+msrKGSNZc5nfKal1wMee5FG56w5Ef44/4/jUdpwp/Uf lt++0sqr0ODX2ZHIYtY1aoSVDbwc4B0npaIUuDgD7km927exgkYR9HW7ftzD YRn17lGPYG+J3p29EeMCvdsPuADDzboY7grsaynsX3/xfh6tPE4+0Y28sdHT EfMgaLyawoi5kpkrfEbyXJ3ka4PtRc7bAv7Lfz/1Sh2pyQOo4RKFrAnOKZEs iCc7P1YtFMaZyFFR6emcUCER9LIqTFsWxKi4TQRpW3JT/zpB7yPux60TOVRt 5OTrphatDhNFRCFFzNLu6hs3Ec3sIKnKplBTkpSq7RQBXX9y5bvxqLT7B6Eg aTjLa3KI+A7oagfOFZxtRW4J/Qi8se31IipxZfPOvoO420ty0IAcJwblsMmf kSPoyiEycjSRZe2iduufKWXLtMOeiDyasALJB48yDzdYHdSMdZ7xwHf7jZa/ 6TcefLLf2PhMv7Hpl/3GQ8f7AZPD987sZl3s+uzPuyk7eex8HPpYWtudVyk6 aCrLhLMjye4J0InUbsCFBPVWw/+yZzqQv5E0yFcYsZ1XIVfwR+A1I1f+Bbl2 7YRchzFXMd+K+W6SC9Z9oa06ENsbEDtNE11ZFzn9py0EDsYiyGWBVn7yduia li25lD5BP+8iHe5HHwP++I4BX0CusZh2lIquD8muHwRTSdBmOQA/TI5gVHrq 5xg1jG9iLGZdYf6aVUjNyOE+I0eeIHKWMp21GCOwfxg+I8GHeK8EODrgtyaP no+7ciRZns+WYD8cpaWboJeNmM9gXQFPyeDlY+7nOXyoE+cl7CMYQxj3YCzH +DzJ47Uv4zO47zlPj30sSwT3jr2U3Ui+5qfD9XcRveQgvWVC/Ti9PsdPRs4f 9HNcRBopuj7HR5HtpEdYblfOvgbcVx2l2p2fo9/FUWkn+/9BzKMYz2Kcj/Ek 88C88N1h8pPIP5PWUZeidP8/Mi2mMZBHwXf+bxA7zYgdjksjKu34LNl8NM50 IVPDpXWSv/dL005YS0HzuWTTUdi676ZL0WNafN8Q+i99kc4rAMv0B3M4ITej BtjfRJ8x5VZ3X4xeMhV52o+fgp4hgBpwwjaRdLW8b1ujKVRXesvPBEXHGfTm PlGAXmf8x+mVpETEeOiU8ce5vU+Q+RpuI/CX/0Uxy7wl/316C+c7zq+cR2bG MvnPQs82G7WtIDrV3LBQtaeQn2sYaonUijlgI+h3lIwdi8IEWDpWjr6qpdbx z5q5gQKcbxEDey4V7+Z101sGcEwN9dj3tRbOPWzTqPRkEfzoBZKvXnoR/1WD +vVyzgbPfkGZAk3bQetJ5KDDNFW8PCXONT/ZornxyDU9+QHy5HYKePlx+/5g AQVM7X012SdNbVtAygV+DpebpXLcvA78MN9VgzrN5Klxr36RzZkfG/XqAr3g oHzBegqwzcyJy1UhL2O7K5eKLdfPBm047gtrC9stUyMDUemJHq4fXn144hds P9aneCU6lW0RysLdcxaqqAMBxHkxah7XgcOD/jO8FvSQ33odPLp14Im/gk04 x3QzL+CD83OxGFvWYv8pBdA/G3WlMe6Nn61b00lm2ULVLF2xrSSHNGM0FUdA u0JD35TjOAb5w+Ya6PieKS3WtVjE/jMmaEFXrF6WjdHazTWiN5F8CLbpWLEN bxNrkXPu9toOZTbD1TaPmg04xPy5JbUd/+TusYzYk7A3i9dMB3gy1jdk1j5+ 42B9La/d9069jBx37orMedYi5+yvRKwgnlnTIxL5sffBkL1sxsvsH8rsSR7d s69Bh8UZHQ7YUhuwJeuL7YUa8trw/Ic6ljsAM1DzRKLAremwozTAH9du3FPD /KyDTnHXStgwL0rrbwkVXvE92PFtVxevnol7+jk77VK+BbwrYEe25e6Be9uO ZO5FjeD3ANdW0M5nfLy1LsI36kfNBu4tm5PwJxfOOYX120PlvKDTM08zv0bO qD6uM+B7UB7obQLzX7XdOQi4B0Dj3wZ0j/Wdw/Xk+kimrjC+p88zf7guRhJi CnmGgphPGEY/6OZIWY4Ppwfcsbjz2FC+Ob7EKh+/h6/k/x8A/WoAfbf7RuR3 Vax+B4kGOT2X3FyeJ74iI8Yfl2JkWOKrcot7l7vnnI5x7Ht7Y709nz0ETvL2 TklD4L7i7SmAWz4A58vAjR0C91VvTwLcrQNwcgauaAjc1ZeAy87ATRuAG66X gXzLOZbrRdMT7N+nX+Nci/FR0FCZhiurR1MZut4YpOJNYbreUCJTXZs1L4I/ +mGr0z/E2SScTeYz3se6xGjmuczzUp57ODLjwEanHwhTdWuMcqprN9DNogBv eIrFYhRzez/Oz27MDastIndKS8a2riwsB/s2y7TIOfUrcaqsRRwsazG658zm mmb0FCaKSsnfOgd1upD88BvO03k85/uNBrqZeeCezvgouc/48Ml9xom/32f0 fHffzDdI4ppYsRq/KPlAI7/tlxRoTVJe67eI35x70W8S7uHe+xG8PTgPkmn9 vMuMvT1OnDw1TgQWdJmB011mYlnXHOvg0/UdeagblapY1T1OdKNWbDzSFfTT ieSDR7r4DSVi76v6Dvhg533lUenMa8i9Sl1pW7dZ+u62MM18LEb/CvxF24I0 OS/1JM0wtdNdkKUYvGmXqsXwkb4Y7agxtTPbAFMMWI1jel1nHhnd2Yki9LOt hWg6Gmmd8C/rWvc68gBUw3oS/tPgaVnXrNjBp+vWgO/Y0nEsn7CWdZkNy7qC RCeYV4/v5WqG57HQScCeA2dPQhelUpdQVmwzixdtY36ZB9wv1nXiTYY6JfxL cCf6Vb7zKecR4PlZpyJH6nJ7cIfrFvjI1XFPRVfVU856kV0Fvk7z+Sr4wQvs B3od+iyJDPSLPdADf7cKiXp5G+YGdFE9JAaGw/8QMPm/AfwmwJSwb6auRc8B nWPM+xJ4/DYy3Hs8+1R7PcCVqwZy3+f1HDpJ7vcF7j3QN5I9CzFNC9UU5ugr FffbwiXqAWgHQPfAQH+x78hgjxgeoN00wVIa+61Akw69Xw3asy30go5jl+Jd fw3iv36hahRQZfLRd9SZ85DTOX7kvDHGeJqUnPczvPnu+Cwkw6BJt66h9+mO RDhOr+l0+zPwFX75yKBP6swX5MgThd2uLKb2loqeE7BSkO/nuzH3i2AvYtLn yshv4UwPG5hooUdy3lfNOW+pes4Y9Bs0ib8LJDt8Kvf34OdO5gd+spHvQT+u uPfMya8W11Qjx/O3hPfVWANJTBv+qLR96Pa80ZICGsPfCTiHI07QQzjz9QLn LOTXWRd8blB2v/mdd1TEQZagd+Mp7HPPjJ8C3PnQH9+p2g3QXy6/ASjC/VHr ale3+TgLWsg1dhnHDeKfopHIzv7DqVzOxf0H9e+QP0pZObj7pbZPeM9RxP3v qDbsg+QocV+JvQ6SA+UX+Q3u4Jp9qTdKlUVrdZlGI0+NMwpJB59+9B95JYXS J1W2fNiCD9QePdFvJn2qPZrjnt/N8kveSFHLjz7xWQoYClWaJdepFve2J8AP 9FSxCv79gffGST3jxkPQrF8RH95votb6bPTxdoD33Ry/l+m6NL+lVYdyaQz0 NEOs+lSt7yGpLuLRbi0B3bXkN+fhLSW780BrE/abKAA9tAOPWjdjbzNsaOHu DH+My/xl9LW2RJGcKtsXNFpO9MMOitGZr1csdnrFDrx/VsPPXx+3Drmq3a3f FC23IBP3sbCbkoLsKcjbmo17ssjP+GIN4NdI7TbeFy5O9tJykV3N3xkOi+7q Cn5rG8f9YfFRdQVqTKXe4OZY1d3DOX/zq2rEu3ofeInl62asTBV3FMTNhhVx O4dtEGUdhYbr6MaHEAe2lB/poFO234NDn3YY9CT0SDLqlZ+/TSC/yhVrnF79 xxxPtAcx4BfE9sQblOUHH6wnkU3Mc0ko240vTXxE4N1Zy2ce/+Tyym9/vMMU G49+94yYJxqwWwixptQtREOCe+rR25oln6opfyY2Fnj2QA485n1vOX8n02H/ /DVaOz/rdL+lZPE3RT2eynLvrh70O9jiIt9jv/vApd3M+3w+1If4zPUh+Cb7 EeMM+BL7EfsTcPcYD7+cZN+ADoyS0eBp05v79NdJh2zzsVb1N2gF5jrmhrFp 12yc3YV1ScloCeuH+7H+S6zzS0ZnYb2ecQXHvd5JCc5B7G9ix60q+5XILmFd 6/zdlGUXCrk50zo+eKYOPauynBPWMy6fceQNRbzh+Z7nq0vdN21rmfv9ainL xzG8yOmbX/vRy0mO6wGZansgU8MQmdZckKm2BzI1XJCptgcyNVyQqbZnPeN6 MsUowTnDaIDfliJn/Lf+SiH4a/5wf4UfnBpqV6yf1+sdh/s7krOrh9fF4fnN zW2N1KsfdXrtyeg34J81U1DbOMf8C3LrKPjXKPCTRZWoKQfu0eAPacSr5b6B Qla90ws5SBzVq4GPeEcf437nQ1xzrJfAdyCbOanM5ZHfOMArDymoJ2vKVI5n xrcned8EgTff/iPofxRwo8DNpQDD1nHehj3NP1s2lb/HQb/IRWTUNJzor9Gg Q/q2aq/FeenFOciOZnIQztzc83X464deLrpUva9Z/XKSabr2ziWlpuHNfcgH nr1zSa0oy9g7l+/eNRtnnr1zJawf7sfas3duFtbrGVdk3vaJQT7Bk8iNeP6b m/HR0Z7/2gsHz9ShZ+y/dq6br8PmlAu+a4c4xjP+G3LjPAjbSKkeyNgD/U2G zJM5tvv38j7GONswo3uN7efaDrqxv+7Zb0DvrHPkOY31zvU2dRK8ubz0H+Ae x2rgb5bZNmi+RLJyLONrB9w+iX3tv4h7//goqzNv+NwzkzAJQQYdNCGBTEqw CQQMNdoJCTBRcAeDz4Z2UlCxThqsRHAXtrgd5J7MPSS4ScXdpKAFiRgQXNhF F1rcBUUMFV3Y4vNg/bGoaEPFClW72EINEOZ+r+91zj0/khDZ593P+/4xn7nv c859fp/rXL8vR3yvVSbzo8p9tM6G2CF51I75FbT3vA4xFPgu7tfaKWJK4Drh jfRcDEXufCuEu3YK3bX6qD3CZ2jNUTo34Xm/dtM5cUZwNjaKPJzp2mJRCb5K Yp/Zz/IcDhVTfBvtB8MTCN+5jurJ4PZn6Nf5awADw94X3cxryiYYO084gZ/o 4qUQ9m5bNvOgKsO3fjf0YmKvMA6G8rIdrYWeBe7RiKerBnhOIIPPSwB91DMx TluNPvR2wlV+Tb891L7mpTvTSf3O8r5o9rY3MP6TVZQmCqPltBaEw0Sm/ypk pes59lDF03Q/R8UZKnMN8LTIog9CtLfmG0T3UVou6DF6dpSvoH4T/eAlGovy K4G7Uf5YSnM1Ewyj9Gx6dgPvpfw85FOah9KykU//echDOviySFtr53cHYH74 x4dqCN4BzyshOsMRnv4fbjlnvwoB58P8W3hD+b2897pQTo+86Lbmtq5B4oft Y+n7sXfxmhE8S8I3Ls6ivXyQx7mA5SKnQcuU5EgZgp5hzaOcP2rjEGQr1eaf J2NfgXfN+2xzbAbWCXuMzlKlnm1z61JGtgPfYb5pHGt5Th/4IKQvyk2dU6qL 5/RumlMaezn1kec0U80pzVEz7bG1NDfltzOPWs4p5Q+U1zcd+5PeHZH6D6jv F2ojPwF//VKbHPO8czTmU5i7SP6rIcCCyBQbZEcG9lJjl9rP19J4OmOnrPFY +6diPe0dtX9ojLt5jLRn0EbKGHOS9k2OyCq/s8++yZH7htKz6Tll31Cah9Lk vslJ2jeZat9kqn1D//p1O+V5K1fnjc4JcB5rT6BfFi1Ad+9qzIGkR+Z+gb2g D1Vr3tnbYp0dnAtrjDRvC7Hm5Szz6F0g98PZAv0B8GZ6KwGPknke4Hdgn4A3 Q/vo7SI71lbLov/hjN8bRMc4FM6fq3D+IM33it+6aa+6qs0/vVYi5RbYT2t1 +8dP6OLEuxWvEkyV8reF4bFEK+WJo+XFphmme6TiNOWN6akpErIN0GHRaXQG GntqCH5NCU/w19R55NkALzr5LBljhJqru0NtY3BGesZFYhdDMp3uiVwBOSbq 9XjHENyRfL1+/AzUpze+Dxk814lzJ+v9QNX71Rs0311y/v54AjxK4JMWLxDy Am/QJRTP9rm+PDJv03DTKhtoFtcnlY32k2/ZYjsGlWE0FbzLMgPQC7RWTbTW 6Bf2K9HPU6h/VSV5dN4j8XXclrQmHeVjCT/JAF7wfqiA7qvwhFlu4DJ62lGX LjT6iaPhCaKcyjojM98KebfGYUKIz8vpizgrlTgnLKfK55+jfDrDgUI+H3Sf rM2QegQ+8P2T3vmbpHc8R7ovhuJr00d+ArzKLwKQnR5P5Y3/ubz/3F0aVObs 7Za0axOdsWiFojnyaez1PTXe+uH/FagX11c0nREleS7Is5hfqH9cEeq7X6Rs 8nt30pw7UacuLrh1yds+quviKOVN1RtyQyUZpgmeA8pjj1FZlqejbfAReA8T bKDzUAMYSGNso2+1qKo3ciq7piRfDK//Pd2pm8xltOZZ+A64hy6y+RvCTYDj zMMaY37K5Tp7sc5Rog/xXhskON9gcy8NClvtA3T3rxSFhl3e1eB/1BItWZ5h 9obtt4YsvK880+yhes8IW29ef5zZvDQAzryA9oiP8lhfBWMeCJ8EzEGeb7N5 ksYDnpfW1spjf5u+BZ7pBq8F9CZwLUrvBm4F/iL9g893VNgu7u7bJ9p3Q1Jk tfXZPegX7b/jgc5TMUuO2looRGDRL6fpDbeHaotHvqhn1Ex6rJDOv/2ukJUW bqiZFAj+chrSw/W2///Ti2V6eKwtBF9GdCZ7bhGmF/I50Ef69suPjX0f0dio /EmsB+alH0/PdmFQfiHLQxXMAb+wfBbB7KHMlyij/xpdXB/XHSHYMUlfRDiF wz8He4LO0TzgCCjvi5pvQ9bIuHIG87hBMxVBfgwanp6dl9s3rPfyCfQxojdh D5TfyvtzR9PHvP93qv3freBDYXmQ91JedKyU6ZTgzABOb2J+PXiIheApJcve CP5n0w/3APqXNTlId1S15qr1OSsBp1AX4fhuwvEfk3equS+53TUn6HvIOAF7 ZfsBwuHzSqSeh5/wlsISeT4rUQ/0Sxg2yz5VIt+IiCLsVeNp6ncnxu4oUHDW OlOFTSckzLP67RdXbwc+IGw9O9U6HrPgXxJ9m6IjBf0br+A+rqN2oZfH7YIm strFt20RzB+f6SVKL8GN+wXjojnJovulzZtn9tD9PYT2wzKkA2avaRWuJvqW YGSWWmensdEQVLemb+0uxXrTPN7BbawQoL2KlN7MLrR3ubtalRmJvuBOUO9h jAUyQW5f4gdZkQ5xlNIWWPcG9Wu4unc/7H93fLXs63ifyXNXtdJ+0MDaBc2L ck3tu6O0RkTfCJoLokvsW8CbhY4h0VeTwFvH/NK8eqIRouuGMg10CLIJ71DT hEwIsg2mASitRfLhtUDmkGlERznB98L6t0cwl/YyKpsXncD3h6u2+ATobvAL 6Ezas3j8Q3mNHHLv2YJU3glZOuqkdNQDmsjRkiF1NJYMFR7Isxg2r7Ttjt4r 8qZ6nLeAj1lX7FpVu8g3KUznmvCxa/WMeTUB0dMIPg3arvUUlYFfTrQwvl0I OSTwXayFfl9uyNrrfpE+kfZOGvUnD3cI0YO9NMegF3cYr4g8lDHuE27vVuGg a62Y11Ly89Qe0rogu+SzGJ9Don/7zCHmj8cm5yAvILqugs4MnjF+yCAxjyxv Sa3Le7n1wHxwfeOBGxpjMPb28Sl1pg1cpzh5ZXXS/PavM/0ydbZZdaIO1Im6 rXpbJ7CcwIk6WKaTKdtCXeALIA91Kv2zQmrHifUyxhhuPtf5rEeaJunOSyWQ AyMfd/VAek5YUx94wPLsObmv8hn9pn1rXqJzeIjryWBa5NhAZYH/gLbjtd58 qZueXfJsXXobZSTsHb6U+nQwqc9Ed5izk+ujNPCFvPTvbK/mekv65OPOyAaM pv/SZLwSMB73BO4n9JvatzHvqQ+8kH0Zth70qLoDulQdMwiHvv4VyOSkDBly oGzUy3dQp7i+bRPr0+Shfap3xksJ+Z2P65Z3o1OVdSm9Xqd1B1nzSvDGwfDH Ga/XXbXZ3GmYIq90G+GeaVWu6P1U7l4hCiYIO8uRi2e59XS/94ZH6Pm270LH aX7reCEmDBVarSd92g2GMHn+14tOylsLPYwC6G3RmAIEY5k+WET4pdM0PUOF neX4QnOjvfC4Kld4nCgn2h56XDto/Zw3PEq0xvXAEWgf0ns79aVd9vtSO/XN t9Hku7/paeGk+4Jo+Z5ytVa2NZS2htKs/Q9ZFvY0zXkz4Y8LoUPYVxeGYLIX 88760xsBp0UWpVW2pfE+o3NC9Ax4VFGxU8nZ06ErTmfIS+9FOF+YJyXXLgVM hBycnst84E+OEaXqPsu+jL6M9E+p9NxwR1lpkGuHF8p0ulcrWSYRoXvq4J8I No5+nJ6d8nnkl9CpVM+f4A4j+JhNbRcajaKIcIOswFbcK3yfoA1vPzq+MRd0 cPxe1zeMDen7JoTU/e6z7neJqzAcCKB8ZNXHIQsPQFvxckTzgnYHjMb35dR/ rBvNSxHzvals00eiMHJY9knhKv3ub+wXms8SWlcvaEeMMXzf3bjDy+Vdbh4R tv+CftA6jGd/nSij8Sxe+Ywoo71firsZd7I+0u+jO7k7fJO/hu9kooV5jLsn hKacNs0mojNWHhSOprGEL90qPOCL0T4oaTwnaow8vqMzqqIZXrqjywa6o4tG 0bmP0lpfy/dCqCVbCNg+EXlXWnGXcCI/Um4PTXnXNCuysZ/MY3OLzf10xrW5 niGxtjyRR/OyzRsVWYTfubwHaB/XQQ579WiD/g1KNyjdoPTI/eBtue9hXEgn nIpgMvbg3PJTsYq7zEt8D1TS+ad+0z9gl29NpShcM5/WN5f2dQXkcF01uD8s /qC30+z96Qd0H1DeGirz032izC9yoSe1+EWaU7UmC7EmfB4MUYi25t47pBHt Ru49WhMp7y1lXCKPz94RGpsN8omkftkhV6F0u29lbAfNZV5SXgb3t0JkX0Ff L/XtK9UbuNx3fcta9TSuegb7J4/WJj++dpvNfQOsXX7ftYt4DvUEMpqnzfU4 pkldbPBUxdGAuG5fhU+ICg/PgaFo0kJVd7DkOlk2qtOZG8my7bNIo/9lTb3C we3m72R5feNvfhHS8/fIZ/OlUOMz/xyKOF5lXVO/mJFD+9IRyb4Afiz4VoLm z9H4m501jS9ccDeae2p8Ky/5o5UibzLzzmYR3jekh+79IbQnoNNcgrnAHCR4 xDnhlZRGfSvVl9H5GDnPF75pXg3OB5+HPHkeovPR9xr02SXHY/pprM2UXwSc jsb5uS7oW8+8Gn2knc9XVad5rLG7pga0GPWplMtmcFkH9A9gT5EoGzvT2D2P ysZO0dwPS6xNzDPA2gzrf67SY7RHR8+d7ti/phc6EWmhud0fxegMj6bnxdgT Fac1W1G+uFrpIVxDe8ZjrJCwT8EsR5ymwRnb3NvllXPsBD5I9WZjv84tX7Of 9u8faUwOGpOztvjn+9keBjoVhtBT4MLmS8ErgQs0/5DvF9UGXVPCxWISzXcW wYjG2mLAnTmT0BbutXhbQ/2+dvrGOktVhrk6Sn0pcvL4yoyYUVTup/IZqM87 qShTXE1tZKE+vo8z7pwU9n831D4fPDnzGPAug/K9HQSH9tH9kEf0/Q+xP4Y2 SJ1Mh4vxPV3CGOxb9Hnu6fQY5hnzW16s2dAvmoNtlO/SR/XgWc1D77y+84D8 5HmgMRyLNholbHcyVGDM7ohHeJlnQPUbp4Xj0dNCKxoCfq1tGWT5mKfaCa4p gEXAbwGP9M/mTAIsHKyP1FaQxuuWZ+CqrShr7KM5/5jKnvwoptbd7a3XNPBH pnSLjClBkU4wOtt7gnBvTXjKC+gue+CD0E+J1v5pHXQ9M9+07kuiQ7YQDM82 wPPfRPvsAJVlGH7VeqsM3RkLaA8WUrvZTM/TXjQ65L2NfQh9sii1QfsuC+cc Y/opIVdXAvNwxpPhHrX7OOgonHHf5gtnsdYyfWQVPUubJTHsKdiFqOd2hgt0 bnnN6C7FPcr3JtW/ktpqon40zVf3Zl783syT+Pj5M7TPh4C3S/uzZ8q7QqvI JiQE+H2ehMmpcMh9Du3R9xIOiW205y5IuiPv8mNO3A9C638/nC+jNSiU9Wcd oGePen6BcMiTkr6kei9X91ngGuf3/LRX8hFKhoiry//C/CN907uwW1ytO2NL wsIWCk//jlsXvhp9lN+HtFoncF8xNLH3z8/vv/f9/fZ+rY/2MfYv7X3sZ+xJ 7P/I7UdreA9/9lEsUh4opT3vDBff5Q471X7OvIX1uejcz7/h74SrADpeGXPc YY+4vrbYjIFXT/ePz7eR1zML7fB5Aj8XPE/AhVmAM3dOAl5+izDPAC4QDdZl 8VAINpXSnNWU+8QQ6IZh7ngvrewxrHuc8pdJ/mtP0ZXsUawd71F5vxOd9VVz in4tbL86xiod27NTaW8UGhvojLxEdxHOi06we0tRDZ8Vem7qkGsdaSW8ReGv l9PntfQT90uaoBJ4I+F+ZcCJcUcBT1T8OalL2FeOPSZO+4FP3d00g+VCJSWj CH+vrA5FMkRNUyGdk5goXPkR65zq+qguH+wKIve+BfmIE/JJ+saLux31YM1p nTppzkoxN5x2knmeBu/zwl8pPKByBJVxRzoIDxAX3G250AcRJZHyC5CbiRue pPOyUZSCx0+00+qfUh9++lHyWhzitVhTQeXuluuBOaJvgFO5mzaKokieqEEd LNNK0Ck64fCV1ntbI9MnbEsCPle5h+cD8gIX7Enj9I7kCTLNBFoYevBrCy7U SFo4bTfyXz6Rtri9Km0eaOO2TWn+tgNps9tOpNW0a2kB0MfwiU8/rBVoF/BQ 8+jnYV7qP/AeKQpPqOa9Qr9S+oEm8GJt6edj/IzGWF5F45d0j6j4CDJAOgvj xSTcHeHx2iTYStF60xyFoGdRs/KfqVw34eu4kzLFJEXXuWA7QbjEcLo7T+kj 6R4jWOGDjui5iyHCA4fP9aSUz/p2OcsrPtdHHvJFJv9Krv9NvyJcr8UH/Pmn /wxd955S4NhWW2ijMbhuTuTpQ77v/chZWWXY91R1mCfn0h1ejj5m+CYhn9I7 Ub8unnSDd65nVE1acyItq+KAyCovSANvwBMppvOixhwxae1PMz+IdXiLhtM3 NCfAX8PdK1h3hHWB6Iw1xeQ34L+jX2HfLW7mmT+QJmobAEdugWxbW1MsjHZK qyhn+HFEd7cwPkx9aFlTkOZcUyD8U4Rp0h1xFHttCvQMorbS7xmuKbQH5tNd 6mw8TPNF8BIwsWqlzRn52T+5dXe38EW1wsb5LTX61dt8kZ99HJrionn5p3/m fjbevgYyTC3S21mjD+0p9V5L/Za6r7P1/Br6NG1++OZ5NV6ar/IGwok9t7gB lzG3yMd8N2cIR+0iZyW+Cwfn1fCdpfIJLp+MFqTNk/YVPaXRWcJTcTXRvQ20 32YR3ki4OcEap4U30p1+dg39U7sBtPk9wr9KXDTX9QSzZ9nYPq99IZ8HyJAd bXVpAcgY2h9ge/RSfWR3TfQBUfmdF1eO+e6Frqsi0x2lc08D/7mL4eGa8Wli zSw6qw20jh1yfqqisZO1tDY0hy3QXdbH0Dh+3Fkz5+GVY6oMjdbS7KoZhbr2 ler5bbzf9KHzsNc8qDtiUt2UHi4e5bbqhu4UnVfN66Y5m07wqLgH8l43wZjQ XLOnMTK+B/qaZzE+jDPcYINushYu3lOKMpDdG0PTRKTY71U8xJLyRWmi8dye GqscyjQPNXutMlNcfEa6rT1A9KKYspb6SnvJF7107AH6bvKPqD8T1rsm++g/ U3OFi31ei9ZZWizSvA3mRYNgyl6CJxJep+1k3e9ptCZVaX49g9fc48kQJmTZ AZG+DHMTrqgOYZ8T/XGc1s5PZQk++WsYPni+424tFnZKn01npiaykM4mlZ0z pesqKr8D68v2HUHo1JjNRjRtHuEafr9w3AH9VcXbXMx7QiherVPqtAB+Cttv 8gayx9N/c2OIbaj2TQixbKF1LPbaNV6Dfl1UD+S/LXQv/P6issO9sB338g1N 5kXAfrbj3qh4UH3t8HTIp+3PGWOMSvQP/FzIT+ndC56ZsH3UkqLDn5D3peil 6V9VhPSuG0NEb8wwPjJ88MMAW0l9/dhQ2FvNuBnBEeq3poWvvTUUnv9d6Oxo CRyY6FiJh0EujH7ngccz4J37t4JtD/3Cdo76Obuim/qdx/0+Su9sLzy33jWF +lFD/QnoD49y485sPP0S5k1EnK+GpK7Q+WgKX2uzubYkn/vgpf+LzMtNtAW9 giVGKP6+vE/bx6y2he3DVLvKge045xGONJ9l+g4p0w/Ys71S7nq7e1C7Tdvx s2sLLnri9Rc4Dsr6HSdTbI/HGEHmcw21h6ITqB1aD9xv4Dvp790Ygt0DwTjY 30LmqbEdRNQ8S/1aAPuBEpbRaOCNL6S0xVT/Ni9IYroP2gscO9rrHDuhMwSc sbyO7wpnEu74Ob0vQVkq04YywA+TccuSTO06gt2FnkyN6Z7aai4zBHeAPnRW vB4ql6/KeZLKOfuWozmF3HFIxQlHC/Yg9mJ0jLEM5wLzC9128NVokj3Yh4Rn Rqn8GNVHAXwY+eWGSAs3acn1hqy9RPXpqAd1wg4Q+6n9UZzfr27CvCl5ooh+ 3wiiP7CzYF0vgk2op30805PSjmaasYxwNsH2GNMMvW2UfGa4kAOeqOPkS7S2 ch84uq19ALhAa7zckkPANhl3RkWH2UM0pIBsGHsU8uHA1mwv398dkqcR6fh4 OcHWY5ezy+3LGzaGEJ79qfAwPgzfNvDF8NIE1sFR/OE8wKfEvSdlDms+Zvm4 2PCqcG1oEiPW1LNcpL9vBtv72X1xcOPjPvzbIYp/+03Fv41IesB7mGjQepHF /NuT/fm3+r8THZpr8W/Ti2iOWwbi33rSNc3SZyr4tsjAHRIuFkf1oX7cdc1r phMNcy/BHciyK5NoGKLL1kg+q7PNJJr1JRrjByK7ZYVwtWwQIyKfEjxuAaxw agblR+n+hIwT48FYmuhbjGEl1dNEbTTdq/qeL/sOnQ06f8tacoWL8HXg9yyv BZ6OfROld32UT/JWmI+ouUFfSps4i770SfryqyTeyjSjpFYo/tIKumPo3q0t Jtyi2v98eNHtbujitgwlXMoHvq4D9MOOpT7horttNf0DP1m2tJrx+SGQmaAv dP+to3olDZjLc5J9uXkDXGf/CuDl9kp+BuYRc0h35bmBYH773TQv0IXMZZ3Y klrfkGl4VmnQFbMR7A1ZZcAHh33e1/Whb/v0jbEQegdDiaZvIJq+eF5NbfF1 +5h3WsG8053QuUqZ981mx39n3rH/aD2Zpm9dIUZE7xbZ6BN45NSGo32FyGq/ W65xxI81mFHab603m0X/E2uNdU1ea/Ds5RrH2ujbZprr0j5zjT0I/Cir/zzE 1v5fzEMW5kGNP43Gn5U8bsjZqN9ZuvDWgK/c+CtvDbXnorNUQu81jV1+nHGH 0pWZB98MzGOPUP4Q5rEfQhr9z25hfFJo64YwjCzhfl7Lfow0ZacEfTsHYDXk r1gLgpU7Je/jUt7K3wj4W+nGPrH2D+EBM/lsR6yzPY/ONtEZhxXfXJ3l6L3o j+Kbcx/NZVTnAoyvH998iJ1hG/jmepfimxPs4LKSb14a55snyubpXeCbm+4B 5qBDzYGHYMlQjBtzgDFj7G0vYXwXjqWOS3vw/3JcndA//r8c1/wBxuVX4/Kl 9k+8gf7Rt7J/wktt97qZT0j75+thD9Ha/c7+xUFhvVWWZZnoi4RhMfpudrJe gOGgO7NZFEKvk2396a4MF1ajzTzFixrQLv6VAuZtlDS9qnhQkFMSDcc43N4J oaYZdFZiAnQp3294pv3q0vP9LCcKT6+Gbq87PJ3mT/GDaA+7ojQ5BeXmRaJ1 RNgzyw28bvK9pqlnnqc7z+8tFSbTQJFy+OjRysB3Ujo0btjYQu4q+U3Fm2hO SiIfXSDa0i8id11wM9+UYPOa49Rn6ntk7K9YT+4lGkvcn1WeKGs6Tmss2EZr D97Rb/T/f7bvwpfou/Ck9r3oE/QbfYY9X+RVSie6KImn9TbRQpVW+bjsXWfe 1g4aH+4Gf//vYt2X/y62R9je9MbxmxOMU1U2fUrj/2YSfpMv8Rv9YkWIx/8T ud76+zcyHh/OuzXkbaWL6RDBrW3CQfhYYXSDwhVy6fw9TfuAYGpgkWsKcNjG 02JSZKh/UlGWuAZ2Jp4skRsQUq+1hc6odyvmLFiqf0pn7HWhla8WTvC79O4u KWO5UzwfXm5jPABwE3dEre8/YzcYEi+o9dN9YgRr9E9xX2he30axG+1HFwlH uMg/ST/dH58guLCvdYLQ6Psh4dZgzTrY2H86m/kv3mbT9DiScLBxqTgYfeut bTkVq109pLHtoihs35B0Pg+V0n4p5TOqb73F3XaczvI+eVaZl3mRYMQANuA0 Jg/tkdlE2xjxuomOS64fdUsYkKifaeSkNlA/7YvOgfo38Pesk9JVe/uQafDb Ff5JsAZrptsF1usq6Onp3XQfgn/zaaBUrd+1V7Z+e+T63UXr97DN3W/dZiWv myihdfOEi7MnYd36rhl0RGlucP+fRF/1LOaXlIZLaiBfG1JbfCoWLh68P3zP +9Q9T+OKQsZKYwNvKjwB9vXCh/FjnHqLp4b2M8H+nhrWM3QSQkl7ZDXRpR35 0g8G9spNTtO09BCRjzTwU+ku7QrPgv+DGsCAkvB4gpObzLfBmwtn+mr6fgP6 k2BQEesDS9uWU/BVE1jsmKa/MiEUqG+e5mUetjZf6k5rs4vyR+7EGWcb1M6R Oyl9eOSTHsDjY4HOE9N4fagu1slebXOvdhAeWf8D92ML8H67m3XH8T6jT74D 73dxObyvPplafvVBvH/HjWd8h+/l8y0q7a54XeHVU1Ta7fwv+/ItlZaoI1H+ 9nga63/TM63nmSSd8TzojGNcyEc5lMH8VQpjSFAYS8P14lqd9ij4+nXF5pcB 8WisdtGjsfCiWe/C9xJ4xrzvFmXX+FbG9gWCxhhd1DMNCR9ACb7GkW2D+jwT 0iajxc66WKBLWiSNhPUQmfBJ1Xor+N41z5c/YB5dkiFmBDK+Yj90UgYi8ijN Vj7e7K4tTp9W3mAexrdU9rA+tMinO4vfBW4ZFne5pX2w3Buwb2lbIHXNYffQ lzez2i406g/7n+D+bDYXgxcMXSz0qcXOfv+eR38Ix+mmPJeq/+1kvAHjKh/L dU2EvInO3rm+uALkKdBJ1utZX5l9DEXBw7o/N9RaJHkHhL8eLcoAzStKvU6h tdJkwk8m1cFlRteLTKtMeNF33N5F5lGW/cfX4Vcepd/cqdZhnlqHBRb/ailY RxsNB+aG/p1LM1j30FnrFJXeNBP6Ft9gO6KoplNZrTbD5HWQuoH5rBsYyBc3 g+9C57EUdqg814Z2hMpTvdpuypsAHJXeITfLo7l1wTaa6DNngYd9tLj1rtIa fFfOusjabGqzlJ41+NLSh3oF4xb33x1aCl9J/15awzYE6RL3hR0eP1P96+wK H66HH0/wnKS/j/W3sn9UjcbnUesLHc1jsi9iD9XrYn9niTqz8bzh45T6zgAP 934q2+Rn6ie3+WlSm6zHzWU8/Az+Vsa855G2TvppRblTV9J/6OApvfgFtF/n qf0aVHI4brslSxR00N5Ue9FrpcOWJ1w44Qk9o5jOr6eGcNfldL6fR3/CE253 r8uQ+uawo6e92EHtEg4c02mOnEQDBmjdPPROF7eYqDdjn8Yqhe3QEdpPR+Nn W4uf7TLsqTbwunG2aS31kNLJJDgMHJjmuQzplDYOthHr8qS/1WgB9NSJfqG1 biXYrjvsoRLpG/Nt7D2Uo/GX6aFu9ovzksawphRzAJlUv++H0v2VYXbT3nXB XydsqAbiF9WXw37RPEj/OOP76B96XrvpH/p2O6BTXeGjCc2gMyZEhi/qCFC/ xlettPdEwX/spjtsKI9nEqUFo1UEgwiPbX1AiIagWOjporGna+6GBrHYc5hg 5/XQw61e7ltpL6R9sZS+yeO+E8yjfgtq5wNq57tVURvk8+6B+vyjYrlPv32X 3DcRuhd532AuKQ3zCZjeAj3Ln3wcgl0C+1g0xIzW6axP7qz1EP6wCLoGQltP aaiLxmFfB/xuU2wZ3uN1dsh9T2s/H7roXmkbjfk5QmXGYU/QfPkAC0ucYjHO Gv0vhG4p+oD2qW1vctv6o4m2ib5ivYHIbYTjF/0KPj3mYK8QHvC58TS154i3 dyypvtLL1fcjgnqdzcJG8HmH3jwEON2WPvV0U3/BY0ruX8nl5ob57dndNVIX +dK8PnNwUt0PzpJRzHeoSaqz7ErHjLlDHX36ebzCJ5zUV5zpHUn17kypN6mv TfDLl8vwrlk/WRGCPbVf2N+kOcGeKdJHZfMeYdhFz333DcMuO8sS8uDDroXq qlhBMFjtA+yreB2bemdfro5qs7e0qZF19HXoNHvt8TEFsWdQHvse5Vssm7DN F8/CVqWNfSdePOPNlOc5vBB6wr3Hy4nmaKdvWmEjMdQ6jyJI52g8+4vq9vbo IrZE/1R4qXwI84V5wZzhO8iFLzdvxscMK7v69PVzyBCqzZ4G3MmgDbjOCSl1 ll12Lei+ge6Iz7h4LHKXOCphzcUjfdo4rtpI0x9GGxd3yPW+CPuEJQqfWFte x76kbPo/v/ZPdB+yTRb9L/VqYh3lL/NuojSpUwFZ3H0EK9cSfGxL4ktwXVQP +BLSL8ijn/SryxsVS7g+VZdfu30c4SGZfm3W1Eq6i4P1jxAe8Q0tWbcdcku/ yNT6tgn8iXGiBob7AYXrMX9J4VmA7z0WPor3+N1I8K1sK5+nooHy6buTyfoo 656Rd128ze0ME9FWKdqFjSRoJ7ZXEkOWoS62qeS6RBbhLKBzjrEsJElOh28D zenTdIk7egIinX0BqrrdGAfyYAdj3dPJ37/C+KXtWWUTkgfbBL+4bn04MsqN e2PuYaqbZg/6AqgP+IE+FDqWBFeCl7elteYV9Dbk8ElzK21t6yUtjrm28riP Ddk18XqU7fAAPkUr/eLacxKX+MVpS64Kvgjqp7yZSp47oB0E9IGsuQNOqPo1 G2ugPzo2pOwiPcgH7q54Sa7HJrA8k/up7tT4HEN+p8awDz5I+q4RfBuo8r4+ 7RS2ZCbawbdoO6mtk6sz43UfSvHbbHult69tIPN4IrnL47aBHdKPOdMv+RJ3 rUrYNF7S87P/YO0ZwF/QEOXKruVy/s1Yn0zaRMT9lyefHW/SOWDfvZ9dDLU1 8LzvxHvTaX5e1ndtmz6WOkHcT09KP19mm8fT7CM+pf62RtVPOmv99qHaP6l7 jL5PmkOml9TalONcb5ZrC9sj4Brr6W6l+bcRDmrj8W02D1lrD9kmjWNP8pkG LcXrLdhnM/yu8p2ULPNkPUOcuUbpZ57tYjbg3LkLLJ8o4P0pW57+tqavwv7m mnO6vVvq/cK3itzXbzPPEPqIq8C3Hsk6BxWmaXL6093Qq8IYd/g6uO9HWNbP fM0bpe9TG/97dDv+zW7dceMjlcIl9LQbpb9XJ6dz+ameM6V1xdJWM+5LgMYJ nF3uz5eDX6ebgJgIfm1sLcZRbXaMU35S5yi/HDOkn+tbn1LxEpR/6FsfYztd 7dZVEvbfWhWXMfe3z8Yd1pWs05DqK9cxsb/N7b5BeQOq367B2uXvl41/JFDv +F3/tLQHEmd4Xw2l1yTp4XSqtnZbbVWbG4axD3P4Nc6I32vT6V4ubnpKZNHd WOQXIy7JmAe3LKX0hdXm9jfk3N1SJ+fsljsrhW8EdfWg9KtjO4WYEoTHOytF wQ+CIvu4TNfOyHRtrUp/W6UvU+kBlX5UpZfAv76MSXDLZJZTsD2Ru8rYJFYb B4RhnKAt/dqNT+ifVDxRKW7NDYqPmggHulZ/nX5b6Qe7xkYjEHh92f7AVvp9 umy/X6v6pIXGpc7sHvicVrBmi7HRmE/lF1CZA5S+XqUvoLSFlPac3BNVE6d6 atrhn6+umPaTuD2kZ8SWhAttIb3ZX6M3x5ZQ+SWBZuGle5bWsuoh+Z0PfJDd Sl+hU60p63MZUbGacMIQxqA3Vz/B42gW11I9iwPN3OfJrIu10QgCj4QvfsJX iig9BzIlxEyg+t+k/DKaI1qz4U9R/4+q+Tymc7yOGGIrVLKOjyy/icpDP+qo Wr8q5RfJJ9cDfm853ae+Xyb3pq+B6l6m8laqvHnwgQ6aAPEkqmVsDLTVUSnm FLBvYFn3QVV3QH6vzVTplSo9T9X7mqpXIC4F1bM6fn45/dIpFTcCfcqDPlql +O43aKztqr5Aoj5Or1Hf7USMCCpfSem3UHqbKp+n3ttVOcStmA05pIrdkKVi NzhknIpYL+J10D/bY1YGS4X+Nxf5jII3PrDv2mcRJwW+a4tSfNfa9kJfzojr phWIGeqcNls2+KhDntdn51SKI0dor5QExZE3wsXiWsAv+DQGLxt+jSO+6iem eYZ0TTFMc0qQfj7gQmmAo7bIKSnXoX0NnlehPNfT3lH4VvOL1Lbqm6Fwmgi+ qaBv8V3ggSF6SSbbBxfSv4PS7biX6DkdZdj2tJF9l+zAd/R9Lr7je0e+j+b3 5fH3MXgPl2fXjC4WmaN15un9OVz81hOED/45vOitJ5aOF3ZvLhGsuXtctYvW jIqsuDuk1//W7Ys6CkePFZm11caY+DezzEthXw3TQuHbhRf9Qvn6FT7moRFO lj66XGSqtu3Wd+Dv1xYP2R9ZYQ9FVlSH+vTR0WcMWXIu0huLMkVaVdS+Fv5q LRlBMr+i3Dc1Iy8z3t6QsI/a+p6xTq0B/BpgjtOT1iXfF7Vn0f90on815o3Z hZ+ebdDjpedOenYQbEWcjbSk7zTmLdqxBraDWN+5d7mmgJcJOppoMQfLW+We BZ4yNOlbfDN/SrcQUzr5vs1HHpFxsM0uWEj7Gb6hJtdDVzXHBVkW8BrsgfDt Vy1p8Kn8B5A/h/PnZsP3NePxiT7miKxIds67BNePEKxfQO9D1X6h83tJL8kD T1KbUdVJtEyeyKzaZJ4CvhjOfuvdEif7EmJ6i22KM28NAY+D3h/6QOvMshXo /dGa/p7Gq9V6Hs2rbVhcqIvqUFDaPzvD6dUhysNcZtUKZ6U+hN/tmFt+F7e4 9bTqEOMpLuWzfYT9ETw3tvO7k5+X8vNafv6Sn9fx8xx+LuXnN/m5jJ8n87MP z2H5PAPPuvzWz8+y/Gx+3sXPBp4jaCuonSW8bNXkmyw7SJE+tbit2+on6ozY X2UfZzRnDrZdzRHDCH5u4bmMCj/9ZxA+B18mTkpfTeXSqNwWWqMR1hotrCc6 u4HOjmdUiGiGGugP1S4SUwhHTYffSPp2KH1bQ9/a6H2hXDORXdUZq5RrFisr Z9lgbDb92+l/Rp/9XUSwdR2lXYW0ad3iDO05TeVRvy7ptBeMuXc56e64NFve KReD5b7ht9DY9pT7xjTT/85y38NX0/820Fh1t5+l+6G3Yyrtw7rbTxGs7m0D XkLfFSE+Hf0fJ/o9vSlmiGD9KINwnIhfaNurzQtnLD827CeH+uE9wH6oQOPX wBbDL9IfZH81QSmfaaljn6GF8EOTHHfBwumC9WlOqj8T+Bxwu2qz/Q0ZbyEt g9L/gd5f1kX6jopukanSCVa2b2J7BcKl5TqPeGpu15BYwXT2+/52bfHwmJIf H1XfDKdvHsQ3wQUyXkSAY35w+j2oX5VzUZs0D+2zYEdhpdH7ZI45IYbsJxzI ruJ9OJGn4l+VUpmRiJ9BfRmRWlfbJZnuOk/3ToYvau5Q3ztk3W0feoN2ohld 76n0LJX+mko/wDFKDqZXyv62PafStw9EU1t36JoTdEYkH4Hu0Vi76pNDxhZp a1Dvaer9TvWeqd5nJWKapA2l93LJd3o6TdkkliA/XGwnHHLRvdCbont0Ee5W Kp9VW1j7CsvmDIJzzYjt8Q/nVf3DZP3/cFq9X6Xe37PWid7P0Pth9Y74KF30 vjdpjYbQ+yYZU4/ShEgPilER4CBWfrCZ4ZOT/l2q/eUqL12114BvgVs0YZ5S cIud3TSHe+K4RcK33mzgFmFDXA+8ouCb4A+VuwuoUHh8lVsfWr28nWCk/qeK UNh9a0j/W+Vr4IUJRDvaevR0cXTyTIJF44tdATGcbfKg56H/24QQbGFAC0OX PjyKvv0bKz4Mnw2a97/fW2Ek7/+/38RnooPu+PohMU8e+9d4G/XqDexH+5g6 g/BbgfgMs6PUtxeV37ywEfXQeP3WWZRz+vd3LFhA69hsdiWdD6RPTd0rf8/x b0DXYj/R+2j0BbzLCiFt4KXPfK0mEjpaU5IrHPUd8i4hfMfReN024bmW5iy4 yw0cRdooPh0LP+AvD4jrb9bzPg7xXGS/79bFUabb6+msBPLSp5VcLf0s0LsN 74k4PWkEax97nOfEEDWJeXpsOesMUzrTE2LYQ5izH3WLtIVEH1uyxILKJLiR yXCj60efsd/0o/SvMU7gEen61bD1Hx4ruBNrftit9IRdVB90ShZSmbQI9xuy zqdjkYxfhwpmoewsLqtiCeQ1/voXyxt/vCHU+OQzoQrJp4HfTGdE/DrEdi3j NVfBcvjwP+wOj8d6xvZAv4rOsRdwCfiyX2Rt1/OPCZ9htqnx0tqsbtXhG+DH 2vM8F2zDdExUGWY3dGItuErl6pYE4VuWbb6s8dl+dJrxUTzbf/R75k246Bk0 u1O/+hjs4Ki92Gpu42fi+aR2c/q3F1sg+Qk3bpe6L5f0ZN9rgQVXVbItzAnW 19Es3nC5kDJcupPCk8eapp5B+JOUZ6bcIcL2nNeqT/EFstU5LWQa4FHJa9M7 J4Cf5AhkpE/TtzprmK/rsLPNSuCBqyoDpxzTvFuZZ6OFr68OQf+Q7v7FiIVZ G7xtWm1D87TaB345zfeUcKNf6wtExvoqkbm+ThBcvPge84gWxP2juI3RcTo5 T/lCKiQYneKLTfICvtUO2ZLiiZwVth0L/4fHI5LGM/sKx5PRd84H6HuWX5v8 jtJn6rb6zHhAp/RfiT7T+kOuUIj7v0/sqvgewDcYD+MPnda6xy71XWvvM3TP NxNB65C814405umfteQGdyB+AHj4r/Ypl07lbLJcvI60hCwB+ksD1Rkvex/l NQnBOjPB7Dl3PAJdAPNz6a818S3q0us9fH/UNM+YVENUKPUFPlEdVYYoXfuI cKCPiI2gd45n3YVA55n9oHlu8Yks5N8izN4lW4U9ZTyvC3vHI8yz7EXdiNMA HqV+8EbowWZxPNeo6Az84ykT7VGf4YOviNs5bX/WB389J4VjlYPo6d8Jx+Pp LLc4Q+0MUX1zNTuEA/5b16YLR0rbdIeifYwR82jFNPZwTEr7sy1UL2Qi66he 6H6xrK+zqAZ9oTnagvbBf8G7/iqNuZlj5Sb3bbZx0uxd5TB72n5n9j6ezv4q +/SNxsR9M3uT+7baYZod6aZp9Qn9WX2S0n4n05L6sUf1Yx3r50RFYco++aHQ rLWtsvZJUPJLVXnWgUJsAJbdENih/dSDfljlhG1b12D8yWiYzjF4lDHDCf+b 8MM+dYJ5oby4S0xdZPbq2+fVsGyKzjFitbQX0e+bLDveOxB+R+3VfK2N2RiD Y4VE/dKuKPzAKDdsWxlGGSIP/Ev2DzuU+T1ZsEeFrGPg9v7xqMUnn27cmlvf 8VET2o40dz9h6bEqv5HdkY4nljCMMmJLIkZ3DfAfY6ORxf6imKf88T101Q4P ilt8kQ7t3cpO1w8i+rGa4NY73tJfKnoisiK2RN968xJ6nqNHRsHfI/vXBX+Z 9TioD3Hd4o2QF3+MuHPd1MdK6uO2pDmpUf2azz59lY4JaCP4BfBrw4oZPwLv tk7qUyBGK2ISVJvvLQeu3zaa6Zb5ip9co+ZkHtoOil8K2e6zXxu3EfwDv1bS IGUCp0e2hfmOcCv5TKmB942IK3vPO5LnWaJdTpYHv0IcP0AryVHw9zj1wXcF fSj0axM+AU1n0XPV5p8Q+7WI0t+4HN9c2LbG451Je0ORlewndHqnT1h2WfUv 5xuRZz4LKX440UMXzjdtNEqgD6vuw1NN9wj4hy2de5e4fmqxcERmHa3B8/SH zVhFxSv6mqlCRCp/xT6pI8s/CK3NeaW0LYeI09xX9OhU9kmTDd9Wa3pFHnyz GIiDtdEoo+cSenZ5V7yym55LEf8RvnzoGT5AToBnS+8eyt9D72/iu4oVr8ym /Pn4rqKcYFCeCFaba+9p08UC+h9H/0siWz5jnQg1nqeAg7E8Z+ZbtJebVrE8 qACxRZJiOOfJmNyWXRzsaprzlL/CleZJ8EH9wjZV2La0pOhFVcXv+7JkOoPO 8gyCHX6iLdzQEYg2Gr7oWMRI9cLWsFIP54bq4LtgwbyaSoLl7VMpD3Ks0TRX D/AeCyJul+EUWdGFtL7wsYdnmca2niqN5YU0H9n6UBveXdEi2qcZSekZnO4u dwIngN2FuY3WczZgnPQ3fRd81AsrtjnN0V6O96sVN/i1hSOT/N4U0ZoEZPzt uz6sJJjdNko41zwpXGsugGb+hzdpvp+rNtfUEa4xGbx7ygvRb5lfc74AviJ8 ORBtkTYpT+rGeFk3V+pvRS7+mu3sq36Kut7ZjvPMein5orDq5yZ4wc4W7ifh 83nDY5EO1nsGr3++X4z6ou1hyK3vX+/XJj3o125+k87Ic36hnaYz4qb/yTgr fmFHv4LUH0vumq32PsGld9gmFHJWKQdxapYsUcnNFitbFMMvskdA9uHXimbK uGalj/vFXz1I/elNnPeiYtojGcK2+Wvti6kumqNvnqd8kSxbAw8c/G/dLq4t sts/ZV0DWovAmFMxzFm1eWpVpXD9ICgIFteLawP1b+7XIznveuu1s9b7QDCJ vrujUmTqgfr3GoPirtdk2cMxvTEHcfKOJveB3pfS3r9jADsYtm3Nb7Inlf30 XKQj94n8Djv8ceRhjfkOwDr3iZ2sh299VtdvtWQJIi7fE+JZjkkptMIUuV9Q PBsIOr6P9ED9P8QS8G7T4iuRkVabj9Sps80yesSsU+fEGb4ZMT6T2r0MLKe2 xNe1VW223DFQ/Yj/AD0zFTf5MvV3dn4tnkA4gvITerk65l9JHThf2Kf8fTC7 pr8Mt9N9JfXweRmgH/qDt/xOX02/5+hnL+L4sKwTDT6k1LU6oZ/0uvVXtbX0 /I7e7HXp9ZNHEG18Nhzvw9PrUuiraLwPTF95O53pqh+CYJMDehHS//TVH7K/ ium5f+UVTrEzX9hgY0plnOvy2f7UQf9pu6aLdDrP6d4Ix/JdCh1Ser6K7bqj 6j6ScX5r8T3bntN9H55wgWHVugzpi5ftE6YZ8BOA+NPsxx9rHdXBoxDecFB4 lQ7MEviOtnykQ5eQ4w5Jm3IPfEpy2xE6E7LtLNz5PD6aZ72pp4bw9zzAG6bz +sQYlrHux+4y2K8Tw3lPu9Qb2SJsG2cPtp7Y82ouXUk+3Af0hUp47iYaayH7 QxDZNUXimhbfJvNYU8wokr5YWfcGPosZH4cskfqVw/s2H3DYAf8M29oWsS0y 7Lk6hO2pHcm+K+hu9ST7riA8xOqfj+7XslpPeozuUo+x3yilu9ZLbVcihgLs Ebkdp4zNAv+w0KeHTwG07UW8Xvih+sgQtFYz4BMD9n7t1zMfg/WZwgu+44YP vvJF6SLccGJS+e3pgu5Pje1k7pXxjxjPHWP4qc3ZRNfHoHeG+uGX2C8mPUZr tFzeDRNZv6rKsB3xi6I53ia6lxsN7K30avPLS0W5bAtRY/kiILgOf5uhucH+ cjbQ8d4nCSfqBH/nywOQ+fvFNV9iT/F5pjsXdVAaYn67Vdp8lfYFpQVV2oKd Mu09b655CT7eKW/hzgYZfw2+DgbSS8YdSN9EKX8Jzr3UPR12n5TLaZ+DLlH+ dEpoDggP+Eb8DvWt1OBzOkrr1Kb887JeAsauYCVkrLAvLCyRvqXhV2Yf7b/K l6okX8GyB5P+Ss1O4KXWvEHGQ3W3GE9TXQ7Jm6W5TzMi0p8/9b1DXzU25Nc8 bxivCMCLTskffzdMeVtw3v2aDWdtG+XtMLZLOoPy76H8nSp/L2S+ki648BSV XUvrv84674Cjuh02kibiRYk1TyfwSvou2y9KHqK6VlMfhmF88Deq1r8saf1B MzQPtP5+cS3612LBf+jzwxeF9e4XeYhn061s+1VaIdKOqBgjXBbriDycCb8Y sctaT78Y+zh0YP0i/U7Q335R+WU1xy6ZBb5Xi1/44BOH8J8Jz0Efg+FlUn1U 132oK3XfjXio/74bUWftN4m/jZgzQJmpVhnaN+uEbf3qK7iPcI5sl7sbU/2y rK8cLKYM8FyFO+yuYNzx0pdJ/m9KaI8QXfLFY/S/D/3GvQPedKRVIxzgi4c8 0LcL5nBMBfBQ/GL8ctU/h+pfP700KlOLPQ1Y72HfzDmEu04IE70p2J630egy EnqTsHkoW/Oo5Yfkmy6OazFBIxhYHdIzji2vWmm2Uf8O0vigw4R4ddCjabHm CT4YhG1d2RXM65HL3fPC9rOzg33PPrvz5Vwq+SL2dxt8mV2GXm6TcWO+wvqv ozGvRVl5V6TipjQnj/XHW362ICU+3wmih/rG59szQfJlnxwb0s9XhNhn4X/e CNw+3ce6BKYpdf018CyOyphlXzzEOpTs99CJceym+wN3DnxNu5p66bxTH+GL S+IgmXdGzFHuxt+9FIp8k2jQGW+FImmvhlTeCb7TYfPCdlY9NXoz2/TlRcYR LR0BLv3ZiWgl+6aZHS7uqaF2isLF/wHdc46Dwb5phkqZbbX55xHw4Sh1RP/8 puJh97Ojpf5y/9FXjEH2JWMX+mn1j/sLu3vqM/WzHD6ngHfozf/hlrhHUY7S lexsYj54rFvYHj8zGM8B88pnieaS9uHb8OtH49Po+2NN02gOv2+4aHxvN63n GHTAhby4u8ML7kbMM0krUn+pr2k09pl6Xs4flM2QRt8dp+e8nXnCBhhMFK7Y VckxqBjPpvR06FtSWcQpYZ8s9JxBCFnWL+aLTHmX/v4h/PPa6qAFf38ft2lA /jTkjQpdALfrRowdxid1kUn1un9xt7DRz7FpAvOlHLBP2jlU3ou7KkQ6fduO b3auEDYjh8c1G+sIPltFh1zHNa3J63h2VmIdz2UY0g+m1pdfIWxrja87s35x fUYfeDPA2V07qDyGcJUsPreS30bzdBq0DfwROXFnK5w2eyCZg2rbLu8p8N3W HPn6Pn/zE6XLeNKv5Yyj9ToFuFZtXtxEaZ/TP91Ll9YPPJY1i1PwRy0+Fj7z BAOGKVh2htbgLMvZaZ7bHoVPtuGwl4H9J2xXxKYM6OKaZm2mY5qMaemAj9SF mxqY/8qxPDdNJ1wnI+10VdThpGd3xb3iWm+z+ftaX9q0EjGc7RpKhuDf3q3L eMnsk/QlLT5PCpdxplettLlYVyjDyfFuixwiF/bQnS8Km+4ogp1lZcsoIQIi /WaC/T4qs6dzlEhfkpEPHGkH8Ey5Vx1fKhqXcMwo4SvXbYVOIeGMLi/sS3gN P21lXIDek2jUwnDw9lC4YV4PyzIf0FyTZ8FvwyxXGLLpzaaf2s9QfkLhw3wE tVvW+b7I7nxSXEv9dFc8Sfv5dbNHxjG8ZSLuDOSjDZSB/TnKWWUkThQ7Q/W6 Ky7Eeatl9J/mWxmDHRjkNBo9H6GxZPm1a9+DXY1fOMFz9dD7Y/Q99OGPYPxo B7wctGPJJUFX0LcOfAu/51hbovFvkn7gY8tKMM9R0YK5LGE7VtbT4hiblCZk ++YZeraVCF6bk/TsKBHpDvbLJfHxbDmvvwNvaYmRZKdBbQvKV7j+7wCjjyjY GaD0q+R3n5xXuqo98DmCvBK5/mcSfbh0KNGHS/tauA+4qy7tpOc09J2etzSN MbI4Piu3f2ltxRTqG3QqC9n+DG09hvxogYxBTN8sUWPHuu5BTBRKm98EGjBH 1bP50mzCq70Wzk71VnLf60SWqrMcdCbtpywln0C92cC7E2P/ZCSPndaE1ymo 1kny3gT2Au5S4O64b+Q3J0/Q/TAb78YG4D8Fmyz6Ef7WpB+r3p3ep+lu+Rh+ 4J0Eb22fVDzM/qRsO2lc7MdQZ52ndO/D4uqKu8RVVG8r33VjrTk5uTzy9G9x NzkV3zg98nR3DaXXAUYrX6EO7DFKuyPh06ZgBGzgau9Pm0b/Hrm3olbsHRfB g6sIHvwRdm60niN8m3odtULBhs0XezrzxVUEN1yBIWnTqOzVVPYPVPZgeXA4 0QUXt5T7+H+1sP392n4x8ewis1+cvqgIRKdFywID0A0MsxM8B+hxZiW966BH jY3RQjXvj8V9w12GD+YXo2oRyw+wGriwxUul/V7q1655kO4x6A/Y2C9FY5Ro /2tGw9aOnovoeYSSg2yjd+hQn6F/2BHCB8WSBO/BnE/peex3aFrUnZQ+g9Lh w3GPNS8SFxTjZFx7jr0jccKguD5Qnx+L26vBXrkhN2TxICFPZN1TSu/MkO96 Pdv32WDjGGhwTAsEm6chxmLKc71jWuLeWT0o/qvuHL5XOhvkvaJsM0oC9WnT FtYPNw32IymOUl8fpjFc1d/mCnvBfJvaahmMZoGvv+T2nmlV7eXJM6Vol3nV 5olV2O+K90VrfuKhua20NzOGm9BZRN+8tJd/ERGunfkia9d02stBcfVANAuV QUymUxUG93GbsD16MkVGUhDvY1lyrLUl3UJDf6F7pPdWhMr/QuTBrpzGnxWe PsUNPSucO7YBkrw24Esz4RNE4XyCnrVd9ybhfdOT8L58hfflx/G+EfSc8Yvp IrPa7F7F/L2IdSd2P+Ql/PAX9wr2OUVjuhb3KdWRTeVHEc5xmPG4iMikOSgj fMyaA7ZPb1H2erQ/vwHZDewaaV/5YaeG2EvqnHlVfiny149Nsk+kPZhc9gaD yzl9GznGA9tawV6L94KME2lKntlPQoPSXvfLuQ4sTJ/GsWQ3Rr2BT26bFvjd I9MCn75OcOu16EDnG3IsZfvF6/hKlH12l2Ht2qMSLsD2oKKL9cbsk1ScR8Uz zaz6KfQXX/okEEyfNvcj36Rvd5hm5CN7iNKzU+Q4+cNjEfN2t88wu2BfhbmN RtnvrSdJ5600ye5wp7C1Ng8a07JBjlnCY3nWdGMs62CAZsYerx2XNo3tAjZG fdCZqTYPLh9oHii/str8sBz2HuUe3t8HmQeQBHe8EtfLbsV60rPlqwO+JZQ+ TmrMYHnn0R588bVA0DGtWsa/5TON+ZN+82MT2QZIG/YJ0wAF0paiv+3VF/dQ 2dqBZDNJZdD/fvIbmkdjMFjC8XQ3Qm5ycRydNw/Tootwb49yIz5dEeEcFaep zm7mWcH/YOFAPEPQOFSPg86SMDpon1y8GKowhU3aJX7wIe73avN4Q+TpUe6K XqJbcQ/LvAP0PoR1EeT7LnofDh0Ced9Dr/uXB2Te8WLoHlR8TDDlYg946kWI SUJ0ZSndbWWgsY1/pt9/oK3/+mQgOAZ/hjslf9gOeQH6SW1lU18daIP+h1Mf JoLuTSprSyqbl1T2GsBr0F7gw6Is3S9cDuVRjvLnCdvf9Q4KzyPx+KylgJWM Xx2/MaRslQe0bcRaKR4RcDp8W8Lfpck4xkV5HHP4EOEeoqLDjMEen9YyDWtS tYntSxcPGNuS6sG4QauukTy518ALVPWFNkWYvmWfb6DZUXfVSi0IGWb5BOga H3mD6mTfWHQdZUo8SSurFIefDYobLxHeSHkvNhIZ/xNJY2lZxkc0lnQhFmaI NCumNeuAQn44VGP9XSVDgcy9hNc5ZvjpPtdo7b00F5Wwn2CeINWzhj7G3QBd HfBPlFx3tl/L3FttfnYO9AThnKD1/dEK6fdX+jqMraP1rcG33uA1LdXmFyOQ j/qpnYDlM9h4AHbI/hL2H1Z/u5twUxv0aCKnf+uuNt8H/j9Pytw5xo5zDdvx 9oaL8jSzKhorY16olvGlur8V7RyD/GQGpYOGgZxmLD23w9cXjbmSx0kLGKW2 pxbb2NcLbL9qC++bZukmqW93d77C/NYF6BelvSbl3BlR2HsJ26olV4DHLIGv abRB65yJdQa/XsqvMwjO/H7XgHC00QhRfg7mUM7fZ28SXFklcZrmnq+DQ+Bb J+zFNeCvjnbmV1/3guIXtPk15zn6X0v/u2gNi4wVzKPfTmnrKO0pgkGGhDUX Hid6piNBzzAftRM8V4XHsv4L1lfnGEbZluwOe2UL1TVHyhQu3CF1f5xp6A/l bcP+o/cHqa0dnR1xOcRBWW4IZDIBKrcH5ZinrDmr6H0f5V1KzM3vX6C0Lvp/ kP30fZ/mnM40cB/sB+YZPZDgGVFbpdXmb0dUin/6p6D4p3+GroC+CHYP/xQL ZDgrZSzXmvFE2/M5KV/kwB4oa9flOVb3EeGA716qNs9/ORBMgfwj0OwnPH5I e6fOspPdgXq8e9+BDAPyBkprMU7z/moOfJI+LXAKeMbrhGc8QnfcyznwT6fm aTV0X1k2oA2pkv6GmixcvnsgPtTCZjFj4VZxK/ZCqQP65wUu6OXrmcWu8AT7 cug4g96u6DaBSxfGdc8Q90nxo4rSxWeQT1EZxAY93lrP/nvSgIcAPhVAH0f5 MWRd//GCYyfQPoc+Pr6D7GNLi/Rroak0xA5oozSbijeJtIvwieJtEg7glkqG NJL5vcl8s83mPCp7gcrWCNvKPSk4cx3Rnck4s+UjvtFwINYX+JESb33nZRVH SbXzznNog+jWxRyHRuX5pNwZvA0X9h7j/c1Y83fC4MVUm2+zjNLSb6HyZbSe buXHyZIDl9G+yEvGe1lPTny6VdnDEow7C17GIWkb+Q5kXkS/Ro/3xdf0NE9q /OWnlZ70I4SndU4I4UwTfMyz8KcB4EmeX0tL8+YzHnyc2hgUD8a5UvDLisHq UHCr0K85ouDBDIz/wfb203F+oT0EHibdJfVEU6zkth7IDQGHZ59cQnwX/0+N 5eeb8Az9A7x3NHFauSpnwz/0VNW7z/LpBd4Xvd/Mfhmof0jXO19fIv8fUf+3 8X/HM/Ib5ScY330r5bsu9V2X+q5Lffeq/I7Kfdvy/2D5ggDMQH9bJ0gciH3c TJD9VGlZA6SN6J8m4yFbaWhDz8wGz5DtlJN9T1jpPvhAeyDht4RuzW0p9jwn 6Ewn2fNUWLoKBBeb6N4H/Qdbb4v2gzx/TQjwxXaiCbJVgnGQLXg70/4g9/uv R0j9QqeQ72eei3SMAs2gIVZNR57Ig2wBOh/0b9ugC7ukP45vt/StwmOJRowi juCb+3fBf6ku+WFr+Bz+ehzHB9UlfUlpWWiT0lxedXYpzVVtvnmJ0txeXfIQ KY3O0JunqW+VlJYn4fKb7+Es0jv8FBrV5pePs32ooewvdAF/mg3QK6R7T7Rk EmY/XthbHxCO2mJjDGJkI8Y37EMpneDd3SE8wxcReGhyXB+8CbkLwQ2HLka5 2ac3dCZZ7gI482at94L4nJ5vpbZnNH78Ushr4OydwZ1e5A0O3VNtfsxxQ4F7 tGWjzo+fq7hLu9ZYTnXNYN7ZLDpjs1+ktVRnzC/XOrybdZVZxmF7tmKsrTDu a9d+yKfwgFMWDITMjmDDQuWPBLTX/Ba6ax/VaT4cjMveQvvs+CA6DDMIhtrk uI6G9X3vuytWCZuedwg4masljWE589UH1BWVdvJdym5+D3QlaS08kfsgI7yY A5wdehloA/5HqY0c3PtsY5tx/nncF+zXwBA++c2FT9Q38xPf/J9P6Jv5kNtD XxF3BPA2+vdLnwvp0/wa6B/wwoyFVJeh6lrfMkosLhibsI1K4Mr+csn/MV1S j8N8zfsw7alEm0vD039t6TUtRkxPSza05gTRjbDdi+TG7xppL/J/plaK+pWg 6YPiu/U6y6HZJxHLhJpOpMqEVssY4NLnk8S/bgId3jodulq3u1uIRiKa0pr/ bqUjsaclwrxEov1XtA3ml9CKbzPwmf/fo1PP/Od742d+Xf8zr+SL6twf25Ws Z+nNE1nQrayYT+d5g8jaqUv5mOQl/O9iSnMleMb/O4fe3d74nf2/M5inE2WY Yel5Ecx448vkc1+xAmXf+FDJJB3y2zfewFlK8N7feBk6q8YBkQV9FTq/nyu5 pZ1wuVrvx+Jz5n/TWYXdtHV+aex1FR3qbDZjLrqf4/tdi99/pfJsPuwZFC9R 9Gm1+eeZSu5USDCoBLAENre0tqeUXAXnpsUvLo0cCI+oeFr2m+BYO9WDmPPH lR8UNc4j76h9lmXtM/CtJe3/58Os20c0BuCWX/TuYjyTadQ/bJc2hL3Qf9D9 4vhEheN7FPz4K8kHgu/kXx1QedC5Wwr63C9yoP9So/RpLFmmzxsRZ+Cvhc77 LMb1BMdaEERXfZ6QlR4p6Hs20Jbq80gJN4Hvf/SaTLtUDJouUfeFL6r7+Jyt Nnu+6M/HWe68Ih9B4oPJA4wdeB7tvf+wfMNQG398aGCef/YnikfvSJqLY8IW arlC3CurD+7l8ouLBMOOhy+De9G++nA71ansRUKer6VPGxnHzU7WswUu4BcX oDeVR3V6oCPKcaVozoNbjZuqzVO72C9TfqquqKUnSt8UQldU8YWS9EX/o4rX EPAwArnSf0xGWXq+Wt7b/1HgVXZX7N+BdUZNk2BrdpLOaF6yXieNdxzf9bwv jj8nfbAcv29gefePv9aGRNEceXE939TvxaC8pxVx3pOD5UCtkp4FHxv4OutH 0T6VujGHVqn9U4ryTaYoZT4H+5ihs0xneyC6MtLLPtBOCtvfLhtsLNDJTPTF NJPk1mWIHxlN2EYxnR5dJErZn9xQab+Bf+UXbkB9VsunnbA99PlAMd2SdZms fiTJz+YhVhq9l1r6ENynYp4DSpuHPpxdc1rOjZJh5sVjR+VzLIZ+sd7AewUd BR7Rml7Atf9cqubYDT5qtfnvI/h9M+EpHYz/Ov3i/RwpF3iokMaxLume9Ktx LE62U4H+DuYOMpj2qJiBu2INzS1ijPo1VxXL8rXqEZC/Kl5GCduSiq/AT14c pW/iMSSoDcWvX6jwJJf0yfbuXvgInpRD3/9Ug7+kbBnP96uZJdmSj4k9BDlr tfn6VKU/2ln1U20tzivrQzFOveMd6Rfr3Qa2JaE9ATsS+LFUtiSlsOOIdP/a Td/WVJvP3Fdxl9DWRYSnZJRIU7KH0r42JER77Ks4IWDbUqT4ynR2/71V3WdL eD+vkPsZcTL1XN5TZfCzkcxDkvP/zhvxNXoaa/Tag+rdxbJtLnNM+skS594g eL+PdYENuf8qCG/gfki8G/3QVD+y2ZfsSat/r4H3ujA17fV3ZFusS1Ai5/jc iRaqs+UlMaLlA3F1y0VxTWuucLdWiJGglyj/QEuUcLFNorjlgBjfckJMaKVz 2logJoJHRPmboC8oz0dsN+Ab/S/h80Y0+BrmwZ0DDwd8LTc9EzyNEWz5my0p ujh1cfqtMsVOCny8qGCaHGvKfqRlfLTVoPGS5EouthP6qWirNjc9xr62G957 HvZBsCdSa+vqJ1eKml3Qv4TtBXwIGIuYX+kx6mk9CSbcQOcG8iHksX+Xp8xT RJe6lByL5vTgPdDZoX3uIdhVmCST8ibBjWXCtnT3FcJSybMDLJV6odBbZ1oL PEXDLu1ik+zQSvyEGmOfQYbLvrKDA+uOQu8e/AXI1uluzpN8kaV5X3dHoH18 C3gKm9bL6fwTPCuBzgb6ptqy2nlb2JbsHlQOuSgxfuhg4z7CXajGeHk+j10U QgfQmhPo2ar2ZlzJ3Yc2LL7u17RT1KcNwmv+unuwNm5okncSz19E2uSBFq3a KLKgvwj+NO0xyJ+c0ubhzV2psOHAnP6w4e078S3tV9aTicsfLrcm04zKhP47 cKS/LvlamV4S3Lqcf0zZlzeT7d/KmmiMvFdlrEJqr6td3T9d2A981+VK/Rzo RikY4WSeuHgLMoZ1wvZXV6LDLZLWzAl+wuV0uRVt6rJ871KfCiAHhO23bu/x wW5a4bo3APe20n2G+TnqRDyLFDxA+tY/FferKuWxedJXudkueVfMYx7Qtk3Y HjyztiCWNP+amn8tRZ5HcFTZFuz/UP6/0uC1C3sgV0wprxBMk2IegWM9Pl04 lgSF/WdPC8faCOGTwWuX6EJbCxkiYmkBVoHPATgJnYHI09okqm9rRJXjPMSO pj2GOpJ/BvXLkllKW23N7S3QlI7pg4RDfJUYS5VTrZWTxwLeI6/X9w0H/GQh dmbgkGsK8G7ME92pHsC9tqjIa8P+2jIhVIE43sdv5Lia8K0N+6b2OsKX0m4N 0T/LdWnN1801XFP0fJs7ckHUNDF9cnwT2wYQcAevAjo6TAfXY83374UdeFA8 0on9R3D7r6WfQ07bqufGZTwu0MhRaaeVjfuL5YW/ojo/BR765hsGje0lGqfc E84idcag33KI2pmDO9eyWYedOuAadAvgNxtyRtYH2MT6ZyPgRxt0ONHbGKcH 46QxF2Lc9Muin4t+ROPEnjJgs14g4z7Ivf1fKq6ny92muUoY3+F98nIV/GFJ nPvS+h91CXvFx7R+XXKt17wq6fnIa38KBTLieyJL8Z5oX7z8mHeMsOsidW/o H/TUYAzgIVG/t4K3qL9+7RLqm2ZQ+y9RP+ScuNTeWEQ0538lnWOX2huu5HOs 6D15t4L3jr2ealvmonPtUvPtUrZlvQcwh/pr2dwn9EP1CfZDoMuPCNsDLYO1 T3uPfQdIurp3KfAWxbui+ve10p73yDZ6ktt4htogevTSsIH6RW26rXWR5yHe ZkmyjAZ7vNp8aT3f+cz/uQi+TlFS+xk/wnkmvDSSdJZ53Wj+B163l97x5g6w bu+rdZv5Vkj13yHXrXcWr1tVfAxq3RpqUsZA65o8BmveuO+ACR1j0f/JqfP3 0iz0HfAD/VsLOpnmkuFR//kkHOriywPvoYVf64cB9xvri0odhXRlm+YbiK+r fNfz3qXx3zPQnaHKoF/gJx5n3QjmE/XCvukorT30Ow5ZNji0/0eA/6juZKlH Im0WX4YeCJUPy3vt/h6ClUljicPKFLpRwvoXM5h+VLJA0LMJPXon9TkOfyRu ogmX5ZuInt2WD26MT9EeWYpPelDBvGeUr9eSOAzMt8pJnWg+mwSTFN7wOWAj 9DBpHKWDjmOVktMtyFU02d6p/92xoIyMBWF2x8ez2XzbGg89H0LfvLADFAzP PYRP7Gb4IVi3oUj2e88BNR6a/x+G/nv93rPqf7LfoN+S+trFcsZ4P/9tq+rn NmG77+h/r5//9uH/V/NrsP/hf3tQ9XUL9XXQ+3+Avk4epK/97tWkfV2UtK/z 4v2kPd5UxbR78h7fA5/WhLcVKpxuNvObNxozpL7HC2/K/3/NATzGM/xHw4+u lHH862PQ64h0XHCHi3/r3jCLfWBivEH4PUFZC8egsnXQeYvMYpkN0VIL3Clr F3U6U9ZugZJPSX3zBXJO/nX0oOtHdSSvH2hYGbPg8nOCtVPnvqSEeUjHvqQ1 3c37kJ7VGm9BOT3IcccQ67ksOkvaLYNHVykWvBUUOaaeKZ4IV8foTvn7JVM9 Ik0fKmrqit0CceCk3YtoJpy/bKrnhz8EjVNX/MP7wxP8T4SDsSXh4u8vga01 x0QhOBwQNeMV/20G7JxAYwCG0lotBL7m7RALMK8RAzE9X4DOTI3UheqWulCt ktaH3Il1nMTJ55R8zU/PH0pbxR+0XQGvO4BvoWs1uO3TD2YMyutL0KzZ+ms3 St07RxIt1odf1++u2sT3S+hydxXoWtxX1eb5w4qOs0l40QO+f2dSmWeozFZV xo69CF9i1eaFOxN697Ch/XivKuNQdxaeISPcocqfsHj87ANFfNyaPEdUDry9 BZQOPwgL6b5jXTXoGVGeS9ZxcaYlI4EMEfodqp10pW9XJnWUHGyvCRs+KlMq v+19jc/kRmMZxzqo/32w2nztMHgw8GuHPSr3A3TlYj3ePHFtkfTvlO3bb8Jn x8IkuUO2ancIfACrvtUm9Q246xn2ZcQ6X1++wzqUioaQdfwRZ7OyjfNjBJuD ZSm0c8KHaIniQTt4f40xDPpOxzmDLlzT9w30fSHgUDudsfaHpW1K1UqtF/bo LXFaW9tC5VbT+NcqPam2/npSPwOu2CZh2M4D4Luy/pr4bU7SWDL6j+XLOXIc Z7YqfbgOvzjxCf130v8m0DwSn3lrPeuwiROPUd9WSzr+rVVU9zbL5xNs8Kn8 jmR4Af07pvHBRy+u8eqCfhlx/cmdVN9U2be3yllnrZHwJ0vnttHYTfl3Unt7 OhO2+SGGEbBnZv7AifLUffHqLso7SP8NVO4Q9CyBa9Iey7Z04LAvQcN5hf2U pcMm99vOm6rNc9uZr1EVP/MWX2Mf67GJ7sOdEdZjE1KP7WrImJYwr9EQU2gd TifxPlQMlaNfsE+iDsJBVkg6q20U2vuXHPabuULKQ4BHsZ5no9GM/UBtFUge 4fc7k3VaCN54k3VaLB9cCR/4//Ig7g2iKx0BIfbP8RxrCQitBXKBBcIulMy4 1doH4AMwnEUdTBf/yyalH0jwYC90Sp2BRWnTyhd9E/L/LMw7dADDP7wb99UK bzf8Zf3yMHQ0CLZ5U3U07jl5RfE8xG/gQ8k9ONy9Z13KPBwQvuR5sHxmsqyk ie7BDJ4XB+4WmptSBX9nU72+5D5Wm89D7ptt1ElevTUflfX697z1UcMvtMNS fpA2ETJZpv/hm2QT1XeA9vEJ4YpqIssvPnpOjcGCNWuFbf6g44eNquLrUD+6 zklcqus5tg+M61c+95Skpweak/k7BtsbFZYvvI0yhgnWWMrLn3s5mi/cU4Nz PqtbtCpfPzTvCe8p0wzfP++JcBrd612TluhpooaO9gL997ElSzOEPdwwaUmk Bf5t/TXhRdOW6N2SpoT/kvAD82p04y748CvRu6Yt8W0Ubvm91qY7pV80utdd 8PcKW8EqxBoQHBvNlTdEe7B2EeLq/dYdXWT2Ru8VWbr4hhv+xXTxHfdUz09n hZ02d11x4ZpwEeEQiF1QfAvhYdcqPCLbK2N3+eBHJXvgfXi3ZfsxoJ6ovijG vgwrxS8nBcXMIbpdPEF4jQadJl08siRcDfxmjhEeP+vdqcH2zYiVVbfoF6+F 6+c9oQOnWTTKHV5EeE1wXs3oCVe5KkVLC8oERUsr6oLPeFkXzSv1dbRHVJaL IT9HGcScbV8gnG0O4agVQ/bfADuen2gPlmRqi2evo7l7Uuymey7P9wjN3+2x n8KfDPjM9LyG/s/yN7RX2h3CTfPuUrLC0bQHHUbMcGDODcSF/V1FCLgZfDCD l1Rl0Fp9VhFCffBZI2H0t9zRYrM37KupifzED31th6/DhB/9vPLxtJhDpL85 asvVXgh9h0vwi9fPhrsqagbA8yprNmNTPXM+g44xzkFd8ap81jV+IBfxlYOj F2h/Tfvp2vAicW3trWf213rea4QvlNriwzHowdcuOhXLy9Qe1OtpL9SPd+Nc 5tWzbm62Xv8tPFfq9VPU/y10Zh/5ubf+FY7NUX4r/H6yjVkHzsh+8BJXwNf2 GSF90ef34Jz4hX054HVwgfAhT/rCzu+h9Cje6fk8PddC7029X6D3mZBNqveL 9H6T/uP4+yV6Hwef4Oq9l95H6svi7zF6T0P8DPVu+oXtnP6j+HsP7FH1h3JD P+oQryBN+r3O75l7V3oj5Z2W/oHs2tzs9MY23B/2V+nd9uX3vkrfT+8O6NnR +4nvvcvvzsZXf4H3N+eWp8foPQuyV3o/8L21Q/C9q7HpGbzvoufsxvoNeN76 vRfS92NeGp/5Z7w/TnO8AHcpdJ8IT/Gs2SDwDxpj9osJOYBf8diPAQ8aYL7p DrVlwPc45jPYbBqpc24bRveha7ox5zN6rgJOkpgz7UvKy67vWJVPeeOS8mh+ tXcoL0vNT0ZSHq2FtpfynPg+KZ3WTNtE6Q76fy8pndZWa8WdTP8HktJpD2hL Kd2t27vVeZZnmWEk7VnKb08qT2uqVRm5wh0xqDzBrEjHJPaTKu3ctfuSytK4 tZG8zjPeCqn3tIHwEGH73sHL0R74HrAM30ufCGITYH6i/6J9SVAYAT29Ef54 55rp+632OYYU5SfmU9yHspejWaBP7hf/+bLS34aOwa77u2GrYxqBfPhqP8M4 jRyLKE/aw+hHMX3XnKqfdMPLffWT+uRv7ZvPMRrqT0yjfZmJsgExZBrjMRbP LskHosw/FSO4mxkQnpsBd3UBW4f0aclxGYWt9mt9Akr5oLzjB76Ta4uuxP9d kh6I6+vrDLz9/75fgbbB6FbL1wrh284k/YRs2M0ZHC/k2ecsXR2ps78njfGm jVIXid5vusxeIdzm395rYh2AV0dg3WBnx/b5hEtizeBXS+KeW8eBRoEN3rbt lA8fRSbj61n6sxMIb9lTJ/VUvntwML8x+gc3JuzfCM5uA33YbAtZNiAFP4TO z2Q3bEAgf6HzsKwJ8ii6842HIUO0sS9VD/3r6exbzKnn2kMWrRnpHuUuyrdx zKQKMyb0/PfdRcImIvoH8L+OeGNe+E6ATBF2XNXmljuMURxbkXCK993A/3G+ OXZiHz3hsU/bMF6vvv63bn3fsRr6doTUYf3O0cHozLgtBMeKfT8ez5B1QqXd rS+xlltOKDmpj+g32OVmMF5GND7kZlgf6A7BJxHRRVvX6Ep3oC9dlMf8JRvv kzDbJhFu8hupL9hpHpVrfmB0XAZH8I1lcJ9cVDK4Z27qt97UP8jV5Hr/61IZ s9hspnohw9GFbc6hK9BNKPWKUZlUV+VOlqH//EE13tXSHtE0+ZxwrLODp5Ue 9Qx6Bt+0BDwcKUtmGdTscLDHG26I23OVpuLnmy6xvOUyOgLhIPRT2CfdEfWd qWxdKqk97le8Tw08VvCuKv1i115JU7Y+ruTlAba7iNsBN768U/qoqxS2mt2D +rs0hKbmxY+1aHpa+qiDLgn88Md98fTxC2nJkwnPa13DugfgZ9b4r8T2lNbe 36THY04PqC/A9bPPyc5NOHPMC4UsF7Jxw4Z2R6xh/oB5UNj+8uiVwFX4VWS/ egSbVDxepvlZf07yHubDDyTLZvys4zNbf8D/PPT+ijI1k8vBFtXPOj9Z3swY +4RM+GE1zcv5YcU5ItrqoVT4jpjXZhv13zUY/C0PxnUVZyfLOlEXYkYl3RfM 1x0oPmy1+S77OlexZl2GXZ3PzXwWZ2NOLL0PzLvs747XLP1C8CGRXppBcDI4 yyVlJP9rnhVnSM27pRMYUPdGGcuoDMvv4cYv2CaR7VQ23kQ0CPwjBcAXjH7f wNwHK4WBmKV2ZQ8AuTbk3EXtVaKkXRNlbSdEqV+8/Zily6H8kgVovlPi9yTj CNGxYoelZzQYLkHldl5hud1XWG7PFZbbd4XlugYpl4hh+8oE9j8XqH9kGuSt Erd2NFi+5th++HcXQ+UehmHQv3sHPg7i906/s8g+L1gf6Ara0QZp5/Gva2fn FbdjXz9IO7Vf105boh32Oc3tRGQbrJ+zcWxI3zcBtBTfWV6lc8D6ya/9KRR5 BHd3bKQVv3sg/Obr67a9c/m6L534f1n38kHqfu5r6u5+hel2Nfcf3RgKbE2f gjgt0kan95yMK0V1Gwy/nXNPj+nRxexS8AfXjWEY2I/2v4J6nxqg3j9b9e68 fL1H4Tc/8FL6lHjd79/Iug+q7jKO68y6B73lSW3MAN9u7mdjegjGEQIxrzTs EaFI9bxS2LRxfGalQ6Gn20OSP9q7FH5bAvXDY9D9MmB7UhXvT+l/vz8Xtyf1 x8+wVvbpz+xr5Ir6dPHDr+uTsM26Et/bIukucbO+YPy+Mc/y/Ud9vbzfTv/O K9XZTNK3hy8JB84py/oMAV/RTvb5FSWYp8pB51/SlofrLu9L3V9K7Xcl2Xha tkUzuP2Hk3RG148NQWcWsTuV3uwewkkchLc6Wb8rKjoqcoU2N2KMmUvUM9sd GCL0o+4hKHuo5Dqpp8932yah/Itc+ETx+22URnjYhXeMUfH5LGE/0OOPTuqk NQs/8Gu3whnnEX7h1DOPTlLz3F1hasJqs8ow29An6CWznnjUXNzUIftMZWuw b2guZrx4Im7/5GP8e6hwbCoQmTesl/qeUg/OXOd72Xy7opzl3qtVX6+ivhLe f/5AiyayAtell0JuJ2y3DcqfTuKpOzlOitL1hU5eewPH0RzQ/w3Vu7qv7TbD 8T57kealJWoXnZgzPdOHuQ8w7j1UeICP6WJ8aEkG4a4/8QEPgO41bHRoTj01 LBcVfvbDQ/vJTXl5iFlB9D7rb5YvEu6qDsKlNxoydrn492GX21Myvgxw25lv f12/rTmJ992Duee+z4AeNvQYud+Z1O9Wnyi/VYAv7jGaqN9DPT7uK+FlusPG cXoQM4rwevT1oOprtl+8ftn9Hx0vHLpjXo0e5DgW3arv8JF56BVNwd0XCRZ9 IP1gweZX6blW6j0VIdwdFQZws68e4zv14J9C3i7TlHv7q+Xsp47SkEdwjPbM n2E7lgVbD+zdQMaQ2A2t0o9TYKiYEnCKm8vvMs2AGKKXVxB826iJ8KJ5PeFZ d4e8h4UGm6XIbXe5rTpVOyNKcuR+le1Ln96wI6Y9P5b2/0LqexZ0IPk7afv2 GJftFMMo3VBp8f5S+lTA3Wrz3Be0x50Kf57NeQeUXaX8ZrRxQOqMBl4XY/TX X7W+d6A+Gmslx8fp428zqZ1Kap/O1jn264A+Sxr/z1Nh4xce6uuBrVq4OGn8 P4RsxIS9DGK/wm/JKaNebFH8FG+S78cS+cz3eYkuitj2r6xeFCl83oLTx9kP XUIP3aG+ydJFKfvroTRnIs0j2Ce6XWQl0mRMF0pzJdJwzsy1lObmtM1mJ+AX pRmQZyXjqUYa/T4h+vI14dHTYL96KToQXpuACbeE1NnqYridkMEw3A48bYzB uarvNtn+S//ZWBlTU88NTekS8nzlQaapYCadqbkX/r1RH6XiNP4tbOV2WXEa S7/XbYyhu1UAzioYexAwFDqw6N+L0scHw1Fa06toj1zF+BPLx/60PclGRsh9 9aeXAdMJzvbUFjumwd8HbEY49mynuRb6RrTfsmjvXRW4Nh02RTb6LjOpzrCq LxPnSqU1RHoeWdJJdGYn3S+dKH/++0vmDkmfNrcoPRaZ9Zb69tKbaq+sg+42 7R3G9fQG+7OWT1Sam7d1cYx1YiJBGmMu4X15Ypt1DlLmbnPspOpLJfVluGzj jy9Q+87OEyJzE5331gIxHLLOuQ7qy7j0mF8cgN3RDmte1BpDRr3NSvOL9Drd rvqAeV7B+u96sl481lP6F0sbaeDsyPGdvhz+G/dHpg1ZNdD+wplAGuEsLoaP Y+msN8OXBG1Yyg8Xjw2xbjmVaR8ryygfdafKZ/C+9+Mb1INvwsXf5fLReuoL YjyzLHKeD/JKvfUb8JeZ3dYkXO3jaL/Zb43zjpneSEMsCL53T1lyWfiggJwp sNc1hflE/6ngMuIhSrjs1C9UhMLZtybB5i+Xe3MI7ufxHeAMEAoTFNLem/Cl AMEvpwWzJEz78oAFJy24SWn3JMEshpmUNqAvBYb/KfD5y6X974EznxDOmmXZ Ty4lWKb4ih21xWJKuNjP58LbSvAONuObMI7YekvXCHDSGhPB9zbwrSw4bLVD bZwvyVX2grQHcfezrogGW2iONelk3S75Dl3cMwx/k/vaxfosu+BrodYzRFd2 5EU4n7UecbNuiKOApdR/J+Rovs3mPMjLYK8t+Zfmsbj/wgLhtvwXWjSXin3p aKoXB5vGikNNt4ojczsQd/i/Xpv7+iPT1Hxny3n8r/dAi6m0HJX2WtJajZJ3 yX/twrhxZipp/QH76UyUGx/wveUJvN58c+Ie/K/nrPFjPjAujAPfUdlCb5cL 872FaJjzxvuJ+UUdyKfvH0z5HvcwfNoa/J0PevTGe1xXnvzu9ZtVu8M6KV2N pVSlFSSvDe/LxJ5zBF/Hnfpf44wBfF8mxvOHD5O+uV6u3x8OK5sJac9QJVzg BzR9LA4Gnk2fhnljH/xEX9E6HGpqEkfomwdLlN2fmkMa68Vzxm94LN/wvk44 yuvN09iHL9FXVP6+EhVPLKn8a8ZxGiPlozzK4hv0i8rfZK1RYq4uPo41YpsS rv91zPFoWf8XH3Keqstqm/K/RXmnB+KnJ9smKV4QfAYybcSwwi4O0e8gwYBS 8IgsXFn5ldoHvTfCJ1fTO3i684ED3yIIR4yIg3F+f0QcsWwE6fmQZSdqDGDX RLQN7DhPwT8I7OfoH/rusNs6UmLpcREdRzh5HnBxugfbvEPpzORjPcxmKnfw MuUWqnIHqdx8KnfoMuV8qtwhKlfGvAXmUdueVfeoBUMLcT6rzc9zcEfPPf7I NPjaBmwieL2gRGga41m/EQcNUxyJUn1Jey6dxgVfmIVJtlmuOA8cd3KibEa1 +dljdMdnEmxKq1ppYpw7qK0hhCNtSak/ccZpP58/R2N8m30L0D9wKbyjPNKs b5CX1BbBt/MvG68k0mi/NRhPy3fCN19g/o7aw7hzQQsBP0icrd4DTU9ze4XC Vp49aNySoJQRQJ6LmFh+0ZEm7fnWW/4fWObhF1ctl/TU+hyV3pWQSdwv9adZ p2vd+YjR3QPcbHI94ovkuBK+ZOj8sxx8RI7ld17Rqag/B/JFjhcoModZsVNo z0Pvj+WN1ebffViST+ez+WPWs5M007ATwDdY3hBlXfps5ZOG/b9CDukXezjO DcH8gxVs72Huq2DbHfhS+3bPoL4EPHHfUVJWI2UKrJsb/b5RGh1jFBoxo8j4 yPAa+40ytlUrkj4jQd/WVvsm1c5yTdGHfou+KZ7EuMDQySx3oDN6cmA6+tsL BqXPle44x8+CbDIfvv6pjQYxqdp8ZG9STK1rVEytLOVHAPKMQks3k326E+4F uQZ0ML8+3tzNg8ZkiMcEg48tv9IHNYTXmyltDNh/gZPTfCwLdkrZQ2AodMKZ XwK96DJ9kX/SQO1DNqN8ihSyrrGT3/dQvwaNSRPv1/epXw8o21uD/YAWIS/K viB8lt1fIcEejWUimdL3Xnz+6N3gNC4LP4Zl1rwPyF9gWR/8RNxk+WQ/Zslw b2iO8xdKkvlXwDX0ixUh30aCKYRXRq+Px83YXbVRNMO/KdsZnBY1RfkE96Ni PseFaTR8kbu15419Uq9Uf2m82y/+dQTKftuUPtbaK5NsePvcQTQPdOZfaEBZ 8ANZb3zD7W7vAsKhXwFuu2o55EJ922LbP27rha1oy2qH7Yao714nYo2zLzcX 4p3Aryrleam9IX6xG/7/EFch7lvkFU36NGYe6h6ai/duDDGenHtrKFxZHao4 ybh7aUsjjdNBNPy4X4Uit9Hdfv8HoUgL8+3XAx+o+IjwVDmWYzxeLU5jKJ2a MjFY/A/LBp/XXaPzvp5lE64KumvhS8IvfvFGYFH6tIYGkekBf8wzy90QFMMK mKelucPj7ct9Kx2fK3sUL/3TXeTY4x1qvkLgYUhV1AG9ghkD6fvDPhZt0D4d Suu1kPBv2HG4MY8+w2wJT68OcUwL8QvEj3ZXmPBHA56S+TnK6vl+H8aOOad8 4BTgGdXINf7FqtQyLKc87ovaVlN72dRei5GwtZnfp+2spLanDtY24fotqr2R A7S3WOb9/DzyQH8BD4CNK63XKfAv6cwdo/5E2EY+KmroOden8HmlR+6X6/Dz L2nNl9Gztp7lkLGFUcJtISflWAxEj9Bd7sb+gO9cyvdTXSbdBccNmh/poyZW hrGUF9LdclLU6Cto3zfRvfjJxRD6VG2uDKv+zjI2cTw+H/a8pH1//pycj59P VGXG8f6Te+8Mjc/NsmO23b10hNoeDn7BomzcQ5f2VUW1LEq7ivozm/5dGBON 7wzsKJN0yt9OWpNtqWsivIk12bX9a/ZDjbUfWM7AdsFGq/yPjuQ8yNNoG/iM S55Id3aN/pLNzeedx7rrAOrHOaC+CzneXTcNsL4dKi/nMuvrk+d/J53/XsRr hu0OfKeCduyhf/ggXYj+YP4YJzR626D3++3TmFdRKMe7c69sZ+eu5DmnOlbr K2zxNaQxvtx/3XaeAx5A+2w+fLYCL06d116PvsL/PJWrlWMguMZ7odfpM6Tt FZd96XYuD3hc1Rk7Rut2iuqjfXipk/5t6Ku1dlUrLx5R/dWseQEeSetSRmU1 3+ZL/njZzRc7Zdl/eafvHEL/jn3CBQkg5/Jd3S9OEMEQxEHaR/9X0f9u+odt 7Q7I3qPldD4eznke/m6sOF7MKz1B+2Ih+wVcSmXzypkuvhiivt3NMqNyFUtd 4lBHaK/a6MwRbnzhrPRR8y/FWC/0rZ3K6rmznm8lgNngEQXgmTHvLNNfruLT s8/1uF8jaTfklXvxqzTpn2LS/MH8yZV7NKH8Es1mXZ5ctl9g2zfWdSa4K2OW Pf+GFT+a+jpMxtckurWO47/38y9XbZ77kvUlOGaM2SVsE/vJB5LxC/gTRj/g O2JhhsgomAVZEPse98T9KWay7/Gi1XahcZmGuH9yj3VnwD85ZEQtCb7wWuiJ w/ewt1k46H7x8DxOkPOIc057sYTWJwP4iKrbg3m+wRAZqmw5aATfRvNkUr2V dF6GJ/tWJXg9Q/mmJBz+ufeAzyT5RXZZOE2bg+fkJPxWvFKgsQ9O6KDBZ4Xk ++ns0wj4DGQHFVQR8GClm9J8w0+E/dEPKP0u04Tci3AaH41rPutkUn8XHRbz C3CfFs1ys1/lIvarnAe4j29Af0d+9acQ1wF/PpkcS7SNztAWZX80Y/IU4Bxv uibroD9OEJ7jL8c3NLfNSh4oY4TA5pD6/RKPA+svfVn06c83rbUKDKX+eOah P1k0JtjWrVvUJQoLgNM7af0y4nk4H/qG30hfQVgn3HnUP+jMlfn2m8HLtmGN mWgVzBvoX2qj2GqDyoatsrqT9tRm0x0uP1YD+FDOe80Pnnke8wly5j3Pvo8y 7nze8iGHd4yd5XmU7hePzlJ6ZmuxzybnUcedJ1zYY/AHyn6tN5uh9REhHqN9 gvHoQyXvHWXDRTS/1l5caR6n/s6m/hZZe5r6uyKlv0Tz0bhskeU457F5iPVB /YHPPN4nqKdqc8xHeQeFbTyd/0tGQuZrmy/Pna052YcCcDO/2PEm1hZ+L6Z0 SxwNbbXkxXWq8qQ81db8ItUj19vGNgOSF/3wyCK7QBwWl7QJ/SfwPo4m7snl dZZ8CbRvS66M/8t+sx/4AHd0oJVoi7DvfcDLbxJeWOE5TO/Xz3KXdtGc/U5z hb/p9d7wd2zrV1mi7GNo/7taJH00H/Tw6ky2lYHsZXdLpuQ74T18N/ujc7Gv lAeEto7yKqKaE/2r0Gysu8D8ePaLJm0bmX4muID4lC25cRmSP3LrW8t9m2M9 kv8ZO2PU2eie2XIuCd9og2yJZQZRsSw6VmQZY4ygsuGbwXa56a+yjAL6ruEi KRNQfAGOhwm5duNXwkvzeF7qQLBOnE7tGT/y8L2YVV/OvFzYki/AN36xfRy9 zzNkzOP59A4fKoBL84woxmieseaK9khXA9vExIj+KypT8PmoFUPohlV0tyXd FdDTsPYK9DV8T4lm8AL0vCL4ALsevmVwLyn5az++5dwNhKevODoJ9nx+0TKS 5cMYu2VXs5LjXNfe0IT4ST0Yr1a139xDONghtqndcHQSfO/6xbawimfVYY0T PhWE7ZtLrkS/Ena0En/ZdhPjPEGpV+EX//iQ4qls8UCOJrS3cUZlXFexBLgR eCt0Ruqhj4xxLAqyvayTZdlSflZE9UyU6/VNl499mxrj+K7vlnq+fvHsO9SH ZbIP/7irb1vQQ5C4wD+OBt1lyd2gp+WNx619th02t7K+f5ws+TDXn0oZvxbX k0zxiQY9kabvw/bgEfYnVYHz4FFnPeGn1AmZK/jjyqc9wZO/3Qt9jameb6bV Fed8T9HUhZLX9exzStewH52I89b0pHAAT2obJdi3paxvbKtu77bsh2FvtA88 9YqLwtf0sMiiuTvWMkqMsfz8S915cx38YilZB/seBb/UuwL74er2uO429s5m c1nTvQwPHVLGaJ61ZIrSd/NDpyPz33u+RfEBGQ49zXyxQtgQh8f2wFd65g2t zCOGL2ULrpyU8O46ltdQ+3wXggcHGFz1lEBMe036N7nAfjqJ7jsDuhf6y6zn FLRsV7+xiuY0W5f3B9t0wu+fsI3L66dPkRY/j4wzTe8WbAMJe23jh+yv2CX9 Gs75UOll58k9tvUO5e/2k4F5UoVHU+j4qChKiQN/KR6XWcBvmuQvaiMM+LNi nSMtjZ6dch+I8/ScJfmc4gt6dkmepjhBz27ps1C8Q8/ZkvcoDtMz7OMRT+5l ep4vdWH/1oozQntdfEnpQZX+lEqHz/L3KF35ffjbVSqdzp9AnPYSgsc54coL 7lLct80FBPfN3+nNwtuynfdsKeGDUyQs2jKRznQa4W9vSx+Mz5wwIoBFj38I ewJqg9K2ZMT1G6IyNpRFJwjb2EF9JMT9dshY25WIxUFt7B14LcYO6mevT10+ VdeDl6mrLG5PBhzzJeg9Sj/vdH40BRfYlpv5NLR/KlbQXP3mRvb1CbquOQI5 1F8+pnjTDhmHcfMlyw9tpCVxb6nYhE7wEeRe2PwO4MdAvDIFt2kfbd6lYPlx YfsG7JTb4rhKnahUY1/GY38oAb/0tWMlb+s/bww1cT1R9qc8JdgfjlGaVpIN OG3vNn5M50Ty3Omc/a8XYOPCdhOFsOvbPA59UrE7CT4tPQx6aAB4R/t508sK 3i17kfqpxrZEwTv40C9iuLdBOODDj+ggB9HPRaw7EMQZHfNYEuwDXNspbQuH ziy5hmMyZ1Wcl/X4Vto+b9kgRkcuEB3pEENYn4X3/ybEyNAJLxkjbUls+6qi tmVKpuUyHmc+YxnksjR+G9F1RZRfSXjaOPomH3aWKr5Pr/rGY8kUqL18addh dhDeBl8gZ7B35fp3XoKtIXCYSgIJRPfSmRv2ofxWa5NntvOpRL9EJ+FAa+Nt XBtvYwzwEtCs1AZ4o2dUXlD6IIl8GfffuBG+//+63fKn3bSC7sIQffgzulca pM638pm6BDr0mGsJF743Argo6Fa/WPkg9hm1Bd8DnTKGq7mM6Os8b4YZKxLC hXgZRFfPH4inCHvOxuZnEjG7EWPc/1aosQF2n9rjBF/PDF7GcQ78q8HLXHUP ldn2NWW2U5nmwcsMe5nKYB59fvH0iL5lq817t4J2wDrq9kNyjtX+rDb/6k3E CGJbLF7vp2m+YiV0dpyJs1O9HPav1MZuFQt3LWQoiI2EPUvPbBOG/UX3r7Nq 86XV4P+w75pRYhLfyfIuRSyNJfC1Qf8L5Z2wsY7XL35H5tbRecjWLd+dfFds pP3Sa8i9tpHwn95u6Fo2FbNvsVJhGzPb8hsIWPLyiTguOJ9hybI4LAnifOpP EDx5UcIT5pN/Cz7Mw+z/ubwb+9Zekhj77WGOxfoQ4J09Sy8fGqoo7xGVCKWb I23epnsE+rZgbrm4meoptuDjlOWmqMiJLaGzegT2wtXm4jvU/3vGU1QmyHZn zcArGq+xEVx48A6DY0fon8RjZWWLkmhIlE713JpbV/xRU3iR/1qCTdfWLlq2 PyCW7W+j/HbKJ5zHtnI60UdRzUP4zBilzwH5HeO8TOsBJ5V0nl4yXOI/kfnv Q0dzcclIxA7sqplriushL9CLh4bKi3tEbbG4Wc/YxuNs3P7PoXCFv4bSrtcz DkEn0wleKvU5FLn3feYTwleeX3QctvSyJS6y+EG5dh0PNRLtg/FaZRt/uCHU OKQphHuF4Ov8vSfidMQ8vjteor2TxviSN3o39X+DcNbOGLIfvDbQ6LWIx5sr JrFOpNpj4FFHOr6DcWWFC7trKlqJNnsJdnKxXt7XcdzJvwl4MnBr6c+5YwTf CXEceNELkP1Vim+mBQXdCZKe88g7YcN22IM3HvyFHAefs/lT4T+E7b8RX4Hm velpxtV8bfm4W7NXqXvAI3GjDff1r+Pu85IHl1ZccjWP10c4MPDjSjpneVM9 aUMCQkyqK7arOFcxyHWXUV05A9T1HI3ZKc/Zk+f5jDVb+PB156k+65zJmE/i yXcGqKNBrt2TewmOIg7ZQjq7ZXROcPbOTukET7aX6LFRh5Lxyv2b4ramUj60 V9KTK3H+jt0YarlOjJnSKeMVUPtniRawrfzIWEj77AjtWcSL4f1Ke2wdx3xk n4LpTyEda4Y8nyF8tK9tc590MW4HXgTNvUfPPf888/Sf7Jqkr4A/rIXv6A93 Tao2G+rwfcQc5Qad2fQzxlF1CfeeHAnbTOA4jVsIfr5Gc/DDD6x9Wfniprj9 KeOB7EM1xPuO8JmGDO6XipFJdZ8EX8dgf0/LWXaPPtPebCP8hebPbDGccr/S vnbq5ypAV9DtmdO8dhDbN9hIKDhm+EXogIwt8ocRcX6BMbAdusK5TlH9hX3l qkl0RkkK3f9BAi+06H7Q+5fD8Xg+VohJCbg5cya1cRPTnDRHkY4eYeGLVR3Q kWEfWk6DfZxzDIodwpbdPKjt7oq4HJ/j4Mkzu+4e67xKWLNQw92UjMcpHU6f 5KkwTtfiFz87Hadh+8p2hTy38sy632T9EdEtKu6mNuqZdwU8bjVoWMIFok2S BqIz9rPHWT6w6mOF97kfTzpjKNPGa8/n6WcNyjce7ezrLDuAQ8pWw518dqYo fjntnbV0NzL/oa447usu0En4Jsd5zpH6v9TPrKYLcg6Y51EuNMxFxV181rIx Pyzzpu8xL+Cxog58j3Nx81fgNadlER271qKDXkzAZa+S1YuKfMDIH7Yrm3r4 XXcgHog11/CtUm1e0w6Yh/Zo/3cY7G/rie0SxomZibl74k6WT8fn7po7+84d lblJzt0TEyUP5NpAis1lgoYIpPgFfYZwyCamWTu8zE95ojgh39g7oq+Poij8 F0WZTu30i8cvGezT6/G9qs9PKZp3G6WBdswimLjDL/69mOnfVyyfXY+/lnQP 41wGXkrQDjVqDndXRAThbI/fQ/PgA0xjfvtmpk338B25CrDp8eVoA30GXPOL 11/+uw1sA8C+wKvZn+RI/9fZNBGdRKdYXE04wjZas+MDxu/ab+yjcqOp3Agq Ny86LVo0YLmNBuQuY4qgQxcVVF/UP2C5j6IlLfUin+AA6AE/y+7s6hzGovOM xuh8v1i7fkB9kFgUMcC6qbwNvvnpHf5yjtJ/DduGfxSFfc4W4yPgk7S3PoqC /llL70hfTe9e8IvoH3olOv2DxllG/z7IF2gMJ1m/dqMBGSti9ZyBvQ/9Q58D cYt66B9xbRCHkuiSKM4rrXcUPgAd9O9knGJjNIv+z9I/+Dmf0z987J2k/zz6 P07/2fT/Nv174E+P/mGXCTuWzzlGxX7EI42tpv+D9N9M/4foX6f/Y5DV0/8R +l9M/0fZF9p+g+BnbL5+X8G7ybrfXrsYHrCLm6tjJscYGsh2Fn6JpK8Qx+S+ ZYTtGgeV60zyFzFD7aEFyXcDYrhBXgX9SeYP464wRGbrfRyTiuBrNOgXP21V 9lgLXqJ61LoG0c7SoIBu2XH657NB9Q1tHQefI75JiKdK+FoW5YFH7Nbzu5/H /WHZ3VG66zLpNr5fOoQNdLyexzZDdE6jC3jNx0QX0h5d7DXML5ler5NynfYC UULvtE+u1pL4GkR3RJfQGDTeH1RfePpv3VQn5H0cn61d+VdfQ/O3pgq6Cldf KkIsyAWsg4d2l0EWCpk3yhMdVCPloyMyFO1K9/GItYPd93E7xMYo7PPcEk9p f9DCUxRu0u++p3orU+LTRMW85Pg0lhyI694Y1Y3tQvlOvu1NasuQ9POPJqpY ZxzPCfrGRGfmUHuLqb15qr2Fsj3XkWRbQ4LDJSm2hsdv7Nce7nLV5j3QkcK9 SuWzvbA30eK0p03aQAyFHsUMgp8lyXZ9NM5jV6qr6Rf/cJ7wBgd8MvrFtuf0 3GzIarrwLvGIbRONZ6hNuieWdArtBqI5Ap1mDD7D/vLhX63Uu8X1gd99Ggt8 mh+j6b++1mnGvML8QH9dHKWfV/9UHKX3T8JOev+U3mmOa53pfwRvzPu6+K73 UzGr3Cn+kvrxHOA8fETP/Qx6jv5JjKsKpgvy6L62+aLmSSkT+IeMCuZ1m372 r080g/6ofxKlN4DPA9yFeZR9bLppPY4l2xDRXeBNwvPkmvzmRss+r4bybKwf Kvl02WhX4UYzCCZ7k+ccvGeD49bf86XiHy2UfOG/Xw//v3JNWc/KgzsUvlqt +xWwH+PGPREuFpOM0QR7TrO+jDsqdVeyolXYe3/fauFGRozt9rpVvXW0Xg65 P8VDJQkeAb5BbKbZstzu7fTMMWtbx7LP2KPUjwy2/46KUrqPtPJi86jXnpKe PbpYZLKst3gUdJCOthdKfyVJdjZd2NuIr8OwlPBx2qeTMKft4BM3Qp4/cxjj HazbPv9L4F/Y61UrteOWDJ3Xe0xPjS44PqtNxXSEz+YZUarH2ucqFg7Pu6qP 6VWMX+K6ZoFlLw1dXQO6gHSWJuWKrKqfamUluSKT6j2p/rNpjEfp2VmV8Pfc xnr3NHb4PeD13GyeonrgEySrKmoe9zbSGczjmD0os0uVOUhn1qX4fUtU+fyq TRzTM5u+cdA3WeqbsPqmTZW7juptpjLpVMapytypyixWZSqoTBDwh8rQXfv8 TAUzu1X+aNzzvp+buNd90UrhrhRzPguKVfmEfzwRLpZ+x6gN1O+GrhHRrOcS cxVbl5cvFkhdqdvd1Abu6+OqPPz1HZZ7m9MyER+J0l6QfYzBvzdwRBd8mgHG wwcQ7m9hG6YPBs8t3jtiMIM/CjrJBz9IP8QYvSMDumOajAm2fRXbr8V58I8u j9u59vUbFeetP1qb4K1nne3rxzHp/Bdadwu1vZZlSXGa7dvtgQj1AXiutl1T fXBKudJPzkm53QebeB6jko8CnE7Ksb4N2wD4RHJxLFPQXdBVl/L/LL+2DbHM tyk/C/38FqAc9GQS4/nJKq+UoR2l8SDeWksSXRhUY9EZljUovQY5r4g9+5ds 10uwAPyvqijrvsOPlovqnahgm050X1D1IcRz+QjWYd5rONP4dkNUzK02q6Zy 7Ky8eCx3F/Kgm6NimFK/b77T8l2bdGe6AvmOaZQ3NfCwYxp86yX4TjcXY62r zR+0Mj+G5/sfX2B/hdo/tkq9oB/UAi5afDK2j7of91Sr5UPel9yfavOmd7B2 3nyhBUahbvjSyfz8vzFv9sHnreXc4PM297HUefOlXWbeOhLzdlPB5eftprT4 vMX3Z9mXyu98VmIuyz6c2+GYJuesrjwxn8/ex/5QeE6fvZPyYKeR3X8+W0ar +SxKnc+yVX3mMyRsGXsGo9P7nG/EsnQB94HPy6YxhlA2GC7jZ5jPv9uq5rOy H239Q26ffV8aushKjP/GL4F3G7ocu0r7kHmYMv6tmpMbD+MO8gvbnbBRoTxa n+9V6UEpA2L+K/S/T11kfRTog3NM+n3w8/h3wyCb4rnDPP2Oad77lEyQ7tlH dkl5uOmnurNk3bWfDF430UxcN33bv274R9xiyS4jzd9y645un6JpSqArh/Hp +ydIfpQhls3tTp8297RjWkFQE7WeX07TxQehoqHCqC1OnwYaAvG3A/bXp/Fa v842QhrRCzWsuxEUBuxU8RwO3h3iOC9D7KHIR+C/f4flipGnu31JvKq1rJdB +4j1MqpYt8+yQ7vSPreoPhN9Yw/N/WxII/pdsAi2s/9jfX/PWgPoolj9Jzzt cfoeus3G5cYRaH59mt6UGwosSJ/Wn06cU9eXTqwMinSrXLB+lEF7LiLLzl7f n6ZMX/e1PMd9/XiOnan3Uul5xqmY/2LPUfxO7XK2Gapcg9KLcMj7q/mm6tjx OxXO6oVenneDtKuOnBpMrt10ScYZMtfR96zTAToGcW7peYmwpe0ZFMaqseHu xPj8oj5D4q22GUnjywEfG2eb8MQeyIbgC9TbLL5J+fZgfRq19d3J4NFXGLfQ 3fgDK56wO1HHDe+oM+qh/K2WPhuVOUR7owG6ejRnwHN3sO1b3N7+O+9JXPI7 M5PK6GwzxbZnH7ws/ehqm1SbAfluy2BYBF132EMznrLyTciRwQOl59cifkWj snx3JXxG6Fi3fvcH+/FbeSd022Rf5rCsQT1D172GY/8yXPZOlHofdQeSxriF 8oZQ2ShoR/iQpvIlwDWkPvu3z0tdj7rHkr4pVN/ckfSNN+mb12R7cyYmzUup FRNOzt2cp1SZDKuMLxo7JNPMSvlfg3gTR2RbNSeS2iqV8cy/fQ/lw7+9Q8Zk rlkv9+ilXqrPXm1+/w5+3xQ7yPcXz22U6L9Lx5X+0DZhsw9qzzXVE5nJe9AO vvHs24CbqX0OXvhsqi/ncn5UOu2C8bkSFfuyajP7HgL/7Yiw2fb19S+KM422 0e6mseJbaJfoqiKOvanDz5bNHem+HX7OHcpXCnhGJzvzRCnklOzXxxCdgANE Y3j0PJT/Nco7l2QoeuM3Igvx8eh5gWEKd8kQ6X8I+mQ8pnyWrTCORnM6D35T oTeo74XdlTExKb+Gebbg4b5Cd3DHN2j+//Iw6y5F4Kv+2AHul/I3VHGXKCI4 ChoFsSIYxsEvaVzPRdUj7+C/hEwDfnUCTMfm05qMBZw2s4VNOzmob6afMV05 hWHi3gkhyMtkjMSbd1n7V8kyAhZNafGzpX3phMPgYTOdmcF8hSLEbi0fC5mB OKo3VIdwD9VWDIdtSBZ4s/AvdTn/SaPr07IsHn958YWzkerb3dEpsGdnWzXw qw8pu9SJ1Ee2F0DsaXXOsjbU09x9rHC8RB/HoY98T6KPm83mFsu/1mYz1DlK OMD793Wai0ukH5MaFatWfT/+E/4+owff+jk2rf2YjE8rhsegjwD5tNTVrF5O dRYm1Zm9Zq4Qa5YL0RaSdwmti1PYxOwU+4mquI2b1ImFzgDd7YxnKR8d1r1F /YHdi7PtYdiJYs61GfHxrNS8JSreJOsrSb/BE6hMUdKY6CyPH8F1rEAdkJdp IlGHOKt08Q/R3DNOrfgUZntFgkdnEJ7p7aa822zu8kyRtekBjiOn6UPmsQ0H 1hC2lNDDrS02Y7qd9VjneYfSWspzVBktEo7oCunnI/Ko31f1FMERJ8f/Bk8V OKbm6xBOtFvupPo/5flbFx1P+z8T/eJ93lW2lWjc19OyoC8cEPkx9gGz0gxW bWS9Yc0YwDebislCuKK+SvEojkP+KG0CYm8LLbbtcjJC3e7xKb6f1HGj/bnm fhnzGD5H4I9L760IwaYS8CUKnDyq5WHuaHx95WrHNy0UjnKaZz1rnqA5ycIc lC+C7xOb23ua/hcNKYMvrnK/yEIZ/XQF73f4nsLc0dzCjtODOYnk++Ffxxdp YjltVtVGraTqSc3TSfNXvprWJ4vqvl04CL7s0dM8k/R/miD1tQyxT08rnaSe 14XHl07SMyk/g9/p7MwT3vulDlhtMfhqtyAWjSv8AJXJLJ0EG1PEnUKfLVvT b98ltPDYHhfGGy6e5fZupXORtEblzrQs38rYmRR95CR8Uep7Prxd+QE5rud7 gZNmhe+bPIneoYeE+6+b5isr/M1sF7Xhkn6AslkfXxeaW+4FWvv42AiuSt24 bfJeMzvDq1BfrDu8qmCSXPveHSl6snRu+urJKp7m/FT88fq9Sv4E+gvx5DTq /zi1BwfyxZ2tymiSF/HPlxSN+Dbr0DzNuGG2xHmWf5gXSYO+P/voprJvRp7+ mPk1iBOGb4R28WwKP7ZOlPTjx740IR7fDLxZms8titdaWG36Vync65jF/4Sf OtigVZvn96q8xbQXC6Uu7PJhcf5tH5458+APCGelOHmLfri0JijWLEI8Sf11 7V3oyRqQXcAG9HWMf7nGNl8qzS9+Dn8xO0py+c52Gx3MqyF8M/Qe+A3oG/W3 rNr8i3cUnj2b0pLo93GT1Tq4rHWg74DXFMn5DkHPnWFbG7Xb+QyNdSvDgBbW OY5wLEw3ZATx+FwGrXsd9SUKWbEHvjAW0xznsHyu0fBSnVMhmxPahSUpes9V RCck0+6bqJ8HaE5PSD3ravPiU4hBDftCrMnkIGyjNFfYUx2Kw07aw0qfai1s DQF3oJtA78G5i1xT2JZoqH8SYDzHXnfYQxVmGuwmCikvKzzBPyk8DvX5a8JT bndXzMIc7LoD7X2bcA5PHuD0CXcf+LmNdTMZD/wxaLPKuD8OGpPFQ/BtNE8B N6/gef1b+GA7JrTzi1P2YZUoAu8/ZR++2HcfagvUPpxRwWdg5nm5trYg1lbu z5mfJPkNF0quhph8cRyhgvXqxGzl53o+dDyhqwlcm/q3Hvce7Jk6MwgWZTIO 6AmPv929ocHB8nj4f7DyCFacUvjqDBpzUYp8YiPjptt436Wckz9b+qSrATdV PxYa0t+zME6oM3HaK8/Ep3QmPuUzMY/2fhZ8MOGe84uHvohWiSzeF+jLJjOE /ll9RTr7ZMxk/02n2D5H9qlDns2Hlip8Y0bJKJZ/Jp2jh9qZByrnlc7RDMu3 807glolzVID4WZrCr5LPUpcaVyh1fh8qHx1JxeH0Rbe7ccaiY5PwOKKLCd93 SD+TwJNiHcljG2AdTtLZAg0Im5wiNc7VrB8R4blXZ/XPz6mzCpkQdE+zdUcR zir7P4OeENVTJs/rsseYzy9hiV/eMbcq+HepTd4Df96SggNE43haSqxgxI5m Xy9b2B9VFp/xE+zT8UD8bEcSZ1ueMzMGG1DgBDjX0e/LOaM7PXmeYHfsBJ6l 7mUvZFflGnwD+plvijPt3U5rNNQeCk/4jntDqyNLH+KbBJ1F6c/V/Fzhc0Vq rYJ+8aN2vnMtO9Io+94rStrXx+lcd/O57sZe/NE45o9r53qS41vt3xSnJzi+ FZ9xy9cs/LN/33AS7pPF+Czw7+M3hn5ymmDXBPrRuq48hP5p25YYbCvqbnz/ FyHaq67I/LfY5zx8r8EWjvl70hbaGfk70MPTrXtqttRv/JtVkflH51RFzYNo L7n9J6m9NdTeGmrvp4ek/poBn2ub4rSH37qLpb7+3zxk2StGHvoA/SiE/mqL xBfzQKNRmTnwxwF9J9jN40w1voS4PEsvsa4M0e/WN16H2V0kxPcRUwd1SR37 pe/w9yukbaaUwS5dxToAzHNY+iXjNSm4xZh7VNyG+D0XuA5+zsbMBP+W/V90 sw8S0CrP036ZdIOkA8qA0xJdMITwYSfth26aY7svGlubyvMdfQm6+9AHCRdf cLcSDlcBeWa2cNA3R5mfvAF381Il/4ntS9YJAS9a/3eiH1eNZR/J8p6151xO P+Qy3wjEWurH29P+ZKTYEWpxXLwsWefTm2b2wucW7zW6UwjndqXO4egcnsMk XCGQjTkcrXFsdp+M/x6N8H2aPIe7ld+e+Bymwsm8AyU5Im2dlDsswZmJ+z2I CrZvAB+afdV1C2XfNbXd0lmEL11vcHwP4V9zrO9oLx+J2zxqcV5JqdqrBN// GjD8CPUjiUefx/6coIsUnnC7XMNZtIajeA1rEmv41+3qbtgitD8W9p1bOsf2 lPlV+pDqni5JndPc1wae09zneE49l53To4PPae6D7Odv3yjwNEuBn0k8+K/e sewrgROpOZ7NczzuV33muILPDPPR6ll3U5vsoXru0tZWxz6rs2TmWAM15/uU H5NCycf7q4mDrIFX6nP81UzAy/h8F9N85/B8lyXm+68K1HzvEdqZ3Sl+V0+I vJL0+HxL3Cik5hs+V82KEO6muExnHep78E0L7+7LQ4FOCcewJdhN8G/Go8UE ax+l3+18vy827pe+gfxi3DCW50SS1zLnfL+1zMFa5pwY/Hxo3n5r2Wj45Xo9 OI5lMUlnQPp8KT+gcI4zsBsDHUz/4LsdYlyIdS8Wn5Z3/suPq7KFyge4M9Lx vjsS+SCENYSPXCW3hz1RELJ1NZ5i1B0Idl3VJs/mAtXGPNyjsJ2OdPvnVK00 912mj1+odvMg6yA8aRe3v9lcjfZZ54/P4mL2ixEIGmOUT8wtnVHWAwVPrrJF PuNeLZV80EWQURf1P6Mx6N/lCe0PbVfi10LqfS9qnfsx1sjLcgXw29lWH3Gl 80UkoeOzaBzDVejx9PeHtZDyw/KO/4M7WfYI/0tJuHtlCu4ekXc6nb+TqTDh ul397iqGCdet57sqqPaR3g8mtPTbRyl31HV3FtklLsX4QTfBKrrLKnz2U2yv mpBXZlLZiey7C7iDigGAOEYSLnw7Of4x4Q8PzJSyl1vexBzE16WB1iWX1mWT qfPZexpn74Fapaus9fXtIrTPLX2ohQpfbEmivzsS+hCZu1Pn69pooJ79aMp4 QhKGGdXmzTI2gxDTgSdi3aHv6luZuQCxRPW8Hml/kGZzB9LSp90izM9pr/0F 4bzW2Jb4RcNWSrsNthuBVUOmBZpPTKO0drUn6Xw2rGrRRAbsEwAX9GbEemlY KnX/GybCt6LUv8k4JXWMM45BJ53yRkhd6YaMlk1iKMGdM76VGaAZ1wa2DEEb kJ90+MXC05SfpfKXJeUPoz4Mk7rPDRo9D4evZuhAB5p9k/Rm2KAuPC31nxdu pTxXEdqPZsC3XteAOsCN0I9euJzqQt8OJsa7cBOlXU1ph5LSHqP3I/Q/i+q+ RtoROrdURZ1t0n7RachxLiymfPeSDGH4VjoXUNpxShuJtIBIb6Q+pdE3iJXe e5k+nfSL+z+h9kcajVHEVmyk70fQ9yNlnUOOUt61Mp7ykA56vo7KZdE3X9A/ 7bf7t1PZbFV2iXp20vM89eygZ596ttFzkXomvGKIS579+4up3hyqj3DL+x+n f4JZ98+hcqNkvenH1bOPng+qZw8971DPLnpeq56p7XRdPVPb6QvUM7WdPls9 U9vpZbLtHz5H7c2g/xOUl6vay1LP1F7aWfVM7aUdV8/UXtpB9Uztpe1Qz9Re 2lr1TO2l6eqZ2ktboNqbSu0RjP3hUsrLk+2lVapntFeontFelnqm9hxn1TO1 5ziunqk9x0H1TO05dqhnas+xVrZ33xvUXg21p1HeaLl3HIvxLNt2BNQzte2o VM/UtqNQPaPtLPVMbdvPqmdq235cPVPb9oPqmdq274CuLrUN36djZDv21eqZ 2rEvU8+eqpX2IHRtqWydSnNR2gxKa6G0O1Qa2i1Uz2g3Sz1Tu7az6pnatR2n fZRP33YmztF9M1vAe26MbklKm0xpBZS2LSltNKV9g9J2JKVlUNpYStvpFwsu tTB9FN1Nz1/S8zh63kPPODvX0/M+en6P/glvWvA49embcty2SvVM47YVqmea X1uWeqb51c6qZxqndlw90zi1g+qZxqntUM80Tm0ttXOc4K2P2iom+EW4V7Q7 sOVwrLRZ2v0HmkVl4Nkh07zNYmJg66d0phdMpXLFVO7k15QbSeXGU7lTg5er /4LKTaByn39NudeozBn6j+odPc/T81lpu1H/HN3/fwH6X+7TesxnD80l7dX6 dnrupfHNoudZfb57iL67K/HdD76gb+qpLwT7VhJ9Vl9L/w5Ku4/SfkjvM+kd d/G9VPZSn7qKqa4fJNW1ieb4ETojP5T47Mos6WugXlN4dsdLdGeqO3Wd0te7 hXWQG6N59D1iby+k52x6JvonRjRN9Bg9E+0c89Lz2/S8nJ6xH4me+cGD0i4x SnD+B3WwpaZnwmt+UEvPqPMgPc+i5y56prvqB1PpGd+uo+fJ9Ixv19LzuGqz F9/SffeDHHrGt6vpH9810/8W+tf9ou4SPbfQ8zx6Jhq+dwn08+n5E3qukbr+ de/RM/q6mJ7foGe0txB6BvBhBzsCen6h2rx4Rto31G2n52PSfqWOxn+xS9VP 479I9200QM80/ott9OynZxr/RcxRIT3T+C+iXQ890/gvol3a03U0/oseOad1 NP6LaLeSnmn8F9Cul55p/BfQLuEDdTT+C12qfhr/hXWq/mH0bKj6ib65sFDW HzxHzzWy/uBpevbK+oMf0rNH1h8kXOuCU9YffK3aPH9G1hncS8+HZJ3B5+h5 p6pzEz2vU3U+Ts+GqrOVnheqOgmHPY92iXYLLqVnr6r/Pnr2qPrvrDZ7Plf1 30HPb6s6q+h5n9xbwZvoGWtKuGGwmJ5X07NT3t3BWtrD1wL2VK3sCVC6I+C4 Cv2gueuZkfQ+kd5Bs52if/COPq82v+qh/zP0DzrlLP2Dd0R0/1egl2g/fQXc qpv+O+n/KP03A/fyrfwKvM9j9A786W36hwxrJ/2DBthN/8D19tA/ZBH7qs0/ 98r6/nyW/tcB3wpsBby9dz2lre6TRnvnz/MorYX+S+if9vOfQf/S/rx3oqRb excqfVnCR+6lvWN+3tc3OnxjQP5J/R1fXi91jr0Sp69M4LlD10MXdG53NvzM anq9KGWaBP6ox2Z7+/o7h69Q+ua+6FiWiR1J5h1xew2sLzI+KQ4n9NGy4UOt Lw+J6oEu9+dC+3jGoLafHdJmX8pmzHbmfUg9xFWsG8Y+xyZGmffLekMTH9Lt 3T7o64AmYR0l+DBhHwMjRxNdR/ihgE9ZMdfXHz/0YBzBHPdA+mWldsTHzXFh PExf1g+PARZ66hGnV3tbvR/ywm9A0B4K2Pl9jx7Mhj3ZWSVL3Ca039YMOmbE dTl4I9NyibHHCni8cT9rsRFqLPMQn3KgsUQ+HhUabDyR7lEh8F/0Bo1tLfT8 bOmPq9N8W/X1SDxtk9mF9bLeiQbbKWXA6r3T7GTdIO3EshR78D66svo65dvm 35TPYo7HO+EA4ioz74f2DfwPsQ8BpgGvabD4cuCdFuWJLPiaoDsM+khZUh42 f466r/rr1HIM2Al1sPvxrTQPQleI9QdfEQ72v3DyJY7Nw/LIpLTI9b/CHN/D 9slad+cAfpocKTbaCbuaosTZvHtvXNbcl8b/IfN9HH5xzUivXdhgL6P/MBfx kTkO6YC0yytSvgKfTNS3p6y1hcw8OU/GiGCeD8HLu85bMmyh/ebsYL7DmsL0 ruym2L/2+9BbnDKH598jfYiBx5Pke2dy1UptgRUftSRPxk6timpeerZTXpae f0xEfOxbArx0ZVNw1yb0KVj/ak21+a0v1lwSzurY/vKktPf84k7wmIbRmgFG Z9G+qKfvGqT/HE2Tes53blf8oA5v0E5w/Vub4CfRZ5inSvLZtmaZpUtP307E vK45TWPwax6fjBNbgvVmmQvkOgk9hzzJS7zzfFKfZq4Jo58vtyelTfaLeeBJ 5aKf1dKPPvu+pm+h30x4y7w3WM/v4TjvJbPaTC+I+x3cHOvGnNJ6HqMySTyI tEvgzcBvn5pf8Pg7hfZRqdyLvdvkGtq9cg3t85N5lfATyGvWbfmitaXRvIWV PO5kRZ2N9d29UXupd5O9DD4P/GJ5Il6mIQ4W2UUG7ccliL8cCA6wHzX6zvil W+qLLrTin28xNtlLGeYyv7FhmFqjxXreURn76MmPQ9ECe2m48na3NwN6N4dk DPEcjiHuSIq36Id9D3BXtvHJF09ETksbH+pLDexwdMlvhK+DSX4xF/wi8I+q MAZpc2Kf/xLNkTx7dulbBP2DLjrfI9/ENwvBT4w8eYjWtPQewBrIkNhW4O8k H1vCmbmn2Vcej2vnUxV1dhfk4NYdU20Oa4W8SO6d8k8wP7A/Ftpx9lmIuEuW n67Ird9wW366dPtRnzqDJ+O8ffiXNEShZTOhr+iuGQiG+8X3HsScBSLp05Li IoMPa1d217OVHl3lhl4holNFCWIYIN6kLuaxLjGNa1eSPVkHxo+1qjJYj8VQ +ljNVA/sybLoH+dyN+v0UL+kTYe5QOpff+8OlBXaBy2D+incG9ePLsM95xc3 nbb8FE73SVvfxFmwsf0DwW6NYRRgUFQL0DtgTBHDGE9fGPO9qYlzOqlVwpi9 7ySlPeQXtZPjMEYXiOvhrTbHjVD7lf24sQ9PXvvaL6T+c1ZxpOhK4Uft3qT2 0iT82DsnkTbxS78IPNcHfviS2lwu2xSr2BeRlPvnJWBa7Z0WTINduxXTA7rY gMOUX678EdYk8X4J/kidbgV/Dir4sw82HYk518Lybo7RbnhvX7Kc+ZU6UZYs Z7b2rF847vML5xzUK+F1IEPN5QIJnydqFny2cDK/eK6WZRPQS2edhcAqyMXx LPWoM29iPSGWP9wMOfnsJF+ZZZa82C++ex90LaivrsF0opU8vAZ6/EkyQfgD C7SwT5LvPpYk8/t8oLs7EExfdoMhfMB30daSevFK1UaRXetJb6TzN71uLPvW cAJPTI7VBptU+B5WsXxQftpjYwkoL7K5VXzXM7X1/7lfXzTKHahP35/8rYXb q3g+eTTW0S3wkTlIfCLwsP3iOy+vjghNloPPd+gD/efng/pQbYjHqJ+Hewfn m/7HlhcLD+R89A74OJ/S7lxfKWz0bt/A9kDmaJrHINEbHuivAr5SXtp6yqP8 dMovNwaIc0/9mf8/1J//ldqf2GOD9ye2feD+vDto/Ba1h5ZExxgLorM4JgzO 3kKOgQHf89Uy5spAe4fqXvK1dX+f61tA9S4ETI8Opbp+z7bjyygtRPk6t0Pp bb+/bDvOK2hHt+rs0w63jX58fTvvdF7BXC1IupuKeHxjqP7xtHZ05qILZTwU 6NhyXKCFl21rUHsHvk/GGM1U92rq/xJqx6C2W9oWyZg07RmXq/ft4187hkau qy26iPcer3O4IRGHfoA6W65gXtqi8O2TYfn1V3Ee+9dVeQV1raW62hJ1xdIG ruutM19XF9FibUZ+fL0gS1nHevYim/WWMKeI+wPf6ZcbP8cFkPHlT1abF97s +42y++2m/gRTdJgSZ392n7hSHbS2nVE6Wyv3G0HoodE616yMGYGVjca6KV1i LNU5bN1IIdZ/m/q6LDeE+FJPvsU4MPCEbYjl1PR9Y0vkSVHDOkW4i6JaHp6b Go15VA62KY2RivPPqzzLf14a1V3A/sU4XZxqnSJsyCsvNrthw0dl0umu9aDN SKJcV8vDwk55Q6rN82+USLjlW/dj2LvEy3QgnepzUDkn6qMyE9fflFKG7Wlb iN6nMhnrrhGi8YN43nzVx0yaq/8VjvddzFDpQ6m+yUl1laj0LJTF3Qe5LZX5 xrpcMWxDrrhqQ4UYjjmw4G35MuEpny48gLvAxQFzAfsBcwneagRPGeZG9PPP 0zhzAHO9CubquvLJlif/2e5OlpvIel8J2CtjbWbK2GG0fwNCe3PGYDhkfG98 3wgaMaOG9kiA9sQ63geZ8o5YP4FgjFPGGas2e0fT70H2hQ1dFY9pUl+xr7ZI fKkadJl2Q5OwKzubPN9GxgH6+bv2i9vPIa4RfNpAR8I71OwOR+4OBfJw597+ XlLeDuQFRqVP00fBB91dbqwD7cfOyJ3gb1z8kMpvTyqvlyBewArYecbLwucT bHW8VDZslb1hg5hxQ674LvhyVfA3b5XfKI5UPcn7SiMc5ih9Myup/ry5p/9z f3j67W7at/txhyIWAnw/QvdZ8lx6HirJ5ng/J/mew/1WrGKhNcCnQuyMX8zi 8ZcMZfz5UAn1A3XL77/aSu+3IKaywj93y/Re6Gdvo/XCnG8D/F/fIGE/YsMA 9oMerOo0/YDXsHWHj376p3HPWpUYgwm7lW6MV873rIakvMrRleJennORPg1l Iq3Qz581M15ms5k90BwgBjXK0/jWyliOsYUpMXbFrPI4nSTjrqbwNP3Cf0Ly NP/36rUFFxP+lDSHT+5bx4JkGp3wW/gPtnmjDi/2tF/8zWtxXouPYW93RZ3w eg2H8G5yeKXO7LI7gQNyLM/1kvaOlF+AT4egX9xZHLfHBn591wUZv+gT+GAT 2VwWdC/bOWZDd38LffOgpNvBq7g7Q9qCORa8RH2W+93Bvpu8dQ5agx8/SLj5 TpwNen6Dbb6ZTtnUzjg8fOCxH1D/AcbhobsDHD4WW5rA4ce/ofypdxhcZ+gx 5dN7B33XCp4J5vyVA8qftcJ3ZfzK69azT7AowYzIKHeL3YxBVwU+VBDTEesB ++W+d1FLPW0gQzjo28WwY4TPF3r+AfQr6P2I12D6FjFAf0TPMUrbQ88/9rLv SdxRbyxJ9jNLd1Rhsp9Z1inpo2cLuw7wBJta6W7BnfUT6bea7pQdSr92dsT9 5rtMyzE/4S8eK8oWrooTBOPOES30Z/p9Rb+cV6VujYfygrgTDoGHUgkd8hue ZN2pz+m8H4V/e/As1l0n7Q2mfEV9WvFr2vd/cRO+iXT8Gr4vj0DftYLX77YT qq7SlqdZD3dSH93YJVQmKm0gD/lYh8kwj0m54W0NVC/zkiI5XTXwUQp4QecH fn4cNAcCc7DmUSF+SuNeQzgy/N/S+swneG/FVmZezBSph3dE6tnehvVv65Rj yds5Uo3lBV6HMhVTL7vtWpX+LtMceRYv1fLfArpV8bHbUvTpYn/cDj8l0Dkz mB6w0bmJ6Sm2KrE/rgLuwP7WJB83yy9mfqn0BX1fr2Ob2c9u/ut1bDMn9tex /Y/eFL2vgrhud2UfHdtLE6AndJxjdRQl9Xmq5WfipYK4TqLlZ0LNV+/65PnS ZXwPp28TrUcyLyD25VL27wK7euDQOu1R0+ZOyp9TkiMcrOdrxQhZKYKoE/r2 kCfRHvVae1aVAa+8jNKLNig6NmL+2s2yJxkrBDHQjiredeUvmI9vHl8j/99O 0UOLnQEPb53QDh9K8TlAuEWS7qykJT9QfPpo8lzNGBH3CdqHFqS5strJpHYa WO+yW+qtq3Q7eKd0T52Q/hZwD8yoUzD1mNRHvPUhNY5OnCPJC8k9p/wznJF6 foez/u/6fmvtlfX9v567fN8vrU/0/datqX2/Ze8AfS9P7fuhmpS+a2yf50jp +/uy7xVC2T7E+3/L4/H+98GxEvv0PPscAz/ckk+l8Mpjf3iTcFUX688CRiR4 7a7ICpub8nchnffvw4l9gz1MeazLCrkT71PAMtrLN1DaDevpbpZpW2iftrS8 RDi4SfUQNQD/9ey/ZsV/uCPmf7h9T5pH8B2V9cGnMfApY7/hYxwMPLuP2Naj RsL6qk1WTBFK99P/KSpbyft6P/vjP2LpM0tfKVVLFR7V2Ul96FR9oDWCThz7 /jco3UikwzcbfGF2Ce313Slrgxj1l1mb1HXxXYqvS0HcB3Kfdem5c/B1+aJ8 8HX5Iufy6/L5JSvOi2+lFWvKB/+viyWfuWaq4n0FgPPymq3nefcCpiCOE+zj OYa5WiOmf1byHcZ+fzqpzE5Jox6Hr0dFr8K2Yp5fTD+g7zv8boJPWRPXUfWL OSfYzyfHXpqO+Fc7hfba7MHoagtHiMvFiQ5Tvv2CRivugOmPXVYfGH7CYp99 gfJtDdzHQ0I7eHwAeGFLWdfjA8GL6dA7LmF92f7wQq3rn6NxfxmdDGuT1vSz +5TfoaQ787M5yr7TILwUZyAAf4bYTwzXF30Qgg8C2pdnwedsGSptzGETBXx5 oDKdiTK2y5UxEmUcXEa2nafazmphv5tmb6f6j1bIf6G92pkyd1UpNhaDzN3U 0/G56xvrJD5352Zafr/7z93vi5Ufp6S5+/1I3v8p99nvYa8i5zNXzWeumk/g /dVvhcqnJ+Zh3aI+8zlAmZ2L+sznAGXaFvWZz1w1n7LtrHUPy/nbqf7bHrbm 85cDwf+B/YsfZzsgz3QPwUmsU1T0TveJLpZXRcUxtiNh+enU0VacLujVE1z0 MzycDvlvZZ2ec9QX0T9AXPfCcPnRGqLh7LXFZ/aDv7QG+gMdv0R8V8ctwoTO zUL5XcUXSd+Vwj8I+8NO6xaQ9aE8vlO62oup/Hk9n+Vgx0qkfxKCW+JoJFsc pXEHIyuOWXodhBNX1Mb3Rt97LGVtT42TPssIb03ZB6eGKXlLT4oueuzTc0oO /LbQuk6l2AZVER2THj/z0jboSaVfcbEilArPKyz/d/18LygbFdD5yyAXgX0K xx2439rTf1yaEnOr09wHvzVJfZzDsAw49cc2N8FchyWjigTF9X4xZVdkoeah /nTD3xH9HwHNYbDt65THofdebT5aBVyRYHebgiUh1oG3fGTEfvcF7FCNMYau LyI8Mwg7EcKJF7IsrqwdOOQoZYti/tat5B0hxd9esoZg7JrPJO4D382qH1nr JT55aJf876LyuvK9MZG+N1SdWYg/GOntqbHstNAG1r5TjgPyGMSQYvqkGqH3 tFe88VjdBbgzRBrj7LRWwA/Uufgcc2jFZZI2cslrVr58kDuY7oRP3mO8fIXC yyN979dP9kIPinWjFsh4ZNWxF85HNvzWzXFH6T6EXQGfK8iwbwPtXp4GuWrS PZWl7kvQSVlU531rbuX3z4W2/3hfODpgrHboM+2bwLinntvjYz9rUeGae9pZ Cd0zolsKgVsW5XN8ru6B5NzwPUswwKE3/HqS3jnerRssPx8m78L9gRSdo8Td W5lyJmieOptpnt7n/enk9bgPPBXviE7CH6Z0Uf+u5VjRnfC935RD99D7tD49 L7o3TRe2znz+Dra+pYE8x7TIfd0qds633+x8WMISWZ+w7LcrO18heif7xUns g0SwHQj8ZLilnu2311OdtsiCbi/BIo7XoTenl1J6FHuK6FuCg99+iPv2Fa3/ tRyrGrqGeZR+D+s7JXAFyz+/i/KqpJ7Zy5V99ZZwxvry+30bhafTIWwqBl8P vbvUO2y0umgsuAeW0X9a1cp47Mf+PqPkN/B/0U3PDsy1/izRfenK/imdz1ye ETPY/xRsaPzi5sfVmdpJ6T7GhWOMA3cn1dcyQH0eVZ9L1edPquOsquPzwNZ/ j3EcGchIPzJgAwj9R8iSoX/YQmnwFf/5kk6Pj9ryBf7x6Vjg2f+MMR1AZDj3 W8pB8qJjDMxvKX0PH4/D/OIm8NBmUHoh+k3/Reg3/cMvPXxUd/P5p72O+4/9 BisfQvDHWh37LeJ+O9cRQcx+morZr/lEwDecP5YfSx3KPMApA/5To/E5Z/+p 8LdQHTvx5rqIJU95yZ8iqy+I++RmecqSVsWrIlok+n0jAFyM+juP5ms+4erB JrprWwtEwaPVQuvcIGytDwg7/BO2+oW9dYiwt/QKO3xI7aL2EUd+Q5UoWF8l MtZrInPdCTF0J8ELnHvmf9FdL2NO2s/6xV/ObNGEh3mXQjRQWhn9/03VSpuX /n9ctVLbQWe82VsnPPD/TTjlUhVrrAY2T7B1lLY9wkXvQ/Gs7Ldb/KJsjoKT swlOliTLEx6lPsKeShfHQN9W0tiGPhoVmcxzplNEaWtl3Ei+byilLM2bKzQq lxHITZ+mZxwjeGAeQZv0XUHLAeFspfpa60TmpgLGE2owZ/D3RfCJ5xHyiA1N Qms7KEQ77b32+5X8kRAbzAFiSUOPDXoZLdQX2GvRuF3V5oUXAGfnGs5K+K5g mEywWX/d5pY0z/9iXTwrnfrswXi8RGOCD54YE+tqQnd4mZRzAI7cOJHpy43G 6sQc/97SzfIoHM8FnMQv7sigsgRH/nIT/TuNJ/k+avOLb52mu3Ndypx2xk5h PjE/uugG7MwbYP666buuzgMiy+q7Gk9dn/HkYSwYE8ajZ3Tz3Cu9GEOO41vQ 8zjepw8L+vRhBmIQow/Kp1Me9hDqVe9Zcq2/lTNAX/dQX91Wn6BHBh8S6O9O Dff4bI7bbd2Z1Of59D33Be/wE4E8pv/Znm/yC50cF8DQ6Xn7AONbR+MJJPcP 8hTFA1gmxzx5Ke45rBHgAq1pPvwuwWbwUTp7uuOoD7ClKnppPsef2iQKqc9X eU+I4WqeG+JyAeUnF/DQ2jeslxdFm5doTv7yDdbnsfzpihrYxZcoue9i2v9X tVC91LclBrUTWWjp+ZVCz3En9CCYnib8BDqi62i/V8fME0XS19zCaCWlZwiN 0gt4z0WJDshl3L8Q9IYvevFYip/b2PFzO+vgm/tiF+PRtM40vqF0VrYyra6z v5EMFbMeNvi7NxD8qmZb+n89Oqie9T7lB4PwLtxpUs86c3TCJyeV22D5pb7h C/anJv1Y98dPEnzmTOpzVf7H9lNS5pXxhm7vwZ4kXLd0lqVfSe0toHttd7U5 BH4ijyl5+Ja4H9YF0teflDvZhl2Op6zK2WU5rZ+vhj7lNFXu5a8p51DlHv+a ckNUuQf7869fmJfiU+9APN5sWUqMiwZLh0nLsuJCKZh0kmCVq8UR10M4RO/Z Se87qLwnqXwzvRclvc+n99Kkd8R58SZ9n8200IG4HyHLj0ClX7iKobcg99Ro 9iEqZVeuEZS+T6WfAH9Upg8/T+lrVfphyFhUOuSBCl8b/g7r4bFO9vDDkGeo 8uuBU6ry8LOVpdKBA6qYB8PXg98ktN2OlDktiOtKpPiFgA4hxyognKMd+ALh v1LHMmuVJV/k8x8/Y+8hltMM8JYk70TL4pgBkgfBNvK4A/yixIqdVRaleq3Y 3ypeAc+f1IPNaJ+U8FepVe1EjORL53w/jdMSXU3wF0v4MtGRdLZWzcE96hdD rfiH2ew/M3aR+wv9L8BsdWc2s69AKQuaB3lFO9NXJXfgvLGtthwX4ZSt6yXt TLAzX9gJrnpT+THH1mPcgI2Q/wOHNDqY3jSqzdxVLHPqIHgl98w3gHNCvhj3 tx07dqc1b3xPShz0oNB+Pv/r/NXFfRUx7GG9jDIZDyD3QwtWI0YpzVdaW4bU m+J16MA6TKhTPjv7+bCrNp0jlY53NvNNnoaNwYTJat6PMr9Rpo1WePc+oe36 Wv96ln2DFTuA+skx3nAnYPzwsyLvu0wrvn2A8Ek9AROPjW7Tmf7OJJi31PLh Fqcl+vrik3GnDb8Y/5Dq53HQ5mqu9xkc+3A8fAeDD0t3Tl5Vcn8Q8xV3FL6j 8dUky9L2p8bZljTiHsWfevfGEGg/6d9NywLeqY8qAu9nB2xsIjeLSRXdpgk+ FeAX9jt0I8BTsnSb1PgXcn7Tx6FkvSeLhyzjB5rdjEfImMAj4jq5BuXrkt8v 84pvojmY6hdFX+r53Zi32ZLnVHSCdbsNUVRxF/rZBdxvPnw0XYY2VDGQiwsg HwaOwX2kex59BA1u9ZPqXiXbAu5mruVydL4GGMtq+Ie6krHqo7pF5N63oNde qvpfgLEp+JxVMV/6EzXYD2hRlVp37+X7+M0TSX3cybrfMwgGdE6/SN9PVbye HqH9S02KjtmBuA9Apomsu5/9u+ydEFr5IWDSDawXAV2NCkOut5d9EoidTXcy DJnK93vsNyNl/9PyWrLh7/NV5Yud5UYz4PM1cvGiisEsXKtz47GrevR1PTVS vztD1mEIdwvlV1yMlzmozslR+IiW7f15aRKMzFZp96g5LGHdc9bJ+ObUJHxl Nu0FT4p/rY2GR31bIL91FEIGBt0jpnmvY9wMeGsJz+166fua5vUd5QMDfMAt xnIBf22l1bFz78l+2WcnxmjP1vO7CLe0O6FPrXwWa1Tex7C6U9irYx+2Kr/o O9AmYnkaOQR/5B0t7xyJG3mT55fKL16dn5jLlsTz56ib44bGzjXoeXsE9cFF x4l+Pa6KesLt8u20B23O8PSumvLi6Rf1XPhu0860jGJfz1zPOmkzkZ2c1pHP /sHOyDile7BesxfheWhsSbjBRud/Xg1i0NQWD4F/qqmIjRleLiatn65kHov6 1MN2Fnuwf/dZc0Nw+bya0+zq2NlVal2XNJ2XsTmYby99B2fBrop5ffrPwbOe UR178zDLJP2aZ90KUXhDB/NrsqN0P0r9TXE0kD88FjFvd/ueMvdgTeUZuQHx Yjusu1m1P5vaT7NsIbh94KN/KzzUD3tSP1yqH7AN8VMfZoKvGAimT5u7wjcJ faF+iMgKe0j1xdWvLx3SlmTN3+L+ulSj+rFP9aOmOvansOVviNKSeOZHwf9k X9jyXrjkVt/Mo29mKX/qBzFO1g/ne/0aGuulnfKu7j3G8UuXq3iusT+V835Z McpN+0TFc710nPad2lvwQ3hpi+WL2vsw9u/RWpbfbDRmGKzr9Mc3VbtlfGbY JnXSHfRd4TqWL/b2Qi4FvRprn3Gc9FzlU3Bz73Hp85hoqOVJNhux//MFcIZy ee+U1Vr2WHkSrmBvFQ0VmfAvVDJUDK2S8XlULPexk+M2J7GL4TVPCWd0Ks13 qyirjj1yICmvzi++MdqyiZF28TI+ONFfO9nWiWHGl1/EYTb7n7x4hPKKVJ4c /+aLe2Ts3otsE0f/i4W2/VBffmQ/PMOKTUN4FvNMX2N/RnlE21UNaEcp5acE J75xh4UnUDvBtQWxBLw/oSl9LY3h/Q2rJA8MPCojnfCPZzmOuQCOTGUIn9T4 LmjbpGXRs6uiW5i+pzSH5JFoJQQrIA84S7iBrSLXNHHvgrdN8MCPczH3TtcU wAy2YRLCw/5g82dJPdj13RwrR6+/4K6OnblJX949if4PoA4Vn7gLPmTZXyf7 OT//fFi/y20swmJYe+GNE0oH0FR+l0y0y3a4UeGXdjNLv4RtLmRWlm0C6uJn WhfLvzjuZ4yR0uzAG7ybNPq25x2D5upFmjc515o/KeZU0C88J6y5Bu3uWxnr ofVfIHX93l0Fmhw8jaQ08C8CQvvHfvo5A8X5BZxLxifgu3FA3ErhBMl5Nzw9 3VS6u4VVT7GtsMZ8rwH0YyxbatC5TBc9zWe+he5O9NfSPTpE/Xb1lW+m9Hu5 2rOgswiP7IcbRvrhhl2D9l/wHVyU3P8436GPbDGBP4o3LRldRYTHYbC8he5f 1vu8+y3lV4/2iCEK0T72aN/26d7AHXpEz+a4zVmRbo43J2NejeL5OIP+VSMG ira15wrsEhYzr4h1HMZsJ/zh8cmIR5CR41JjGsBGYWvnoPvEop2eHhtqapTz yLE/pV1qQYvSU4e9AsZ8A+Fq4HH6Nppvc9kB9oJ1FpStY3cTzYM3YpqRhvjc TGW+2WbzoIQxW3pTeEsJnDLFZskYYyzTH+WYOk72Qyvi+lfg2bhBu7Yz7/dc HfcrgacpW6StWYPFJgCdj3YmNkudA0PFsSe63+0Xo8t9f68xLcPrp8n2d4Kf Tmds7qx5RXODxphJ0MER1aG5rb5Jen41+IeZLJfEeH/K/Han9K+BuHd/mdZJ 3xfQGMITNPdC2gt41ofCt3v1cvBZeJyGuEp9n4j79MjHoaq/53uJ6PW8pyR/ UXuT47nmiSF0dy1hXGsU+JtmjeIzuC15dTia4DPgTmH7XFU31XeHrM8GHfOd 1eYd56plzG2iJfIQQ8dJ/8XSJ/gze/rdQ/b+MVhhW0o48DrKgy1tCz37lWza C/0ddZZhjzn/MneTm+VZUj7crWTDx5QcrRT2vfQMmRvk1UPo3O1Relu7Fd69 A7wk8AWhH1stfUl7QI9R+augH8L8UzvjXlZ9Q1V9WT6pBwY5GPykQS42H/c5 w+ZG1jebTeVcSd+OUN9CTwq0xDzoSRnSbyLGg7jM4CvAd6JL8TucSgeNKILN QUvmpfgIFjwotM6t2huK1zp7r9prNmmLPXs7++02xFD1Ppneh9F7pnovaGFe cGwmfCXAp2Mnfd9ygv3W0b00atZAMjKhbTo0aL9gryr5yhm8b7lv1S9wTHJ1 DqjtYdRepsE+HnNOqDybzKv+UuUtpLzXVJ5D5b2j8hZT3naVl67y9qq8JZT3 mJobhTNW36R8Ai6jvKWYE+SrvJwWvuMvTYV8P+E7MGeWqiNTlrv9S5WnU95E lZeh8t5ReQbljVB5WSpvr8pr9ovscypvmMp7SuXRPZn9XvJZp7yoyltNeS+r vOEq7z6V10Z5m7yIJ7LJaq86x4AdXBR8vGz2fxgQQ/ZLH4COGYRvrVPw2SP9 K2XXDbTOau+4VXuvUZ3rVJ2TVV62yttuwJ5M5o1UeXkqD34IO2XededVnkfl wY5hi8r7UOUVqjzYMW9TeQdUXpHKK6e8HSpvq9oDJTJv1gtqD+ykvFaVN0nl rVd5uynvQVVnqcr7hNL3qDrnqLmulHn+82qu91HeTSpvqsr7UOV1UV6Oypum 8g6ovIN+ce0lSp/ONN4m7DX/VpV3iPKg/2hIX0ixJaoONe/+sCwHn4nX7lXj uVblHVbjOUl5T6nv1Jr4Z6r6j1BeVOXlqLxiVSfh+dfep/JGqbxh6ru3Kc/a /7ky7y/U/offqGsnpq6zfyt8S8n5u3ZE6jr7W+GDSuaNPJe6zv4H4atK5b2X us7+OfBppfJeTl3nv3hDjh0+H0duSl3nv9il8koob5XKU+v8F4+rvFLKa1B5 31J5y1VeGeXdofLKVN49Ks9LeZNV3s0qr0rlVVLeSJXnVXnjVJ7PL9znVd4U lZeh8mZQ3oepe+62VYk95z6Quudua0jsObe1/9Weu03t/yjdz25r//tUntr/ 8HPmflDl3aLywipvNuXNofQZaq/S/XDbYfiANGRM30AqXLjtuQRccOek7sGZ BxJ78JpLqXtwprX/j1LeidQ9OLM1sQeveS11D858UOURLnvNdpWn9uDMOSrv OOVZ8H+0yrPgfzflLVVjH6PyoolzdE2tylN7d+Z9Ko9wm2vKVd43VN4slfc5 5Y1WeWpfz5yo8s5Qnqbyrld5I1TeWb+4+pPUPT/zHkrvkfN59WGVp/b8zCrK 61V5z6Xu6xkvq/UjuuDq9tR9PWOTyiPc7eqHVJ1qf874IgH3rr4zdQ/O0BJ7 8OqpqXvw1k8Se/DqAmv/oV36brK1B6vNi4UWrxi6M7j/OfZ2J/WhTmSDZ1wd O1HMcq7YCfi3cEr7GY4lvk7SXEdFRRfR7x7mCZTouWeejxSfQczvSfqG293s F72Odav0io8QE/woeIDHkSfp5e7R0o820/Yaxw4kWmlur2tKXL+vA/p9L7/X pnP8dPb/UFtsjAmIeUXQz6F3D/R2wmMl/7evXgy18R74Cxz3fGw1161nHH4+ Uf/tqH856gctVT6N6VCi4dfpA/hLt3TKUv2lQ+/vlQksTwGvCLbPeteEJyK3 nX8XPhOljxTX40V9YkxAPqnnsB7HPOh0M45vf5XP9g1Ps55KW1Kas2qjWJL0 nlltVuH+w3ougG0ktTEZ9UVWXAB/Bf4LF0bmH62h9Bz6vRD3Zc56QIQz0zjA C8F8wZ+75cudxoE5OFlt3qJJf+LRIGQ09H4n/EFKeGO2wb7CootvWMW6nnng Y8HeKfCaY1rg9fRp1GcP0ujbVZbef6oc7xbIiE/Rvh0t9bp+5hjUHszStYS/ POhena8I8Rwz/2/4ZKXLfUbp+Rxh3gd48DxfvsPWfFHZNPjCrDbv3aX0cQ1F 88Cn4xLweyXv9aV7wMs1xkSXwGc7z5/0xbTakP64RV+7M+DsVrvQkyQc4j2O 3Yg4gtJ/e1d0WnRJkv5tm4rtKPVvN3TXVMg1WKfKn00aB51dX0PSuniT8mhd fC8krVGe0B7f3Zenw3zBgXTWQ9KvOutSBaX8nM72j3xPiazo9cLRWsx2yx1F QlxDuOpCGsOyAf23Sdmzo9p8rQDyaPCNoAvPdgvwNZDP8o8WyT+7GGafP4uU DB3x+Sr7tgU+WDQ0UFvSV+Ofhin5aj++EfLZXhe+rdgGrHci06ZSDz8bcQ2k D9Wsc5acuO83Xl6LSw/iDLB8PWoeGaAM29dgjJS/Y4B2oRcRTNX52atJHfnY mVTd+T2nlY78UfZZT2OD7vDc064p8CUWLTZ71d5ZjLPG+gtR4eY2F6CtP+xV dSbpAOx5HHOMPvLamsz/OUT7w50cq5POW2EyjJNxhsSzUjdo6Ju68a1H9E30 +yX9Pv7WI2EH/cbR7zZ6H0L/C7/1CHgRrK9Qh7tr6FOSJzH0TubNuuyP6O22 RyRvZGiU0hx90h6kNGefNHyb1SdtJqW5+qRNBh+6T9poSivtk5ZBaWWpaZnn DNYpztzF8Ds17z1Km9En7TVK8/dJw7ez+6Q95YUpaWpaK6Wt7ZP2EKWt65NW pxu3P6I/Q7+D9Ou+5ZGwRr9v0O/WWx7RHfS/8JZHIq30e4B+1fQruQXfuq35 X0NwbE2dcK+pEtlrCqDDlDlMb6Nvd9Hv1/T7E9Xhpp+XfnfS+yj6X0H1dHA9 2cn1+EXGm1LHJ+Mxnuerqa9rrL5mvMC+Q1LTNsHfRp80fDu2T9pyg20kMm7i PZKadw+vc2raLJb5pqbh2xF90uB/xdYnbRilXZ2a5jxPafY+aZ9Q2jV90jD+ Qvp/jPdtah7G7+6ThvGn9UnDtyP7pC33wi9matp9lHZtn7Q5lDakTxrk39f1 SSs22M58CPTkZqg7yrJH90leUbv/a30M0Zk3NoKvOOS9y9nsWTHiIR/T84pE PEb8S9KvJuGH4MPPLhkjtLldrimRC2ISwSoDPr04PpTkLXrofz79/z/s/Q9c 1FXWB45fZFRA2miXWirKjysmGCIoGiIqCBoIKvFHLS0ZZgYZHWCaGRR1JgYl VzfbxXTLygrLWiu3tbLNyopa261n22ettTaBSlN7bEPFP7uPFc583+fe+5n5 MAzqPs/z+/P6vubq5fOZ+7n33HPO/XfuveeeC1ll0D+13+ieKyE7fsb3j/k9 V9ImHccnQD9R6FsMIv2yQ/IeWgNg7KR1YLnHsB1xUNcG3V/IbRa2ZPc6U7GN 3/Gcxc+vDGRhfHycOkSMj3Sf2N/HNcizvVtIZ9V5bSK/941ksiY9P6une/15 7wG+jqtfwO//njcJ49aqPSnqHePc5uFq9K8G2isYlCPwGXgB/XWsut/o9tnX HDRM0DTwc7r3y3ktl6HJJm2L89E9KdTWZbzxXCcf5e++0R0xWXnuOboX1clu tOqTnnu+USn4FDxj85JiMicmsR+VJ7EMZ9z7jN9bOn5IgzOsoNblXNAwKUzs f5N+c2NS+DPzKlBmW8JSaB930lYWN415u29ZwfW4EsQ5ks8Yyb38zsFrhAxz yypuU+6otOMgdLTCxH7APduepz0C0lc5QLBdGYzDXsP3Ngdx3SC+j76G6xzH 0X0soP0GAYf067x7JCxub2Uu5PnGhe/GurLaUppWMh3pQbrvY4zr/XgOjOY6 zA99RnejxVEc93VMR+dNnPHvpGzMhDyyleuQo2h+mbE54K5vrYzE1zDk2Zo1 U9zRhZ69XGeAZKXGR+OKaY16jUfw3il0KpK5fV/VZqbnDan/wTIoDupinLTp 2Ql5PIz2tuhMl0+OCTwH1Sj0Mwo9f3M54+NY43c/cL1lsk9Je3gij7/pxT3a 3gYWdr+7j66brveZGO3+0sRsny5PRmI814lpdetYnNRPcVK747ak3eD3N2Fk i6RIPfPtyi1tCKbbRjY43UPxJHkgEjKk+J2A9xh632hmJNvuk+HJCNfhmUi/ 8U57qzuknq2wI7uEdMa8RF/LxGxxb+rmYZ75os8J2zlRz+deYW83YfJ237Hn toQxK40nk9Df4P3ujLCwXVyfdxuzggcOfl93GD+jAt69fBtfe/csHu8GrDcI htgT3iH6yw2pQfZSBgT2mWQ/Vuo5xgXbKyEeos2lNCWxZHU/spDbKrxv//8x /MQA+NbLhU86CZcBXwmAH/N/DD9BCx/lnC/LeS/Kmex4DXhbH7bd+fx7wcq5 ja9lBC3nF82qzV7AvQ1lvfcNgiPKek+gHRP3DZCh0Sbprg7S68E84EKgDnih x0S2YLsuns4zIki6+mDpqI7KdPGin/MU9E1rvOoy0/bRWUfa20Ta/6u2s+tq aau+PljbQT68bnNbMARDT+nC0gs9v/tc6HB4JyNdOuKn+vXq17Vdxp57hMbe YgzoT1TPsPV3do9snUu7H3RW51ra8+T6JKu9+wGP84D0kIV+87rLsUfIcSC9 rP73+X9+7jLg0N268TR+BUm/+3LSq/Ya+8HB2msdgOxjhPvGg156KaTfQbIN jWEYu3k7xm+as8dLfew+4xPJfxj/Ymicoj0IPkahjXF79tv4fZEIv/pZriu/ hkUIHaoP5flR7/vuoWL8cUa+PxFl0+q/y+C7ydTfE/1UNlynADS13KDqDazd crGzL7SOIvnD7UoRf0kWBC7rSW+I5tnZTWFx8q7aeH6uiLeb8+/J9wF4f03e OxzjO1/sPf80tTeSv/BzAPAhO0P1/KzHetRJnbzXmO+F99wp9rN7yuV3nfzu FvvePZPFvnfPePk9Qn4vFvvjPTfQeivZm5p3KCaTzns472MpTjNkJ7JV00xt 6Is7xbqKt7Nf2biZrwvHAx6de9vl//0Dnetwa35/Q2c4iGf87IJZyM757Cff uFFew8ALV/7B2LLIwR5XYvHEYeCdq/pwLN0t7IycnzFmPemv7udn1KlODVtF OhQHY0mWI5mD4jsjDsfmvObZ4Lo5fAXKfwvts6Ec3bwfGob5MvogUb7N1Mft 0tT9fFm+ZVwua2XpPnsjfE35P+rpDDU/Z+j54M2mG90x0lZXRNNd7ugs5mZg Tbjog/iZikTMb5M35rD0jWF0Bx27AfwrQ/vJl7wrlngYL9YGqV+T9YzOuPN6 ls9iXuxv3gR4sReD13QDi+N00bw0MvwZ4B5H60DlZloDKxb3LLNpsc7I21Lo /j3kkZ7PrlwvzwbEirMB/O7leFmHTb6zFAG4ZFWwQRWG69zgYWOh551XUBYb C72jrlbPUqBlV19G/xMraL7ysf5pXpPdC05Tb10UVT+d3+PdOvUHsimXsZUN LPQsG01nKoLJmCxsddcl57E3sAQ5LpB8oXOa414IxgdMAkgf7jhgbrlcmDR3 hbyqEDyCG0SeIRsjRwEz79+BiXfFWXFdbFB9mxtBg2FArIDbdFH6MyqymbR1 yzDuT3aLe6ojWhrlWOHnDemv0d3hL1JfLdYNs5HmTyPoN60DZLSGv5NhoPL4 071NU8X5vi2R3P70aD5u3iD07UjXDnPMgRslX/ryOfw9IdN5jxPvuGwC3ony bEq92L0qVC84PegL1wAnsnXThLoxCfnd9w3T0bkPqkeThuB3IdOt9rjRJ9hP UDw35pU0VvO15mY2kI8lgOdaNaBhGL43mg/GIu47TVkyngHhw+lc1rVXO/nd 6UM9jUvYRLLFtBTtz2WOo3eHC2Gkh/nABaaA5gR1XyDwjpalGItUHbJhd6BP HPVRrHNIPqWN3TRZ2hIGD2l/YNhUrscau7QAaQooboEaN3rTDSTHeA84RR9L 6+o0b4vDPJL0mZrpO8nHND8muLR/gFHws4udqVP166Rtx2g6T0fjmPt5aafT LcbeR4exiEebGMaPJmn7jRnVvQt+bs1T9ZoKQ00vxtOmNBpPaC7oflbM0WX4 tVL/LYZkSG7vHrhpz9qh7urWiHtQGdn/KvS6jwnda+860ods4rxixeMq2sJS aJx+gCWK+bB+lmq3K2d1WJZ6305GM9Xrfe+IsfncO2vuQj0iuy4rGR+7C73O 16RckijGw3OPAQfF/Qi3PcJ43UE7EOdvBl6tsd/F5+kUD2OALp/pvtOs98SI cyW07uTZz/s4jEGUH79/tZnH/8APy3uAw9GzSPpGcfD9Wc333UJ2OBeW/QDL wjjH3F+gbRN/IYc15XN9b247qmmksNNO9to33oT33wgZCHjkUx4qT4R+rU7a //Lukv0/P8sp9hXOfkRnxlHzN1xMz4z3ZW+5qW9R3O+hL7iJDZTn0ZObbhQ4 YjyLcR+X+I0CTgPh/wz8EoUNdipzKq91OshKon/aRX0YlfW6SB5G8mm0uDeR 5ct+jNujk/VP4fVvqdqPvftRMF0qIXedoTtsPuQ298NYJPoVkqVJpkvgdW6v ak/nnhr6rZYXlQ36sqs1cVCf7ykALIe2fyn01NUQ3rxPEfUqQ9VTJbtx/eQV FpBXRD4b8GzvvFyfozx4/69Zjz1O56T946Mz+uLjAyvieoCeu4ZNVNhPaM6N MYK1uFgyrQk14VleQDLH7SkTZ7IwWv/j6zU3CpmKxhD5O3qjWaz5IDwG4Qky PBbhGTI8DuFZMjwe4ckyXEF4tgxPQHiiDE9EeJwMp/WiePVeF4TnyTWk/GBj DNFM90hsG8R0TTNYdPlg3ZSmKsjlg6kvvSM2I8Lrnbge842hg9NRZ/YOu5n6 kNtjXQmJMa6kghi+Lir0fFvdg1gE6Tjok2jBmNfjDc6oRHnWiu13JVQEprEQ 75xRGbSOWjGR7FP+URftjDrPXOsN/Ixv081MRzbInLr8bG4LCe2gzAz5eSDL JvkZ865YK+2HPg5ZnurKILQj8N8Zlc0y/kh3CDAdrQPTXRgqzTlPcpvqXI+e ha286Po+raVJ+yhcZxr4RFTQXUKR0m7lEBZN+4nOKLLFgzIAf1zKzFiOc1Q+ v8eovzk23xPg+7ADnnEljIql/pefc3nr5oZJkZjM0f7AVrJz7NXz/XxhI7I8 +UahgzKRy0Bh+cojZP/2o9hhBpo/XBvr1BWuwDe6SzXZeV1cNj9j2cRaWr1i rcUZnkF3xEfTXHLiSK+X7htxjRiczstgEear4YnMZeY2xCPQ5+jcUXQm4JC/ 7FhbDN9/YmHIK3+i8w/fx9Idf8hT17gmg/hPugUx6wbpomWftD1nq3fnJO9A uv+LbEs0pE0hHp6OcWV+FkN1BrBjXTeziRxXOjs8FGU/Veja8n3seFqj784m GPzOcLK1QXJx21luN7exrbu4ceKAWNKDyWej+D0zqY9TvUEeU3vlkTEGY6qz mo9D0dmPe7cQH2ku6ArPbQjcF2dhDYmX0g3negzCXuYu2oOX+hHz8Z4qx/5Y Og9F4xD6KfRFJ14MVh9o/YDLJ+F09y0/mx2NuAX8vAr6EJJPaM+4UNg/VKTe Oe2FkG1cupOSZN39+J0t9bbdCF8n5tRclzxenoslvfMdQo71+u7roHkG102h tXHP7ROd93BdA8iFt/P9AbXMhjmpnh0m/f4GWqcgfjb+4Sy3j0HnQ9AWEzZ9 ydimJ5jOt9YTeC7dc+drXA/Lc+eL8jwn6cGzwHsr5R1HsbQHhLj3yjQud5D7 bSgt4um0v7V0rfkD8AFtzhsVfhcmt10g1jPmUz2ltkd6LYRzoWfRver9jsMW UR/1XaxrVPgKkokbn+jOlmeKFOdb54udS8W8elMP020Eb3IeE2uKwel+/QLX GfLMO8j1JHR+mqlucZqBG/Ee9XNLUy5jdOcZtcOmJSwa8wWja2nBp/z+syHs wTX/YBGupfIONNrHGsr3pCLoTGvTFFEuGN+jMabGOJu/j3U2h32KcRL1wKPa VkimeBzfSLR99n0s7UEEq59Szjme3erdcSm8EN4br0iJVyTaqjefzgsYtWUt bUPEt/C7jC7wM81ZrKiggpWW0RjB9V2Gi7kYPVFnojYWsFh6xzOanpu+YTEy jk7Gof2UiGB1hb5T/i3Pyri0VraeRQSua5M+S+C6sPo9o021n8KuDhLHZ+uP +nHKg++Jrcdc5+2bG8jWDsYw5nx4ON//pX6c7E7yetXEKqgsMD+MFXwLi0kW 9xf2SD3ABjmXKCJ7GdQfup8CfQMPf+p8+qNPac6L/jiu0PPaQJrPybKNdbKP qWxjg+6brRJz2eBw9hTw/oPWp6Z+HOtGf0Pj26QvqX0UfOp0n/7U+fah4oyn QdPTYZ861/ws1mmYydOirlH6eolvYm98TwfmM4vL0b1wOf0pyYmp8V5v46HD 1F8x5yNM7ON5e/j9CJxnT3qTUafpTnCS1/clD/R6teU45l7w+j7evvOyHxf1 BfOrWPcapEdc93YWw8fxgcD/6bRPnc3AieP+6juBZStsiXjfT9aJPMY0c9pS fXDXi/5qYgLghgu5w8kKfHRyGG5xXlL2Wbz+qd/4fF/WSbeZxQQJixVj0917 LmO9id9BwNe8ITttTEIfldTf2vfd1Rfb21XXvQkm1VuyDcr3+ofmi7JtxLhI 8x/PK5/LvmXfGi/ygpws93APifnmK4f52R8Du7rQU/KRz7bwatacsVfc84c4 n2QMRZ1FX9wyVMClMX/TVMzrF7GYTYALr0O8GyDLRPB5IvXhQw6/0GRmNG/S bZzK+wQd2fkkGWZjo2+OFLHpH/3sH5NNDD6H+/oKeUaLxt1uFmbtbc85YE1O 3SMmPDhfVJ48IewkFHp2f6DuawfyhMZhsc927OH+xg1aH6N6Lu/2O8TC6vZe Yr6irhHqaJ1J3jFH9pQigpd9naWXTZTDQseil06pU6PH+7q4r5d0PLhew2q2 uX/aX/6LpD0/kHa6J4J0a3OE/aW+9/X6eHPUpZ4xBgxeRo3fhD/DzxHe9Gd+ dyfpd9A+qHM539vfIeSho9OF/l7thv/P0ffSif89fUce09AXc/n0HTEJ+mp2 XoaeEuS+r74LoINs68j9jCPXBuB/XMiOX72nrUfq/YJ91lvXczgJiE/3Lxyi dbS3uU2oAc+o/CQbH2STidbTyCYxyTlijnPhXtGX87t0jE8dFrrofK411Kdz UUTyDN9vamUDCA7SzdKkS24NE/OtMlDR6A1vmPft4CnzDr301rxvvn6r5TrG Hoaw//Aq3vbTVXtV6voZC7NU91r70/t0qtPlHgqjPFX9FoF3z1/U/HNUG2J6 n54zh9tKadDvVfzRzSTuZJui3oc33TnD3HQOl+v3q/vuan7IwyzkIXZlBZs2 tfEJkY6f3X7S26LSbI100zjozn7M2ybWaw5fIc8vW1jY0ouuRXE7Wa2iH1b1 xgu9P5yWelY8D8LJGqmwssjfeGjura710tx+ouJ9hp+3aWUDCZYzMj+D7MiS XEjrSXSmIHBNCfA3qvYmCT7BKGMDd6UyrnAWQzBojdfNz8AeysEcLkpzFhZ9 8pI9/wOabuhLU1h/NP2jH5qS+6fp+zcDaPqHFcUUhCY8v6wBTddImtIlTcpF bRfLPopsKVI/xecte9C2PuXnCeLpjiuEleasHmDcEO+3gbM+S9ja0rTfPvag uK0Y9DOuqYV0bprL4C2reF3z5LR692c0evfTHdD3TWLhiDuAzmFSXxLsLmiS O6nfhJx4geycUjoug8Tx+8ArqD8Jlk6s/Yb9U5UJZN5lbqRzTcT8heYneC+f OGgK4SDjvxcQP0GNT2de+kmzsXcaTzeloe9qGkpP6Sg+pUWaOwPS7A3MR82D 9N0oLbdDcB2f+6TLfK9VbZ05r70u1rnsoxfKrpVp7uD9/36CDRm2QsRn3wTk md+ovH9+3jeDplBZ0/wA4ReyV3tSaZxBukTR5j1qGZBui1O+D0B59OC3Vf4O x+8fKK8MMc4NbLle3LUnvw/mupLiPYLroIn3SMpH2PG6sCMj3Lu/LHLQlMRI FkljUHYTS0TYE2STF89nSYcJz7fl7w/4mpi8j7vPXP0d/7x/ncGniyr0QWk9 QtxFrqwT9o3XC9tTPCx6Xpsywcmui+1Pv6TXPWKPD+f2x8Ucr0PON+le8bVP oH+l+X0s719XsxiyuwH5je6d+wxxp0t7V1x/pr+8Cr3tx/g6+T3ivIPPTuaa 4fK+3o7xweaVhB9v24/ztq2QzRsaEya6WRT1ZZgnGuneYCnPtcq7vGPo7mDE T8X3uPUGcc/7xELUpW+9b5dno66gvgxLYgPVdTA8In1reBGFK/j6nSL0gzKG iLLDPJTWc8NkXmUEB+GRfN2xia1z5Zc2OCMqqG5nEE7OgfpPKa6zdVosnZui tY2Wt4Tc2WIU81Dik2+9a5CQh9cN8tmeUeQd5HEbBom+q9HNf0dkP+7tVuNh zNsh1yJ2a3CNnjjE+yzCrGWHOJ4Dc7Z5jQijc1MLgV9YRiSvg9dyG/aRTKE6 C3wb0Hb2T6Tz5wbaC/Ts2xDO81ZyuM0jz2YWZtwsZcdDUraKC9zH4fMP8Itk pHVmFo528WtVL5vvp7zju2NB2iAwZl/MjgftO6n70dSXuIfqUkkvR/TnA1oo nOc31ZffCGk3rWK9HnLEKhZWXsHrBNko+gx97nmxFxTWJnR4vG0Eg/ar/TB6 DkuZ5ILPHmrA3RB8f+Zxd4SMr94TfwFyxwGye0x4m5PIJh/bL2yfDdyF8dJN dqgxn9O1DNVhXqaLoTvr+tLQw/dKXVnfx3J9qNVh0aA7hmxakc0R2kOnO+sk 3jGadEkaPIqQRtVv20lx1w3VRayfqovEOENtiuS0GJRrGuJ/T2e/NPHLKD+x Ri72/shOL41NhBPtp3EbbeEDYsvCdVNIn4SPf0sHTVkXqYsCvO+o/qI+vS9t Dba5n9DJuxsiyoFHFPAYIsaKwganwJl0ivZLvsYKen643U+Px4nvWfTO++2p uniy6w0exicP4evF0uaWJ5nfs3ezTuHf8aS1OtClyxE26+OAF3ito3ONAySM BBpzsldfwHyRjwN0Fx79PsT1FtxskMRnOr5j3LjQDV5/l1XBwisM+1sKPb+j ewWqA+Jeu+kJHeS1C2jt+oVaWSbwjCL1UfIeb8Z1JOOFHUGyldMSr0vc1KOL gU+GT3WD9+v0bAitO+AbrRHkIjwdPg4+Hl6BT4CHXPX9r92Ig3YTRXUe7eYn LnGHXDT1j6BhPY0voGPwmCfI1tk2ZcxQ8PpxtiXnEZYx5gnvD40VHVy2mrSK 31UXkdPk/XDTd0Ludge5Q2/SHV7vmEf4+bO8Qs8LSZwm5v3YvVWXSHoSqc0Y 75qHxTib0d+BTxnNLJfuVSz0fvdNU5YujpcHnuBns7qW0RKpIxsvu9U6TPi4 fHfhoZ9o1HGb2tR3j0FdbcFvfj/t42662yBezDO++y3Xl0D/oYHL6zgfnyJ1 dP6R7G+yLfH8PYGFLSK7026NbslCWW7NVG7DEmgMCTtQnnSlR90bI11I9xBd Mu1hKShX52AaV/IzxqzD+6s3i7Mgj4cZESdGQ0c02XFGPfgJyuyfdL6U5lWQ sfk+PdWp9fm66PXVuojyAsg6Q/L5fbD8Htf7hKzewu8NDPsQsPdMqvCeT77e +8OYR7098lsW34d5PCzu8svj/O3a8qD9DF4PvIh/CDAP0x0oXrp/icnfeZA9 tvM+aaiO3w0hw/NJL3EN2j/ZOZVhRbQGTmeb0S/oSI+Anzf3PHUn2mUM0utc WfnFTvZVrNpP0rnkxolfxTbGfcX5rFzHx+wDZexKD9p6soJ5vGtkQaxrJOnb eLajbjbTPqE8q7yQdARVfXGSkzYtF+VPsgzvf8Fjfz/633cCh1gaMyS+tI8U I+sPzbmigXei1Gn6uH8e/vfVoCdO9jFx/A7oqaJseTzkWej912law2hKVPP+ F9kQ2eyO0MVOHMXrcxjPN0KX+nCijs77xuFbuoa/cXTGuClfp2uq1sXQXvW6 SLpoh10nv8cD9wriGeoc0RQmw1PRp+aBd+lcVhFh6QhLRbyMpkKUFyvBPCM/ W37LaEF49jZPDOnOOFlxMX7T+MGQn0eTn4KxfjPCLmjCEujOINofy3nL29CU qOPr5pSvawnmPCJO4kaEY9yav25IL/yTMUbTOZ5sFrbwojqQPtvpkWIcyxG2 zbnORlOkLs79rC7e/YFOcX+jSyj0fjQ+6NrN49yu1H4WtmBHkP3O3udhnhiu 7nfuFbomOr7fnRjJ7Q0GP68gxog4Udbn/hnw+1jA708Cfr8nf0u549wrAb+f Dvj964Df96J+5WjqcUXjcfW8DD+Ddc4/pu2oETy/ozWQD4E8zwhnEai+gyFP WsD/4qBnvO9xJwfl9z3ynkdhj4vWgMkeF92xSXa49ov1Ae/7cl1AroHwPVyy ubUL+JVp8SOdVz63GaL0vc/HzVKd67luLKPxotz87hRX0oCG8qSILFdSSUp5 RV6Kc8hMWo8nvRW6byme9kL6rhHffvRyz0IWev/zL/3rt96+VatjP7mCxZBN P2f4/Oxe+w1bRT3D+D2LbGBPrNDRefulzjULHnTqbv+03Hz+HieLK4bYEEU8 bzy04MHEoSyS7sJAf/0v9EdhYv3+P3O4fdqj/N7rRL7mKvcT8I3ff9jn7kO+ 9/6fkUJH5Ha2+SL3zjcNF2uCvvXKSHnf3+oBh8qT2I1ZXDeZy+bv073mOU0D tog51YB1NOeU3xxiffYvv269nsstEQibn0jPprD3hRwXtieRcdsA66Rc35DI +DpMtZTt57u5jba/3EY28Vvf4Hr3C8uaX3oLYaQ7XyH02f6Stm0S05FMDr5+ SGMz2aSksVXajz2P9hNDOhguJb/YlXSNVejp5PO7Yxqv+0MD6Y+QbMzvXJxJ 8yWvt/EX+WTTWEc6aDlbvcezWFVVBataDJgPNq6nveAfWakPLYuMyUT9i+V3 08i9TFdmeyztU1Of7X7LXe3Kakd/LvRH+BnQL9zcnrxYc/jwbsJ/Upygge7p w7wgD98hK3/I793rc+feF24Hb0dvuS2Fwn6eEXHpXodm0tvEk695uK9n0UQb 1SfXzXS3vVcn1sY9O8VauGe7WOP2bJX3Y8Un0lPYxoa85mkWbdbjFG3Y4xDr lR4L4s8gGy+J9Gyi+6RYHMnmifQkPQ7MrTGGZ4s+wEPf82hdR/QVnmTRB3hI f2+jTLdRpish2d7N7fB5aI9rJ2T4825up+/COdHHXOgSfceFo6KvudAp6viF FqFTcoHqok7qNcVl0VlyvlZ4Qeo7X6gWbelChdh3uEB1jeY4Ldp9VsgFz9He 2Jbw8nK0h/It4aOeQ1gL/eZr/aR/wXUvwo9D7glbdyOf06Juh2/OaQq3Sn3F DLUt0ZoE7f9JeZXRnt4uunctyB4Zl20RFzBp/v5bwIxGW9uO9wVoS268k82d AryTnDaH6FTzIfiUlsskU/neQ4SQX1gE5Qd+RNA+I90JO1lhMeUV7Eah4xa2 o7xCN0W2v62iTMM2313B6ejahrQZbeDroGw2+S7INDdms4lTKtjEJW7KLwbw Yzc2srhNX/L2lOgqLG2YOBV8HIR+YdDgdEq30cz1xHWTl3I7rsdbBUzmHMTn p2UTG3XRpLeVPIgpa37BVP0rzGVZBOFaxlRcIafF0/rmYM8WtNttUwHHlw9v u2HC9ri3e0u80OGl+52kfs5+Ktst8bJc42W54je+bSFY4A+/L9R10+D0jEHo S94f10Cw+ft/aN4/EO+0/uO6547Y8oiYzPKZ8EkxmRnfQiYd0sZcEd/HumbC J30fO3FpK+nlRm9cwqJbvkEf0eplZR/EZJa1uW8kHT/nB5ifI56z4gzkEMTh /PL2ZBm8Xrrvk/SIOa2cZ+jzWj1ttI9EPNPS37JE8C5L2Po+TrRTXQDMwRtF nRgu6wLZJT+Hsn6K5t94bsfv3bLeZCN+nIyXTenw7X0JZyDZSpDfYuS3nUi/ j8oLbZnk29e4rjpjr6PtGWW6cJn/EMR3yDBxbytj7RKHI/iWKr+RjpiKO2Rt b57EjdYG4kS+3gyxxsX7j7ezV/e0EE6YG7dRP4DnniyuI9kDWeM2n23bsuaY TNUGL41/NA46m6+Lpbsr1zSL+1yEnmzrMbK7S/NsshUrxkPfecO+tpe5XkDr i2IN9kCbM5xlu6bGFZO+1c3rw0lXl+whkA3nWIIr7M+Ku8BcjWTb5r1jUp5y F3r/eJvc99oC3PP6nJNoTuy97yvlDL6PsvL6hjUGFl3mvtJDa5/Ij+u0kr4q 8M92X9dHx5XfOYf8P5d798H2eJu5jNcnbdh80nUge9bIJzkjjs7bk64U6vPU j/n4J+wWs/003yOdFNTn47SuirT8Djbka6L0hZ7Hpzvj2xjtDYNPznnraYz9 OHYS2oMKS65xFRMe2n6h6Xbe5zsnKt7nIEeifXvdD08qL3941ajntlzP23uq 73cU4/d+iDOHF05w/Ia2sUkTuT2fLck/FeepRP/+2LA1K/m4uJn3KXxvYd8r cm3sM3xfQTLvRfItpt8ks6h5E1xhm3/re8nxLA150p3zVjH277ud7PnifQOt lXH9WtSzsrdYpuuuxNt8Njfk3i2/X3U128f3CAcWc/tsjX8+S/etKK6C8GfW 38xYWWt2inNgYQP1ja6C0gZa84PsFp46FP1c9ncxZTuyU2heIfY0aN2jmM6e KMLmtNdLuLoGhvP0NJ7QHgqlV3UKKT2FQ77iMLicJWDEqndEUHrSu+f7wvvO 0p7Qd3KP0TLpC6ZL5LaWWD63tYK6Q/TQfp+KO+FA+uia9K+p94MAxx5KT3Aw D2rjduNbmY8XVFZyLbhPmx2zvjcf5J0eYdmP9eJFPPGCaNTygviAOq8MQ19F uvSBvA7Al+Rwt7peztfI0QZozdyJqkb3qLZsYxFr1kBuo32dHC4vDMjpZw2b 64h5Hr06yHjWSr/5XtN1519w3vjdC8RjXl89W6923nj+BVfm+RfK2KDU8qRB qdR2ZL+WLPqvR08nhoedI73fYHHJhoW815ZsY7nlHkaF1PuYX+h5xIznZhZW 1NJrvhFg71yzN7DFsBVyN9ripidYRFYF7Vf8q57GfV7H2SFWZmq9hs5ckk41 xaM4gHl349c/cP3XLLe3J6OV+sq/fpfV6v1BE/5DxdM8/DDCv6cw+obw72X4 B5vEHaScdn4eCXhq5k9bC71ttPeygeuuGUWf45ebWFfyEC4jHZWy0sJtOo2s lAtZKRyy0nApK+kwXiZAVjKyuBYjl5USSI+V5CUuA5CcZORnjlQ5qUuVC7cZ IZsk4NufIeS/Dxnjj3j+h3z+OSYzHU/X8JmxGd9A9ogk2eNnkD3gl/4M8oSU PUZBrviWyx47+8oeP4ulM4gZmL/wfa5mrezhdbbqNPJaq9eSQeMkxxkyp8RZ yhxdiF9UVvGFp8wwerfTEN5QZigeZTRMSa0whOWWGSKynOtQD4y0BqhYnEy3 08lG7iyCuEt0BkmXjXR/4Ol2IJ2J0iXKdGN86VjYTLIh0KDZi7LK+raB6tua O/3nTfmZpALGdYGa7sNzKWTyYWz+xhy2kPaFqP+ivgNhFQgz0hmhicNQdnpW vLGJldH5NOd243POZ03PIVxx7vW9pzrfEO98r9vNz3Rlk53NQs/9H6CNekk+ h2zM74PIYse5fjnp+mYJWwQRUv6PpWOJExtZIt4TEc/dMoTihLtpnwTvFC9s E8rKtWRBA37T/skAKp8ML8ui+jEJuDojPksZs5bLGWFUVhgrbxpDsmIr209y NPVl2Y9jPuBl+4H7fFd1fgqeFc6I/JRfL4FsFIUyZ2Es47/w/hziRaHOvubd Dv6Ex8ezWBpfKE9XxfexVJ9o/4PmxO5IzEmQnzVK5OnK5vklIDwRPI/YPITf IcLvMdh4M9NtLARs0IC6tjer9WQb6auAL61Z7pNtFU/TWbm4ZyHH7xf9/QCL 0J8/e4W7ic4zn8oua2ZZFQbSo7x6I8JiKAzv9+I9ld7xLQK/6/E7W/5GeVxt UtPLtOX4naCBB/nv6hyExco4Mfidht/p8nccfg/D7zz5Ox6/r1JhyPRh+J2o gZlQ6Ik9gbA4GUfB78/xO0P+TsTvv+B3vvydjN9vqjBk+t/id4X8nY7fj+F3 sfydit/3u7cxksliRZ9/6kV8N8rvWfheg+8LaV1Sft/oflS1URCmk/EyuG6v JzaHx2uV59Q8p0ya7/gdSzZnkzNaY46L7ye/UeOSDaWKp//Dg7BPIKsZJyvh p/RJsY20Jo2xxSHt2OpEuhP3tsrfKO9BEpZqS7tCxtHLOBWIEybjrBDz+DdG iDrx3f0tjVw3dAPGS6scL9dJXeVBHJ6AdXWrfAcs/g2wyFakRaWP9pAA79eQ Dzdrz9yp65W0TlDm/h235442QPuxxfz+BLHWQ/tW4PW3f+mjd93GyPbpUXl+ keYtdIfjAYTH83OJbex6kivwvBHPvaq8QHp8XGY4wj5sCmfvu//A9vF1iEeH N1BbQn6DyMYBcHZxuxXvCL1OOpsKPMjOAf8NksP4/cuDwvk3kebb+mA6fyxs uuUy1uzj6HyfPNe3g/TJMNfHXPL7+v70V7Q6MmuOsHSuJ082r9pGxmQZTlVk GCLQtq56E/PdDLLh4GRFqc6BhrW9fl9lWOuyVvYKc5n5ee1kgpXlVpiEhfK+ 6u7gZ0FIvt+Yc8sXXm/Ok94Pg8Pzdoq16rxmrW2Kt/x6ldw2hXOTmH+RPQqy rUrlkYE+Y80WaqPrTVJWTRTrVHvqVd0h4FX2up/v3P7EPa3smbmturucLCyB jwfxzApfBj8ffiF8BbwRvhre8mQng/w4aKfbGUh3zAoKn3Qo/Dj/5g9vclQo bMwTYi5C9ZBs0RZ6WsZLW6EHhE7OwHVzPxD3NrmSHqH96jDS76S9uZb1zMnP q3Ldzo/vp/sNrIzb5InIWa3bSXHFWb9Pb6P5nP/33692x7O9Tsf16v2BdEfH NZLOvUhb7X7LTfePKPccJV2wVwswFg6uYG2rncywttBzZU0Wy/5xBaZqTq4r oksEbcnyvr9YvKfKd+qHZhR6hvO7GFucdLaSytmzwWpmQ3NWh3/mSoorhkyv bMzi54LeQtxIVU8N8VMRp9Vq4HFbXMPPq3ETSIdlUhbbTTotTVlizc55XWEK vbsyZ8buimQDQGOxvNOvi8JprxVh6fSdxnvUhVgKb42ktbtshjTsllW0X+j1 tlzL7b9FyPloK9nE5Pb1MC8CnCuRLmHekji+vuiM4vkmoP0luEaJvPl3sre3 lKVQmIt9FUu6NGiXar4JyLdB5tvQ5GQJE5VmwLojheBzvY6oBSkclwjmwLjc sm4Lv0edrYtjV1E9KmvGPKcZfYghAuPej67C9x/j20/UcLxTWTDN76sD0mHs u+KgakcQT1p73A4eKU62dC2eCU5mXwsaK5xs1dptWZq2rzP0/h1jWCvqfpym jl/h0tR59IFX3J/80/DjRiPLQD7pmOMb8Uwoax7wy+RY2qcMiwmIP1nAxNgq wtA+rkgKyKcCYVeLsCvVMGNFs4L8oy+I8PNGGQ6ZI/obCkNbCJdh6HujP5Fh ETIMc6jodwg/0pVGm6A94GoRx+uVcSBbRD9GYe6tLN7fZ0av99c7FndPK+8/ wgCj+AEIzYXeH1panQDzuDuR5Gn0T1c2DkSb9MSSrvsB5DeU8qP5m7G5idY3 uo3NYdl4HsLTTesdvHzCZPmEyfIJW7WW619WDALdQ9/TtKH07NUXdNQmCz0J 91M7xfNeagubelgyfGr2tp6jtG+jth23mcarBD39vgV9EYVJW1c60Rf37EY6 sqPklPDGc50AwMOYswt5ku0l9LkJGGd7gE/C1aC7y8kq15YxXSvvQ7w/7Ecf E4cn3T0UPYnPYV96mnSdISsrpLufxWIqK9isvzmvZw82mmnfZwLf94ln4ceT r78ScD4rJn0VuaZXRu0LfWieGFN+cYLbbaf9f18f+RezCj9nNd+7gdzyUhrp 75DuDtK8Bvw/LPS+SPdr7xX7FS9dJfdTkf6lHHx3aM+Dch0j0jN9nJ9jSs9Y g/Ft780NGfdg7Gklmabpg+T4gSeFDfqBJzEuptNahNDXaPpt01RW3dRI/ddP WHlSXIYzckEK5t3Vco0tFt979U8Un2w8UlyS819ej76mETAWIWwp0g8pSZmo uPm9W84hpSl8TGr0tSnU9ahImsdTmLHZrQmP/EjIZffV0/5K7zSRn6h3R/N1 HDeV+X2znPfEFSeGD9kj7CN69wfbS5F26o4HnmMs9Pz+n2v+wNL5vXKKuAeX 2/b8euza5YfYGLSdncu/YWT3MsbZVElhN0E2jmi9kWXItnXOfihbrpv6cEWb jExy34jyoHWLSG4vZjf/HfkZva8TcJgbsOl+qlhXVeVaV5VhLd+nYuMoH7o/ Id5lq1xLeU1WyD6iLtVVkU/pUxFvDJUFxZV2/Yv42sXwP6u2VKJ9a9FrxD1i +SzsarrvWe4PthFcVY+/LFz3s8nDWUqGGTArxq0lPS1/OrZCky4LONP6Drdr 0njsh4asNpaSBXoQ7yp/PM8h7T5a03DwuInoa2POwfRE3fgJ+mozzXNe72Nb kaBcbM1ozRph/4tkXtqPbN3KMoTN/d+NoL6Q8PaXxWBXsPU+FpZ50TNnTbnS xhjqBJXDtlGacSZyPq0F7nPZQMMv2EL3f7CEsp+j3g8e+wKdW0EZ7UDfdyXZ U83Q8f27GMyZF5JOAsaXCNfIsbHPYnxOjhD6zokRvG3uJl1kGbauaQmr4Peg tpbEugcyB+1JA24erSc2jWL73FHs/eQhVF+mxfK9PYQhj/cJNukXttzLHBsB A3WD68PjG90bUIZ0e2S7Dn7uie/L/vZzmpuAHn87HjwuBfm2ybzIfm4EfbdG hpPMXIRv812Lx6ZkRHJ6o6Q+RuyLZnYOec+fyPP0JmzEO+mpAsZCcX/1xPSL lvURWQ5c34XtQd9jpL012iNrKgBfovhZJWdjBXtmXoWQlREnoXxhXAaXhbJm xpZng4+QgXasp3uTN1+FviqB0xV/h9BdjV+QQnBp/JhoBv7gq5oHxhvHxkaS EVh0Y0UY6RW55dqMsZDfF8nfyT5xMvVBfetZRtnF9C14fyPpI33DlnDm3JTL 3JPC4VegX3lc3LUp+nHXCHWtu6UBcuIdaClxXDb8TO7X9NEVQHhGoSduov9c qtinATyEr5qcURGGvjXuWr/NorB48Z3CV5Edfd6e+DymEfU4nvrnVSuAVxbh zO+Zmf63BpLZX15IMPV60h9qusudTbZvUAZ5VN8QVoT5Yf6mJ1j6RowT4Gky +JawcSpLpD0GMW9/idtRoDuOMS6jfuwjndx4eQ/yUDovz+dLYYa11I9QH0Lf uI2dAWiLkGfoXBD1S5CBBsrfQ8TvIf+Uv6Pl72Py9xXy9yfy94/kbzonWKyx DUq6Ahl0v0Oh97k3Bb7XvyPPp5BdinT5bRvtZbKwCXvlGsH+YOfvfHY3t4qz G3R2a96xQVMy5Pm6Qu97OVxXTej5ZNM6hZgzPkf6P4NpzJHr79ei/PcFm7cD 7pV0XkPoNjwXKc9u7Ke9hkk5LIrwa5zB7yrXqWsIhB/4/h5klCgq9wpmOKSu EVCfT/drArd7uc4R0sq1BcDet9GfBpVYpInUpLktYD2C9s/ubPWtR/yYp5F1 jZ8fRBpar0jnelcB+x7S5hHT2p/Rju38vto3xDlN0P0JyRO01jrVg3GhMWJh oSfsXpInqL8GnME0rkIWmpwYT/vaYq8LfPXfTRtwtnpedmK6wRDDaH160hMR C7ktSH5+NuwK+RxhrXBzvXuq31aMrQQ3+0nvrrKK5im7rhU6IGQ3g/Iv9Ljf 4XkDN35eoInWDdlhgiHs1nrb1LtpfWtBOfzOpvRddJ5P0ou6+E1fWtnDBOfm rWSfSpwtpb1nylfsP7rpXPGBYPtLnE6zQvfoinOqtDeop3uVWTTRXehZXkP3 zgia2VXymUT5tej5erS4RzSM7HZlc13p8qShngwzp6VF0N74Hqedzp1u8zo5 zhe8xzj/gB/BAQ8+I3nYGf6zWNpP52P30uvF/uZwRnPyoeVJB++h/Tcnm2/B OKlgvnqe7w8gfv9xF+3UxqV9BO0aFWQXXZl77RSu68XcN5at1yXSmFG2fmCt U4dn66BMpzu8wQjZAHGjnWxWMsm7ZU8Pfgu/Y5yRiS/Qb24ToULYdPrfwia4 gL/XGTkqFr+TtfB3/Tvwnwb8e29uMD4t4bf64buUol5wyYacCteFsTaL0aGI Ri/eM2jM5bhiPk/yPIflDuDDB0kvSNjR4qyW+O7CmKrm8T+B34sXbYOT/1d5 ED+abw6ah7Nt1mXBZmGpH15Mrmx5Cr/F3cnM7XHHYrzfSXKY1l4t2a/lcrw8 X7ZxONu10cB2b8xlezaGs70tR1hbyxoWLWnhZ4bpLiI6wyXttxBOiuYsXtum wyzL+fbNKzaFibu5Nr0Dms9PaniAznJh3vjAYYwdi69v2DSMJWzKYYmb9JiX N7HUTdto7j7ggHNQXHZ2U1iycx9LFzobLF7RAZZZSW1s06U631NSXSPRf3+h pJY91zyl7CndFOfg0gfn/bl5iku57VOy4eNsu/ZTV2RGcTnqojNiAeYqqXQP WoIrYlQsP5MQkUh2x2JlOOm9eumba1B28bw/A15E6YMcVpQKKzsorIkz+8JS w+cdct/Y+MfsYjrP6xxU2kA2DRo/T0iV/VT0pi2MbdrDdPd8/0aDs2OcuM8L Y9Jq8Gk1eLQG/FsDHq0Bj9aAR2vAozXg0Rrwcw14nCHvWiF9MHkvXJizddyD zu2CbwjbU/Z70HIsg3AIK9vZDD4ZJJ/0krYX++VTMNoorDefDA9yWENVWMH5 FIznanh5tuCTcxDpxng6hyegrJ9WUp1ff5hKOGO++mDjBx+mOg8hbDD6kld1 U8r+0Tzlnn+9weuAa52hwXWz/lN+P9W3r33q/CC1mPaZiefOQec5Ds4/jorN WAocBkkcRHh0hgFh+Ob8Emm+BT2DckFPDudN46HXQE+qhp7z/fDmfC/elFUg vhf0/LSU6GlxDqX6jHJC+dPeJbeL8aQn2vkYxtGeSaQPdL7xqK/Milw3dfvs rjnDz/vsAPLzpm3CLpprRHeM03ttDNlSck0p5HVLwL2wu/Hzs9zOBfGx8Rvw rA28WwI+TUUZVX2YOu9I85R5/9KBr9c/2IhvrlvDG8qOo26A55yfN6O+L1/Q 4LrvRQ0vc8HLCsnL72MzvyVenpe85OHRmf9NvPw+1vmhysvrwctrP0Xf0OBy o24UgJcoa2cU2f0TsEhXcWIE2fyTsER4NIXRt7loQ66i4mLK37U28RpndHG2 qyrpU9Jpc7lLGoZR/xgRFuu6udtvZy9C2Lx1jZgf43pCH0P6Cq6btTzqaXEO Af+6botxfvN+qpMlpLomgzc9CZiP9li8ns82wLfAb4bfAr8VvhV+O/wO+J3w u+B3w++B3wvfBr8P/n34D+H3wx+A/wy+E/4Q/FH44/Bd8N3w5+DPw/d4PQcZ vA4+Aj4aPgY+Fj4OPh5egU+AT6Tr/uBT4dPhM+Cz4LPh8+Dz4Yvgi+HL4OfD L4SvgDfCV8ODxoNWeAd8A7wT3g3fDL8OHvQfBP0HQf9B0H8Q9B8E/QdB/0HQ fxD0HwT9B0H/QdB/EPQfBP0HQf9B0H8Q9B8E/QdB/0HQfxD0HwT9B0H/QdB/ EPQfBP0HQf9B0H8Q9LeD/nbQ3w7620F/O+hvB/3toL8d9LeD/nbQ3w7620F/ O+hvB/3toL8d9LeD/nbQ3w7620F/O+hvB/3toL8d9LeD/nbQ3w7620F/O+hv B/3toL8d9LeD/nbQ3w7620F/O+hvB/3toL8d9LeD/nbQ3w7620F/O+hvB/3t oL8d9LeD/nbQ3w7620F/O+hvB/3toL8d9LeD/nbQ3w7620F/O+hvB/3toL8d 9HeA/g7Q3wH6O0B/B+jvAP0doL8D9HeA/g7Q3wH6O0B/B+jvAP0doL8D9HeA /g7Q3wH6O0B/B+jvAP0doL8D9HeA/g7Q3wH6O0B/B+jvAP0doL8D9HeA/g7Q 3wH6O0B/B+jvAP0doL8D9HeA/g7Q3wH6O0B/B+jvAP0doL8D9HeA/g7Q3wH6 O0B/B+jvAP0doL8D9HeA/g7Q3wH6O0B/B+jvAP0doL8D9HeC/k7Q3wn6O0F/ J+jvBP2doL8T9HeC/k7Q3wn6O0F/J+jvBP2doL8T9HeC/k7Q3wn6O0F/J+jv BP2doL8T9HeC/k7Q3wn6O0F/J+jvBP2doL8T9HeC/k7Q3wn6vwVeXyLdl0j3 JdJ9iXRfIt2XSPcl0n2JdIeQ7hDiHgKvDrXQMiQ8eHUIvDoEXh0Crw6BV4fA q0Pg1SHwqgvwugCnC3C6AKcLcLqQbxfy7QKcLqTvQvoupO9C+i6k66J04G8X +NoFvnaBr13gaxf42QV+doGXXeBhF3h4Avw7Ab6dAN9OgG8nwLcT4NcJ8OsE +HUC/DoBPp0An06AT1+hzL5CmX0F2F8B9leA/RVgf4UyOwEengAPTgDnE+DB CfDgBHA+AZxPgPYT4NkJ0H8CeJ8A/SdA/wngfQJ4nwDdJ0D3CdSNE8D9BPI5 gXxOAP4JwD9B8FEnTqAunAD+J1AXToDnJ1EHToKGk6gDJ1EHToKGk6DhJMr+ JMr+JGg4CRpOosxPosxPgoaTwPMkyvokyvok8DwJPE+CxyfB45PA8yTwPAke nwSPTwLPk8DzJPh8Enw+CTxPAs+T4PNJ8Pkk8DwJPE+CHyfBj5PA8yTwPAle nwSvTwLPk4Qn+H0S/D4FPE8Bz1Pg+VeI8xXo+QpxvsL3I6DlCL4fwbcjoOMI aDiCsjgCGo4A/yMoh1Mop1MIPwXaTuHbKZTTKXw7BdpO0XeU0ynQdgq0nUJZ nEJZnAJtp0DbKZTFKZTFKdB2CrSdQlmcQlmcAm2nQNsplMUplMUp0HYKtJ1C WZxCWZwCbadA2ymUxSmUxSngfQq0nQLup1AWp4D7KdDWDfy7URbdwL8beHaD hm6URTfw7Aae3aCjG2XRDTy7gWc3yqIbZdENPLuBZ3cFbeXBA89u4NmNsuhG WXQDz27g2Y2y6EZZdAPPbuDZjbI4AjqPIO0RpDsCGo8g3RGkOYI0RxD3COIe QXkdAS1HUE5HQMMRlM8R4H4E5XIUOB9FeRwFrkfB06PA8Sh4eRS4HQXso8Dp KOAeBS5HwbOjwOEoeHUUeR8Fj46i/I+CN0dR7kfBk6Moy6PgxTGU4zHw4JhC 5j/hUUbHQPMxlM0x4HsMZXIMuB5DWRwDbcdQBsdA0zHw/hh4fgw8PwZeHwOv j4HHx8Djr8HbrwH3a/D3a+D7NWB/Dd5+TXwFjd2gsRtpu4FTN2jtBq3dgNEN ertBbzfgdAO/btB9GnSfBrzTgHca9J8GvNMoq9OAeRp8OA2Yp1FWp4H3afDj NPhxGmV1GvifBl9Ogy+nwfPToOM0+HMa/DkNvp8GPafBp9Pg02nw/zToOg1+ nQa/TgPH06DvNPh2GjieBo6nQedp8O80+HcaeJ4GD08Dx9OEI2g+DV6eAY5n gOMZ0H0GPD0DHM8AxzOg/Qx4ewY4ngGOZ8DfM8DvDPA7Ax6fAW5ngNsZ1Kcz 4PUZ4HYGuJ1B3TgDnp8BbmeA29eg62uk+xrpuvDswvMf+P4P4PkP4PQt+Prt 3ly9xaJU6g1LHTa9wZQJaZuxEakZlvl4i8L77ILiTEUEzJ9eor4W+d5Kpt9a inerUlaSw2OmWxqUvBz1O4Fgs0rlzwZl+nR6S2tQikvky4xi+TJL/VRQMiZP fiUfxW4tLhmROtbIkZveYDBZHea6WsVcqyw12WpNFsVqUEYAtt28uFZvUUYY eZ56Q7W51qQYqk2GpZq4NXVGUwqwytXX201GpXKFklhlq6tRauy2JMrAZlps J3IIRnnt0tq65bXKMr2l3mQnIIiFtDVa2LQnaTTaTHa7YtXbzI4VEo+oQBwk eqMVq62uUl9pWaEY602Ko06pqVGq9PUWR9Rys6Mav+qVuqoqYlyZTV9rrzLZ FJPNVmdT9D4g+Jind+gDM8yx4KXGVOtQfFxixba6xTZ9jZLLcfCHjxqlFFgs psXAqKDW7rDVGzhTR40CbHwrtpmXmfEZLOrzmb4DNWufL9P0RsVBH/QOpTg3 kwolWeFlTy/LTAZHnW0y3glGnqmyfvFi0KYmyFb4l1l6+1Jz7WKlsm5xPbHc AdrrrQ6ZWkltGMGTs4LALyNQP6r1tUaLScRSbCarRW8gWGqiKF+i0QW1VXW2 Gj2hnsnhzbYpSkldvYPKS1FybIsV4XLr6msdUdQmxhoVWYl9DyNPypYPTn3w 5I/0yQ9H3vb64Jp911qXnPvVN4anxz9u/PVTP+pYN3ZF557thz755saHPj64 LvL3RTff86Lzzf/aM3pwy9s3bLzh1Rjjkl3KmbOv3Z3f/FbOF9e1H3DVfH70 23MHXrltzd/u/dNPLFvmGpfuaLtQ+d3KX5g+6IoNWzjHMMhy8PsrJxvuj7ji n5NqlfeLzDF3fVKRc/TJxXfbssKPflSoO3Drx1fce+HpqFeWjn9lx/fTXtpi 6Xjjg0937v0ue+xnliPTv1xY3/npFX99/qPJt990MHXnbV+wzPf/fpv77f36 a4btPvfK3Jf3Df/r679+eM+bT1+ZOGDP44sGrov4Y/TBl14c8k3CmDrnz+dX F131jv6G539fNXryss6clrCOuwdt+VjZe+qTmFF3v3jv+kG/f2XoE28fffr4 ngPjGgZ/8OSV7Lv0ByN3/PLwj7bENS654o2ImsmjNxotD31tWBi2dOlt5+It +sp7Tamfnalksy2Dfn3i+rCnV62OOPfOP6/cN8+06+Aff/zqN8X3vbXnHz2v rXNWfn7Dl1e3jy7Y8Dfn2R8OFJlmvaSfn/nKbf/51F7mOPBG6lczv3w6Z/Jn v/779o/21fzt03M/5Jq/WZJee7Dnt4vXzWiv2LM/TzfaPi78hmPPRRUt+vwK 5wfFA+/OGjkg57m3hsTEfBCtrJ1X/coIpe7el1+rOhD5n/qjT9z1xXc/Sjr4 wZZd+7f87E9/37H79pcn/zRl9xVNr765cFLb65bfntizRnnk7Zd/H/77r6Id L378yD8+uXXiYx8v/52u46ar7Z3XrDliGPLjzcZJzVfULJmycskdO47+6K9D NkV6H4tiL4x0DX78xe4rN+X9POKpj28MO1NtHvSu578r593pNi3+87WWCXfX Lh30X54D1y9b/7ebD8W0r7xj8eczP/zutS/rfvnWqe9++upbuRW7fvnJp58+ dXzbR5vuyfjs3X1zvjxT8tEbi08/s3fe4qmvDPo8/6UJhZ9dcXP776KuL5oQ PvNfObqVFV9WnPrDjsVflqfV/vLUDPNbK/6sf3nD3qo1142o+7i1pPqrCR9G L//1G0NuDf/ZgGteKx9405j3Xp/01ktvDkm8efcdDyx8eYnu3b97f/PK/r+m JR98/L4FX7xww6PGd3d1Gc7cVL/kqa0DajZFbY0c9Oy3P5ow1TZ48b0D2byf /Prtmau/2rMydtWLN78Q/fvrMx74+JePHvvkrSucnadeHdLx5bC1f/v4wOkD X02r/vzl80Pb19Q2vXXNX/712k0L6nYtPxz36q3L10Xc8bX3yiXWqkGT/uOq sCELf2V63Hu+8gWzfqn3b9dY/jq9Neqrhr9f8fHJ2bo1ZRPDX373N4tv0u+v uOa/C8y3zppSu7zjhY+WzDz46R2d2V8Oqbrls0ndz+59ofSLNx5/79aX/tqY +or3mzffPBP/H6+/+4vSlzelJux+6pnX908Y+Je/D9pU9sW8pOEHF7/9ctXK lH36mXvurL5+wKi6mzfvHvLWLX+I/uW2OwZ+ef3oAafun4Zeagb13ujA0M9Q x5CsVJkb6q3qzyhmrjXU2WzophQj9drqsKEJrzbpjei35BdzLUYcsxE9mN1k W0ajlNkh4ovw5eZaY91ydPsrTaxejlGGuhorDULUF9eYHNV1GAW9nish/1wJ +SAG7zGQHWIgr8RA9rgK8sBVkKN+HKHCrLTUYXxwrLCa/PnY0a+a1E8WU+1i R7VdiwfQksHU2Zr0hKSjDgOavnaF+gE9s9Fsd+hrDSbFvqKmss5iBy7XQM75 KWTAOMg210K+ug6/r4f8Ew+55QbIYDdAzvqptW6ZyWavr7QbbOZK4GFcUauv MRs02doxephMnI81VovJYbqsOBYzRgG9ZYzEkH9mAXkFjaPSHfDRAJHC981H LA+lMhgFee9myIejIdeNBn0pkEFTIEOOgYyYCjk+FXJicnFqysTxxYiPEdWE 4dpUy6UYxqowCovx3/9N/GKM1yb5y1xrr6+qMhvMNPzXmGrqbCtYJUJU6YHi p6aNHZc+fsItGRP1lQajqWpxtXnJUktNbZ31bpvdUb9secOKlb3j5UzLzZs+ 49b8gpmFRbNmzym+raS0rHzuvPm330HxsmaXFxVNIRqzIGtmGaUv07wH8wvl M88flg05eTLmT1Md/+/wk/MvP24W5PHJ54PACBI2BbyeAr5NKdKE7ZTxizVp i6bV6W2QiEpXGPSoCyaInTmzcnOV4uLc9NTxtxbblOkk1XIBSOFxqe6ZbGa9 ZTiTaefpLbX1jsCUQRImKzIlpGaHye7IVBoaIM9PQ9K6pUJE+l+53OLyTIhi TOBRt9xkK85V0lFPxzOmlM8unD1n3mwlsXhuyWR0uA1JjMTJEXZlVv5KhBZN g8hZn6zMKZYv06fl0gt9TopiplrAEI5LhySiF+cWKHpbJbVywIGobjKCRh5q X1FrUEwNDsXAO0WaQ/jSp01Qlk5TCkbnQuw3QTikX3niF5PpeXKRlHAUWDD0 GSqMEXbwa3pxg1JiWpai5DBWajLUk5A/plBvr68xK/Z6q7XO5mC3lvjjzK5T +ouGuZOINg18LC02+X6o4bnE3xIfKN87xadqEhh/Oofjj++DmeMPp7TTi7Vw xHsexc8ryZmFilGL6iPeRWdFE7N6dHVVkLdJrFbj1ddKUtAp09wtigX/lptT qlj0DlOtYYXSXxyZha1uuR35YOpRbbZjMDU6qqMuFl/G8MOkeY7NVIXhtlqx oubXGXmWaJv56M8Lj8Njrl+I9luEsKJo81jDIoecy2Vism1UDJh1R7GCsbmA o0dT02MGSeMV1ZraOofiw0HMdcYaZLwqPYYDozrxoPTLUeqmSwAYhQmbTDmK 5mkjLEaWMiJ1HB6sUl9vtIFvBI/IQ0NjEjZvc5TvCgBJSxnLykdPqwPstJS0 lAkUZ0ZRTmk+Js2UB0QOwoGZrfzBLHV6o3hDHkhF4xifZ5kcHO7w4cOV6SUl c0oUeiu2mPR2VKTppdPLUCwmTP/Qs9Ango0I8/S2WkzlMpXFwHW5foXZqtSa TEaSTtBFcYpNDj7Hyymh2uZAjTLQ1A2N1cAjToI4o7c5aD6oX6w31yKyDxbS 1ZocNZh6smUWfS3hWStfuARm41HYtBXo3RS1JEk0mow2bFQSafWh2tSQRPNE SwMfs7lwxuj3fP5b5UVUTiXKJQr1wmgRvhJe39n3adwlnjwMMkNltsan9n4a tsPvgYdcYYDsZIBMYTgvfhuZfEbAx4BOG3GH01gHuQeyCr2X24kz6DWNpmVm A29mjIuj6E6oylKAUpA7q1jJr7M7wGGjmUuujjqFUb2jWo26l6XWTVUeKqHy EOItD6d4Um7SRueO6imvE5lKBerTCF6BRvpLN+B7wNde6dElIgYt+ThEl5IS 1Ru+qKe9kmu/W3k9kes6FGexeZmpNgCGWje0ULQ4lBUrIkpQSNRf1KZKD3mh do98jwn4Tc/9I4wp6n+UW62oW2i/dQaHicvd5hpTXb2Dh80gmbFab+eFUqNf bDbIMBLOLXrbYhPl7UA+9dF4Ar7jKL1Hlc0AylxczFRmmCETStnfLDAXP9Ko vhuTokp7NydQFGUEYvSMVMjz4W0aei6DCSQbKRTftHmMHGEfCWgAxvpC4zi+ L3x9kXguQ52uT4+6zPZdpgSv1xwFvuoni4fR3at19TaloNhXVKCZ8XA7ZHGC 4ai21dUvrlZ7IEXwFNMNE6cjhbEi9Hlq+kya/omlLh7OO69REUwpRcdAwPka lehRJosul9aYLPMD/qSYaxarddPXCdbWKdSnKnxyQBhMgiRCOBIiUb36W54u p2R2wexbM4kNyJnXgjrEBucxmtXoG/DFmIRXh62+1qDno8bl8njanDlgZqUN JBr0qDDUnnkPMRtoIf8SwrNY76iWuJTXikU6o5KXn1uszPGt5c6ZMWN6yZic 3MJMDgMfFD7azBCE9KJDEItmZMQoXsdBQGzzsSSK1x1Xm9dzD+a+9zD5JB+h edf6GP+7a798z+sn7v+3vVWDV0PvbxTmwzeI599aiNOZSsHsuTlFBXlKaVlO 2XReL3kJGCx8ylhJnST15mr9x3d9vaOOxnE+bs8o7fP7cusIHwN6VxEuLxgc XHbt01EjwGoz14g+zs7jjvAJE9JF+RoDSfo5uSreaE7ohUZiDqx3GKrF2q66 Po9aVloyZxa1AdWhjc3P7O9PVO+0ptplZludWGAnEJdMq8pEyoLikoJZ0+8k XJLBWLlmw0Qf1wJZcWMsfAJ8OnwWPPq7jcYxTPSlZaJvDxyjcvW11CvXyBXq Xt9KV9RYzLVLudjXT7p6X0K139bE4cOFpa5uab3VD8PreRC4PgRcH8K49FAF POSOhw55PVuyx9RW2W1ogGMu0on9O31YsH5bjGHqpsgys15BLQzoyP8n/XiU tiMfI/ryqGCdubYjJ3mon75cy0fwToGwX0fdqpzqiDFIU6Z5ehLhR6QbR9Mu A/+j0HeEjTVm8q0v+qOdSQ8lkuBpHaYB/iH4V+APwJ9lLOwq+FS67qmkLBdi gANT2RUoz+WY8PFBHMIKb6I1YAAf2jEtMlnMNNdN4flA7reMJqFitJiuLoc4 YXfUWa0mYwqkq+W+Vp6SwhPUGoSMrMr/qjxdC9nDajAvqqy3L3LULaqus5sS k+RsJEojJ1qrV9jNmBapLCdYlI4SLKKPlBpAMsUU2ZeOvveKKzOiJGpcTWNv 8P9N7/N3LIZr1CJmtZmoavJx1Giy6ElYpndDjZFNnqKwrILZZSjf8uKyKb4y GZEySqyN1ljr7HYz+Ih+ERWOD2/DM26ZEEXt50+Qs/7UBX/O6/kD5op/6vH7 9xNpX01dPoWUZlcSMTan8LGZb7xhHpRbV4PPRt8YPowQKLfrF5syozixIznS I0nqqrfx1WCjyQFBnbhd7l8r5kC4+EWj/gplZLXJYh0p8pguhLOfjbD/jNcN o6nKXEvp880OhXBbalpBIwVVB4XGBMqS11XU/YiICP6Cp4IKSPw0V4GB01RR VKmtr6kUk4HpNVbHCqXUABGaNwSKo66E2wxiP9GMRCa+Li1+ixV0+ipwbQCd vCbbORi+rCJW3cX4hWD1CVIh36gRxa6vr0EuoHp3Z+8o/oHMISbYo5UcRVQ7 FaREt6beztsQLcGbeKcKyDw51Ql6p+lglUVvr5ah4l1MEvl7XVUVGiWz2/S+ hPxdziO5TGfRL6ZKZrXVGapsprt5vbdUUpXnP2U74+9y7OH1fjLVTwONSrQH KrpG8QFyuroAIH6PmID5bKWVNxs2YnTaWPtkuY+BEU3+HjGBr61BzkRnWIU5 pHgqfGvbXOsQy4IKbbEqYoO43mYKrKcoO7/Ib7Va0PZ5UwGrZX4K71kQL0fz Gf1YjbmWRNRkxWZQOHJcy2BxHXnRzkeLkguEq44II/nMD2k4HxagpVFWd0Zd flKRjVVvFwMWIIxU0D/iWU/SAdFHFcHB5JMDLjbZaM9ZLnLUVfF1jtzi8ihf GwGtJPISTFHt1cosWMHr/yzehmb72hCF5YtKmCun67zsyjXrWDk2Q7WZOgGU g7oZPs9GM4ACnk0ZWhdfEMNwK/sGDgMFVGvUo5sxacuAYJtpK4VIBXTtzhO1 UyHfgeTyWt8nMZSDCj4WzymMYhBCRjqEBOBv4nI1gDcu2QZojUJdQ1Hbwq3l s+9ANRbLR6NF4xNcFctG6JvQ/dGOThThMR9xfbnPqrc4zKO5JMGJJ3iFQjXE 9xtp5vIiIbxVrsr0xG+ue5FbkivmGR9jnvCx8m/4avncIJ+7iAs1so3X8LrC +aKtg4JHwfosfwVWa3A/ieVuHmmxCAiRagX21VtelQnWyEnK8mpa1ZHVUa8U mWvrG6QSTXJUpKjzBn0t9XpUkdUWgnqtp/mc2WGTnTftf9KvRdXmxdWcRhrb iM9csrAvMtcuqqleKfguJSylRF9jNNuXUlHKPVVIb/7GQOuH/rg5s/IobkGw NoP5hUC9uDjXB7VA4MXEGKKq2dgIGAZth63OQhnPNjmmleZRh7DYNHqsQjMf tLJETXfAM0qSOfllBC48yN+aIsE4ShvFyYo5xZSSzAeakTLJSF96o/r8N9JF kWBA1dTsa9IBXOC8DdZ9qOF9uhAZrq3qkG1Efy+e/v5eDoJmv04N7036VEHe tkWVpb+aTvffg6MdmGVf3LuD9lfySWKR31xrsNQbIZ7zrlYFJvpgCUFApuLn LSFRK6wkq6iR1GTVr6CqoKiro3Za9mW92D4/U/LLYlefgk6LGV0Vadzx3Oxi xkvYchGAz8VExGJiiL0XK/SYogdJrKeVR9KAknTwibzeZhYKaxxuiuiPBYq0 LkMr8CSwivBcyProyDOlkNxrGtJ7BqKUl+VqYdHAwVfzBd68stCciIMaYdQu b0X527eSo86qaLuOEk6vJRm0uA40ZyoiVNbNXFkemTK9yJd0vUZkWLQZFMj5 wJxS/zsGV9+72rkH0ZdgGBzE/8QR9iQeR/1q4msdlSvN1rFK77DFCNMGacZK qXJH6x6ajonR/NVWs1xv42OMkHr9Ooa+OBYUaB6f86JjMvG4ORZrtZ6eJbO4 3ptFacigDZiCnAnp9H1WQXGp+lQmpCvTzA4mt0lZwbRZSum4iak8z3qryZZP +3Q5JbTvx59qAko/IaOQnrPNdbzezjIbbHWVFj2NuhQ2uqDAh69WpuA4zi0Z N5bx/R10mozxThe/5zbMq7MttfvSUfncNnu+3EsCj8qmzyrl4+gn+72evy+E z5NP8kWa9/58mXwa4S3wDsDa6fV8aoVvgHfDr4Nvgd8Cj3nXpzvgd8HvgW+D fx8e+X/6Gfwh+OPw3YCDMfoTvH9C7+cRBjw/jYCPgY+DVydL1FdSlbCaxBSF 11/5bXF9LVUWar3ocfgEBi1Tsyci46Gx0w4mpsc2E9ha69vo6/29AKPp2D6R LjKOcRZfbNwa0dB7v66IeikayJdhmk5LAnIRhlrhiNEZPH2DghkF/lHbRsth yI8PDvLp69Px217nh8B7UE2v5ps/l9bXslloi2X1Jl735pmMtfRWVo1pLLUL m5mV6kFxwDxClbNLuJxdUpYriQq2poLmbdSvSKLOKejyito3SLlATje5aAxs o0jfhtd1o5wujVYWmxxjkO8YIeXz8JsUWjXhdC2YNSsvr7q6pmbBgtzcO2+/ /c4FKXY7xDQejyeJIiCk9su7dlUMy5S808JTI9KIhDHM4IudSWs5XASzr7A7 TDXBU43k2Y3UpBIoU7oS6tS1PKX1kEz/NFr7mylTFf47hf6M5isnJajJiho9 4Ns82p5Wv4FbRkzH5ZNwu9VEKwo+BRMlvaFBycstGWkXOtfIHRFraVbOKzvk UM1XXs52CdPug1l6uTCJ/j4AgZuZAMqniiMQWIxWQcuOFJMvPppr5R4oQKhN C00vCjKObRHlsSAFZcHf7lTE9J6Kg3NE/uTr7SJyMt/il+C5oK8mVunkeNl9 eJX+X+IlUl8MO/FFxMMHLXJR06cX07p6Np+MYyCV+ghSTRrQ5LkAuVVAe+bq XLB3WxZ7C3I5mvEs8TSZrOCH+qQylhna6ytHi1qvrlmiIqKn4bnzP5S3odYR JZMKIoLGUNS1A4IyRkSswIeRSiUXMniRVMikFSoGeofKrAo8R0Zdel2j4fLX Naj1BepR9HqX8yjAEsvlFGghDfbEbAEgSV0C7YXXMjEmB8NJ/eTHR4wts+t4 o5peNENIn8kK5o71NTxTxBPzUXNlzfQavSExNTmVxChWjVl8rdgG5O+ZI8Ra vLpGbJosAujchaPKwdePczD3p6HBIOY+GIWkBOFfElFHMQ3uQv9mdh2fpPki oMiXmY1inZnToJgsVf3CifLRqYwbO5oUSC8eW+zr8v5RXeDwqQDzLXJRcTA7 yLWY9DZZZoCpPkmTiO+AUM3SMlczR2diroSMaW2yF3VgjS+Ff/65rEF9Kip8 tUz75MNl6ovBV1MG5CPlEZqRq5ETJeFJfMVYnXgMi9LGFdMUWiM1mGguJlba 5ORFA9cg9qfsVuCqhwRqJ0WGWqDBlyQwYtHquEmp0XNpC3nZTKS8i27LJiSq IPgRQDQziYKcI63wx5WrfpeKzdicWssKhSs+QT4gpIYrabwGDqcJT2+9rSiK QR8s4uwS5m58/UjCtVtNBt9kNHB9dLqNFKJmEBdJuQ/xIXZBjuEEq3CNSq94 /uwURhwjHKZpSlSVY3garq4jMLH34UOtcQwQvBwGotdjog1g2kPzgT640L7D 6D7f+6cpitWYxboUMlJFMsFxsQ3AaA3SBy+AkCqLWKMQT//aggAgdQ0DBNBe ixB9Vh8w4e6VmNfFKAl/9kXT9kkHAmdHMRPxn8Y1XnaUXLxpo/MxnxcGSkFm oo0lGjMNYCN5tJHq3r0yEglGRom4AsLNFlPt5YIggZDKHa2feKosH6ONcfNI gBo5Ok2Cn51ZOmPB6NKiO3tBl2WhlM7AJypakZ2PfhGL/5wdBK2AeKQpqY3k Lw9REIzvh1BNUJ8UtZZPW8ThA/4qkohhXcbjpY+SUgL5rMK5PE6rsal1BLL7 MiBdBrM1OfRhufrtUkzXwujF+t4oBo3vLwI1NLAQfLEhTAVys0a/9DIrLS8e Kq0g8DRMvRTAS3MUGfXNJ5CzPJvebFXxuxh/AakXfzXYqpGD0+nnMk8SwGJ/ GtlXczlV6DPQCVOzNcU/V6Nxnbazmdj7pvAU+mYIHGMIDgHuCye3JHfcWLEp 5BOyxNtk2gLvB4dkiYMQkPgzk+NCU0c+dxQzAYEfPaMuAmguX7mjn37tHpW2 +bRGoOqD5dbVVpkX19tEz+s/ZEXbNqRqUG8DyYrU1ABfkkkB21BPqylGGRTF 18PyRGIIFGa+n6VxXPUySuoA87PDfR0HJc48l/ITEWrfTztXwePNEhH47lcf x3zrlTxuSd1y33gM+dQeGJfwy62z1NfU9hON8tPowPdxUhlXxuGs4MrvveNw oHzNmw5MVOnpZJc422yBIGax+/Ian5K6bExZWRHnLdedN6wwkAqPucYUkG8K 6a2XRqnx9AYDYR8YURNvel4urS1pir03LyDs20nGlnr6mFXJRRv5vbTfj+J7 2viUCWPH15f6cRecSCTNNEg+SYE8Q5cgNGW4xkgyP1M/2lE3mp6AX2tET2Xo VTgmu0w8rZ5UbYVWdKI9SQkghYntGurTRFcQrMw05x8CQXAYuf1/5t/nTb/4 d1kn9A6HzVxZ7+BrgXKZuleYopRDLLcpcw0G9MUWjNl0GG78CLF+H+xbWuoI vqdQRCvW/aQL9k2k61OvEsei+6etRhN4quGKpsDUStSrrvGhRJRg/yAC02rz HWf7X+fbLwh/WtQzcw26NTRgPpOqJnVufxY8Du8nIN8s4ys1Nv8vzNd9cQAe HykXXmH5twA4al4U11pvsZu0vYGMk2eqtZMNAlROk95QzXPrVW+ow0Q5qYpL 5FWdSrvJUW/lsAyalh08bnWdRfS4AXH5npPsfsy11nqHH+plxPVB7RN3lr62 Hl0bbW/YRtqVmdPzpucqBXk+wqgDV3rFo+GrqM6g7YxkLx8Aq5jkGdmmOawS dbjJrTP2GQV4RgJQ77zyevdZmng56FtqyMCEHIR8eUncS60mDF/UbdYuDsxO Kc4V+hvpjF+uoqRNYMq4sUyZkI73sWSGkyljx/PzP8r4tLH8qZSKea8ddcCG fFFhhvtrZ1RAHFLv6PVV881fpfkJqV7fuPCeNoav8lVSlym+l03LUxJpuWZC UlSv37eI39P4KViTbyo7Rt0aoZUyqR9YIldR+4+lKHNqRxtIu6S4qKg33Lzb Zk0T9YnHU2EFfOD55Jl5mloHFYto9Py7SGekSTWmkTb/OC/TJdKRD77PTEp1 ShqVAfw4KgN4lAaRzePeAl8s9hJpjOwzfvvbuAobMm4dWhqNLUlB44xLmcgH wltSMvhzXFrKOHqZMDaFj5BpcqCcLddtp+cKfYFibp4kihXNFUJAfmlZkZKW Mp6PqfQ+LmWc732sCB9hHDPCd/6Pj/Nz1LU90W3KOl3MNe0wDORx9Uaf7rjX c6xT2q3aL+1WHfJ6vl6I50JpE4vsYTnIHpa5xsjgOamjFfNYgyquYdJoRZ9I GWulzwUpqclKShr82DuVBcOpz6urXILc7eqcITgMc00N+b751NQZzVUrlERq EaPNtQYb16lCq+RF3W/e6jRBCyRZNCsfEG0FMtfWkFeCJFMSaYPOofcnQNb/ Xr68PVJXvdRksvaqt+aa5eR75yum4IlVZouFqOyXv2KnYQHfMQjIOQAEMxts Btp8Fk+K6JP+VTmfz/X7zYtnIvOgPX3IMoqYABm0OnVmstxjUp9yPlwptkPM dq5wJtVD6WRm73mLf53psqIys6Wuzqo+Rb2BsFtLhPOQOr+MD3FIdLL/Xl0l MMm+iZeeb4fRpq8fDbPdyPUYxNO/zCVln17Sd+CeLuHSa23sUolEj5O4zD/n k2aXxqempIznffloi4NlAfboxQ42hZ6mu9nkyXjWmtgwPLOm0DcTm0JhFhPL mkx6BdyuINkS3CltCO4TdgO5DcAyac+vQdrw26LqKdRBUNXTUqc4jtBr3qzq lGgmSHItV2zoS9t5n0m/Q3r+bqYD8lSu9Iz0bWw6bPWmMVV6krE4Xxwmso1E dVEvdGcXpFSiLJfDW+DtKNNRd3IGpSlZddYpvp9j5Z6RfREG0jqx77Pc7IBk 5lP0JZ06ruQr1Jl4HZpOGu2qQgDS0J7uCj79Lx1dgvEBo5kRbOEbBOpeEd9P 4gKaKDuNpvDl51ua64fXJyd9pW8xnXTcxJFEnwqRJkPSBqSjRf19LKtzYMwo 9c3CfR/lCV4+qxdrFwG6pl7PqTZpZ1D1bX7fnaF67T4dva8I5KPYJlMSV9Ap 9pokP5Fgi4oMqY9xDomCCJp+Ke3MOS43/bT+UmlYy/pnUAPxx8eeEfNp3T1K 1C9Jp132JQDpKz9+pId3ccIuBJehkNMCvs6FqsvrhOLviC6ZWCgxyJ3WkbTT yuuQr2qNpDeuDEnAKtWnH7zkXnDgkjvcvkDSJfC8KKDLxJLXj8vFTdQXH27a NTW+vkcLfqzvel/gWp88ds5oT5K+U/mJQkefT01ghH0ERGwIp0KXRC91WMhV 6y1Vy+u4iRCmPgmOdgM5USyjJSnDJiv9fYvSwOrzPV2kvdj3KJl/n2984xGJ +/0Yxe4w2erUg+dTp06V80wrP8jCd6SkQoKqezCN9hp8ior+Td8rivlhqlpp /pAruIhTUCPSxtojfI7xeR0fW/EN/dcsk7Tco+4Sz8+UGpwcUrJiarDK7Sy1 D6X10ouvw/p1dCDKMinK+gUljQyqGT/u9EkOQeWCvmkhvjIpvvaVH/uRXYPl 9+/KrRBbWW1/+QaRWy8/z/5lVoisTIqs/QqcQXkZTF4V6XwbegYr+QDYBlTC QJj2unobpjak4GFyBEinqLIqQEONlXwgvGAyg8Azjf8d20fe5dvp/rOJUpxm UpzuV55WSRdaPeIE1UWlaGWBXb/Mp01xJ2VWKbZC+VMrLtL+uMm/Iy861aiA vdreX3kr8XOBlpDsURwu2dMU6frCDJaKOoWRQp9HiuFMiuGXJYcHrR9Ck3xR XdUi2d40YjiHEkQAl/kuV5+98xe1qx8sLg8HLsLScUkO63IwqpHyK38KlvLD QHQKQ6Ewqstiy24BbcQtsIr+8k7f8RRNfI2qlUyKPsxAPmg/xpdbzYZ++xdZ Efl6ZiLp5V8CSM1yA/lgbd0X6SJtvZ98egMozr/dp4ur6urxtRGEg02Oers/ mMIK8pQ0bUQZNlYbRjpStabFdQ6z1C0zQmpwmO2iA/VHDIyHdu6opVMMlWYL Ri2TJmufHi0VPm1ZcBmBrxPaTRaxWc5yxsyWO+uMWWlFfrSRH2M32+topZpg iCnBmNnMWI9ChkBiqLNYxOImrzBqcpaoGjdMYiwtNXVaTun00WXpCv+q/sbw WlVvsSgCVp9vJCoEfFNm0fRCCZrO9y1IOpn/2P7zw7c+6UwNDlRxYhEvSDZr Bs1q9DW0Q0yaQOr5AuKban2Q+IqRro7UiulUD/2m75ItjJ/al/CW6Ctp3VYc 4MU3X34GvdVXhgifU16g0BIp5VWjWWvmBS4bPR/btN9sZJHL/62WjJpZua4b x0QtHvqmt6+oqTE5SOvYSmaTKYy/+IvTz6f5F+HhfPW3+Bm8nHzf+G+yJEfr K3WEh4Hm5haTEXP8QJxUBmp/+OtKn2z8+fT95P8mf4+oTxGLE5BCqxsCd8fQ 9EeT8t/o0WItWcTKlHGRVpx9wURqfD3FHsF1NkeMreeSOp6j4RlkUvUdUXk8 Hlu0vjqaz/KEBdOnT1cyUumS0ILSopzZo9MmlDFt+DimgSOzDABCJPtx8EeT XOCRqLKLcuXxklW8KkfUS8R6dw48FW9inO/k+ZkTYz3p8JuUWQUFgF9j9R0+ ryNFOrH8YxdTDn6CBgI8RVU7Jnuykjp6fEpUEL0FdeWKb6ARAOoqqYeezE/4 A8JkubFPhjgDdB3qLp6C61FwGbzvZz5mTlb7cLGVn6lQGxST5nTI8rMwW7PI 32Pxu8S0TPNrxDgjiSVlyVI5d0befJYPX2M2k5fjEbGh3kGtXCPOMHGOok8V lCM3P14WeGojimDKdFl4kkrulF7paJw31NtoY0K1t0FphAadkkU8mBKYlzqc EprECIrMUwktbDVVFtg2xZ9KfFTTyDg+HXYemQMRg2hvIFnE+Ck+sfrSQHh9 6w8T9M4Ox4rRQpDsFSURNY5Xz6QovpIktSHxjZvLIFMZJGOhappSFqcoY0ff ElA/zba7uRKifAZVDxSn+QpKbkMCuwWzEBpv6SmYy7dkTcK4gVQmtNfVmPxn S1T1omAxZytiS8euJM4mpZdFRpPBXKO3LFKGDRuWJOxDUX78GTlaewqbzg/U mhyYSC+V5lhIhbh4DDeZRdpKdRjQuYxLSxc5qurwAtXkFNUtLteTPrd6DlZ9 v0ROffKw6W0+GOr7JWCQqaE+yBqrDVyGp2ckCdDL6paaFK31I/QHdZUOvblW KSgewzPA0KmvQdnweWiVnfylOEXGaLToB/KIVOAVuUKfGcgwY10Nssez1s4N qWjtDqr68mRfxypMafXSrVdtrWjtGWrXI7V1U3u2fgWkh7769r003nsbY6Dx lXe53HzLJIVTJIyKkX6w3mJeRrVTE6wG8XRq+sjR3BiPMCc4PTd/zqKS6beV Ty8to3JQeUpAokT8HM38nNu5E6YyWClZ2BO4ZPpwIUQQ21rHrf3wNKQDrTHG 5zcOhK+1DquP1Zr3XnYB7bXibAI9CfcVtYZqW10tLZaSeR1NTcC8q1dGd8o1 NLqee8B8xnS7GIusYOzHbRhh3IzRccsH4Q8jyruMhTdf1P5KlDJqlCIX8qKm a6xR2fmZW751Kg4dRPls+ao2qIS9BVpeFL0nQZfr9D51eT9AildlqcO0h2OB TsYkF4vtDiNVUwlPfFCBaW2JIt9L2gJVw/6HexTT1MgyZh+7p8CVTCLS02Sz aWk1y6svSNcAAjHKauRkfmp8md7GjSBxi1QqXdr2Iy2VkukLsTeUiXqoX0at QlsihL/d12ao9wd7te/qmKDlupq5PXCdQ+6E1XEl0X6SqIAF5pR1HwhcSSdI YmUkpRG2BFDnOabiqQoH/WGJ9kO5Cej+PPtLIjPiyyu+NCOjZF70zT+qUb26 BLK0mETIyidlTMtLQZGlPK2QJ0lGoBYDaZifgEG/yekVT3mmsx8QwtIYNYAo QfeCGtRLgEHnTk1QXeHoD4JKvh8Ot/CkjKTEI3lltCdFSUw03Lh8eNrEvFf4 v8ZIQ7IGvCoLjpQfR5LdH76rjMZ7ibwvnjWz1deSV8XH+lr/Ih1S6GuDgkbl wKuyQGNhglJy5WJNanHWoW9y0oBE/eQ2gkrpNBKRQua71UPMkLMq64X2Js0I Unx/FGELYQZf1/enUHrHImMG0+rteaZlM4iyudyOZQEJzUKjUvOq5Fr0dlXj s7S+cjT/jfSL/jcO6Wm+Oa3eTKfUTFVkIJ6wxTRlbEoqneHnQ7Bct7LQCsEs QkO2Gu2HUrGaR2xN0YZPs5kxTZf0M2l3p8ZkxFjpD1NXXf3ZsDx1lU4TKFV+ iOW94hbb6kiFkl9uUMD1+XygWV6dMIdCSym0LpJXZxIjRJU0YmYgRiJeaTGd KzdZLHzVTgue5dpWWB1ky8FaDfnID5vbYLCYF5vE+XZfCr5nJE9hk11wazVd E8EYZKgUsjCncM1v9XXE6LHjuEJ6Ck05FdWcaUGenP/3diIhxZNV6pLx1Im2 b2I0OXi8gFXIAKj+eD6l+KA5++ngjOXXXwRDUMTjljak/pm9vvIiafxwrcKs Bj9zavZpnk/uE8/Aze/zzdN+86d4qrV4rr3bJ6Y/njT9wjX0L0b3tAIIsMGK JCAe35HwnSYNRi+ZP1EPvqlmIgLSpfWXLiDe2MuMN+4y46VfZrzx/ccjJUq6 NSe3ANOlOl6Smsj+eFQvZGMK0jQ09dcfL0jN9MczNVj1tbwC08HtXthO1ubr v3MsWB3yl6M/HuYoQfMV8Uix+lYb7VT2115lPAx+RbJOXrR9aRZ/L1ZvxRoA aRbIFt5P+5cHGnj3KtaDtTH98HJlufWNE5BvPWYoRn54PAjMvvC07dAWpD2r 8XzHKFFwqb3iZQSLZzGTSkeqNt+g8Ti8tMuFl9Y/vII5gbj15nNgPFL0741f n3gBNFwiXi+A/eeb9u/gl3YZ+KX9O/il9cGvUkgK6iZZkHrla+cXGSJ7xbvI EOmPV5zLUVTSJpCyeP/9gb8dBWshwdpbsBrtj6fyN/hQ0Sue4FvQiJp+Q1OP g/cb6dp4/cDU9gemKhNNxoMC7j9eb8CXgFfPDwL14nNweGpEfzyVf+JL2gRx xq1vvj7+BY2oxruUPpWqh6NdA/B6f7zO6/3JAb//8Y7ev3nYur7xgnkebx98 t8ZvD/hNvhPxY4OEB/ifpFsNZrIFy+lUNwXoOI04cESCfu8Dk6VWPbewvQAV HFNZsivs26yvrrNxZQx+YYBFGoYKMhcaiT8joyhXKS9VphhTqvxQlqvhvZLz ZCniPaWqvpZvJQkwck7Za/+dw9RYrAiqv6RORimX3urGdqJTScydcWsSz4L2 PIPAD9AcCqoyBBi+eARKxLoksP6UngLB8TW6/qFJS0YCptSfqOsFhEWJy7p8 +2iTlFml4n4sfCuvNZPFDH73qyrE5PomMnSCxR5VbzbYuWIvf7GLF5MaYlBf rOqLQ32p4cnwskwNWWawRQmTYZf3h+v7yslhItcbT+pdY6MqTXabnqDTi10v Xyp9IZX8RS8Uk2sMdVZHGl5sDqmpbEW3IHQpG/h8vaYy1VDFo1amqS9j1Zdx 4sVudNgIiGIyGEQIXsA7WquLypuVo+RW62trTRZ7lLFGLzhHL4sN4kVvDOQB xTPYFqXyzwaHfDHq5Yvd91K5KLVf9kkgaSqQNBVImgokTQWS1j8Q2hvhcMaq cMaqcMaqcMaqcMZeCplxKpBxKpBxKpBxKpBxF0MmanqDvIkN8kOUVS1IKxVt qvpCZWGyGjj/rSg/GSVVbxUvaWpImhoyVg0Zq4aMU0PG6a0CTroakq7GGS9C Kq3j1ZAJapwJasgtasgtAk4Uv0ea7wHKp28h1jfNDrRBIu00Ubuk9Qr59KWr qas10w6+DOdxhYa/eIq+gL9x0/HoD6TpvShGFoLt/qWwYJEmKQsNPp0VWikx LRdK25e0Gd/XfB3fg1SHClqw7gXBLu72GU3mmAiAf7+aL5ZTEJNPga7UB6zl szEKFntrKkJa091imEFC7U5rIqEzUkYfmRQl0bYKC6sauPJOOJOP1yrGKVFR 8wKJTFYgWUgYejlM1pOMoMg1UJ/xGA2Usjq+Gmo0OcRtbH1wrdKYBfIvVa6o q+emlrn5Gw3XFbI2StqLtH6n8oMWVe29rJFzvk4lL2Wk0bQtpxflpBr+L6jl RlvpnJ1Zs5Rm9xcPv2qAzakX97chHvjRf8TpNpsaT2g99wOPqr26pxS4XyP2 sPhek7AqZaZzk7Tt5uArPKKGScDDorT3i4BGuvwqtyQ3We7OSivK2gVfqolc 95sJe0sUTdUFJ9zm+bVFtCriPh3xcmFlhq5CoH0HQopU4FTjIyBa3JRFaXrj xvfy6fCYxVRj993Q4FNp0eA4STVlTso29VyCI/WdFYS7MO5rAA8XjDDeqcwo mD9reqZiM0xWbQLwPTqffGD1GUwSJph8NpNuNdXSQqUMLtass/HtMg5LfKNi ENajKFDeYaLVqpmh2jEu/XcNSTG/LVxujx5MVIGp4XPlhU/+L7w+2s1Gk0br xf+txmy2Vq9YpHa5PstiAfexiHYgjnn1TUMXVdbXmu+uVxezFd+VXxSf7EzU Y9Iivglze3QtrjYy1XSu/yStqFIl4v2onF/k9lK9yfTBJu0WaaaTls4V9b4Y rjsqznCTUCp2wDUW+dJSK8vU9DmzLysqjyv1v4LH1Gg/amD/O0kwb0pP9nrH 74LfC/8hPOZN4zvlswv+vNc7QYd4rdJb4LMQ7ha/+TNLhrcS/xpWrJzFD8hw HTw6JZOsjDAmls7JTxpDz7L5/JmbMztJgfi/1ERd9whih4NsZIt2UpLLckk/ 3ddmVNsMYqN6mrwyB3WAThz77lNGujE+1XYZqp4NrEITIpWHXLJVYbFwRcrp wjARh1qmlii1lTqbDXMCSQivob7avMLk8NV/NWOvdxp4NC0aHvPBafHwCfDg 7bR0rzeni7GYYcq0VEN2c/HTFX+0/ldTxMakbTNfXPrOho9+e/g/T5/6cdqA mLH2n5WUvDJts+2/Kz/dNHFN3Murnrrjb2/+YetZ75EvEirTc3VKbJjxa8ef 8raX3fv0klcK7038deSxk//863s7P7l/QulNtmuuGpS67O9V/5r76xm7X13w m5UPXfvzjP/+8r88f3/sT3vz980/Vr224TcR2XH6xAEZwz/48OCJb3753e/W 5z9sfjbqtZvv+OfMAytfXfLgdXdHFWeOG/Xjjgt/7vzh7W8ff3TFffPfmPT8 dZZnnD8vOrrwveSfZYVHV8TnnHjhwq/+0vX5X3476s0h91c/VnDPQ7W/v+uT 2eem/CRl7I23/cjqfeLUW19+/teet6//XeYTt/+qYeO6pmdf/I9t334U/c7o 07MP18W42bbUd5UjxbrsEdYZFYvXvLZpy1M/vNz+h8l/iz/SePauAS/+uOVn Z8d+PG18SWzlctvcV/7x9J9/vePe9f+sPTbnk+T3rkj/KuEPsa26JkeV8day hLyBv+l49fufP/zQnv9a9N/3/OmGv2fd9LcJZwZtvGZX1bxly2ZcPTf9YNEH Nd/96JsxD7+//pvXfvHs8/Pz8k0Ng6pHxrVFHM5YnfjUn10dC7+d+sON9333 6GfPv/HGIzPr7yhbcsvKa6JOX7d/1MuZD1xIOXHl55a/zHrzud/e99jx+z9w 3mQZvNBYND3ryeQ18Yei3zk11Dvlr3d+6fzdo2+//quDT5yv/ek9E2aX3+VI 2TTlpR99dGN3FAmTUbSGYZhG+p4jxlq4Hm/KCPEM6E99v3Pp1G2ZsLGnSEPu dDSskKwYUKMp9ZkLpO+iB/efAvXbZ5rOWMkcRdh9mk8Hy3z23xltkJK4Rnjk zBo7cUZqeqqSOD5trFJYaXYkU1fLb0lRbSQCCT6AUtyiuempqdOUxHRlFo9b Wedw1NUIxSWKTxF98cr88eieIl+kOpsGXgaHl3FJeGkTKF7ahP4j+uKVaeIF ydiXb5k/3/7xGzeW8h03tv98S0vLxk0smjFm7gzA9IPsj42S52kT8jRo9hcZ UecBg7wygYJAVIPjrPkcwzINhr1iCBpSx43LDYgRQKyfBvDvMvDy8SYw5wC4 M8pnFpSVlsu6lsefyEs8y2bx56yc3JI5swu4LZdL2Z3U3tlGN1j7rMOR0TmS iqLU8UOYKlSBcDlNbCCO1h68Ha3IHKPo3X+hoVEjqqlZLDdjKiFvauPQjUJ+ VqQwSjaAe+FcJ01qppKpaJKZ1TPPDfLM86xpUjmN6eDdjIUx8fS5NhkWGF6c W0CyPS3u55mWUTdSYKQ3/BXqCgXyQkLp5F146pVUUrVO4D8DshKPM3t6mSIM 05hJs0Kc1uCDupQxMFOtVa02MpafUzSD0s3TC9mTZDiuzl3PdQj9h174HNd/ 9kLll1JWMGv6nPIyBWhEFQtJXAhbHNx01Asxj8ELsBFzmDqDoR6CeApNBApK SzgjIdqIi4gylRJx061SyS3D2LmVWhLWCZDValiU3tCwiN9lyXr9XuSf2Pgu Z/SJqJhiLqNn9XJhboDopDSqYsm/A6tXOtJlq17BtZpHqKdJ04WcxqU5QXGV VHxWr7KNoT9hK0tYmDMn7PpoXj3i4eO8XiPkDpbAK5PuRwo9oq/KacSDbAZl 4Hs3PuyT37P544kwesQ8PmBLBL0kPha+VffowEcGPTz4ocgHoyDn/P+p8+xj Xs9nzd6eMAbf6e1RWrw9wxB2Fjg/VsSfngkfwh+HPwTf5fXckgpvhXfCb4ff B9/p9WQkwlfDN8PHIAxpMpA+Yws84mQg/UT6vRPPOPg8r+fcOjwXwiPNxD3w B+DPAacNHC9PZwv8Vvgd8K3w++GRZye+dwJu52avJzPa6zmzXfhvu72eKdHe nuUJeCLOlAb4Cvh8eOA9BXCmgJ4pwGVqvNfzOfDoRJ5TgdfUbHjgPxV5fm6E pzj0bbfX8wVw/ALvX5Z5Pf+KwBO8+bLY27O4Af59waezCD+rgwc+U897Pdmx 8MmIBxyyQVs24OWALzmIlwM4Z/E+7TN44D0N33LxOxc45QLPXPA3F+lywZ88 8CsP/JuO8DzwJg88yAO/88Df6aAzD/TlWeCBdx54Nh24TAdd04FHHvLNBR9y wbs85JkL2vOK8QSMXIKVDh/j7XlgPuJnwbvhgfsMSg96pwO36eDFDOQ9Azyc AbxmAKdDiHcI5X8I+c1ogwd+MwB7BuiZAVoOAfcZR+FRXw6tE3VpBvKbAdhn YwW/uhaKMusCXreCJ7eC/lvx7Vbw4FbQ1YXyuDXV6716L57A7VbUl7PA6xB+ d4GvXYh/lsKongLHbwH72x7EA45nAfss8DtL6VB/DgPWYYqL59kKrzd+FeA6 vd5rFuA3aD+Lcr8V5XgraL4VvO1C/rcC/66b8AQNZ4FjPuDmEwzgfBZlkg9+ nwWd+cjjLOr+WeB0Fny6FXjkg4Z8RdCQj/B8hOcD73zkkQ8+dSnent+SR9md JVpB11mkOYuyOYuyPItyyT/g7XkpGd6B30QTngXIq4Dig18FoD8fdSAf+RWA 72czvJ6ZgFEAHhSg3AsAqwBtpAA4FoDGmSi/mYAxE2U3c53g4VnUi5moHzPR jmaCT2fpHfV9JsLP4vfMfYL2s0hztlnkexZxzwJuIfAoBI1nwYeZn3l73nUL eoknhXGCp4XAtxDpC/F+FnkWIk7hDlGmKDfvIMApAm5FwKsQPC1EXSo8IMqR yrMQvC9Cnl1oV0WAVQRYRYBdlOrteRv16ewOWf5lgkfAj8MuAv5FO0VZFR31 9vwJabtQBrOie9Wdnv/c7K83XaiTs0DPIdTfWYhzmOooyqELfJ2F+jULOM6i d8CcjXKcfVzQOBt4zN4Ff178nqMT9WNOhLdnP8phTmqf+tqzH3DOgs9nkW4O wuaAhjmoC8XAcw7Kvxhp5oCeYtSrOajHc8D7ORQX/Dicz+uPpxi8Lsb74WJZ llRW1BeBh2c/FGV1mHj8PjzxCfX6LOrJYeIV8DoLPhcj32LgXGzxl12xVdBR jHyLgWMx+oqz4Gkx0hZv8fb8F8q9+DznuXcw8CtRNOUJntyGNnwb6LsNPLsN 8G7b6i/P2wDvtv2iPEuA320om/+i/PZLGg6Jeky4l+QJPLooD/S1XVvhAb8E eB1GnSlB+yzZKeIcRt06jLp09jhvSz3/pLYJ2P8kXyRhE84YH86ivA5v8Hqv BNxS4FqKNlMKmg6jLhxGulK0ufPd3p7vdfBW+OPenh/Av8OgoxTlchh1qxR5 lqJMSgG7FOlKUTalGD8Z6CoFDaXAoxT5lILuw7u83tXAuQz16SvE+wo8+Ar8 78ryetegD1qDsipD3SgDLmWgvQz4fAV+loHGMvCvDHHLWrwXxqLelQGHMpRj GWgpB87l8V7vQ0hfDvrKUVfLkaYcacqBXznqRjn4Mhfx5gLvuYA9Fzydi/oy F/3jXMSZizo9F21yLtr9XPBvLvKYC/zmIv+5gDsXdMxFXvOQdh7SzrOI/OYX i/oyH/nNR37zkf520H076L2dwgFnPtLejnK9HbDmo27ejrK6HbjcjvxuBy9u R32/HfXudpT/7cDjdsC/A+1zAXBdgHawAHV5AWhYAD4vQNoFyGsB8l6I9r8Q 5bQQeC6k30e93i3I8y7w7y6E3YWwRYC/CL8XgSeLgPsi0LoIeC5CWenBXz3w 0INneqTTI189ylGPuHq0jUUo3wrgVIH4esCoQNlVgI8VyLMCPKoAbRXApwLl UoG2VgE8K9A2KkBvBXhQgXKvAB/0gLOI4hEM1LUK4FGBvCrA+wrKD/EXUXzU mUWol4vAp0XgVyV4UJnovZCxHx5wKoFLJfhdCdwr6TvabSXSdQFGJb5/DRq+ xrsBdciAcjAgngFt4yvgZgBeBuBrAM+NSGdEOiPyMvaIOmkCn0zgx2KkXQz+ LkaZLAavFheJ8q3Gt2rgXI1yMoN2M/hjBv7V4E01ysWMsjCDNjN4ZwaOZqQx o8yqkUc1+FWN8qgGDmY8zXguQdkuQdteEiPKbCnyXwo+LUVZLEW5LQUOFsBb Cros9A6eWUCTBfXBgv7EAlos4KkFtFlATw14VQPaaoB/DWDXgNc1wKUGdNQA v7OAcw55nAOPv0K7sYHHNsS3oR3ZAMsGWDbgZkNZ2lCONvDNjrh29K/ngOc5 wD8H2HbgZAdP7OCFHbjYkZc9Q/DQDn7ZAdOFOmxHPbGDTjvydaCOOZDGBd65 gLsDTwf45gAfXeChAzg4gI8DZVKPvOqRhwtwXaDZhXxc4KcLcepBTz3i14Me F/jtonjArx7416Nd1QNnJ/jtRDt1gVYXYLmAswt9TT2Fg69O9F/LwJtlgOkE v1ei7q2kdIDpBO7LUMeWod44ySNPJ8rOCb47Qc8y8McJOpeB38tQt52Iu4ri oC44gasTdcQJnq3Ct1Won6vA0+XAYRXSL8e35YizHHGXUzrwYBVwWAWaVgHH 5RQHfG9A+gbUhwbk0wD8GkBXA3BcAf6vIligayXoW4k8VoKmlRgHV6DOrACc FSjrFYCzAmW4AjStBKyVSLcSvFyJvFaC5yuJZtSZJuDWBNhfgedNqA9NgLca sFeDn6sR5wjq7mrEWY3va4DzGp1oB2tQlmtQvmuQZg196/Je+DPiNoOnzUjb jDJpRj1oBp+bwYNm4HoOZX8u3eu9KhE+Ce+Ifw7xz4Ef56h+Ic05lOc58Ogc 4J/L8l5YCXrO5XkvrAJN50DfOdBwrgA+G+1lKnyyaDfNPd4Lq1EPzwHHc9QX o76sRd5HkOda8HAtynUteLIW5bkWZbUWdWUtyvHn+PZzpPs56FoLPq5F/VuL uroW/FwLvqxFWfyc4tETtP4c/Pw5vq8DrusIN9TDc2iX66pF3V+H8jyC/L9G GW0EvAdAywPA5QHg8QDiPwD8HwDsB4DnJtC8CXQ+QPFQFg8A9gPI5wHAeQB4 PgD+0zzkHOrJOfD6HPh5DvDPES/QfjYjn82Asxl5bUKd3QS4mwBjE/DdBF5t Ql6bUOc3Ie2DsULm2LJFyB1bWoRct6VZyHVbGoTcuMUqZMctRiH/bQF9h4Db FgrbzsueyzZbAHcLPYHvlg+FnL4F8B8GTQ9/KGSWh9HuH0a8h51CZnmYZGzE ewR5PYJ8HwHsR1FHHwHcR1DHHgHejwDGoyi3R5HuUZTJo6gPj4CORxH/UaR9 FPx6FPXmEeTxKGA+mirq46NZAq9HwctHZV9O86itaFNbUW5PgDetKIdWwGlF W2gFnq3AvRX1vRV82AZctqF8tgH2NuSxDXGeRN7bUA7bgN824L4NvHkSPNmG +rwNbXEbcNgGnFtRT54EHk8ivyeR75OI/yS+PQnYT6H8nwJfn0IZPIV69xTi PgVctqM8tqPebUf4doRvR/h2hD+N8KcR/jT4/zTq69OA/zTwfwa8eAZl+gzy eAawn0Xc3wD2c4j/HOI/h/jPIN/nkOY5pHkOaZ5HmueR5nmkeR54PY/vzwKX Z/D+DHD7DfjxG9Sn34DG34B3v0Hd2QG6d4APO8CPHeDVDpTLDvRzO1Auz4Iv zwLfZ4Hvs4Qv8nweuDyP789Tfkj/PPB6vlvwfyd4tRNl9jzyegF5v4B69Duk +R34/jvwcBfKZhfSvoj6/CLq44uoLy+hXF4qE3IjnwsDj5eB50tdfFy/8CH4 /DXq1tdZYrzfjfS7kfcr9A4cX0G6V4DnK8lCBnil2tszpsfbk9oAv8/bk5Yg 0vFvND9C+/p6Pq+XF/5GYWgf/wBf/6GI8H8g/j9Qz36PNvYK8nrluEjze9D2 +3TvhYPnvRfaIRdnLPT2TEZ/9fwG74UX5nt7nsn39jTs8vZsX+ftGR0Pj/eH d3t7tkjZ7FXA+z348nvU9VdRZq8in1eBz6sEG7z5Pfjxe9S5c2gr59C2XwWN ryLuHpTPHuC2B2W0B3zZA5z3gMd70DfsQbw9FAd4vgY+vAY+vYa5/VXUZvPh C/Ceh+dM+EJ4lOVryOM15PcapQEeryGf1wHvdcB+HelfBx9fBz9eB76voW29 DhxfRz6vo2/a2yrKaS/a6l60473I+22U4duof2+jfrxNv1Gv3kYd2YuyfxNt 603k+Sbqz5v4/hbK8C18fxNl+xbq8VuoG28D9tvg91vA5W3g8Rb4/Tby3gsc 96J+vYn83gT/3gQP3kT6N8G3N4Hnm0jzJnjyNvq2NuTThnhtwLsNdb9tg+B5 G+p5G3BpA61toLMNsNtQBu+gLL9F/leB1/8Afu8A1juoZ+8gz3eAxzvA9R3g +Q7awzvg9ztlfK3Ecz148w5wfxf1+F2U17vg2bvA4SeA8WPw41rgciPSfos4 55B2OOgYjvzeRX/zLtrACNTtEYh3E/qZm8DXm5DfyHR1bV2s93G/QfrN0m+V frv0O6XfLf1e6fdJ/6H0B6TvlP6o9F3Sn5O+R/iDOumjpY+VPl76BOmTpU+X Pkv6POmLpC+TfqH0Rukt0jukd0rfLP0G6TdLv1X67dLvlH639Hul3yf9h9If kL5T+qPSd0l/Tvoe4dGuhY+WPlb6eOkTpE+WPl36LOnzpC+Svkz6hdIbpbdI 75DeKX2z9Buk3yz9Vum3S79T+t3S75V+n/QfSn9A+k7pj0rfJf056XuE79BJ Hy19rPTx0idInyx9uvRZ0udJXyR9mfQLpTdKb5HeIb1T+mbpN0i/Wfqt0m+X fqf0u6XfK/0+6T+U/oD0ndIflb5L+nPS9wjfqZM+WvpY6eOlT5A+Wfp06bOk z5O+SPoy6RdKb5TeIr1Deid5NkCz0TaA8T0T9j93tKETDj8Y/kr4oUyoDtI+ DuCGwYfDD4a/En4o/FT4Ri/lLPeHroL/sYQXIWFFwg9iQg1gIPwQJrYdo2V+ Vwjs2Y8kDlfKcJ2MP0jCiZCwoiSMK2RcyvMn8D+Fv17iPRz+Zvhx8JPg+ZXn 8AYmzN+ugX8K/g/wR5CtlpOXwyetHxDgwwO8LsAPDPDk2qQP08BQ46o8vELS ei38MPg0+Bx4uh6+Cf4dJEf6MLwPwDMcXgc/CD4CnjbsYuDj4BX4VPhs+Arf Pm8QGgNpCqRhEPOXj1pGajmpZaWWF/lo6a+QXroBP/Z6slHfsyGjZKOeZ2Oc zYbckY22nL2Dwn3GdRPJRfRxrTG9nc7nZEAOd2FBnPg+jbsBQRx9jbhUpQjM P9AFy5jyls9g+fK81RevZ8YubX7eHsw5e8a3QX486r1w4H1vz+Pd3p6Und4L /9npvXAhy9uzPsPbsy7W24N5Tc8T1ZfC//+XTvZb1G7j5fPGgGewsJD7N5w6 Nng9BowvBswhDGhvBowtBrQ3A8YUAx15g5zaRE/UtyanfLoZdfyepmb5XCfg NG2QzxZGg4OnabN8bpHPrXgOxLNVPrfjibGyaQcTfYiv3/F6fplMv/DM4+OY 55fzqbfB00Ix8XRTb4PnDvT4V8q4BzBi/Ei+d6I3GUS9IN6Po4eJluHn0esM Ee+/0jEy6SXeY9A7Rcr3OPRYEfI9Ab3YYPmezHu4qfw9z5/vr4r9+f6qAvle Id+d/nx/tUWT725Nvvs1+Xb5822J0OSbB0oGyfA44DBQvqeCFzr5ng3+hMv3 YvBsgHxfiGeYfBdtXrw30EhJNQDvLXiPEnThPRIwxftW3sNfyd/3+Olt0fC5 5aifXuDgoxfhPnpbuv30btRp6C3207sx1k/vxlQ/vRuz/fRuXMhryVD+bgmO z8aG4PiAhz58NjZr8NnaDz47+sFnnwafQ1p8vJ4jbhrZ8DxPko/Xc3SPiHd0 n6i7R6ke4nmsgY94wdqk5xXMX19BW3ylgtTXDDXGyWSrptbkWER25yiM2/ib PN5nX2tyWtr4sampmns+Jqcxq81EcSfTz0n8iA9Xo/8ZAeMKaATuZ6QOVcOt JNv41eN004WwncBvHpg9o5SnJZNyRtOyySZHdarP1Nzk5XpLbb1DNSk2efzY TPxPTc1MG5s5Lj1z/AQykkfniiZLg07qHfU8r8ljAHAMYii25QoePCxhlWpw zZWZsEq1b+diNn3NJQDRhTS25WRCzGztEy1hlfrqUvA5YZWwREZ5aPPz2cuj H9KIHr2qBMtgZOfKpBshrPpaswGsBiyHY8VFc5XHqiYjXmlqMr7IonMxX1mI YhYcUzgdigA8icDUANxSk63WZFnEUZfp6E5LnlBy6NIJ8RNxjWb7UglI1qzJ ZJVRQTWCk6hTbXBNujhaPiOEk8fUWR1jTBbj0jFS/8xn223yGNXi4xhRZcbU F5BRQabBa3JVVVUG5c202PlDqW4LFNMEin1hjqZfKZXmWlZvNVKz0N6mC0AG nq5Kukkmmz5IqMGaUqlm4fuaTn8nyfJVb4OZpJobQ268CAhFzi2RvWzPP8B/ T08Mtt97vc6IAc9sHuY91BLGEgq9PzNTHDfenRHhz2QMY8psN1MC4riCxcGw fFyM34N668V5rrIEjvEiXnhgvOPB42Gcvki8/zc5sW53VcP/IClkmeyyfuGq nAwI6xca16LkEy8R98LH59H/f8jrjqecZKMBIvymrfi9C/6A1zOP5h98Tua9 MDICv2METfM2S4gITzyE31vg3/d65if4wns2AM78ZBH/jmJ//KQW/MbYcwfm WQsVP3zSmViYKOIvnB8QXiHDz/vhjINMdyfC7szyeu5K9MdPR753pcKTnBnL xPwR4ZNAjyEeHmOf4bykF+FZXV6PEXCMiV6PKcMfng0Z1ZQNjzHXtEETjvgm zA9NbfCdfvg5e/H7qNdTpcDTERudCJ92Dr+d8Hu8nsV0znSQCM/Lw2/MNxeD d0vUfMH/WxG2BPkuQb5LtvjD88GzJa3wH3o9NVv9+Ny2D7/Bo5r9Xk9tth8f 0r2pzYfH3LauxY9POfhWhzzrAMf1vj98fid+UxjouyfVD+eO4/idDg849+zy hy8AL+/ZDY/ybyT+D5ThkPMbk+GL4Fv84QtRpxqRbyP40HjeX16kZ+EG/90Z 8EZ/fNLXcIMHbqRxH/fTq+/B727I8wlez+osiT/4YwWc1eTR3u5lEk+E3x2N 36i79wL+vVv94fXg873g272HaF+4d/jabBG+brOf3mbAXgdc1oHmdd1+fNaC znUo4/XAZ321JtyN38B/PdKs7/TzeS3oXw/YvwDNv8jwh99Hv1GXfwH+/WKd P3w96uEvNsDvgD/kD38AeP4CZXMfaLuvyJ/vBpTTfYBxH8r/vi4//hs+w2/g uQH1c4PFD+eXsfgNnm0ALzb0+MN/hXzvR125H/HvX+gP/znqx/0V8M3wmvqz Dvjdj/pzP75vnu8vxwdRVpvRFjcDnwf97b0nBXAflO39wWKJ/wDvhUdRvg+i rj8I+A+2+fHfuhO/0cc8BJweStCEo10/lCrDqzXhgPOQQ4Zr6u1jKKeHUAYP Ac+HujXhKMeHwJ8ttB+c7udnK2A8jHJ5GGX5sKbcaS/2YfShj6AdbE3190tP Ir+tiL/VSPu7Mhz16lmU4Vb0D4+hPj62TvIB4b8Fbx5rEXx47EM/nGeBy2Og 7XHAe8LiDx+O9E9Y4VFeO1v9fH4rDr8pjPYqE/x4tqHevyT74ZcW+tvdPvDs JaMMX+eHvw/0voQ++iW015cX+sPfA5yXQdPLKJfdu3uH797D4YRcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVc yIVcyIVcyIVcyIVcyIVcyIVcyIVcyIVcyIXc/9MeHNMAAIAwAAvJ3OHfDQci 9rYFAAAAAAAAAAAAAAAAAAAAqO1NHlQHFYYAAAQA --0-956278597-1227232400=:53603--