From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1D0M8m-0007y5-Aq for qemu-devel@nongnu.org; Sun, 13 Feb 2005 10:58:32 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1D0M8Z-0007s2-Mv for qemu-devel@nongnu.org; Sun, 13 Feb 2005 10:58:28 -0500 Received: from [199.232.76.173] (helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1D0M8Z-0007rd-6l for qemu-devel@nongnu.org; Sun, 13 Feb 2005 10:58:19 -0500 Received: from [62.210.158.45] (helo=quito.magic.fr) by monty-python.gnu.org with esmtp (Exim 4.34) id 1D0LuJ-0006WD-Ox for qemu-devel@nongnu.org; Sun, 13 Feb 2005 10:43:37 -0500 Subject: Re: [Qemu-devel] New emulator: MIPS-user From: "J. Mayer" In-Reply-To: <1108135188.15068.5.camel@localhost.localdomain> References: <1107974989.17910.6.camel@jmcmullan> <1107986571.10555.833.camel@rapid> <1108042101.17910.9.camel@jmcmullan> <1108131466.10555.1233.camel@rapid> <1108135188.15068.5.camel@localhost.localdomain> Content-Type: multipart/mixed; boundary="=-TRf8s2gcgkXOykAeFLFE" Message-Id: <1108309390.3148.12.camel@rapid> Mime-Version: 1.0 Date: Sun, 13 Feb 2005 16:43:11 +0100 Reply-To: qemu-devel@nongnu.org List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Jason McMullan Cc: qemu-devel@nongnu.org --=-TRf8s2gcgkXOykAeFLFE Content-Type: text/plain Content-Transfer-Encoding: 7bit On Fri, 2005-02-11 at 16:19, Jason McMullan wrote: > On Fri, 2005-02-11 at 15:17 +0100, J. Mayer wrote: > > As I was reworking some parts of this code, my current version may be > > quite broken. > > So, I'll take a close look this week-end and send you a snapshot. > > Broken I can handle (my 'mips64.spec' was taken pretty much directly > from the manuals, so I can use it as a verification suite on your > code). > > Anyway, any start you already have would be good for me, even if it's > just a reference. Here's a snapshot of a quite outdated version of my mips emulation. But this version is, I think, very near from the one that did boot Linux. This will give an idea of how I did it. Don't care too much about the CALL_FROM_TB macros, which are not specially related to mips emulation. What I did since this version is mainly: - debugging - remove quite all #ifdef, using a features field in the CPUMIPSState structure. - start implementing mips16 opcodes - try using some generic micro-ops: the goal here is not to re-implement the same simple micro-operations for all emulated targets. This is the patch that isn't finished and broke my code... The hardware implemented is very simple: it's just the interrupt controler + a serial port. I also implemented MIPS R4Kc like MMU (which, I think, is not completely finished/debugged in this version). I didn't make anything to emulate mipsel targets. I only did big-endian support, but little-endian is planned and would not be very hard to add. I can't release the BIOS I used for my tests, as it's not open-source, but one could patch yamon and make it boot (or start booting) Linux. Here's the diff with the current qemu CVS + a bzip'ed tarball of all new files. -- J. Mayer Never organized --=-TRf8s2gcgkXOykAeFLFE Content-Disposition: attachment; filename=target-mips.diff Content-Type: text/x-patch; name=target-mips.diff; charset=iso-8859-15 Content-Transfer-Encoding: 7bit Index: Makefile.target =================================================================== RCS file: /cvsroot/qemu/qemu/Makefile.target,v retrieving revision 1.57 diff -u -d -w -B -b -d -p -r1.57 Makefile.target --- Makefile.target 10 Feb 2005 21:48:51 -0000 1.57 +++ Makefile.target 13 Feb 2005 15:23:30 -0000 @@ -78,13 +78,33 @@ PROGS+=$(QEMU_SYSTEM) endif endif # ARCH = i386 +ifeq ($(ARCH), amd64) +ifdef CONFIG_SOFTMMU +PROGS+=$(QEMU_SYSTEM) +endif +endif # ARCH = amd64 + +endif # TARGET_ARCH = ppc + +ifeq ($(TARGET_ARCH), mips) + +ifeq ($(ARCH), ppc) +PROGS+=$(QEMU_SYSTEM) +endif + +ifeq ($(ARCH), i386) +ifdef CONFIG_SOFTMMU +PROGS+=$(QEMU_SYSTEM) +endif +endif # ARCH = i386 + ifeq ($(ARCH), x86_64) ifdef CONFIG_SOFTMMU PROGS+=$(QEMU_SYSTEM) endif endif # ARCH = x86_64 -endif # TARGET_ARCH = ppc +endif # TARGET_ARCH = mips ifeq ($(TARGET_ARCH), sparc) @@ -255,6 +275,10 @@ ifeq ($(TARGET_ARCH), ppc) LIBOBJS+= op_helper.o helper.o endif +ifeq ($(TARGET_ARCH), mips) +LIBOBJS+= op_helper.o helper.o +endif + ifeq ($(TARGET_BASE_ARCH), sparc) LIBOBJS+= op_helper.o helper.o endif @@ -276,6 +300,9 @@ endif ifeq ($(findstring ppc, $(TARGET_ARCH) $(ARCH)),ppc) LIBOBJS+=ppc-dis.o endif +ifeq ($(findstring mips, $(TARGET_ARCH) $(ARCH)),mips) +LIBOBJS+=mips-dis.o +endif ifeq ($(findstring sparc, $(TARGET_BASE_ARCH) $(ARCH)),sparc) LIBOBJS+=sparc-dis.o endif @@ -333,6 +360,10 @@ VL_OBJS+= ppc.o ide.o ne2000.o pckbd.o v VL_OBJS+= mc146818rtc.o serial.o i8259.o i8254.o fdc.o m48t59.o VL_OBJS+= ppc_prep.o ppc_chrp.o cuda.o adb.o openpic.o mixeng.o endif +ifeq ($(TARGET_ARCH), mips) +VL_OBJS+= mips.o mips_r4k.o dma.o vga.o serial.o #ide.o ne2000.o pckbd.o +VL_OBJS+= #i8259.o i8254.o fdc.o m48t59.o +endif ifeq ($(TARGET_BASE_ARCH), sparc) VL_OBJS+= sun4m.o tcx.o lance.o iommu.o m48t08.o magic-load.o slavio_intctl.o slavio_timer.o slavio_serial.o fdc.o endif @@ -422,6 +453,11 @@ op.o: op.c op_template.h op_mem.h op_helper.o: op_helper_mem.h endif +ifeq ($(TARGET_ARCH), mips) +op.o: op.c op_template.c op_mem.c +op_helper.o: op_helper_mem.c +endif + mixeng.o: mixeng.c mixeng.h mixeng_template.h %.o: %.c Index: configure =================================================================== RCS file: /cvsroot/qemu/qemu/configure,v retrieving revision 1.55 diff -u -d -w -B -b -d -p -r1.55 configure --- configure 12 Feb 2005 18:58:00 -0000 1.55 +++ configure 13 Feb 2005 15:23:31 -0000 @@ -200,7 +200,7 @@ fi if test -z "$target_list" ; then # these targets are portable - target_list="i386-softmmu ppc-softmmu sparc-softmmu x86_64-softmmu sparc64-softmmu" + target_list="i386-softmmu ppc-softmmu sparc-softmmu x86_64-softmmu sparc64-softmmu mips-softmmu" # the following are Linux specific if [ "$linux" = "yes" ] ; then target_list="i386-user arm-user armeb-user sparc-user ppc-user sparc64-user $target_list" @@ -228,7 +228,7 @@ fi else # if cross compiling, cannot launch a program, so make a static guess -if test "$cpu" = "powerpc" -o "$cpu" = "mips" -o "$cpu" = "s390" -o "$cpu" = "sparc" -o "$cpu" = "sparc64" -o "$cpu" = "m68k" -o "$cpu" = "armv4b"; then +if test "$cpu" = "powerpc" -o "$cpu" = "powerpc64" -o "$cpu" = "mips" -o "$cpu" = "s390" -o "$cpu" = "sparc" -o "$cpu" = "sparc64" -o "$cpu" = "m68k" -o "$cpu" = "armv4b"; then bigendian="yes" fi @@ -575,6 +575,7 @@ target_bigendian="no" [ "$target_cpu" = "sparc" ] && target_bigendian=yes [ "$target_cpu" = "sparc64" ] && target_bigendian=yes [ "$target_cpu" = "ppc" ] && target_bigendian=yes +[ "$target_cpu" = "mips" ] && target_bigendian=yes target_softmmu="no" if expr $target : '.*-softmmu' > /dev/null ; then target_softmmu="yes" @@ -635,6 +636,10 @@ elif test "$target_cpu" = "x86_64" ; the echo "#define TARGET_ARCH \"x86_64\"" >> $config_h echo "#define TARGET_I386 1" >> $config_h echo "#define TARGET_X86_64 1" >> $config_h +elif test "$target_cpu" = "mips" ; then + echo "TARGET_ARCH=mips" >> $config_mak + echo "#define TARGET_ARCH \"mips\"" >> $config_h + echo "#define TARGET_MIPS 1" >> $config_h else echo "Unsupported target CPU" exit 1 Index: cpu-all.h =================================================================== RCS file: /cvsroot/qemu/qemu/cpu-all.h,v retrieving revision 1.41 diff -u -d -w -B -b -d -p -r1.41 cpu-all.h --- cpu-all.h 10 Feb 2005 21:56:58 -0000 1.41 +++ cpu-all.h 13 Feb 2005 15:23:31 -0000 @@ -616,6 +616,13 @@ void page_unprotect_range(uint8_t *data, #define cpu_gen_code cpu_ppc_gen_code #define cpu_signal_handler cpu_ppc_signal_handler +#elif defined(TARGET_MIPS) +#define CPUState CPUMIPSState +#define cpu_init cpu_mips_init +#define cpu_exec cpu_mips_exec +#define cpu_gen_code cpu_mips_gen_code +#define cpu_signal_handler cpu_mips_signal_handler + #else #error unsupported target CPU Index: cpu-exec.c =================================================================== RCS file: /cvsroot/qemu/qemu/cpu-exec.c,v retrieving revision 1.48 diff -u -d -w -B -b -d -p -r1.48 cpu-exec.c --- cpu-exec.c 10 Feb 2005 22:04:41 -0000 1.48 +++ cpu-exec.c 13 Feb 2005 15:23:31 -0000 @@ -165,6 +165,7 @@ int cpu_exec(CPUState *env1) } #elif defined(TARGET_SPARC) #elif defined(TARGET_PPC) +#elif defined(TARGET_MIPS) #else #error unsupported target CPU #endif @@ -203,6 +204,8 @@ int cpu_exec(CPUState *env1) env->exception_next_eip, 0); #elif defined(TARGET_PPC) do_interrupt(env); +#elif defined(TARGET_MIPS) + do_interrupt(env); #elif defined(TARGET_SPARC) do_interrupt(env->exception_index, env->error_code); @@ -285,6 +288,19 @@ int cpu_exec(CPUState *env1) env->interrupt_request &= ~CPU_INTERRUPT_TIMER; } } +#elif defined(TARGET_MIPS) + if ((interrupt_request & CPU_INTERRUPT_HARD) && + (env->CP0_Status & (1 << CP0St_IE)) && + (env->CP0_Cause & 0x0000FC00) && + !(env->hflags & MIPS_HFLAG_EXL) && + !(env->hflags & MIPS_HFLAG_ERL) && + !(env->hflags & MIPS_HFLAG_DM)) { + /* Raise it */ + env->exception_index = EXCP_EXT_INTERRUPT; + env->error_code = 0; + do_interrupt(env); + env->interrupt_request &= ~CPU_INTERRUPT_HARD; + } #elif defined(TARGET_SPARC) if (interrupt_request & CPU_INTERRUPT_HARD) { do_interrupt(env->interrupt_index, 0); @@ -333,6 +349,8 @@ int cpu_exec(CPUState *env1) cpu_dump_state (env, logfile, fprintf, 0); #elif defined(TARGET_PPC) cpu_dump_state(env, logfile, fprintf, 0); +#elif defined(TARGET_MIPS) + cpu_dump_state(env, logfile, fprintf, 0); #else #error unsupported target CPU #endif @@ -355,6 +373,10 @@ int cpu_exec(CPUState *env1) flags = 0; cs_base = 0; pc = env->nip; +#elif defined(TARGET_MIPS) + flags = env->hflags & MIPS_HFLAGS_TMASK; + cs_base = NULL; + pc = env->PC; #else #error unsupported CPU #endif @@ -622,6 +663,7 @@ int cpu_exec(CPUState *env1) env->cpsr = compute_cpsr(); #elif defined(TARGET_SPARC) #elif defined(TARGET_PPC) +#elif defined(TARGET_MIPS) #else #error unsupported target CPU #endif @@ -871,6 +913,57 @@ static inline int handle_cpu_signal(unsi /* never comes here */ return 1; } + +#elif defined (TARGET_MIPS) +static inline int handle_cpu_signal(unsigned long pc, unsigned long address, + int is_write, sigset_t *old_set, + void *puc) +{ + TranslationBlock *tb; + int ret; + + if (cpu_single_env) + env = cpu_single_env; /* XXX: find a correct solution for multithread */ +#if defined(DEBUG_SIGNAL) + printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n", + pc, address, is_write, *(unsigned long *)old_set); +#endif + /* XXX: locking issue */ + if (is_write && page_unprotect(address, pc, puc)) { + return 1; + } + + /* see if it is an MMU fault */ + ret = cpu_ppc_handle_mmu_fault(env, address, is_write, msr_pr, 0); + if (ret < 0) + return 0; /* not an MMU fault */ + if (ret == 0) + return 1; /* the MMU fault was handled without causing real CPU fault */ + + /* now we have a real cpu fault */ + tb = tb_find_pc(pc); + if (tb) { + /* the PC is inside the translated code. It means that we have + a virtual CPU fault */ + cpu_restore_state(tb, env, pc, puc); + } + if (ret == 1) { +#if 0 + printf("PF exception: NIP=0x%08x error=0x%x %p\n", + env->nip, env->error_code, tb); +#endif + /* we restore the process signal mask as the sigreturn should + do it (XXX: use sigsetjmp) */ + sigprocmask(SIG_SETMASK, old_set, NULL); + do_raise_exception_err(env->exception_index, env->error_code); + } else { + /* activate soft MMU for this block */ + cpu_resume_from_signal(env, puc); + } + /* never comes here */ + return 1; +} + #else #error unsupported target CPU #endif Index: dis-asm.h =================================================================== RCS file: /cvsroot/qemu/qemu/dis-asm.h,v retrieving revision 1.7 diff -u -d -w -B -b -d -p -r1.7 dis-asm.h --- dis-asm.h 3 Jan 2005 23:35:10 -0000 1.7 +++ dis-asm.h 13 Feb 2005 15:23:32 -0000 @@ -404,6 +404,8 @@ extern int generic_symbol_at_address bfd_vma bfd_getl32 (const bfd_byte *addr); bfd_vma bfd_getb32 (const bfd_byte *addr); +bfd_vma bfd_getl16 (const bfd_byte *addr); +bfd_vma bfd_getb16 (const bfd_byte *addr); typedef enum bfd_boolean {false, true} boolean; #endif /* ! defined (DIS_ASM_H) */ Index: disas.c =================================================================== RCS file: /cvsroot/qemu/qemu/disas.c,v retrieving revision 1.19 diff -u -d -w -B -b -d -p -r1.19 disas.c --- disas.c 31 Jan 2005 23:32:31 -0000 1.19 +++ disas.c 13 Feb 2005 15:23:32 -0000 @@ -108,6 +108,24 @@ bfd_vma bfd_getb32 (const bfd_byte *addr return (bfd_vma) v; } +bfd_vma bfd_getl16 (const bfd_byte *addr) +{ + unsigned long v; + + v = (unsigned long) addr[0]; + v |= (unsigned long) addr[1] << 8; + return (bfd_vma) v; +} + +bfd_vma bfd_getb16 (const bfd_byte *addr) +{ + unsigned long v; + + v = (unsigned long) addr[0] << 24; + v |= (unsigned long) addr[1] << 16; + return (bfd_vma) v; +} + /* Disassemble this for me please... (debugging). 'flags' is only used for i386: non zero means 16 bit code */ void target_disas(FILE *out, target_ulong code, target_ulong size, int flags) @@ -142,6 +160,8 @@ void target_disas(FILE *out, target_ulon print_insn = print_insn_sparc; #elif defined(TARGET_PPC) print_insn = print_insn_ppc; +#elif defined(TARGET_MIPS) + print_insn = print_insn_big_mips; #else fprintf(out, "Asm output not supported on this arch\n"); return; @@ -310,6 +330,8 @@ void monitor_disas(target_ulong pc, int print_insn = print_insn_sparc; #elif defined(TARGET_PPC) print_insn = print_insn_ppc; +#elif defined(TARGET_MIPS) + print_insn = print_insn_big_mips; #else term_printf("Asm output not supported on this arch\n"); return; Index: dyngen-exec.h =================================================================== RCS file: /cvsroot/qemu/qemu/dyngen-exec.h,v retrieving revision 1.20 diff -u -d -w -B -b -d -p -r1.20 dyngen-exec.h --- dyngen-exec.h 26 Jan 2005 21:30:57 -0000 1.20 +++ dyngen-exec.h 13 Feb 2005 15:23:32 -0000 @@ -246,4 +246,28 @@ extern int __op_jmp0, __op_jmp1, __op_jm #define EXIT_TB() asm volatile ("rts") #endif +#ifndef CALL_FROM_TB0 +#define CALL_FROM_TB0(func) func(); +#endif +#ifndef CALL_FROM_TB1 +#define CALL_FROM_TB1(func, arg0) func(arg0); +#endif +#ifndef CALL_FROM_TB1_CONST16 +#define CALL_FROM_TB1_CONST16(func, arg0) CALL_FROM_TB1(func, arg0); +#endif +#ifndef CALL_FROM_TB2 +#define CALL_FROM_TB2(func, arg0, arg1) func(arg0, arg1); +#endif +#ifndef CALL_FROM_TB2_CONST16 +#define CALL_FROM_TB2_CONST16(func, arg0, arg1) \ +CALL_FROM_TB2(func, arg0, arg1); +#endif +#ifndef CALL_FROM_TB3 +#define CALL_FROM_TB3(func, arg0, arg1, arg2) func(arg0, arg1, arg2); +#endif +#ifndef CALL_FROM_TB4 +#define CALL_FROM_TB4(func, arg0, arg1, arg2, arg3) \ + func(arg0, arg1, arg2, arg3); +#endif + #endif /* !defined(__DYNGEN_EXEC_H__) */ Index: elf.h =================================================================== RCS file: /cvsroot/qemu/qemu/elf.h,v retrieving revision 1.5 diff -u -d -w -B -b -d -p -r1.5 elf.h --- elf.h 29 Apr 2003 21:06:46 -0000 1.5 +++ elf.h 13 Feb 2005 15:23:33 -0000 @@ -31,11 +31,29 @@ typedef int64_t Elf64_Sxword; #define PT_LOPROC 0x70000000 #define PT_HIPROC 0x7fffffff #define PT_MIPS_REGINFO 0x70000000 +#define PT_MIPS_OPTIONS 0x70000001 /* Flags in the e_flags field of the header */ +/* MIPS architecture level. */ +#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ +#define EF_MIPS_ARCH_32 0x50000000 /* MIPS32 code. */ +#define EF_MIPS_ARCH_64 0x60000000 /* MIPS64 code. */ + +/* The ABI of a file. */ +#define EF_MIPS_ABI_O32 0x00001000 /* O32 ABI. */ +#define EF_MIPS_ABI_O64 0x00002000 /* O32 extended for 64 bit. */ + #define EF_MIPS_NOREORDER 0x00000001 #define EF_MIPS_PIC 0x00000002 #define EF_MIPS_CPIC 0x00000004 +#define EF_MIPS_ABI2 0x00000020 +#define EF_MIPS_OPTIONS_FIRST 0x00000080 +#define EF_MIPS_32BITMODE 0x00000100 +#define EF_MIPS_ABI 0x0000f000 #define EF_MIPS_ARCH 0xf0000000 /* These constants define the different elf file types */ Index: exec-all.h =================================================================== RCS file: /cvsroot/qemu/qemu/exec-all.h,v retrieving revision 1.28 diff -u -d -w -B -b -d -p -r1.28 exec-all.h --- exec-all.h 10 Feb 2005 22:02:59 -0000 1.28 +++ exec-all.h 13 Feb 2005 15:23:34 -0000 @@ -570,6 +570,8 @@ static inline target_ulong get_phys_addr is_user = ((env->hflags & HF_CPL_MASK) == 3); #elif defined (TARGET_PPC) is_user = msr_pr; +#elif defined (TARGET_MIPS) + is_user = ((env->hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM); #elif defined (TARGET_SPARC) is_user = (env->psrs == 0); #else Index: softmmu_header.h =================================================================== RCS file: /cvsroot/qemu/qemu/softmmu_header.h,v retrieving revision 1.8 diff -u -d -w -B -b -d -p -r1.8 softmmu_header.h --- softmmu_header.h 3 Jan 2005 23:35:10 -0000 1.8 +++ softmmu_header.h 13 Feb 2005 15:23:34 -0000 @@ -55,6 +55,8 @@ #define CPU_MEM_INDEX ((env->hflags & HF_CPL_MASK) == 3) #elif defined (TARGET_PPC) #define CPU_MEM_INDEX (msr_pr) +#elif defined (TARGET_MIPS) +#define CPU_MEM_INDEX ((env->hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM) #elif defined (TARGET_SPARC) #define CPU_MEM_INDEX ((env->psrs) == 0) #endif @@ -66,6 +68,8 @@ #define CPU_MEM_INDEX ((env->hflags & HF_CPL_MASK) == 3) #elif defined (TARGET_PPC) #define CPU_MEM_INDEX (msr_pr) +#elif defined (TARGET_MIPS) +#define CPU_MEM_INDEX ((env->hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM) #elif defined (TARGET_SPARC) #define CPU_MEM_INDEX ((env->psrs) == 0) #endif Index: vl.c =================================================================== RCS file: /cvsroot/qemu/qemu/vl.c,v retrieving revision 1.120 diff -u -d -w -B -b -d -p -r1.120 vl.c --- vl.c 10 Feb 2005 22:00:06 -0000 1.120 +++ vl.c 13 Feb 2005 15:23:35 -0000 @@ -2321,6 +2321,17 @@ int cpu_load(QEMUFile *f, void *opaque, { return 0; } + +#elif defined(TARGET_MIPS) +void cpu_save(QEMUFile *f, void *opaque) +{ +} + +int cpu_load(QEMUFile *f, void *opaque, int version_id) +{ + return 0; +} + #elif defined(TARGET_SPARC) void cpu_save(QEMUFile *f, void *opaque) { @@ -3376,10 +3387,11 @@ int main(int argc, char **argv) linux_boot = (kernel_filename != NULL); +#if !defined(TARGET_MIPS) /* Don't have any disk on mips for now */ if (!linux_boot && hd_filename[0] == '\0' && hd_filename[2] == '\0' && fd_filename[0] == '\0') help(); - +#endif /* boot to cd by default if no hard disk */ if (hd_filename[0] == '\0' && boot_device == 'c') { if (fd_filename[0] != '\0') @@ -3645,6 +3657,10 @@ int main(int argc, char **argv) ppc_init(ram_size, vga_ram_size, boot_device, ds, fd_filename, snapshot, kernel_filename, kernel_cmdline, initrd_filename); +#elif defined(TARGET_MIPS) + mips_init(ram_size, vga_ram_size, boot_device, + ds, fd_filename, snapshot, + kernel_filename, kernel_cmdline, initrd_filename); #elif defined(TARGET_SPARC) sun4m_init(ram_size, vga_ram_size, boot_device, ds, fd_filename, snapshot, --=-TRf8s2gcgkXOykAeFLFE Content-Disposition: attachment; filename=qemu-mips.tar.bz2 Content-Type: application/x-bzip-compressed-tar; name=qemu-mips.tar.bz2 Content-Transfer-Encoding: base64 QlpoOTFBWSZTWQ7T+S8BlMf/5////5////////////////8IACICAAEgBABAAAhhAt58747tW198 8ejx773nPasUUADxeuvfa++nPkaVVLt6PQGh6Y+x9z1Edteneg74M3XbucXy7cuX1veO+5wL1btu PWqgL2e8fXtuczp3bXSu2BdYfdt72Hm9baFAPTetSl847W+bWfffH0Ad9h8de9fdzQC+zR09U6e2 AejS9tKJsaqqRVfTAgSBSfduvvt0d9ng1776+PT2wat7Pl761x8ntkSEqr7sd1eHXTul73e+be99 ne6wD6AAAAvbvl9Uu7fQXu7tS7wHe7r683vvvr6OqEpB0ANG++sb6c7t4H1630powJG9u5a1rtvQ Ou++tye9nh77uu6vjN7rd6ve0a3tq+XZ9XWVW+5vae1VLvvuDvffbR0z3afN7yQd3u9dPddlwel3 1w++4AfQjYaSaejOzPuoH1zVrKHvfefJ9ll4di+197nhPemb72745775972Ek++3PH2e+86T58Nw 7m193dfSsffW6sqrwO3fF03vXOe9d5zNmvr7z7691u66vHeHnl1r77felt32i7vbn1A9Dpj3euW6 uwHS29Yup753eT23u6dbPW9z13hk9a+zC+lviO7LWfbu3r3fe332VrFt0M9vu933PF3Ms92l1t53 L20GX3b7N9zqfLu3vdadoYAAfT6c+fcMLbg2+7h72Y7jH3d4tPXdO7lrPLC9b3H0O9NfZu5O633b TBwhqtd9mOe75KZVXZr3H17jx1ZtV1rZdu2V3Rg33bg3u47m3G0NvSXdri6c92XPdllTt0zrq9u7 Vrp1d89zc+dre3faPJ69t3eOMpvWXs3tvd93AOnvrOvsbvlOTOvt7zyd3Xdq+zQAbt1rGbzfffd9 aX1dhX3D3LXjA6Vvd15p619fdfe96l31y74Y6t3bbrV2WEppBAAgEyAAQ0NABGTIJtAEYU2mqaan lP0k0GmmjJjTUAAkQgQgQTEBDSaZqaFPCp+0mQQyntKP1M1T9UPSeoNPUaGjRoAAaAASaSJCAmmI CTBTZGQyJpk001PQRjSnknqbU3oT0poeUHqaaB6mgD1AAJPVSSCAamUzQTKemlPTSenqJhMmI2iH qPUMQAyD1AAAAAaAARJFMQAJoAJoCZTaCT1T9MJU/Jspmk0wEeoxRtDEo9NT0jT9UAaAaeoIkRCA SYEaFPCIn6k/SnkejVHqHoyVH+Smn6qHpB+qHqY9I0RpiAD1ANAD/RX/XU/vJD/KEIfDCrfZR+1M E/ireiEiQFmcVR9IGaSMP8mCWQOZGiKsPj+Q0Wk+suv586FwCbhkVRWfjN5Kq2wQqMIwgIxAIjGk ELKUNdlYLlWwEtH62VtDhX/hLo0AhZQrvLxleus8XSFlUVGNYtbRtrFea9V1tbem45rV23XNlNWT VEVbYrWiti03qVXVuspbZSttqaVpEBAiwUr46EEUpRbIXAwgXEBLgsLWALQaBFKRGRVLQictrdOT auyuZMqZqVGltVMESwsFDFyMgihQtEQWhEY0Namm2o2TVtSla7cc3NhjEbwSojcjSkYDVI0QCN4g RUog0otWUooAVFUUwoo9BR+1AbxP7PxUAfbFMYEIshgW1fi/3f2/t/Z/t/Yct8Dxv/P+pfA6uuBQ EURkD+k9JhgQVEC8/nV+n52wrzDV48fFq/T9bro2a959cYQMLbbXd3d3d47MbJRxCF0j+kT8U2fP mhjblnhmvvSuzXxzzhjRZtozY25sL9Z8GtZZFaLaLVZLYLJRWrfM1XEWtionOa+hHUqPr7c1doiV dsoqk1syorNfLkT9orCzMUMWDqUAcyBI2EgqSVRtsBsdltri2NLK0xLWzSZmUaxUhaIyUiprbJpm kIpmKjBEIpCKSLGRnX6KMV8TNtgd1p6Q77X7Ob0avz68B7NoCjsgSC2iq1AJBCoSEYKyMYfq8KKq zh2eGq6OKRjGRkfVM8SwAqowAIJ1d3u9V1NohCHfaQGMkOrS6z72SNgL17yLyjlIl0uFul3AbtGM QmkzmrJogB5Vv3QbIkIikJFYEhiMZK1JqIs0yVtkslrFi35lduVdSoJKtFtUWIEFkhybZsw1hrEQ FUJiawsE0TLjCAsUi5CgHSc/Z3+fxfJwV44XjgzZ1UHu3er1fszPZh6PRjjuTGJBWBIEUGLM329K 21yY2le1ualjKyqoIgf5AFhQDkkCzAQjEQAlzz641zXbrDWsMSSjZFlEuvxUMQxrFixAZBAZB8zy 8eo1IMAFABUBVJc02zzZmL8eSs9QtuKx9VmtaxTBbdruVvGNbUURURImSQkkJJEyBu9waytwtLXD MrmNcMyuY8ZhlKWlLmYIiOLSlpS5mGUpaUtKWXgAnBo0VgKLmsMquZJiDpKKmiWdVLjd627MtI1u 2Z2iuKIuMC2VUqy6YYuFNMJTWJkY1qY6eN3YuUM1VrVbSrWq2Hwa2aNPCLxlR1ulFylFzMwrcZyc NKWmnMxlRwWURcpRbQoqlXOHTq6ttuszHcKLNGqiLLA4N47Jd5dCZabrVpC1mksk1lttqpSVUrJo YYuUKLxcVFlYTNV3bFgdsYsDBMS0UFFDTxXXGjYmxd3p1bzkFAta0OWYTCIVP8P1/ntR7qF75P1h hIelQQEVI/T/bmYnyCer+lKf+rP2M/1/936Q3rts5FEvMlLYVHV6a1j3rVLhmE4dOqpmKZIkOLqD kv6mkPQwnL1sXe7wb4RVAMqGwQZGquJEAKauKbNs4Md3Xnx/m3NsNaFBwYqhVuXHxSbdjTUZMMLz Nxlrl4UUF2p2Pv7b9Dg2SM5hBu0HBShDBG7BNtxBYAvDq3N0ULbpwYLq00nEN9hVTUwh2cv7f+79 V3j9+NqX1sTjuw1wJyghRGEWTuSox3u3tHHs7twzWLzNYCmsyqeGcu20vAWNjedrhAtqYY6fq8um ApIG3ythBYxDlDk/E/I4rIHoTeUxoqoSZWoQsSMhDbEvLh3ZGb+Pl8vubBP9NtLHeq7iqwfvbKyl jHbMphKRmTtz9lvZl1VV1BZAswjC3Wv3dZHa6rxpxW/20zy7sODhU342pnweeY+1JFDu9U4kVGHx P8sZGHg8Hmq+aWasuqL4WJeKM8ZNDhe2gih7er32s/nCI+wkULkzjWng6vXlmxktDhSYlG2OKbq7 aJiD8uHBrm9NG4WR8IiGLIA/U0JE4gpl+08nL+QfX4jZHWtWsSyI1NppzGoL0oKcBM1VZsSVTJxJ YdpirsVORMUCWtwxkFVYVKIoXXDsTUNUM+l6Ymt397mZBQNMlVAWIgLFTxcWKMY0YrFV3+bxuQNz Nq4NYtFRa8eLwukRUajizl0NWgsBjGIooMoGQ0CLpLZYVqQDGEKgVkKyiDawlovJwZ1JMQ0MgDz2 GG2kslNcmFZYt5RlmbkQWqbv6toLu1alXYFMeVUk5izh4xYbQ5cUwNJd2Uu8MRJreXnwbDVEvJHj cpmocNziu61aqa1c5fbS7m/PL0C8usd60zUE6WtaKmG4biGOLxW8btYYnOZHCxQFFYcscMeruJAw ydN2cNtPSOnYsc9iSWRTJhPEsvuWVFQrjBjQVmIYG7SlEvBl022qtonAUs1iapCpFUIwwpbMbG1+ ZhDA01loeYakKVSIGL1Fuuh2JA/t7OBYKBFCbZUgLAKgVBe4lpMSsETJwH1/c8w/D7LblVMM79WB tsTPx41mivxTisvLFEwE7g2/V+ntTr8VO43eBRLq0OyBKMypbM8JpoZJg7ijKowuGb0Xii3YXg+T Z93l/c/7P/T+w/wP63mguYuEYuDtgO6HFJr42yIkEkEoDSi8Ewtp8CImsJNDsmpLNJKIuqR88aYS GhNYOLHcSGmYiwgjJCCgpFOTrDYVjjulSpVRt5NHE05ODAAAFXLrrpwcLnCq1ZJ9jWljvjJxHmbz WiRQKkWciMiMOE3zpTqzF4pxt5bozeoc3hNIVEiSlKa3pU1SiYNFNS0nCFSXMU4Lc0Sg8rSbhvJD hkUhWny2GnerUldZtzVyhaYIOIqhBDDoiKmQO1AqKAsAnTeW5/jOuUWQxDkkkUnN5OmGVMDKiUDZ 15gLJNKc2QZCGLEil2gvVu9Ju4eM8C1NmU9BjjaZmWUGgkmUtTLEkxIgg4sZSIyh6QsMyqVkAUJi J4XNVFQu1W3fAIa0r6UF44VVRdQYTEnHFm+Acw4JONWp5Wom6aphzc0XyQxBSckXjs4vVubDwX/g v1Ry+UGruAWhm94QWotCcRI6UG30aIXauTJwy5RV9QgVDQLGdTOacuXacFPI1aFsL8dmzuoVHVnW 9j/25TtQ0yFQ7Gc0zr50N021wGa1Q2xh3MZt2EmdMmi3qO2j1/FoT2Utku+hmPJhm0Rzd/flKY0i DjvCCJEIGtpO/hc3hGsn6oYFRn1zJdtPLTmeE5l5gOR4DjZ2GSAEyGBBCRh5Dzw5PnlQZDyysxXr mORelFH/w+DY6j22/Te/sOm6HaZKqrOt+52hR3dJhCmGCOnXd/BvWkSIjArA5I4UmJY8jWYU5TDJ lHeViJYJmd+kcttwSoRRKICponh7YPEYDD1j/yjpUOY/efAftB2jSnR5lzJmDXXMbg1rC8aPklAb 7GyRin1azVvcHk2/Fw+CUv9/Ppp+3uv1lwgTOjtCy677S/yZpZFCVGVF7zoq9r0RbMXNtDzM7KNo nbGptbGatGLbVtttb+HnAKojZnBlvZMx1eWbFK0OaXYm0E3/JPZjdhioGMwDpojaT0QbYX1MEo+6 vSYr1vn23t+fBfl3HaMazzvmUdUetprZIKAdMOz22+7asH8EBH3fpJybcn78Wose+Y2iY5T0ei93 LInpETU6vUqnZrpa3nmW8N90x/LaLFiCiCi9cWdBFE6IRHu5bjxcDLPnPT7T5Ao+gZm37INmQWQL wh4ji2rTbSHl0UhH5nVgUWqKYmg3Ibiv39/frCrpT506BZhh/q3QQcMvBCM3H5hwdKScEQRYDEh+ vGtClgsEwnTuvBu/RUN3pTLIplRt2sS73LjKCdJTLiVZ+3NGIlEyic4SaUpwHSOpxIEH8E4LHs/y d32eDB9evXs9Pq+vGtRrWta1q+tZznOc5xr87UrKsrVWunXwiF2D63CJxggfKc1YdrBPqgfXDxiV DTXBsc0e6+BP9PeP8LHBVLZy1LRGxAEd9rz4+ocF/U3jRlZtuYKGhda36RDVYgphho90kGmfeNyC tMrKjSlHBw6vRsO/8AftCSHHrT7KHGFc/MfL4gZypuiYimhnKHmmZmbXVyfdq8/sdtHcEeiKKpzE RFk5/m5fjmAnPgDhHOcwOeosD1MwUZwO0PYun8VOSaWcIOHe4xcoanfaw1fD0d6G3lR2VXhKSpRF FWMxlVpatKtpElVVWHXqhplZWBpxVEmOMmDJthWCxYS8HWYmNxRDDH6orYfvQMxlwV0REgRcY1ta K2xaNWMRrFjJqjaiNqTJk2LRYSTUGxrTDbQbai1JrYti1sRsbFtBqqNFrY1RiyaqSojRsaMW2uPp QPeJJwypLhYoscsJ3cUKmmAoSAjNsFhUoT18s4SlQoh7OGBUtVFYbkdAH/XQqvarBAhBRFQMEhIA QUgvL4H7cJjGviBywI4igAr6FYgICnvQVARDEip5ggKDVXPHc1W/YarRUWxtojVEMCKBCQCK/LVq RZD2mAUHx+3O4kEPFhyiATBL9D+0wOZBBYi/v/kcrJZRZ8nZjz/aft/JNBWMD9FivbllsVDwiKax NOrH6fo9v2/ZWdQzhEUHRBQ4S0qEQYpJJAM1jbWqNZKUzLbSsto0zbJjaLbRqZSrfmta5Wsa2+ZW 5azTSqptlGraIRCDBSDEQDt7QJgooXYFx+GDc8tx7M5p0b+zbaFk+38dU3h/u8dzxS3+IoUFJBcj 3l5wnF7ncNO8/ywgklcZ20Bn8yh63oUDfmdO+RGCImqBQ01URhFogOQ5aAMQbwUgmAiwEgz82uOq uvy3jPztRH6OgRPfT4GSHLpZAGsq0t9C/3cW0ssss4tPDv42x2nE2/F74YPkGnQM1/BCJStEmiEs BiJUszZTJhNfnVzlEqZUu3t2yUxsBCehmOgH0S2T32p+bx9/i4t+nTvfl/5whCG90Xe0Y0jtjNsT b/yKQfRFXnnZ4ezfpdf/fvyEC8URXXBUB7Yqui77kE1ePRnuBTv91Q6MN+3fqvnPzwaytFvFepF7 YM6Y8VDg2IJhvBbile5lJgY7rIEbMEhLZrN27em/L5/Q/k+JM8Kxz8vDiZ2RTEOr+3HP+EjLn04V MbBNhlooxkaEwMW9fPnr1WYhFS3od7QbuzpsJ2WpE2ddH3YhvyoagS9iJYKKohlFXGlEfjanw9/b sNAxE5AhYnEq8bLQcfqV3a1ebbYpWmsolTTUluNzaZaiqmRNNLjiVMi1oqsymy5tXv643m/U0Bm3 wEQvdune5axpdXStPPRR4lLlg+E/EduGvEus4+fk6pnk6UHQv12dUnuglJCCwJ3CLRu6caqrTvZw 8CElQOTJ9SSGOIe6KCFEgsBQFmG0VjCxkoQoISxkCgrXMq5yspTkGjlamwbUbRsWlJU1NU0bGjTa RYystjY2Wri0zLczLcrmZjNzc3NwokbEVGpZlrksaC2izKzLlcatcliNuZrXBtoKk4tJakgwgjJA oyflwhiUIKCkFI/LQK0HyFFl/4R/jAEqKyKgWHIgHfGTOGCoTqSxhU0GhR1Z7nyIz7joU/N6sA/T Hpj2Re2JOvqsJy81SB70dWWnvl/GXsUGaHwy/A5Lfo2auKr4pXFrY1Q1nQwsFRgWeBCoSFoxT9Vg FRIhPxD6Peul/bFdOTBQoipKmikLRCMhaSVy8uq5q6uXLbkyImjTMUs/PTBIIiIYAyKIWlKWtFit KULAtitCiKWgMW9eX+eks1aoHylAqTLRgoUJYQAYSn3P4ev/IdB/wXJN38dnsIQYBJd50ZfCMvX/ IJVmYm9k6/yPSyh15x/KHf0uWfuHn5+5VYIjfiDX1GYyPz4YYMZtts0Yo0Syoo22zXt0h+iDD8Aa hWQOLFgfjTH5kpZCliKbJkqS0moxNSzU02EGQRIgkgoWRGVkpWNEsKrmiBmiA0aZogZog7+cpi6z c5y5NMQGsyitN6udXSRSy5YiJpIslRTbKbWaV4tzSSSm3VubnFXNSzZjLZZLSZVmUyimW2W5dtud MSAZTWo6/T7t3XU7XOa9PfuxjbGNgAMyoKSLBZIxxKmUsupTE9bKiliyOXen57Xqjf7a32amqCYK E2hGYFlzlzjaS0VkiIiSnXTa7VXa7davHq3S1i2IgE06riSqCEIXMyWC5FzIB9eFh4bCuWvr5zmq buTEHeB9gOf8/xHzZ4HloCkmxD0S9G/FlNzluhmGs0B/znKANO2w4EaIRVAz6V+MclDPfnb8uWvK WONUzln+j22Tnd+MNvhtHugXESDsXgf5hEhGJ/0tkSsXcrJKQizMfA9vb7fD5TMLWdaXqZjHXanx BkfKWQmlqoigmLkR4mj+Zqj2UQIHgpMr3vxg75CKCMfMVX+PAzDZGvHnwvkUGMVizIvLkp2nUZUa MKNH1RRjSRm+OecOZOXIhfji+jEY0Kv4ml867UujQ++0t/V+/g2XUUN9ChLm0ZXlVR1/Q59xJizV olpv4HB/Gwf8Tm3IPDN8Gj2Z7pnCKSM4+S1oomBECo7ikqMdEQ1wAkeaF4SD9kHOZWrwP5z7JY9H CVHl9SPh/MHH+fnffiIYox1wagRuBRlTOlpmqJAymIF2HAxhOsPgdoA6DjrI9tG8+ygbkgQEzfvQ XkSLwTpM4OMpejg0nCYN7Odx1dvrw8RFoJLazEfvn06/813qbLuz+G1tQuPKZf+T914Z0RglJ9K+ ZwRBBrxBQT01dpRj8BvcLtsvb9lqx8YUPDS98JTVFk6v/a450xyMe3iT7QizOwJH+YnNdgUsCGzS 5kTB87hdeA8VmMXO1mzJI0SZqK5sEEfiLCUnshpjpmzLUWL+NFKSTj1Hebi4n6+mjmHDtG3dL+BV zhhGk5HdGnaODZESjw0PuPaamyLBtIybDX83+X7znIa7GDiYG/EBMgQuByiSQn5Jc7ZIAnMTmHv5 yET3zn7qcLWr03TrhUKsWn93rzubrx6RVYwhciakFjkIMNfDX43tj8uCKN2sjQtRMhAPy8PPrSBp 7tCPL8d5rr6KVHETMdAue48sM5iaH8JmGtOA/kilr2sRmxAjzGf53T/LzmfzTUFwaOpbWNJ0kKKc qx7eLyuI+/etGrZFlRZKq9/0e3GDB4tduvHd+zO2v5K52O48Ohg0ZWOJCeQWfuzy1yKWeMbVbOc5 u7vXbIyjz2sNt+IGJAgY1s3vg2OwUNH5SZqmgQNypFCuu5I+S7ZiE3sGyDQxsFtn+45GnYahhpok aPP3PXbXCiE0qPR4LNtcuKFLRUUU6Rzxq+9qoUu/4w98olDvU+eqz+UMzV0tRN1meo5OadLGy6tq MfjsD5ST/y4SDcevE5lpMEO6qdqLm/P+kKf3p1xJ1QhySN/VjIPzuz0V4Cx+eWpWXwsobSvr7mBK eiWjD9baYUQuFiM2ZMeG97kUo4kDHxiZho0OzN83X2UzN4nBAFpSccI8Ltd1b/f3fpZh2WSprYhc Jpo7sWe67QZRprdp5T1xaT1dME7MZeB4YdqSe3IsHiRnNrPUUM0P2POdLNPOjTbr1cvTu7WFnShz xin/R4/B6rfFiYqukKcpoKCi9e4BZuQVrWbG2pQw4AzIGzs5/CSRNmb4h54ROGEvfjAnj2VpSiqZ c/ZTwNLIIIbooqJo5+YhDxuD7DkrFWcYotJN9QRx0XE4V6Yj9RaWpu+1LOaivVgJqgnvedF7smQw klInhNdAtHlWn60Rg7tB+mH84/C83jAmlj4vR6o9neo2aHqjxjWfxTCu+JHVEjsTqN0GaCiwubzR poi1piawsE1f6NVm2TVsCQOULuEJVDEbwZWqHui9o6mzSV9ieeaU0W+r53RY46IJj3DGr5Ofxr0Z iYyTNXSFVZsgOz91AmkguJCoVUHfJmaaHHVcYDEgRU/o+bus7R9r51NRAzFOFFC5b4V4z1+H1rRl L0LsbBcSoml/FKoGMqv01UjCGVlmpqYYCMylhSyzEMykrLaVFNXM+Mym02nl/ks2MEYjN8smBbTG GOCYAWWVPuIaSCuqKFVozlShiVtstqrbSuzGcPUHEpvJLO+yFn3WXdH0/gtepe9XSxQjk2qHXQZA AKQYKL4LmfH+6Pl5YdXkNKFvIcSzwNc3VE4haYkIKrP/zax0XT+stY3Fcxe5rvM3Vy/+oX/sV7qc Ye5mLzHnOUpEyHPKVMyF1BR54l1qub4K1aMTnopxBZOlil27FrLr1tYi6SmSiunK10l7OSYxBkRs AcYpznKg5Q2EbR82BRm2/gnXvj18NfPsWra9g7VC7NhAwRf24V6PXsropZjlZvZVvE5kK96MY4wi xmMqpz03i5fKvz0hF/SqM2tBm00Bj+V1opItctakxGIGeYkkGdBoFchVNur2bNGIzW1GLWDWF9DM ErSyNJAhSFCSlXMoGtPdvht4MDeR7694rLzid1HSzmJFsACAGhQl79Bo4mtCiZf9LtWg1axivevZ VBQIMIN1z8e7G9hg1iqz13MFV7sF5NgqzokyldBj8Hj55PA3eNS+TIGHJcu7jCCLWLeKqYrAleWI Wiy2TDRrK5SJRekOw78fQO2pkN8vNSQ4dAfMyTkvmjEaWv+ZAsk1wdY0H/lScst++RCih/7BzsIu VMhL7HdJ396gDNf+8ICEWu1bGE4abzlMw4YaCnPCWkYAMviY9zU4LGpaoWypC56iUQpG7ECsj8FT UgleD4bJ7M58qIx2mIxSgbIWWVxKCnfIasavEz2z1PkVlwhEGyan22zl8Mnx2FZ4M2bGPhpgRUfM pQDJChvECgyW9U+cYichbq0T+KXeTTEEczv4LqvgJIfBMg2NvXKLuygqd4hAnvBIzQp0B3Q9eemX UOFeRcmA3BgJCAxIBtSnb3saBwnEWzrvzwtOMqtDiFpDBm4KokLtIGFgLQbJO+ovoZvqKSeeZbjC 1wpYgn0CRHMklvtrDIYkzXjq++VrlZz+bpo6mbHjW3ZpI223bbY232iBu2/wz1ZnI+7mYW8Wznav S1VVZqTz7BzuvHeZPWa5/Ee3YNxX8Fi29tWqCPGVpGNcA2/GtF7zxv1wjlp5SddVG/GHMZTLLNt+ qlyo4I9d08eXocrrp3so9F947eICnkplpm+C3K59QE21bxvjF3N4UcoNZsq690SKzbtlQcBaX5R8 47LjKWmi/oBsdOms/kU3sHFo4+E0bIxzorJJmqtOHlIbIuhqtSVKeLkiAHeUT2GjxnfMh1vBEQsR iCCj6jtnBvjHib21WwkeQmSSBmyVSAbNWP1HOHj9XxYyv1dgxCgulcy7fOva0G3HXX/DtYKqvMwm Kfr6fIhTa44zla7NmBd4cDuUC5FtciaZf3SI+WKsgaDyxI2fviEfRZfvqvrtBr5Pj+nx8L5XK8vx +vh7eznn7b5UAYAAAACAgQ2GjSnt5y2jBRupCcTQnV08tfceI9Of7ZJmKqqrltteu5lW221VW2qq 2ltpbbbbbd9R8R5nLAPyUKQxsQWJFjwY8wlGPGQEr9UtPnVZD93Myyqct3UGbAOyiCmgHQkwuXJV IuBzh+DaUqi20bXtGq8dMIH0DvOkpayO1gXMII4DHLApVuGnxboEzlrLJirwd5J0ihpgUsKRIFjA 3FTNS9TsboJc9z8mRqe7EH+RCDccjLbt48/IMx7JwOGhtPftpOJStMkaog0CEqMpid2KhNPXxm2n Vd01vY8rMfbN5cSSSS4Xd3dCSd3pQsSWFtqiiqqsXc5eHldbFgsQOEl6FTF2sCTpREDpxM6Sl8JT j8ND4Lj0cWp1m+yGPgcd3dtR5RC2bXXoOUmssH36pkjISJjDrKEpGiF4hV/vLZfNn0nvb8rmgSRc ebyeOY9eFuhrzO8+UGx7GDIMQ3LSkNkPj3Y69543w2CvWghBoSCCwvxNfawvdp+vWkM5XofsfB1z 1eNzyq5faDYioYaIp/FDYioYaIpXBtfbu70cvL1fndfQu/deHzxC8Sm3mn1UjjjmJyc3a4osMMsM lspaJal6mnrSo4DD5fx0Ofw35LPTfJ3PKfkcAgAAAAAAAAAACAAAAOucAAAAAAREQgAIgQAgiAAD EyIkkIAAAIAEREgEAIAAACAAAIiZESSRBBIAAAAAAa7Xu2bhAHBkCMULhJafD6vSF73tr1+XrANy DxcSGtnTrHLul2H29GPVfUzW/xtuSEkMMCQ3eTjbQWLa3aviX1Li6r7IIANCImEaUJl3OAsFiMjA uc/GAAFCImEaaEpgLBYjIwPiko1Hnnq2ThpPa8zZMtI+Ua6ULBFl0fdE6jN0h6T0mJt1CajFCD2/ Eo1nmHh9NAYu2L8UaBkVSESRVZPUq0q0nf25/5+fBDADQCBZn2kQMx75kln01U8ca4TYlqeLTjDl DX406UIHVFxVLUs9nzWNI/U6zG8PRm1CLEfZQJZAxMyfE58iWDD5cbP91PwfR06aCvQm0CEHM/hw P1XPxZ4N4lT8b1tW2g8G6QoRQLAi5/wwKaPggVkVRtoKKxWHFGwBYZqhSp7lLgE08TQmvfO7sgd+ P0r6WTY68a8fgQ1dOSFalgiw5tsqoFhCQA0liLK4uQZmH6YcQvE3eN9w5v2+y0GoYrCZAA/me1jH yjn2iag17ndi9bnfnynKTBPsZzv31SjbTGqiuG2L0pER7/Pbv3xS2hfdlQYJorP5I2a7+X1zGCjq 9xd5cf11XLAwJ8A1Y3QeTWXNFxA7JqfnuhnJa1Y1bekhA/ZFdVgVjY7awlRipZFgYZ4SLaIKnSt6 bMk+fLkxuK87FuFrvKyeughTK058Pm9Hydfh8D32Ny64koz+eGsok3Z+GbNoc3bI+mkx1UNJKCRo hHYf2O2Ed72RrKO9OJXEHUJM0TfhD2CLmblHjUweHKrPKkLWg1q7dmHs4s5VXpMbDnLbqFyU91EY s6JdRCpcuybVoIh9js4TLycNAKvZQ16ML2Yd2rRRIjKDMUkSr7th9RnHHHMTYip1QFX2XRNq1Te/ BnTCm46Cn104yZI8FJd4u1pE/C+WJvy8ucdKp0iLEWEV05JPbplWxveYx06crQe+/nX5m+17bm58 /l5jtzgAAAACSQkkkkklUfOjYiREvMNIHl6mamZUWfBm/RexcX4ckHk7HIpSh3EhRZE3KOPRwxJA kJhKVD1kkGiINiCKGNu4TI0/5DX42cbH2jj4meJNL0PN4LXvBoWxeqnPFuSlg285ziCpbHlzxI3R hnjCj3vOdybCr4KvoGYKbbYeDhjyhWzAoM5nQ1LX0wHGQWDGIgapGek2Esp1Ut62uk0upVouPwYE eSsUxOX2DHUb9mNxA3wkFixjD1lZzS88zTm3sxShmq1VbqypJENV3FX8fZ8pCnQq0yFXhduta2GQ sXaqnJ9DvskSJRt4qU6nnPOQtortwqtrneBkGcYMJe6wpOZsA3ioiIiw03ezgnLU6+n1/hs0SKXq gYcGIxgXdFTDtQtzQDxzdLXUTgb75QzTobFNf4vRrD1HEsOA0YURHIDrV9O8DBRYTIEJcjs6ElH4 69dsXSVbmjT0Z6JkfEzlUaMwARjpxiNigH+virnwWUI2oZ3aBpCqw9+qEaipXi2tD+52e/UlB3ec a8Iw/MBcjJcsJW5Jmfh1l6g3QrqZnCprdm8bY8k8L9Hmg7DMR1LRY13TgQvApHIlBewZac433gB1 58+/y+diXmLTJt2T359UGzxjChb4GSUbsq5S2+pXGk1QfdbmYe2IbTQ0wats+7ifYuMWbw3C3lA6 6kHFbLItzdBIqRKsfmouJsa4Suz1RifChPGKI8TIjlKtcWbv/F0U9XRdD67uXg0Zzw8uVTFL9YvD vaob1uZFsnJeGwcwEkRD7EZu6+2qZaNcS5oxXMrRQZ3ENyuNY1B4+7pVE4obGavQxthxqg2zCyOt 6R+bKmxU5DjhkO5EYhciDQsCzET5rZCmO0Uh+9AeB+MLO31+fcN8seZP8yl2zMa9dkBODZh1EvZs HTKZneCmKYoQI8bkPTwzjqkzOVCcqY7D7TvueGLyqvQ1Ldb3wacOuhiAwmGIZcPJHppbpPAeDm0F zWlYoCrYIY14a76Skw/FVYvmz8uEyrjozqdWjb1uojC2XrR6Yjarg6OqVZomaq0QISSZIEJDCTCE Als8VeamoyvZt7psjr8cXi3osMRNQ61tCHyaaSAgbjwSRr0EhrWCbsojA/v8+gK5Wv079RVxa7rq c0XaxoRgaqmB5FVQOYKZZ/ZyIruJ2YG7AMQI9owPE/FAt9ZrsN/ySNlxnZsjOSswhOCbZpjRmZzC V8HVMhfaOZeSiHTRnU4ldjhRHn88lbP187cqBTso8tZGyp0hVq02kPUY+OI5fsImxx6fDpaQ9Bs8 c2XWlpMqEneQj0ouF0CZRzEkqFZRl0kKW2cl7vV0/QECZ5ow0WilVJJk7Pvvgt+dPrUl3Cb0qPis QH39Z6O3GdtvaLtECjtwV/JGJzD5yR7GreW+JPywT8s/v6YJ2oDdZKReKt3Fa4/dTqYDnHDfiuHI 0DUM0oPLf7SMaLCbpFD+LvwadGUMF8lp2c2LSqtSsCqRE8V8cmDP7sxx9fpmpbbbafUscHB4Hh5O 8FP2a2oyVbjAg2t2Cbp2M1TWMduiCUC421uF+yFNHeV6wk5Src7XTLDdfFmCdTQom55zRAriTttc pbDyRo36YZrBerPJfDG6u5ocGauXINmW9CFOaFVg93AZE7yW8PpdbaY4sTKDgOQn1S3rOdvSdvqO sb12x5PPg+m/bpqsESNbPqO3U8YFNoSI8Z5e+jzC5poUCcqD8gYptt2ijR+kdmKmCb3VtdTeakhq +OzWQmszNTGQ8MgvS7qbXDr3QhQVInoGRYsEwSNVJKezs36FIbbOosc6YUB4sxdfzJvdP0k0XNKA +o7kCHXaadG9VDjozIhdXaRBz0sWNmTpC44yvptz3hO2Ok44xKNhPtvF3Bb58yMiZiu6MBGr22zG A90WWvC+Fyvz+jN0FDNTO+3NphgP1URnQPRf9+WeMyjcxhcYcXuzs1F7ckB1noDLfVx6rq5NE4dc zKvUFk2Ji+hJknlYiFEOapkgknTsSm+MHoRpBcpx70W2+CdDZqnvyejNqyr/o1BgGX8PioGuWWNh zPnGQfWMSjQBoTAM8myagY353eje+qP8OyiSjbr1Q1kXLV4IVR9tWnreNL88xvvVHruHzfb8PRLp b0e6CkaB+62/x7Siwnky+qXFzUdDD9zPEDn+1g+7PjI63ogQhsMAeoxByFC8d29LRIJ6TaGbWGlS a9aId2HclWZy03lVvRjGHyRnRkq39c57sBzaJguZ7lUDMtCP0bYO/fmeqEram8H6POS/78Yx0ty/ wrqGvK3c2TJmHvvHar3xnzxlfNyRc1mbIO5B6bdRd4M13CjJ7zltxtYlVvtRsvW73+34VcEIaI+b fwKdc2DGbBvFgVRVYgRnOSnQvZXC3P3hqj5fgyfLlabmt2phnAyby1IFhML3n2FQbu7a+yqmqlms 4a5z+j+KXaNTHhnConaob6yKNbAH9WG2O38Ye3NMq4Rwe61R8ZCUNeCLcC8msZhDF7JDY19n0a0Q 90bvhoLEgEr4c7LMCFEIxKNRzYUNjoyDPzf3/iWVgvzE0mvcUDNakr8X2xj2991yNunrxmfB44sQ mNs+yN8PTjfSnFeQmRdmCtpjn0kZNVsoG11XajqpLKow+JgxN0u6gK74jxpzequn6dx36M8kTHPJ YY6JcAYMA8o0M7iZOqqKMIUDHyp6N6UDLaR+gn0zPDB6tJxyUDhwKyGL4toiG9bhCoP1+5yTR7yB VltptlrhBNvxojUfO7NV1lRJBYMNUho6a681dJWQz7/Ft4PvawLacfaumUhZhZjZEg4gCaOctJGu i6l117JkI0PyQLcNI16AuarThOEIOnpE553MKkf3f4cStuJS3GHW0YmvZpnaDvJ7QbSXNTgxG1WQ YAgWBBzS7K4SlbpIf3dWJHnNoosHLJosckDt68SaGnQ6gHxynRm7yPhTovzIHm2Ba5cd1C32SDkz nttDi3G65VJNraM8rOsLFrYMNWKLWGpl1ab7Eitf9Je/Fja5cvjAV37AGUDpVCs9dTor67XM0Wjn U1m3KN8KkUSHe2MxQo4woGzZPbOgsyrrPE7Uvf8O1jWHGvayPBPHVGDPqOwoLgcccUgNomKAnvx5 ZbcdJ7CYOcjnHs5VEXuozj24882xFDIfqsynbzaM1uTm2+ZwgtZTaSOjJzd5V2zeg0O79+Y493M6 Tx0uU8ea2rHv1HPwlR+mBDfuhQluTPfw6s38DCXGfXe7ye9vCENBSHtxMg6QO3Y2rLt8O7GN7+l8 FZgmGu444P4y5yKRfhPRD1A3XWFKB9x3dStSRx0KaGxLjMnUfE0B84nhrD3EFkVLNjThZNqWJghB ZtKpt6SeXgR7FkMmDVZNuTfeBQ2bNtIGm+tV9sKg6JeN04v3d1/Xh5+GIdq8XXvvjOSmrsZvo3PE jKg29VZA2VXHqcf1AqfOmXDJmx0UkCVyLDjjDPJB3qIxWLBa/WwQ98c8s7WXmrNJSYMYWm8HXeMY XWsFdsM9cVMGylwnIOmaDavNm102C1Gk1pNokIRSMBkZEwLRExY3Atg0ag6IgCgM6Bg/RAIRf9xy e30/J7fvlCmI574m56vx8Pu81KwY5R/i207ZnW2ovvW3PW2L2tmf3/6udrWvbrSUOxa02TRSUZKS m7lA7tCkhHZ8YHpIDV5w+zUajx7epiiR094sq/vn3Ktx/HR9TOc+l8gv9nvdcCSSRQzhwDfZ936T 5xiiJEn3fSdf6FA/uK2j+mgBHX5eI8mrEyOcfd334VIlFVRkpET6fj+/9fhZoqKio2G07p+Eurly 5cuWv392fj7rXVLZbLZbK6zgwd2Su+W/294w2HuzvAGwAY56I23K323Dwbd/pu5oNb9hq4f14tP8 P7vX68jx/b++7yfNw/p8P6f09X4/58fd6Du/dV7/d2+L6Nv5fx+avwz4f2+j96/p/Xzfw4Pu4f7f 7+Hv/Xl8/t4KNfj9v78ejy8HJ92rPweoLqs+avv+bver197s8O5i1j7uaezq7fw+Wezj9v8m8+oi fl/wP22tF7ZYtUhISZgiq/4sXaN+0t/g77mtbuRqbNWNWYb6Nb/m73FvfUwUCdu9n/M+DyDTHzHm ++mzwUnIC+35+aMlo7ttKSl6c0YYPn1pmCAB56MT6krz49O0hNRim1e9rwYPEGYe1WKvgNjEREKS P4/ufX17APXynKCqiImSFqIiWlBZQiSlJLh/EdtNgCIHbVkov5lSp2JK4vhVVVX8wfUq7DJMKVk4 P8XHReIemHqCMO7tLJgecPr+b4hiJsPR3j6/q2iIojsBPzsZtp+kNfcbv7VzsNdm6RGW2b8Iljpb mFiLGQJfyH8TM/LZD7vXS09FqkVwGo4yIPrQj1wC8Q0GQuxeBRUPx/qPt05SH9H30KlVQQ/CSfs8 qcAB/j/lH6Yn3xa+o/bPD1ybX1+PfVvgNH5rF3BIyMhAlAVEPy/llvjFIHQMBnIXdSeaavU/3n4v xPyhsZ+n90Ld0hq32YHbqazns2V6YQg7vCEIQhCDu8IQg7vO1RDHO4fw/DV6Gk3ztqbBtVGgIXXZ m8lcMPQEFG4p1WRjF2L5vEjKEIONTRRjqlj7Cio21uOhYw5nxSSShnwsKRJJJOVU7SU46u/GnGKq onsOy6wPUHsD2B2jkSBp1JTB6Va9TwvCJq1PIY8iF4wTnhAHHHAHcEIgCbbn37TG/LLGSTJJadWo ta1s5PfVy5nD8fGvF+r7uMtvvxfDxi+GcZdir+23tn1tPiDbl1Vqo216mrlrx7nrvHLMtXOnwW30 mZltlMmnHMa6CBSYYnjCBs2bNmdqiZlotzZoQhCRAjGLu88AbtO03BwszOaAkBK5qx/w6fUmGzt3 dDfb19J5stSwfPDebuBa1jbWua1rm+0KtO3SzjiBBWzulxCeDR3OXiLi223Nalk2ZkmXO3IPftgH GwpZtUAhCEGTuYHRy828aC6kDYa3CsQyxTDhMsNRvHkeR5HqDB5syZGZIJIO+got3HCOvy0YMGrr rsjEpLDwjY5bcN1AYBgGAYBeGIYBpDFqg0GgyHYNBoNBoMoec7a1rPs4baafRkFpT1BJSmFIYwyD IwRghfM0UhSlHO9jteLx545yuyGJvDmMni2OBwOBhgcMTE7zJkzhW8L3q+IYXVrKywX1jUx2OL+g QT4/ueMcuXLbjjnnOcc85znPHqXcuTbQmhfSqJEUkVAFpqbU1fX8h27dtmuVKuXNt8gJTMSJgFZt HleaXlfRdd3x/DrQX3Rd5cvu8IsyvCL+zuv38u48aMbb78X3PIznOc5zZPRSbugPMMdPZ6On5BP6 upgN7qH4uly6Mv2jOLoizadeswGJB21u0kgMzXzfsTxyHr9NG0BJJAatPlPXCpmZv6nYzbg6C4rE arV3uozUHkJHgi5xnIWnI33ez8Tj8UfXXl9v261iHebzjltbFuMzWM061bA8W39alVbKo7tTry3V T4K/uOQqMnqyNdmhTVBYbgNwgP4F+xX8fq1v2EatJBW1Ftv1a2a3TJJEcbbptjU0YGaIGo2xYtyX VLRtumpowIAoSYbEREVVHRgYYUkhMjBgJMz/ktyEP6CKEVYKApHaFFyVYisAag1AlQARJM3NKrZX UqUtV+1lWW2mmMJIFMDZgpq4aSEEDDETgkkV5JQpYUIOTVsisgc2uWiIom4bnLnLkIcIACOcLjkH OccggIPBuXRTcksZRlllKJLNyBgirBREFkWQIMZw2RQIyFKAQRC0uMrjEpSyoKFalDSBQFFIpBYx GounGKxFaKixjaDZqWxWKxoxtBFFFYAVFWCkrKkYZMsCGCkZy27MERERNRQBkghDYyUSAO9UTjjW RFdNa1rWtVbS2lVKRBBKi0UWKLaKW0tpbS0oKd2uruWtySNjbEaorRogIm1d9zXERootii2DImG6 u7lWtVriuGFKONcYZQjEEbKAA51zrQBlcRMQSly2VpbWYTLRoWltxsV0VxdNqN2qgDbRV3c2NyUG QEIiKRDRsKW0/sgB+UGkA8Dzwr8Z+83eqSS44j+9V/dAVAkRRJAIQBE/+2DIIoSLYQAboeA9NKAg UQhaWQtKQl5X/iZJMZ/z7xyFj5f7/9Ggn3hOEDhCGKqDEGl/0oSaRyw0MhRZ/o0YKsJ9r/Df2zJc Q63ZwuqbSvxK7kxot6x7Ja6W+ByVLN7K81lGyJNaJJ/chUAILEIID2QRL6Ps8uMGta7VGpUktKVD KfuvQBUAPAqlCkgOeDcSA+9u4O3s/Z9vR4u0f1+2n9v6bsGb2eA5Fij0Sb3iGkyYPi/Guqyz3/Vo +j+74/44fZ9n93z/N+/92j+e9bH7rfvxw/X2ft/T+W79/7av7fos+TTu+3t8Wz7vd+/Xs4Px6+T6 uPh+fm+7w9P5+L4vL5vz8fn9Xq9X5V1930efz73B5erq4/RxfHy+nw+rZ4OHu8vzfv5OPzdvb2+j 0fF3PN2dvt5pnsGBvnQJMzN4GQwEP27DRE/QZA3YNEJ1f7kP1H7MjDWkaYoWaCNkgjx77apKEog5 Kc5xJEQbxJj4/j+ssiwyTH0IPx/1pz/Fa3+lb1rXhKI2i/jKaX73Suk/h3qWhRZo/Y7EVQgSA+jn 6u2QHwPv7aeD38fB7Y5jlVEI/9VsD6apfwKQXg8M4q5V1+myPM0KYkTshFWVY0/Om9xewbxGq06p +y3QfcicYmEVAnWc383h0h/n+Zr1wK8tMlQHKQpFlpaDMyBjhEqFEtoDri93lKQ0wrVQ6IofvhU/ tW75Ja9x5FgpddbhPb8NkNkHnIuZgp1evTuLmkY8NRX9Mhj5NucIEPqHrFVQZ8vx/Q2+jRAm05H3 6fPECxj0N9WJ6QaEIrCcjayyCFD9H4b0XWq/MW/DrfdaotFZEgCdgQQYxqYl+0h5iOw2trdcrDVq lwS0Q5kUDJhIYtP6w43m3hQwrvaMx4jiqjDveB5O/fjwwn25Oh9jOr7/dEoG+X1SKbdiWMLDUEhJ /axs/tREhIUO3+R7ncx/adZMsZK7ESXPJpscX0EO2AceNJRIb65Zq+/K9lOaMk7hr0kQ5Ki+DIEY 7QlI0hN9RFq0eJQgOzB3n9vgiNAQwg4igm0skAM0Hoi7zPzACfqCAu3h3RWlllN2cltMkoqL9KX6 ytuMWUKWxKizsfeHBFCnfhQkVO0ROukDUcuW24C6RD9x/V13oa0aQqPuj8noqQf1QOEYkHUGRCKn 1j7eHs+mSIPGMZUbJeaLF1JhA5OT08vASGcTHL+DjREaaZsNZ/r0JQEgbtFI83YwKVLyszTUGx6S ioQFARrKRIjAUPiQvtaB39/8s7tEVNEBPbPCJYiDk+QCvGj5+Rzz3ops+r6vqrK08DO9O8iicZxO aG75u/Cc4/FEgkQRD8ymHjntrKIEo/e803RCMKP8KePqu1lcs5eXrrotMDEk0adn56Vn6/9hYMXb vNA5s7k52/hV7PuZrIwzHxgtVFmndbqpGz17adeahArmEumRw/F1+4alnfGvh6O5jlljmwKVmG85 xwnwfxntokKZzqsN778IEb3KxfCeafp/7uPlPZ0vdf2aPMpkq3sjDr0/h8KY0dyFN6hXG7dG/A8E yOfu5dkLPpqVyVtRXbTVHTnhZZnxs3+xyEm9JWb+rnOno7kfwDfYp6WqprfxT6Iasct6JGVkAmhu DS8s4DdFrgB34eCCPs8HYSNczyCYNUHYK5MnO2l2j+MCjUHGv4iQ5TX3Ust5jNlti1kNhDXh9bij +569hU4+BEI8A7+75eRudCTI2l5wcXl+P6O0KRJHcPCdNUu9J4wZpkwOwLfC3V8Dt7bs8/EcYePw Gpirvnibw0DTmN5BBhTDLSTgbtdXPCGbvtRPdzdgjyW7teAvCzDMbjmdosakMjSIdm7mYzAgQvIH oOM/1cEO8+j1LxLijvb92wJ77gtLaWbznSdGi6P3amNvCzTnwc9WXcexD9BYd0/Fjk5+mEtYAw1H jMQ2E8zB6TipaP2UHjGfj9MfD3nd/OC1arl8iHsw83IBRu/k7P1fj42+ESRHucuePuNQQay0PfxX 9ypochU7B4B4Wx5ZnnXsszcnPq9GUe7VSPJob9L1qgr134iUiwlG2EDll71DYp27NnbouJ1Nxn6e vcf6o07qobtx2m48VzH0P5Prjy8ndTv7pzecIFHm3zDf5Cesvq8fJubXyMwAd3hc9x3Ow6s4/WvY AR0xNZ5NRfwuSlZDkOMS6K4+jksqj8GG9h0FJX9E4JV2QlDNSpnQsFb0Z+W+nTFg9DwDwnX0TJkz tfciCjJNWXWny+oz/dxfX68J2eaPcyn0uDc58nlSW31y6j8jeaqPvTjy9Sx9fDyDzLYKTju7Q75v g9XTmipxjzPD6ONyfvt0+iXceUPciXVdVh9HzUYzk8JrTlJcL6YUyguKfRvbUUMGz111VUa/iXor 4Up2F0lbabaiwufdN0qnTsjvR+Ep80FxqXLNnoMpfOqYejlz6st/ReiXiz+3yzxu0b/r17aN/K2G yz+HDM49ElQznz0gZR4VfGzVtXBxfr8S1U5Lg1a65l+zDV9XPLP9PLuFqjX4JUXRhwwI7NmmN78D Zkw6pOkZZFKPnwrOq3DGr6ow0KOzEDbmOPT635uj3P80IZ5/CVnZ3e3WcxlOGB8UndccC3lcvjQu T0mXDR3+9z3c1ldhE3nYIjEGYQ7nIQGOWEOLi5Zg3JCMBqbNZwAKtT3JZrzzHl5u5bVRt4+544Nk w0xqIQZzyKHj+FuyQctQ++q2mghPuZ6NcUW1TlwJiDDPzdG7KeFYZY317t/YQOHvHYtFVN3G0MYT VTZx9PfonfYXryvqPGeC4spatsRCWbot6Jxjnj4VKbwhGGztrXhEcnLfRBb6nl84nihBs18LY8JO Gvf8CDDSp1Tn8dd769SzJjxrwZu9FbwSoClTp8adIfprKGg4bBPDMieLv1DrP4KCoGY+aJJl6cNr /L8tNYyD6IuRG35l0gB9AQH/hZDfVgGysGMiKTTWqLGiq5LcsrGqwtTWWW2xixbWZtFaVkowYslt VIZol1h+hpUqRX/ulRJBF0hSMFgoTkMgFYJEPT2YQylUX+uC98DPE/T9dOjTX5P3e7Z/rgCWiF8A okhJ3qyTo/8paX/UWRebjNqySaYoB2SC54COiADX9ejVr14Kg7IKyCm6L7AQYDxIgQypULsS0dMW lVIiSSTxQhURPD0g9eTDEc/VoDYrIAf6fxEPy/MGH5uf5EgSbjQdQuSUSX4nbJy4rYEwWjXWIilk QFzdV5tfs6+Ov4nm6ly6/IZO1zabn8dOsA/z9EXW7ydFq/ymxDM0h+aIBsGwiJmM/qlX+x60Oglh wbak2baTGDuxVq9XTq/d319dMZMzli9Eh3JIsLlW1sapVwYqqoSuBR623fC7OsTbrVnJW5s7iaGL FImGihxwuycTYnPd4hnOhUFBLcefCJeHgtk7OykmaVFCnHHUYuldauomZQ1tVR47eYZcsEWMszlt q90XdlgZiMhkMsbIP5kkF8iGZ2on3Pxh4DYQFHxELEAIQg7j8dfs/ccteveegoswV7iXBTfA3MXE oUMhIJnq/Sfz8ewPzP9D5tca41PV3+3qpvRVQkctm4Fbb9keveEbDp/1PCX+7mcPm4Zap63FdW9H o/F3+X89dc5eHhaaU9IAA2Gch0OucaZYZXOAulvpu1rHLaqo9a3PE7h2+L3uW+O16t6ERERERERE RFIlq14fPtr1ait37Vb5UCZoySGAgVMCY3cQ2TJYKHMyAkm1gL3k7/zfR9B9/yDqgre9IYEPch3m ND5vJ+Wss9W8f94x9vQltjzLcvgsUJLpw6In48VR3Nc4upVxnyU0PdX4K5nXefjQ9GMzq6/wD7Py /Z4NZCiqux07wE701QnKjIjSSekRNx02rRbLs7mNB+sXvTD0RMotkyqBOITvVP60r5ZNiWjOYpOO URciPxMcS7OdvFzs5p/D3QYOeEodf4OxuRIpQ6Jj95W/Y7xhkogoEUWEIQ66d/4v1zOVgw3e6ulN 6F0I9C5Rd1EFAUUQUBRRBQERXHwcMCpcaSqTwT9Amr89kJJJ16E3XZYVEEkAB2+7ejouwAEPX3Xp 9Po69KHOelePPoyV79HTqpe7fGjW7FNGlVVVba9uE155mMfbXuy8tLTggr08vy/Y/ON/XgoWggCu zpff1vKnXOO1szziHDKmArCgJESLmti71UpeMqAcRVyEAyCCgFIIZ+RJI9EDPdRQyEDJ6AuxBOos HzBa15Kf4Ij+6Lg5vlLWJ7dDR73Rv+HzFV0ntMRVXgPNJB3BKkkAAAAIc3Lraq0+9fm/Jfv7upm1 KvjpqaJrb73Lbhk2rrF0CBKjQgwgqSArVBZanN9R0KspSx8PRcjmXBYalnXNzxnE8eOHjdLbcRUK CCTBYwXVy5cuXLmQWk0I2bZv2TsDQQfHwMw3g/M1UR7fFzfu1i0apXeedlNYjs7/PtDbtv6x7YBm j2w74oW2dRr1+zzafD588XbR15j1Kn0n8/UMxPDyeZ7uuvpd1EhRrS1zw2T1e2coyn1acqUkmEIY NGiko0mpI9V6MyKleIW02VVfHhddVhhRXXXN3d3d3eVtyRNPggopeOWSvwwrxWVcMaa420XCug9e WONl+CWN8ZJQhVbfdAh7cgXyQeAkhgkZW3Z6rFja1JlTfTlhnyzU2RV99llllFdddcX2245d/XqO ORsaORJMklpd5q+9TB3B167Zt1654p8cbb76CZhQsjFjExMTEvMTEsLSL2mJbKOMY1R31tjntatu bzixY87Wz01tURgSvTbGN5moiNVyhTOmrKvNlhmzYXjlxaXl5WUFRUXl5cXF5gYYYYYYYYYYYYYY YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZjMmbQIdXoZoO7QQmRjmzPmnmzZscccccbrrrrrrrs 2bDDDDDC66mBEcmGATE72YNIxAueiOOONNGONuN+F5XaS2zM14N9zVxEQ222g72Zrty3miZ691rX 5Yxgm3aTJXV4zXbvnB27a232bxtttOtaznK379kEOb454tfdRQjGSLNER667I0Lk6tqxxo0Mmz6G uaVqDPFqWuZy7v1d5i22lut1wuS5LoQSUsaLmYIMGxJyW6wq2Wxcya2WIoopREwQNyoIP9n3DFSq kI53eDOOW8+BWX+Ix5ddLBvBwMeKNoJCPXvabjLB67GMEwJBeeTZ3dYmAXi8d5m8xSHYzI8s6Ekk gs5gtuDOmbBGKYz4sxp1AkI1iZHmiwcvPelzc/s/UlCMZRSZoxSdnd4JLO3UBzY8PTx6urRroVE9 VE41USlm2IBtBnv9ipzK9kkuLeZhm2m0d2BCkkkRIjBI4J5A7g+6HHZ05zJjnhvXt/tnTgJmP0Fm 98bXFnY851ETThzi75hVNijHjb2eOoGYPGCkyA9gNEAzdXmGeuwZJ2l6fL5eS88nG5n45HIzQ4Be 3K8s9j8LMMqMfPVyU/M0hMMtGHgxDtKPpgc7bDC6bb47QXHToe9G3cavGy8HUeDrtrupMIR9EZKe rV4aObW3NaX/dYURNvthuW4H5H8/C2erRTpS4nj6LOCDVUslsqzGM4aMrSdmSWyZx0lWU3FDAnFN UttT0iU4PAf+bsWkqoYYHGTaZIdfQV2Wlw7IboCgbbVRKL+PPVx2k7nq5olSoxlZnx+rnNDaKgob zkTpbU7BnZmLsZ5SORCqfKvgHGtVGjQeeOmjCXHlPMXXw4ggJhs7g0bGMZ8Ahscd+/VdOvh34Q+a ihrqYpp5zdhCHRUaeCCVsZNU+e1lSME4aTIfs7x5hXj6TQbtb+z+EwTZ0PzPMwxFQJM4oEowGogS NxHdq7ptZqpVZbdXd0cmyPx3HKVruSZogexrSHca/dk9K0mvOXlpX3C04KaOHnGKWvZCbrbOs6tt wLtS0yyA12m/lMai+xHO1FfrI/C819zooI93U2S3Vn3c6FlB+a33h34D9kMQor7MnwH0r0atQ9b5 He7yyy2yyy2yyy2iimiimiin6ABJ1d6WRKJSVjZQSiUKwCf1A6p4BcQkaIIbxqiFAl5+P8cMESv6 jIUfIxBIME7AbAQRfhAIQAgRVin0g0AFBIqGJ+uKEAgAQIECKAEgJQDiAOIB+F/h1aNhCQ1g2SnS SdGHdirITwbVLastqlpSv61y+SRMiZEyJrxq4N+pXOEoUn4RCT4Y+tVssKq3p5n6AyED+MBPYEnc dYEoCJEIgkEsPJUzGbEA6j9Uy2I6icYorZ29wqelpIaf0fV5dA/ShdKH2rDjZvSw/OHUIAfpiCUj FEgp7wUHr9A5hsQYFHFCI+BilLdVfclq1zauXfrmTWS0qWZLv2AXpguWbkzkG3+HDhUqI7S0MBrB tEREADOxQBZZwelaPizmUJJvPQmEGBSG0GhHO3dEzpJO5PAPHYXcvBwQag1pkN47rubKEM90ZS6n t5347uNzml9Nvhr15X5hDu7H0BnfElgVs+Slbtbk2ky0aY2+yRg+q2jzivfa+NZTPg9M7qDdDXTr Xqq3RspfVJWF168rdEbcnkyO/7tMy/gojRjNzw4NlQwShorqBU+Tn5kolUxaKqeymm+D1E7H3JvF z7oYIjGNFpllXxqcp3P384z3NWD2Qsymz1fIbj7PUOEsz+TotFL85eK5ek6wcJDlgcqXOwV4tVKh r1ydL7TuJ3ClANicNjE6WxwTboXAsKGgM9jUe6Axhz+2i+WD6JLE878xb8tlbM9BiPwUzaA0hgMq vEVzSS4Fu8UY4exlHZ1kY+s/P5n7LW61VVVVVVrW4fSHhfpNM1RkiomWQRlzG3Lgh7u7u1PA6e2R RTjjjWoqi/fvsgbVL2Uw/LnOPHGGYdFTlXsvjbs/fdewCD1rPq7/PzmZnjzL898FVVWlJsbPcRCT Y2cKwvYlVJtRYqixVFiqb4Dpy7+ho6Bve9mzWqoosuw1e97ly3h3dOcU351TdV6T49e+xEWtaxMz a1lrHQ1nxi9h7+ydtu9nLblpGsYTbY2m2zs4g4ENVj3ZpxzPili0JXbxulDQbTe12rRRRojGMYxj Gq449dXZZR0iZZBExLmCFExK7D5dZ379ty5o9TPPz2NjpxxbDyb+fauueu+VpHozQ6b0/Leq7c06 8jin6j1djra3Wqqqbqq1r1Yny5IYsUaIqJlkFy4Y0uXO+yw9fu17oqixVPZozIqixVFiqLFU5XqM z288HV1qm/8UCSE+FkCT2AdyT+cm/P+6TRP6f6397IqIojn+XMMBC/pn9eo6tKX/sT+ZMq/5cm+j OeN2c+N48qDrDhy2U5ZvNGZZkcOOjtw2juI/qMrrV3TUTk85vNzZt0hKbB3Mu9o3FlqQQ02JaiFL bAJHqacotGInMBasmS+7zfEoCW5cWiCCbuqgzmCaLtwYmpsOZIBRZytIsXN24XegZrWktht5GlDX AqglQ/m4mH6dFDlMnPDOSXW8mELoS0HLf/PJKmcZeLA0MnPktAUxk/0WzkRohWJSpTNjH3am6YG7 j3zXsTpt/vD7mTFAxZZPwxZs8BfoQP2f7HVYgv3i/fQlVRURFB0h/u5PsYHk4zkk4gntZZWQ3tOp tdkWcM0gPVfz2tjQos4FiENy1ZotVZ+6rGzC5eBaY9big82/iWnOoARClUprUNx3wlEl7KP7PstI BqybuiBjzpI9aBCGstVquRUNJ38aGMlH6bAcSuLf6bhQUb7rzmh+p2ZnFmHQZAWsf2NtzTRVgHAw IVPQjlOTNCJRKaRTm8+yDpJyGyxjanXaDte4DDdhLpXxBEdIlqxqQ+2ATUk1aZvRnBrF/rb2HIZE RvKfGWhaGIb+C2WjKyQ85zc76N8Gcmjc8f+YX9LO7xR3D/YgOQU8vVCHrpQH2kllRYPn67U6jxzB +9mK6NNIPeHtKW3wrXs2g+bWTZJsghMqPooSqapyQfX7UqB7Uevu2zDyYOE9cTMzKdtgiKQ6JJMh z5t5/FTebUTa2Wov9MQw+S3rTRYcP73pG1BthBAYa82K7RLhqWBM1gwN6R7qryV1WVK0lqU4ENJD NxdNX7KzlgD1coSEl3DQhIF27Qf2PuvbFReE2WxCw5xfGLKac1vfH7r5Uus1iozCUe+HGjFDay4z bNRmFa44qolNfwlZdasEGHWGYCYsWc6rVRiEFpm8zOV+Zl1DMvTcUSYaMus6lFp1N2Xq96LtU0gB JbXmr8aPfiMYtfFr3vVr3pXWh4nGMYdsLcMznOd86wzY/oN/eTWS4b771bYtNr2sX0SDnNGSrsfm E2DcBQEUjZeZPOZ25effH9756qqrjdb7wDhjG4UQiDZCZJpaI7HSRBMZTSdZowVdWbmZvVSmLKim GXFySUXOci4ixRw9V1XiSiQjQ7vFgLEwUISpbjhASSEvD/H7PDxfZ/ZPq/Z4boej0R7bfbWuvZGd oiSSZJOb2/DOeu278ZvV5XXHnlKLZSuQTZyDbwcBgXqHYN6MGL6XrYWsWt7LDYxitYtJTGFUVSV0 kx0UVEEXsFUVERVFVXqKJJY2OqURtLm+rXYZ8Qdgc5JDg4tg0FjQaNtaNWy2LQVLS2759vHGw1xi 4fBu831XkU6ByDpEWoFQZAkJFSRSoMkwVIC5663k9NMa7buDgsrpvo4MZBddez4MNikKCxQPQDPx ePlozlsA4Hl39+QfSYVaUtLVNyR0OKqvN5YcI60b1c1maLrVmndc1xkkEwlAgIkkgkkk44iL2ERE REQERqlbEtXORuW27t12t487gAAAAFVrtv5fo49vL8vc2ABfRT0ohbtQOHu0wYstALq7pgXHdQBZ i1BQNoARFGAOAlKt2JstU7i0pavDZGAHUSQGQjUWIiIWxsXLbmpWbaVRFkXaIscdNQwE3EAIkA8L mvmZkQ+BquSUVAQMiAjjl5eqa3usDPFgHVESLCMc4sV0xzHTKRN8KEiYwJVGts8cTxdXWCAwmuSB w10jaUWZ/xsat1lUmBloy06ranBVz56Rzu+NKgukZQ6KWoYw4WIVE2lUxWiaOlLbpnFlQOIZvffM ckcg5hINkAXyRFfKRRoihCmhJEQIZKQwBtwu4UddFNm1F8REcN6vwQVnl2xMGnTVVAVI4BetJtMP e1tX5fwUinaoxchtYFDqSfthtBDIdDQG6Re3xQJYhGKMajITX0+qzmEDF/gAblLKVSypZVb4NVr0 VObMyvrraQBRGRADeJw6t8lmPX8fm+OfSh69nfAAaJk1Qa3LzemrZeWv8RPn/StczUo+ELfu+b+6 0lf4fFiHxn3phAkRhFPoq7hX05hKxjY2MTGz+Z1QlTbElTreANOcoqTObWDV1q4Zf7ckzNZNzKoT j4/79cuKiV67tzU764vrOIWYu4ylxogB5tIldwwCP25SRKSM1mBIs7O4561IbspFIsFgMVAWKQT+ 7F0iW5qhM1Sk3FIVFJzyWlwximEUBbNGrx7vP5/Hu7111ytsy5kJzOVsqFDkyKCqqw3Eg0BxwABx xxzlquNUzUAOOOOAABqjSkmpKtv1lUlW8GmatmXR25w5ywMiPHjWTCUbTbXDIcMXbSjug6xEkSmC v8K5EmVMg3c46VcxZJCiSWTTUDhhUiwWc/97AwGKAJCCCBIqokIKJgVSG6IvoX5vn+j8q+53V+v9 7fi/V52vv79NtEQBVoxECGpxSEPwGqRYJpBRoFRVBF1NxEqGkpKuhtcwxWVTTURKkmmExdFrUA47 ZHqKvZXeHx/fGGFTzEISS6zNKqSVE/C4VFgWzK8AtvrMikGPffO/5LMlGv555MHnac80bHPPb32q eETgoQhCTQrMgp42AUfqODij2bbBRf106+02cSfF4Wtr0YVRK59t1q9N8+Bx6ZNrtPrPKpqT59HV gvqAa5YN9DON5j0H1GwiB6SoKQtoaZSTZ3nNyRCmU1YY77G00hrKs3Dv0RiYOqH5CbNAkGgRvuFy qY7wQeqEuBfTEAPRD0yfxZsL2hShY0m2HD/e5mtyfCjLiJZV1zouZhrkXFcjF8ex4ORV8pVdmJHA 8fxphI8FxFwvo/vWXS7fGLqDkvsSF6e3PM/AWE1xZ0Ided3u6RV3v7XEvklpZjMPfcH8Q+OSaWY8 R6iDX2+p4cDUn/jaxSb97MFxf238Vvu5zQie5437a4DQVFD2okhODltHSQlcMy1D5fJGqXE5kIS4 DCeaMHSBSiOzkRzTrDW9MZuib45gc3dIu77CXVA8y2yzlBMKAINw33JRqrEwrIhSzEUZrjPpg6jI vXl4H3lW1wg+V3ZnTsHaKrrhHauOXwQYurEJg9g22nYt6tUZCgdb6qCqqElMteqAqnvik3zdJToI moM6Xo+KJ5Cnlh8x/MLEyZFIatRSniH8Hk/McAbTus9Z1ndld+ao7QyHdFMDkAA9gQQ0R8FCu59A 6cuRWySZP88+qvVZZDMZOpl4AKlnWJNhorIZpVjJAJHz9nCcQan2xHtpAQxNosT5D7UESZ96nrzf 1pdDY8srrim+ezaZJ1DR7IWagVN4+0h9qI5WTuO12kA0GVZAJwjsd20fIJhEkeXIoor4lRSoiUI9 3u+Wj8tj9EzuczwkQkmChpiJmiyDrN4efE9Kvbz4B3HO+w7s9kQh3WAs2BikGzFQqK31yjvVoT+N T8UufCidLyqQUESRSOBcEGC286e+VgfP7snPiwuWo5/RAXPuhHvIwjLoXwjTkS8wJAY95+lWGgV9 L1jmYSzjmJ0noPQFyYUpmAzc3wvkvvHeULxOwXD5bBgwrq96LSWtJ+hNB2734tzxRxVS19oy29lB DQT5hoBxhLRxDcPlmcZmoyIYxryoPmOhtsq2EF8fgj7J3+y0SFiZkohk/eiUV+dkBNQeb+dYMrya HnZ2crz3roNgQUSAhpcLJJOdm0smZPmRBx27GgDuy5w56ICIp3KKNGeBX5YClvBvrWS9ldNXTJTY u7OlETIplttttKqqKuFrT4Lbo+8hg9RvhVk+e+z7904JRFiLeCpLnd+DW89tu1128OoDiAdWA+Rd l2VOG92loVt0+ga+P69jvXvyXjn4viWMt4cUg8TPuuc2TwlxE753hztXB8OLH7dbhvVVG5vCMKYR WAwyQmtbGXay85lP18R0pYfc87hxHHD0ZwJHBY+aezWdg2ic7bQ5XQ6Aji/Bm/HaNnXAcTkYHzcT egdwvJON9Y6vngFhnDNg2arbG2tpyC/Ow4GmuOkpDTD5yvSVXQ5lPi3vTXSdpBkh6ETDoYSKgfOQ f86BxmBrWtqcfQfB80XW//o7coyUq2U1FvBFmLxwQqknK851ea/fmnrxC9ZUSPBQKJAChbUyZqb6 10261Mslo8/77zbz3vKceHVCVEyuwssAc7IFnnvKqvPcOzNUsLib32lJ5z4z40MvdM6R6mdAvvzz vaUGbEPRdtYqtxyimgls9x5UPrNXkA1006gIjSRrobfCi1hiPNB6uVRgCRAH7kWI95kBNI7WQR72 RvQsbiNobznTgtLiBIVzBRb0FCafa55dHq4e+KPjCnJDOFcboDHd4gcHHce8vowxTDx8UMNBRCya u/E5FRhnNWzehpkB4DMcPeBhrtnKqCIEuiXhJL0+WY808gQkyGEV/zshUoad+kq4CXw+8blLSy4H tu2m3TtSVFQKK2YZf7pnhatlvHgCarCesPpjltkJJ8yXmfn7FfH2ig7tc7UfHbSr3/hsdJ09PTJK KgUV4oPpnZ4MGDDblXtD+MK1hsd/wHpZVRbEuCEed+zyvI4beGlR41eWio5Boo+/u8/t+N0eNWtv NPooKqtFnZRZC0l/eruvsbggWkr0pTYHIOsA4+8Q14bngjmYYiUpUcKV8ktMuGhKIqLrUn1+/w2H 3SBykJFIVGQGQWRUhBNdii4QIxsw0oWABANnZsfO/RwH4+g/i7CaQAugpqNEAIkVgSRSRNu45TXg eju17fDN0584Ylweia5WpAkhFZTBjaax2kmSCVa2qFabxM3efwBzVnfyDcPpsWVlazmcfvGI6vp5 MeSWTBBCjM8wJK6NIfX3X8DJHvt53pz95MKO283VF9/yq62vU2sya9MBJWhu6Ulvp1YO7UoHTJJb enpwbZ0qVI1Jz8+FkneDRz+JtXi1a/lbibbsvvvppSwNbF6MtXXr0vHzflNTzWU3eCERBDGmDZDn Ob4oeXM8saD8igrWNZinpzJhAO9XtFF4JnBlsIccnCDkNEHQ5IC+++t3WEjls95OjLa1nTrRwHVn uYIlknsLa1nTrCElkaAFF+uLxRj3SVXXKbQhHXt152mwHIaA6tIN8WiIo7UHuaMwceneccRObJBC xL97rLEHgcSIjCIkJ8m7zcAwVvNb6kBo0zjq34VeFungYZYSF7JAaRZDMwYMUrWRJZnq48uY9VPZ x8bY/0ovh7o+kx3b46JZEZYIliJl4nkj60vr1lHWHPA1WByxItFozhDrIWYamZ0zcsccq8o0MHu5 JbFHxj6J1MR9KYUN06jSy9SuExB24iuZvj2CXmHhEPL3efV4y9cvKZGihts1K2LS54KgefPqrVqu 8FMcznga1xskYu9ttUbWJm68jXLy3dVyfcgtVqKOhEHcxoaHecb+zdH0Hetsb7Q2EM2a7mfbLtoK 5U3BDWBiMxUIjemKs9q+32h7OoxmFIcsiUiRJQhykC1LBx0IcQ4JCVtF1tYQlnq8/XJj2Gpp7NaD NWVfmYlmMZaqn1sWtEoxx0HVE7Ojv49+8rNgivrgJlMxv1BwLXRmC2974ZGMyfGcBxc2jlaLMjdH 8oN5rHZDTEO3Pr5O53jvfM1tJVkzo2IwhH80HIM2jfpZ8SitJJVwXOMDpo3waj8pxK0UCfB0dwvb 341j3EE3X7ax4RtKrHhgcV96VUSRP7oEAEMSFgQaaQB8HnFKLXKKCWhxN0o+SXf4P5B8mTJ6tBgK JJnWxtVUI7R9JRHsrmDgj6U0QTS+xNF9It+2t/Dz+Xaf78EFhI9XnlihqdzfrBHW8kxUk2gg5pKF FoUYzJNwEHzMkmBYJtEd9D+yChzReYUtKWklKjaW0AWEhInYernwnHn3Z1DtcLE90o/HhVegPhNJ /X6w8TkUGQ9kkzU/hNuqTGg2uSYayHla1RE/YfOxknkEQZ90R4nPWTme6MOPVvbks+xKURFFFFO0 I3Zg3I1nIVD0t3KvId+7g4H3vBgUwosDPyJCASSSZI5vpXpc52uwABgAduu32J9f3PI89evdu047 rzDMwYFDWRkkiRiIqqlMeDzGaImEV5ILIVXfmyDb246dCOfssNtgxg06enniD5/glwU7RHQQhbnD 2enHCCCw9fMDICwdJmYzEjHeZ6TRNd5pjk7yC0kndE/DKrPRNEe3CwvSCDgggbGxsbOsYBfTsu7d t97WiSDd/4bBsvG/DFTfCaw36669ftAZAEkVkEfmy4fVt+o/f+2mSSRx/z82buL/UV9ujWpsj/Xp w0lOD2Qzyow9tFCVjN+lE6ctZbDZDdJ9Ynec4Pr4iNNOyZRQ6qrfXn1a074Q/X36f8fv6vWVko/B 432urd3gzZs2nMbafpg/DY8CS+XjwhjQ/GUxr9KdS2TmhZjkbNZRVQhWFPFTw5haI2O/DBHInony TlyPN6aUoVGOOGFwTpFGPN849tNxVbfzV5GfXBkkoQhBuNRfRUGPB5fK6Euvh6Ol3vhCEIQg+/WV +/EMTDLPPba769XU8Ya1vyUVeH03Bdje8DeDQaQ7f5dm3axHpqMuvVqhp5+LjnHsejZv5zBs4kg0 6aXIcj/4CbuqI2+3xVSP72oJo6naEX4vwRMKuN5ScdB4eH8OLqn3/kLAjTIfOZ/gQbDb0KiJtR6k Lu0W007TMUwiZS7U3eXMsLyUBFLjoiqiKfs1ipqFTKF3XSYozTutph9nHOvOs1bVDxk4OB1egXDI URFOeXx+jjLfs6VgpDYarINaiSNXoe1MwEGGP6p7v+rzHFEpuYyglVmvlF2R2/S7mvY5CfNopxPk umLdyZ746Ajv2cd/JvPbmqYYO3O+U/68lq6LqGGX2XwePszD0W66ItKu0lQ9Uv5Rnb1jNQS00aeC WrZohfthXmV6JsCpvgiVtS2QfVNJhF72sWbZ+ZxPS1CaZLHsp2emnv8L2D7Pree/ZuVP8dpPDmeN wMti6GXxtdCCyVXeXAV/B9WZF1ypTqS66jzYskk/CBwhUYMAeaCEgh3Y5SRNnZz44iZYdsMjRr8t 8IZYP8BY+WuBo9Dtlxa64pUZjPD1IoWrlctzvVVUvUtXg2KFXnr5uvcY0Fu+Rz8sst5dPidjgzvS m7ibi43YNL8N+9W82s05R8MIbUU9pUVd4oxjHq0/RwbFRv6fPKjkwjKO/ohGnj0dUqvLv9s+S7q5 e00fx28qz827e362HIZlABO7kHTsD6RIdMqp3JSlzoJfcyHtcHdpy7r/k1fpHhnHYOfJc/XWseCH auHYnTZ5j0UsFqYvQEUWceYqlIg1HIO2k8f8JW0d2Gfjj0oZpIB++e6GXociwyTa3fF7IE7sKjMt YkP4OdD3vRowhNsOKfVheqz7AepkWH34oCi0sDZ7mSmMC+feN9RbRea4dzd0PTy0Zo3QqlLj4uqB lXajSm5UwYIB79Ievbs7dnd0ca4lx+7wx0YYi2xgcNs+GzgnKa4IEgXYqSDpInOn1lGXCr4AJ5Yo GbxpX1UV2+qjurvmuWh5pqmCjyPp5dcLMK4cymqybZi1zxxu57TGcC53UyQGp4IqhKMqXbsRjNUb 1dc25xA6GQmc7g4260cA6RhyYlAM8WiA1C0efTHPn6sJLDRs1XKj4/CwEtcqR3N+LyDvQu17JbK+ DT6t6S7FKBg+eN1bOi1UGTmJM8nPMgSuHLOKGit1oNuFJPqrKO5VPKsrz221lGV9XSsd06GK0cCM X9WRsJFwqk2mms8JGjYKl4Nu2OxjOuX40GXvTjZ9sEDWWaEhx5rNpNVEjn5mmQFtczHcPZK2fyb8 uMHRB9mNBnjUC8qHGdx+Esmx+jVOiezdCosCVPYgGMiz5kgcvJogJMTtp0a9RwQgqJTogciYkmDB GhNxI+qXTfvVeauPjylh79oxl1JjSkIM2RKKR273dFcNlUQM+hdBu27zh/BDCyH0H+bJESIQgMgx YQYqkjJAhGT3j8aOQWBBvo/lsJIIJf2L/G02bmr/VOTYi1/kmv8y1uNasVIH9bCV4pDR0zMGU0Zp 1pVIKIhSkmpKGTnX4vzu/bbL8Lll6CnOmjP4cw3FtaT8zVYq7bqx7NZlnPk9mb3S22pyE6azWscc OmjMxLaKCJbdN1oxiriGtdqpOJZP1FO3jcMe4pYSFP7vyZBH+q02cUlPAoB03XVgM1LDogGAdCrK zqCwlFJMLQMIKpRpRMkKhYWVVQd3AmrZANbzDjw/v6bYyqaMVZCQQ2IISIDUAWQd0CoIhtIFF3Si DBmhhvOhmDlZVXhSK55MSD08g9f9HxYicxEEZEQwH/YOhDWXWo0oAd52na6nbcwEwgiBwFVYRBFf koDjPZ/0Vz+3+4fqH4dv8n7PwHdk9/v+nLu0En7KKKgVDD5Jj49ZE6nrBXcm3bu1obdOmyDmLy4D upP2kFf1deDRTWKSABIqE6H2J6f7kN8EO/jX4jNATfNaUPM+nkiIkaCHYP40Io8sw+5b1ZEJGQk3 SSSX8qQhFYkSMIgwd+vU4/MrYVD6yf1GK/X/ScDBWKLRYgb0+lcOFrkYSBBHcmD4MXrRevciFI7C 7w7JYhtcTAlqWpcChUvsE2gJ0OHPk73zLzKGbhdSlMhOSGX5lu/Zjrj1euQoZOpRQupuNq2LdfIH YHMb1YN3PzGJuVM5pELqZttumSSTAVNAMyS4dcSEmPL4qRwDUYJ+nKVeis+y5Dean8oB+qo5jq59 xzoRYdQUMUgQM0HwxHLmyRjUYqr1enlbpWKi0eavg+S14a2QH3oEJQhpr6o43xGeOO2L0G4wOCjy 1aQKY2CUwIue2a6SEpHxIPBOiaAWAu8SKVSkX/0tf6TBwvfJsEqqrCjAF0EEIf5trVFJDmMOODVp avybFBRTtNI/ZCQMswiHSD3qvM5nkIQ4BKUmWvPRbwDx3/gMEwEAyT8uvI5IXyqumcZMuamkSs0q YLTtLTwOPoiELH0BHUIfpKKILnYL1ZXsBVCevjxUKeqZofgzV6BvAOJL5rS1dUCwV0BNFxVWgULF bI1bJQsVpPHpPLs5LgQMTYHjDBOoQ/lYFdAdH+0GEEkAhBMEz8JOw0EJ5vZZnJCZQS1YAJGEYqJC IkIxCMQN2DeUi5V/X4e5jO8KoTYfY1ZH1bEVzR3dOyt7EjKhNmVWJ39BRaLIhB8WrwrrSzNidVu8 CW33LXVy2TWmaK/bqy8uvMjV1tKtb8mLUUWiiijRRFYqNo1Go2NQUWv6jXERjRgsBQcFFHiJYgM/ rL7ulFywJgVdv/fEQKB/vKRxRU8nMIo7CQnMQxQ7hLhrDLmOKincQDOwFKIhCClQZFRfAzDnB4kG hYQKKShqjfGoYlZU/ZkETBsyEEcKFPsAQkvFt33TvxS7GGAm2jBQm+bEmSlCycCOdhNROyFtT4x5 h2nqjA9QaFMjPJqIUOosFWlOlEHXz5tUQZma/B5znOIAcdrjZJrLjEZmYLr4vy3VLfgfPBjYIO7h C70L8YjJIbAaPRoFIb2bSAADw8el2kqbKlq5qucAL3VSQJAngyKUGqx0lgWoPAiOOKVYjRHcUVrt GC8QLB7IgXZlAoREREZ29KRq0kPECdAobmt2YELi2QnpDRwkw+AOab808OnRVV70tyHdCbhAEKHA DCYJ2WID17RdEwV1VO6RAMh06LTGBEkRkCBFIAWRgiAUxABdus1sZBoj+8LcFO6g/f/1FGCvULAU HSptBsgWdqLTZ4Isjo8juncogbW3sprSblMW2CULFtZgK566PQMO1CjgabQbfZbi9b1FI3kPd6fQ 2jR9Ab7h3JJgxWPWhIRjK7MTmTlNUZlW75uWw4PHlRRRTCEJ5q8jMDNgZ5MG+3h8L8poYDAbK/FZ 3fOLOiGgDevjnnHeZr6pYwjhvRTNygKHUEl0xEpFehth6nMWMMurWBdb4wYnfBUTbeSQloHuU8wp pVz/piIpURkQXBiPzhjGIiMDTNlTAA/rOAEQgFGjgYsT2gdMYwqnTPeVe395ndcpbW/CYW5mWFQQ QlbbRtti9+UNwMaGlEREeHEleNEVyEY0N7UGESh3uhcM+gSubZRxIBvDiJPKrYxBMC5UrcOR49cq 1m29wCgAIPgt7vXtb5+QD8fnACEBznEYIUGqEhIjHW9fXLXS9BMhZIghIFOXNVEgqo5D3Ho7TRTx JMpAZnHotpbS1rzNzad05G5Ms5F1AMDTu3vL7fhg+C+Q0Q8CCQgkI4jUTkwZuQZjvQHe/j6wfvw5 uqz2Od2qitkN1oHPU7PBV49yeBnK0C+ZkO95L0UzUjz2X03R8Ivv4F2lcDWWJG3lBMRAxh+ivwDs n1uJHoYXMaLMOUFFGVH2EF4m58QDcdpNO9oTWgsW3nFQ5TYfGDNofaA6ZIZEEQQionQv8ICASAAF pomBznAgSPBh+ZIjcID4NNHozJQu6qQf9kBD6385czkFX4nSfC+b0HoBa9B1KJlCAGcIhMwORVnu o1+EOeWtWYLF/U3uFqpCAezgFD6+c8/rkspQa82CaU+U/dLw2ssyiIUSxaiQHl3DeI6NHCSmkqqq qAMkuSy0fab+gpyKF3C8oI+HRXRDSO3DhJEkkSSRCSWlqYSAHJCIBGLAjAZHuFug2HSJoRD4T15/ dkHdNnZDrBrsDHHBqqlErPStCbxI7hgwP5LVE7bp09Kwx8+AvEc5u8bJpVkSEeUFKIKs1p+RoTPA TLlnC9pJAtrmptrKVqu2t219Or8KQDm/1MFGGrouNLw4KBbd9upoh5kzZRyWFJIrVq3tW1moiKWZ 5agFm9H3nfSUQVkJVNEA6ZqQbSN6KkjKoKipmMhTWH47Pdzu70ookIh6pIoDStBVQkEQxiIVBAwS En3KW5g/bkgaYCssZdUH/Ka0OoBVYSpyKSyfEhQARMPtUplFSQKitooCqqeFKgcCslPf7/a9/ln1 RNq9r885sxxGsHqPM9yElugUr7S2hHuQvlmcr1mTpXzjE24JkRbidfz43DI9RghnUzKqXvm9ApYN 0SRAhAAjBYRYnlnnTd3Nf/ExcrmSKgHA9W5zlQ6bjTpkmSBO5xu7rnSKMR9TjrnMRjEXS4htJSQA +NgQMwOGVIoaeN0cqoriYilA1Q41WJFMZrLtqsKrkLQkKTgTPIyRfdgjfpOQFHb5AFVxtxPOtlVg iiwiSTID+Lu0WlLbAt7a5coFttwq4ePyPQz5QOZ7jcm2STiQ94nUbUOgH1793AkqVKhK1SRQmSAH Uq7c9zVjoAzCvCSC8SIGBKgRiYw5N7ntpX1R3M/K+FGwvI7p8lV9xLu7OB+fi25NNglbcQgff4GN DUR4MAkRBiME0pJE5h17l3+X8AV9d73+zj2Fa9fbFwsjG1amjxPGvHKSsCxh73CIkN96o3i+Ax8J j2uHDJWyCrYUoStTu4cO7dXSSaXmd/zAv8ZSFraMeCiPCbV18MYfKOlota+nqzURoqgooozGjE9Y hQrVVkHY8veKh2YCQxEL7CYicyVFCRAiQIxjg+n0ixBIMRR5c5qEzUiisPLCaV5qyTiQ7DsIwJ1P tXVD3SbjdKwVYCv2juDn1RGKqKs7h7T6fEJgZb1yCBwZ0yzHCklVkkZcoYQ3ge9JsTYj7olBrF7O rqvCQh99yfBLTgYlIGSAYg4JTGAQ0Xxm84Y7gIkGCMAQDDCJQMEtZZKVyE4LG+oOxBMx1EORtiKm jYm9awS5chlttgFtt57nV4+tb2YIEkhw3uO0StgwnjI7Q7WqqbBaD09Xu6Z2ta11NZmmta6Ww2no JA/CJA/Xn9qF/oXmAZPBndRYMdIMad2N+t3z6juUqC1LXOqB/g90XPpZyNZiIgDiSa8sITdjmxQa ABdboLGD6wgEBAuxQ6giLvN7DCGwgAetOaeHtGFgEDofXeDlRRDrVGUlBNkQ9oHEDGBIAsNKPGLY GDubOnv5rX7a279jbrauApJM9La1urBGfRSUwgrBiSB1oShyQp9wHzB9aMglQcKVCYHK2gQiv4QB kGQ063fu/Iy7W7xd6pIlXqvfeC2hiXglVa+22z9Cyfk4vYBnMAL9RtQd6PpOGCPvKJEeQcwJPn4X GRZU/CZJgd82zOT8IxEREREKhRzRA+CG2SBuskKFQPSUSlQJoCkhJOxgHFCirULIAj4IMEskAT6w IJ9FUC2Aw2g7/dWbMEs8CVno/HXhMdqqWoiy/00Ev3o5fKDdzrYRNArv31VUY1ajZkBOmDx+TqqA RCPgRVQlSQBsJYeXlwdE90ic+Z9tigsVkCRk+zhWfyN+se8Q4b0aPMpdQhqjaBR+55U+DFwRydcP p9UDQbJ65SF5W28gDeJBhwMAWJObW+hil94fL7Mn+uQ0+JvN5EURkfTOFmrS0DgJFmuqE3ohkoc8 VNaxT7BqTFXFT1AaN6AXUutIjIWkYgwRAOtAi0gQAdhfeT1K88YQQ6JjBz89eJ40A4xgiyMighBW Jy89vuCID1FSQklZHvXxgQgLxClKRdgbnAXwxH5ogGO4yBd4wAxSuIlkCSLRwqhvhS0rJS2KeS8k doS7r1oxAGMYxjGMYxjGMYyg0AIiSCSAIYBBEgAAADCZABEMAIGDMYxjGADGMYxaQ8PC3c1Pi1XY ZM37lq5SXGaFCjEpJYHsgY6hoZYGCWUAlgMWEnlpWmIQWKGfkqK5aVTADAIxWMQgsRMFhCzXv57c lLjvGqt9gdEIiR0YO+3UCr5w05mTT7/ARJoUpXlWPAO4LoKchskaBl2iQwMMm+T/AmihCPUe8Pcz 3RtKhi3+gjpYtPdjJKwwkdHKmjrKDE7g7jSKXEygaLVaGWKoUBdARAWfAgEgVEUgxnfT4Rw+1x3Y aEk5GIyD+s1UL4EVb/JsqWI2BiyNJB6LhTeEZGIt41GMyBFDP6RziAefKMCy2eruK+xB9XoI4+ou NO4vmoWlYLMYMQkN3fKvmqrvVbW3q28vCm0pDsJAQDIqMQgBG1QAghCVNSqStalTVKtyttnNq1Qg sCk1hQOLkRwF+c+BlKvE2Lh3Cr3XbhBmYyUsJ5bjQ3q+o/CVswrn8/aeOFpPuVPwrK0/kO4JjCwh 87HIvJhtt9h9S+n0ORiue4s9gWM9ezRH8YxjG2xwvQ9rRBZyMK0GJECqMkRURLAQ8vL09/aei3Le M4LJ4dW8nqa7w4QENRDvUyKmhSmA8iDxCPKynaFmfLIKKAsihAWMXIqlYL7KRRkBVgqFCEUIi81Y 2tWmVsljbRttS1yVbiuVmBpRTMaLlclXKAIUREgQEHBnRoUN6+nwHvNwq5QK98tJrAhCBhuBrT42 iVB+RII9ZCSSEIQ3k0bhwPSoJ3/EhALbgTMhrUKLc2dAqWPRu+fHrFDLPsiyJC+RnCHmbWu7fJq2 t5W7vgAB6bWcAJ27NaCd6hw6cBSO9dCcKSwn2QLtoGQyJHxQ1XWzMBiRNJCihiQpIpUeWk2wiOxk gALRIREQMAYIGrITBcWLAIMIoA7d8JzoE8UgZDzFRlVaw1tyT4HDc7EAUFPGOKZY59k+dhqDA3Ox dA1E48bOWM1wwhXKioryA7D2gLNPkfWvW7w5EEZlou6e4JLo+XlP4KBEU+jKqnbpACPFXory28rX llqWzWgAAAADbJJqUrabZqaVBFEZBBIMTgDjb4HlqjACCICGiDq1y1SiukdykYAGuIWHnz96yd9r YTiAT1lfV6yw4HH3fGQiKgopFk42xwLHWHqGH0Q5sNIIVJA3eD6MUG1oYM/bMwfDSvCqvbS3jXhd tV1TzI1SRKqQQQ2yj5zfhALUUIhoRAlkNAd5iyIKAl0CBx50JIE1NCSQ1lUgh26lKqZ6L1dW/QhE Ev1bBst7XrlyF5oSc1vY2tc8J1lVBUQkCQNfVn36h3a9IdTkWRzsRWFkp2N9W0RN8JJbSvNTRoMo xN5tRsGXUt7qHcssCbO+AvvEF74hm+oQKaPMzmQZJIF55KQgFKwAEenyd/Z31eMYwZ8vhiw+wxDr yZHe6MTBFTmTv4M33C2OiD8flBztEbsxz6/EEgXzFGbPGKbjtNFIgVKm4iogoiI69kkHn1epQi1t avjEYRjOu/jkCHBva929+8/KfJUTKGWvq7/T3a3UO5Kcr95Yp9koWFGKQULAQeRt3LRuXlrgNcgM 2kYAglsqAi4yBgDkDds0N4sLrZZoUBFFR0n8mshMFmmRRRcgm+IbzLpwKfNCBcL4nl2d+DF78lhI JkA2PW0mcc8JA7VewGi6SKhgWCT0kAJGEe4DAzCZ1sq0CTEe04zcejInJe8Td4Fr4yTgPAYDsRuE iBZ7d5YJpmSs+hCPeRsV66KA5CRQpOoBk3bMi+Z7SegDoAauWhWchTEpekdoebrevewhoA9Ota9X XRBeG7+/aaMhvmJISIQkhO4E5jGbVdChoepxykJJDId2hoxe+zCB4MUXKnPQNOXYR8goeWKMYgQg dMXnIB0RAzACBu5hhz89wbemMYYJ+bvy3VBWwwh3GHdJJBXkc7QIMpjxvu33xD3mJbgiHP85sHmg ra7iLTy6RU9KhYzlsbGvnXh3gyhevtSkF0AoWeBzfEl6+xbatmTwIeqScSEmpIWDxwttWmQOSGX2 pEsH1ByCg7w52u5ETZTohpBQAfcid+Q7GG5CdIHoT4cN9L6sVEVUTz5Mfpbcm56/HmvVavO3WtXW lutOtLlVlsgjoMRA5vmg8zl5d0MnsH0OMQLEO7Lsdhho0SHSr8oZrMAjyB0wsFgYRM9T8AFvtNmK i/upRih3p2EPk5HMnDoDrxctuxsslVER1JiR748U0jb2+RjDbbbbbTTAAAfRd/x3z82u7ukA9F6K 7+3br3xutYSBx80mbVVzIRGCgsCEPZJbjcrK1zZNNMspEialptqU1sstlNUtcwa0VsyKnNacsWSt rlwSbSUjBFRjJCllYWQgoWSjSgUNBmO6YSEJJncMuBBhGgY0R5R2mw7UU7DZTRtJLPpKEQrNaYaA 8StPMQKGYECquwrQiaILDZAh4qgGQNRpAW6hnUO/IOyBMxQqYOV9VFQi1BnaexgXRkDsDuM0Ik4L StNiH2IcERGAwRGEQFEAsyB8J4gUlpPZD0bYqZjnbIa8pJeIVeQteDenHrWQNmK6yxOmdCd9Bblv Lr616uvMUV2WioqKj6pJLRSSSSElZx2h8wB71wGyzkdOe+QR+N/r939KidNVBB4DwoaMZQ/vn776 TSHxerY6b8jhsahfuZPANDszllr1IrsoNUT+qKN4GNM/fbNmaJc7jtlp1aLHlQzMFXZo/l/tS8Xf bj/4fgfHtk35/9bhbXz/5eBR9Yg+CZveqPrVP+fs/X9Xfo/2f611Vf5b9v/T61g3+/jYKJuBQaF+ zluoP8z/Gjt+orOT9K4Jrf5H1PUvdz/+Tnt0rnFUn5k+fuW2HMB6eM7G/4pndNe/i8Mrf2rCYvxQ yA/3I2Jt+X8Wv9jfOEtlGp2rHPgP8y5nNBYm8uvk3x/Z+w45wnKf+sP5pPIgfLQUMwkJhIeBV+E4 Vu6VtFwwZ0agoKKNTmr5Vb1T/2/4ToX1/IZKDvHgPY9UA0cJyZ3fHjUGgmEIFJNpFBmgDbKsz9Ju bq15pa4OVBlW8vtl742m+RKx3Odj7w/ZMNqQ4odgkaF0ggwOZPqxsLjH8psYe0/B9f9UqVCpI6XH t5QbfKmooKHd06SdCgMGgEBKgWVf87fFX+rq8lH9YPLg4N7qrz5WwssrrrrrorqppsgPC+Mirx2x qhRTrHD44jbWc5tl5zBEYf76KrhvciNuHM0cO1sY1m/Gs1njjbba+c8axjGKxw9ts5znfn4H+EOQ jkhkh/tX/W4oKOPIE+p70fUkYyai5rTSYfATEoAIAQCG9eQeJvQwLkCAEAIa2N3FgUOnHF1o4Xdl ZBfmjAhGDBkjIAkQEPE7e/h7844tJQEiAsl0auEkLkACEEIjESBEWEUerAN5mxwDjM0OHA4cDhxP CRyAv1HQpQUdRsvhtjmRsuWCrZiPsD7eGCbbey4GHALvQdkB2BuTrjSAO+AqyIJwMuUk4jpzEEeB oiOAaISVnZ6A/o7rctHEr4emUo6J1DA1IG94cISiUzf3oaBkDoQbzFY0J39y0Ia2wim+Y6hToSZ6 AMQVVB7gNTK+3khISBQcdZvxAkScO0QkbhJyxsH0Dqn2TyL0/6DcBFXuMiHoNpzzftC3uL5HoiIj zmb6L5QJhmRLRLQYUKNR4JwCI9U5QhDMfSlV+59lbrlfv+kKaoBghTIIREIHVu4858U83rFK231+ /lt+Dlne1rfD9WdczjeuGtb0vG7t3wQ55edvLnmYu8eeuTp5tca41zi8avO3nbl2Y8c3XNtpyd63 vRh4nmcvRHC9/o8rVba2SyUBqUWyUBoFaW9h3QuR0P0EDwmsNbSulTiB1hrPBV3H6jfnP1HQJ4DH XR2k4poEBrZbSpUWSwlCgekOqgYbAoePW+trLb7/et0+tR6SAdXcSdsOIG146dhsSmqpKqmo0QIR HZzSAYYwYiNBugSFa4dPp0gEEssFXHrRCvTZ7CAOYdvMNMuAC/SlEXIMhUe6WstHF4e6zjdTXb+d LeNraMNBKa4HUQ+5DVCNSYoEgPCrKeufFs9iq7NzAt9YdpDs7R7lkLOrFcIjSAyFEB4rXXzIjGuz jQ4Jjqg8EFt+en4IS6iBirO2wMUQ0du3MXTuAFbEmBoCJcw52bfCBbAdgRwEIXGdaBuCIBksoyq0 oJREq0aUtW2JVOQOOtKj41ZRfVASaqRTa7tuySSVsYQIbbLaVKiydvZ20pgQ0XNDLRNTYAhnPUJv 6gasHn6DEDSLAN2U1aebCKpIpzFBrIHA0ZzehIw1hvBMVMU1peim1UlVTUaIEIuKjLCx71Dmo2kB e6Alra1481xTVV9fq35Eb6cm5yuZu3kBCgE9vt+LnO3or1at77b2VcEAQ3D0ICGyaBiHhPSUA4DH kQSIySWAo3oGLi5aMwbc48A2BwYCpBjYCEWN2DY2JsvwDY8Jbo5eXHGTTMfNsIgESUwbLX7RA4cY PE2BTVnGO4PYd7UdirwAOHC+Rnc4bDNhhUzByR/3kKA+sR7fpJCQkIfsRql/qIMkYf400exTJPhR 9QEQnz4hT+QI2A5AvKEhGA2j8qrqgDxXUXy2cOBjzo2IgYa2ouj9CvKGFP6rFl4VoqRmaQNer4/1 yRg6XaK3F9IXzQEig0EYkjl670Xsr0V6K6vKOerUWg4iQ4M3Jq2LuMNNBSf2uXKqGPT+bnMRKBE+ GP8vLwhzEzyQHBg5B2FS6jUhzBksIhP3hOQiGTJv+nPke+EhVV/YdpshzrtrWKSWYbD9ZIarbwdm nUA589k7/5co3dRt1hIEYw4mbcVoQMQLCCUGoeL5hHljRgwgbwbTm/3ee1/wVVXZd6KyiaoBgYue gUouikIL9PXpx17IwvJbZDwQxsIsefqyF53Mf8TZCbmpjKLHy6PmcgDoHJpNWhNLuMuonHEdQOzu b1If2HOmmSCmAkDEDLeyWQOkQnXBYeUkkpRURc6sEZN99MhDAZeSZzt20nJJIzU4lGsEigcBpYC6 Y25Ei6LEJDA6VZVyDYayLcEiBXoy5CR6L23qVLbvr2bmsqFolhbQtpbTmsSYhKwMIYiItEojawAs kGIktV5TpyhKQOwmzBAOB8eIpIALRBCwfDSruRtHLRrDlkDrRs7uqZ4Zs6HaCaXwiXz3CyBXSMLs bDpdy+90DJlmkSOAwZbYmNoeYcDOkJpNBp4ycs/PF4pwCtDrQscfGzARgu1Y6WLutCFaJiLv18ST gJK57hUQtgGQQDiaF0tuJJCXeuwuAxd6SJ4VMdyIB5OY7+KfaaUZIT7x0DbIbl4LRRUR4jKpaMgh wYBZJrKTAiQSCIhqgWocicyMjCMZBEIJzOE5dRtF7g4m55cciVJW9QOkMPNiX5iSQkkJJCSv4aXs zETRmKVIm8Q3osWMYQYxNJZtKpSra9NrXWvZ3rnPIdpYdG7v2E3K+czKhfA5q7SDd3v4ldu0/lp7 t9aHrTqhYhkOvWYG0AKRIVrJ/s1Oo2fzrz0+SHKpR/OzETV7TUWsV3/v9hOP0FqJzP7WJUI0UpIa pXfg12hoBp2xhpUY6TqZF28dOZLqgbHd4t9f2yb66dXUMSloidIyj494y4dnTMFNBaYZPFGe38R9 GkmiHL8x9H60Rj5CUFtaQOJgnknlN17CFoac1HE3/7+sHTsNArCCHWaOlHmidrkIf46afilxIMSE Mu54QYwksP2oFr8qqqqrAr07GRD1kU23bVzevk6DRoqSRyPkg0uw800T2GqLoiUTGqWfcSFCkAd6 +BD2sfbLkSowRE0mYGnRGsyWOIOnbRaFp4F4fofx7cJNdroPYVQsUm96t0nG85pKcgaMhQRQKRgf zoFB4DsvQzGLU7TqkgqgCXvmHAdYdqfnG+/1w2kPvAoC4aC6qCQAz8vhVy7fpkiJ1jfUIiGD1wNd kPi7qn5+kf/IgWxN3qLZteDCBUJvjayQnkSjaEaHavDVGLtxBgm6TbKqIB2V3sUbGw2Ng6YvDLMl qSC5CckI+a1kkv8sFtEFmXH+2Ci6hcZAvzYc+NRMa1dR3QN6/OZxnOcEMdHu4fe2qvjLHPCZPBN4 gMQfzZvr3lQnAA9IRfwykiQkWSCJCK96sFVdufA9Z20nFYf0Fq6rlSDbDvwuoNSGDltJfcfgGcHQ hA5CxftWqsgBLJQQg++AF3Sp6XJEoT0n5asW7HFMQO6KfgsUbA27RsjkdsZ6Aq0iG49BsR+QJdPV mpxCUF0Sg6Q4IaTQr07VALJBhvJcqDle0DMBGO5f+H83vmr3zJ3ydIJAvcyYkMYUZBjKUgqgwMbp nOXe7s8lQDJhh9vw/yWT8YUJ3unnuhgcjUj+a25DdddZAiSDhArnd4M8tDjkjvyKCoH5CC3YlpWG aYwXsEV9YxVWOW1WXpW1zxtzq77fZYqLJVBIkJuR/i6jO5VwwjCJAjziafp3jdhUyOZTgBlEoyYf b3mQFFkQ2QGkuhxaudQB/MwBoN8ZB5C0CHjzsCQGSRgKertLsg+DLvY76A0ASGUwJPXBFVMgntdJ CJOqBa0Kbsl2vAN2aaZcrUGGDS0MDSZKDdGZqHYjgFNT162vu3nmwqkpMpK82+GlLfBrwgvuWBej o2BiuweJELSqQJAkU6l+EgzUorPdmzNjo0dsUxUCLWHYgasaNt1IXIrrrSmaC7EITJvZ/ym8HnCt MIw/ahAFFYiToK69WNier6fponp90hyPusHNa+OvWbLAc8sWuCmSz40D4Gfvn7nInEE7bm0pziik 89ca0qIO7Br3Hi+btapoHwsO+i259V/V9xmoPiP3I9cAg6AC8A/BoDp/vPf1S4SjGpySKO6KXIhI mR0laJF86HKAFk7I74AatU+/LSCjUE6aLxLkhjehcJEDmckEsdslBp1NAXmiL7SAyIKdfYQiQiwi EKkixo3wPcpzZ1zqjUrWtSqJ2jCFCEopAqgLAumjErZgOritjN+vITIA3bQoSzhhN4GoaEUID9Hp CJH0RcBmSB38ykfjF4xyBzqWX55JjsPKNHYITR0rdPQcLFKC0Qgv7BBDETuEH7ymiZdhDXIPBUeX UbQkIZk58MteDRgXMAuRVBGJygeIgoPi7LqrRC0IwPIIEtCIfbDEO1QOOotiawQ7Nke6N1BbkiS4 EfwbCXvAwNe6WwlEgEerTm7D7qaNKaHREzVIhVbWCVAQzFWrATzXe4qzP5e+aH01QyP9hrNsHzZ6 5uk40Uqp3LQBs1nbEhU3+yk9/ze89P5iF2/M+9iYzpv4c9/WqQZDtMn98MuIucoGUxhsVOkBqAgk 78FfrC1EXVqqqj89v1H8Xt+j6rcwmZmQ8niAG97tttttuy1VVda49/6OZ6+lQSEFAzMPKX88rJ1b 3PbdXONt37boEhmPEU1JBih6HVi16VQ1VFVQDkgBqqhjElIhFI92ttpXq+xBCEO17pLu9Fvz7Wm1 oZ05kySQSJtTZy5qK6NC87VsX5FCSUBfDY25LjeIhuwX0u8giD4+noMPlLbduM3zQMeIjAK81CUx fccS3mAPz/Rqth4SXzE9amIjcxiSor54es9EkIVJIq21UWpba1rWNtWtEFFWttttVVtpbVSW2tGt trBWLRt+XUhFixCEAKKqStspsiIiIiIiIiImwBWsiIiJpEUUUUYF+7wFOHck7w6TBPeL4no9ZiCY i7xhyPLx7T682LGmraGqlQqmvotovGDCmFJa9a+QRDOKWxMVA8+qQFatEyWC3VMcQAydsM+TkHSV FAhJIIwoZDOmqlktkYMqxxMQyGqFwsguqxpokyBZFplMlJMCBhMFGmGCIHGHri2FjDCKYBQhpLTI oM2bIRuGRDqQTz/Rq1VNSu99zYYsLbVs3cDUqjqF6ogHL1WtkIPPAQLUurQsEJPV+xKFkBIqKoib KAsaaPIBfi94TfICiySxhKKIsBiClhSoqwokDgSluK7zUyYLgUuRKAh0ooGG0sGeuHn+AoccrDeU KnBYTlETuajieVmhmIMknwcrEE9af5vwtlphkVXywVkzHQg4hiY5rcLHZ8X56t2knSSHEIA9gxDC JgkDwNJVgYkYOcCqITUlB8H0UCF8PChtQy5oaboXY6F1IInM/CynWd4vqHqNBjjBZJghU0i2MjON ZF5I3sWrR8XWHWB083i9yd7AsVh0j4pMtkq0yX03u3qXjt4d/eyXnZS25LRa4QumulrG6Vt8/o+n d2r6b+bG24MO0HJ39w/9UE5xULEnc98hgskX/Nj2gZr5U/Lhf2mFkYmv67goPIfsZiLqHVvLbooZ kRzGmONNdnZs93gnp9pQN9Keme2Rz5tceFlR+n45HB6oZ4ScqeX15ia/OZSHDQ8ddYpF2Id6hsGs e7F0S8sgMRhyg+RISNDtxJB2GjFYbLSsmBBn3E1wtXqwq6ajtraNy7KtIpAYa01vpNNExYEdyNGE BEeRqzkAKLuk3cCQqjdmZlmmREFhihA1qBo1JKhK7EgFNw4ps44cmuJAxk4hoo7OAqFG4TUIBZZQ oi7S4ymrwmIIaCzdKQWRYPF04CwTiWQ4TInbB8PTw8ok2EtL7/B+RqHogTjflo2bqplu4jDELNoB I0mp0Zw75sfqzVmMY3hAn3NNwlpYAk70kJmqhtVzNcbOi4dSG56RgSvVIGooyYApr7O56X1j78RD 73mZM0pCJE6gKzBq3JT38+WTGYN46eC9UURMaBtGmBkidj3byqqqCylPtpDkTX3/rZSx8fT5/BvW ta66PVoTum+F+qgzc17y9Sif2JtHhCAcZiWCJwA1EhGhqRW1bSNKrBi997QymD1RXsNwd6c4be/b fk30JX0CUL0P4kiTZE7v3H4yYdj7TuNKqqqr37O45duLSeCAS7pnNtvdpsbGwhtqSxW2uwHtFQgo QYIbIiyCJmTfuSjuKKH1XMMcjctyQInIgiQYFIY+T4YDnQkd4Y/N+AqofCKCtgv7x+2gODLkJCRg MIlg3lCmQzew0kNe8zNtxzGmDEJQhjtJ6HPBBt1ACBLRemi7F99kKnChGIBAVPA1Dcq9+KrQsvYc UbGkd98VXWAFQKYSSj2wJnCCBFwA3F6Xo50soqxNlSlRUhScRN/Trg6pp95MiwMNGBjz+oLLF3xC QHMK0g/EGUd1O8jCMRERERF+fyuXy9ut1k0QSEhnBg2JvQ59JnV9rEGo92228ulVSFVwLRXsQ6hp VYLy4x6zYqnN3ISS5JU+Wdpwb9l7snSGKgqgq2BLRSz1iNktNIlYTP28d+ucoiyyjg2QT02vxkQg 2gGZ88d8V2huOMKsD9ViSdx1Y/NmRx3krLIwosKvlPyaqtyQZsQa5CI5bWPjH39ZEkGE/0dMwB2M vnSQ7EgTkkBYKpIoTJoYLa9xgQUUtjtMCoIUQCtpzJgchmJcm5EBX9e1wwGkDwgCIMJjUmMtDl5d OGQAOWPz2K9d0GsEqBuQi6xTlkrfI16swxRUYLFEGMTRxJTuOfLjiRJqw21wE2yDU5HQSF7rQXW5 paiWIwC45kkjuVsQoCKhEJIc6UW84tIhFdK0LFHEkkJES4tAIkVUq0IYtAaHNLUhOpQoLhYyJsNI IvAdDOz5lF8u0WJL3UkmObJFt/RE765wHbXSTlF8rwIgLiqZQc6Ny9guqN3HQQqqoeZgF0fVZ3Ze jbMItvOYdLHFto7rCoZyhBD4hEDMRrRRPFmSm1a8b5ZBZicwBLFypBOeDEz2qHvA5NVrdpN84DWd OyDYQVxRSC0S4sUjQ+GiTe5xiOAxfZLRoJfDsByhGjULga5M5s4avIzdQ7Kh3xIy7N9FHbsatz40 a3jkYvsQyAfNrLRli0+p2sTz1C6Ro7IK12GQWHA0MN6dIclHMZkGC5scBjujBh8Ex3IH12jaWjbC fZll153MsAZvAjXcl0iB8WYsdNkSq5QOAuZcY7b30+rLDvvGUG/CNdZJ6EX68995tfKB5xREo2v2 ZVuZxfMUamtkguNF3HqMHVNckvhdV06REEREMcQckbrJc4/NVzLzPdSjn4gTJtIplwI0NIU95kV2 VZoqHWJWUMdxKMTCbxh4xvQyzasUxshq3XcqCCORqN0CG+N9vyeXn+ImVzeMRGTHkZAPJoyiE7i8 qL8+I0dWY0Tzg9NNMNDVeBiWr4UKZcuoFnau9pWt4ZrGdhcXrfGJhHGdkRl308GVbZUSLCMNI4yy 5b8xubLcEHjr0oK5S1xFFiI3p8vh+/fHX6/6FAD/MQgQkNYGc+DaH2Rz7331ZX8ILPtU13k5u4ky 51lzpXQdwFlVHhj9YIeEldCsShvnJhKqQKSmQjJsZFyi/oKF4stY0GSalaFayWEYz8YJqvlBKbQI iKGMFByTUO0TEIW9PswF0YT1cP5XSyQYEIRimHLFiHn/RC4nLYIFI70MijMuWg7/q3C9zQwu8unH PH/byim4HdH707jXlYAcrBDblIWhtq6Kpojn+DKC1uuftxYyPmjCqKKX4JjE2Axe5gFgbIhwNgzh uOcreLCVuxdA7kqkAmj04qhopdZCTBxGYiX0yX4SgNdSpQ0kr1WJcSodr2JdcA73U4yI1qaeewG9 C2QgZIYoflohFDTBKWksCcDlxPwzgplvQWRCCQF6QgSUEAAEwKKDeaELISLoIqRoKFtwaBeyBICj eKDzwMC3Ye3fhmkscA1JgBTVikE+pp5HEKBJw94RyHVLcTWioG89uW3JtOETVCjB57m80jMkjJII ZDIF6AG6c01bAMCuh7Zb5c+O15lMn5ie6FH2zZxJDDPqSIZxMmbWQuqFNjch5leEUO8U7eJI4Gup EfLfg2AbhBleG0TNGA/GCwiF7AJ+KHL/Bgf2q2huNCB7IPNLOhT6CyFOaQouNzG2gAVOZFP6WnqU CCKmd/m0EPzmCdsyZOKT3NCeJC58tYvLMtNMM1ZoyhbpK5MIymofuFYKFM3fDuQUxNoLskWQkdiG zqUDUDXSyJM6yFDJOBy276iS1vAbMwUAHs80XGKZCb44391p2sLxbZG5KaG40BCJHwsp/Cfbpka7 hzENl3v+DZrVNlLM3i71Kze8kw2WyaYt02FuGQzMMNGUNRBW2a4M0ynBucJpN0paU4n4N6NG7/AN FwtFpghzMWaHJzBCsRBytjzMOjZOesznJcoKFhoLhVmyE3YGVT/0UPcsbJtn5x5zyhDj0E53Fpq/ SqvsKMCVJg6fnfLhJJTLVWhaq8HE7JgdRPogho2fMwS/pkpOA+V0bh9ST4mBVRTPQ7xDXxGtHyZX fPDFUIL6tg1Am8O7Gwq0BTbEJgyiRkH0XJREgWLwOY2ZZn5chBhA27YL5ihRdQgmCC2x9xljaX5G aTRfKkNY3tvbRRvvpuinE5GoOmKN9JxaMlsDeuxbbyFCIESLk6oOUIOfk+iiSnAB2kP0w1msmmAA ZnUJhgUAGz7CgdiGh7COplIaqfX0hTPYSRKHQBzxdUm3lYsRKgVDZHdSrBEnLgkGT4KcpKxOX5lp j3VYs6IgLpBnZpwOAhDSDugV/Ycjxrb0nNadYorb+X1XKdtwIEuWudUpRDRK0yC73HmIIZvjrbCV gvFqFLJbRUhy5c3I2M1kDUiWPIXUhEomYQ0pWkgFRojIxItRAkSgP0CEpirny+CN+N7S3HOgfDkD knj32tLRiIsK2JZaIoIMKx/Y+LR7D5LNrBBFOIVGUtSoJRSBRKktsgpYlig2DKEiIEAikEgRjGAR Eac6FD4Om3DiDeR01PNLCxFOfkL0khIyPaSpHvijzUuSH6p45ZwzbEq3LDcVWUQwRcXtY+n1NAWI c1BQxfAGkLS3mPwx+G1wmJl7LBchDWi4bbbWuKraU4QWGJs3+X+gwgwqhF07VoMD4810ukYRhNkB +FdJRlkli2juB6umGy2IrItvmEJD/HP3/f9CBAVJo/b3vLMZREuQiTIZiBIqKSIDvFgB835qJCk0 DAY0GSRSH8uSKVMYkkEelDJrWTbWMMjIyjLqXIAMQcoIiIbTcREqSWE/u8+P7OA/Dr+af2dH/NFb Opq1VMblNQQEficN8bG94Kq6IoxiLERCIJGEYkhGA/E/IOTHH+fZ89ELtAw/tYFzGaE5/3DW+PEC lYAMSKEBWCQYwDUWdjx9rD3gxu2u3s2s/wNuzg6kAzsQBYQvNymFwCAu+iFT8kGeR8GWekeAgkOs EzB5yEyRkUJErL4JE+KAakA6QFU53iSGQwqlFyRoVZUDkfQA7J+lSd7SgPsA0ztuWBFAEgJFa9OU vHc1ra93b47lbX2AIBAEA1UyqVVSqayqao3Ya8l4DAKidqJYaginjrlNBQgonBYhM9iwrn7kHYHK GzUobAGAPlUDzWGCASEOgQkj0ErBVVCkdmud+3zi8/XRniAZQCMFkCReaqGx7xsNxswAeIdJDGNj q8aKKKyVASKeye5HP7xCgxZSC4gLle4KeAT3hDqgJkIc+RRznePewndqPdQmE7gPqfqYSsURtoKW rMGwgm+gH1dQcRGkHziHpzksy3qUFUULCqRLf0BgCcbUiGKHIcYzTvgqRLELtSJYbAXWRHcG0h8/ EVRBCqiSEMAkUlEIG0LWrJIyVjMKW0cE1ZS2SjEFkdEoUBpd/No0LAWQUU0XZxEmGBgaSwNyc+P8 JJSkUUG1uk33WESQX3EGCANyKgKBwjhZqEhHstWlKiStL4oFWKwY+NA/Mapo7WW8ZatMRgwERjHi 6LZwcU2CbtgVm28LZMS4zHe/z+41NbaW3YkPuJ4z0B3HhAmkikhE/P2Kq+JDQRNY5gKIQH1ByOXK El8bJQVS9aIHUuletQt38xUDieVUMIGi2bpJJO8JKVe0KmOcNkoUICDkQftGPuZHIWIPW5I/OcAC xj3killSHVSLhqHNwd4IQgkIAaZKok9LhkoKJfQeRsgJRJzPGmzATgaPaHP7YkWa6KgCdcWmMgk4 FVJMbGs0qDDPVm4S7c4NTCzgkD04ZOw7PPmqr++iEg3gP5OUlXVJQ1megTMr0pJvqGnvYooVIiRY 4NC5ixKESmKLswvd0l3gwwRQ+uGmzqXQ5dRApE13Py4kkk1P6nWxD9ZEgS22aaimy0a8zbiLWyWC CtrkrcRriNcltJbGxkCkNPdwDQHxOTpJCO9CSKY/mgc03p+oP6YBQLyvFwxDBbqEKWEI4jRF2GfD 6fCj3WsAUJ06zMJLaVC5blx6iB8J77w09Z5Xp2ZSOGFYq45SSWqiYbNwhQp93PuuwOroD3E83acy TfneA8RBiIyKKCDFkhGRkcKdIYgpYMQTTdSNIYRu8FJAUkpC7QFmQC8+1yX0APpa3Fyl3/6//P4/ dOY2x6Q6ZDlQAWnlQTyh+sdjR0PpPP3905I7fHcjubaH7O71HM6amD7VxlOHHlXZ0mMmxX4bXbov 2wtD88QLqEbSRtnNvrUX7HsnwlpLsmt+ithzMnvCjA6IcjSBRRLo/oFIIUHTdyNrHnJEsqjCqXAa xkw+qxClAgvfilo+ZujawgW+OgKiOF6W0RaFXsDBxwJBS+hv7vCC5baKh8YR++o4RbWUNgh3GbpN i5MTc1fXKmQyRIhD78aQFgRACBAJAu573LooFFAbTT17NolFEeRxxIpFgriRNhBdQcEEMoJ/FIfV 79fIZn4X8O6tWomkHMNW3WLqcSqa2FkNzirDgmWaaWyjlHDGCxxrKYlSouby72aZEQmCAxJve8mt BpcG0NN1RgirMy6tzMEYb/Hs1orDIckS8U1wQKfCCFAXHtVjmlBOiFQXoFIJtXuGAs3CdRFy+wcw oNGoNP7NN0O8ip5LZvMHhsugQYRUC51d1gTuFhEjdffQxQ3975sye9ANgTfmxo7KfcuXLI/x1RKK z7PUVIKS2ERfpivlPjQofZBDniBwIE7iuKbgLBEDbcznkBEoeRtkG4LAsRADsII74JIFG1UpdCJn graN+kDEAkgYj4zfPtwG0LwDgIbDxZvBgifUQIUsw0xZF3omjcGqUEja9NghkZsYtFnLt3nj5ddi juscO7AtFr0jAT3FZwGISRDU96m7RMKHc5tfgraXVZWVAxP7tRiMYmhOMklqfp6xzSal/7/8oE5k 8wBnpe2Pl2klMJk9r2yUFmAwkORITJfskBgjBrhGmCH7e+gCiALo9+j8RCj7v/v7Zoj3ChdP+Vwj LhqoLpsUqkyU9867Y7GQ9WtMYmUX2rCsQv94aqd5FFlBFQsSMgjEBClRt/igkMAWCfW+f/J/z2pA NNX2g3KIDTiAQiQU2feKabIaYBKwcoQwUIMKmIUEMIyMGCggybkPTAgJT3MI0aGpY0sPCmmijAIJ Aw/Z509xe97kzmOsr3+y1rvln4JJJUqST1aQkIRNFZqWkrJr7Uq41RbMspUaqK2mpVVFqLUVb0gb fh4o/NGD9pCsEt6FPZIRVEd2iH0vvBC0eoHTwOUDgeuUH2vdBwC+4hIiyEgA2lZi2ySsMMsqkJag Svc77IFkcmE1gd9vpv2YH9gsJJBA5vadMJOUhETs8BJvMxjUyYdJgnwCoHYXUOnpd6lQpCUJQ8I8 IgVE+OchbGqN8Ve7A0qRdCGTSQIQhjgVZrzVDzod4J0oRNFwqIMA/kBqgYDbIyNj0wSLBC5xaBIi HCBygVBkHcHIdDhuqqqa63UlrUQRoLobzG6PXoHWC6602RC/TZ54fP+TyZfuRIfaFhoEIXTAhIfC gqHMH4N/f44Ur1eNspno8TlLh8pbm5p2VBoajEGRZQqdWUfpp7RhS3GdU48oQ5BuZIna6NDG6aqp DQ15v97bA5oECQWRFAhFJFQjEZB1MEJQXfJ7BAwHQLQIxnQQ9ch1fZptYuVhkPlzn3NJGH7MXekM kMD5NzgInanr0J6apYBm6P3VHH34KOpiqExjeb+ldZ3kLjTk+puVMjYM/WxflogEjJB6lAINJJud yYITCRrQWNGxistKJbCFEMZ4585r3djx28L9jlOOVtuu5V9HXpUVt6TkcleOQ6O/qY/P1TytVUqQ zjIOBgpKxxHx1Sg6rsuOBlxUTlvXbLiyGVYCkM59leC31W7mdcl0mx2cJoOYiU4MMIQnVBkXPLEO HO4cE877utnUYjhfhVVVVW8+T87NtxEufv99shiz3Uam2tW1q2jkZ5I3VcGi3ejp2cV0bsdi3cmk ENDA5mJlJ3B13mJVkkiRhlavReOe0hw/60HotBQIRxbgdu9ihVctwmORlyRkYBkKc7BYpokHmnF7 /Naglt3YvTDwDTdQD5OC4kIhGBEhDppLKc780xzQa5A0GNaLAuFt6O2ax6oEaigu+f6GAeqlLDtg NQ8u2xthiYhHFYiV1FFogdEoA7nn0kJs2y5lttuBmKuTRwoiUkpJxznEPL0TwGDuGX0IgmuSPA9D Hd3hOLItgpDIZCKFNnMBLopaED+DS43QFPpwdxIZMHK4lDhCBg3mKO/8XUa7DvdNbC272vsYOtWI bmE7AX1nVJJYHHhk4nDBJ0/WyoiqiqaR7F3hTDQaIhCP5+V2JE8pE235b3/h+0Ozg8/MPEl0aKpB HGUQR8TcMC06uvDboHXVWUauQ1P6/A0E1iUhNV/eUr6iE6MDut1nwty2bNV1fBwxpqpJCcldexQp 7yO9H4sAhA9PD94xSu5ADQnzUUgdSNEAYLFEWKB2wLLhKH2Gbf2HtnWH5PA7kDeHHJNZ4wrNAWpy U08K8wSrlg0mp5iBgAJhcqJX7S1kLRznV4wksWm1hx0+L26UbI1VoWqskDqgczmZwAhhh0MhTMRc mJ0j02VMDKTPh9QEh2HvYCoMEKgdhr4jXHskkkkkk46C7q13M6cWWJYDGrWFMqZFCzZP4966OO6E VLddqVDre6aYa3rNa1kta5fG5AMSQ8CeHf+OjIkMfvsaLwVfFlddWQpgkmMHqoTv6ZcjjGKuhShZ JMwkMAFhBWy9LYGsYhxcgWGdD6Q41DIcg2AYagbkEQZ6T50VVUUV9Xn+NlfXmYKBIyG6DBHxVXjp BBQShj8Veh8TaSUzmxfl4UTzG/r+741QNuz1dkvoEOE4ThP708HmvaElOaRPw38+oU4JF5o867IR Xogg9KTqDcg5o5mBIUQCotEJEE8IJqPciFwF4JpkDwQ8rjuhrk8xKJCLEiwCwO+jnhjHfSUkzMHd t4+a3Jl4G8kaCoEIcFM5SAF9wgb1gDmggj3KW/FjqNj3MphTaiiCWxZOVg2F1AZ+1h/+0uH8khsh SKMGfxA00hBSjIFYCMLJ6hV/eshYj91rhvDE2Ce14dewqLJBF2yCM3reTN3RS0pbbuEfa8MJkg4O dKERVYGo4nLdx4EYwJuR2ywQmh6DpOENNCvhdjYaUj6HtD0DBP8ESRZB7kBqqa93f9TzfPXMqnNB oGla+9v0Ic9le4VmR0NECWjQ4wkUkJE7nOPi0UqwaT7LALihTQHIR3E3IDzShIOjKTwgdA6z1DEb 1dgWI/Gq0LE+qQ+LjDU+KNiUxoiJZYsFPknYpEGAxiEYhvNjCsBGH4996Be83OfQ5QOYiMk0CVp8 e6GGmj00SfNJPT6QWIOkP5ul4Z7Q8qjJ8zPQIYn3csFAQwc7bthZkIt5kWVTsGQYwVYw9mgzYaSA kJDkP6ecooOI2wyFIHRKSZEQOsklnLBrMulTKU2V9c1bMLkg5wFZMsyXgpPQZUhkSiXZsw1rKXRo hQuZBBUqzV5IaH8CaOhvkGjiAksHowxziqMnNgDAUpYlrEoCt0XCKGLRAn/KEELQR4QBxK5YYwwG N6fywCWP5+vj3lXSYiwZfMFJZlhTgwUIu0IfMqrqyvEGZhLjxSgU2hXcdzhAGH1eWBig5+2JwDZe eZOns9lvQOn0d/blrwLlWbZJgkq9JUS5Yo1NBTcSiDGcwJ86WeJklrU0gDsMWQTUFopYDFFDosCR oRjuM5FiR6VUJFm3F/NrStsYE7oWcTGS/nY0Ru8WuCjBcOiTWAaqEE+chbwhYbSBoiBOtE3v7eGh UAGQR7dobg2kQITHL1ilG4ucgMiCA9olooAeg14g0qIsCBpTAJDqk0X+7hYtSHELovMsLKDZFoiC LII0gFZA0yGAxYRSBWuMKi2I2CixYiGGQRIYZFkXWahDRRgZCwRxBIgbEEwYEaYIpWLygFgW9WEf jgKAFSQS8F1nqzQk2va3seFevyutVJqayWxVYstYMiFHjvCkfJ2JNBbgGqIQgp3bgU0pb1BDMYGy G0NMCtV6DXMDaiGhUBPQsa5LJEqSzJqKBtNNlWUSybTUYqRQVe2vm0dF6QukQgBENqHxhZ3bsA5z lbML0XpTYkB3ZiRQZGPsZdEjIn+pihPOa0Lt5hieQX8O8aTx0JV+nhluJvDL0ih+mOIh8cA6o+yP Z8pQXhQGvUbnegby40lEVl13QDM8I5gWEB0g0RMKBRooJyt3a3VVbtrbYsqvigUlElJi1ZKrqdlr u0acXMZbiuI1uLaK3SqZtxqitI5wBuCJdhS1Lf0MUpBRkkJLIWkKaySEhpERxLIQp89pHTeKbcbW lLgQil6qtKAmDMvGKSymmms2lnoJBQipiGSnRCJxwjjuAshDshSjxYA1FnIxExVRTrYJqBsJqtWl Ek28/j4nvF6ob6M3kuBygGH6QrEshhFxiv7SrRKkaMaLV+G9i4Ow3czSDHMiHUVKUf2fP6c1A6CT QnWwWSHJhzEJUKg2m42MCkujqOURwNhTH6cxbd+BTGAkYq7ly76FN813rJWIqu2y81u6bFwYDEiI bsxggd80PcUSByBgAgZSQ0YBgMhAhBXSNQAPzAC2+Z75MUPxV/0rkAOeV4kU0Px5X/HiB0CQCRWQ GTaj9xtxszUbCWjJZMgiJE/GAQSgmh6MsRO+IHjFaggEDwo931+6fLmZJKlQkTrRP2IkIkQ8ioHl iB1HQfv+5BPrUUT+UEPWBntiSVKwc3XvNxGRSQKP6J5uDq8ENSatp4obLzMh/DDqJ4Nxr6NXm51s +fur3zb41t1EsgzJkmWvq1b55RdytvglM1nXNYLQbQAgRZBkB8PNowuqGpCVEEL8e81trzgxpN8v h56dW7JbMianaIhgGRszi5A9Zz1L3BHbAHQoAaECDCQIsYOt7tS1ySawsvFG66+cNgfDlTkc5+RL MNT9dCsFFFBIJ+9x2/CGtbndXOTvvdu3XKIgKAASJODVIbHpacmymSIWW3UgFRkJBG5cTu7t10CI GRKCA7K4LAQcyuHHAAgtxLRbNaIBrSqqqcpKpty1eHHIRgbwgWP7YCUBJfsITCfZTUSYxtFQ3oVn g64LCTWaVALrC64Bw6OQYoxi+G+BjId7A6VL+4/lyzQhNmMLvNYYkurlypeoOwk9mO7tGh4xwQCA nH8eGPOGxjYDD9CW0ynTNOkMpy1ubhvN5lmYEgyO50oHE98V0LSoZ1NcKU1RiFbxbaH5jiNRuUZ7 jWZaxAz0NBjTbbcRElXuCQnID5JOuB3kpnBiS/FAovRqOCVRs4tDiaNMlvg0OcPbAQ0iW8x5CHaM WR4nMV9trFwUh5EaUD9FoVmI+9CdpsnKyeOMJ3AgWIsxppwZuWRdQMKYS0MsucBO7tAswHkQSLlD 7BP9KE3h9om+wDxSDGXyQ9sIOoeCHwKhbYiLIB7Q0Idgtug+PaGpDhIkOP3tdXJrcA+GihQTUGYk 2gTzniiCLBToUP6kUtpfXH4brb2ezsULsC8/uJWIZclk2mU19DAqTj+NJYYggk839jlzdmM9Zbh/ LlgnBy2cj5jRxr9kkDSCgoICCAk7coWobz2H6OF3j63enC4V83IidXW8bGe/R2j2EHRy15WieSBe YFhCs8VOJUhCJARCziVcltVZrLyrIXVGfufkcBzgGoQXSA8JRAWRUC7FGooEIKQIKVABuMjqNGkP HyE2BGalgy7gVlow022MMvs7XHQF85lQcUi+6Ki1qYkpeND+oglONA022/4dniuYL5TQmN5OOKRt DgGaiZLu8zzdhB+jOESqJ8cJZ5R/iRDKEB7zxIQgfWeckJCQkBKwhm4WmvVtfuORAjoAwB0ZC2ES p5eyR88ygDFz+qD0s0kzsSGRkIzjFxv6ULhym/no5sAEiRDzxczXjZDQWa1JpUE+jOxgxghDPnUs m9OKFIYB1AaInv+Pm5tO31W9krfOA1UkZIFLUsoDK8dvJi7Xly7/Lcte6n2iuoypI+2ijcLj2e3y hZc+fKCB/NqnAMtUMg/NVrUap13oemdoEIdxTUDpQ4c7JWiJy+XgKhgwhRBVByEA8oeZiZKYQCo1 NTUsUGpWlWS0CbOQGvkhZaBI3EekQg3O8guK1zIjDR3eckyUfOBB+djgPl42gFt3ScE1Z6o9c1Ip knP5AaeZCLmIgcdp5/bdcCLeQUg2SIHeTC63qTQ8XhhwJIICiwYED4VXQ/h/mq3a8ZkamqpiAUO+ GmTC5EJNNkPSZvGoo51maxl7N6NQ1lOwchMICqkOQhd2wURmkurVEVBBiy7hkmIpFkDIIIheedOn bwcQlKMmabZqZeHO/mrrrJtFRT5VchpthtGp25xY2z3c55/Xd1nVrtVbhgPaotna3Z23c9AlNlpe edWeUtmt06+TtpZnO8wNWIwTjl5b3HS27mQ3TpsyoIR69EXFbCJp3BjXSipEqGxQtlZYyvqA4IhD DZyRR4wXlaSQgBs2lhc9UmacV3wOij+/9LIslmPkvhyp/SmHvB6lEHM9RzIxCCcwMhzVDbRIjsqI LAsSSngJhC+Jhk0GZoZDAscTIxYtplmjWhFcum6o4NYDmCjG/vZyySDyulnog8Rt69qbgCByFDOC 44GwuoQIHlrGw/CLIyCEirIQ1QwGkGgIbL9g6+RC0LDQ2ENXfCReS7l9IvYBkQD8YEm+Tg1i/Z04 zFdy5GY2Wikf9o4gHy8GoHHppFMkFEOsbKwCidzAoRlo0MZmVahczCIwWGMXHEhUscyYZCWkJ0nb PUMCoblBQoNIgMm9YSGfouhpQoPRbePPCSOo2VMrFWQzIfbRPOJnexC5X9GcswP7fQ3yluOCIhkR O8pfUHjDgNQIe/PfGMGKBJ8cBPzBgFAHtgp+sIA2j6gOmkxrn4u1zYSmzfz8SoHVRO863U51pO/z gVxvymibcVVt2DAx8s4hX6b9dQpjR8Pjk1gUMwEDQeqP2zv691O8kx+6KZUU1LBjaiS4sqUW0kF4 iWnLIa8AHvi9wSAIEgjxGFF+L5VAsIBLMD5VMh5WOcJnniOMkIKA6OpH64pSGHqqEJI2DNmH3C7B yiwpZYYR6FhaIRA4q9mvdlRrTLJF11tKbGs9lzfGxIoFgDGQ0LSgU57luBIQYBPZrBDEib6OszlP pB+Llj34YsKCoi1VhSiiEZM8rDPTTt6IbleYpshHsQwSk/2RIoYgY8z4RSwowT3uMwnJCiCsMWQE oD1CnTlgtwQtDYhpRr69I6dGWmpVYGhJQVG4hIhVIylLcg23E4CYLDBty1GQ7xISLnUC0t2rz2IE SmBucJznLdCZkQFKipEpIDAYHYEQC6sJ54EObF6++UaCcFKzisrqEV0bowF5K3bz+/CaTMEp3BYL UqJ5KXhZwTou1GMjMS4c3LI3LjVU4LMvN7DLY9dYdRdyS+WSZgydcOxQbmSMRwIsZTBoFuWTGhNU 4R4WvbqTBLMGaroTA7b6MNfRJEs6u7Qd6aAsYIzNA/6XTJbCMrcgVQbzve5mZL/D+I5KYfXvCF03 Ia33Zme/mkuXKBrUWnGJZmootbRCUc4XAwKMFyLvLcQ5sgi8El7EWV7GUzdjPHJIGXuMNtipSDWN rFZHcrJMPtGdzJw9Yuxcq2xsT+pBix/PV+hbd743CmTxUqUFML1qM1wl+TZqZrCnadZrDcOvJlxV VaWsTQ2xtj+e3dSpsna6plZjiIJjV9s4O15O/WrzSzOJRsXjVjPjXFzVorveWeAl7Od0dP102yEU IQOKpf3dDr+HnL6CBbntnC4npiYQy00mxuePV1tlohqWlppBWwmkA0pDMGYihIpLvg3c854/LzDl x4zj1TwvFxrvq2cEK41yYo9zDR89/mR1EItbbnGLCOSQr7Hw2+ytvaoZzILG9Rkuw7A7YXz9cYzj jnQEnTe8zobV9nvIREJEhEiQEIjXn3BcnxFx9+ZFqLR8JIsbwSPk57YXTOLLo/Vzvrwbg3IbgltT sicpDBmBDOlH9KJzpKJoYKH3nuVA/HwdcRtLEwALmFioxwhKlLGkCpSxslotC2WMTQbh0igwPJ9K fF/rPZrx5QrPdqmi6uE8yuhtwFWKdoKTLVAtdwlxIBdnDPeMMtIA/yZPQSWDJHyoQB6WIRiqHVAa QghrCAg05ACMCDSUIuEjSBamSzxcAWMtkI4CKctVpLQ98DkQSRPJ6gsiYXVGjMQcnyo1bmr5eyFQ h3Ghkh1vfR7d93m8wcWn8FXyy1rKNvs7Es6Pfm+sjtrSPrI3GTmDmAm0T0MbU9AABUEVoYIIJIis SE7UJCDd3DZNaksBLqPt1AvEATet8OmmQNagOyQppghpSUaSrXGOOGoGdUbALRwuF4m8382+s1Q1 ibMhsFKZGCeYK23H2BZ8a74WnrgZgiHzKpFxOwQdygcS5czoUGoT+nEQpagJbtq7EuEBMSbfOhih EJEq8GPNIbAGCklE/rZTJAa2Qbh7mGd0FEJNuPNmcntwuJiLXTvrlrQyU6FcKHwJ+jS2+H1fRVvs 3Ltc1QhsVWKDDtvuKkcIy3COwk4OR1GBogkgBygq+Z3AegDlOzop1vwJKktp80HbCMBNhR05QQaC D1hvhxR7A20e1tuBRUu6l2IUJg1AOnw7OLqaKiR/r2Ow6srnlEIS81BgAUjq1GZdsAbi/cMGhhAP 1w+klEToxHowzySL16/oD3dvO4tf/dWLTVapYppqBRUu6lu9RTyCDBCPnqocia6YtVgTU7AK6CUq PTduDOTLTFbxeSszNwALhEykTRdJFiGOrI97Rttewvq0kuNYCEDopaAlJT45iBFIsCLAie09nu+M 0XDFjQSfephpfFuZtNcABCkCsQjuQftiM0UbwSUEiZA5zivygiSQEJ/DuUNMvCLlYdJ0ISNw+4CB ggkgkJghgPYEhRjl3zd+9e3Hu6tdvTDJPMbdnUwOCImUxGiYDrQmFZ2fGDuE0e0Zx2Zg9AouwH59 4v1TEAwGDBh65CxrQpkMwlcT2lyLlojQgB8Pt8z1Z5H0J8PpKTmdFGj6aHExrtZyBL+BsrLxFCrd PtE0qR0rj42aOFYvEBBCbi4brXULcTUzbBgjPCQ+iYs0ShlccLOed7zw0b2gm3ykOVoUuYAuKW0L aHJ5NaiZj1xGQndGPMzthqjHOfMpaoC90wah8kFU1Irl+cLceqvJ02SwF7hIxsK4nBa66McRakK9 1BvF8lYASZQ3vaZvAokOOAuMiwShnKxrplGhLK7XMqUD0DLjGQjOKN7CiA5DdygpXasRRNkyBMSa dllEJ56UUPgins9laDIRIyXG0gNAydEJYHu5TDZ2y7Y/XanrZAMGkRCBwCfOiEUw2x12L8wsciIz VRmyJmbqeeSqSN3FyTUGisHNE2pBu1sxUFiEmzFnadJoRcBto5xztAFbNGOdTu1QASSNbJG7ObuT CRfjkMStgdIdM5Yq5cCEhpBqLmVlpK4F6WHA+MXlqkqLVSC9qjRVaZ5n6HrBhiAigtP8fFo8UPp/ xjYVMDZNf55JEjIZyCcdG3HWU7vtvQ0Mmh39Ay2FVE3K/X4UZRdhKFZoGHnZujXM8ZSBCqbHqHQZ zOnEmzV2mCJB99qCCyTonOQk1kIAL3YrsbiUYq48NC54CjAWs2waqyt2KZinfktDvCkSIIHMRgLB JvwkUjFxnL2bHBi3lpQzwY23KX6FCbqYUMpFHJrNZZU0ijknYd0UEYu0RIdsgPM0WOqIhRdEgS9m WKsVRwgRKZSjklovOYkgiB4B6N8zveNp0uoYknPGMm1F5TEleQbA0vLGRS09KsRIMAYhEgWhRAgu wRCgDKQKQHKyD4tSA71Qih0ikIOxcbTY1JJEdHeAyZ8MG3mI5hcFuh6Lr4F115AN3HCUeNoyEWkL FKNg/5/x9vl/Rbt/+f+f/9/roNK+/knNDtYT30f2/5sB9JEDPad0EJIoEAiLEba1832eXSaWWUZp pihW3o+1/CiaPQVK8jkx99U5eQ4xqYKqqEjoBuoblTAqxRQUnhCB0PliwrCChA34dCcfJnyEA/li I7IRSmbpcwsXGWnCEUtkNlTIhEqRBAKGnhMveEH1aDGPvkkWxLWkLs0pxHQ2eiodPwIQ05qjlP4Q 22c3qfpZiBBYSHgzJlk1ASFYOqFEDTy+LhLQ3LQDlDSPCmrhZOs576kDZLNBHQIlxQEviFyROhYS fMFFELaxAP2QRC9M0Gizgh+UT5EKwD1hETrgD4QGEBFqAAlEG+jFCP1j7slmbtLDuGT9tOo4sCCE UI/XK7pzTaHGABUUJAAgaDFv1YuB2Lmzx8e0nhBv77gboDJ6299xC5kIlQ8RBCihsHCMMOdzDVuU iVwYhhgYYljFgozguspGRg6smRYgxGA4NY0YkEoxYMo3CsHGCkHKQSNklhJkARSTGIwxKyMFFpmY ds1hlaIBg2MeGi06MMuMGFkczypv7pP0x936enfDvI/H+sM8576pVpUW22X5bCuW2Fvxae/TpLK9 +/Gmk0mkvpt8t1XYJy6vKdb1eYE2IagNwwhEpNANoKadIVIgHSQM0pZppaYEViJEGiI7DgbUIhYD 01r3BtjRLCXgIX1HIsdo4aiRos8OGt7vX8+0byQjMTWIQQGkgm5He0JHzUHMILawVE7QOhYI/Rz3 1oUAHM3Cl1ZgiiDMTyciIPRkz4qaVDJsKTpAyEzXhwDJ8dUWKFYDz9IkJWMSWJoIpqCnCztp5Ihk 6kyKKSBpQ5s+/J4BjEHooYU0SpXnQzbMSMSQJCZAEfAxPzeW/jCy2qx3lEMGB5A96DYi9o87fdxt jvs3tVVT3tPKobbbbqIbb9Cb4MV/NER4rwznGOepiqrfoYtZjzM0ZxGtF5S6xHG061Npj+D9Vqq6 6PXEWtI9m4iKu8GC6GH9B7L93Ze98A6cUpgEYQGLIiEIqQM6/kITiIbJIASJwH8qjWIkBLnggDIi hsVEMYgQYdyUPwIWCniqBoLFj8l0NnnYHokgnjKRflrypcLrYIjFpYFDQBF8qZwfSh9nnA6OiSSS j0IQeiJzkTxgvMqegoa50LFiGK0nRA2IhJA94gnusK8oFJA/qxGpBeZylQJ+qHZkmo9Al0AP5n9p Iw3IUZjWhtPrSKA+QCCPY7ZQnFR/wQGyNTunpMFKxjJD76EPyCfwsL+1U+TH5Yakrt2qYroEhpRS Q7uf793lQd6W6ieUpDn3AaA6Bip5A3vAvDiECR5PmgyXyUgXsOUyrH4iAN6gDu98+naStKKMlNjT M+JPsXJSCwiyTxgoILthQM839vX7D9HFgTkeI0Yx3+ZHyz/VXE5BoEm9GQqLAkVKRCecmHnPmob8 vZOJ39vT1+rRWoqbIiYdhPpTz6GmFoq27ufin0uLxKNu2RiQICYIpcEogGyIkVRC3pKqqKreehhI RhKbrgQ0TY9Ggehnt85EhFkWhsMQP5JnVKopoItRaE9JEyRYQH3keB0Y8glRhBMSiBEIjhJhC6Uw i2NBhgUh2BDRAi2P8dkWRbEYoJnw7GwcFdkPcbEMAcLtWQkRSIz74A0ESRACGuihmZFAxLhk5iXk fXb/SaDvYQkZF5g/G0Nxzru6sBbiE9OLZ40FQ5nipKXAkkl1nE8OFrNlEr3suVMoNoMMINOcymmU hMpXimtWc15xev3OnDhwtDyDoQkgZDApyI7dbe+be+tX61zevV4vEAAAdQuwyIVIAHuRHs9zws+Z cfaHQELibSLoKeze/evbV1tu5a3r6BPG5wAPCroG9jIdU448rVzKZkbstUdEtsCFtTvwTYLGYSF5 EZrFS1PovD/UewPXODpmN4EwbxQGhYp+eB/WYvXJ9uh+uBUHTkaf2e0/cjomNHRYuBslIy59KAer s3EC+FVCQZGmqBLqkQD+AIhI6IiISKCCZxczDAobMzpgcIaYhi+dxEKr7xVWX9WhBYTsYBYWASB7 KRER7Ap23EwLOHJhF3OQBckADv24+H5+/2anaFQMwZzskbLxCsTWhT6bNzUMzZm0LkpHZsQnBLAz IvY4QWygmbXmC8F0BEZQGS5ikVJaeVevx1wHXaPS4mPSnUoYL1hkrJEkhchSEHOjhS6/7jM4ZNDm O8c4pppZkCYKB+qKmhTETzIGKQB+YrWL08MpPHXblzFr5t/vJdGvMupoRFNfXrNLyIbhmCqvce4n ywVexNSFZ0kJwhXcGf0J74fOBa/PGJbxV1c2+tTViTbbty1c2gq2TbXK1y223ctXVJbLJKZpi1jW 6atty2qql/zUFWlpRiKtr760bbcwWZlqvj2t83wklsPbEMABwpSIAUoEsYBUJRAYhKk/s7hSaJCk 95relEgiAgh+i4yu8mgTkLSaAMBDXI0ZJJYKT1vrBD1xSST/in4jzhDOBqC+MhhCScnZD8yAjBOo n1k7+wBwwQVcP8/b2ltxE2EAc4xEaRIAwhGBAiMUkzM2mYLX4qy15947at2s2WMAaGCqGX5+PKyq oDJAPIOypQMiRZ1HaSgXEshosMEDSRZSiXavXt2SZKaCr2tyZvRaVeNWhZJgHANqkQWDg/tFTgCH ZM7iRUUUVA4iWBOkO3fbaFoo9oATayILi42QHdVC5DQG8EIUDrMFXMU8j1SHutYT2AZD3kw9zglN ZoyaglCCYRUIqeeEiLLISSBkpyWC/rDcnAIkEhkQWSbaw2azIjAEi0DeIsCKkBRmlKAEiSKMiRo0 GDUaNGjRo1reSjEFkIpioREEYTfOqY0altqBVQklQhMUxERdY+/WBhmZNM7hjdLb3Ntu9uwxt3ta tcaNqUuEiDmKGytwR/yUA7KL//i7kinChIB2n8l4 --=-TRf8s2gcgkXOykAeFLFE--