From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============0621243856458565304==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: [zen:5.14/prjc 1/221] kernel/sched/alt_core.c:1409:6: warning: no previous prototype for 'sched_set_stop_task' Date: Tue, 28 Sep 2021 01:55:09 +0800 Message-ID: <202109280107.BerKXEBh-lkp@intel.com> List-Id: --===============0621243856458565304== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable tree: https://github.com/zen-kernel/zen-kernel 5.14/prjc head: a74cb46b3e41b71e5eb452467ef2000188afe8d7 commit: f746b5817d3274fa4f458f87f6b452e7304b1d64 [1/221] Project C v5.7.5-r2 config: parisc-randconfig-r013-20210927 (attached as .config) compiler: hppa-linux-gcc (GCC) 11.2.0 reproduce (this is a W=3D1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://github.com/zen-kernel/zen-kernel/commit/f746b5817d3274fa4= f458f87f6b452e7304b1d64 git remote add zen https://github.com/zen-kernel/zen-kernel git fetch --no-tags zen 5.14/prjc git checkout f746b5817d3274fa4f458f87f6b452e7304b1d64 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dgcc-11.2.0 make.cross= ARCH=3Dparisc = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): In file included from kernel/sched/alt_core.c:191: kernel/sched/alt_core.c: In function 'dequeue_task': kernel/sched/bmq_imp.h:52:9: error: implicit declaration of function 'sc= hed_info_dequeued'; did you mean 'sched_info_dequeue'? [-Werror=3Dimplicit-= function-declaration] 52 | sched_info_dequeued(rq, p); \ | ^~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c:444:9: note: in expansion of macro '__SCHED_DEQU= EUE_TASK' 444 | __SCHED_DEQUEUE_TASK(p, rq, flags, update_sched_rq_water= mark(rq)); | ^~~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: In function 'enqueue_task': kernel/sched/bmq_imp.h:61:9: error: implicit declaration of function 'sc= hed_info_queued'; did you mean 'sched_info_enqueue'? [-Werror=3Dimplicit-fu= nction-declaration] 61 | sched_info_queued(rq, p); = \ | ^~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c:461:9: note: in expansion of macro '__SCHED_ENQU= EUE_TASK' 461 | __SCHED_ENQUEUE_TASK(p, rq, flags); | ^~~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:652:6: warning: no previous prototype for 'resch= ed_curr' [-Wmissing-prototypes] 652 | void resched_curr(struct rq *rq) | ^~~~~~~~~~~~ kernel/sched/alt_core.c:675:6: warning: no previous prototype for 'resch= ed_cpu' [-Wmissing-prototypes] 675 | void resched_cpu(int cpu) | ^~~~~~~~~~~ kernel/sched/alt_core.c: In function 'activate_task': kernel/sched/alt_core.c:955:13: error: implicit declaration of function = 'task_contributes_to_load' [-Werror=3Dimplicit-function-declaration] 955 | if (task_contributes_to_load(p)) | ^~~~~~~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:1188:15: error: conflicting types for 'wait_task= _inactive'; have 'long unsigned int(struct task_struct *, long int)' 1188 | unsigned long wait_task_inactive(struct task_struct *p, long mat= ch_state) | ^~~~~~~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:4, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched.h:1869:22: note: previous declaration of 'wait_task_= inactive' with type 'long unsigned int(struct task_struct *, unsigned int)' 1869 | extern unsigned long wait_task_inactive(struct task_struct *, un= signed int match_state); | ^~~~~~~~~~~~~~~~~~ In file included from include/linux/kernel.h:11, from arch/parisc/include/asm/bug.h:5, from include/linux/bug.h:5, from include/linux/thread_info.h:13, from include/asm-generic/current.h:5, from ./arch/parisc/include/generated/asm/current.h:1, from include/linux/sched.h:12, from kernel/sched/alt_sched.h:4, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: kernel/sched/alt_core.c: In function 'wait_task_inactive': kernel/sched/alt_core.c:1211:56: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1211 | if (match_state && unlikely(p->state != =3D match_state)) | ^~~~~ include/linux/compiler.h:33:55: note: in definition of macro '__branch_c= heck__' 33 | ______r =3D __builtin_expect(!!(x), expe= ct); \ | ^ kernel/sched/alt_core.c:1211:44: note: in expansion of macro 'unlikely' 1211 | if (match_state && unlikely(p->state != =3D match_state)) | ^~~~~~~~ kernel/sched/alt_core.c:1211:56: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1211 | if (match_state && unlikely(p->state != =3D match_state)) | ^~~~~ include/linux/compiler.h:35:54: note: in definition of macro '__branch_c= heck__' 35 | expect, is_constant= ); \ | ^~~~~~~~~~~ kernel/sched/alt_core.c:1211:44: note: in expansion of macro 'unlikely' 1211 | if (match_state && unlikely(p->state != =3D match_state)) | ^~~~~~~~ kernel/sched/alt_core.c:1226:40: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1226 | if (!match_state || p->state =3D=3D match_state) | ^~~~~ | __state kernel/sched/alt_core.c: At top level: >> kernel/sched/alt_core.c:1409:6: warning: no previous prototype for 'sche= d_set_stop_task' [-Wmissing-prototypes] 1409 | void sched_set_stop_task(int cpu, struct task_struct *stop) | ^~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: In function '__set_cpus_allowed_ptr': kernel/sched/alt_core.c:1501:35: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1501 | if (task_running(p) || p->state =3D=3D TASK_WAKING) { | ^~~~~ | __state kernel/sched/alt_core.c: In function 'ttwu_do_wakeup': kernel/sched/alt_core.c:1578:12: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1578 | p->state =3D TASK_RUNNING; | ^~~~~ | __state kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:1611:6: error: redefinition of 'scheduler_ipi' 1611 | void scheduler_ipi(void) | ^~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:4, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched.h:1860:29: note: previous definition of 'scheduler_i= pi' with type 'void(void)' 1860 | static __always_inline void scheduler_ipi(void) | ^~~~~~~~~~~~~ kernel/sched/alt_core.c: In function 'try_to_wake_up': kernel/sched/alt_core.c:1793:26: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1793 | if (!(p->state & state)) | ^~~~~ | __state kernel/sched/alt_core.c:1799:20: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1799 | p->state =3D TASK_RUNNING; | ^~~~~ | __state kernel/sched/alt_core.c:1812:18: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1812 | if (!(p->state & state)) | ^~~~~ | __state kernel/sched/alt_core.c:1879:12: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1879 | p->state =3D TASK_WAKING; | ^~~~~ | __state kernel/sched/alt_core.c: In function 'sched_fork': kernel/sched/alt_core.c:1973:12: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 1973 | p->state =3D TASK_NEW; | ^~~~~ | __state kernel/sched/alt_core.c: In function 'wake_up_new_task': kernel/sched/alt_core.c:2136:12: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 2136 | p->state =3D TASK_RUNNING; | ^~~~~ | __state kernel/sched/alt_core.c: In function 'finish_task_switch': kernel/sched/alt_core.c:2384:28: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 2384 | prev_state =3D prev->state; | ^~~~~ | __state kernel/sched/alt_core.c: In function 'schedule_tail': kernel/sched/alt_core.c:2433:20: warning: variable 'rq' set but not used= [-Wunused-but-set-variable] 2433 | struct rq *rq; | ^~ kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:2518:15: error: conflicting types for 'nr_runnin= g'; have 'long unsigned int(void)' 2518 | unsigned long nr_running(void) | ^~~~~~~~~~ In file included from kernel/sched/alt_sched.h:16, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/stat.h:20:21: note: previous declaration of 'nr_runn= ing' with type 'unsigned int(void)' 20 | extern unsigned int nr_running(void); | ^~~~~~~~~~ kernel/sched/alt_core.c:2565:15: error: conflicting types for 'nr_iowait= _cpu'; have 'long unsigned int(int)' 2565 | unsigned long nr_iowait_cpu(int cpu) | ^~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:16, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/stat.h:23:21: note: previous declaration of 'nr_iowa= it_cpu' with type 'unsigned int(int)' 23 | extern unsigned int nr_iowait_cpu(int cpu); | ^~~~~~~~~~~~~ kernel/sched/alt_core.c:2600:15: error: conflicting types for 'nr_iowait= '; have 'long unsigned int(void)' 2600 | unsigned long nr_iowait(void) | ^~~~~~~~~ In file included from kernel/sched/alt_sched.h:16, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/stat.h:22:21: note: previous declaration of 'nr_iowa= it' with type 'unsigned int(void)' 22 | extern unsigned int nr_iowait(void); | ^~~~~~~~~ kernel/sched/alt_core.c:2706:6: error: conflicting types for 'arch_set_t= hermal_pressure'; have 'void(struct cpumask *, long unsigned int)' 2706 | void arch_set_thermal_pressure(struct cpumask *cpus, | ^~~~~~~~~~~~~~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:19, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/topology.h:264:6: note: previous definition of 'arch= _set_thermal_pressure' with type 'void(const struct cpumask *, long unsigne= d int)' 264 | void arch_set_thermal_pressure(const struct cpumask *cpus, | ^~~~~~~~~~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: In function 'scheduler_tick': kernel/sched/alt_core.c:2753:9: error: implicit declaration of function = 'psi_task_tick'; did you mean 'put_task_stack'? [-Werror=3Dimplicit-functio= n-declaration] 2753 | psi_task_tick(rq); | ^~~~~~~~~~~~~ | put_task_stack -- from kernel/sched/alt_sched.h:24, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/kallsyms.h:177:20: note: declared here 177 | static inline void print_ip_sym(const char *loglvl, unsigned lon= g ip) | ^~~~~~~~~~~~ kernel/sched/alt_core.c: In function '__schedule': kernel/sched/alt_core.c:3357:31: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 3357 | if (!preempt && prev->state) { | ^~~~~ | __state kernel/sched/alt_core.c:3358:48: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 3358 | if (signal_pending_state(prev->state, prev)) { | ^~~~~ | __state kernel/sched/alt_core.c:3359:31: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 3359 | prev->state =3D TASK_RUNNING; | ^~~~~ | __state kernel/sched/alt_core.c: In function 'sched_submit_work': kernel/sched/alt_core.c:3438:19: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 3438 | if (!tsk->state) | ^~~~~ | __state In file included from arch/parisc/include/asm/bug.h:93, from include/linux/bug.h:5, from include/linux/thread_info.h:13, from include/asm-generic/current.h:5, from ./arch/parisc/include/generated/asm/current.h:1, from include/linux/sched.h:12, from kernel/sched/alt_sched.h:4, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: kernel/sched/alt_core.c: In function 'schedule_idle': kernel/sched/alt_core.c:3512:31: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 3512 | WARN_ON_ONCE(current->state); | ^~~~~ include/asm-generic/bug.h:104:32: note: in definition of macro 'WARN_ON_= ONCE' 104 | int __ret_warn_on =3D !!(condition); = \ | ^~~~~~~~~ kernel/sched/alt_core.c: In function '__sched_setscheduler': kernel/sched/alt_core.c:4031:46: error: 'MAX_USER_RT_PRIO' undeclared (f= irst use in this function); did you mean 'MAX_RT_PRIO'? 4031 | (p->mm && attr->sched_priority > MAX_USER_RT_PRIO - = 1) || | ^~~~~~~~~~~~~~~~ | MAX_RT_PRIO kernel/sched/alt_core.c:4031:46: note: each undeclared identifier is rep= orted only once for each function it appears in kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:4749:13: error: redefinition of '_cond_resched' 4749 | int __sched _cond_resched(void) | ^~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:4, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched.h:1948:19: note: previous definition of '_cond_resch= ed' with type 'int(void)' 1948 | static inline int _cond_resched(void) | ^~~~~~~~~~~~~ kernel/sched/alt_core.c: In function '__do_sys_sched_get_priority_max': kernel/sched/alt_core.c:4902:23: error: 'MAX_USER_RT_PRIO' undeclared (f= irst use in this function); did you mean 'MAX_RT_PRIO'? 4902 | ret =3D MAX_USER_RT_PRIO-1; | ^~~~~~~~~~~~~~~~ | MAX_RT_PRIO kernel/sched/alt_core.c: In function 'sched_show_task': kernel/sched/alt_core.c:5010:16: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 5010 | if (p->state =3D=3D TASK_RUNNING) | ^~~~~ | __state kernel/sched/alt_core.c:5025:9: error: too few arguments to function 'sh= ow_stack' 5025 | show_stack(p, NULL); | ^~~~~~~~~~ In file included from kernel/sched/alt_sched.h:9, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/debug.h:33:13: note: declared here 33 | extern void show_stack(struct task_struct *task, unsigned long *= sp, | ^~~~~~~~~~ kernel/sched/alt_core.c: In function 'state_filter_match': kernel/sched/alt_core.c:5038:18: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 5038 | if (!(p->state & state_filter)) | ^~~~~ | __state kernel/sched/alt_core.c:5045:56: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 5045 | if (state_filter =3D=3D TASK_UNINTERRUPTIBLE && p->state= =3D=3D TASK_IDLE) | ^~~~~ | __state kernel/sched/alt_core.c: At top level: kernel/sched/alt_core.c:5052:6: error: conflicting types for 'show_state= _filter'; have 'void(long unsigned int)' 5052 | void show_state_filter(unsigned long state_filter) | ^~~~~~~~~~~~~~~~~ In file included from kernel/sched/alt_sched.h:9, from kernel/sched/sched.h:6, from kernel/sched/alt_core.c:14: include/linux/sched/debug.h:17:13: note: previous declaration of 'show_s= tate_filter' with type 'void(unsigned int)' 17 | extern void show_state_filter(unsigned int state_filter); | ^~~~~~~~~~~~~~~~~ kernel/sched/alt_core.c: In function 'init_idle': kernel/sched/alt_core.c:5118:15: error: 'struct task_struct' has no memb= er named 'state'; did you mean '__state'? 5118 | idle->state =3D TASK_RUNNING; | ^~~~~ | __state kernel/sched/alt_core.c: At top level: >> kernel/sched/alt_core.c:5191:6: warning: no previous prototype for 'idle= _task_exit' [-Wmissing-prototypes] 5191 | void idle_task_exit(void) | ^~~~~~~~~~~~~~ >> kernel/sched/alt_core.c:5340:5: warning: no previous prototype for 'sche= d_cpu_activate' [-Wmissing-prototypes] 5340 | int sched_cpu_activate(unsigned int cpu) | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/alt_core.c:5373:5: warning: no previous prototype for 'sche= d_cpu_deactivate' [-Wmissing-prototypes] 5373 | int sched_cpu_deactivate(unsigned int cpu) | ^~~~~~~~~~~~~~~~~~~~ >> kernel/sched/alt_core.c:5416:5: warning: no previous prototype for 'sche= d_cpu_starting' [-Wmissing-prototypes] 5416 | int sched_cpu_starting(unsigned int cpu) | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/alt_core.c:5424:5: warning: no previous prototype for 'sche= d_cpu_dying' [-Wmissing-prototypes] 5424 | int sched_cpu_dying(unsigned int cpu) | ^~~~~~~~~~~~~~~ kernel/sched/alt_core.c: In function 'select_fallback_rq': kernel/sched/alt_core.c:1357:28: warning: this statement may fall throug= h [-Wimplicit-fallthrough=3D] 1357 | if (IS_ENABLED(CONFIG_CPUSETS)) { | ^ kernel/sched/alt_core.c:1363:17: note: here 1363 | case possible: | ^~~~ At top level: kernel/sched/alt_core.c:142:18: warning: 'sched_sg_idle_mask' defined bu= t not used [-Wunused-variable] 142 | static cpumask_t sched_sg_idle_mask ____cacheline_aligned_in_smp; | ^~~~~~~~~~~~~~~~~~ cc1: some warnings being treated as errors vim +/sched_set_stop_task +1409 kernel/sched/alt_core.c 1170 = 1171 #ifdef CONFIG_SMP 1172 /* 1173 * wait_task_inactive - wait for a thread to unschedule. 1174 * 1175 * If @match_state is nonzero, it's the @p->state value just checked= and 1176 * not expected to change. If it changes, i.e. @p might have woken = up, 1177 * then return zero. When we succeed in waiting for @p to be off it= s CPU, 1178 * we return a positive number (its total switch count). If a secon= d call 1179 * a short while later returns the same number, the caller can be su= re that 1180 * @p has remained unscheduled the whole time. 1181 * 1182 * The caller must ensure that the task *will* unschedule sometime s= oon, 1183 * else this function might spin for a *long* time. This function ca= n't 1184 * be called with interrupts off, or it may introduce deadlock with 1185 * smp_call_function() if an IPI is sent by the same process we are 1186 * waiting to become inactive. 1187 */ 1188 unsigned long wait_task_inactive(struct task_struct *p, long match_s= tate) 1189 { 1190 unsigned long flags; 1191 bool running, on_rq; 1192 unsigned long ncsw; 1193 struct rq *rq; 1194 raw_spinlock_t *lock; 1195 = 1196 for (;;) { 1197 rq =3D task_rq(p); 1198 = 1199 /* 1200 * If the task is actively running on another CPU 1201 * still, just relax and busy-wait without holding 1202 * any locks. 1203 * 1204 * NOTE! Since we don't hold any locks, it's not 1205 * even sure that "rq" stays as the right runqueue! 1206 * But we don't care, since this will return false 1207 * if the runqueue has changed and p is actually now 1208 * running somewhere else! 1209 */ 1210 while (task_running(p) && p =3D=3D rq->curr) { > 1211 if (match_state && unlikely(p->state !=3D match_state)) 1212 return 0; 1213 cpu_relax(); 1214 } 1215 = 1216 /* 1217 * Ok, time to look more closely! We need the rq 1218 * lock now, to be *sure*. If we're wrong, we'll 1219 * just go back and repeat. 1220 */ 1221 task_access_lock_irqsave(p, &lock, &flags); 1222 trace_sched_wait_task(p); 1223 running =3D task_running(p); 1224 on_rq =3D p->on_rq; 1225 ncsw =3D 0; 1226 if (!match_state || p->state =3D=3D match_state) 1227 ncsw =3D p->nvcsw | LONG_MIN; /* sets MSB */ 1228 task_access_unlock_irqrestore(p, lock, &flags); 1229 = 1230 /* 1231 * If it changed from the expected state, bail out now. 1232 */ 1233 if (unlikely(!ncsw)) 1234 break; 1235 = 1236 /* 1237 * Was it really running after all now that we 1238 * checked with the proper locks actually held? 1239 * 1240 * Oops. Go back and try again.. 1241 */ 1242 if (unlikely(running)) { 1243 cpu_relax(); 1244 continue; 1245 } 1246 = 1247 /* 1248 * It's not enough that it's not actively running, 1249 * it must be off the runqueue _entirely_, and not 1250 * preempted! 1251 * 1252 * So if it was still runnable (but just not actively 1253 * running right now), it's preempted, and we should 1254 * yield - it could be a while. 1255 */ 1256 if (unlikely(on_rq)) { 1257 ktime_t to =3D NSEC_PER_SEC / HZ; 1258 = 1259 set_current_state(TASK_UNINTERRUPTIBLE); 1260 schedule_hrtimeout(&to, HRTIMER_MODE_REL); 1261 continue; 1262 } 1263 = 1264 /* 1265 * Ahh, all good. It wasn't running, and it wasn't 1266 * runnable, which means that it will never become 1267 * running in the future either. We're all done! 1268 */ 1269 break; 1270 } 1271 = 1272 return ncsw; 1273 } 1274 = 1275 /*** 1276 * kick_process - kick a running thread to enter/exit the kernel 1277 * @p: the to-be-kicked thread 1278 * 1279 * Cause a process which is running on another CPU to enter 1280 * kernel-mode, without any delay. (to get signals handled.) 1281 * 1282 * NOTE: this function doesn't have to take the runqueue lock, 1283 * because all it wants to ensure is that the remote task enters 1284 * the kernel. If the IPI races and the task has been migrated 1285 * to another CPU then no harm is done and the purpose has been 1286 * achieved as well. 1287 */ 1288 void kick_process(struct task_struct *p) 1289 { 1290 int cpu; 1291 = 1292 preempt_disable(); 1293 cpu =3D task_cpu(p); 1294 if ((cpu !=3D smp_processor_id()) && task_curr(p)) 1295 smp_send_reschedule(cpu); 1296 preempt_enable(); 1297 } 1298 EXPORT_SYMBOL_GPL(kick_process); 1299 = 1300 /* 1301 * ->cpus_ptr is protected by both rq->lock and p->pi_lock 1302 * 1303 * A few notes on cpu_active vs cpu_online: 1304 * 1305 * - cpu_active must be a subset of cpu_online 1306 * 1307 * - on CPU-up we allow per-CPU kthreads on the online && !active C= PU, 1308 * see __set_cpus_allowed_ptr(). At this point the newly online 1309 * CPU isn't yet part of the sched domains, and balancing will not 1310 * see it. 1311 * 1312 * - on cpu-down we clear cpu_active() to mask the sched domains and 1313 * avoid the load balancer to place new tasks on the to be removed 1314 * CPU. Existing tasks will remain running there and will be taken 1315 * off. 1316 * 1317 * This means that fallback selection must not select !active CPUs. 1318 * And can assume that any active CPU must be online. Conversely 1319 * select_task_rq() below may allow selection of !active CPUs in ord= er 1320 * to satisfy the above rules. 1321 */ 1322 static int select_fallback_rq(int cpu, struct task_struct *p) 1323 { 1324 int nid =3D cpu_to_node(cpu); 1325 const struct cpumask *nodemask =3D NULL; 1326 enum { cpuset, possible, fail } state =3D cpuset; 1327 int dest_cpu; 1328 = 1329 /* 1330 * If the node that the CPU is on has been offlined, cpu_to_node() 1331 * will return -1. There is no CPU on the node, and we should 1332 * select the CPU on the other node. 1333 */ 1334 if (nid !=3D -1) { 1335 nodemask =3D cpumask_of_node(nid); 1336 = 1337 /* Look for allowed, online CPU in same node. */ 1338 for_each_cpu(dest_cpu, nodemask) { 1339 if (!cpu_active(dest_cpu)) 1340 continue; 1341 if (cpumask_test_cpu(dest_cpu, p->cpus_ptr)) 1342 return dest_cpu; 1343 } 1344 } 1345 = 1346 for (;;) { 1347 /* Any allowed, online CPU? */ 1348 for_each_cpu(dest_cpu, p->cpus_ptr) { 1349 if (!is_cpu_allowed(p, dest_cpu)) 1350 continue; 1351 goto out; 1352 } 1353 = 1354 /* No more Mr. Nice Guy. */ 1355 switch (state) { 1356 case cpuset: 1357 if (IS_ENABLED(CONFIG_CPUSETS)) { 1358 cpuset_cpus_allowed_fallback(p); 1359 state =3D possible; 1360 break; 1361 } 1362 /* Fall-through */ 1363 case possible: 1364 do_set_cpus_allowed(p, cpu_possible_mask); 1365 state =3D fail; 1366 break; 1367 = 1368 case fail: 1369 BUG(); 1370 break; 1371 } 1372 } 1373 = 1374 out: 1375 if (state !=3D cpuset) { 1376 /* 1377 * Don't tell them about moving exiting tasks or 1378 * kernel threads (both mm NULL), since they never 1379 * leave kernel. 1380 */ 1381 if (p->mm && printk_ratelimit()) { 1382 printk_deferred("process %d (%s) no longer affine to cpu%d\n", 1383 task_pid_nr(p), p->comm, cpu); 1384 } 1385 } 1386 = 1387 return dest_cpu; 1388 } 1389 = 1390 static inline int select_task_rq(struct task_struct *p) 1391 { 1392 cpumask_t chk_mask, tmp; 1393 = 1394 if (unlikely(!cpumask_and(&chk_mask, p->cpus_ptr, cpu_online_mask))) 1395 return select_fallback_rq(task_cpu(p), p); 1396 = 1397 if ( 1398 #ifdef CONFIG_SCHED_SMT 1399 cpumask_and(&tmp, &chk_mask, &sched_sg_idle_mask) || 1400 #endif 1401 cpumask_and(&tmp, &chk_mask, &sched_rq_watermark[IDLE_WM]) || 1402 cpumask_and(&tmp, &chk_mask, 1403 &sched_rq_watermark[task_sched_prio(p) + 1])) 1404 return best_mask_cpu(task_cpu(p), &tmp); 1405 = 1406 return best_mask_cpu(task_cpu(p), &chk_mask); 1407 } 1408 = > 1409 void sched_set_stop_task(int cpu, struct task_struct *stop) 1410 { 1411 struct sched_param stop_param =3D { .sched_priority =3D STOP_PRIO }; 1412 struct sched_param start_param =3D { .sched_priority =3D 0 }; 1413 struct task_struct *old_stop =3D cpu_rq(cpu)->stop; 1414 = 1415 if (stop) { 1416 /* 1417 * Make it appear like a SCHED_FIFO task, its something 1418 * userspace knows about and won't get confused about. 1419 * 1420 * Also, it will make PI more or less work without too 1421 * much confusion -- but then, stop work should not 1422 * rely on PI working anyway. 1423 */ 1424 sched_setscheduler_nocheck(stop, SCHED_FIFO, &stop_param); 1425 } 1426 = 1427 cpu_rq(cpu)->stop =3D stop; 1428 = 1429 if (old_stop) { 1430 /* 1431 * Reset it back to a normal scheduling policy so that 1432 * it can die in pieces. 1433 */ 1434 sched_setscheduler_nocheck(old_stop, SCHED_NORMAL, &start_param); 1435 } 1436 } 1437 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============0621243856458565304== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICIwDUmEAAy5jb25maWcAjDxbc9s2s+/9FZz0pZ1pEt/iNHPGDyAIkqhIAiFAWc4LR5GVRFPH 8khy++Xfn13wBpCg0860NXeBxQJY7A0L/frLrwF5Pu2/r0+7zfrh4Ufwdfu4PaxP2/vgy+5h+39B JIJC6IBFXL+Bxtnu8fl/b5/Wh91xE7x7c3715ixYbA+P24eA7h+/7L4+Q+fd/vGXX3+hooh5UlNa L1mpuChqzVb65tW3p6f16wek8/rrZhP8llD6e3B+/ubizdkrqxNXNWBufnSgZCB0c35+dnF21jfO SJH0uB5MlKFRVAMNAHXNLi7fDxSyCJuGcTQ0BZC/qYU4s9hNgTZReZ0ILQYqFoIXGS/YBFWIWpYi 5hmr46ImWpdDE15+rG9FuRggYcWzSPOc1ZqE0EWJUgMWVvvXIDE79xAct6fnp2H9ecF1zYplTUrg nudc31xe9EyIXOLQmiltzV1QknWTfPXKGbxWJNMWMCVLVi9YWbCsTj5xOVCxMSFgLvyo7FNO/JjV p7keYg5xBYhfgxZlcRXsjsHj/oRr84uL7Tgb90K27F5j/OrTS1hg8WX0lYejiMWkyrTZMWuFO3Aq lC5Izm5e/fa4f9z+/mogq+7UkkvqoSmF4qs6/1ixypI9G4qdqc7sJbglmqa1wXpI0lIoVecsF+Ud Ciyh6UC5UizjoU2MVKA6PGTMxpESBjItkAuSZZ0wg+gHx+fPxx/H0/b7IMwJK1jJqTkZcGxCa042 ihd/MapRer1omtpyipBI5IQXLkzx3NeoTjkrke87FxsTpZngAxpmWEQZnKIpE7ni2GcWMeHH5j5i YZXEyqzx9vE+2H8ZrVZ/jFlC6F2N6qKE/1JLjxgVsqhQNbhHP5RxtwXwp28LAFwPm9VvM4KrQpZ8 2QusiGPPvoOElLmIWB1BW1ba03BH7IW1ZCyXGjSlUZ/9iB18KbKq0KS88564tpWNM7Ojsnqr18e/ g9Pu+zZYAwPH0/p0DNabzf758bR7/DpMGdeuhg41oVTAWLxIrLOkuMMV7GC3ABFXqKUjl7F2sv+B gf7EwdBciYy0Im0mUNIqUNPt0TDfGnA2T/BZs5Vkpe8cqqax3X0EImqhDI1WCj2oCaiKmA+uS0JH CCSsNEgTGqPcPrKIKRgDk8MSGmbcyGm/fu78h8nyRfOHZ6p8kTISOSfSaKGqUK05pSkMR8H+LaZn z0WaPVCbb9v754ftIfiyXZ+eD9vjsBFNczSWP1xQmH+05+GhMUyGJqWopPJp4ZTRhRS80HUJJ1iU ztmAAxorkEOQfkq0K4Hd6rKMWCoszBbQfmmMT2n5Qeab5EBNiaqkDA3TIFjRnHUFzMjmA6Q19Xb3 GTNqGgs/3ZGVB8gnpX0zDIXQdfO343YJCeqPfwKHS5Q1nAr4X04K6izguJmCP3yHp7OdzjccNsqk Ni4vCvwEb8xeVZCMJ+DzZZm4HZo0B9XmJQddwlFt+hhImM7haPlUciMELcLTN24MlKO9jGNgLIaa UacgcQvfYleJTYhlMSx9ybxEQqJgVSs/UxVECcNqmM9aOiqWSeF2HWYM60myOPIizaxin6CwJSu0 cf4HSik4OF4yhPvkkou6Khu7MLSMllyxbgP86wmjhKQsuXdzF9jtLrfUVQepm60eQ83C4sHWYFod p6w0FskOcBY0l86q5iGLIq+qMEoSD0qzUsqRGHp+djWxrm1IKLeHL/vD9/XjZhuwf7aPYN4IaD2K Bm57ODaGuKUzkPeay/9IsWN5mTfEamOwG5U/HG6Ieoiuw3Lhl6KMhDOIKvSdwUw4Hi/2h40tE9Z5 An5qaRXHYHQkgYaoBEBTC+8ZvwPPMq8jogmGnjzmtPMErHOJMSQIoKe/0UHGVDhOoxsv9u4MKbmy TDz6HiGKRxFxYhnnPLdsOJhP8JDAVt2qyvKsjZqDJWh18Kv1YfOtzR283ZhswfGtyTfsNq8vLz7v TvX99kuD6KOfzvo2+mUETG8ZT1I9RcCB42EJlg+Gd8yccXxB36LRHPHf+CYwAdkE1d2CJI1vkIE8 ZermohFwedhvtsfj/hCcfjw17pvlAgzbQt6fnZ35NSl5f352ltE55IXbb0BcYi9n78mfq5nG5+fW RMzO1mmVdAHzBGdEEU1dfbUI3SEMXqFaZytcKa8rmcsJSZQfLUBji8QNmMyaO8dSZ2EtNfpXPh0k tMwqI48jAYtB3YEaBQnFfbIJpp/q85nVB9TFu1nUpXc5G3JnlvP46QYBPTcYxxqehiZFiRyrm6sh 7bBizu4ZQI0JIK/ee0nQjKTFu8P3f9eHbRAddv80SrVfnRxczpyjctCCCsc5GJDiFsLDJuD0TLpp J18iIueJ9C1jXua3pGRo8HLi8xjj25rGrdNij2HDa5pHmEXz+R80v3q/WtXFErxVy61twQrYzx1h gzgnLFYa6HuoJUIkmJFrubYEN1/VkZIuQLnhVguqZTSxi3r79bAOvnRbdm+2zGDa7Z5p0KEnm91E 6s/HYP+Eaddj8Juk/I9A0pxy8kfAIAL9I0gU/SOAv363VRMA/aqH8joLiVcY//tAjZIkr1EHBMen 7Wb3Zbdpp2OJKE2JUlzVGQW/njkemIxoh/bzOeBr2CO/2GGjJrbzH645Bp2EKpqt3Wm7wUP3+n77 BJ3B8egWwppMSVRqvF7LyzKn24UpBlLnyPhfVS5r8BqYzyNuMpwm2zUOXBcl035EA60hAolHIciQ dzOIVAhfrAv88AgTw2kJIfNI415ehNykd2o9oluyBHzTImo9AkIpUwAw/vtk/GHWL2M9Hq1pYdoW oMIUiRmoBrmiaeIjpRhFl+8FFOpf3Saj+l0yGM+GZFp0ySibXi6ilqZkFJ00y1kSUZXBdoAjbiIj nNCotxKxxuwe7Ji4LZr1m8xXNb1hgQVGpr4JQSPL/NAM+ISwgC7giESWlLQucLOT6BS5Hl8hahbD FDi60HGsPJwoDYKiu4x2eWsFbS+g0LrbnrnqUikJFcvXn9fH7X3wd+PqPx32X3YPTSJu0FrQrCXs PdEvkhl7vj852H3OQUMIDmGofcpMpKVyDMPOrWiu2WePzHQSYPJrGZw52082VzSYAYPwW/GRExPO OESSYEBgbYwqLGevKpr7JhBGXsCXnbVi/9tunk/rzw9bc8cXmIDq5PitIS/iXKO0+QP4Bq1oyaXP EWzxuRtJgBKMqjbobHdijhXDS779vj/8CPL14/rr9rtX5ba+n3XSmmsJO1vaCaXMYJUb/7LxyT6Y f5wTQSdxFXrEJcOQwB9c5TwpRyPB/zRuCIZ0A3TJQY5Ac4SVHc8ri/cubYwOEtAtahJF5c3V2Ydr 5/C1EUp/BRMTnlVu+s/F+LKHGSMFJTS1z719DwcfzUWDB2SrAwR2LpsFAp+JqJv3HeiTFK7j+Cms fImGT5exyBwv4JM5Y8J3tdWYmJys+oUzkUseolPeH62oi7DR2i3czD0rUdcBHTelkVTS3Ip4Fcy8 UPYuP7NTvosQAyZW4F1qr+yK7enf/eFvUEpTkQYhXNgUmu8aou/EOd4r9wudeXsSBoad/LmwzKek VnFpiSN+oZHPhO0AGCjJEjECYY5pBOKYeImJm1g1GFVBpCcyTu9muGiPlacnbBZXmtM5/muSjthg trveMCZddwB2DGzK3QRgcdFHuNT5GG3LKpJgyHG/HIGywJMt6U0Ac3K+XDZpX0qUT8ECmkRLTFpH dSkqba89R28mBHnnbCrbHV2ZtSUEvnWERoZo25TodESiwS5ZGQrlT/FCI1n4nCdcWi75aPW5TErM 1eTVaoyodVU4uYq+vTPlvOFpfIek7gqAiQVnzjI0NJaaz3BYRf5xY1GNyQBo4NK7mtiKuEuIIJDL udZjATVAI7pjpgzGC3Qls2lHpQ+Mk23BLocluZ1XIf0gsG3g8An/9SsOCX8mvbj68pNdG1qFttfc qfUOf/Nq8/x5t3nlUs+jd8p/2yeX17aILK/bo4J3wrEPA3OKhSvqgGrugVDn1BHxXy3gWlzDHs/s 57Wrg3qQpV1HpBi6bTC7WYITCUFOcy6vx8PMSs31FIo04EyMIIrrKaS+di4JEVpEmO8rRMT0nWQj ZD+Wu7aJ1zsxqOaoOdNzFdeEGFgVdK/9Gg37m00eE7U13TxtyXOV18uLOdqKJdd1dutdUoNLc0J9 8Kbgwh2slFlPy39rJP2yAduK9WIYu+bE1I3ZqsqgZNpUhIBlyOXIpbUbNwGxz7eX01gZ9F9E/dIK lo9qS1Dxq47CpBbhX7RwbF6Dag99o7TNsuER99+gzHVQKTn3eYxz7d1o3jQbjT/h8z8MZzRkM6aj dJ1AHD7gX9v1Rghsrz0igozr7dOeoAqcxCZ8QwAAQ9bcf41ltQDVP0OypuWdtEsZDdCdCMRezgeE FbZh7yCYTeA0H2EyYq85QnIpiAsJy4vrP698MBCsXgxbZHZhyxl+OaVSNnx56Y0nrO4JKa2v3P4I Sx4lbPxd8yQHWS+EkE6Q0WKXMN02yTS6JW4bwBD+ULtB09h/G22MsCKe6ZgR/zy7OLfKzAZYnSzt OVmI3EFEjI480wbSmlJfdsy9nILPCy/nRJPMl9dYXTiHLSPSd+cqU+HEWdeZuJXECd1bUCcEHiJd iyKlE0oINJ6NHxOXJMmZq79sfCp8B8tu0bon3t65CHnGtS86spvhHjjCZiPhaE8RCSAgHK3TqEQW /Q1me+Ihtn0qH1X/ktktcOlebjG204wxlM13Tt3PAK2LrP3D1M5w3BfiN5xWpyYg+1mrlj1f4ofQ KVONxk+9bm5EQ+tcFQqvoEW2dC1pCCqOYOZn6eVMSFYs1S3X1OdrLofYcwSZ+Pc9IgOFhflh73CY s+Kib+wb0m0xib9gQTJeLCbj59IbK+H6FXYCO1WlQ6xuJh+x5XjZs0vYEoXuPSA9pD+W2llp/IYQ 3u/QGyQ4YPPIPOWzCrmgyo+UmG/CKjsIQMD58dW3Sds3iJW5QrELzDB7Wa6a4myYsHStzcrubtT0 ChOOd5htsaiEH8dxLZZENI8D3BRVcNoe3WJYbC4XOmHFeAeiUkA4Jgo+KmPpc2cTmiOEnQ/rBYDk JYm46PiS683f21NQru93e8ztn/ab/YN96T2yH/gNcRumKTOy9EUbwHpzN9ytulCsG42s3ly8Cx5b vu+3/+w2W+sWcxDnBVdeCyOda5xQfmQ6tZ2WkNzBkQGHHfRitPLCUw9ckikNJh2f8Y7k3k14cUod SWqX+sAHpgJcQEhzF5CMGvx1/uHyg80QArkS2jGMzSKCgo0aRiZFDNhrOWFnuZqAVEZd+0+N7fep Atp5BYjnlDllUR5m+oV2zH2IFWQs8sZIoI5sD1Fb/ondJFIjgrmK8ZGUnyQRSuILKreLx72x0Viy M05mD9iYEV2ZzFuT6m/KCR6et6f9/vRtKvBDz4+UOJNJKQ+1ag6qA62IXU01wFC2GzU+RaVXXnBI 7TSKhSA6vVx4MY7WG8CXt9y9MbFwmLb2ew8OK7l/RbsGzfr4upLkerX6Gf28XL7EwxL+9Y+PHcdC BaAat2amh160++Z00gtkZI6Hj6BxRsZzQDZOgX2oZkWqV9sxmKrSjWQ7mHGVfaVJPd489wFXRilv /7nQuVwtnNqGGItiLVurS0aMrnXuNjC5XlaZfRuM0gQAt8g0TtA/PJ9quw7xuN3eH4PTPvi8hXXC S9B7vAANWs/yfDhvHQTz+eaG31x74XXXzZmVJYgX3FtTjcb5wyjj/kHa2+QiMB8x69x8kNP1tHQu 9735oUym9ehdWAfDbKzWd3N71DfD2omR19xxFVPnA5zNhEME4MwMwAWdcdkANzpPrQu0PgTxbvuA 9cXfvz8/7jbmbWvwG/T4vZVkSysiHV3G7z+8PyPjsRX36QvEyOLd5aXLvwHV/IJOwRd1q09d6vrD uzSe8bn+0yT6uFoRcM2ZKys8tgDTJGcHaXOZXYSjdD26YU5KAfuZZSMftTNRYzC6urmyvFu8zxbO 1oM3pYXIujCjs2BzzkRTyE6tDPf4w9z0N1f0dkUcI95ch8EomU9aA+zF2u++kSmcVCPHdKYZ3vxP G0+aOg9aLGwt7XQdlvnlik8A3ueHiPtY8XIxXpcXVAFiQX/i5X1bmluTSvufxWJbpb3F9YjCF4eA dfkhtrwggIvlmDtZ+qykwRDFo/G2YaiEUR8bP12ctvrZ5ppGWJc2s1UGP/P2yMKz8gL/469Tbiui pUd1IWyzfzwd9g/4sswTsZhBVvhkYFUXt35fAxdKs6T0GwNDoaSkNC+T55s0g/wMX1Ppz3AiE/gW nehRibRNg2BilUwWsQGjWM91NGlwzRZY+Xg5qI/j7uvjLdbZ4kLSPfyhnp+e9oeTVaeB3aPb0RmL bs1qTDgBuMyIniyVNUm2uivE5IDxfOXzfQxRCAdIeX65Wo07Ldid0lj59/LOEJC9iNR/esvLmgZa Mno9mmML7SZqo1Ku8CSHY4ZyMNozFbrYzQjZ+YerF5YHH4y9vzqzncqXtqkpINt/BrnfPSB6O95G l4OM3IGMUSIZSsKV15S+QK6ht77f4rskgx5O3zE4WoN2UeZP2/Y1yv6j3B9z9nj/tN89jqeED3bM mx/vVJyOPanjv7vT5ptfcdia+rbNwun2JYNFdJ5E79CtMrcGDgFODV8LMOUHmE8kReSoelA5I9WN Negz/mgZwWAe/fh6sz7cB58Pu/uv7pOdO8wee4mVRPJRFDXUie82rbsRiL6iayjGaipeU5ZJrx8B cbDOpV1E10HqHKtk7dlCCFBEBOt6/eepbMbqH1yYX+2Y8Nw/JHjYgyQerIrK2xpLEpyApwOZQroI KFpunnkNNDyUGH62YuhVmSyWmbuPqIUGDy/LwiZl1s9oaIklD+D++x8IjmfUx2ak0CbnatWfdgEf vrydwc1BTdao++UCF8qWzqOyBoqObdsB3KFc2FXs4K19FMr7OwxtD+n/lYb+mVuTTm5TWJ2ACOoe sJIlOZHj75rQD+8nQCfoaGEq47mHIJYWT2B5bmeAOqL2T10MnWuyzO3yV8zRpiBERsJiZ4EBFTNw k/r31G4t9/Tw9e9ihihtyAu0tYlY2yfKOvP7HaE+r0d3jy5u5XMqPppMbMith+95yt39aAHj+toO jCp2+KUF5+3NOFqD/xWMwiQsmSrR3+6e6XbyUqjRF2bfOMlGwFwvBkQ/26Y9L+MW55m2aVKFqwnZ XEc3feb+cNqZ0PNpfTg6VgVawa68x1SLzTaCQ5pfg4fTo4aUOyDb52AN0ndHB22a9A34UaC7tH3z aCF1uXLhKIdSZf5RQULNTwtMRh0s4WSqZgUq+BO8CPy1h+bZsj6sH48PTTyerX9M1kQIORkdR+VY cA7npLnwmij3kuRvS5G/jR/WR7DF33ZPU0Nuli/m7rT/YhGjo9/VQTiIY/9zO+4GxBzvKk2NnCjm tgDPe0iKRX3LI53W5y7xEfbiReyVi8Xx+bkHduGBYV63yZ+PZ5BH6v85e7blxnFcfyVPp3Yf+owu li0/zIMsy7Y6ukWUbaVfVNnuzE5q0pfqZGp7//4AJCXxAiqpM1XTSQCIBO8ACIDd3obDUZvY0DMo ItaUMC9bVFxNmX74lN+x0YVgTGriHjkh0T78+IG3ZBLIzYWc6uEzRokaw1ujKacfbwmNhdWc7pk4 FvTpJcAyQMi1piTRsclrEaWgr540CrxU9SJAaJV1HGHW2LEoIuNteU2pMUX5KA6Xdqjq1uIdNCxr JEbh/Y2eE/lcHp//+ICy68PTt8cvN1Dm0p0f1limUUT5fiES43MOhYjH0r6aEMO1zYUjdX6g/Wd1 cuPyTF0m6akJwtsgWhvLB+CruFivrG7nyuPAStomyilYF0QOB0REF0uzvjkZWJWpbq8F6Yq/h67u kkJYtdWgF4kFRZ6J4PTf/SCWivrTy18f6m8fUhxIy+ind2KdHkNyZrw96MIaDGK3vr4QYoR28k27 yhBj9rcEy8EWI+/on5HUyrekIllSsrPuSqaijalC0gQ97upH90ChBibbIg6Wh/9g/oYHUOyeeYfc /CE2qlmBJbpon2GmG2MzmBFyjWsccjQ0ENM3dJR320RUwz4UEGXX/OBQQ/EtlFCNyKrl+b9UcZoc MqJwjEezjgeOKZP2kjkS18wVF+lQNGkY6FeEVlkzGVnXrk1LPj6LldV9lbjObE5wABEoP6RkFZfD 2vfw9mGpAIbpGbQMSfPgJ5e8Mnd3jun6flvtDyVdL0x6UvKeCNAGFXkromAUzumhIVMazejeXISC T9QgaB67MgwGaAHlLz4Xi0Yx8ns8V5eHDo86tB0vz9B9ZpiW52kKuynt1jZSiIO2OJbj4i+fXj6b uyqnxH+M+y2bCPax+rRMss/ZbV1hckYHX6gzqttRlqawif8btm3FxGaWmqXU2AEU7VinBBTW6vgm gR74ZRKJbWYOaiXYmq7j8BThzBcNyE03/yN+BphI4eariC0kZXVOprNwh+Eqilwuq3i7YKtPa1OA E0B+57ri4QSgY1qayEjFrs2Y6tAtLNi0GOp+4WG6pF3f/Oo2yzRhFXHC3Ozcgs47Y3sBwHAteFID dsJIU0PO4AS7bCdd4QLPxGGST0JoRtSxOIPe7+DkdN9krXGteNqVKZxx62hF9lpNXaTzAOAScx6N d5moDxoJixyAoUltmKmvz7TDIT/UNiLp43izXdsIEMpWNrSqZb1ChrqUmWaCH1eFCp82G/uGHdQl BhMRhoeFxcULVOeNfRRE/bBv6o4E6pYtFaGZsfbnsrzXDVbNKak61UGwyw+lIfdx0KbvfXWA85Rt w4CtPEpB4HICiNgKU7BZFzVDdywYFcOod2qGvFCGg9uZ0hpO0Ex1ceJgnKSmK02zZ9vYCxJHGrqc FcHW86iwCIEKlLRH4yh0gAHVTVuUErU7+ZsNpdONBJyhradJL6cyXYcRHS2wZ/46pk7TBhZEczpr N06wp3TQfbA9N6FMAEmxoukg++vQ8wxreB2kDL5yk2IYYeW9JdsfMvVswCC4tmOKQSkNGiVNN2xj aBGwDiwBh3kRaB7lMzgi2iCxItMv8VmZ9Ot4s/DlNkz7NfHhNuz7FXXxKPH5vhvi7anJ1IZKXJb5 nrfSTkS9zVPH7DYgQqZG7lIBdfoDzdghYexcCsvT2Lvd46+Hl5v828vrz7+/8vSAL38+/AS17hVN bVj7zTMezF9gf3n6gb+qaX4HPcXs/6MwaqfSdxgNo29K4raadUmjaRBZeqKlwV1aDhdScsVJmBQp 5jfVROxxcurgU7JLqmRIVG+QS5NUuZ5mToBMf4PZwqJu2cKcgn7wUpe25jsiMS2K2uHUByP94cy0 LBvib+EIdxQ2AR1T1MejkO1ERvEsy278cLu6+cfh6efjFf7/p3YzO36dtxn685E9PiLhXGP3ZC8s VjNyWGWddW2DLk/mUtjV1d4Vo8lPKmLskb3j2bginYDOdZXdnUEX/5QZ4RZdpm6SI2TgCbx3bZ3s MUGBi6Ctz9UexNO8clLwVEYuLKZjuWR4H3huXDR4NbhLCt3dqUxSjGjTAV2ix0sXurs4pgMgE9Nd eoMSzTKkD9YuaTMteOqohhQCD0w9KaAd8BurDW87CRv291VS5jq9HsXBIzFqnji76lr4RQ8lqrqd nGgEq91Z6Z1Ol2gBN1z4dOSZ/knp/JJ1imlFRgFpEXlVoQUC8Qih0tB3Tzl+Q8u5RtihgICUqUtT Ft4jzbESq0UxSFiqTosRVpdb79cvF1y94hxLzuFMpOgDT5OdDIS+D2N4q7j4ZQYQ17oOEhHCCgAm aWKUlVWaYU2CFnz2RgruA7c7tw7nISTDnVA4SDtJPsE/tOQ7wDkCx1yrsyuBXOtkZ5t3FQ/yxwYE AUqyQVKODqLALGKEO7dBjahNL3qiZQ2rsKmgk3IHYkmyr1sX3Lz3ReypbvNP6nJRgBR9nlgtSxbb dICTBWacEXE9QnlbMEN/oa5gjaLrhzbr2vvf/TWJF0x6Gv9GbafM0Wew3+mObzxIit4ZDvu9qq5l h15NPHd7ULP85Y3moQAnRYuOytouOUNhBWHKZozPpoyizeleeLCPdV2bkyZyF9kek+4cj+i3caKO 5kPeZ/zybDKp5fkNkrovmZJy7yiMWw+HY1/IAscPQGAwIHCyVx3MDx0q9PidDhVHOgaYadC0jFb+ yrOg4mbeAIIabAPjVRz7NnRDkIpzzejtNE/RVVGjTXlSNgOIZuW5AYou3hToW0F2ZdF3eiHC9tlf k3sdXoDImnW+5/upjpC2fbPWEex7R7NqiyaO+wD+c9PNnqquGZGnbWZMB4TVaFK1WJsQne+uE4lY hlmCXRR1V7fopOekqHh2vKRwE/TNkK6iofuY+L6YD0TjkEqhUDeQ2At7s3l3FNfjks9Q07rVi2lB qGMJM4Ags1Cdx0qWOgpnHWi/vbILoU4HMxrOLrOUfROHsT3iCrZLY99YNfyjVUwA1xuygvXWUcEl 7zLGMvMjadY4wt4UtPive6bdsni7jdTcJeUexECh2hhAzQPqcMU0QRxhf6s50XEgnBgr/YoQoT3K 4fSk5BXmHWi1tJwjCGCrgaMIxHKqhUiRwl5yLg1mYOhT6IC8tBgq6z4hn9jh2Drtsvn1HgTdlH8/ vz79eH78JTZ96ZnKnGGXgBt6+EdVmQn6iVxkY5kV+Ia+EmZFbsfknr6/vH54efryeHNmu1GB5VSP j19koBpixpju5MvDj9fHn5RGfS0S2vf76oAr+RekOGyxh3r18+PLyw2UMXfQ9aoqffjXcLpq73ih ysHhaddqRpa2KdlxRpG6vVbp/Oml7GGBh2RToItWpo4z73xcO3OEhmFU/hzvpFhq95XVG/m3H3+/ Oi0tedWc1RRe+OcYfKzBDgf0u5aBjBqGcUe5W+PqQ+DKBKSe/tbI6j45vD1jyvonfJ3jjwfDEVN+ X4NUaGipBsnH+p5WYwU6u2iBxCNQCWkWHeT2EBGf3Gb3uzppqahWhVVlMuGfQ8M0NWMCgurQOB59 mUh2944r+omiqI85/GzIO9GJit1XSYNnDM3JhIaTy3CHt2jTe+5jTbRSpFDlpnAKm8Ey7zLN48LC ifodTGYodeXkbjyzUJ/T023e0UUc8OFKrGe5s2genM6tAp3eJ01itg3bpRtxdfgizsHHhYEAndAh CILCdA/QmzGNtajbXkqYypCyGgsCngBP618Bkf0DmzaIe/SVpSwAh4iBgJBR/gVyIYnM0MaXcdyU sdcPdQUrcaGGZL/xV5R/jES3OYrB13Z37jpVqZ7QoFVjHPW4YnR0lwbrkQkbibd2KXyJjTSxuzLx I8/aiMLeGyZWjKZAg1FduvDXasy0KQZlnnJaaNhy95RJv9msI+/NfhSE21B2xTIliHobglAnS/1w E4da35sllUm8iqirQYHnLqW7LNOCRRTUPkvrvQPHe9GuMm1gwGaeFpp523cft07W0IRe8JAB0Q0m D23Wnd3T7jwew+a4poc42iwtqOZayh5xsoYkY+vtfmlrfB4T75eprtsnmyD2XMthn2y9KJhWg8Ea x0b2RLOI1qGriGsZhz4uN3fjNBPtuAX0RbjqHWB929VRTH9MTiDzOxast/SeO1GsgzXliignWZmE 2uNAGphiaN9e+Ebj6nhEr6Nl9MaF5p4xPGqc7PSWPznxvkXB0mAzblEkWVvmK+uxP6FEPPz8wmOy 8t/qGxRKNV+OVtX++J/4r+67IsAgfd7u9hY0zYXspUGLfEdANcu/AMnrVoIYQJgPVtP4xSdtikjS rwHxddGkQ9KoWWpku1CDNSVFgeIrlC70bPTRMSkzvXtGyFCxKIrVwidMQT01PWGz8ux7tz5R4gGO Yl/VNKnBnG49KQVECNh/Pvx8+IyaoeXN03XazLzQShImst/GQ9PdU3KrfOMYsYqZbgKKR0Z+D6K1 YqfleYoxFwHeHVpzlj3+fHp4tpVvKf5kSVvcp1qKcYGIg8gjgcozrGOcjDkLRkp/HUVeMlxAREkq MqJJpT6gmfLWVVYq7hHfKMPwvVZRWZ+QrxEqJFXL05Eoz5up2BafSi6zicRRS5dV9LOTWh9edeO7 hnK1oO2COKbkRJWoNpRaFVd262izeaMAmKANPvpNcwc6oHO4y/ytZo8uxgQKLe3Bxh813Or7tw8I h5L4/OXmGtvpQhSAl1FDU3i+PWNn1DiDCO65GOxmfXRsJqALhabQVRvfXxivOeSBhIuJpoaIUXhi Io74N5eM5fGtwocuPS/0SdKHvmf3t4D3FjwvSdhC/2HrCiOoxGopaOBk5rBxDIyHyiagUq/BU6r6 b0jgR2bDSlYSTGNW9Te7nXs1HrMqtwqdME7+Ll0cEd0uwM6vHJtCLSLj3mAXbR35HfG5QLxdAEvT qqfqF4j3FOCvc4ZSGzmgE5qsYvwURNb31GA4t4n1kJe7rN0nRM/KW0MX3DkiUlr72CVHMwMWTfF2 L8kP9ASFNg6XKH9wyTrlVKJdct7zt2J8Pwrm94cISlcL0ZPV0bQR9Xabyp6BaEOXMuGoYixitJQ5 MwCOzWoXpkjbBFYbATYLDWFgYDHcqGjI8ZhRCzsgAy3P8arlSNG0tMF1KqEMXeI9dsol253pCSNQ zv3kWlAwJz2sHQq20Hbc+e3hmkIcNZnWZB0vPLgeQpRbQY084whpFj/Wxf6Qw6kiZHkCKgRmu6HV cFQPiar+VJfKRlKdi0Iv9HRJrcQbkkfM1WGYUhUMbx0UhWuYHHvk0n7Xfr42a/lDVpRLSKPdO0gv OGKM8qbMQVOv9gVtw0H0bcqGnRpllLAmA5UB4ZxAQ1YNd7RwYNUChxQ7ASEWRyMFVzMpxyHBwa6j q9jJm17toa9xtK6Wb+cE4u+PQI1a0p8Zu0tWoU8h8r5Z6WfWjBN9T7RB+Rykp7Y6pnQBrpU/UxhS rYLobinwlM/LwuDg0Vz0oEpkLWVlSpqmyI34Reh+6EPKdyC76HaCLoX/G0elXUOVwT/JmRnoIqGG FU0BD2lLmndHErz5QBK7TMSM4bMEKgdIlalDoGKr86XuTKQVjIvAS4dZEtu6pyyWU0O6MPzU6KEY Js4hIVlkmoTU50Vxj2le0iJRb9lGOEEpI1Lm3GGWSWX8ZBzQ9gxHIeYomVI5iVtQ4Ne+HdYsk9CT /ArUegkLR81KCaGjT0nruKUFrHjZTfg+zG4PnCUevU/xBfLFTtjHoOyiyKpjZvIExbquw2a09qrc CC66dBV6axvRpMk2WvkuxC+KhSavTK8Bg6LNjnaJZdGnTaGFQCx2jvq9zJiFdiy9YKYna+L9WBzr 3ZzbH8udrHmYV2jufOmDcgOFAPzP7y+vi+ngROG5H4WRWSMA1yEB7E1gud9EawsW+75v9vQp76PT ng4Q4ztETIbacRTTrusA0uR5v9JBMOfbNAsM4CXHl5KOzdlkh+UsiraUC7LErkPPGJqcbde9Wc7F kbxO4mCrsh0+cCX/9+X18evNvzAvlExq8o+vMGDP/715/Pqvxy/opfObpPrw/dsHzHbyT2Po+AFv 9H239W2IeD1Be2DFIOp73SmZbyVpGcQh/XiXxIMg0daOq0dJcVtX5L0Lotu0NNJN8q0It82FbcHK PcCBGcuPFc+Zp595BpL3hBM7Bua7Cax68yMc7IWezgYR2THwyMc/EVdmF2OiSgHegAzitTORIt2u 45QfTwWcGrRcygmYwW9eHs1SULQqGvo45Pi60XR+hH38tNrExvq4zUqxHar7pC52cVC3jsziym6z DsxN+7IGgdFab6AHO/iUUrVeSo2zwdhQTfsQhzmy6PLNJk2WUjZwkhKmcmPsUZXBS9MnFmCakFqN IkCYtPVNaN2khuA2zw1pgIVpsPLNfewknqgylgHLyy4zv29aY0D17LgCArL3gbqnmrEbo5Bztc6H JrgaDWD31d0ZNJFWBwsD7a4prVEbrffOoRsJBjojNN+kF9ITI/5adjo7wsfWgBXW4uyLZut4KoIP VprYud+yXyAYfgNlHyh+E6f4g3TNJMIL+BQSofoO3rukZgPoGaPsUL/+KSQTWbhy/JgFS+mGtEg4 RRBtMO2dVh5DPJ6YwmCINibMNLdfDBemdnUeRixes9Z4FxjDV07jfr7lnL4LSWuYrimhhuQK1EGc SOmnmDgQlk3dD3/elA8vOJzpLJdZie55ds0xJ7YFs+JMFdT+QO9inKTdhqTfFUd2p83WqE3klw43 nmfVhjLFmdH+0pygz/lPEPpz7XFOgEmxwixTgpMzvWQkCVqZHXWONugT043aAjXc2VDhY24xcu7Q IFLQvldcRxapeRx8jDdhemWzDGHAr4P2fqiEaXKGhOnZWSVw1/kUDOSSVksby0ej2erGe4AJ06zV NwiGrXhvIbhryu25ajK758aELsPFPUp4A3Iost4q2LJgNpg+HX8eyCsvju7NL4py4w1F4XCVR4Im jlf+0HaO1c5bbjdbXH/Cb2o+Ig2hJ9riKC7oODkRMo9rI+luzRyJvPdAxBlwtByfyTsqLTEJwms4 CvLq3iyOp19bOceqy8dVY301+J5HeaFyfKuF+iMI+i0MzHI4cGB3dA5DTtEndCo1RI7hPXpNLayc gwGyRvPubHylClQaByBArd0dxFI/BkXRs5qGIhbLySRAAq1XD+QnoqNZfsjJUHWO5Cdm2QUbc0lL oU0vCmAYXegqDKU065sOJxIl2HGsGdYjgWtnHYpwpy+EPndc+zTyBYvA9/hutEzl+7Qf5lyMB7sT puJ0zfeRSL5Go5dQN2mRHw54nef4vsdQOn0sJllRK6svqIAAjumyiiXw49AcjVPhE/QfuR4RUTbD 8c69LyTllHaNyyCKmcr2MsEhme19SN/Ilxql8GKIKvC/dpPCe6vI1kHvGRNTlwjnWYxXCtZU4hh2 DwJVOeZIcLRuTraglOBIjXqiXxPRMzXDnwtx9lXXIIUlvCPs8/OTSDVDvFTRoNk4x/T+t/wOheZj pOGObnNnKRg7RdiMk6foxM+/McH6w+v3n7aZsGuA2++f/zIRGX/M7EbE8N5g/I/z9fnX78D84w0o FaCmfOE5s0F34aW+/K/WdugyP4pjYBPfhTKW0BwOZ/E0NVGYaJU255VmGEYC+G0GjFn2LYRQDuYC ZyYFCBcLNTQSy/2hA71ihJdpE4TMi3WTvIXVziITS3HDej/yqANoJBBWBes7PDujN76Ds4NgRr3Z nbgoQTb3bHjRJJhkhDdKJJmFCffy8HLz4+nb59efz+TjRfJbGbS7wCKci82B6E0BN2xmCvJwrlJL oJzafZAGOPq+WKFq42Sz2ZI2Ypts5apLluK9r7rN9p1svbO8LXmdR5D5dk/OTMULyG243HI644tN t35fP6+JWahgl5qxDZY5jd/bp2RyPJss8RbrW72vujChxRq7vM07+V/RNn2b7p1LZEVHz9p0lCxp U6VLI7zKlkZ4lfjLXb57ezay0yYgcymaRGvnkufYtxcykEFVb9e0CZwTF7Hh2/MDySLKFdokiqOl muL1e2oKk7fnIW/VOzp5Eyx0ck+nhHcdQeL6+vHL00P3+BdxQMk6MkwWKbxC5ntd11fW4Yk39ok9 Q1O22hR+5EBsFXkCjy3NW14CeGLQJulOMr1t5AcmRd7e6QqxEHX0Y5JfK4FYrb5XJW7pNSF+Ag0X 34Baie1FmNr4TpHsZp6z+OvDjx+PX274ZR4hCYgXKND0SE4YwYPbsVyEFF6TZkdzqF7n6YWipcpd ZV7T9iOOLHfxmm1os44gaHikp4vfsk8tdug7LRFbpN4ZiY5Ok9YqgeX1AkuXPo6o05UjeSaOgZl9 iLmLDuq1u+iafRcGq7DXF4dzrKfrbg59/PUD1Altsck3SJoIlIP/Y+zamtvGkfVf8dPZ2TpnKyTA C/iwDxRJyZyQEoegZXleVFrHmXGVY6ccZzezv/6gAV5wadB5SMXqr4lro9EAGg27AIo6hvO1Giw/ pRR9dmSByclKcKSiCUrvEOrtNAmngZWguvx5chIburogLPQWb+BRFhiPISJNpIbRtnyn6dR1aKtg m1KUNmxv7fGsroNixNgi/prvfz8Peuh/SZ6PeO3uKHG/t7nd04TYrTdddLZVU0NYgWWyuKV727Xj Ij2WIB0igCzEpyWdA/MhVPhv7YklVlHV5VeXmGVG/FykE+dHG9c713WkUd07sBX90gj9ZQ/brrhG RL4+w4uI5xCLFDyxVIqHRLYWKgtKQkMPIPWZd5BW6ylv0WShO5DUMMf2yBVcUMqYMyprfuCuhjz1 eRgFnkdk3BLKkh8fX9++X57s+cvoo91OzHy58YqbKtxhDHw654KmNn1zq82ytyFseE1TafiP/zyO x6zL9ttcN8GrDh1lJJcDJhYLS8lJxIiR0fSxOSvpn4S3eJDIhcfjq7Mw8F2tNwRSI72m/Ony7we7 kuNG4XXVe0sz7hhaTrUuB7QCGnvS5GBWg+gQRCErIbTte6mE1GhtLY3EAxDqy5cF+LrN+JziSs7k wUaUyeErNqXnoi98oLfJ8B0sncPwJjKB0NsgVYCtKE2WMEVEbxSx2RiXD7T3FTdDp2jkKbAIvrDR +MCnzXZ58zLyAX+hUuc7FFVzGNQPbL2ksUqnSEU5bLUdT50H4r5aF4x0eHp7+p2c+tmBCE1FBR1Y qRq/6boG8+C+vm1NN/0W3hmpS5s0+oSo1Y66Qnt5ExoVu/k9vllQpjQ0bpfO9Cg0FpkGwrAzh5mh DQPdbc0EYjxRgLAZ1+TIvB+jo1fnCNPU83FGPHtOC88gWul9ngg1bk0OtF0EkBAPkAY+IEaA6yFE H6/IOfXsgy0che/kfeI4wWMx++nYCc2mb4WYt/htXJ0Fez3A9tyd6cOpC7HcwKOjO6LeNiNHyRPs lQ94eYOgSY6hYfISvwSoMSGtX8cf4a65C0CouRPywTYNxfS1xQFGtjusiNs0pmmMR2GbeKagRev1 2DVxyMxrzTNAAhRIkyBHyQQr6nV9nYSeuXduNNh4AO21UtB6YOjg/bWI8JuNChZatQ8JJgDwwm6+ qxBATGhZhHSVAlIvYB5w2aB9Pq3D2ZrSUByIboCrHmGMaBMASIjXICLEkxSJUL0soeSdAgoOdCyJ dYpYp+FbyzoPwaNRLAxJkKClk1iI75IZPMnafAUcGSpecgWWkjURUywUETF4psajZCREsaBcBkeE 9JUEYl92a9XwHI0tGqOjwar6H4okRi2CoeOEsuSdjq72WxLCzcz3Bnvbp0L7ULeKQpmZl+xHCWwT hBlc3lAqReW8RR8U0mBs5Lf6CeBCZWjGDC0kwwZqy9DcMjRdVDm0GZpbFhOKGHsSiDBdIgGkiF3B UpqglgZA0eqQ3g+FWrLW3NggmPFiECMW7SeA0tWuEhxi0YTORuNNiJWPD0Vx7hiuyg8FQpR7nfrd os6OfzlzeoKU6iYqSRJM6gWA2XobCAi5ReawTZefe54EiLhseXemdy693rTnYrvtuAuVHc9IkCNW Tb3n3U1/rjuOfVf3NCbYMkAASYArRgGxIEF962aOjsdRgCXLm4QJqweTYrHSThIsQzm9pmuzg+Cg LPROPzG+EWfNXsiYU/MSVhGBkMA3pQgEm/SViseUCSBRFKFDFSJgJoyt6+2OsPdZstUx2dVtRAmi K7s2SZNoQHRAd6rE1I60wW9xxH8NA5Yjao8PXVkWuFoSk1QURAQ/u9eYYpp4zt0mppuizIJgfTYF HoKexEwcp7KrQswa+71JwgDXrLfwDuLa1NmLJdSm6vs7cDs39wzmNloOEmxkM3BkVcbFkhKRK0HG x7AA6I+VMgo8+oGmVyCCPd5HRZdqbSUsr7WJphLLoAizJARAQg+Q3JIAr1jLiyht14b7xILNyQrb 0AzRUHwYODquedsmuO0rjKGQsJKF62MzL3nKyE/wpKsrf9EszKOy9zkJ1kxZYLCjMs0IJe+YnCmi OofrtsBM4KHtwgBpeUlHOlvSGaos2g5/4VRnwNtDIHGIe/5MLMc6TxgadnXmGEISoskfB0bouqV9 y2iaUtxJV+dhIR6pb+HIQkRNSID4AKSZJR3RIIoOGs12OdU4GjGpDet7HYor2aO3zxaehKTXW08u Aquu0WsJE890pokIMTyr04bBeW1tI81d/Xr5SIAnEUa3egvgQz7U3AyDO2FVW/W7ag/hQMdd7XNZ NfndueX/DJYiTuzvFOp829cyHDq89NQh2ZWVum+9OxzhKZjufFtzY5MbY9zmdS+Ueu55dBL7BELD wlZZsf6JP3WEUS8vAsNNt/N43Q2BlxJhnQCBs2szHvgEwqU0tBIf6cSDFHx+mscRF/Bu0ahzcnAh CklvfB/i7eEJvNBfvxixXyWYF119JWSXRsEJ4ZlPhtb5llC5WFYync3ry+XT/csXJJOxDuORj1tp +W4Wx+ncbI6xHN7MPO/oessEz+YeCmTY1i4NLn5RnBxhfQZAvCIFZZ+nMcGq934FlGfB5cu3789/ rHWrj2Uqw+QqJqwMrSAyhd++X55EE2MdOifv5dH0J1y98jfCx+u8zGFX6kYeOSDNeJsPxXV5QLU+ 3wjNyHm9McLQ6c5cwMLNC9fyq6K+PvAB/3pCrVTK+rDyzQQbc4egy0/4Ad2eF7CKCgc5ykilWtpG KiYbPk0ubB6PBDGecjQHABy1Im9Jff7+fA/3WrzPOrXb0rmRDTQVNHzX4QcTwAEnVabtA69EKL83 1C1YfpQPhKWBdR1eIvOlbJsu36pvC7uE8DBgFqDbRBLWnMiM7/JTRwJfhFFgsJ1gF5r1ospCN67F yCadHWaNvCXZE5Nmxtk7OHoOsaDEaj9eF9TpJTgZQ/0FZzS20hkP3KwDEg3xN6h9DDfREiQLfYt4 pBnPmgANHD4/igUateky6J261GN1UxHSk74nrRHdzpsAt7c7kphH25J6Enn2/oHSnoiYRrhgWFIT i+hz53QNUEWmVtyKEYTw/rXu0QoEI7IUZKbM3K61RpF8QcKqv3SSLNqD+RCeAOxIOEBTz+MEdt0V 2S+wEk9Q9xk1fE5hFOt79iPV8rhcqLYsKKru27hQzas9M51FmOf+CLMsSJGvWEawjbMZzfCPMmzH UqJDYm3LT9QM2yiR4HQws1S1+v1kPVAi1YBL2g+nypJleDDGzr8rtrEYgZ7X5IpNGAWB89iG/r18 UMjKR/O01MlDxFBXEAXGAXU6ry/iIWa+vuNVgU9kdZQmp7VS81qIe6WGiT3iOeLOK+lt7HkLXKIf 75iQa+w8UsLqUZPOuvSbb07xevuOgYf6orVKeccL63VzQR3g4jSl8Ukon8JSTwZj09HMcwlKwSz1 7CyP2TTtjRfu8qZFb0mCz3IYxJq4KAdofTNZUVJLpDRHaYeaOYNqkFEzUoo7dM1fssSnpCb3ayS7 LCQ41X7/zMDwi+4ji1Cy1LCqhtsmCqgrFzpDEkSrgnPbhCSliNXVtDSm1pRrBFA3ayDdyD15yFsa lu1hu/drRHesTQBiYkjLhmDnTbJ2bRyaJ4kT1eMLpmDQ2t4UQXe7KbIIPSsYQcObfqG5NR3pSEVv 5UXlFVtq9s/Xh/9wGzE7bxkTQ0i+vKuPQRLgjmIb2q1vINwWZWa8e6Xsc+lZihLdmi/LReuDAsKJ gvrT56nppShXbo3dPH3pvbrqmdOdHlPTsprfV7NevF8A9YL68dAMhkfSwgBxoG9yFVj9prWeep+5 YK9KblXNfNgO08wuLKgdM+N2GiBYZasJ5GVMM4aVN9+L/zoUUcs0FBpHaVMewjVcTG7gJouXW60d 14tty9UCIfeDFtCyfrR+nRY1SHnUCgXVFSZTgp9LGkwE9S61WEK8INt8H9MYve1mMRk3RxbMvC25 0GveiPVS7IESkoY5XiIwDtAzJ4uFYEnDxEvQPgQkRosDB/kxyzylEWCSYlPQwqMtKpAUpDOA5yaw wSWXID/FFv8EG0si/LTa4kp+Ji2W4daaySVWMj/DhZqpFo9+FmrXXrfDbEw/ZrIwy/fHRlEfc41p XKKbM4OJpwzPXUAsQ8W17RiLPZIHGGoiaixi+RaiSnFe7qEIPpK7TZ1zFCjyLIrxbzy6rzsKdWGu Ny2QressyZPhed62eLoyKlnftVi8KYuLtyVwYskrvNPf57DAG745Hy1vroVFd7XQXgcW8wuElHtn gMAqFT1f1lnGtSqCJKGvzQVGonUt3w/tkaAtzknb5YFnBgGQvzO38rhlaYKOaVibUlSGebMTZnbg qZCyKTeHA8efK7E5j3213dxs1xLrbvHAuDqfNHzPx7bF7GWNUazHgyRHq3XHGInQOUpC6R6DwAEp TKhHhU1L23eKD2yEol7bJlMcmNfqbDRd10vuetnGMk+vSjSk7xk9ko1EP1Nf7z1mh219WtJWyg7m OgEYmFg/va+RmnxTb4zY7n3hW2EXy9aTRtkfhnprPM0I1K7eO4SzUE9gh+1/1RY5FQT+Bwawoo14 aTK765TqTmlAU7E884NJNQ1CmeD44iCPOwsYaptgxVUEogwziK0QZYmd0hpksYZqBnNhNOGbsj/K ByV41VSFcVdoiXwyLeje/vpqXrEdmytv5WmMygxf+ktGsfJpDrvzcMR4DU4IkD/Aq3JHX9X6vJSP 7E6gXbOy/4kCTaE+foIVokzjbHq0F7OlphIf67KCZ8yPjqAd5FWxRhfX8riZxHq8Tv7p4SVqHp+/ /7h6+Qrra+0cUaV8jBpNKBeauRGg0aHfK9Hv+hGMgvPyaC/FFaCW4W29l5P7fqeHx1ccw83elDGZ lQydeW7Et/L1G6THFdvt/lBqQ1kSc363tysgZi84fkeoZSu6fafvSmBNp0m19sqJ07B2/0C3GBse vhRk+uXjH49vl6er4eimDP3bGlGWgbKvBpMg7HHRGXk3wG5RmOjQGLlSdQY3PysreGSGi6FcC63U HCDO3mFn8tw01dzHc4WQIusKwHSPGYOPX31+fHp7eH34dHX5Jnr06eH+Df5+u/rbVgJXX/SP/2a3 LsSSWAaw3jGXr2/fXx8+XJ4vTy9/fPjzr3+9Pn6CkiEBMpXsFScSM9RXUuE8z9NQv9thkM95w411 uImKNkMVg8aFOuWPRTts8saq4KelsSH+Ra6i9VtCsrkpd9VgTXELgNHO+dEik4LIyNnFoTPDg2Oo JhUaV9eI6QEzCySoRxJXBGpJNjjLWEJabvq63HmoEAS52ueWs8U4SG46eJ3B1yNqUpiGjbdLhqP9 msAwQPVt6qRaiNUJCx3RvJLeVu2hszWk+qLNm+aAaDWyKDBPF610HqqypWRGiYd8Ph5dheZGPbu6 PN8/Pj1dXv9yfOS+f3p8ERPe/QvEPvm/q6+vL/cP375B1FiI//rl8Ych0lPT5zelGWJzBMo8jTwm 78yRsQgz22c8zDL91GqkV3kShbEzE0q6vtRT5JZ3NAoccsEpDZhLjal+AWyhNpQgKmVojpQEeV0Q uvFW5EZUhEbOjC5s6DR18gIqzWzqsSMpbzunLYSpenfeDNuzwhY/xp/qSxWrteQzo6uIhXAlsX1s OYXY079cbJuV1IQ1AlfAvS2lcGrXEshJELnNPwJgUK+mySKCfyyA1Y83Awsz91NBjrGdtRlNnFH6 kQchSR3hbFgiqpA4gBzUoSO1iuwOCdjrFcPNR4c6Otixi8PITQrIsZOxIKdB4MjwcEsY1jHDbZbZ YZZcBn8TAuzW/tidqLrfrkkbyPPFEHdbR8lGMyO0aVaGHQxDtzVR8X54XsnG7WJJZs44l6KeBrhY huj9sgWnbldLcoaSY3031SBjcpGXGWXZBinYR8ZCfHNi7LRrzoh9U8xozrnptOZ8/CKU078fwMH3 Ct63c9r1piuTKKAhon4VxPB4Xr7kl8nug2K5fxE8QjvCUSdaAlCCaUyuuaNivSkoz+Syv3r7/iwM 5ynZxSPZgtQE/fjt/kHMzc8PL/By48PTV+NTu7FTikaoHTVLTNIMES/8THys5yDWIF1djmcKkyXh L9Uc2c0qq5HqjodJYqTofKGZJ4C59nNxKgljgQr03yOGjvGZuSyZ1rGqDb9/e3v58vjfB7DVZQc4 i0TJP7ozuRsRCgXbhBHPiZXFyAjuampzGf45Tl5p6EUzZoYLMeAqj9ME9RBzuFI8B2G+B4En93Yg wclTbsD00xoHo75CC5Qk+NmixRbizm8a029DGJgxgnT0VJCAoN6FBlNsbdibaOS7HmsU9tSIVGJs EeOypcgO2IgXUcSZZ2o1GPMTCdFo6q5shcyX3bYQXf9eE0smspoE6m7oloPg0lJFK+2/LcQk/t4A axmTIQICZ99xzP8mz7xCzmsSxp7BUQ9ZSE++svUMf/7T6nEahP0WT/+3NixD0YKRp2kkvhEVM4KN YlpOV3/fHq5gyb19fXl+E5/MS0Dp9vPtTZhUl9dPV798u7wJxf/49vD3q88aq7Zo5cMmYJlhIY9k uNXt2WPgwzHIAu1S9EzUTb6RmAgr2GVNwtDap4CBY967lVTGSk5Dc7xgVb2Xz53875WYP8RE/vb6 eHnyVrrsTx/NzCcVXZCydNqi9oxDWb49Y5Hu9LEQ6TRlCdI/+M90hjBno9BuQkk0z71kHgMN8cU5 oL83ovcoroEXHPfEkHWOr8PI4/YxdTZhmN6dpMca8PNHGXb3WhMVRKjclGC6DVAX6KkzA+Ocb/rG CvwE5GPFw1PmTWrUEeV44utAqssoltXJ5s/HQAlOjyd2oRQZd1tZZGKle4TIojeCZEG4mDKtcogx 5lQQQqTnbtlU65quULOYD1e//MwA5J2weJyxLmpFUq/SUShxhAoklfp2Q8VIL81aNUmkYpE6VYqs DtufhsRtlIHG1miHsURjZ4CW9QbatMU3RnUOzJ4f8RRwq6sUtXOomSuiql7MpObbLLAltioc0YSh R3WTUnWCMONJYJ+OATUK7UOzfmgIo87gVWS/7pL61qdafi9DMdnCqcrBUdTjGgMVzGKcIUyRdDQB Q2/sLW1JUMkh1G06In3F1FJ14CL7/cvr259X+ZeH18f7y/OHjy+vD5fnq2EZLR8KOYWVw3GlkEIo xQodX8QDfuhjCMXgqQSgIXXG0KZoaezxR5BjZlcOlKK3lzQ4tpMd6QkeRVdxiK5eUWMwttFgHVKO b1hMrLGoaGfRhij9GDVWT0EOiCWSSMc4dS2dl+t6zSxyhh56jUOU4UqWBNzIzTQW/uf9IugSWYB7 r9PF0iSJzMsfxsmolvbVy/PTX6PV+aFrGjMDQcAmQlE7MSugc6SEsnnXj1fFdE47ns5/u/r88qrM JMdQo9np7lcz1Wa/uSYxQnPMWEHtvP0hQUt+wAc4CmKEaI98RbQGPmwVWKRmx9musUsLxJM13+TD Rli71NXhSRL/sGtWn0gcxEefVQqrJYKYYKD7qc/YuT70N5zmzje8OAwEc/iRH1WNOk5UI+Hly5eX Zxlf4fXz5f7h6pdqHweEhH/Xj+ad29eT9g6yzBqfnbHv5F39mHtJ7gmZLNzu9fL1z8f7b+5jmfnO cNA/7vJz3mPnQXV7OtfdzZE6d+xKM6K9UvyCNkq4EaNCI0v69vXy5eHqX98/f4Z3xOcPxpS3om3a sjFe4BY06Vd1p5O0v+u+hUeqz2KhWRpflfrtW/F7czgMMPMhHkuQr/i3rZumrwoXKA7dncgjd4C6 zXfVpqndT/rqeO7qU9VAHJrz5m4wq8TvOJ4dAGh2AOjZzd0BBRc9VO/252ovVttYPJkpR+NgGNqo 2lZ9X5Vn3WMMmIVcGG86Qfvlxcem3l2b5RXGSQUjo6t6M+mhbmRRh1qGcHF7/0+xmP3P5RWJUABN WPe96d8riF2LGb/AvbxgrvMLEfbw322qnhgzlE51RCfvCyvp4uB73xXYed2IfjAbqm75YPcbH7Br gQK4ATk1Pt9tKvs3nPT/M9Jo3bEnBtOhq/Ywes2e4WFp3Y2HMXashexY5VNEzz78glseAAugi4ye bl8fcUsJ2ilFz9lB1OR7Iab0SdK5FSOp2tf/T9mVNLmNI+u/UjGX132YGC4iRU7EHCCSkthFkCyC kli+MPzcNe6Kdtsddk3MzL9/SIALlgRV79DVVn4fQOxAYsm8UBR85sX8dCkw7IQJtZtrSjzkqt79 gmyQvGgwkRXFJMa70ATapUj6Zz9IjLKTwjUqRxPsn82oRmOkAdFsTKbKcvsz48nRfQDDs8JCs4WH 0JkcIxK5as/qFpFVfJOYZFlR6UDJzN9jaHRrIdMNc3DptcRutELTLRo+ypZmh3987jADLRwJ86M5 8IBIptYdxMrktWnyRn1hB7I+idWVF4yrXZkXxthCukftd0vNesj4TFzW+GtiDt9oEqEeZiCygXAl VYv/5ptlfB6lgw1oSXq2eqpfuZlEsngqV4JY6Gg0YA73NPS7yEjBqanyY6n6qYfpjSTGMDc92NT7 d8H7d91QY4Tg6kpghJ5k4r7aKTebyIwaw6VKOXQNydm5KPDrvqK1wlmeo8Mw2BLY6yVP99pRBG25 EsJaW6Jf+F2PAGbY8USdwy2pi2rs2+Z8VV28A3TULqaiiztpauzjp9+/vH7+7Y2reLyFzFeVrdUp x+RdXbixXGbashOwanf0vGAX9OhpsmBQFiTh6ajr6ALpr2HkPV3RkgcCn7TTIMDGvBkNA8+Mtc+b YEcdYa6nU7ALA7IzQ82Xvx3hCGVhnB5PXmxlgrLI8x+PjlM1oJyHJIzwDVWAG7jhH0TY6LeM6WYd WPhjnwf6PuCKSQMD6PdXUuvw0bUy5OPdzVSKZxu3qsjxhMhHIXc+Q3J45YdvzBgs1ImywlleUOOF EocevugxWPhRhUJqk8jx0EhJjOu59Uox3Y0rX7hGgbevcJ+iK+2Qx77jwamSkC4bshrTSVbO9Ohf HUruDBhzHHxAAmuc5v1YXCk551SzvlA1J8MS5PRxS3ueY2DNpVbNq8LPEe6563d0dfnYciWvIqVq z06Lpc5Hw2QDiNqMWoKxqHJbWBZZGiW6PKekqE98xrfjOd/yotVFrHiyOjvIO3KjfCGvC3mn4zni mWuOx4pPZzr6C69VW8J14PbS689QmCwjMNapCylXmzuA7Ky6hHBRnOcWAZGSdb1hEN8mA6yVcvaP MFhbiiij6T0TX2fA4xW02YuPdk02HlF/Ahy9Ft2hYdAmyro3Csq6Ab8I52COSLO+Gq9cX88to6dK +f8yvcsQEbpSJ90fGvXNY6+K3GoxF65bmlzRkC6UPjvYdgVCCGhjY3HVVrUq5gpht5z2svP88aKZ FBTtrK3CUdvQUKUQpY5cB5tNsnTPG39eZFYdCRuOrirXnj6IiHI/SVJD1pfl0GIyscNidGFySRLN Av8k05cns9Tl5QngG+pBhyOHPlEveS2iseFZzarG7OUZ8XzVRaSQ0dLKfDM8c6VzKl0tLRJxNXG2 C9SzzEkWDwMm40rcbcxZa34iY1EURuIVgLMrDUcjxTnpKmKX7EmYV3dEU5FnLIyMauesDhGnG5ax oj44oPFLu0taCFriSw7AiuzchK6RoKzz8tToBSFlJSrNf8G5g5mimY76eoFU1cwP91bJSTFq952j R5oYjgFmobwuGA2w+4sp42JClC1FnhF9+/o/b3BG8/nl7eHt28PHX3/lCs3rl7e/vn59+Ofr9z9g x1Ie4kCwae9SPRqbY8TW9qIAssLfq96JZan0RZUMVrZnuSuyx6Y7+dpdNNFOmooYkiHexbuC2e1j IOhTWABrGkRGj26z4dyZkXRl2/NVlyOWjhahkT4uSmNEFBm8a0mSwOzhkxAbFoVy3zCjgV4H3bUa Fz3ToxyYRMWd87+KC9KKC05Rh0YZcsG6X1bkzEZFbZmlA4BYcjk7IjD4ElEINklyEXUo7sTVgvnl EZZmBW5OYSaKyQw8A1d9gTkG1nnyBbWda4my8kSJI/uSge+46Rxzia6j8lDgbiRcWAzEXEwoOJ+q zNlTR/V7AxgOs8s7yjYT9x/fQWRl6EWukV1peVi6pGU0KDoeTcVXUSPreaUaCvak2yyN3c59V9hl UgzmK9CllUG74esA/s0PxT/inTWcQRGNUmgs4Fqrjkm/D7MAvXorQqiPFieBXI9JIzAGMvfSDSUI aLMiYyN90za8rZurWAUZHy912YuX+UjKciuDk1g4ai0Dh9cMg8favEQ9X8w8CotSa5EzQ9kHsFQT 7yKu1GSYRR5Z8MLWtlm+i3hscyfEi9cFMeYMxaGtSAFGIk59iRKangJPvjy0Zvw1FrD5gbratmIb ojUyNCqxFZabnzpkNEjCSDDu1Wf2fKovbgqPKg7FtjEbb+eS9RVqTkesgtoUmFZ15QUffmtxDM5j cWKyF8ibKd+y6eElLGWO319efnz6+OXlIWsvyw3r6YbDSp0e5yNB/m6ugJhQgquRsA61o69QGDEV vAmgT0jXFJFe+Fg34BhjjthEb8L6CoAFT8SdZNIyO5YVHveQXU1FeE1qcO4dae1aysyxEdoTHUQW L/bimQ6mY4L1odJWjWqDcwDef+PA9+zG8lh2j7emQUZcFQFH0SQnfJk+5gcs/WimTuLLqjEcE2su PVZBALek47MN75Kcs1FRQBUVLb+DRiVxIx78o7wz8qGzbMSE1tXgFIfgZztLMDHzMdbDTFEV1wI/ 4dLpj0VBDwS3TDYzwZ3Moc+uTDMUL+/eQNVPW5Wi8skfX759fv308OeXj2/89x8/9JXtZDWovJgl NAHDaTx2ee5eO668vjF4OCuncEWFrw+tzSWdJIr5SPRzH4tWujYJNJZsTCgq92dhm8/JgDayFQPg ZlNe4TanGARfHC99WZmbjhIVC8FTdSkw9DTcSTbXAwmvDzLvULkIsE7EBiRJ6lNvOiqfb3Ddb1xG VQ3MHqNUFXIAp3Mu/ypTYuBkx06icPMw8gHNBU3qA4rNR24uvGyfEi9GCkbCBGA/dsEsA2MBNgpu dJFPTrGN7IAsbMWxFv9PdxI5Rzh/yBohZhdVG8U62QEzYp2Mg9lr5Nlq2DRzIpA1gShfAROPj+Jm AZ5ek4YbaVvYlHT9052PYSkVYZcv4JoAa4tnVubWsCNX/Ieio033vJG4qrlVxDzTEUDZ8+UcXE9C Plo3N1va5F1TIjGRrjbts5tFQLqyYEhJOgPQEixz36if+PYbl3U9ofb+7uXry4+PPwA1ZhUR8XnH Fzao8gNu0u6sW5zfsT7THJfpFS0QjoNto43WxBngPw2pFY406DoREHka03a8TWyv+SWZp69pC9Qa nM3H0wJLPiWvDsZWaOdIIvHEvg5rMtwIvR+YuspSrn2wZRJCHvqiZgTrueZsOEtHmuVYsvpl34/1 9PXT92/Cdtj3b1/hwFeYP3yAuemj2iQx7UZaLN3WGyRHDpKuCGDI6ly74SsvP7KcqhPz/yP1cpX4 5cu/X7+CFQerxxkdWfgBQ5YRHEjKjc1AjkfeHcKuROYMES/JxaYSWOWUFurWJchGyq39GTBViWzb gDjwxJ6RG80JWlEzfE/Pn3n39m0EL+SJOV8Q7WlGHa1GfsSXoe99BHg5tXcNNYKRLYzmJzHs5j1u Jyin5H6+xWYUbMnNpjFQkti4ch2urTTYuYlCRxnKTaANNN2bBycr2nclZZV1IWIlkCqLYnufWM3n kIIB7buZgLzuXa1yZKe+mkw6KJbP1KnSdj2JT859ORZg5g1dAYFXzS3wsoIOh505HwmVZP3dTkBO rmWd8Z7OzOsnCkizTfiaYQs88NvpbOgCpNmBba2MJ5JU3BwF/b/fPn7/9cfDv1/ffnt3oYt4cbXk l33gF2Nx1Ub1d1evnc9LXbbn0rl3CJShrMp6wFftEyYOx13ausJzLLWH/tieCP6FMoBpIZ/2/6c5 lc8V9gOQZdFbVXI6QYfCDU9z66rZcEc0Azc68vETSSQHCHJzQER2SKS3rrzY3gRab4psJS33kxDR J7k8DRE1VMp114UGpt0oVzFMMyX5PtR8F6wAuWC7FDPmh3t02Jsxx3MRi+bIiUCRUVsge8+RYH8/ WMcBKxb7zkvZFhG/B63TzJsoKuKqhQl15zrFJoEZ2Q7n/qZuCE9DfB9Z2M/IeL65ilPAd+v4mnho IwYALz0OoNXOfN+8iSSAx53v7XA5mrPH3c68JTnJozBCM8uRaFuT5pR469RSEHZYfkGO1QyX7/GW /BiFqCc2hRBFCRoU1irBZjKX1YwBHPJgeoFixXroR5a57lEBwfDLtIifPC8Nr+hcnXUNG8UR/vbg mbEwqrD0SgBpRxJA2osEIhcQo8lku6Daua7OLYwIqfgJwHusBNFsAeBOy36rcoER7lxhUXs/KsG+ jLUg94fVicY2LszOtGG4N6xwVuiHyFwGANbLhDxF5aavZg1y3rFbGHiDEa6cHUCKp3ty34ykA+z4 bmkP2RB4ux0emEP7AH8jsCw/P+z2u/esZoAYRId3MuP3RrlHiAatQvpxTviyGSlKIXfxkWFfyJGm weVhgEw3pkfrRS61DkMqLuOgd4UBLRjYdt/IOCcEWHsuWBL66CgASGD1HxftXnc89TRGnSCt+SOZ Q62ZIGTNXYruiI3aZV03Y/cYetiCuGTkUFQVoolXdJfuInRyqprsXJMTAfdGG/kwHb+vclDeE6Td zGq9E0HaiEDCaO/6ULhH6logkYeO2wKLMVemGiMNXIlJA7QVTRj+psdIcni3sS1Elt/uJTV0lmjk AmJ0XqKMJqkfg+fSaQ9y69MKeXL7gsXZZtSPE9z5s8rZJ+mdGUywUutehwK9LwJcHQAwwY4wJ8B0 UWzC26oPZ4Weh3QJAcRINU3AxmcFfP+zvPSRvjMj+FpqQV1FBR6E8VgjP/iPI8EA3a8iwUK/ywe5 MEAX6d1j4m/16K7i63BknODycIcNLV0f7JH1LhcnyCjLxSlStx2YpMW+CnJkdJFyZNUvAGS+5XLN SakmxwtKIOaggtLghH1z7On6KPLRIRZ2Zf0tdQsIaH2IrWuHHM1oFEeoxicQzCSYSsD6nZAjayEh dyQhRis/iveO+LHNCil3NHyOJcjUL+WuIWJC79f13vPew/L9d7My8i5q9G6WHaFBVLb6TaTkC2tk XBeX7nNsv3xG8LFxQZfDNosAVghGwv8aHu0MhrykaGKuq5aM0SBE7UyojAhbrwMQY3tZE4DdKlfh 7TGbs3ZRjDRp1hNUHQA5tjLh8ihAhjm4SJjuY3TVxeDwhWwewhEWRBF+2ARQvLUVAYx9jMwEAsD6 Nwd055EqsPfR5YuAHHZaFU6829SthSce3YvJAh1Jmuy3hkPBSJHKUjzfbIKuUUilbC9WViZa0wsc 4jZrbV4wYBWnwncTLUjvTDZ28KCA+GiiEtCxXxK4XhiiutoUPs8G33RwYjJZSIJg73pqJilyLwlJ BSAROtn3t2rnbTyTnTixt3kmLXwnYVuM0qkSkiQB4LfjuEqShiHuoF7jOHywapxkq7HdKj/ADlxu 1POwnZYb9YPIG4srsvi50QCdwLg8wOWR75Sj4x0gDvutK4Ur23cpO4cjBIViGIpFCPjOuEC2hjn3 pUi40YDa7VAJATJRCTkyb+IvZRZkW9UHyu5earBp0HUxQ/gRc/D3yIQDcmzVyOUJvjUikTvT/URC BytxawRPorxNgn3S/dhoJmAqAcgjdBcaENRLtEZwVWu6uR4AAn7EJJB7GdnjjSxN8OpOsQ1xIXfE g20ECTk63HC547spMhALuSM9KTpjC2RLLRcENCuphx0TgxzPYrrH9GDXNSUhx5sjI6bzK4PxoeKT DqY4VnSXRHssUthx228qo4KBaZFisw5TF2nmh3us2dAqiP0A3/ns4zDa3okTlOQ+ZTMzggA26vIC uUTK4RjffqzJJQn9LQ0HGBE2GtSYVY8FCNDZUEJbXVYykIbVtyT2Q48gbUs+aeDtCC7rdY2LcL2D d8M23q/4avZYuxCkhZMKp+sNjQKbBQVmAVCDH8oLYmkIoMyxG78gNm/Hw/xi0qcsmJDkf317+fJQ srMzFE5Ynm2rEU7purDD2JyzcnplMFn/VXMPjA1351RXHODi1wU3B8Gp81tn6ZGGZn9j+d8gyMP5 24+3h2w1eZ0vt7mWqCG4y+4QYCw/q3ZiFtE42YlkTBpq0iKUDPyev4JX/ZHiQZvjWMC/NsNzEmtJ N0RY8rKaTYZ0kejz5oopKivBuKu8AizMHJkdyBV1T6UxAjwwjxVeVqMD48o6ZHR8bGrMVAOQ5sdo erJpM0iTS9hnHZ7t6Xw5EnUzRsWdlKbD46QMM4giGml5pCPL9eRNl0etuBwWL7OpAnTBeL7JLlJ2 TzZo2NKbxffLG54quPICZlJ14wuz2Go1du8phcVvngAzKwCt71ktPDvsDR90VNjugPvBqP8WUcI3 o8RveMfj8kN1KY5lUblyzSnF8Fw3zIrxXIb7NMmumiY5YY+hnQCkxs/wP/SSOsAXKJu4ayor/5ON lK3R5lIPRiVkT9aodmZG2+kbdi4PRDcSBsBkYMDoZ6rJuLUNDUWtPvARXeumvBaiBWV9qVrsmiWL zbnJq+Uf377/l729fvrdvpO7BLnUjBwLXiTsQgss6HsmhDky0V8p7mlwovxCS75IqMcwMXzXTXgX pZi6s+Jr3a0FAAbCdCM+8Esae8Bk45H/PaMIvVT8O03VdAZ86MC6ZQ2mEvnYkZ1JfRJm9ERBcIZS xkuuREB4yIc9iJIgC+NdRIxvCaOrHibUZoNV7LAfO+HxDndatOCew7CqIPCRL9ihG5yy2JoDr5Hx 6XIorLRNWEeeXKHbjKRYria5MGvqTpqJavlqw3S3M8uQCyOkDNvIc+dQpCUajKgm6Wx41YTi0Awg DdjC2UGv+0IQqG0g18QzrkQxL8G0EfnVGzW+2BWnS0V6uynnQaIevsgy6LmOFBpCS6kT0pqZgQkr M5PVZySOvL2V077KotTYMdcZXMfc7+MI2zGZcdDj0a4Q/ccVqukD3a+MjKuoj4F/0OdCo0/L9yJf Xr/+/pP/8wNfhj90p4PAeZh/ff0V3rL9+fIJPBDByn4aCB5+4j/G/lzWJ/qzYhRb1EBV1o9mdbU0 8dQ7zTJ91cCr0RBeWGHWac8VB3pZn4caZd6y2PciZxMvW2u4YSca+jtTSsDsJ4nWF0zHLx9//CZc offfvn/6bXMk7Pok0rXppaD776+fP2szlEw3H3RPRWd3lwmQBmFduZpJDR+1z01vltiE0j53IOeC r4MPBXGFRB1iaIysvdxLHMn68loKBw94HFuD3MzJiyPhE9coql4U6uufb+CV7cfDmyzZtanWL2// fP3yBi6wv3395+vnh5+gAt4+gpHEn606Wwq6IzUrixrTJ/UsE6pdwtPAltTqBUsNq4tesyhsBIT3 S7UDFc+cHFiv+s6Q6md5KCtZ4vLl8J8vH3//159QHD++fXl5+PHny8un3zSf6ThjjrXkf2u+7lNt Bqwy0VvhbqJawyYsE4aUrUIkeT7VA/qZFZ7stB1xHmygTEa5sOTQ/pxh+mIHbwa7QVFfhISVN/Qr ZdvoRmFNbMwwrc9iWWaUcQafH3ss1Qq76zu8QADgq79Ss1hs4rySruqg2/WZblQYBMaCE0TnjCsF z7hwttL9l+9vn7y/qAQO9s0500NNQncow+cMiOorLZZHkFzw8Dp7ONOGZ6ByLfII3zji76IXCpjE 3mbwBGINCFLYXbWdJ9hdg1QhM8ZMF+8C0WeBM4McDtGHQndWs2JF8wHbG14Jg/a2aZYfuoxrHAcb yNnktcP6lkTGjLejC2pgRCWql/kUeay6ZJ7lfL0Ta6dYCpCkqgsRDUjRVMrFFfr2aKZ0LMpCLCEl q/xAvTSqA4EzSBDbyMDlkS1us6N5EqtBXowrOxopfA8pxjbfNIa68l3Kb+f3CVYXQj7eVDMVS2N6 CoNHWwyrskhzPa4gieepFxJnhHFtL/UIVjxHCu9ptuqVN3Xsa1weJci3gB8gVVTQ0AuQVtdduTzB kgaIw3PuSkkS1A/MkvOIIsWR8y6XLDN5WxrDCVJJqaNSU7xHhh7SqoUcKRmQ79C2KxDs6FElpJ6j x8Ypent1Kbt0r1vMXmtwFzmuumudfYefsOkDELYvo3SXwMd7Lc3afYpprWK+sF+RQyWCPmHPDVaJ hYG+daAj4/nGdaG7iUZHSdGU02wry90wuX0XqW4nA2r3pjNezcHm4MsJkY9WJiDRVg+B+SOJxiOh ZfXsiCFGNxA0QuoIug8S/AbT/1F2Nd1t6zz6r2T5vos7V9+SF3chS7KtG9FWRNl1u/HJpL6tzyR2 J3HntPPrhyApiaAgJ7NpYzwQCX6DJAiYPMEHeJL3ZIiDiWb1AtI0o2eQhyjEsLSee5n0iJgOeHvv xm1KLHQsSNqEWMyA7hM5AD2cEXTOIi8gRJ0/BIlDlr6pw8y5PZah095aANQRFFHezIvxxVeP1EVK 7a87fN3u5as42dUv5z9gw/vOCEg5m3mkOczQLN0Njw2US/tstl/8eHVYtOyQVmlDrBPypmuCfNiJ n2ThybB1/Soo3feO09w1gUvRB5/f9gdtElLaHd+uI6ISuruJ8URLB0Pra6gVfzmkEdzQ71k9zlA/ /CYmdhl49EZ6VQ32qmTHEkr97W+7+9RxtpuJKAc9Q+shI5uBHvkzSllu48gjh9we2uxmpSonXdOy WK/m+7Hc5q4rjZt7UwV+PL+Bq7zbg6cLjEgKlcMDSNgboh2cioTB0vl20fl8Rh7QPq8zCF5Ml3Or P5zITkCiPXaFDupMVIRmsrammsqLagHbQXS+p7FVkdbWTlSfxlhl6c92tnsIfVilxnlPtkobFQ1V E1Z5EMSJQ5yTaoQowj0Xo8ZYC9Tvg3SU5/zy48QC8gJkMAJOgffhlGdlCSH7qPOzLDc97NRpI2NT 1RCp0SRD4EYN/uVY5GYDbfhXOOSqAHVRBRMdT5eUBYOuosO8ghBgZo2YyJrsAQaHvFEjkrcKsTXP 6bZwI276HQJCredKdDEPQM4KRgKp6doOCLxosg33rXQhyuc47AJA66KlbyPkd82W0ycigLJFNBHi R4q8oB1G7xYTt1rqbG4yAJWyfRrKpX7DHQby/qzJ1vW2Dc8h4MNEw2oWGaLkFgNjUwXJa+o4brfa 8PZQbtrKOFmRROvnuEySui6oiV9hO47CWCkiuCDh2pbqUBXLNOuPfaXDxbfLP9e71e8fx9c/dnff fh7frpQ513usXZ7LpviMYliIaabA4SMUZdJ+qofVeb6cJMsvxeF+/pfnBMkNNrFHMzkdi5WVEIpB 9SxbvsN8Yx5dayKOhqGJ3fQzLhHnQj9bU17ZNEPJ00kB6qyK8abHAEiLSBOPJj4kD0MGPHE9+sOE 3GybeEKUgPkxtnLVCDy7E1VfbjzHgUqgZ1KTt848P7JZJxgjHxhH4ojRmZg6pUn2RuQ8zUiq2A0y l6KLVY7KVX5B9fYUjrNuFRy+tFhGDFFACdl6yAWVQXYnyAFNDmlyTJLNV4QdmQlVMB0PmUUVumO5 U1i4yo3rHcZ9CbCybDYH00N5N4qkkaTn3GcjKIv2sEHaEA3A6iy6NYzS/MH15sSHa4G1h9RzJ57g YDbqntLkYKRwHeRG+Tt5VOm8zm4PDDEO8U3bQM9Tl1LVBwZaPAFsyRvYrm7BYujBHzUHD71x84EW MkyCdlaJF4YTVml9Q4l/PkFIsNz0x2uiKeThOj41uRkM4a3RZvIRndCEI3LOGxgicpc34vMcnxgk A+wRs9kA+y4OzzhmCEkPOGM+ywC4Z6igXSLPoQ9KMVu892l9ErOJZYZWHTHbzCWfkI2YElJu2L6X bkxu+22miTrsUPpKZcR2c5rRTBHVmDs1OkwFl1pCkeUfsW7exMVyeQsvvRtLOMC3VArxqy0yoxDE Igf7xlvjO299h+jpEORY1pxDds+l0O1WdX4jXbFP2Y/XvTKr1fRFrOQP803a5B4lzd8NXYv3hfhr u0aOZru6mcMXchGfxqaQfKxpKIRZPr4tML+xTrAioIrGCij6iCzWnij0xqqApO/HugDQI4emxzRd rW1Uta7lskGNC4UwAmnaPCSHM4+8G8otK83o60MuYq8n1s8RItarcXPCIja1tt1aue/V/8ioghj/ t8Y+rapO1vZESSlys9m25Xq84o5Or0z6odiDcOSpi8mm07cCurbpUuRIfNudAZrcHe1QlzV9ytOI HPuwOVhk5aaTnN1ZUVXperPvvyS5NpXouvuNG1P3Oqt0J+aFytiadxSIOik2lLjHMQieZHIPtOH+ Qh1gPl9603YVzEiI1xz/Ob4ez0/Hu6/Ht9M3fNZZZpw6P4CkeZ3ohxLd27WPpW6mseK5IXfF7sU+ 3NJqupJ0VhhW1zHgWUDekhlMqzJCZskGxDNWTgD1BFCGyukmJQ6AE+80MVcwsfh3LHPmJolDCpDl WRE7EY1xWIcOODqmgcvLn6rY02+ALEYUodDAlgUr1/ZZTQemvC4K6uzWLL/Hao42nYJYcdfxErF4 V1VeLsmM5S0DiSCTboO+2a+t1bLvOKz2bHNIKX8mJrY1HvaQ0CdRH+HU1rxjiN9jmNF7CchXOu2b l2KW+9TU4AC+WnvJCs290C/S8j6tDq1VefPWPWTZFirPlryD8pK+9ZI8GfPA/VO+I4+lNAd6l6OJ hwhd7ZnUwzJti5E00+/sjMYpwXRunKqKKEoluWpom5kOX5NREAbUG2fGGzujRvTtedE0n98bPKtS TAJRtvMdegRLfDYJhbN0YnAJNCIvhC2eeDJf4yUZnUHk0RfjBS9aAaMwo+12bnyF1+QesiWmsp1v eEsaoLB9Zq1x0DsgvBKzW0dSJ25fOniqE0jwoVsuy/O34/n0JANOjI1qhKpRrEsh1tJ4REBgytGw KaWNeuGcFNfmI1vcZjKb3MaSCWzvOs6khHs3IfdwHU8r5hTVNMZjbqLiuu9a+TIz65UWWjNhx6+n x/b4X5DGUOfmvA2RxduCVnvgQts648SQmPaRjfGYoWRLxUFqG4pnB6E5PlP3TmPeVbl4N72iXX00 uXlev5ucWNWs5G4wL/2PMrsTU6zJFcURbdVkcZEOzSyeWTzRTgDdbEjJ8E5DSp4PNqTiLdbZdJa2 YcQI/GAjS9a+z0xyqCae5qAXFwVpSW5JO9MivCdt4vrhRE6JG8WTWQD44W4qmVVrvi+PYGWLZbag FciOg90qv2QhesYUdzx53GdyJR/hCvF92vQWC02Txkz6XjhkUmPfL5UifCPrj0bCZWIz3oh/M9/1 D2JHT9/q9/2MPK4FTUvo+Rwp7oJYsGJn6WnNl9S19YAm5jOPPsUFNEljPw1GHwlyPOGFb8DJS5Ee 9S3ZJDGkiEg966mpS1HnJDUjUyjGlQH0OLkldzwjP5q9UxmzybaTqEcnOnGM3+PkRr5HI6rUyh/Y mBrSEsTvlYu0bBrgGSnDjGrnWWrzCkq0tC+cNBAvHfpQADbMK9Fp7cSyFJ5NLvHjqh4RSpoHMA35 E9CWz8VX1Sa7B5OzkZhflh71QN8YslIixnljJY7QtqZRsUWdOufRsXvJtpPv7l3HYL/B5n2ILfAn 2MxGKRflrsAlUbRD3aDTadhhyKivfJNBnLgbkO/dAPENooz2+r6UthFsT1TtTK6pPYsoCLPNa8do chOdYQfFKuuMeu5rtHcL91y1GT9aB+DbZduJLvLl8/oB7/AGk8VPvC7XUFxqj5mW1XxjHGJA9GCG KF2McYsMDjYg5CUi1psqbRZlU2gvcF3ivTAyznlaZ/CYnDKbhsOHOs+sZHVM3Toz/da094eM5Q82 K7SXGGZLTJXBgSlZIFF6Iyoqd0t50lKPJI8vl+vxx+vliXh5UrBNW+hTnD69gXrIrKePoy3ort4e GvsFpVFunqFguYQwSsgfL2/fCPlqUT1INCBIM03q8EOC5mtiRRnkQGRZqUtwXDCNAMFGe6PFoVRI evXoR9TIv/jvt+vx5W5zvsu+n378G55ZP53+ETrZ4HNGBfPUqhoEECY824BJf5aud6ampalyp53y bYNO8Do3WNC1y/WCtmhUTGyCqQv4SUimRFbnx6TECgNj+UPWNsbcYAB8vdnUI6T2UvoTLaNZ6YQE /UftzJXD2gxV3xP5ounONeavl8evT5cXuhzALEY5PjqVxP4tbS8NmZLMY72v/1y8Ho9vT4/Px7uH y2v5YGXXJ/Ieq3KE8B9sP0rAEE4ekpGNOfpSHaPt6+DXL7oGANvvDw9siU5ZNXldF2Q+RIoyp+IM HhzuqtP1qOSY/zw9gweHflyMBKjKtjD9zsBPWUpBaJtNVRWN2Qofz0G7hRq2Z8TA09M2GlktOKXa peSKAKDopU2K9rVArZmYKj81+NmJnpamtq8Ayx0wWcek6LJQDz8fn0VHnOjTamoTU7dQHAcZFZXP y9GiU1UZVVSJielwNfpAEGvqXkmCnOV6RsUffcrWnMuRT1aFXoobsibI8pqjddilDssIb6UiTcgJ h58SM4a8JI02EAY5oJnxWXsP0GEChu8cMjU6Z5ekRjRzNCGQ2Jvdlsgjk0umkpvYvBkc6S0OtpmX pJHBkEAQT+QdTPikHxhI59MD7FNFVRt5KrXids0F+ODDAObUh70Cu2wWeMnRGyszMeWH8AD8JTXi NF6zQ74R+i2+LNVg71ELDJ3qig7PvdHR3j3nsNtUbbosOm5Uto7NH7HRTQL89IOO7R4iWasFfKTP 7k/Pp7O9XvWzAYX2Xm8+pJMNYkDNFbtFU1De3op9mw3eiYpf16fL+S4//s/p6Wiod4hZbJWyw9+p +ahDAwuezgLz+kfTl5bjTk1m6d4Nwph6fT9w+L75Qnigx3FkegwYAO1gA9Prdh264VgyNZ2LdU0+ xBjBTZvMYj8d0TkLQ9PoXZPBE/BEWQUk+on41ycvPJnYqzTGA7k8NyZuracd8nqB9GO4a688sd5Q pyRiS1sw8xGXDBmfLyqbzCH6Oywu7SGz6OUCu8iFlZ5Rt9F5mghFSggtZDH2GfqgpanRazK1t1yw zDsUc/OCV80NB+wwWY9w3mwov0RypFpfdIO8IB2pdmO7YEZzS6LrBZpqJeVOpVWa5hwlvN3aLham leVAO2Rzkmw7fEJIsV6Wa2oFMdjA6eVmDV5CrXzvF+VCcmGy9r8lNiOUsOpP5KFq+GbEKnMVU7P0 Q6ZYPJOFf+qcIllFFID+YKJwg5TFTvl/Utu1p6fj8/H18nK84q1aXnI38szL2I40M0n7CvnP0QQ7 qlVHpsNbzFmqzA+G34Ez+o2D+Gialc+cZWJOkj7GqBE8Z6WTJAo2kxqoOLZGnnpYlclT36Wtw0Tf anKHMjhVCDqklyTyimOxrzjEwUjNeaOn4Sow6FY13O95PiPFvN9nf9+7Dhn7nWW+ZzpHZCwVWlM4 ImApOqIlApBpUxeBJIHpu0IQZmHoHrTLaDMJoNNJCMR0nbzPRG9ANwaCFHnhhNKXpWB8Pon5pJUX b+8TH7+kA9I8tV8MdecQeGip4XZ+fL58u7te7r6evp2uj8/gaU+oBPbgU6Hu4IF1m+KBFDszt6GL JUCXfJQAwAyN0tiLIvx75lq/LX4zWIj4HcT4+8gZ/RaLXZoV8JAyFdvxyirGwEDbMgoWK+6cpCQH qkMAhEcqUMgrLgn4SNYkidHvmYfxWTDDv3EkXH0SJXQ4Kjt5uJSyNMw9YDGmnYwpOzlMzjIw6nE1 cTgnB/cKdh7GvDSDeW9Z00KA5sH2XohzWpVJ4KMxs9rHE9Nbd6pLp1+yfZzjxLVDDLsYVZt5QUy1 i0SScMQ8o+ZUhSD7BFB9HY/SfAFxUbguRUnszz0yZhQgvuk7B0yWI9P6lWW10EH3mBBgexIgzcjn TZ1BlPTaETm4Gk1Q6PXg+gHjtQfWHlYtr9OtGA60uc+6Fv1uqh9J5V05LDnsN3RjqyvIz80GS9rv ULkY7yagXO5gZulsxyJJHTZf8JwdcPAAE0GfyDumzElcrGFqKumtpAMD7niunZLruX4yTsp1EjBt Jius+zDhlk9rjEcuvEax8uM4FLGixTNzT6X5fLcwH3cIaltlQYit2IEq6toJqAGjL9/2XUfplqhb y5G5YC1eL+frXXH+il8ZCL2yKcSKaftUwckbH+tbjR/PYmdtHVGneeJHlOwrlgVeiMQeElApPP54 fBLiw3OFd5fWWO1aBwOZdz9WeXw/vpyeBKDc15hJtpXYktWrAy/WHIf+UFDxZaMxUictogQpu/Db VnYlDemmWcbRu+8yfcDDpmZgzo5DbWW578jRRak3QsKyKWEvvlROso2bau47tvJuobxoypRSundf Er1edhVu16TyDHT62nkGEt3qLru8vFzO5gEOzWBucRjX1cx19alrDMEMr0TGDSf3Ter9yHBFYXOr Szted3n3gpmJ8LrPWV1oW9u9gWG1RbdD44TRZ61VIBpD/cLCdJ9QrpF01xa9/FGNTDRCjJEYOhMP dgXkk1o9AGY3Fr8Dz8W/A0udExTqwFsA4cwDp+PmTYSmWgTfIuDgioISeUEzqWGG1rskRbnBPovs sLWCGoeU1ZMEkM4cxjjyoaTQ6no4Un3F4u9Q0wcgluruO0h9TZDXiJwHgWcGi2jF6oSP/0G5iiZ8 mLLI86egdB+6pP6V1WArb2lDwcwjD9zVYp+ONYM0s/SCVrnzSDyIFWGthAIIw5jWZRUc+6Q2psFI 7/M6R1y3Rk4/y3z9+fLyW58u28ukjvOWbxn7TK6VowRU0IHX43//PJ6fft/x3+fr9+Pb6X8h4EKe 8z/rqurMBJSN5/J4Pr4+Xi+vf+ant+vr6T9/gtswc+mbde6GkW3oxHfK2ef3x7fjH5VgO369qy6X H3f/Evn+++6fXq43Qy48iSwCn4xsIREdyVML8v/NpvvunepBs96336+Xt6fLj6OQxV7B5cmWY+8g gUj7Ge4wtOeVp2ORlca+4d6MTkJAQYjY52zpTjy2WexT7olNDHmAxuqt75h6oybYk5VeG6Ty7qf7 knTD3y797n2R1fvHNahW7uPj8/W7sbx21NfrXfN4Pd6xy/l0vVjdY1EEAekFWSHGFAVXFo69fwMK GqJkfgZoiqgE/Ply+nq6/ia6A/N8F80o+aolZ4sV7A4cdBogSJ4zEel51XKPtJletVtzseRl7KCg quK3h5pkJLx++CSmJAjO8nJ8fPv5enw5Cr37p6gMa2RCTw3IMy6N2b1YEsk3zxpLrH5cin48qTBq 2Fpmja6+4UnsTH/fM9AL9T3bmybF5Xp3KDMWiKFpvZUa6BMH04gFa1kCEYMskoMM3VmYANLZDIBS 2CrOopzvp+ikAthh3dlr/4xrshuYCUDTYeNjkzpcZqjQNadv36/GUDE6x9/5gdOLaZpv4VDGVAsr 38Fh+gRFzDfUe9K0zvkMPcGUFGRFnvLY97A/tfnKjSd8OAGUTNiPCx3DTUibeGY73xYUf8pHDBN7 WPLMell7ae2YV5yKIsruOOaN0gOPPFdUC/aR0G0DeCWWE5d6EIBZzJjqkuJiDexvnrrexIuwpm6c kJynujxUKDZTi2xCU8usdqKVg8w0S0z3AfZDoinoYmS9ScHdPJHzpgZ/MUYWtZDfczRtqKfSdX1q VQEgwDHL23vfJy9hxMja7kqOog93JDwOBzIa0m3G/cD0viYJ5j1ZV5GtaJrQPFyUhMQmzPBJjyDF 8cSBFK+C0KcV3y0P3cSjLEJ22boKrLekiuZTjbErWBU55l2RopjvYnZV5Jobwi+iBT3PQWofnlSU 5d3jt/Pxqu5MiJX5PpnFRrOk985sZp6C6AtAli7XJNE+VxkA+/4qXYo5jb6/yvzQM+OF6dlYJiPV KhqCCAA3YCGADXe9ZMWyMEEGSBiw9TwbptfJjqthvoubHiMTi6PFhAbA55Slq1T8x0Mf6S1k86qG //l8Pf14Pv462kc0bIuOjxCjVnuenk/nUZ8x1kMCN3MA5zQH8PmS9vfiXZi2uz/u3q6P569i03c+ YrlkMNpmW7fGbb6lasPGtapl6LZ3rucVL+K0ugnEK0I56dLRkupF+yy0Yhlj4vH87eez+PvH5e0E 2ztqKZdLT3CoN7Rl6UdSQzuuH5er0DxOhG1B6JmTYQ4eMX08+vZhQB7gS8QM4aII+CooqwN6jQTE 9V2b2ZowTWYURqatK3vbMVFWsh5E81xNE2ZWz/oH/BPJqU/UVvz1+AbaHDErzmsnctjSnNhqDx8q w2978pM0a97Lq5WYyKk1Iq+FloemiVVNbuDKrHat/VpdueZVh/ptz1qaOhHeuq58nAYPI6z4KcrE bKVBNEsBzY/Hoxa8NU14wm5DetO6qj0nMir3S50KpTEaEXATdERLfx+19KCBn0/nb0QH4P7MRzck Y2bdhy6/Ti+wb4RR/PX0pq49RglKjRFrdGWeNtLM/mA+4mVz1/u/yp5kuZEc119x1Om9iJoJS94P daCYlMVWbs5MLfYlw2WrqxRdZTu8zEzP1z+AzIUgQVW9Q3dZAJI7QYDE4rq8lZqaolbzBP1yeVml ruZskpN6e3Xibjv4feYdUPAlH58SpZZIbpB1enaSHm+HZTeM9sEx6Vyl3p5/oO927HXJUYemdeS+ Z1pPvIuVXxRrD6Ldzxe8nmN3vuHYxwJOIOXms8Ab3KtL+mSts7ZZqCorrOkt2Tjp9ur4fMLf+Ftk 5M63yUCl4d7sDMKxqoDfEzfAcAPH2bEn1AKEFU7xtmdyeXZODj1mVHr63E1mBz9gn2sK0G7qMgTU G93IReOG10cwruaycIPhIbQpCmLMYihVxWVn72r3IoybQjB9pR9gfJ0pULu5WzkSHwt+WHHA/RaB Qax1gh0MTg5S+MGdfAKMIhXHqyrVXBwgg/QTDSJQpmV9MXFT9ZiObCQF+CloELbQs3VDQdo9BC1g O/FHCWDUTsTHwjnPWcYarHHnTa+zoFC7EyOfpaWcoD1vLRv/w85QJvqhm2azh9DgmSO0i1xIUV5C IANCZyVdlz6hH5kHoX3eI9Jok/ebjdpnsFtBy3ACb4F0qTwkcakxkM7KuSlXHqKzMfG2QugBYcDp 9FKWKR9p2xCUFcduDAql8aDATpyPfbPKT71Z6TP7uCCtSJ6cDraogh2+1hhsqfGKHFIoWc2nujl6 +L5/Iakc+gMnbeeaFYVEgl7PNrvIeFJ3gw4rXCKu1HwsroGuumGtg3oL9TsxMTTOMd5NiKnCPQpO L1HJdJOduDGqCKIvfnFZ98WMwlt1065yXS40phnWieITeuAGB9K6URH/E0OQN6B2Mv3rjOexLllk M52T/OQFHBboPFtKjE8qIxhyHmWYJqSbil5f9WfVaVsp5DJyRtgQb7hmBv9HghHN4uIqAG7rCX3A sHDj3nrKZq+zeMPp/dJc/1cO0VkLRUulcUUtDI0LwwJTAVvjJrJCDYFluQcoMrkogQmIahtJ5Gep kH3+Cm/j77SimkW7hnZ3YTdKXTcCWBoXdd9SWBfHgmRbHhElMcEzcIfZ+igaLLWDmYfpsGVdyIoD PTeRIKLtHsLF+RVimIcR1sV/6MMTnpx7AdNdZBek0Goyi9uj+uPrm3HaGgXiLu9RC+ixGAfYZhrO oMSiR+4OCClyK5RJhUkLOCYPVF1oBqcQB9m5hKNn0sLRszuhysZmYWrO6yke6HxaMiSwPcfvI62y 44YEtEE2lCQHx72I/CvoA0aIBO6XF6a5flPhZG+nlznIXjV7tBCaWAFePwg+y8qTAx01aKybNtrG ovKkIoBXwoRqsP0n9YxxdNCBLFLbYNKamF/bY6/0Ho2TR1HdKWHWyRpOooKie78sboTqs3KN/lGI iw4TGnihCe0E9GSsZXH7G6SnDCkh1IvT4wtutKzkAwj4EZt26/B1ddqW0xXtrXVlY4oV2fnZKRoO Joo7z4pMlP1xRjc08BaM/n3iF2il86VS2UzAJGRZRNUJSOMrbhD4TXF+hZ1ZLRe5pr9dIHxqKLnY qIrIgUlDvd8zyR4lbqQPaDSxdsPfVgWcYwxi3XBWnoZoCWJS4yml9utMkKz14unx9Xn/6Nw05UlV kOAZFtCCJARSJYaicZtEsXNulr0CurSOXz593T897l4/f/9398e/nh7tX59ixWPlQ6LFiD2y7Y5z 3Sk4IS8HRdyRxs3PQeMmQCMrajJzI6KQRcPHM7I0vVaoMKQOp3FSssINu2VR2ba2tTjyJOh2ar6q yZFuZIWbeaSagZH13/lwpmY81byau2EyvAJj8DsjOIjlXg32k/X8HNiY348+Cg37SZ2vaxiY69KV cjHYfl12w0muC60LgimJu2/EyEpsNRWzDlCUhT8rkfW7ZLE5en+9fzC3raEeBgPCmpYgX2lImIwe FkmcMqCvG0e8GKBwpDDQstFsFcxVUW9aFPamL5XGPjPuz9l15URFG010PFwr2LfULgBXiXvXs+4c SuhpPDtnHy/XJYNEztxGG9ex76ghUk+XgYi+LaaRpwlDNqt0cu2aK9tWzSul7tSIHcruqi6R48Uj LJiiK3WtXTG6dzsPIa2Yr4KOIjzXRd3NPSiQbe57P/r0RJIig5mV3ioANbrfB/AnF3nBBQ+7G3Px QKe3o4WR867LhNxZoQfR9cXV1Km6A9aT02PqywVwDBrA3X0Aash+Fj4oB+0sgcuVzsKqNQnJBr9Q Ge9DFPTgVGckOSYCLA+mMazMCzL8nSvZ8FA8R+IYG0U9isz9nU/RXPAKQmVaXNRwAp1ESzoU17FL kcRNA8mDmpn8pXDye6A6T9x58mJoWPvo/Y/dkRWunNWyFvhc1agWBCHQ72v3LgRBRa1h5UhnJtQW 7+LnXiQUC2tnJp5mUXLiC+YibhFPcuZkIJlg8JRbHz9uTczVKkFJx2wVXLl1C1qobm5Jyy3IzzE9 ImYrDfsqR+/hXDSrStUulU1d7bYiiWaz1hYDYiEZPDGU0UsWq4J6KBsApq81qpdZK+jlywviFeC7 LzaiyvksQBbf93msaJ417Zq3dLI4zn7AFGZjaoxi5Kop5vVpy8unBtm6oh9KCgQgiejQZQx2CQqY nxT0DB4GHD7RFe4m+OcwgUg34hZaU6RpsXH74BCjMMxJtQ5JpmAQinLIECzvH77vnA0E0wdUXeBI ItxaRCMa/n18Xks4K3lvwK4Se33ztvt4fD76E7ZvsHuNT7T3uIWgZcRxzSDxronOqgGXGGwoK0Dd YZ3vbCjLhU6TSjkn7FJVuTtVnuhv/+kXxajqhX0a+AHmJEZWACU1KnNXQYVZy8eyet5jWAO/Iv+Y z+spWUo9pNskxwHcaIODQe9oBDrgMa8y8pA5f5FgCetVlonqEAUUtRVNw9+rWxI4U4x5BToaFob7 xft4R6yTLaxCGylHs5jpYPB6GGZaFLlUia2U04Z7yvSuCMv06h/BdZOE9QlsGBds1f/cjBBTbK3k inL8sSOrZqHyRkvREFFQghZC+24hoAVyT1ugFnmszEJmQi4xfA3epCU+ErUwF1rWDfUzNb+HDN1L jIQ6u8Ucb5Pj6elxSJbiydwvg6AcmIlDyFMXOe71Ab2QAwG33y3d5ek0XgfObhx7oHa/a/2QxNvh 9rWn5rt1sFCf3u3e79CTHv+61UGLP/347/OngCivC/qu0GEwVG688HlTCRmuLqttj4fQpqiWPEOV qlx4/KADjXIfU73UhMPr/pSjhv9mn+PRC4es2a4wOepaSE6CMsSrUgovpZfmmKSLDCSdERrJ4DLg 0b+whOMrlvjCEA7NijWg3uSxhtfZrLWiCPdxkQjCXYTHbQTXuwEIYlTF+8hfld6MGgA/nx5Nz1S5 27XUvc5LnfW8f3u+vDy7+sfkk4uG7ikjT5yeXNAPB8xFHHNBnA8I7pJ1k/RIppGCL90ITR4m1phL 95HNw0zizTyPRBShRNxrikdyGq092hc3XJGHuYq2+Ork/Nctvvr16F+dxEafhAai7bo49dul6wKX VctZJpNvJ9Oz2AQBKpghUUvN32C5tXImzi7e62IPPon1grPcdPFnfHnnPPiCBwdzO/QmtswGglO+ xInXrmWhL9vKr8ZAuRQHiMyERNlI5LQkBEsF+rfk4KAIr6qCwVQFCHUi91tgcLeVTlP2pbUnuRYq 5Sq8rpRrydWDNTRQ5AlXmc5XmhcTSJ+hqQeJmlW11PUi0uRVMydXdUnK59ld5RqXPHcxUbQbYi1D roBstI7dw8crGvQ+v6BzgqNa4snoVo+/Qbm+WaEDCKO59kKIqmoNckbe4BeVzq854bKpVkCT9JX0 mpy95RnhbuVtsgAlSFUi0IPG54PuAGuTTNXGhqKptOQnqqedR4oCgUZLc6WTweAuVFqyt3O9KD9W 7YZjSOsMJL77p0cMHvAZ//f4/O+nz3/f/7yHX/ePL/unz2/3f+6gwP3j5/3T++4bTsbnry9/frLz s9y9Pu1+HH2/f33cGRv1cZ666Os/n1//Pto/7dGLdf/fexrHQOPjJZrNLNu8cPPJGgQa44CEJode 0PyOlgKv5SmBEz+drbxHx9s+hHTxV9+orME6KIYrl9e/X96fjx6eX3dHz69H33c/XkzUCEIMIm7p iqUWKNJrQUIBueBpCFciYYEhab2UulyQrPYUEX6yEPWCBYakFUkrPsBYQkcd8hoebYmINX5ZliH1 0r3W70tA1SYkBa4nrplyO3j4QXdp6ijlLj2a3opZqmxOdE6OpuRqCzrRkH+d0lzPJ9PLbJUGiHyV 8sCwtaX5NwCbf5iFY64iJNM9/9mdYm3k3X71lx9ff+wf/vHX7u+jB7MRvr3ev3z/O1j/VS2CFiTh elNuVp0BxhImTIlKVhy4zqZMN4EnrtX07GxCYhdZc4mP9+/otvVw/757PFJPpmvoHvfv/fv3I/H2 9vywN6jk/v0+6KuUWTi/DEwu4KAS0+OySG/RW5rZ29e6nrge4H2H1I1eM71fCGCM635uZiYqzM/n R/dGuK97Fg60nM9CWBNuF8msXyVnzBCn1Sa+kAqmupJr17apmbLh1MV8G/Hy80V8YBOQfppVxhSL N5rrYEEs7t++x0YyE2GTFxxwy3VubSl7P8Pd23tYQyVPpsx0ITisZNsxcr9js1Qs1ZS32CMkBzgZ VNlMjhM3ZHm/vtnjIzoBWXLKwM6YZmcaVrVK8d94u6osmRB7026bLEgqxwE4PTvnwGcT5iBdiJMQ mDGwBkSRWREejJvSlmuFhf3Ld/IePux0RjpQdduE0sEsLTZzzQx2jwiSYfeTJzIFSkjIHqVAoTn2 Ud2E04fQcAgTphPzyJnUsT6Gs1WljWruL4Q6Y5MydkfWpmDHpIOPvbOz8PzzBV0ziTQ6dMJc/gYl kYeFDnZ5Gi6Y9C5c2eY6O4B2rw/WLxHE8OefR/nHz6+71z6QF9c8kde6lSUngSXVDK2t8hWP6ViS P6wWJ1hFzyXhDgJEBMA/dNOoSqG1Z3kbYFGiagV1VfZQv2jNQBaVcQcKbpRcJKzjdSg8DhSdvB1t p8qN9FfM8IK84TXOgTuIQxIi9rjt0p+5SsWP/dfXe1BiXp8/3vdPzOGD8X043mHglWSWIgYEsmy+ N6c/RMPi7OY9+Lkl4VGD2HW4hIGMRXO8BuH9iQMCp75TXyaHSA5VHz25xt4dENyQKHLOLDbcJlRr VHY3Os8jvkwO4ULP8/bi6ox3iXEI+wxArDGGQ1efhZvA+Z492U2LGzhQHD0iSqE4+W3EN7zZeEBX MytqxGpGRBqxVrGItwFn6/iU95JxiG8kd5VFCDBDGjURctA6u26U/BW/BcLORI/b24geMlQysynm akvyYpC1U2NeuMhIZWlxrWV7veU/dvC+5RKpf8qosYjpjfQLWRvhBk7036Xr9Ivfo+X0E5924WWv jVKZc9MsDz4jQ32bZQpv8sw1YHNburajI7JczdKOpl7NOrLx6WwkbMrMpWKq3J4dX7VSwQKYox2B Gi3jxnvOpawv0SprjXgsztJwz7VAeoFG2jW+SvhGdhZrwupAKSMc7dIwm6eydnHG4mQ0arBHGMau +9Oo0G8mXf3b/tuTdfR/+L57+Gv/9M1JxGlef92b14rY4YX4+sunTx7W3q84IxN8H1C05pQ4Pb46 HygV/JGI6pZpzHgBa4uDQ1IuU10Pt8m8udRvDERf+0znWLWxp5t/GUL2xaSAVOcYf9+YHlFLBmEM FZn5nmlQVGC+XEO33q8OdJhclrftvCoyz2CwJ8FcWKtG06B2sqgSHXHRqdCYJl9lM6iSdYTBNSPS sKZSasx77PrW1A2wxCFt0rB1ZSslCJ0ENDmnFKHaKlvdrFr6FdWn4efghkKZhcHAflazW+4NkBCc Mp+KaiOiAiNSzCIvOIBlI01LT9aTzjMcCCPhDYJ0LpWGK4NhTvKkyGjnOxRvcINQtH734Wh2hWIt VajurPzmQXlzIYRyJXv2QyPUMRui1Gz7eAshA+bot3cIdufTQtrtJZurwSKNj1jJfaYFO5kdVlQZ 8w1AmwVsp/h36Akt/Ua3M/lHAKNzO/a4nd1p9/rcwaR3mYggnAXY72HzgIP2087issme0yKjHsUj FF/aLiMoqDCGgq/cTe9/5uJm0vO7qdYCxNBKkbMbM1IDd1orGPNKOIffAqMmUL8oC0KDwZZwLIQn ZMQygQboIyA37bSIVOXEJcjgEIEOlKhCuu2r5MIUX9/m0hDNiypgjjyVdONxIBC12cCehyBa1tar b9sMBh/kpMp5qK6vUzv9DtfBTPJkeJIbl/GnBblDxt+sG2A/Oim1vxwWXVNkWrq2KTK9axvhxset blDDcyrPSk1sRBOdkd/onYj+O3BEumIQ+pyluvEGPC9am8NeE2sA2JeZ4HwEitkf4tqO/RD2yzvy /U5aHmo9FDtTNuV6c9b5BHdEkYx+OcOLZy97GejL6/7p/S8bMuvn7u1b+NYurQVgC8J/CpJDOrzo XUQpblZaNV9Oh8HtpMughIEC5N9ZgQKyqqpcuHbBdvXBfyCzzIrOG7IbpWjbh1u+/Y/dP973PztJ 682QPlj4a9jTeQVVGweGL5Pp5bH74F5pUMZqdB7N+JAdIjGXQUDj7H6FEVrQkB82r7vaui2lJAo/ aFSeicblST7GtKkt8vTWLwO2swQhfJXbD0QKgnl7fjrzVuRG5E3XvbIwHM91g3Dh7oJdwx7I0dGK fWZxG7BRYmmSXVrWMsq+vzsHZsbMvef+oV+pye7rx7dv+Davn97eXz8w/LXrSiZQGQVR3I0r4wAH uwB7T/fl+D+TsWsuXTTjTdfDOhj03njUs6wcsPgwbAgy9JxiJTmvJDSAYFqwEOb4gRlcXieEO+Jv Th/tGf5qVoscJM1cN6DitGT5GZzDHqXzxQxanHhW+COct/GxVS30nO+qxSd63d6pinPmswSrHHYR MM0ZtTbuqy9461CLVqBhRAvmB8EMLai3QIBCjE5pNNbfWot0WaC3iQp2eZc92TWIGQpzfGWQP4J6 irmbijxcVIg3xymvZeHXxSbnNXyj2Be6LnJPjR2LBgY2P7BMqyIRjYgZBlgaOMSUpC+1BHHoKKeE cyuIRYoxoXU5HkzJ0LDcn4oeV+G1DjGmoXhgZCirdG6PMaru+r8/yyZ+g61l0wpPPs5XXS5Q8DM0 Kgc1ZKFk0OB1FkLMizFauDGoahaOG4DLa1C2WFO3bomaFNvGqIpZHpar4yHAlWC2kdNhdE6bW5+2 cDRCZMd7cLZgcQIbHDdrkgz+GdSka9w+wZAvMOSW/3hv6I+K55e3z0eYmubjxR5Ci/unb667msBI ZejNRAR0AkaP1JXzrGCRuCSLVfPFlRiKeYPeoiu8sGhgvRT8vb5FtguMItOIesmM8OYGjm8QApKC iIiHe2XtJ+HEffzAY9blOGMbzRIMAggQbPco5cLMW5bbEq4aOvk4QEuluqCy9lILbVNGrvo/by/7 J7RXgd78/Hjf/WcHf+zeH/75z3/+r9vmjh+BmrVq1JZ9N+iWAlSGExCwY/udD642tfU+8WqyykRb p9D6Awyycwy275Idn+MPS+OCDKsBnXpjDHWzsc1kLmBqOSdfE6Xh/zGkfXnGSwf1IcMh/FEJ4WYb e649RjiFwwlO8Bo0Vlg19gYpHM2l5Z2RHfqXPWof79/vj/CMfcA7UmeDdkOt6aWF4VEd0GcHvDu7 RRoHaM0fJYbNg8iCh54sTGx4Ta1LD7aYNk5WMCZ5o20mEPvcL1ecEOBNbK9bwGllUnO2/kUkYn6x lJAEznZagINDzm6Uk4GJTScuvp9qUqe6qUO2MQZDJp2jYwG8zCoM1agqOLcDi6IpU3tYGP87EzKK 6RVeHebytincqDVFaVvrHNjmcBqUo8PY60qUC54muQWdFLiA79PGINuNbhZ4U1D79Vh0ZoQKIMA7 c48EXZ/NTCClUcecQmzDMIZy67XCFiwps8PXiDHzTwcE3TtvDD15XMFxBtGzC54cDIFTVKes1BsS +RTEtQw2CGhS0ZaT+vo7DL+ijtBxV+8VVK/HoAw0xkk3KDqc69GjnZtonj+QGeXd4/vCyqrAFzBO 7raynd9JjFhazOdMA+2Be6Bdi00qGoagQxd1DkK+CocVBebxS39Y+2UXrrU6B5EPtmQUMciGdEHY YmdwCGD0VDNAnuJBcCqm/PZokQOvFvgUZ7/znrp6Ktg5PZ516rCLyymCNoaZkNsc9rLZNPxZjuEX +0wesTpVt+t0/oeiQaPHzTLen7LVuBuQpfSqE6m5lMVRCSbbMh78Z1XVNBoRT2BfSCfTS44d/LK0 UIDpEY2Ac6v0TqSRQQUUw2i4NOZhul+/3OnntDVWnkszxJsx3CVRKYjkvAeOwGCrdSDIvNy/7t8e 2LOdCFokJEd/m+l/697aNru3dxTqUMKXz//avd5/c7LYmDiA4zDasIBdBEEfTEfcwtTW9IfFmROJ +iz0ohPe1hZVt7TJ9OeqQVsKlpAwZXNBNxTAvWxaBRHUQlmsu1Es3Vi5cJyaowCaiDPZGUCO8vYy YeO2maVj3u5rctYYeKZzvCAoPTBDmei1+9Iw66Vjs/J9eWuGT0w+0H2noijyMhWs2/6ZIxIp0W3k Qm3RnzziS2Y2wIHLGdt1S2ZdzWp/XJqqliUJSGRNRgDRFLydmiGwdg7ROqXI515VM91kwbysVm4k SwPa9m92tML+AiJWZYUv4Y1/BWkHkbfZMjhgGg6H0zlGsmy4VzGboEpXGehMyh/FPvJNv5Z0A3sn TfzdXam6WKEMze1nWwiLsoYqLMKxIgnWmcwSJHC+ZOcTWltHlZDOyIPWTod3BdxWcN79dkOqTIIE 40/88HBGV6MxftFhHVAKwmOVGGdCvA0ltxuHGDDRgDNd17hHkkKuMkVEYKshz7Tlg1zx/avc/wG4 K/beolgCAA== --===============0621243856458565304==--