From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755608AbdDQV2G (ORCPT ); Mon, 17 Apr 2017 17:28:06 -0400 Received: from mga11.intel.com ([192.55.52.93]:41439 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754468AbdDQV2D (ORCPT ); Mon, 17 Apr 2017 17:28:03 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.37,216,1488873600"; d="gz'50?scan'50,208,50";a="846966735" Date: Tue, 18 Apr 2017 05:27:07 +0800 From: kbuild test robot To: Anna-Maria Gleixner Cc: kbuild-all@01.org, linux-kernel@vger.kernel.org, tipbuild@zytor.com, Thomas Gleixner Subject: [tip:WIP.timers 8/10] kernel//time/timer_migration.c:190:4: error: implicit declaration of function 'timer_expire_remote' Message-ID: <201704180505.dI4AIR8C%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="VS++wcV0S1rZb1Fb" Content-Disposition: inline User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: fengguang.wu@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --VS++wcV0S1rZb1Fb Content-Type: text/plain; charset=us-ascii Content-Disposition: inline tree: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git WIP.timers head: c0b7a5dbb870d1660aa5e566c5ce9972290a2bed commit: 6a3164fa4cd35a587b5bb2e4bd86b75900af8286 [8/10] timer: Implement the hierarchical pull model config: i386-randconfig-r0-201716 (attached as .config) compiler: gcc-5 (Debian 5.4.1-2) 5.4.1 20160904 reproduce: git checkout 6a3164fa4cd35a587b5bb2e4bd86b75900af8286 # save the attached .config to linux build tree make ARCH=i386 All errors (new ones prefixed by >>): In file included from kernel//time/timer_migration.c:16:0: kernel//time/timer_migration.h: In function 'tmigr_cpu_idle': kernel//time/timer_migration.h:26:1: warning: no return statement in function returning non-void [-Wreturn-type] static inline u64 tmigr_cpu_idle(u64 nextevt) { } ^ kernel//time/timer_migration.c: In function '__tmigr_handle_remote': >> kernel//time/timer_migration.c:190:4: error: implicit declaration of function 'timer_expire_remote' [-Werror=implicit-function-declaration] timer_expire_remote(evt->cpu); ^ kernel//time/timer_migration.c: At top level: >> kernel//time/timer_migration.c:223:6: error: redefinition of 'tmigr_handle_remote' void tmigr_handle_remote(void) ^ In file included from kernel//time/timer_migration.c:16:0: kernel//time/timer_migration.h:25:20: note: previous definition of 'tmigr_handle_remote' was here static inline void tmigr_handle_remote(void) { } ^ >> kernel//time/timer_migration.c:348:5: error: redefinition of 'tmigr_cpu_idle' u64 tmigr_cpu_idle(u64 nextevt) ^ In file included from kernel//time/timer_migration.c:16:0: kernel//time/timer_migration.h:26:19: note: previous definition of 'tmigr_cpu_idle' was here static inline u64 tmigr_cpu_idle(u64 nextevt) { } ^ >> kernel//time/timer_migration.c:406:6: error: redefinition of 'tmigr_cpu_activate' void tmigr_cpu_activate(void) ^ In file included from kernel//time/timer_migration.c:16:0: kernel//time/timer_migration.h:27:20: note: previous definition of 'tmigr_cpu_activate' was here static inline void tmigr_cpu_activate(void) { } ^ cc1: some warnings being treated as errors vim +/timer_expire_remote +190 kernel//time/timer_migration.c 10 #include 11 #include 12 #include 13 #include 14 #include 15 > 16 #include "timer_migration.h" 17 #include "tick-internal.h" 18 19 #ifdef DEBUG 20 # define DBG_BUG_ON(x) BUG_ON(x) 21 #else 22 # define DBG_BUG_ON(x) 23 #endif 24 25 /* Per group capacity. Must be a power of 2! */ 26 static const unsigned int tmigr_childs_per_group = 8; 27 28 bool tmigr_enabled __read_mostly; 29 static unsigned int tmigr_hierarchy_levels __read_mostly; 30 static unsigned int tmigr_crossnode_level __read_mostly; 31 static struct list_head *tmigr_level_list __read_mostly; 32 33 static DEFINE_MUTEX(tmigr_mutex); 34 35 static DEFINE_PER_CPU(struct tmigr_cpu, tmigr_cpu); 36 37 static void tmigr_add_evt(struct tmigr_group *group, struct tmigr_event *evt) 38 { 39 /* 40 * Can be called with @evt == NULL, an already queued @evt or 41 * an event that do not need to be queued (expires == 42 * KTIME_MAX) 43 */ 44 if (!evt || !RB_EMPTY_NODE(&evt->nextevt.node) || 45 evt->nextevt.expires == KTIME_MAX) 46 return; 47 48 /* @group->group event must not be queued in the parent group */ 49 DBG_BUG_ON(!RB_EMPTY_NODE(&group->groupevt.nextevt.node)); 50 51 /* If this is the new first to expire event, update group event */ 52 if (timerqueue_add(&group->events, &evt->nextevt)) { 53 group->groupevt.nextevt.expires = evt->nextevt.expires; 54 group->groupevt.cpu = evt->cpu; 55 } 56 } 57 58 static void tmigr_remove_evt(struct tmigr_group *group, struct tmigr_event *evt) 59 { 60 struct timerqueue_node *next; 61 struct tmigr_event *nextevt; 62 bool first; 63 64 /* 65 * It's safe to modify the group event of this group, because it is 66 * not queued in the parent group. 67 */ 68 DBG_BUG_ON(!RB_EMPTY_NODE(&group->groupevt.nextevt.node)); 69 70 /* Remove the child event, if pending */ 71 if (!evt || RB_EMPTY_NODE(&evt->nextevt.node)) 72 return; 73 /* 74 * If this was the last queued event in the group, clear 75 * the group event. If this was the first event to expire, 76 * update the group. 77 */ 78 first = (timerqueue_getnext(&group->events) == &evt->nextevt); 79 80 if (!timerqueue_del(&group->events, &evt->nextevt)) { 81 group->groupevt.nextevt.expires = KTIME_MAX; 82 group->groupevt.cpu = TMIGR_NONE; 83 } else if (first) { 84 next = timerqueue_getnext(&group->events); 85 nextevt = container_of(next, struct tmigr_event, nextevt); 86 group->groupevt.nextevt.expires = nextevt->nextevt.expires; 87 group->groupevt.cpu = nextevt->cpu; 88 } 89 } 90 91 static void tmigr_update_remote(unsigned int cpu, u64 now, unsigned long jif) 92 { 93 struct tmigr_cpu *tmc = per_cpu_ptr(&tmigr_cpu, cpu); 94 struct tmigr_group *group = tmc->tmgroup; 95 u64 next_local, next_global; 96 97 /* 98 * Here the migrator CPU races with the target CPU. The migrator 99 * removed @tmc->nextevt from the group's queue, but it then dropped 100 * the group lock. Concurrently the target CPU might have serviced 101 * an interrupt and therefore have called tmigr_cpu_activate() and 102 * possibly tmigr_cpu_idle() which requeued CPUs @tmc into @group. 103 * 104 * Must hold @tmc->lock for changing @tmc->nextevt and @group->lock 105 * to protect the timer queue of @group. 106 */ 107 raw_spin_lock_irq(&tmc->lock); 108 raw_spin_lock(&group->lock); 109 110 /* 111 * If the cpu went offline or marked itself active again, nothing 112 * more to do. 113 */ 114 if (!tmc->online || cpumask_test_cpu(cpu, group->cpus)) 115 goto done; 116 117 /* 118 * Although __timgr_handle_remote() just dequeued the event, still 119 * the target CPU might have added it again after the lock got 120 * dropped. If it's queued the group queue is up to date. 121 */ 122 if (!RB_EMPTY_NODE(&tmc->cpuevt.nextevt.node)) 123 goto done; 124 125 /* 126 * Recalculate next event. Needs to be calculated while holding the 127 * lock because the first expiring global timer could have been 128 * removed since the last evaluation. 129 */ 130 next_local = get_next_timer_interrupt(jif, now, &next_global); 131 132 /* 133 * If next_global is after next_local, event does not have to 134 * be queued. 135 */ 136 if (next_global >= next_local) 137 next_global = KTIME_MAX; 138 139 tmc->cpuevt.nextevt.expires = next_global; 140 141 /* Queue @cpu event (is not ne queued if expires == KTIME_MAX) */ 142 tmigr_add_evt(group, &tmc->cpuevt); 143 144 done: 145 raw_spin_unlock(&group->lock); 146 raw_spin_unlock_irq(&tmc->lock); 147 } 148 149 static void __tmigr_handle_remote(struct tmigr_group *group, unsigned int cpu, 150 u64 now, unsigned long jif, bool walkup) 151 { 152 struct timerqueue_node *tmr; 153 struct tmigr_group *parent; 154 struct tmigr_event *evt; 155 156 again: 157 raw_spin_lock_irq(&group->lock); 158 /* 159 * Handle the group only if @cpu is the migrator or if the group 160 * has no migrator. Otherwise the group is active and is handled by 161 * its own migrator. 162 */ 163 if (group->migrator != cpu && group->migrator != TMIGR_NONE) { 164 raw_spin_unlock_irq(&group->lock); 165 return; 166 } 167 168 tmr = timerqueue_getnext(&group->events); 169 if (tmr && now >= tmr->expires) { 170 /* 171 * Remove the expired entry from the queue and handle 172 * it. If this is a leaf group, call the timer poll 173 * function for the given cpu. Otherwise handle the group 174 * itself. Drop the group lock here in both cases to avoid 175 * lock ordering inversions. 176 */ 177 evt = container_of(tmr, struct tmigr_event, nextevt); 178 tmigr_remove_evt(group, evt); 179 180 raw_spin_unlock_irq(&group->lock); 181 182 /* 183 * If the event is a group event walk down the hierarchy of 184 * that group to the CPU leafs. If not, handle the expired 185 * timer from the remote CPU. 186 */ 187 if (evt->group) { 188 __tmigr_handle_remote(evt->group, cpu, now, jif, false); 189 } else { > 190 timer_expire_remote(evt->cpu); 191 tmigr_update_remote(evt->cpu, now, jif); 192 } 193 goto again; 194 } 195 196 /* 197 * If @group is not active, queue the next event in the parent 198 * group. This is required, because the next event of @group 199 * could have been changed by tmigr_update_remote() above. 200 */ 201 parent = group->parent; 202 if (parent && !group->active) { 203 raw_spin_lock_nested(&parent->lock, parent->level); 204 tmigr_add_evt(parent, &group->groupevt); 205 raw_spin_unlock(&parent->lock); 206 } 207 raw_spin_unlock_irq(&group->lock); 208 209 /* Walk the hierarchy up? */ 210 if (!walkup || !parent) 211 return; 212 213 /* Racy lockless check: See comment in tmigr_handle_remote() */ 214 if (parent->migrator == cpu) 215 __tmigr_handle_remote(parent, cpu, now, jif, true); 216 } 217 218 /** 219 * tmigr_handle_remote - Handle migratable timers on remote idle CPUs 220 * 221 * Called from the timer soft interrupt with interrupts enabled. 222 */ > 223 void tmigr_handle_remote(void) 224 { 225 struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu); 226 int cpu = smp_processor_id(); 227 unsigned long basej; 228 ktime_t now; 229 230 if (!tmigr_enabled) 231 return; 232 233 /* 234 * Check whether this CPU is responsible for handling the global 235 * timers of other CPUs. Do a racy lockless check to avoid lock 236 * contention for the busy case where timer soft interrupts happen 237 * in parallel. It's not an issue, if the CPU misses a concurrent 238 * update of the migrator role for its base group. It's not more 239 * racy than doing this check under the lock, if the update happens 240 * right after the lock is dropped. There is no damage in such a 241 * case other than potentially expiring a global timer one tick 242 * late. 243 */ 244 if (tmc->tmgroup->migrator != cpu) 245 return; 246 247 now = get_jiffies_update(&basej); 248 __tmigr_handle_remote(tmc->tmgroup, cpu, now, basej, true); 249 } 250 251 /** 252 * tmigr_set_cpu_inactive - Set a CPU inactive in the group 253 * @group: The group from which @cpu is removed 254 * @child: The child group which was updated before 255 * @evt: The event to queue in @group 256 * @cpu: The CPU which becomes inactive 257 * 258 * Remove @cpu from @group and propagate it through the hierarchy if 259 * @cpu was the migrator of @group. 260 * 261 * Returns KTIME_MAX if @cpu is not the last outgoing CPU in the 262 * hierarchy. Otherwise it returns the first expiring global event. 263 */ 264 static u64 tmigr_set_cpu_inactive(struct tmigr_group *group, 265 struct tmigr_group *child, 266 struct tmigr_event *evt, 267 unsigned int cpu) 268 { 269 struct tmigr_group *parent; 270 u64 nextevt = KTIME_MAX; 271 272 raw_spin_lock_nested(&group->lock, group->level); 273 274 DBG_BUG_ON(!group->active); 275 276 cpumask_clear_cpu(cpu, group->cpus); 277 group->active--; 278 279 /* 280 * If @child is not NULL, then this is a recursive invocation to 281 * propagate the deactivation of @cpu. If @child has a new migrator 282 * set it active in @group. 283 */ 284 if (child && child->migrator != TMIGR_NONE) { 285 cpumask_set_cpu(child->migrator, group->cpus); 286 group->active++; 287 } 288 289 /* Add @evt to @group */ 290 tmigr_add_evt(group, evt); 291 292 /* If @cpu is not the active migrator, everything is up to date */ 293 if (group->migrator != cpu) 294 goto done; 295 296 /* Update the migrator. */ 297 if (!group->active) 298 group->migrator = TMIGR_NONE; 299 else 300 group->migrator = cpumask_first(group->cpus); 301 302 parent = group->parent; 303 if (parent) { 304 /* 305 * @cpu was the migrator in @group, so it is marked as 306 * active in its parent group(s) as well. Propagate the 307 * migrator change. 308 */ 309 evt = group->active ? NULL : &group->groupevt; 310 nextevt = tmigr_set_cpu_inactive(parent, group, evt, cpu); 311 } else { 312 /* 313 * This is the top level of the hierarchy. If @cpu is about 314 * to go offline wake up some random other cpu so it will 315 * take over the migrator duty and program its timer 316 * proper. Ideally wake the cpu with the closest expiry 317 * time, but that's overkill to figure out. 318 */ 319 if (!per_cpu(tmigr_cpu, cpu).online) { 320 cpu = cpumask_any_but(cpu_online_mask, cpu); 321 smp_send_reschedule(cpu); 322 } 323 /* 324 * Return the earliest event of the top level group to make 325 * sure that its handled. 326 * 327 * This could be optimized by keeping track of the last 328 * global scheduled event and only arming it on @cpu if the 329 * new event is earlier. Not sure if its worth the 330 * complexity. 331 */ 332 nextevt = group->groupevt.nextevt.expires; 333 } 334 done: 335 raw_spin_unlock(&group->lock); 336 return nextevt; 337 } 338 339 /** 340 * tmigr_cpu_idle - Put current CPU into idle state 341 * @nextevt: The next timer event set in the current CPU 342 * 343 * Returns either the next event of the current CPU or the next event from 344 * the hierarchy if this CPU is the top level migrator. 345 * 346 * Must be called with interrupts disabled. 347 */ > 348 u64 tmigr_cpu_idle(u64 nextevt) 349 { 350 struct tmigr_cpu *tmc = this_cpu_ptr(&tmigr_cpu); 351 struct tmigr_group *group = tmc->tmgroup; --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --VS++wcV0S1rZb1Fb Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICKYw9VgAAy5jb25maWcAlFxLc+M4kr73r1DU7GHm0F1+lac6NnwAQVDCiCRoAJQsXxhu l6raMS6r15Z7uvfXbyZAigCUVMfOYbqETLzz8WUm6L/98LcZe9/vvj/snx4fnp//nH3bvmxf H/bbL7OvT8/b/57lalYrOxO5tD8Bc/n08v7Hx6fLz9ezq5/Oz386+/H18Z+z5fb1Zfs847uX r0/f3qH70+7lh78BO1d1Iefd9VUm7ezpbfay28/etvsf+va7z9fd5cXNn8Hv8YesjdUtt1LV XS64yoUeiaq1TWu7QumK2ZsP2+evlxc/4rI+DBxM8wX0K/zPmw8Pr4+/fvzj8/XHR7fKN7eJ 7sv2q/996FcqvsxF05m2aZS245TGMr60mnFxTKuqdvzhZq4q1nS6zjvYuekqWd98PkVndzfn 1zQDV1XD7F+OE7FFw9VC5F1esQ5ZYRdWjGt1NDN35FLUc7sYaXNRCy15Jw1D+jEha+fHjYu1 kPOFTY+DbboFW4mu4V2R85Gq10ZU3R1fzFmed6ycKy3tojoel7NSZhoWD5dask0y/oKZjjdt p4F2R9EYX4iulDVcnrwPDsAtygjbNl0jtBuDacGSExpIosrgVyG1sR1ftPVygq9hc0Gz+RXJ TOiaOdFulDEyK0XCYlrTCLjWCfKa1bZbtDBLU8EFLmDNFIc7PFY6TltmR3M4MTadaqys4Fhy UDo4I1nPpzhzAZfutsdK0JQptrbRKhNmJBfyrhNMlxv43VUiuN9mbhnsD6RvJUpzczm0H1QX bs2Ain98fvrl4/fdl/fn7dvH/2prVgm8bcGM+PhTosNS33ZrpYNjz1pZ5rBJ0Yk7P5+JFNgu 4NJx+4WC/+ssM9jZ2bC5s4jPaLfef4OWYUStlqLuYDumakKrJW0n6hUcCK68kvbm8mIgcg23 6TRVwo1++DBayL6ts8JQhhKOmpUroQ1IDPYjmjvWWpXI9RKkTJTd/F42NCUDygVNKu9DlQ8p d/dTPSbmL++vgHDYa7CqcKsp3a3tFAOu8BT97p44yWitxyNeEV1AEllbgropY1Hsbj78/WX3 sv3H4RrMmgXnazZmJRt+1ID/5bYMJF8Z0IrqthWtoFvHLqOgOBECDVJ60zELPmlBLLlYsDp3 RuPQsTUCDCh5XqzNSffs7tAptuPAxYDWD3oBSjZ7e//l7c+3/fb7qBcHrwE66KwA4VCAZBZq HWgNtOSqYuDeiDawl2DFYB2bcEMB3VklYgPIAhCBg2HzCh5ZNtMwbQQyjW0c3b9RLfQBC2r5 IlepLQxZcmYZ3XkF7ipHb1UydAIbXhIH4QzSajzX1OXheGAWa2tOEtEWsZzDRKfZAD10LP9X S/JVCs127tGBu2D79H37+kbdsZV8CZZPwCUGQ9WqW9yjJatUHV4UNIJflCqXnLgj30vm4fm4 tmgIgBRg7Y07MW3CYTzObNqP9uHt37M9rHn28PJl9rZ/2L/NHh4fd+8v+6eXb8ninZ/nXLW1 jWQCJcbdSkQ8rCMzOQo1F6CDwGFJdULngTDreJmatzNDHWe96YAWoCIOWOMOTi3En54jngY5 iUPF/rCEsiSuw2ohHIPDshOdl71DbODebs4iLwoQs74IzJtc9hD7qMUd1dhcKhyhANWXhb05 /+fB4mlZ22VnWCFSnsvIFLUQEXjfDWAu96IdaN9cq7Yx4VbBTPI5eUdZuew7EAfgCX6WAMIw qTuSwgtQQTC4a5mH+FnbhH004r69kbmZnl5HmLtvLODy7l0glA7WQzxytyDtAHFPzJWLleSC GBV6pnKe7EHogug3ZZGN4ssDjzeeY9eF4MtGgTCgqlulBbkZdMFgukEHqfGdZCAUcnOEw4OZ LRDANlpwsHI5JflxZIFCAifjMJ0O7tv9ZhWM5o19gMh0nqAtaEhAFrTE2AoaQkjl6Cr5fUXN jqARTsqDwp++/W+IJ/kB1KMHdNeEsXJNanzKHYdIKW5hNaBNWUNAHrglr6AyP79OO4Ih46Jx sY6zOEmfhptmCQssmcUVBqffFOOP1BgmM1WAzyTIeJAhMKAOFZjIbnSviSj0BFLI+qUTLBFM 8+5onHQJzGZTES1dsoSxPTOqbAEowAZB2yjIOrBmEOs4GbVyFSJGZz/T311dyTD+CeyzKAuQ nTBiPL6E0VLipEVLHkIB6w6ibdGoEMYYOa9ZWQSK444rbHDApIhsI1z7iWM3Cx88jthVKoKN 5StpxDBO5BNQShyeLygL0HDZ3bZSL4MrhBkzprWMza5LBeSkGfFyDdN0KXhzjbCCblUl8XPD z8+uBuTV59Oa7evX3ev3h5fH7Uz8vn0BQMMA2nCENIDMRgBBztWH6sczHrawqnynzkGdBFeN qlC22aQ9H7JOLtYOurCMujwYKWZTtL/C/s7VYejfaXCtqppSUysq50k6iINlIbnLqlA3q1Uh ywjsKd8mjlv6c3FmpSlDGXd3e6IjaJ0X85H2r7ZqIAzIRKgbgA8BdS/FBuwQ6CPG/ZGU+gQK uWm3BJdSBaMCOoYOjyMknRJFUcC5SNxQW8c9ktAG5QQxHgBSgLpRVOsGkmA0MIkIi7MJaZlm fHyrFpYkgLuhO/hWTKsUlLeIjNoYnzrWhVLLhIhpTfht5bxVLRFEGbgZDD368DBN0zG8HNtH 20R+DeDEBuAIRnLO07h8dbIELeZg5Ovc54/7c+9Yk+6Dl9Tigc/rXkJbrEHnBPNwKaFV8g4u eCQbt4bUVYMZhHbb6hrCLQuaE4psasGIc3dUYuDB4Oh+w3lbpWLkzo/Siv7U/T37gIBXDSaH 0xF6KfYn7vKR6XH6fj5FNkHLVTuRWcV0jc8ODEk3YgdGcDR/Hei9PTq8OWCqpmznso68T9A8 pa3A4U4OlUxwgMFBEECQQsgXE+Fe6wm0lzDCNbYl+4vR4KxVTfmA8UTW0i7AdPiLLzQC9dSC kPE1pc81pmdEn+UmLtjLCmbAwbMFElapvC3BgqAtQ6CjCQEznuL8ynE14Lg+kzCIOzC9pMWI e32O71U1myHPbGNMEmyIGSqfhyWYrE3MBsS/NdhrOOs103mwSAVBOoCvvoRweURgrqgW3XbT YtJldBRFccL3uJWu+moSX9I5ReRRDvazcsiv6vXd/4t5SL1SCO9goC0Ycht0Cp3sJCnt7qWm 5/Fpf65WP/7y8Lb9Mvu3h2O/ve6+Pj37XFKg0GrVz3BqlY5twAhRss9bi94feX+1ECj4USKh QqQdapOD5QYx3c15kPDwwk+sZFALl/0pwVO2gc5kfSblME6Z5awgRsGI2HAjQatuWxHmEYdY OTNxwmxsTrLPCQP4KTHX0m6o3vcg6DkpOS6PU+WusOcMtp6YY50li4WGztyms2FrdTs5lcfU E7rhDgeckmpYJAtOXJqH1/0T1sVn9s/ftiF2Z9pKFx1D0ILxeRQNMYjT6pGHEjEIQw/0sKsy xemOFViCqOtAsExLesyKcXrMkcPkyvwFT5lXJ1dm5hPTgynQ4XbpmKA9fWBLpitGjy8K+VeD b8zq+vNfMAUCObkKFJbqFuPNweBAIGsef91igTOM7aTyOa1aqbDM2Lfm4E1wrmMKL4KyxlDC CtgPqx1o0IHczUDHBZyojvXz3nz4sn34AlZye8iJwTanl8tMfR6kdWpXgAbL1gCOaOs4wxvX mJlViLx1tU440PO78lnuhnFFmWkWvU4YxhSrV9zX3eP27W33OtuD4rrawtftw/791Snx4ZTQ RKH5pqWmok4OX78UggEEFz6pOa7BkbBwNNAxPkzoVeMMXoQuwcEXkkYQYF/BB+YQM4Y9cCBx ZwEm4OuFPv1D7gE5/SBlY2gDiCysGsfp08rUatA4VZkMlzK0HecaogkuLwBEyolUhRMyEAvr 0Wfn4h/SJyw2EKispAFgO489GZwqW0kdheND26m1CdLYrKrD+GPub1Wd9iSl6+I7kgyH9SRY msp7DKxJuQTgXqaUTdJp1dXna9qufzpBsIZP0qrqjlhVde2eeo2cgFStbCsp6YEO5NN0WnQH 6hVNXU5sbPnPifbPdDvXrVF0zaJyyFpM+cy1rPkCYs6JhfTkSxoCVaJkE+POhcrF/O78BLUr aUhe8Q242snzXknGLzv6eYYjTpwdpp0neqE9n9T6HiBPWFGn5FiQ6N95+erhp5ClPE9o0fAN QHOwtXR1BBnQYTgmV6QybRXbYlCAuKFPMVxfpc1qlVhxWcuqrVwEVgAkKzfxup2d4LasTJAH 6EvQGJSLUoQpJxwGPKS31MfN7lKjJ5cDBex2GhC6DqA5rKUM6MDhQvVKWOaHPRqhrThQKAvc CJumSl2bqNoSX05oGxxqHiagzFqq6DmbVFXVdgtRNuFotXuMZyBAOpybEFVjXWIkMu99+0qV YEeZ3tBG13ORuWXf35nhAM1gggs2ghW7+NbxwBvJU0+MF6eQMCGFLpk19AzlX5HDaaEVVpaw pNc/V0OTj0mYaQdexTrgMVBQiPi+e3na716jJxVhptBjhLZOCkxHHJo15Sk6T16qhhwOZKh1 XJBxByTmjG+6VTXhrCYJ2Pn8OnmlPD6ZUGA1Mkbcivy8PD51PORC3rUNfcqAWkF/wVpN34Gh NM4ZkKaVkaLWCt/GgBen0zWedkWm7Tzt+irIwK0q05SAni6jIH5ovaCRz0A+p+HHXHSqKIyw N2d/8DP/v2QNsTQ3LM3JNosNXHqe6876wkdCd5nyaXIBWgizdKJmxENbh6Knyc7ADg/uKri1 QGpliQJXDjATH321Ynwuc7LvsKiK1S2Lq9OHFXkaVXj1nePROucBfb/wPeJhOF90SqsFospi ZBg194OGA/ojl4YznRPd++0CtC5ZGmC7oXvY6R/b1okeHBaNEtVYtwRnxK+i6f1dDWxoDmya w3KlST4Rfldyrlmc9jghZBnY9bAU5aG3wpTs2Lg0wX0MUbFLCPt3d7m+uTr7+Tp8iHWc5KYe yIUPy5cRWuelYLWDNZSMaAW2Miri8Sp+cANqM1nYHWiFifq71/Hm5vB46z6e4b5RKhDy+6yN rNX9ZQEhKjHdvTkqiPfvwuEAm+QV3sDsBJoYbMimugfnQ9FyKo0ANyW0jmtJg8ceY1OsEToK VhqXdKTlbBcKdu+FDo+qaHqgcGAFGxshEmfrEWp2GcTF+FpDt82ELHunYyCcxczu+ub6KkLV ix5QTSiC1ZEXxd+dYbB/eR8HzjFgJg/enawvq8TbNv4CiGQC4GRyElHQkUdfdKO93X13fnZG ubr77uLTWWSI7rvLmDUZhR7mBoZJ0w0LjS9KyaGW4k5QWI5rZhZJZRTNj0R4B0Kt0Vee967y MJoWiP+cVlCOdujvaqPQ/yLytP1DjVVuVGwCfKoSbDLlZ8BnyWLTlbntjl4ph3a4t/kLZbG4 eUid7f6zfZ0BbHz4tv2+fdm75BnjjZztfsNUeJRA66tVEzDm8L0MtfPwa5LqUC4fcXt1SK1P mrscmI7fe4etLlQBOH1zfnEWzBaV7de3HpYGhbTeEQTHxsMaHv4a7IW7WXNUnPGFRfymqq++ YZcm/IbKtfRPYfz8Djub4Du1oKAwvCiYT6i3Hx8QamH8aJSiI48Wq06twHjKXITfKcUjCT74 kalxWLqVjFlAU5u0tbU2RhOueQWzk0/AkFiw4w65irU1pLkoXAu4xuhtzHAiPuZOI5OEHD9l j4lHi5FNRdu5ZFA2n2uQEqsmb8MuhK7Cpw5+Q62xCnTCgAYX6UdHKcepAqafwyl72wB2ytM9 pjRC4k5slEt8DTb1jSjo2ZAoSBYPEIeB/Zo8ld4i9WH1UX+T0SGa7ztRcwyPrRJ2oU6wAbBo 0e4sACuvATp1qi7p7IJjh39Nf4jjdKURRw+ghvb+kU48IhLosk5ji2P9DoymxEfBIHRTVa7h AuDfpG6b4lDawnetxev2f963L49/zt4eH9Iq+qB3R5kH7Cm/PG/HXAOyyuTbpqGtm6tVVwLU JgUi4qpEHX1N4QQdobYZ+bhqm3JCCDx6QbajNWfvb4ODm/0dJHu23T/+9I8gW8Kja0LZnyuE efRFOHJV+Z8nWHKpBflS35NZHRhUbMIZ4xY/Qtw2TJxwuu+uTLoNXmcXZ6XwL2inlirQJUHk NLFS98wljsKiOSpDy7Nb1qSVQar236wOmAU/EpjkNbalXissbP+5WMQs1WpyoEZPL7dhRk49 Qh5exo0YqLdkKFCpxOXbt6dvL+uH1+0MyXwH/zDvv/22e4UZeywG7b/u3vazx93L/nX3/AzI 7Mvr0+9xrdk/MwoSHP7T7/7d0Sj8hsqFGY6YM0g8uN8LnSZ5AaDeRSksYT99OjsnRpyLUEQx 61dn8eFjDoI8Xw1Lzsm34S4e2ZgiG6yT+GP7+L5/+OV56/7mwcylOvdvs48z8f39+WFAqn33 TNZFZfEB2bgy+BGnO/GXw/eHRAA+OFsIcI3h5wL9WIZr2aSvOBlizZSTbKxkWH3AqePIoof+ l+mHvn0BXaooOobbGA6m3u7/s3v9N9jqALAPRw9hsIiqpvgbTAgLTEVby7v4V8JwV4RffOAv 9ycAkibTZuCpShnGzI7gszjRnzPA516bRLqwaeCdMOaCMpzQil+RY8xZMb2Mp2lsA+CfAeot 0vlcJ4jHnOADWKyaJGEQMvvXo7SHtRWlZjZ8uQXgO3wa6X93q5LV/bvU6IWla/98dnEe2bCx tZuvNB1bBzxVwjMACsHrUCL8786VIALtL8sIhsFPqjgkm0Bw4Edf4guMgWVh5IWvxFgD3jpu lk2eR4kH1wAegDPyRcbFp2htrKGcQLNQ0UalEAJP5tMV1dbVZf8P9w0TSARA1siyB7z4eRwp ihXj6RR4uMOXhU5db9+371tQ1o/9M6KoRNNzdzy7PRoC3FpGNBahWRla3QehR63uQ4nbVO2Q oskvZAaqt8JHjeRIVtxSKYoDOSuOh4KgKafGyg0q9InR4L9hev3QL06WHbZ/i8cypeH+3Bdq SWd3Pf2W3jSWiU7turj1LMdLpcdbLIqTy2zkxEeXA72MAZYH6c8Pb29PX58ehz/8E3Ti8Uvn vgmfr5JVzoFuuazz8LubgVCsqeFassI8ULVZNVQvbKfLgYfZSrU+MTAfPjJNd9cUxMrLvmKZ tFeYYIoya7UrgmMz1eYfXeNfFYmW2xP5RG40YKmzzYQfDJimT7RnwJI/uTwr7ix12owMTgYq XDchw7KIspU5p78Xy2v8xsUo/FsoJEMGrpS5F7bEElbe6ga4DOs7Uh0IxEf0sMJS1ksHZyhz 3RyLPbZ1c0ObCUdEV0mXFhaG+uTbwRBNgtyAw4OU5HT1HQL9TRd/sZndHv66R4/9Zvvt2z4J 1hes0iyfsHecUSlaqXM2jCxfc4Zv6fe7x91zGHzoMs7WSY3nTgM2GM+9BmZHxsgNfwRXXYf+ j0Dhu8rShJjXUd17S62T1iGb7Md++foKQdaXHzGymn3Z/v70uA2iKMdjpD6mBAu3dtMhz1EM t3v5BsHH2yFs63tgsQmfNOeqnoeJxaXJ2f09xLEHwlh2MD9/+rlvP5qnOLm+1mRu3xTulHNQ cFHi37UKhMnwuGEt60zVed+YPqHAZrquU+HfheE8ZRjgXinTEVelkZPDreTRVIOmcRMvOIus VYYfs4p8woyA4NCW01HIv+aAnxmMH3iOjWNx1SeNnt+3+91u/+vx5Yx9kldduFb+f4xdW4/j NrL+K8Y+HCTA5owl3+QD5IGiaJuxbi3KtnpehM6MZ9PYngume7DJ/vrDInUhqaKdh0naVUWK onipKlZ9zKzfB8rjWn5ElNhJm40eWFWNJ8L3MsI34bXAiVTY6t6Vplk4XzSTNu10Q52qzgeK u0wgNaM6Y9qQ5JD6sLBzkOuKkcyfFLLj8qUhJcYcugAoZnr+L3Ivc1LlFckGNqG7PSjnRhy7 1vkDFbYNcR/W4t1Jg83C0gJO9i+kAtA13AE4yFNW1UOGc1vkqAvNqF07HmxEFIM9OZOZCmmj i6SQIJhgptDYNlgrJ7CIA/vi6AQpjxXDb+kYndlT1DlERRFGRSHGAr64ZVhhfGnr3HgoSA6h G2ONfqlf//H5+cvr2/fryz+Q50rrH4vFH/iwZCDVj0sDWqXo4xB8XgW7IuXqvtUKqU+qvEOA jdTQH/NxRmQmnKL62dWq8PrGFMdqd+SmKqF/O2/YEXlemm6sjrovuaXsgZqyReF5CLchZ+Rv fxwLMGVVcrJNysjlB9NId6bZu5Ofmu95bZ6sATG3nfgdqXXXQUvggLhu8+vT99nu+foCuA6f P//40llRs59kiZ+7zcDYBaAewTO7MTDrgvncbdAuwbpPFchXi4VTB5Baa+sYyTx0+gQW4ill WlxRJ6WloqX7b0KbyuZNORXuiJ209dJisbtU+QpYmO9GEKlqOx5DvjMI6aU+5bk57XtKZ9aN VgcAu3mCr/YQKs409IjxJDkKwWww5/yjii0fGZ1DX+kAia1aKiTK5w8deVa4Su5Jo1a4YdAW GSJ3DgZgkXxwnZX2YtPT2gzimXF1rSZ5QlI8wbys9BOlmpWpQ0+FGzY2aHdp04Ik9nnuIMxz fz6t3EYqMogarzFUqaEH3C5A2VLjT1NInzYWOKJCNs6mF310x6bSgre4uDGqlsek4j5jtBNg 58oD8KEFQHfoqpH7b1accc1TPAojmQkVGTD+ylMXlIZpDqYUnI054I1SBbDOCfRve752NFGa wfodMctMx2Ff2j5Mg6MmhWWbAAjcDtXbVIp0RsaZ8unpx4s+1nr+14+vP15nn6+fv37/ayYN tafZ6/N/r/9nHB7DAwDlCsCWwBG7h81u3BV6toDINHCToCqWKWVU9JevIu5LEzWFCJYmpQIu IZ4LvMZysx3Olyf7gvxfPoGEADW1i5nHFIDamJPyB/hqVX4A5K0KnKWPiCHWS0f9/hJ4K1Bg MypizfbBTgUBEsGNizCEzXRap1mk2gxk1TenV7kwZholWIEl1d+fvrzqQ7xZ+vSXZVFBDXF6 lFPCqdaJaN7V1l5nA7LC77bCvITcFa12CdSF2dbCAsUWmf1MaFNRlE4r7chboAwJx3ICZUTU YxZrRbJ3VZG92708vf4x+/DH87epgan6esftKn9jCaPOUgB0uVq48K5defCydWAOwv3uwM4L aLjvW0uBWG4Ycur17zepIDX4uP7bCe5ZkbG68o0rWIBikh9bhdvYBvabONzwJnfpttPhezIG kUZ4UgCnkqh/tn9zHkw/Cw+xzuSepMie7W95Ud/6iMpVoa0+d3hkUnGarAjAkUoF5njq2aea p5OFhGBHpIpTZK4wiQWz9Rk1N7Knb9/gjLubEHD+r2fI0wfI/HYmSAH6Y9OHpTtTEoJws8ms 1MTuHB7n9UG/kZ0fY4qkLP8VZcCg0NCjobU8xLTdN43bCToqA6IgdykONqO6Kks26wbpQ04P QPaOCibi8BafHqP58mYNgsZhO2mbJSJV6bfri5edLpfzvSetFfrNNsPMRa2ETDrI1HDfWkV7 nQFSCVexVL0pqf3jMVWHI13l2lN8ffn0C+gtT89frh9nUuiGY1Y9IKOrlSeZFzou9T+9PEie s4TViUuTv9u6qCEIHdwAKl3F5rJK4c4ANwgjszq1Z4Zap9Ca2fPrv38pvvxCYSpNDBqjpByK e8MYjdWxZy6V3+zXYDml1mMqkBoLgK3GKHU/WU8Hz7KnU0DE7hNVKDbP3ayqNMfu9Kw7HfIP ViidMEDec4feVA5G4G2JQk152RvKqLrxZi1PJvuvokslv/DNe91YLo6FSjlHy49srQEM0fV/ r86hUALYtab6jQnHcX2peI2ZmaO4HECTHVhxKNl5EvIHCbFaLVCEgl4C/qM9LtPSNxEzBqkD F3w1x64WGEQyE8BV7a4564anvelqsga7fGxvdU0v2tl1aPWwieOMsIHvtNcrhJrPaSm/2Ox/ 9P/DWUmz3tJCNUklZtf9oDL+EK1RQOhzUbnrUxT8+WdHt+ecFleOk6UKz5IWiQcRpOxUEfUX 9rmMek+xo/xKQntJFWibOBRp4q6ISiBmcXfRR+iMZeDCqWLmVXdBYp+eGPbgCShXgSFyudkh GrjQdsP7CG1prZo9VcjhQvDToLGgOpvHfD+jhDgp2H/sEXsPYEjPJ00UbbbrG/XL3ceIhSrz 0voxeL6Vs3ywDsvpqbMUtjNyOsyxCaHNT2kKP6YcG8BYtpB7crv7AhAFLQQMcV4uwgZXVd47 u7lVCy0fWsqFaBMccah/UkLodo3nufUiJ1/yeC9AiwuyxzlCqQVPZVJV+qtGRoiQyqvHsi5S B1tKKxBVLDWi51eIzP04+/364enH63WmfBo7MZNKugrb1EVerh/erh+Nw9L+o8XJtFWFsBGn O7JocGOn5+PaFU2kMtuWx5omZ/NOAJPcebMMREibfVFuZMvXWBOVW9WyGleD+0Yd/Lh4qs2i wTa3/Jyx/lxzUgaYN760KgsggIZPBEg7EsttRrhU6hCkobNndoDQSG7dgYAK7ehkrGTPrx+m TjFp7gm5M8ANUov0PA9taL1kFa6aNinRtKPklGWPrn+Sx1lLBD5bygPJfQg2AGjHC4qb2jXf Zepb4JEuVGwXoVjOcb2f5TQtBCCEQf6v69kdQ3bKlqdollyZiG00D4kdr8RFGm7n8wXm1VKs 0Izz73q5lpzVCmHEh2CzsU6neo56/HaOL4CHjK4XK8zNkYhgHVnujFKhRJzw8DCIbxAXDvbX TpDtMsIXROFbcEuCn0bQ0M2u1BQ5eGRVpGrDYDWfDFXGSjB/x0Cf8WMqjpz7IaYrdtwhedwt lpFmHW1W/pLbBW2MOxM6Kk/qNtoeSiYsVwGNN8F8Miz1vUDXP59eZxyOvX98Vqj0r39AVNTs DXytKjQK8P9g6f7w/A3+NF+yBj8P5gI15mp3qqCKkZe36/en2a7ck9mn5++f/wNZLh+//ufL y9enjzN9Idw44wmEvBNwp5R2jLVONvfkwg3cNvMlCPQCdYNLnPXh1TlDznj5F/BWZJwq1722 gYdwMcp3CPksl8EpdazoAKk8PiZ9+v4Re4xX/uu3AeRQvD29XWfZmLP9Ey1E9rN7FAntG6rr BxQ92LnlTapgavHDD8kku1N/wFWUXjxsbqaa6h9amXu5Pkl94PV6nSVfP6iRqNz8754/XuHf /779+aZ8eX9cX769e/7y6evs65cZqGbKXjGDAxPWNnJ/brtQHYMMl6JYXj4gys3ZzocaQGwl U0gutmxK1j6x69knrXMFzkgtMR+V8RyK6DWKDKZhXAD4dVUVVrLRKCWrR3d+yVLp+egUgN4A lHu5kaFnGCoLXCtn/SeCzgZPqpTq17t3v//416fnP93unxipg6o8vRem1xyzZL2c++hyZzxM 0HSN95R6/2SegnfGaPIrtkb3VSCAdBMZOARZh/jGPSho712wiYkIYXTtMxIGmZQHq2ZxWyZL Nst79dScN7gGZvXv7Vrqiu9SdlsGHC/h7RdXvpm/IbK6L4IfqwxKdFkv1rdFflOoXbiXbzAg aBDe+Zal7N6bAryOgg2OkGiIhMHtT61Ebj8oF9FmGdzuujKh4VwOvdYB7fEL5uxyu4vOl6Mf PVtJcJ45QEiIjPymd7pApHQ7Z3e+al1lUpm9KXLmJAppc2fe1DRa07lHSTeWHQchuNubBe89 /5Pwb4W2LvclI3SCcNghanNtt80xVSaxsZ4UrctawLQv9ZiHKVyJYjjLumpw11KNivyT1PX+ /c/Z29O36z9nNPlFKpY/Y6umwHzE9FBpphk52tEKgYHM29kQI1XufXmCQmQMz9hPnyFsr756 YwpHDQSPm1ACabHfO7BUii4o5JmIx3xqo6puq3sd+dX5xuCf7L+qXeWOagZutIAEV/+dCFnV A4bHdNAoespj+T+EATfedtcbO29ZlffalBYXFSLql0iwQwjFKUSiILg4sa4/GXgnM5psoCbq 4jNlSLAR83Nku7hAjqI2um6xQdq5HuxY8JpK+8kJFgEaIK2Y0U5AK+05CiSIRTPiCsD3AeFo iItEf2BNxzs0Lm+xdyfhwHho/YwxNgsW2+Xsp93z9+tF/vt5ugTteMUgNN5sUE9riwN6mjrw ZcNCtGBeCDQwA8KaIVmkswzs+GiAMssK2W9xbeQC6/BecH4YwtyOz+2+Hdo7pKJOArheu4i0 mUabFjmUVVHEdY29h2LBnBYpOduxYQPHWSRM/kHwSRmdlYbZ94D9Y6UkZ4mbpatXxnZB7SP9 c1HVHkWtfiwPBerzNeojCSlrZgPraJIKaYCvfaeCPbNHFquDRYD6LI1CKaFw8uUs3CmXtiq2 AlpFa+aiSLHco8h33oRa3HuJjLwvcrTDHVxl+TMKgsDr1i1hJC5w/Q/wL5p97BnDHbO7oYj6 kmv7Zj2c5O7GCd7miuJ0GGeFsNfQ1NPYOsWVIWB4XkFyfN8BH6Jm207S2sUMbzXzScJy+35b uZigwf9jjfpSbXu6xEvchxvTDAxCfPGN8wbvI+obdzXfF7lHvZWVeVTRvPEl2I5vRB1wrjj3 9VlXhpIzP2XocKAHlgr7fK8jtTX+7Qc23osj+4wddZqPlhui9WDvFKZNC9f9orzEC/vRPyex lzbg1KeUo2kVRqkulH98UBricEjilCeeO3mN+gC/k1ne2ZiFd9vO3ncRHAirsS97E6En6uTc eCBph6oOlnJ4KHEATqNAn8M4fjq8CJAN7476ydzf7eFihgTzfWz9kGwnb1sSzzgCAperJ+bV gkXVqFSvsZNql/M7/cSjcGUH4/2GnrIZRTJSSf3ZDnk8Z748zOycAwh/7DmBOnpManF89CX6 982QbSB5YQcSps2yZZ6YJ+B5dS3JXd3kisuEjbSJUyfX7yiiaBXICnCD4yjeR9Gy8QZg7RhJ 8ztaR06kImBD7HUkfHMS0SIK78wG+WdV5EXG0HkaLbZ2UhcLj57wRbPOM0+4ZfzvioqyxNE5 pgWLowNMd2h96gbAHvpUjA4KiuV756apg9ST5JqEVvjIILtmx+/omw/S7rZxHB9SsvB5Zx5S 7xb7kHomhHxYw/LWW86LZ9O38ERSiJaw2igJAI9xRykDgLqaWTsHqXFnbCStNupn1QW+SFRR sN7ea0TOLG+AyUusrq/W8+Wd8V0BgkaFViZIJrc/24OiVte741Qw9oBXyR0ICUG34XyBpRlb pWyfCxdbjxdXsoLtnTcG2PtqJ/9ZQ1/s8OEkIE0TBsydcS8yYXU9KzkNfK2UstvA4/5VzOW9 ZUnUyt1tvUGdKQP87sc5OYj/ZfmYMU88GQwAT/QRBdSS3LO0ciyh2WhEzQ6n2lrMNOVOKbsE wAHL3Yh4IB/qFIU6Meo726swYFJUB557DpA5XGGeFpSj/gSj2gt/n9vuIU1pLyvfkBgEfKDn uyTxdDVA8cQeQPTy8JhyC8IhZQmc/gC4NHAnPhWlvvw+JLChke5SBAwqwAvEl0wtweuYmNh2 itolketncT6DNvgANdQtMgcTZrozijuqsQhH80Xjvk+vitNsI/cfuyZJjDYIUe+Pfa/19M7Q tKUpl7YasWmJNMYmgkkp9Yxl5DZakdcbt9WGIw5uCcffidMyPQm3Rh0E0VzIo7dSgGRhdTAP AuqXaWrPYzuF1349repNaYWOJbebqBigkXmfrlHkSeoVeLhZvNuivXxYXv3MWlotntNVcDTJ wcGp8HTOmddMwC1kZkc0XJqaTbuXQz2s9trn2c/N1A7fL0v8wQI3ZyFmSmWsu15YYEiDmtqU I7nIncF8HlBLticChSnpIGeiwIwXG4mhTZQr7SZqGpso/znLYN9miB4ONvj+Z8ts22ATYR6Q XowmVHlX7Ud3nJaZGIEmI6cI43CSncQN/qRRwMpijoWZDt8j267nwbRyUW038zlKj2xkiIEj h+pmhYaHmiLbldvxwNmn63BOpvQcZn+EPg+WFMzC7vkZFZtogbxClSdcn0XhnS1OsVD2hn19 01TEbRVk5GSrtcfdqiTycOMJUlB4Siw9epK7Vekqk9Pz5B+IrBRFHkZR5OmWIw2DLdqZ78mp 8k4s9dZNFC6CeatnpcM8kjTjyNd7kCvf5WKr0MA7COzYoS8l94VV0DhjEnrdBUpV4GLlYdIk wVlVkRaZzed0jSoew1sethbk9EXr/4PWo/Gc2osJQgMy4/FF5hpcSRbhwERwk84ABIjVZb4W CCMHjocV7gdUHI9lL3nbY3u4WJVLyhSUUNPjmhas6cGYfI/bondg6EfVdFqrJN64x4OSKt0G doxvT/MBow386TVTPedSUuut18fUaZmktC40mc11MMY66o37KKrVKsR97xcuV70AG4+y1mDu GO5A8X9SYPYDBKGa3XGh+WJtLsIdAcOJsgdkhoYtmzLGIUevjS4X1g9QWy0zRtFOggnFaSFZ TKALuy2IV+EvCSD4AEPi3nDa8RTCuo+vGlaaR6Cq1OGxzaekg1O4g6yyGusfLpKrI7Kx16ho 1iWtGxSRmRfeAGWnKWOdHW0ysqcSzpY6FYBUI0/TegwxuzFJvPcNKHXqgs8MQ0qZCX9LqhL8 vmBnFNwZxxlLOHGW8qzeSFXpdPcJFfEERVlCU9+cUlUjbDnQnM3YsR3BhUOrU1jr7OGmRLch xb0EHdcTVN1xPdlnwN2EC3KT6/H36heI2M3n3uDKPZVg47B/25PVKxduwpB0BBtcrCc6a2hf H7I7Aksa6n9jPAhszTYl7Ovc6cUb9mkWQr1PpsD7x4RYQwG0nPeJrBxTR4ARBJUFh93TbqxX I5jiRdw0NLTW3SlUyp9yeQaQIggSerm+vs7i71+fPv4OV7pN8q40TiAPl/O5sbOYVPtjWhwb XnDsSs8l5wZ6fmer4u6O02+8FqfWkyDFRYI6887m0fcZuVwOiFVVTqP9+JdvP968YZ0OBKL6 6awOmrbbweV6Niqp5gB0s5Woqsn6utejhUKiORmpK950nAEt6QW+4POXt+v3T0/WR+wKQbQV 8pieDoh6p8bLFbRiLG+bX4N5uLwt8/jrZm18by30W/EoRTAXlWKzs4Pr2JNjBKZefxEfEoUu eWSPcSGX5PGFeoq0DKxN2qCXqxVqwjkiW6zS+hgnaLUP0pDeYJuLIREG6zlSaXr0VerCS2B8 NbAYXr6mZL0MsLxsUyRaBhFaXI9AdAKOjc+iRYglHloSJnqlUX2zWay2+KMpZoOM7LKSSydS Z84uzq2DA6sombrlHF9RBrHunOvW00VdXMiFPCLPl0V9H7POwrYuTvQgKbebUF/S5XxxczA1 7kA0Jim+YvbzU3ivP9Ui6mJALFalY8Mb6CVgfH2DCMHnJSAfM2tvNCWiqMyi9RzzZJliJNlE my3+EM1z8UQtCbCm2gyNsbLkTnIG8YaaEOMmPz5JEzJY+B5DHyNaZ/sANTNtwboW5SSJGxFx kFBviN6I2zCFE7KdL7AUVUvoMSdlVeCdcCBZKQ7c33TGUHXJEtmTFACLFVoF/phu08eZ+6JI 7IvITC5PufxO94bU/pS/Z3j17FjvwiDceLjOQbXNw9ZoU+JC4BToEs2VJxitRIvgILimnFwz A2nEeOuR6+YKP/yzpDIRBEtvHSzdEdFmvPRkwJuy6sedx/GcNdwztLLjJgg9KwnLFaKtt+Ph ktR61czxpCFTVP1dAezKnaaqvy/ct7bdWCguSa3OEG+sScrRWmRlIXAYIPtDBotN5F131N+8 dhLLMEFB1ZwrvDUJKs2h+19ay23uPK7K2tq78AueMoJma1hCwkaptZh1EC48w0U00dq8cMtq fCnWq/mmwbnvWb0Ow4WHqaKxcF5VHDK9Q4TWl+o2Yy6w6VxlfDnZBxQRn/6KJTLTmAbKbr6Y UoZPbdLDpMvWd+VN1P6OErqUxXzSzB26mWjWatUbK4en7x9V8j9/V8z+n7Ir624cx9V/xY8z DzWtxVp87+kHWZJtdbS1KcdOXnzciasqZ5K4Jkmd6f73FyC1cAGdvg+VVPCBFHeCIAjoL6jU UhJOkTQO/uexiJ25pxPhp+otSZDTLvbSyNXcWCACBy6QnejLVcGQFi2jrCwFXBZLgM18twnl VVZg/csEkU79GPMq8YJPyw4a5agVQ9I05HQcoXVS5WprDJRjzeBMQ9BLZR8YyXm1c50b2i58 ZFpVsarsEIYh309vp4cPjFiqaxq6Trn/v6WWY4w7uYiPbXcnnaH7mOs2Yu+wyAtCtRmT8liL p4GZLfJo3dw3NpPQ49riPQZVsehXkdRDwhm3ypULY6DcaG6bepeSb0+nZ9PUpS96nmzLu1S+ wOqB2FP9toxE+FK7zbkPZ8mnL8EnPHDpbcWhFep6yUenEhOQWCNf3yqZy/7/ZaA3ZCeQestj MbDJWaSMbqFziyofWchy54curzNL/Gelgsxi3Sa3I/0uWilU58UxJXHKTKUSmV5GqiKz9UDV HMxnx/Xl9QuiQOGDhj9yIzwe9BlhU5W0mNFzqG8jJaLUuXquv1nmQw+zNK0tBjMjhxsWLLIY APdM0NfLfJvZLPl6rn5N/a1L1tYwHirrZ2xoQf1pVluLZaiAty29YvcwDD0YEp99A7VsWsTt aeWBxY4/nKVmKAfUOA1lO3Qnxd+qqsK2KmAHrrNStqDh1Dapi943vSLoTBjrtnQwPM4jHnyK a6RVIstTHJaf2goCK1YaaY8eebNmbX4fAzU2K/qdyGYPG3OdNZTuvL4V/jIn8cZfhLQkjMFq 0ZaP7ramvrO4Yan2yS05B4Vb57Vy69mmceSHf2pUDNmmUkDS6JXnEw018pyO3vGVfXDTWh66 QU+v002OL5gx4jcll6fwr5V06pxQMONdNaeabCDQCkWMciKQwAIodU5aU8ts9e620dR6CNek fI0I+VHqYwpDuqVvZxG7hXZA3daBujkeyso6379vvbnZEgOiHW3yMlWfo0P36U7KDkVZ3mnL gVCQw3HBvKmQ80fvQLwBG5AK1oUsSSCVqxLRyasypcRtXGt5hMfhDaRT1fwKXu2obRGRPpIL GgKoRYHzjRLIHgdOuW6WRWcS23QKTglNMB400AHX1B69i6AZ5Az07+iAC513v12en1EyJWI9 8uwL1+agZsRD2txkxC1+fTheZVFAqyt6GJ8bW/Eitrgs4SBL6UfKAqzs/Ylebuhlj08+fgCm tzXedejdZWFvM8BDi1ugHl6EtDiA8G1Be33oMZiRxrzgPrEsHczSinD4hhPpr/eP84uwde8D C/zjBQbN81+z88sf58fH8+Psl57rC4hi6HTqn3ruKQxiu09w5MhyVqxr7nvuqjNqndfyDg7Z 8rXn2Ps2r/JbMmK7p+8qSLnJq7bM9OWgMa5N5MGTJrLXL3VgHRKLSZXo+Ur4IpBowkJ6mN75 n3CKfAVhF6BfxEQ+PZ5+fNgncFY0eEW/s+jQOUtZ2xpk8rysVqN3YlzqCkSFa9ssm261u78/ NiC8WNm6pGEgSFHyCIeL+k69bRcjvUU3ceKmk9e5+fgOrTC1izRwldOAkDMSSyRm3g1lYolV JQYhXu/b/Z2OLLgyf8Jik2kZ6T2vD0s1iSvMnLlty8wtsFVjaMKfpoHFmPrh+Un4xCRyOaZl gYHRbrh8pOfZg2VGq/kkFtOh94TJL2CwPN8waNzp4/Jm7mVdC6W9PPybKGvXHt0gjo+DNCFm zyu6Yp6J9ysztBuo827fbPlzCC7zsS6pMCzK7OMyQ8eMMKZggj0+oV9GmHX8a+//sn0Hz0tS nVTsRjbFwEoqb2hE5A7FkXfPgz581YfwYuyoaxVPz+6YbHfJaZNjQvGmSHi8fzn9+AHrN1+Z iUkiSlNlLaWOEuCh9RzlppqTs33S0hOLw6jusOU4hG+jlk7OUFh2cw6Wd3DObuA0Zcu+gj7Y tUamt4c4CMx5AIPpS99GqK292k6uM8dV9jiPyUCKA0uBPG5olKDHILm9dqvIpTUrouV4/YgG 6+LInicjb6kGyHfdg5HhnrlhqpZzFBd4E53//AGzStHc9SFpuImJPtwFVXdSLaqDphDktd0E ewctw57aZygjsCcvAt+sUU/HFPaWatNVHETW5u/aIvVirlgXU2yVma2hTa1tcd+Qnks4nG7v WMd1T7e5VhHcq41aCCHFllvZ+gvZJronwslab782KatEX0D4TZHn6p3HyXFoNikHFi4t3woO 05rDYLC8zBbDcFOwm/yOap59FfvB2BMoaX3WE1cOGJxh2cUW3ZwYcuWxaK6sS+21RQtNxPtl wc60zVJf84UpVOUgI1ze6LknjOPY8vqsVGSoHtgrF+l7F3VlxqfdL/996o+X1Qnkf7VdIZGI 3cfNpRq68SamjHlz8k26yhJ7ciEnxN1XWol7SD91yCVnzyfFgTKk4kLfEZ/KVcqHBJ1p9xcj gEVzKJ/lKkdM5CkAHjyyD+JKZ0/eaKu5hJbs5StcBfBdG+Bby+H7sDBRgp3MFckGfQqgPqpT IXr+yTxxbrmRH5mWv3uRzRMxV4gek1vqyCYwOM6pr7ckMv7sNA21woVPlco7M7WgXzFmbvGB NLJSS10vDyVZelwmHQxpybxOrHMiraw9Y51O65OONmYmMvbaWCwZscQaUFgo826FwaNyZ0v6 8IPKNHx+r+Faauzuw4GoTg+oer+xNGj5Rdc1WWjBDiZVN8i6KMaLchFl6hlWu7w8rpPdOjc/ jGZKkTMnP91jFqfJPVO/aQJzRjpd7BvN3s3bQyBN+oG/YC1+2wSgUPHCUVaDAbq2fw88KF94 lG3MwKAeX6av1uhQkSxOFIUL30Sgv+ducLAA6utTGfKCa8VDjsgPyFyDmM6VVUt/TkvcY9Nx sxubx+a+p/gQOpZd6i3m1NQaMtt2i3kgFZGfyQ76AjD4+pL/hK1f0WkJYq/Z2Kjv6cVd6+kD Dj/UvXwfB2VZdLv1biuZKhqQMpZGNIvmLmU9ozDERLZZ5TqyxbMKBDYgtAELC+DT31h4c4cC uujgWoC5bnwjQ1RHKxyhZ8k1sn0uohqBpVHouVQ5buIut4SEH1lc51OeVVK5wca6rU2Rc9oy Z1VKFRHdtRD07tASfZGxkArmgyF2qOGRoYMOpp6WB6wIbuBAQD3oHCsHB3EnWJnZ8hO6t1pT 2a6iwI8Ci6av5+mtG4/a6m7mBWdz0r/zyNCB9Lvrki5nZinXZeDGrCIBzyEBEA0SkkwMR6Gr SGoT2RSb0PWJbiqWVZIT3wV6mx8IOnzB8F449V9AqgwGHJW2OH6JbDv5teNA/S2dE7WEkb11 PWrMYZT3ZJ0TAF/LA6rMHLJsCBIPbHG0kCzzeC51ElE4PM9SiLk3/zRxSNWZA8REQ6kmdEKy 0hxzF9dnBPKEtFJM5llQ27jEEIY+sbRzgOpdDlBBwDiwiCzV8d3ok06s0tZ3LMFUxghkaRjQ x5wxl7xeee6ySsUsuNZjVegT3VVFNJUenFVEyzMSA/VwbIJjashUMSkLAP3qEKxisvXLilQf SDDRzUAl22EReP7cAsyJUS4AsvGE8cq1oiHH3CMWnrpLhSqiYGoAgQFPO5gaRAUQiKh9HwA4 yhENgcDCmdMVWMXBgh6xbWW9u+pTs013dTkCnNqfgez/SZJTUmohLtv1Hb/K3cgnWjmHTXfu EK0IgOdagHDvOXRBKpbOo+r6BB+YFjajOJlt6V9d20ASCNCLhu7TRcGp0cUBnxCEWdexKKA6 parCkBSpU9eLs5gW0JnruOTMACiKvetLewJNHXvXpOKiTrQrKBmxGlSOLL53NfsujYiFoNtU KbU7dFXrOuTeyhHaAEZhubaOAsPcIfoF6dQkkpUFVJnQV2Pa7j6V5YEvjEPqnmLk6PDFPvmN Dh04XUm6j0HidTOz9Ags3IzKlEPeNfmXcxBTl9OJISzoKLWm3bYk8TKKA/UNjwqGNa3dk7hg Hm5oCwiVKf+Mi+v9/raBzziZ0OzNOJGZbN2NY3m4iZuR8kpREExZfAAwsjs+nEVvmmRsxIGx j9h0XDcYQSlvj/uC5VSOMuMqKbawJyS2x55EEnwigs4FLI5JqCS92rgsmxQD+VxNZy8VwXi1 nsiAnkH5j0+/+Ter9f+tDrrs554maQsW7kmT55eWiWUR6cPWN+kx69iQMT10gdWfOwc0t3h7 Ud5/yLkhC5WP9sUl+uesivRvsKJ9+zUuWQdP8PVckh22RtHMgkdy3eyTu0Z2oDFCgw2H8Fhy +nj4/nj5ZnX6wJpVR3wf1dyhbwM8ApjOFZRV+T5LOnzPSd/AiLuIIR3RQL2XT/Or90Wxxbsb E+kjnpClyfbXPjbsfUQd4QTnH6hybPNuR5CT9PcdhnqCmkvE7DapMXRPT56uCcqiQltZa0Mh QwQykc7Qw/kyPaZ+PFc/xzVOca5/jLXoKxmEFNrEjEFeq6JrU49sqpEv322boS5EkYplBB9R yoMKG7aVBy4GntVKV4S+4+RsaW2KIkfJ1YpCtWwl6uLI9VbGB4FszW7TXm8EYT5hTS6iYl6B /yTg4ZiEJzzX14tb3+o91wOhI5pFkkOWKUgGjkGMvLlGBIEuMIYJuvPtzXksRUQWP1pGogHl xCgl0mkGiUZPAfQ4ilb2VIselSdlurk3anfMWzjY+OT0r4sFerO29UddpJHjxla8Qh8XnjEJ B4ORL3+c3s+P08qLsaiVjQgfw6ZXxxPk3BJRtHdsacu8TwgcU9bGHtC+nT+eXs6Xnx+z9QW2 gdeLZncxbCEtLGdFlcP+gts+1eXo2rhhrBD+ZoU5yeX16eF9xp6enx4ur7Pl6eHfP55Pr1Jo cibb4GIWDOOvqySoN4+5KOVuoipx8JW43BbZWkuA/gOv5DfAGrUoxaMsidZH6R78LtLZqUzK NJpQiwci4bFRa1PuYezh8jJ7/3F+ePr69DBLqmUytWjvVlLOggdjVBw/IlW0QVoQBVdwucwT wMhIJxyfqqzlONQWXTCmVW1k/DdaY3A1Jozifj5/PH39+fqAlrRWj/bVKjMcAXCaESVZAhPm R+oRlEt/3LrQ4vuYJ0s6L44cW7AeZIFqBAtHNjLgCfk1K0XTXV3wom/Rup20h8ZScoOEg54I qYFndXwzstiaRIh5ahGFTGjQFAfmnCYsDCUK3k0d9FboiaqZBTrZbRNWpL5KAybtFQVmIWTw 33fJ9mZ8fUHWt2xTq/UvYrQp63T+wJamP46vkY/WkPEan+3NCbL9ltT3MFEa2pUvcpgvSZDK 7TUsVksTbutnydpDSYX3IvMgorSHPTwYU+jJoiie08qqniFeOPSVwIh79MunEV98kn5BacI4 2oX+ItKG4XBuUcmUaSPSUdDXa92mqwBmhr3WhAWminfMHphLMASOT1nxjak1J8+cngZdENtL xfL02trFinkUHrQDKAeqQFYljqTBIkf9yM1dDCOJeh4kEqpRfZLlIXCuLqlwvE1VhRFSu+KY VL4fHNCpDm3ghGyjJbOSGE2NSPeFvHMHk+ZJw9Gy0HUCS8xYbp9jMV4efOZYu0QwxJR7wQlW bYdGuufaZis0jm6tLaWKCaowy9apC5f+8sK9vtMAE6xQpCp3OGubo2xAkp0Sybe37CYS7EvX i3wCKCs/8I1O/8QjAmepbJEGcYHQ333Im7mwztd2eEFU9zshm8yjUn7hzGtTBa7jmTTX0Wm4 HuqV41TbiAZw7hg9iUoY92BxmDQw6Ft9r7khpBZeAtKpUb5GxaDiOmkgGb6MR0DE6rltyk4x j5gYMDT0jr94qNmuysncUdPJFZ0y11jqia/fFKnpNDElaRfHqnGCBGaBv6CvpySmGn5RkWck FkMylTAuMV5NLomfRAZCcryagS4GaohvQTx5lGqIS3ZvUoN4LpsiTpjmqGGkF6xc+I6lAwAM vcilLp4mJtwNIrI8HCHrzc1SDzaErkHZpb7i/FaFwiikIBTBYCGm64dyTjin7V80LtKAQOVZ BGRdTZNZCeuld3W5VfEotiaNF/QXQUCzjXfESLe4Kou6GE6Y2Mc/abB2tbu3ROOVmG7j2AnJ Ec6h2A6pW7cE7qnHyxPOw2f2r3cNELbXwA19skFxf/b80PJZIU9YYn3obOT7NZ1pQdbdlCk0 bEEvGL0MQEH6bqQg+vaGoRGocDBcsbB+O/34jporwvNTsqbW59t1Aru5pMvqCdxjzLrdsV9d yVkMgmxfdCmGjqfliWxrOjKDM+XsH8nPx6fLLL20b5eH8/v75e2f8Mfr16dvP99OqAeRywqZ oCM9wjcP51q9nV7Osz9+fv16futvgxTl34oMQ5KkN/yJ/rFMs6EFp3ojMS0TxnpnRCoivcM1 sqNTTfj06NgsySDOGUi7J79lakgmjBsRX604iAKLuQvSpeoQfGJgySbZ0h41pO9kLUgL1Lqi 8UQO/RXKwzPBBo0T+g617Wk8C7JpW5BpD2TT4qDaJhQ0yihmJ2rnQelDt4HnRCV97TuxLTM4 aNGHfZhVDG2U6RuVZldnxgzYFBk1x5FMaNpt7DwaWEG7xAP6sb2S3fICVJjLH5eHC+GjkAc8 W0oKByRw/+O/ys556HJxX0AFZdiCuTSbFA6BRdeV+TGvYTms1a8YU7t3rKvYhYmIbunmuEnY cZOqBdXY6hr6ACTtOt/303y8k66e3h/Oz3g1cPn5ztvm8gMXM60lBjuKFqPk6JHv0Lc2aj+r om702IxNtzYI+OS3y8tCjVsygMuSDzmGEQpp5wMD54rZIoZg6Iox8CvewxjNabTlnjfyMllZ yKoCnA8i9LmUTj6XjOt8njSMDo5jdNDxgGOApirq+4lqLOA8ZB+ZDafC/sab8NgZzczxDsMj 7hnshLZxmpOlGT5pKVFzQH/Bm9YsFT5Oc8MDDfih1wNKSVfQz5AdQtcmk5FlMxZSvUZRMDra l5qccF/Bo332DJb0rIwxpo1eqpEMVW5UaBsnIYhekZkI2fWIZQPdXgNE+QPSqslyedT2tifp 8+md9KjDF4zUNrEmD4zyHMm0MdBVo4eSuuny/5nxyoM8mKzz2eP5x/n18X12eZ2xlBUgBX3M luUN9wrJstnL6a/hyfvp+f0y++M8ez2fH8+P/ztDFy5yTpvz84/Z18vb7OXydp49vX696BUZ OKk9oHg5fXt6/WY68eXLQ5YScUp5PF/aeSzARasdwATtlhqgE/2IaxP7NSbAegs4yK8qZEQe RfZdluo0IzYQrwEfGxn58Jsv5fvU19MgjX/1SprjOsnWZsBMDmWoCtpqHjrFBf3z6QP672W2 fv45mEPNmO79Z8zIWIqA6hGf9IzSirPF6fHb+eOX7Ofp+Qss2WcYNo/n2dv5Pz+f3s5i7xMs w46OboNg+J25n6FHfWzxD8F+iCFEt6Ql2cg1tgBZWNqD2JSY6keO3OKliCUeysiErpxv0Fc7 yzM0MLNFaZ2+xSvVZIUWUxlfkhZZntDUoz4CJ6QfsErR+EPl0DR9xU7gTW9ZmXaMXYuAKxzM krmqgg4p7uVVERrjCYge7c+Dr5TZriO9QYrS3LJcE3+gZQM9MHKZr5tOfebLyeZ2mN61W4wg m95FqcVNo2Dj5o1WvMjsgXT4rttlBY8JYqkYP6hl0IelHCRIxM5l8AvOA1pVjJrAsASJ9LZY bq3Gq7ykzT7ZQptRb095NrkujOYb9PHAt75Vceh2W2PSFQzPMyvKmz3Cd5BECzGd3/NWORiD A8Ur+O0F7sEuqm5YwSNj+oFDacxklnkoP97nLVfUN0doZnxtnmvzKCU8xuFQb7//9f70cHqe lae/FFeC8kauRqqvm1aImmle0I5PERV+ZpZkpOcu2dw26tljJAnDleXdcIwgxD89iDi9nwiq 6YLDwgIjoFTjNJkctvWw58LaHrNtsv/VI9BevjjWO4yTsVphaHpP6ojz29OP7+c36IrpnKAv aYOIuyMvSvnHtubqOsiLeuXaQ+KRykG++9+aGSHNN6YnPhBaUPfECC6ztM9H3cXJnRuZCSE8 qbIg8MOd5YE0stR553mRPRo6xy0OTXizNTd0dE0+pa1eRflmuKuquyvyfVksx0A3anPuMMS5 vpKvjnVa6aTcJFERyoExNxjHAPIKlcfI1ImbIjM+Qwnxq2OnF0j8d2VMoIFObLc0n3aeoJma ZW4btyOPaEY6fW49tMgsU9PRufA2/DQfvUdGZOxBOvcKFa3EoYTmXh1L2FHpaxKN0bqMSTzG SJAwckhIeGc2/H2+pYyj+OSSY8/3hHF0qtMQgDy3j441drkd5avwyt5Cq12d4rOXKyx/q0v6 5b5DTy32VWP92YQYIxjYuzRL6RBaeqs0NxbH0QKHGXes7JVeHzEoD23iJHCbVlWg2ZK8ixHC bMY1b4bGpGwLq4fc3Z7SY1SVaslQpdciCQPKzW1pJTT65bPGpcC0/8fYkzQ3cvP6V1Q5JVVv vlFr1yEH9ib1qDc32bI8F5XjUTyqGUt+slxf5v36R5C9cAHlHBKPAHBpLiAIgABIV5Y0xRGf afhZJD7/UN0HtdBwrZ91HdDtUtZRmJ6LdhUpixXOA4h7n4ZmeyyJM1CluFoL/LnDJwqw8E6A hvxfjq5sa3+s3mAAVtN1YELCdTLjd16Dsklc3giKercLuk58V0RtoMiYkkogizKR61M3LkqY IyCyDJdLr8enH4i3clu2zimJIwgTV2eq9xI4yMslpgI7iNWCe8HY/RVT5tiwHdEXoX/K9+OF w2mtJaymjhfpPUU/DchYg51Az/4sFOrCTojB9jH//9rA+CIfYQ7X1fU9RLnKV1EX3ptT2DMg itkhzwRYGBqHGHBsA2UokO6rBZgfyxNX7E9BcF8R3AQmsDK0LD6qgsDt7iw6Bb6OeCyQDo/6 ZTbY6VQNDWCWnU7Rt+89dowWmt1ocKG5lbbAhe680KyAaAvBehNMBdaP3dScUYDOdFOwnAfr UbSOtz2ljJlC3TcESnV30wv5Ib9J3JjdxvucTkYO7245Qmw8XWJ3fIG1vHCklSog4M9h9Yil wXTp7TCRuFv703+sYgUboR4zsgeKe7WxDYUe/a+fx9OP370/xOW1WvkCz+t6h3izAwrPXvhV FkSDLocEWFnZOslX2R/GRvZBdZEZXwtef/bWTIL5wrdj4kLr7HJ8fra5RGPbo/awNUY/K+UP TsaldbouMM22RsYl142zqYxh10SNZB1x0cOPCHNW0tnZP+5zUNYftae76emf0lhyBSMRw3x8 vYKC+21wlWPdz3h+uP59/AnpKJ6Eo8vgd5iS6+Pl+XA1p7sb+IrkNDHyaOn9J3xqMK8IjaqE rFtqHSQIIngulaQJw5IURSGBbEwFWKJpUNWKIkqgLKs6QA2aJuNi+2q7a1sg3bKnQGeZ+Iv0 rGLBXksPAACIVjNbeAsbYxyzAFoHXDh6wIGt485vl+vT8DeVgCNZoQpmCtBdSrNzc8DgeOIr 4O9Hw0UJSDlXjOVgocPSkXDByTUuAq9laVOh+zqJRPACdTJEJ6stLrGDUwZ02hIu2lLYI5sW R3x/+jWiDhe8jmi3cLj+tCQh9ca4x7JCMJ9gXZAYx5NbhWimecQ2cHgSv9TNli2qotNg7FCm tTQJTb0RGrlGpxghTe84fIo1LMJO4a6iKoXuv6xinIgFgsgmHtNcPjW4/jC5xfl349EG7brl pWquQNuVUsXojpQNhnKRdTkkWHtxNvbGqLtrO4l85Xn49O74eGAyoFp0hE5QlI2HaGzfrig4 y45bjgCB6p0bTCT5ykPIeKPSQ26WDzdmSMda7mtlrvXE9X2/eMeXAVJEYrpoNrqW+mYngqyg dn18v40WMxQ+1XzoFfgUWZ2wbxcQnShL9ADjOsFHvGW2cPia9yTz0cfVzCdogD6VYrGwl4z8 BmDpIE+7OX9DKI6HDyjb/txmTyI2PvqKpSUwn0G0W45tvDkjC4wtLJjh1a9gHInyVJLp7ZnI aDYbffBZ/t3EuHqYq7mcBnqQuhYDy/wWv9DzZ5xPn0B0vLn+rcfBHaL15u+8N+nh9MbvDHp1 XRfDjDSehtYRzVF+HSt+hr2W7iEPhM0O+SZS73qLc1diQ4d4rLUkW0F05CRpzOgNuNadYGtI z6InM1MwJXz4KsqNjDaACrMoa1C4QhOSkUQO25bM6h4UDkGjbnKJNG7XTpo8YqjBBIpXNaVm n7OYr0WkALzWaiIAdG6h2+OFzw42sUAtO4h2rEFnGZKuIzs+Xc5v57+vg/Wv18Pl03bw/H54 u6J+wA9lVOGGaMrICs/Eu1vMOoc9xc9VuUFE1TrEQ7IRWvM7NSnxR2BNmGk/UU8HAZRF1FYa 2mLhegguCCqf4cG44vpLwmiN9MUiERHZMDkRzpdiX8WbJNUk53UpblG4gQLi6iRVlEYOi1NG k1ud4vc1QgvIlHyDSCReTW9RQK7hW3jwKCpJeIsE1BEboHHo07so1iHRM+lJJU8W5WmBp0cX i+TmIInQfPcZvjd4hyHzyM2+NzpwnzXTd5NqTcob3Qiy0pElUnwnaG5EwusbNFvXKpXoxNF8 E44ts5+09yR+xs8WTGVISUbrfIXsLFltQTasMrSN/fJpCt85DBzCc2m/MjL4Gi1U9NaY0Izw M6/I8yjAycqt0F18MDKJY3JoLRKIg4A13vs1Y2hY6KaeOk8Y1KQYJNLdHqJzoJ7LEEuH74sw w7YFdArUJ2qBYF0VWZ/KFbsLBekGLuppUciEfC03gUBwHAfhi0qiesVKLTbg2sMmOL+8nE+D QCR/FE+j/nu+/FCPg74M/4bp2BE8XaEKwiCaD3G/PZWMjoYQ4cDBrTgFkrwMqyjfORleS3Lj zaNKdY+bu1WSHW75VUmSQLdVSKmtzSRNX48nMdj9+S5HWwDp+f2ChfPhFdMKkjSP1LsNh0Zb ZkLFz71uK+OUPl+YLWW/JyGZOe+yIyDbWupyOTv7gCBjtSMOc0vBMtwhiMtykoA6bOJg3fAd uc8SPuy180FjdXg5Xw+vl/MTJkxVUVawyFSPyYKvL2/P5gRB7KffqUzlXPAdA0ma+3BUoU7c xauiZ1RE54xyl+xpRfAVB6F2HMMBqK8Mk9JLIXjFVXTXbu7mpxbkrBOEBErGUE0y4MxFHkYZ yUNVyuqJuEwIbAg8Rx0E4EVLyTbSBbKeoIs6gAp5SkWE0mQbmR9h2fz775VnqaJP3sEh8Wef 6RnisFmBP/slKMhFaNIvJMBeGLQUIjuVppyWCKcBssE3RzYEXl1iMU0aMsh+MFafzvdw4/15 g7BjsjSI7p00eJ/jh11DWbHFcj7GuVpDQrPpFL0lN/jWPdXwBigqzFSQaHnBIS2k8N3EYPvA 18GbOIkFUgc3ZosoROuS/1Sz+SplLFIRDYPCau9IRioJbV/xacKRRDQFLHZCnp4OPw+X88vh qi1gPyOensvPzwJvOrQvCu0uISNVwRoSI0YAv91X4RBXiwgcGpF6s6Oh8gpW/NSDs2x2wZeN N/TUmGf8kBtr/iVkrqXQagBGlBcOnM30YouJGnSBA5bTqWdGr5FQE6D2ZxdMhsOpBpiN1A5R tlmMvZEO8EmvoyGnx5/nZ3h48u34fLxCkurzifMKfdJIOB8tlZ7w38ulorRpMtgZ4eKDwOPC judMSiTDx/Fd5CJY7+ZoYisZoN9sDlLh4BpGCKYx1oLXBeV4oueyyUk9x9Vikt/IbvZV9Mwm ccC3Gpyynaf62kPMqjAYLjyFxhV3X8iEY2SkGnwfrqwZEzm1L68/+TGtilvfDy/CT1+q0tQJ ZikBZ9Lmrqrtc3LnvFRtvy6Wthl9ffzWKus4k2ik7b4tYBwZ7VMpjLoeU1q2BbFCEItSK4Tj ml3USPrvJzPBLGTMvqv5tcTORB02e4Bvh0e5MfDdMB3ONGMaRPxZYGyGIyaTmUE6XY6x5yUB qPlUC3E2G41VAwVfxlNvrq3iyVzYWKQlEpKMv7+8/GpkL33wpId5tF1FuTFyUhASeDdGShv0 BkF3DDUBJw7/+344Pf0a0F+n6/fD2/H/wH0jDOnnMk11+X91OB0uj9fz5XN4fLtejn+9N9Et pB3l++Pb4VPKCQ/fBun5/Dr4ndfwx+DvroU3pYW2VDuTz78u57en8+uBj7Sx5v1s5alsWf62 wlmV9Xgoo1zhBzssvdVDVezHZJeYA9SgwExlotlqPBp2fHh9ePx5/a5szBZ6uQ6qx+thkJ1P x6u+Z+NoMtFT74AsNTQi2MiK3l+O347XX/YokGw09pQTI1wz/Xxdh8DGMcXvmtGRmj5E/jYH cM1vSY6sNsl8OMRNHoAa2Z+R8IVyBZegl8Pj2/vl8HI4XQfvfGC0aU2MaU2Qad1kuxl6tMhZ S2k2C+nOms0GrjKt9Pj8/aqMq64TI6lDYRZ+Cfd0jB5vJOXbXk2bR8qQLjUfWAFZap+59uZT Xa7iEJQpBdl45C3UbK5ZYwntj+5sjIdb4ojZTBVKVuWIlHyuyHCI5DVMaDpaDj3t+iBg3gg7 qL9Q4o1UcaUqq+EUS1FjeWKySo9LSXZ8c6hDVpSMD6FCUhJIw9fAlJXneRPHomSb8RjPbxLQ 8cTTtqIAOfwfujw7fCSmM2yYBUb1N+CAyXSsvVmbeouR5oq9DfJ04sphvY0yLkTM7T2VPT6f DlcppyPsYcNvSmqS2M1wudQCvkjpPSOrHAUasjBZjT0jkCSXqqejCTaszaYT1eDctW2hQ1tj DAmXFpOxyb8bdvL083iyPl3gWj/AwafB2/Xx9I1LA2o0c2hfvKyo6pIpFyv9eiRM0a4bUntE vZ6vnI0drZtSSL2FnkEZDvzpGGemrEw557d1cGYr/GOuGptKs3LpDZEzo7wc3oDJIovCL4ez YaY9ufCz0vU2bl06Elhx6cHzpq6ok2XKl4p6uaHTmX40SYirPEeqaduaFSPeM+NQfamyqZbc bV2OhjPtCPlaEs41Z9a4iQPhBJEejCVVXs7/HF/gFAb/lG9HWFdPB+zoSJMQzDYJi/ZbBwvZ LaeOnU6reGiLtuzw8gpSlj6h/VCmu+VwhqZSZlk5HCrOKOL3XGVND1Tlq+K3zplyhr9W3maR +USnZc5qNC/+w3aRBGCAxpUAjB3rV0JvxOHuCRrrg6Nq4Ue+mOrd41c0C7CXUcPaTVNl+xUE LSK7fV71QTaSEuIl8FHQdpO4zEEeCJf/t3z5xUsXAUODQfAVHTHQ7rCqSFMz2ingCFvPXUEk Ae9HVZrg5jhJkJaB53riICmyiDpyQEl8mVBGgrVDkShpaBHE5QpX1jUULHO8lGjwoHjGVnbS BJSWdPYIfX3IcXcLiWbRqiJ7v3RksIoz+8gp1w8D+v7Xm1Cp9xy1zRQlX8m3y2j9ALaX/WiR Z+LFvracVSSEBEC74AfZfgNxh4ECymBrmtfUmjGBzGwl2j3kBZ2IJ+OudhS6nTf6N3TT0dSu r6USmcGIYt1r7KSkTPXz0LcH+HABrzvBWV/knUnx92inz4jpva7zEDQoqW1PIadvl/NRC8ZC 8rAq0GBraeLn2zDR04O3sYbKzPHuNA+BBqkuFwEWEzWuIVM0/jlnn7q5lWE8S46deCFrmIXZ 2vH2rUOv1Ie1HZSvFQRasgRtAn8aJ7a0Fs5Sec7fbyFj48uiNLGnlAM73cPx8iLMjpb1JAq1 Y4n/3Bcx5o0VJ1V2T6oIVPqZuhAbXxrl+8Mg9PXlFGaJ4zErx9ju6youILlIaZTk0T7nfCmK k31M0hRea+h3qIAm+8SPIehIjjcW3++DeOVsb1UUqzTqvrQdvNX5/PzzcGMMm3J8YDiAGjGG oL9irRNYEKSiiNzLDs+Xx8HfbQOdsqqZO9645I6qKBzwMYn29wVoOMWzjH78ox0b7WMbsN8R xiobDE+dd7yW1EbRKKirhD1omPE+No1NY60e3EY0dlY4MXs7cXdrcqOWKA+qhxJem9tFnDgj xvoXPxzpv0wKCCLgi+FXbuVRwicW3ulrI9OBObHjWXRHItx5kzzGXvQr1XeTaNfwwRSodPYA frE6/8VVn0bR1uQkcL/ZEcUZYQk8iMWVQlzQoaO943GLz+TXYOdEksqCyrSNrC8UIOiBq4Wm jBxzN4WYXbwjsgbx3CvJv0RBswD78vCaElMlujYAuDjou0VC5CPofVGqn5xwtiTyX+XazRTM +/AG80GjwDuB7ZuY5gVLYmX1hCYgkQDrtWFMJAJp7K4umKLiEz/Bw1bEXxKaBfDKUoRBCOTQ kHF+nRsfKRGuOEUSy6pIqfAuzth+65mAkdGngGkiF6lZEdOJcwnxEcCXRrHltwnyoC3SHsa3 a5hUfMHs+Z/2KAoen76rcRJjavChBiAWtb7UG8Sab7ZiZTicGDRWuLsWUfiwgvcQGRZThAKN Fe6ph97gBAoR2kH58eGnqsg+h9tQnInWkZjQYjmbDbXx/FKkiRql52sC8fcUnWEY783fedr5 YIcF/RwT9jlnRpOKwoXTuOZ+G1uspeVPrGVGKsA4aASsum87U74d3r+duZiAfLs4PAxtAIA2 jsxBArnNdPO6AML1j6UGsIQIW1mRJ1qeEoHiklkaVqoJbRNVufpprZ6ivVpkpd5RAfjgpJE0 FhtusOt6xdmEr7bSgETPe6j8Yww9uMbIMGUPlEWZuhsriJhgkJMQB8iZamGxddhEgo+6lsra dZJxRJnWeos9DDsjfLPHAmCsLd/un6sHX2LzKG0hTaVDCw65yqPO/Kkc+C2e4yB2Jn4QSDJa 83tG9YCWdy0ESQAu7qC95GcW2Dj4H6vvX+WTX6Pm9CuudZHYChwUnY1WtZ/kdpWQwU5cXHB3 AZWohCCL+MNqlYwmXyNXOzHZFnXl+gzeQ2uOexbMWa4DRe9qQtcuHrdz15klOV+cDmSROZd8 aSzgu3w3sdYrB85cNVRN5ZqYLGBwbQQPsQc7UpGDLmPhzWoKhuVKlGTgtMcUjWcJUa602ZMQ sR67dYvxa0nGZ7ajQmpJv07+RSVBd0nV4WVGV0iluKzAeeVWPzmNOZO/JSfQoQYninaFzYsE zCW7aYcWFxD5JXhjMPBekxSUjhM4VU/flHaBMX87vp0Xi+nyk/ebig74/hLH4EQ1oWiYuRuj Ggw1zEK3UBs4TBVokLgrnrsrRjNvGCTejeK4KtMgwi1cBhFmXjFInF84m93o4vKjipfjmaPi 5Y05WY4/nJPlZOnq8XyiY7g0Ckttv3AU8EZqTh8T5eko8dYSr9/DwSMcPMbBE3NQWgTuG6BS YM7OKn6Ot7h0fI2jg56zh567i5siWezxu32Hxp8sABqyOXNWj4ZpbvFBlDLdUtFj+K22RmM4 diRVQZhMT2IXf6iSNE1wT9GWaEWiD0n4LRhXTrUUSQChqDH9fkeR1wnTp6UbGy27SothdbVJ 1IhlgKhZvGivO5vD5XT4Ofj++PTjeHrurzoQTT3aJ9VdnJIVVWLKiFKvl+Pp+kOak18Ob892 LhWhNtiI1ybaxQDOxH0KmtxtlHanwby7JfAzFfadRTFRbZQFa+sP+YhholybqUWL8RKcX175 te4TpKMf8Cv+04838QlPEn7BXmrL4MkOhWGUw8NUoRbhhFwgCAjTEzY1FFlNma2dbGhifvbL Sv70hiPlQymrkpIzHDBCo0/SqoiEon5Oo7Za57UIgv+Q+YXDD0xwt+I+jzABv40YrdyFeEvg qi++QVFICUIqFW5wxcsICzSDj4mTg1XkKTZrIs3PPclZMyZlIRRSqq5NhZv9iIuKr9n7iGzE k4KgVKwlGQEbOBddxBN3G9iFi5Iz9ufwHw+jktZvs2G4i0fpn1poxEF4+Ov9+VnbVGLQox2L cqpp+ppsBBxLUi4vOxHtcuqji+vzyccFXibnuPpHVlYVIQGdXIRqlySN1EDptiUVwYchjf9N DXy+osj8nBYnXqLdaAQEzhsf0pJVQS2W54d94WuCLwnOhGps8bRUxhB7ylJOa1+q/LDbFDwD bVZDFmUpX4T2l7WYG18FbgkQrdIVpFdSbbHLQpckq6GRuWnN7+zBRp3yERFndYl7WtfJap2p MaGVzxY9B81qnBb3dvUa2jWA4hNglFo+Y1ayNuJQSP0h7LQBeGq/v0qOvn48PeuOTfwWWkOq GMYn2ZGGQSL3a/BHYITis3R/xxkU52NhgW+yEl5Ew420KEr0dqji91uS1lGv2ZFI2BdFzXqw SF1lXugkEA4mA9YqpTU6uawiMOzjIwuNbqKoNJiHdCwDZ/mOnQ1+f2te1b79z+Dl/Xr458D/ cbg+/ec///nDPjorxk8/Fu0i1PYsZ5W3qr+gbVakLGd39v5e4viWLO7B5OusWlhrDKZaVnwZ KgYbZYnwQ1xtTZSG8bxZvyykgdvofGlk45qG96RMOj5K9W7s+RKFhB5G1o/+s5tiirpXE9eU 2Yd5F0iEG0mWd4PNNBR7iANBKP6UFOj4f02KHrsV04xhoMvEZeho1sbKrlLYthJ+djhLBVUU cqmfH9WdkYEfE+iRLBYDR5rrA46VKiojkOhSxeRGhXeBQFtiiDFtvTYLiDnns05djUItjQl7 nATOLz6ladoxiZGn4q2ZBmB0d8so1Oyou0Z6qqywmwalNIByIQb8LfCPaednH1UVZMVuLbKY 7HvDZkuSlKYEC9sMKCnxGFtbIDKygaDWd7UxCwIJr1Hl0OF2RKCJYZM50Fp30dQqPffgSycP HvBAO2CxVXanHbRTnIdtWH85sZULu6pIucZp2otQ3C4NN3L//40d2W7cOOxXgv2CzORA+tAH 2dbMqPEV2Z7rxUjTbBNgmxQ5sNu/X5KSbcmi0gIFipDUMbJEkRSPncLqBdLlH2Ycgy5IcgKC tNLZjATfs2hbIiWdi3knqW1oeplzrtTn/xoZ5Dy+2AHSd9/1zc51kcKekGRayum70SjBxabf n0gXbO9f3zyukF9nrSPlUJElqtTZzDomTFNF0u0n0+cFjh092Ak+kM94vblBLs85Xo9jbuQ+ 64o6nEtLy7SRec0zSKK6BrK22s/6JJ16NQMmqvUc0QjYdSoLhtYge24oVRP/uEjTBhJebgKm qzJJBSkXZ5/OMYQ6kEUdfzZB92fMdm2rYo0eZt7cyWbgzh7kzShjJtUADjrqTLB9MepCRTyL G4FRiVHlwMi268x7EcO/PxLlu6QRJfQMC6GOxO7c1qO+PBCWVV92OVuiD/GejSDoOfKahWQi V+uyiKVQsmPzAztaCbqN9qoxh9d1UcdNm7aWwp0kBUk4OKZ/zIVmhQ+yDHXemZBC5wdrLIo0 rls8SLMY+AkxF992zqnJqg52+6zSl5Wn82SVd43v/GoSqLSRhyPaJZhPLnIjYDAtbt2+PdSy P91fnU4qwhwHq7vgcXb7L3ksPqF+PvM+gMHicOzHdyjY+rojPjx3I2r+cDuupL1v3SnCzOcS CdkDhRaRshJpzTgoTQ+kcKALPAGgg6jf2E7gALBpNqxYWiiXW49tcS9ZQYFNaG6SWyHD982V zf3d+wtG7QTG1Wvppsi2paphcohA9u+HdNgGPFPWHbTMAoLh+Bi3NEvgMS556LMNrJ7Ugt7+ uddL67SISSQbil2gszwzDwZ+jTPUai5JbIQG4R7m1FFyyfpgpEDhec1MLDcgd4lC1OQrEgyD EieI/xHujy6WKRGjk4C5gD/Y1NPiCM/g52M//zU+j+5BlCbh23WKoUSiPusysL27GAZUO5ZP +qzVaBh/+fXz7fnkDqsLP7+cPNz/89MN4zfEsMprUat5Hxa8DOFSZCwwJE3y65Sqy8YxYaON V4nFAYak2tXzJxhLGJZuHKYenYmIzf66rhlq9B1ghm68VNkWmnGmDYuTaRYuQCFKsWamYuHh uNZ1lKXGchBkDZ3ZKCzVerVYXpmc9T4CRQEWGA6PRl7Q1DoZYOi/jFmTwmDiCyO6dgOcK1x5 jIgxBzPANaoId+s676RtgFx8OC7i/e0BY1rvbt/uv53Ipzs8PhhI8u/j28OJeH19vnskVHb7 dhsco9StPjgMxMDSjYB/y9O6yg+LMzfbzjBleaO2AVRCI7jHtsNkE0p1gRWgX8OpJOEipW24 OCnz8aWbL8rCctc5z8JqbpC9/7gwHBd5mNcmsun8Xh9iv6AQYe8bDrg385iPuS1EGCyXPX4H jTAcTKdnS2bFCGzijngkMy7BYXFyOD/xnQxU7eI0U6twx7Dsz9krwanJOCeQEck2UbCXMFGs 4qJdB75VZMAFQnYGYDdNxAReXlxy4LNlSN1sxIIDcl0A+GIR8hcAnzE/rV3rBVv2dWBLtenM XI9U2zbcfEKGxwJgfctckgC+uApnjfBSRfaOKLtEMUPo9DwAgmSwWylmSwwIpqjWsMlEIfM8 UmVxpGla3rvDIeD8T4Z7THIHfkX/x1tdb8SRESIakTeC2y4Gzi70wE2ZWTSSVVxGrK69fIc+ vG8auWRHbN0K8gNsV7EfycLj32gggIECboVuDZgy4dHNWzWu+wrNkCGnPlbMKFeRDP5jow9Y CCA3Y24affv07fnHSfn+4+v9y5Bnycxv3ikWUQIVTbORMcOv0Alaacou+B2EYfm9wQhfA3dx Kevb7FAEXX5RbSs1KoGeFuEIUj0nIA+I2GxGfGPlyPi0RlJOoh2RrOSNg8+eCwfMjlsiCqbM onVGHbK1BH3nd0SrJgceIYrxs5P1LpIt02mXxlIWTyQ3ogU5+erTxX/pb7tD2hQLP/wR4eXy j+iGwbd8xn1u+D8khQlsuTBhUOiKQqI2TYo42UVcu+CErrskt1RNlyBhyD8wt9XfJM2+UnW8 18fvTyZhBzlJGcv4pOiS+69rOdB8WBup4NdbR7K1vgfqKPxIt+2matreqwhuQNvGexYg4Jwm 1VWDbhuZEqWta+auRb7uorZdVQptrYOrYFnyx68vty+/Tl6e398en1zZUwuVXXrqdKJaLbGs hPcZJhvEhOfs/7QarqfGkJWhaXWZ1od+patipqi5JLksI1hY0r5rleuEPaAwfBtN5MbEH+Kx MIeqPNP/gIqCHYvDYPVdCcyWhDWY61z5elcKh1u13s2aLi59ilD6hXHarvdbzSVsFK0/cFGy BHAuZHK4YpoaDF/F1JIIvRORwtWGIok8XQCWq0GVqyRUL1JvcqLL0E6IK0vlJdoPC6doUWZV 8fFCUDwE3Am+iEDQQHCYBUU40ExycJAGWPpzln5/RPD8b6t0+zBK0lF7upzFKME6ulus8EsE TNB20xV8miBLg0/+nAZk0Un6JZik/2I3/eJ+fVQ1i0gAsWQx+bEQLGJ/jNBXEfh5eGgZ06mW 6DBU5VXh8mgXir26JzVJN94f5Og72OQnTCtB75e4gTlYf13ULDwpWPCqceCigZtCASMljquF Z+RtkGP5XmsIwteV3uNk9ExVeHY4fGksq6ruq0gJECSgwkK8v1d24/D1MvdTQ6T5EWvbOIBK Z74Te5Zx4qDSN6jrO10XtZoF2zXoq5KzznwNprqpnNYjuwYM2Y8YFL5M9cOb1tDR+Dr8P/yq B5zSmgEA --VS++wcV0S1rZb1Fb--