# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: colin@gibibit.com-20080704180836-6bv0lfeejby951bm # target_branch: file:///home/cdb/grub/repo/trunk-clean/ # testament_sha1: fc3f0eef98dd4f55671fb5a5c35d5d7060ad7b44 # timestamp: 2008-07-04 11:15:24 -0700 # source_branch: http://grub.gibibit.com/bzr/trunk-clean # base_revision_id: colin@gibibit.com-20080704180626-bbrj490ldahovosg # # Begin patch === modified file 'ChangeLog' --- ChangeLog 2008-07-04 02:26:10 +0000 +++ ChangeLog 2008-07-04 18:08:36 +0000 @@ -1,3 +1,70 @@ +2008-07-04 Colin D Bennett + + High resolution timer support. Implemented for i386 CPU using TSC. + Extracted generic grub_millisleep() so it's linked in only as needed. + This requires a Pentium compatible CPU; currently the code does not + check for this (so it will fail on 386 and 486 machines). + + * conf/i386-efi.rmk: Added TSC high resolution time module, link with + generic grub_millisleep() function. + + * conf/i386-pc.rmk: Likewise. + + * conf/sparc64-ieee1275.rmk: Add kern/generic/millisleep.c and + kern/generic/get_time_ms.c to kernel, to use generic time functions. + + * conf/powerpc-ieee1275.rmk: Add kern/generic/millisleep.c to kernel, + to use generic grub_millisleep() function. + + * conf/i386-linuxbios.rmk: Added kern/generic/get_time_ms.c to the + kernel. + + * kern/generic/get_time_ms.c (grub_get_time_ms): New file. Platform + independent implementation of grub_get_time_ms() using the RTC that + can be linked into a platform's kernel when it does not implement its + own specialized grub_get_time_ms() function. + + * kern/generic/millisleep.c (grub_millisleep): New file. Extracted + from grub_millisleep_generic() in kern/misc.c and renamed. Changed it + to use grub_get_time_ms() instead of grub_get_rtc() for better + precision on when high resolution time is available. + + * kern/misc.c (grub_millisleep_generic): Deleted. Moved to + kern/generic/millisleep.c so that it is only included in the kernel + image when a platform does not define a specialized version. + + * commands/sleep.c (grub_interruptible_millisleep): Uses + grub_get_time_ms() instead of grub_get_rtc() to stay in sync with + grub_millisleep() from kern/generic/millisleep.c. + + * include/grub/i386/tsc.h (grub_get_tsc): New file. Inline function + grub_get_tsc() uses x86 RDTSC instruction (available on Pentium+ CPUs) + to read the counter value for the TSC. + (grub_tsc_calibrate): Declare this function for grub_machine_init(). + + * kern/i386/tsc.c (grub_get_time_ms): x86 TSC support providing a high + resolution clock. + (grub_tsc_calibrate): New function to calibrate the TSC using RTC. + + * include/grub/time.h (grub_get_time_ms): Added grub_get_time_ms() + function to return the current time in millseconds since the epoch. + This supports higher resolution time than grub_get_rtc() on some + platforms such as i386-pc, where the RTC has only about 1/18 s + precision but a higher precision timer such as the TSC is available. + + * kern/i386/efi/init.c (grub_millisleep): Deleted. Don't define + grub_millisleep() -- it just called grub_millisleep_generic() but now + it is linked to kern/generic/millisleep.c for the implementation. + + * kern/sparc64/ieee1275/init.c (grub_millisleep): Deleted. + + * kern/i386/pc/init.c (grub_machine_init): Call grub_tsc_calibrate(). + (grub_millisleep): Deleted. + + * kern/ieee1275/init.c (grub_millisleep): Deleted. + (grub_get_rtc): Now calls grub_get_time_ms(), which does the real + work. + 2008-07-04 Pavel Roskin * kern/i386/linuxbios/init.c (grub_machine_init): Cast addr to === modified file 'commands/sleep.c' --- commands/sleep.c 2008-05-16 20:55:29 +0000 +++ commands/sleep.c 2008-07-04 16:55:48 +0000 @@ -43,15 +43,15 @@ grub_printf ("%d ", n); } -/* Based on grub_millisleep() from kern/misc.c. */ +/* Based on grub_millisleep() from kern/generic/millisleep.c. */ static int grub_interruptible_millisleep (grub_uint32_t ms) { - grub_uint32_t end_at; - - end_at = grub_get_rtc () + grub_div_roundup (ms * GRUB_TICKS_PER_SECOND, 1000); - - while (grub_get_rtc () < end_at) + grub_uint64_t start; + + start = grub_get_time_ms (); + + while (grub_get_time_ms () - start < ms) if (grub_checkkey () >= 0 && GRUB_TERM_ASCII_CHAR (grub_getkey ()) == GRUB_TERM_ESC) return 1; === modified file 'conf/i386-efi.rmk' --- conf/i386-efi.rmk 2008-06-19 04:14:16 +0000 +++ conf/i386-efi.rmk 2008-07-03 04:19:16 +0000 @@ -84,7 +84,9 @@ kern/misc.c kern/mm.c kern/loader.c kern/rescue.c kern/term.c \ kern/i386/dl.c kern/i386/efi/init.c kern/parser.c kern/partition.c \ kern/env.c symlist.c kern/efi/efi.c kern/efi/init.c kern/efi/mm.c \ - term/efi/console.c disk/efi/efidisk.c + term/efi/console.c disk/efi/efidisk.c \ + kern/i386/tsc.c \ + kern/generic/millisleep.c kernel_mod_HEADERS = arg.h boot.h cache.h device.h disk.h dl.h elf.h elfload.h \ env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \ partition.h pc_partition.h rescue.h symbol.h term.h time.h types.h \ === modified file 'conf/i386-linuxbios.rmk' --- conf/i386-linuxbios.rmk 2008-06-19 04:14:16 +0000 +++ conf/i386-linuxbios.rmk 2008-07-04 16:55:48 +0000 @@ -18,6 +18,7 @@ kern/misc.c kern/mm.c kern/loader.c kern/rescue.c kern/term.c \ kern/i386/dl.c kern/parser.c kern/partition.c \ kern/env.c \ + kern/generic/get_time_ms.c \ term/i386/pc/console.c \ term/i386/pc/at_keyboard.c term/i386/pc/vga_text.c \ symlist.c === modified file 'conf/i386-pc.rmk' --- conf/i386-pc.rmk 2008-06-19 04:14:16 +0000 +++ conf/i386-pc.rmk 2008-07-03 04:19:16 +0000 @@ -43,6 +43,8 @@ kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \ kern/misc.c kern/mm.c kern/loader.c kern/rescue.c kern/term.c \ kern/i386/dl.c kern/i386/pc/init.c kern/parser.c kern/partition.c \ + kern/i386/tsc.c \ + kern/generic/millisleep.c \ kern/env.c \ term/i386/pc/console.c \ symlist.c === modified file 'conf/powerpc-ieee1275.rmk' --- conf/powerpc-ieee1275.rmk 2008-06-19 04:14:16 +0000 +++ conf/powerpc-ieee1275.rmk 2008-07-03 04:19:16 +0000 @@ -85,6 +85,7 @@ kern/ieee1275/init.c term/ieee1275/ofconsole.c \ kern/ieee1275/openfw.c disk/ieee1275/ofdisk.c \ kern/parser.c kern/partition.c kern/env.c kern/powerpc/dl.c \ + kern/generic/millisleep.c \ symlist.c kern/powerpc/cache.S kernel_elf_HEADERS = grub/powerpc/ieee1275/ieee1275.h kernel_elf_CFLAGS = $(COMMON_CFLAGS) === modified file 'conf/sparc64-ieee1275.rmk' --- conf/sparc64-ieee1275.rmk 2008-06-19 00:04:59 +0000 +++ conf/sparc64-ieee1275.rmk 2008-07-03 04:19:16 +0000 @@ -73,6 +73,7 @@ kern/rescue.c kern/term.c term/ieee1275/ofconsole.c \ kern/sparc64/ieee1275/openfw.c disk/ieee1275/ofdisk.c \ kern/partition.c kern/env.c kern/sparc64/dl.c symlist.c \ + kern/generic/millisleep.c kern/generic/get_time_ms.c \ kern/sparc64/cache.S kern/parser.c kernel_elf_HEADERS = grub/sparc64/ieee1275/ieee1275.h kernel_elf_CFLAGS = $(COMMON_CFLAGS) === added file 'include/grub/i386/tsc.h' --- include/grub/i386/tsc.h 1970-01-01 00:00:00 +0000 +++ include/grub/i386/tsc.h 2008-07-04 17:55:21 +0000 @@ -0,0 +1,43 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#ifndef KERNEL_CPU_TSC_HEADER +#define KERNEL_CPU_TSC_HEADER 1 + +#include + +/* Read the TSC value, which increments with each CPU clock cycle. */ +static __inline grub_uint64_t +grub_get_tsc (void) +{ + grub_uint32_t lo, hi; + + /* The CPUID instruction is a 'serializing' instruction, and + avoids out-of-order execution of the RDTSC instruction. */ + __asm__ __volatile__ ("xorl %%eax, %%eax\n\t" + "cpuid":::"%rax", "%rbx", "%rcx", "%rdx"); + /* Read TSC value. We cannot use "=A", since this would use + %rax on x86_64. */ + __asm__ __volatile__ ("rdtsc":"=a" (lo), "=d" (hi)); + + return (((grub_uint64_t) hi) << 32) | lo; +} + +void grub_tsc_calibrate (void); + +#endif /* ! KERNEL_CPU_TSC_HEADER */ === modified file 'include/grub/time.h' --- include/grub/time.h 2007-10-22 19:02:16 +0000 +++ include/grub/time.h 2008-07-03 04:19:16 +0000 @@ -1,6 +1,6 @@ /* * GRUB -- GRand Unified Bootloader - * Copyright (C) 2007 Free Software Foundation, Inc. + * Copyright (C) 2007, 2008 Free Software Foundation, Inc. * * GRUB is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -19,12 +19,13 @@ #ifndef KERNEL_TIME_HEADER #define KERNEL_TIME_HEADER 1 +#include #include #include #include void EXPORT_FUNC(grub_millisleep) (grub_uint32_t ms); -void EXPORT_FUNC(grub_millisleep_generic) (grub_uint32_t ms); +grub_uint64_t EXPORT_FUNC(grub_get_time_ms) (void); static __inline void grub_sleep (grub_uint32_t s) === added directory 'kern/generic' === added file 'kern/generic/get_time_ms.c' --- kern/generic/get_time_ms.c 1970-01-01 00:00:00 +0000 +++ kern/generic/get_time_ms.c 2008-07-04 16:55:48 +0000 @@ -0,0 +1,37 @@ +/* get_time_ms.c - generic time implementation -- using platform RTC. + * The generic implementation of these functions can be used for architectures + * or platforms that do not have a more specialized implementation. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include + +/* Calculate the time in milliseconds since the epoch based on the RTC. */ +grub_uint64_t +grub_get_time_ms (void) +{ + /* By dimensional analysis: + + 1000 ms N rtc ticks 1 s + ------- * ----------- * ----------- = 1000*N/T ms + 1 s 1 T rtc ticks + */ + grub_uint64_t ticks_ms_per_sec = ((grub_uint64_t) 1000) * grub_get_rtc (); + return grub_divmod64 (ticks_ms_per_sec, GRUB_TICKS_PER_SECOND, 0); +} === added file 'kern/generic/millisleep.c' --- kern/generic/millisleep.c 1970-01-01 00:00:00 +0000 +++ kern/generic/millisleep.c 2008-07-04 16:55:48 +0000 @@ -0,0 +1,39 @@ +/* millisleep.c - generic millisleep function. + * The generic implementation of these functions can be used for architectures + * or platforms that do not have a more specialized implementation. */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2006,2007,2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include + +void +grub_millisleep (grub_uint32_t ms) +{ + grub_uint64_t start; + + start = grub_get_time_ms (); + + /* Instead of setting an end time and looping while the current time is + less than that, comparing the elapsed sleep time with the desired sleep + time handles the (unlikely!) case that the timer would wrap around + during the sleep. */ + + while (grub_get_time_ms () - start < ms) + grub_cpu_idle (); +} === modified file 'kern/i386/efi/init.c' --- kern/i386/efi/init.c 2007-10-22 18:59:33 +0000 +++ kern/i386/efi/init.c 2008-07-04 17:55:21 +0000 @@ -25,18 +25,13 @@ #include #include #include -#include - -void -grub_millisleep (grub_uint32_t ms) -{ - grub_millisleep_generic (ms); -} +#include void grub_machine_init (void) { grub_efi_init (); + grub_tsc_calibrate (); } void === modified file 'kern/i386/pc/init.c' --- kern/i386/pc/init.c 2008-06-15 17:21:16 +0000 +++ kern/i386/pc/init.c 2008-07-04 18:03:26 +0000 @@ -30,6 +30,7 @@ #include #include #include +#include struct mem_region { @@ -46,12 +47,6 @@ grub_size_t grub_os_area_size; grub_size_t grub_lower_mem, grub_upper_mem; -void -grub_millisleep (grub_uint32_t ms) -{ - grub_millisleep_generic (ms); -} - void grub_arch_sync_caches (void *address __attribute__ ((unused)), grub_size_t len __attribute__ ((unused))) @@ -231,6 +226,8 @@ if (! grub_os_area_addr) grub_fatal ("no upper memory"); + + grub_tsc_calibrate (); } void === added file 'kern/i386/tsc.c' --- kern/i386/tsc.c 1970-01-01 00:00:00 +0000 +++ kern/i386/tsc.c 2008-07-04 17:55:21 +0000 @@ -0,0 +1,89 @@ +/* kern/i386/tsc.c - x86 TSC time source implementation + * Requires Pentium or better x86 CPU that supports the RDTSC instruction. + * This module uses the RTC (via grub_get_rtc()) to calibrate the TSC to + * real time. + * + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2008 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include + +/* Calibrated reference for TSC=0. This defines the time since the epoch in + milliseconds that TSC=0 refers to. */ +static grub_uint64_t tsc_boot_time; + +/* Calibrated TSC rate. (In TSC ticks per millisecond.) */ +static grub_uint64_t tsc_ticks_per_ms; + + +/* Declared in . */ +grub_uint64_t +grub_get_time_ms (void) +{ + return tsc_boot_time + grub_divmod64 (grub_get_tsc (), tsc_ticks_per_ms, 0); +} + + +/* How many RTC ticks to use for calibration loop. (>= 1) */ +#define CALIBRATION_TICKS 2 + +/* Calibrate the TSC based on the RTC. */ +void +grub_tsc_calibrate (void) +{ + /* First calbrate the TSC rate (relative, not absolute time). */ + grub_uint64_t start_tsc; + grub_uint64_t end_tsc; + grub_uint32_t initial_tick; + grub_uint32_t start_tick; + grub_uint32_t end_tick; + + /* Wait for the start of the next tick; + we'll base out timing off this edge. */ + initial_tick = grub_get_rtc (); + do + { + start_tick = grub_get_rtc (); + } + while (start_tick == initial_tick); + start_tsc = grub_get_tsc (); + + /* Wait for the start of the next tick. This will + be the end of the 1-tick period. */ + do + { + end_tick = grub_get_rtc (); + } + while (end_tick - start_tick < CALIBRATION_TICKS); + end_tsc = grub_get_tsc (); + + tsc_ticks_per_ms = + grub_divmod64 (grub_divmod64 + (end_tsc - start_tsc, end_tick - start_tick, 0) + * GRUB_TICKS_PER_SECOND, 1000, 0); + + /* Reference the TSC zero (boot time) to the epoch to + get an absolute real time reference. */ + grub_uint64_t ms_since_boot = grub_divmod64 (end_tsc, tsc_ticks_per_ms, 0); + grub_uint64_t mstime_now = grub_divmod64 ((grub_uint64_t) 1000 * end_tick, + GRUB_TICKS_PER_SECOND, + 0); + tsc_boot_time = mstime_now - ms_since_boot; +} === modified file 'kern/ieee1275/init.c' --- kern/ieee1275/init.c 2008-07-04 02:01:55 +0000 +++ kern/ieee1275/init.c 2008-07-04 18:06:56 +0000 @@ -47,12 +47,6 @@ extern char _end[]; void -grub_millisleep (grub_uint32_t ms) -{ - grub_millisleep_generic (ms); -} - -void grub_exit (void) { grub_ieee1275_exit (); @@ -260,8 +254,8 @@ grub_console_fini (); } -grub_uint32_t -grub_get_rtc (void) +grub_uint64_t +grub_get_time_ms (void) { grub_uint32_t msecs = 0; @@ -270,6 +264,12 @@ return msecs; } +grub_uint32_t +grub_get_rtc (void) +{ + return grub_get_time_ms (); +} + grub_addr_t grub_arch_modules_addr (void) { === modified file 'kern/misc.c' --- kern/misc.c 2008-06-15 23:42:48 +0000 +++ kern/misc.c 2008-07-04 18:03:26 +0000 @@ -23,7 +23,6 @@ #include #include #include -#include void * grub_memmove (void *dest, const void *src, grub_size_t n) @@ -1018,17 +1017,6 @@ return p - dest; } -void -grub_millisleep_generic (grub_uint32_t ms) -{ - grub_uint32_t end_at; - - end_at = grub_get_rtc () + grub_div_roundup (ms * GRUB_TICKS_PER_SECOND, 1000); - - while (grub_get_rtc () < end_at) - grub_cpu_idle (); -} - /* Abort GRUB. This function does not return. */ void grub_abort (void) === modified file 'kern/sparc64/ieee1275/init.c' --- kern/sparc64/ieee1275/init.c 2007-10-22 18:59:33 +0000 +++ kern/sparc64/ieee1275/init.c 2008-07-04 17:55:21 +0000 @@ -66,12 +66,6 @@ /* Never reached. */ } -void -grub_millisleep (grub_uint32_t ms) -{ - grub_millisleep_generic (ms); -} - int grub_ieee1275_test_flag (enum grub_ieee1275_flag flag) { # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWXjFEzkALiz/gH2whAB7//// f//e9P////5gNZ63PXMY6vPreaXugZ5XBXo7gqWFe6933uu9nHs+vfXvh3n33u70qm9upSVN7upC SJO2IWw0tsqjbe2opUqIw8FoCCGW5HThHWdqdBztbuA065FOVsYQrFg5ANA1hAVVGaQs1QTZlPeb ko3YOe2VUQw0QIIybSjJ6aaEaZAGmgA0DQAGgaGgAEoCAmgggqeqeU9pqg9T1PRNA8oaaNAAAAAA MQEKJomhB5pT1GTIPSBppoMgNABoAGgASaSRCiZkaZNE01PTU8p6amjR6j0j1HqaNNAAAAAAiSQg 0AmQaJgmQTTJT9TNRsmpD1PQ2lGNEaD1A9TQKkkAEAITQAk0p+kxPRT00NRptR6m0jR6hoNANPap iKcYc5FgYoL8IgpxXqgSSUnXABJgFXOuZWmBANJjowgWkOnhxyvhAwDDfJxYcSMBdw8yvl/+P0sX P6mVf9EbvscIopkbc9W6PwHg3NdjyggfaO5/zgJkuNA8XbYhKGMKSarkFOLvkFcXPY0mEwpXrqO4 3Onz7GLjDKRy2+JtndsnduI3NwpdPkeTCB7+9DO+5tYaygdCBXwpcu+/HXU7bbUcqiE7y638PUsb z4onxkGfe56q/RpTxUuggvEG8x0wWDA9yBhTHXUIqpRNKlYOYVYnWUbojEgflOvkoOA6LJsz9CII Na0HljcsULC/Y7wqOxqhAsm1AFkZ2Q7601uOG+g3rhU0+f04fC7u25hePK50+Ox70Jyh7jOkOoJ0 ghQ4h/wDvd7lFvQNDufF2ztB78qrUDVW+c8lMYN83mPJewHIgbO8IVJxcUqUIggYBRNP2prPZ1HK 7XNvEVvh4dY1sF3OFqJT7KiGgR1lGytaI4A5II2qtMS6JLDYy2sRhBIQgaRJZDK0jaJtDgQD5ZkQ K4GJy13q6UEOIInmAQwqoiH2CfTlQtXqiyNhTQt94h9woCmdzqnpmqhW5LF0YIYGojCGy9gM4zCy 5SbzhopEYm5jDNDWre0YgLLAXXIm/lrC0WnYTqLROycogcnJzHs7a080tkVA1dUFMCbyin0wvYLY hTlwCkaJPuC1yks8d1ksnQlg+8uhYpmpCxlFFUUl1QWLUBQQSdjzS6vT811+8fyPyN+v18nIQkJk 0FgtRriUGEseZuKlv0BQdhkEF5+y/qz12Fsv2PVRXeRlx8fa6YRQRhIPxnsM4IaPK7uKis7oh8FM VAU0gLUL2OyevD1GG4YHTfBD58tlN4I5EQ0pwgSKlRIkkIQhBioyRYqkQYLIpARikRgqKqREYyMZ BVU92HI8D/ggB5OFOf0Gb09GLYMkpajEnZjrwM+7ZNeBJjjjNGn5i012saTM6h266uRXR0YZzNvl ovcwOqZsFMazwWB+SB9q4sxajlt1RsW04+mGyMyoRkXGqk7XpeEtMlh8QIxlwkVbOillEJF2y2bl B2GUXDtSYUmTW+0mL0wg6EKH6gGWB0LLFavYoMIQkjWxg0W+dMWQ+TDBaYwruHUMLWkbC24w7bRm TmVNFG4E5adjAaT5t9vohnts28ZQ0RmbDIUjOxqi3upnDSBaDIMgNZbZNObWnzrDO5EgCpYiaemx jU5qcEOKjk4eoEh1SRxInntz27S7yX5WGBhbsD/UPUD2n4AdAVk4+fg2fvLwys7f0ZqPXF3gYGBB DzXUzdD6QvPKEtoQiQetCw3ocj64rj/AlvzVdFb2Vyxi5xwa/d+71JcaTTM1q6pQ00su/uPU/I+H kxxfoJ6uEb2Bv5zZ737LzWmcaQxnA6S+xXTRVtJyaqvS/GylODNnNqVKpiU8bv/JkYsKo5JSv1Oz c+/jZ+H6vP6/v+VJObKVBbObk9ySqFyjwnqSVeFGhag9fBBa/Bv5PxD6MME/bcPqDJp+JudHJkGO 9A88/bOPBgJB9zdNwkxCasDqFfCFsjXWiqSG/b6iD/oJnbj+f5cknp3NfR+L71RPf4lRCgXQ/aPs b246At7jt4FWiEcuHqVOqFUcsPRG5Xn0vroY3Vfr+TTHra+tckser2vVL0HSkmLq9i7Q5s4Op3Mn hP2BMCdBXCWGcwKQsl9h4EnxvDGnQ8g6mdaGCeZHp534fYPYsz3zBOTmjVwuEm5zQ8eqdz4YoJgH BfdV20/u+9qJNqUUhCiokA0wW7nRAc+ONGipI50ZDk3weIk30OVY4N4LI7vUFD2f4FCHG9lYHRin gZA8IU58urhbK7o8dehLj19tBpeoc2bv56wJqPADZtMo36qPPR3wl/vO5cYvbSyYXU0emqymKnCe 6Xye6pwqSijOPZMzkbtd1XrsJipb8L2mOJ+H2uvqx4detrl5w0WPjPvfqfY6PP5W6fGvfHmlCNt+ OTivvOK551PJT19hbOab7l+txfKspeXn6zBip8/qzZ+XRZiy/B9Gy9U6nQ/KfLZviYcEU7wseO3h zSBuj7sxr7uFi2e03kCaHoNYbKMjys97C4zjPCzkbKjP5X1M1doke1SqJCQhA3dh+R7z3B0hmy58 c30BT0dt+0hm5C3pzHi4XBmMKeqxTT1+BwLjq6C4l1VduM50Fp1ELF+LGsT2CRTDJRhLiv5bY53s LyvLYontusWD0LDOKJ0t1X0HJIa1XDChiKBYVElbbvkyXxY5UHgrWSpQ9BqoVWqmmYU8ByjTMJMD Js2gySWoZk+/WlYQZewIsYT16zX4+xYPF78qnAKPI1EgXmnYgYwVtdVWgqFwXugyhSTStW8+Xk87 3hWCxpKOnPzXnHo8cDqsq6+OyoqFX7CSL3MDSDxLJrGPwBO+lY/TOsIwbBrpcPUjXLzDvd/r99+9 0Bu/zXN1dCmUPM1ddh5a5L1XP4N/lxzy/QX8RoaTVeeR61e1hpIWkte3tyGCXkSS5IHJu81uX/Oi p4OfgDPWWzLPQUxm4uqjM1mlwubvl35mvfa49PRiXuZ6MLqt1mE6rauqatVFIZed/bOtvePbv68x s1/e3w+FYfClJK6pStqxeIpS4iicbHiOPzznQYtYrYF24REQINathwta2JsQKsCngAk/fFB/lFZj 9oSCx3DxVyAAHX0yEVnkI9Yiioz3vnPk68xrmXLMMhkycCdiSYARDKYFhouPxPw0/QHAaH6eOktD beecl2hYh4ncdPYFqWQdGUIGatFJCUHYlJIcZRgmpxAiQxdPTSCakRAmoaiAPCj4Qh2kWQBCIxSZ 2CMcDthM3V4WC6JLej7ci5DOlcdYUn3RG+KnsjtgW9VZPGkNMCRwlYQeSaEO9A7wzbLiJhoo4Yc5 w533GsxnW/h1ffpRZDp+aMABYIsg9fz8FJlpRFE8ARKwsEYSshah7WSBwPdKesXp20kCEora3ow6 VylIQqiRidSVADF06ioVETAKChEHcNtEoyQ9uzu7PZ8/z/Pw9wnYHSUEGSDEIP76S70CAH1PORiQ khHsd4JxGgVDHnHAdJJIXJQDQB7rpdIURz0VVSkEfPZEzj0nUfQXCAcFDiGez5FDcK9Ox2DeWuHi DhB9wrVw55xAw9iudzIstEuItRI7uGsv0KVp9wuVyuafXP5pqAcLg1lj+YMyXwzTatoIgPPgA8cQ JKC/ACuZdg8ciuJlO/4mkO0vwpONzVTCk8wKuInGl9ViWhUExj0IgI3pJ9IQJQRBJoShJyDRhhpk KZHVm9xTA3oGAm0k3NjMgZihZjNVcNGBgYRCtupIEOYPEcFNihVSkNlcUUbfvB8Bnl2bcmW4hhTD 1yQPTOgVkYjEVRGe0OvzIp7Rvt6iId/QiI+iSIZaMyspcEE2D8h5+buiAzMgVVCVVNVTVVt+AaOf i3Y5QA3ga7UZk9I3gGdnlYTVgcyZySVhtDRlfuG9A06aS5cj3GKZTgshusxMXqoxGvja6XXXXYMJ +o+XTzsX1u0++B61tDpurDV2yNcxBIFonCASxeXJAhgcWCkmmBqJuyFEhMTkw4JJjN6pWoJlPiZM ScdcyY45RzSSfXCgzlFBpGM1FqpqsLR4VSlqAn6VbL3K7cZ+oAB06ORTlLrXbo0QNsfqfLYpteuo MjDGAAsKWXuPBnjlJEcWVJMWTFqr9VZ4s20pBKIjTuxceNVgXY8NOK1mnHV0UvZgAoXYUFfXGTdG FESxUcyKVMlbiVrJfIDVEkbMNF2Tm6OjVNqkSRxZJkXi3Xc4OLCyUV9rkqB10xIuhcmhxkQEfsc1 mClmj3sl1Lm7o5NXRyOjo6ubhkrecHA7ALwHJc7drY9VlmizZxc1OTGfgO8T69urCbA3ZsgOmApa VnMLJI/zI6ovLkrZTPsY4SQVKi7pBMAiGiE8O31j7/u2jcANVjsAukksA6yF91TdL+N37Kk+HnKU tg+di52GltDe1SzoopQPf4Hg3L8UFrh9L8CZ2IMKZLe5dOhge56tHTOsro46Ndkp7Hhmpp3EAk7m jRe+Rd+7PfmrT1pp76NaxmLG1XoZs6xdlfqZxze2ysUEuMUOyXLuiG6gip3PHZnO5felRUW427NV 6JTNsxdXdf2VOzLGqquKlOFXuIkbFkQEjbnengjDkIOMxPLcHc8BY3tbPCKg+Ewk7ljubjWsP0II lE6aCotCwFTZJOLa92V0/TadmKmvRtyuMFMw2kkt1b6+Gzq8Lmy6Z8J3Vy3iHRSJwcHJnu8OfX+n w6Kp47NoQRNuxGhUkkyyVFNHkcwXHLm3gQn/iQ3c2bJ5ui58UnNwN3B2eSnNwTjINjyXJNGiw5+N GNFSRRzIWNGuhejggp6FCh6e+xcgiPrqcnYY8nc4LnY7JcRPVCd63WxvIeiKTU+Onx1hgwXAwdbV bThBYoO+xjiLzScN97txezB1sdi28SfjJ2RxRT1HGBJDu49t7dbL3BVwCkd1uzlfLcJJMc778lo5 VOSgjcimT1PUIJPJ3qdLbjRowTUk3R0ZKjs5s4LSym6uS4kndi3ebg3dW+uTMlbuLYmTQxc7Gwow iUMBMLxyI5SORXLm7hJkZFHLF4iUkRH3FuT3fsLoKmTobubFN0VKqX78W3nhe1zu1VLgarcldgF7 BRdupZwZO7k5MTNk7MV/Ko6NWNycaSujduAwRJc4qSk/cCHGSzVi8GTmudWjJiyXO7ZRg5d+7s6s m7d3WczFes5bXuZBY0UKg5AcmS53LPNvOBYgohHbhnCGYTZR4VoorK4Qg4T2ziuCauIcqlPgiAwh 5NTGhVYSRFQpu73r8WFnDerJj32300xJrmweTHVirBZVdKbeAHHd34OSSplq/XJxNyTRwUHeaoDC puR5FQCpyQaG0TUwrVMFwqRk0b6QCx4Ou3JvuAvJU4JODcolTyJuScG5JUERar0YFHPnycdLgqdj BPJJn4FKiQrRiyc2IDw9GXGzq8NXFk742cWbsokn8ZDi1aNWTu5s1KaLNnhTNg3LklipY5IMm4pc MGRTovyWGLFjx6QltsjA5mxyaNFSTgznJc++ni1b01PeGOlrxKvRkTA4VSRGlWLyXNM/FiTh0Ghl ONNSSbPTxd6TWovSZEsmt2zHZxXqXaui46sJCU2aLlhz0kxbrI+Mb8ymEBEQudyDYtptVudFM0Oe TYmSpBuXNil7jDisXPBwdhzJokjwd++DtZtuPWsGDfgfk4GOywQdjscnQchQuW5MnNm3d2DHSymm HLp2YU3QGT7yYZ4qdWTkbUWXs3FeybySaWWXL6c2rVdzZFz8JpxfzwP0qnvJdETeDgmyRo8nJzXu bNy5tGjJ4fABzXPHs0OL0cg2c3FwcWDcsOUNh1GGKHBuVJKkEWDzK3d8kHoImSEYdUwAV8eBtbOM KpZhuLwZwokXLq8OLHSS+OdIvqDbavW3sVm4TTt0aubHNycOyzq3mWC0YOqZLuTonKSTVkuXFnZm udMDpqrpwdnVfyXqdmfI1x6uC2T14pJ36rJq5touZ7ySauS9mknZMGjq7N2S9tUzSZa8V65yKQQe URE6e4p5ODOynjejNzOxuclmSODVSpy7sdHRS5zdfGi8ydGbdc2dWLq6N3dWrRqyU6KXOTJs7LNl zi4uigG2zjuybtHAYJMGCS5BsIImwiPtZ+43KjMuxLXfGttzcSIrTOHQpreyAHzxODxg509IEmxk GTclJKk1SUNIklqYXSHa5uY1MGOfNqbRY6JLnBlsinfGn5Ow1xjY0bH5E32qayWJP6REiDpOTwbY Q31kYbNRYGNip5sqFoRD+wU5tI3bt1OjixY/MinZ04sXn45NWaScETcPQuaOjRUsZUYgigsxyYYd x0JC3haZZea7HCy+1lupi5rOTVycSJ3AXsXhwNzPbJ2INBudJwOUOD2EybDlzuYOSgpI5gk5GFIP IiJvg3IJjRB3O5gkgqiIkkFSg5IibAnjbit52dcPHFFhSiggqLxct4m8MrbWCIwmcRl2tDAyMPNn AyhKIs1OZjgmdqkB4xmbjmqmEkRwUgmt7Lsv5ujm5sCyUMtgoa44qpBJ0ZODQpYOutGFIOCTg8p6 EgkgEYLGMIQhpMTAzG02lVsLjRq5KaMXFo0srjhpzdGzFuZhndKoHYdERNjtuQdjkuSaKlsLuLJk 71qWLmScFa4M2rm2MWda0A1YOvlto1Zzm7at2rnBEqiB2g7knI5QodzYgsZMikDlzRxxuYO5wWNj kyUNyTc6MGjk4KmDoydFSxsInfm/PPNiXpLcuzNdaoQRqkULkU2IpWjyl3kiWnNiAykk1xzsYpOC oMoSRy63DvbffCyImanRQ423KiJyVKlTRBZhOix0eJLSLiotzok4yXQk5sdypQkgwYOr7Ov53QqC nYq2ayd6SCurmzdVMmnBnZpzXNWzh2dlzY+YAr86uSdimjXXTmxuaKnVrcD9x7h3ucENUytPYA8P L0s8mTN3UAudHJ1YODm6uT4k48bm7g6slzjOSrpg4rOS9gfVJOd3N1zZbeIH2y91pUpZyLzVoWOd puR4Q8HXVDffc3cXhjTey6bszOrMMq45cf0ySZok00ZOa5WCDJsU9SzDEGgKnHF8HoVMnBBJ0+kV T6F7qXPQlyofcJBg8Hlie5ncufsiJrwaOTg3GGK0XJuULHJ4IOCTHdOSTAeChAaPWNUVMPsXVmqY ZvJIWas+q5c4r2K9iTFqxaO6mLZTJmuc2rFi5t3IsamDiyUvUyXurkxWeESf1/bX2pSlIy/asFyi Z1FDYnHm6A1LcEgkiRXVAL77hLLzChQhxULA6x5bgUIoPOgt3OoNwi33KF4AB7NQeSbPCoRzx2zf C+M4yUPXkpyf5H8AuB+ztD2BvIDnGDZiKRQgD9oxJQqE9jzE8MPehbYN8RHAiBlBLEYqqoiAiPZI 1QaRpHAkES0LLD65MKRhh9yQGMBiQYxBiKWQywRGBEYDGM+YOPjn3T1Sw+pKgoQVVgVpEnmJ4SUm iciZIY9klDCw/G8cB8yvbxKTvPKUWLFI95AKG5Wk+sslhcnCSEczz/gfjnd/6P7zE/+H8T+IuLgf FA3idyjAiBGMRZFgQiR/mH4FwX6ILpf4sSAkISIfLilgsEkCBcYhlHIFl+xhYL2kPakInUlPnoaV vxDS5xuf3RBzB+Zwd1gyv8W8PzeAXBlcxBNnSCi1EWCRSIQGCu+InQFz51DlDflMPz+Kh1GAnH4h R5A/MLwhlU1QTl7lDnULO0cQ4nSHW3gnYgf1KTeRPxMv4HynY2HkSi9lE4HB1PdHMwPU5bmcl5UU R0mpsYHmvMEqcjAuIox4xGBRfHv+RXRJGJwMi8xknlWp+V/vfI5EeDVLHJcZp9Ep6USYy8yMr0fF VKuJ5pfEV4PSx1KmKa1ZUT/CtXbU7g9qheHyUIP5/L1bg9h4Obc9Qbw0nWHS959RrTQehuPrBP2A e8D3RoVbveRhAiRCJEiSLGKRZI8ihVBBP5xVzXlCLAUhFIh8CKMIgSZSEXIs9/RmENxIfbYsgsUI sU2EJD632SIsQWBzGL+ZbVvPCh2oESEmlYI2Qh2z+iP97hCEJDkRsDAkT0RPugp9n6/l39APO/e/ rAf2v2KdGWen+l7pCdWDVchLNn5Gz0IHPc3GIkkoWSh7lSwxwVJICpYy4pJggkgqOOSOYPyfvfyj mjJgMimi5ySSUODg/3dGy9g1XPennHV3cGzJZRafZE8/nF0jGuy3Bm6PR2dnF/aa2dHo0ZnRufNE n9wDdxPJnm1d2/0eDYndEnWd32JiYyT9x/Ew6TiE9Fnlnj+JgoAjNYELMU7ZZULHwSVvFYiTRLGB X0WirXapaPzFBe4xvYTLRkYYlsPl9yTFEnuvv+ckyfvz6wWLyUFXqC6Lrg1IHK5rhhB6Nc9cPUdI N+BuuoX9oVUsDpDWjriPSSSUI2NQFELvMyFJRehQ2ISF3VnMQxX9VZnkP6CLmN+76A1RV81E9JDe WLHoPLtLue8nger1WNhcZT0lln3OID3sH4nFzAfc6M2LLoxW+i5ozYNOKzRZkzaGbo0WZNWjRyYq dWrm4rN2q9qzZNGbZkpo0YuDJSy5c0cHKQAlypg4JPb61LHJwbHA5RJNyxBkwdgglyXOq9u4R60n BzZtHBo2YMWScGK9qpia/SqCe5UiCJsGHIAYoNKvl7Il551XiN490ROhvdqlgNI9tkPvG4+Sp3Hn iFIS2lfwAQh38NoTRET0IViANVMSwsK/KtElqQvnpvnnemBjM1FGhKLKU2psaJsSWDOMHQBMhogx SPiA8Ob5vkpc+CA7OXDlixXPoxfJc96yi58WzFm4MHBoZtWbFmxUzaMDN7/LB9ByRGihwfeREoDG itfidFCx0dDmjgoSclyzBc3dDRe4LLGi54geRg05crLnVZ7fhFRUikP0Kh1eDospyXMnm8OHC52f f1aNXdi9F7Jq9seyVI5O7JosspmwYOR9MD2kVMWCzZ6qdsjp79Cypa9dZsll/h5MYnNsRhJjZfci 5UhcfPKZiMrTcD+Q8/OfsKFIoUrCgYhSwpGCUMKGNNQooY0wpn+J5FQS5yK4rSykNkOwlDxcdb80 LO6MiyCkUUVYLj7M4+dzldYwV0tUVLQzsljJQ9KSMFyGsITQWU2ktBBGylZBNFkfX5fJjl45s6s6 Rc4OMB56Si4/qm9QgCPjocdbV1cc+Y0fEoXPkfSfMQXLElz5GjJiQqVFNH0cHFS99WDBRmd02Wdy JzZs27FxbOsJOLi59Fmzm4JoyOjgpmxNzd1cmyvESJ+SQ4ExeWLm5NHpPZ9s0hvzdls3hwbMHNk8 gGDu7ubFqyeFlPDc4NX9kaLmjg2ZN3Ze4NDGlVm98k9k9LEdAGTR6mRweVRkVLpnbs8cmSf6FH9F C85nxWLbXxs1ebm+XuwmntkJ3NOj4fZa7Io+kl2a4CigNkNIrWYLy717S+we1+knZb57BA331Pnf siqwsuxuxScy9fiw0hRLqGipMYUk/mXzD+DDPY9/9OkMjeWG5Iyx3Zx7W6zBlCiMM4utQ3tOCHLC aVn7OYNfHN4cBDcZe2ybt8GjmZrqVyLTSXS1FPUywMGXCoKt9nQobyqlBWSMI6yu1SqhZwz9P1fT 8u6InfQlRUN+MnbkO8BDiirV6uJO9hXWBqIgqCI1j/Jx7LW/GvAcj7n1+t7SQ+xqD7njTby+ft65 fr+nV1e1u2UU8lnbtk5M3Z3cCmCxzNFzqxNm7Jkp9y9qA7uTNz8VlyrTr3wql92PLUmN6bVxSVar 1pa29iwsD2H8qVLnR8TY3PB3eXl5XuDyNGzq7YsXBmk3cHhi6s2yy5qycnBqwWeRq2cV7g9Pgez2 p/OSLSE9CbnCCskgSEI6YlkDiZyIpgDljGJCJcItigF0G81mY4EKOB4Pv1LNhXfSb4f3tno3excp 7HzuqvD1eRm93uwerV4WeSzN0DocTtFsO88nydq3PMe8j116Q8cpeUGYK6XMMXEZihcaQn6oTh6c SVBwZK/EcXOEpZmtCWxzdGmO04GUyaWi3zliqlvq+rzU9y5u+jGn1WYll89X0nY4FQ/bRRixB8n0 +1J8W3xfT6ZsHozVPMHh9E9SI79JPCSSy/yW5OYw8SB7fkMT3DkE8RhIvEPjrVetV7BXx7A8Q6B5 gG2vQaIp2Plx50XAyYqeAQshZPjP5QqSek937wfmFkVHgByAm83EDFkRSIPySjUIY3NkQOAImBcN l6YbtsYHzpzcWBrF5fivKL6qr/5LJhJ6E6fozqn0j9vX3skgzaR6pENtYuaO5M8hKdGipU5/oF/t qy+ZX3rnTOXHYnRfnqkz7E85SbzSgjIwSbD3TDMeZUJH+sd5cxbhVMR0pr6KB+SUtAm/IrRBO08A 8x6T7n3rPzKWXP0tXhgyYKexi9H5/z7ub8zRT84AMEkkA5uMXORjcoIImcubEGTRY5MF7/hGbJQo cHoImDkuKblDY1wKXMEnsRJQwbDlzffsEEDG5Y7ncyZSTsUHIHOQwQ5NJCWXPem+cnlezekhL4Ki qP6CR2H3opBUuEZd0Uo9IsRgET7Qjp5nQjlDlG8TCDGCmYL3zEM6MkiB3WsJEtHuCNYloHBwKBuQ IIscq5iIcfgD7aSABe/C8vBT7IheWg4EIQshqRP1qgm3Mof3B+pXmDKSRhFoAA/pj7kqNoeBgUGU GTnEnMagLTWjAwrRBzCZBY61JMAY6Bhp52bG0lmyNrJawVKCSKU/1HSq+wXpD1msKieWkgyMgxjZ CmiykgwD4tK1zog3OcP2ol3TLNyBFgnyiqwgSIwih2XGQLfSpHEIFMMmvxFauWAwciN+aEIJIMGU fEW8MwFw9jnHoDeoD51+kwoSaRcz0ghId3kLFi1izYtZEyKv1ZFNaG+ppVBPSqCWDiq6FG8SAy0J FiRdKVSg/gAXBnW1wHcMFPOB9sGfbEicTW1yxodJJ5o6SXaE/GROsbn+ewax/kwdg9wubc8TEg4J rBSRQbEFT0i9Yn1KCYB6HqyAAGqKGgWFkLpIAdh9tDqAgj5Mw1ELKgl4m5Xyq3oV5a0/WIuJtTNE hJB3KQajR34YjfW09e3shffhlhzHoy2UO1V7FesWK+Cu4dsTQB1Rclhe9Rop4XKniO8bh17l1BAh CESAiQRhIpBGIMkQhBFJfFU8VXlNC4R2b8xCGyDRAgQIMPVLRdUqqJj5B8pzh9j2JRUhG64kKGc+ xKk+KtlRFxEc5IRu1Q5n7ljAmbJwTbtH2pOFtSrJ8MB0JFE8TIn/OQzTUYpNY7SOFVJZFksAqZ0q rXvQDeJcGovA8/giuY4SEPWUUSBAgFRSiikhFSjoe6Pc5HtEXEXY6Dk20DTIjbAoIWbD5Agu4EbN w2yBfpD4ngCbzDKYCfpejOnWQFIS5oKHHLSKehQ0pSqXnr1oXAiaUXPh36hdI+cVuF1qOIPKGYOT jsVRPJTw2a6Vu51YOa9M4QFDFE0R/4oaCEkQ5YUgJCFD5853BzzEuO8sk0ZlLfiSafeneSTBLtBG MdgJyBgR0FY7/gIuFG0mcg5kkaqzYabFSSQxvvuexzj3pToWPlXm8qfFZ9Iy1iatJAkETUoMQEga hWsNQSIMkpcqfclkTSN6pBeWqJspSoukXMsM63YLDIU5h0IOhXIcw5xdI3PlUHE+JBCMUmnANSHG GIkELMUoiJQcihOUVnULNZoMYRy0ypQ0hDSY6LmksXBASGWybUbmipYVjII3QZhPQUww2MDYEMkD GFZYSRJ1ZCgpB0c8hcQuhSYQFSEtJCPwsSZbSEyD852YcNzRVJvSlIkIdECFihMYLmihSEmBNQPT TDAujaDDNEJhEnGUvtGomKEXo9wvYwl0JiqxVoiyrSHNP4FkkTSAUK2Wxk0GWaT7q1oeH5UmQyJV GlRbRLpQukVIlRI0VCarmy6S0pCqhC8+4ukjiRIGQ6pz9J5zOpOHlsJj8rYIHQblgYCFQTIKeBeW LKHSq3Jw8Bp1dQ6GBpjlVxX90cyIcSfShrD2oHYA4gwt6wLKhFg3FpIRaY2Q4SMyoiqiVRQihCMc +KWVALFy+oYg6xstwGy650k2/sO3T318DBEu2NDpH47h7BVRxr7ShYiGIi4nOv1h0H6cFA0cgmVQ xVOh6TZEJBidVUniH6A4Lpk4b0JpMA8jzmQeD92SMCzoTScZ9dHInoOU8PNJv8LFwwQLEkECn7xe gOoblOQHdFYinWPsH1oLhcEO3ihDlSJkfSbMFB1hrdAukxLvUtUg9L9yS10TuqNIHukkqZpp5I6P 5ebkjU1VS5O5KTW482LgX/CMCqwSXw+kkWRIyeEk+Uk5yTaCCCkETSFEBOQb4WQiwIQV4hawi2B3 D0B3Ws4wEhDCPyClczGspW61IZLgqiU0UuRTeOfRC+rzvD8R7JLo/R2tGsaTSJFKiC6HFrPNcR5p +xLRI9EqQuk5mp4FJA1dKYaNF+7g5m+6hZEfQgygi4AUKIdRK27jfVE0taMIuM84uVTKUT7EnXDF KlUpGcnAqRjnRMCifekJGkIO4gnAdMAc0FAyO8vKCa6NJxAkmAiYYIyFbZQW8uOKZUJURPnMFhwj 7jZRwggC1wchPwmhhwVE8rCYoOfGBy5K1FDtlscDFdc6ucGtRKYIfVReqRxYYcjO/HFCpjECYGZz X3jkBg1nWFoeAi61bK4EIxgEVJGEQDbiEgSBlKXYQsl7vJOKl7A6W7FH4u2nZeWMHaYyE2QmpehZ jDlIdTAlSVIRnbj3yJFyTBzgXNRIIEnbOogBXfQpuM+HJ/DvLCautwRuTImo12S+HOqmMGPTlQuT XFH+3e0fOqil47erwiTsLxgetQvwkKkO6S5nxebSeac/NLv5I0tGXVixXZ3M8F6kvz9ezQnjlUHl CqWHLpUGJkKizCJREgYGqQClnRGWgCbUN54hjmkzgZAdE4wB3XBAaT2XJdiZsl6CTORNEkxvY/NO aXkxiRuhkJGUZFyJLUUvWOrjCfqpL4KYJGaN0oZS1kmeiYjdlwYtJZbMpdoqoVN5JM/r2XsS2dJ+ PkYKEjNMUjdC5EjCkh4pwvLOVSFkyusTJ9FDkXqjkkhAOmkzA6DAvuY/ZFHt7CdtDeAJvL0TdqOQ zxkDlIVIyDRCgpSLRzgwrBixBBGCKkUe1BvcDDzkk0FlSHhSLUspSo2RJjehseheBbmaA6wADJdq N5Ugs2Log7R3MSMYxjGj8RyhQBEyILxUzDOwNhQGpJ7J4x4pmUm87i4wi9ISP6iWOfUvHSil2xR9 gmkNeImZwuHn79aQV0YF6CZEdiuEA99l2FYowXyexhQ3TPKBp/wBkDzLAgRgbWBDIRTWLyKlw6xe DC4nKQu6JvHJ+9ElyX70UeZmhkS/tgY4wkfBJgmsh84zpmkyebSfvlSaio+8zecSjtXzfWzGLrEM pSRcyRJeuaDvEXrDQb5y89fpcqFcFTQcNj0i9Ivfzi4H4CsFU/EM4i9gawzTq5yoaIfDuXAvMpe4 ZAgncGS4wookg0NCLcNh+QvzKvLsOAGDmTHNf+rKLdwFXL9otHiK7x+88RMIQp/8XckU4UJB4xRM 5A==