From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pf0-f197.google.com (mail-pf0-f197.google.com [209.85.192.197]) by kanga.kvack.org (Postfix) with ESMTP id 8C4F56B0033 for ; Mon, 18 Sep 2017 13:51:18 -0400 (EDT) Received: by mail-pf0-f197.google.com with SMTP id q76so1554184pfq.5 for ; Mon, 18 Sep 2017 10:51:18 -0700 (PDT) Received: from mga01.intel.com (mga01.intel.com. [192.55.52.88]) by mx.google.com with ESMTPS id a195si12770pfa.61.2017.09.18.10.51.16 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 18 Sep 2017 10:51:16 -0700 (PDT) Date: Tue, 19 Sep 2017 01:50:41 +0800 From: kbuild test robot Subject: include/linux/string.h:209: error: '______f' is static but declared in inline function 'strcpy' which is not static Message-ID: <201709190140.6hewHECa%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="8t9RHnE3ZwKMSgU+" Content-Disposition: inline Sender: owner-linux-mm@kvack.org List-ID: To: Daniel Micay Cc: kbuild-all@01.org, linux-kernel@vger.kernel.org, Kees Cook , Arnd Bergmann , Andrew Morton , Linux Memory Management List --8t9RHnE3ZwKMSgU+ Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Daniel, FYI, the error/warning still remains. tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master head: ebb2c2437d8008d46796902ff390653822af6cc4 commit: 6974f0c4555e285ab217cee58b6e874f776ff409 include/linux/string.h: add the option of fortified string.h functions date: 10 weeks ago config: x86_64-randconfig-v0-09182355 (attached as .config) compiler: gcc-4.4 (Debian 4.4.7-8) 4.4.7 reproduce: git checkout 6974f0c4555e285ab217cee58b6e874f776ff409 # save the attached .config to linux build tree make ARCH=x86_64 All errors (new ones prefixed by >>): cc1: warnings being treated as errors In file included from include/linux/bitmap.h:8, from include/linux/cpumask.h:11, from arch/x86/include/asm/cpumask.h:4, from arch/x86/include/asm/msr.h:10, from arch/x86/include/asm/processor.h:20, from arch/x86/include/asm/cpufeature.h:4, from arch/x86/include/asm/thread_info.h:52, from include/linux/thread_info.h:37, from arch/x86/include/asm/preempt.h:6, from include/linux/preempt.h:80, from include/linux/spinlock.h:50, from include/linux/mmzone.h:7, from include/linux/gfp.h:5, from include/linux/slab.h:14, from include/linux/resource_ext.h:19, from include/linux/acpi.h:26, from drivers/gpu/drm/i915/i915_drv.c:30: include/linux/string.h: In function 'strcpy': >> include/linux/string.h:209: error: '______f' is static but declared in inline function 'strcpy' which is not static include/linux/string.h:211: error: '______f' is static but declared in inline function 'strcpy' which is not static include/linux/string.h: In function 'strncpy': >> include/linux/string.h:219: error: '______f' is static but declared in inline function 'strncpy' which is not static include/linux/string.h:221: error: '______f' is static but declared in inline function 'strncpy' which is not static include/linux/string.h: In function 'strcat': >> include/linux/string.h:229: error: '______f' is static but declared in inline function 'strcat' which is not static include/linux/string.h:231: error: '______f' is static but declared in inline function 'strcat' which is not static include/linux/string.h: In function 'strlen': >> include/linux/string.h:240: error: '______f' is static but declared in inline function 'strlen' which is not static include/linux/string.h:243: error: '______f' is static but declared in inline function 'strlen' which is not static include/linux/string.h: In function 'strnlen': >> include/linux/string.h:253: error: '______f' is static but declared in inline function 'strnlen' which is not static include/linux/string.h: In function 'strlcpy': >> include/linux/string.h:265: error: '______f' is static but declared in inline function 'strlcpy' which is not static include/linux/string.h:268: error: '______f' is static but declared in inline function 'strlcpy' which is not static include/linux/string.h:270: error: '______f' is static but declared in inline function 'strlcpy' which is not static include/linux/string.h:272: error: '______f' is static but declared in inline function 'strlcpy' which is not static include/linux/string.h: In function 'strncat': >> include/linux/string.h:286: error: '______f' is static but declared in inline function 'strncat' which is not static include/linux/string.h:290: error: '______f' is static but declared in inline function 'strncat' which is not static include/linux/string.h: In function 'memset': >> include/linux/string.h:300: error: '______f' is static but declared in inline function 'memset' which is not static include/linux/string.h:302: error: '______f' is static but declared in inline function 'memset' which is not static include/linux/string.h: In function 'memcpy': >> include/linux/string.h:311: error: '______f' is static but declared in inline function 'memcpy' which is not static include/linux/string.h:312: error: '______f' is static but declared in inline function 'memcpy' which is not static include/linux/string.h:314: error: '______f' is static but declared in inline function 'memcpy' which is not static include/linux/string.h:317: error: '______f' is static but declared in inline function 'memcpy' which is not static include/linux/string.h: In function 'memmove': >> include/linux/string.h:326: error: '______f' is static but declared in inline function 'memmove' which is not static include/linux/string.h:327: error: '______f' is static but declared in inline function 'memmove' which is not static include/linux/string.h:329: error: '______f' is static but declared in inline function 'memmove' which is not static include/linux/string.h:332: error: '______f' is static but declared in inline function 'memmove' which is not static include/linux/string.h: In function 'memscan': >> include/linux/string.h:341: error: '______f' is static but declared in inline function 'memscan' which is not static include/linux/string.h:343: error: '______f' is static but declared in inline function 'memscan' which is not static include/linux/string.h: In function 'memcmp': >> include/linux/string.h:352: error: '______f' is static but declared in inline function 'memcmp' which is not static include/linux/string.h:353: error: '______f' is static but declared in inline function 'memcmp' which is not static include/linux/string.h:355: error: '______f' is static but declared in inline function 'memcmp' which is not static include/linux/string.h:358: error: '______f' is static but declared in inline function 'memcmp' which is not static include/linux/string.h: In function 'memchr': >> include/linux/string.h:366: error: '______f' is static but declared in inline function 'memchr' which is not static include/linux/string.h:368: error: '______f' is static but declared in inline function 'memchr' which is not static include/linux/string.h: In function 'memchr_inv': >> include/linux/string.h:377: error: '______f' is static but declared in inline function 'memchr_inv' which is not static include/linux/string.h:379: error: '______f' is static but declared in inline function 'memchr_inv' which is not static include/linux/string.h: In function 'kmemdup': >> include/linux/string.h:388: error: '______f' is static but declared in inline function 'kmemdup' which is not static include/linux/string.h:390: error: '______f' is static but declared in inline function 'kmemdup' which is not static vim +209 include/linux/string.h 203 204 #if !defined(__NO_FORTIFY) && defined(__OPTIMIZE__) && defined(CONFIG_FORTIFY_SOURCE) 205 __FORTIFY_INLINE char *strcpy(char *p, const char *q) 206 { 207 size_t p_size = __builtin_object_size(p, 0); 208 size_t q_size = __builtin_object_size(q, 0); > 209 if (p_size == (size_t)-1 && q_size == (size_t)-1) 210 return __builtin_strcpy(p, q); 211 if (strscpy(p, q, p_size < q_size ? p_size : q_size) < 0) 212 fortify_panic(__func__); 213 return p; 214 } 215 216 __FORTIFY_INLINE char *strncpy(char *p, const char *q, __kernel_size_t size) 217 { 218 size_t p_size = __builtin_object_size(p, 0); > 219 if (__builtin_constant_p(size) && p_size < size) 220 __write_overflow(); 221 if (p_size < size) 222 fortify_panic(__func__); 223 return __builtin_strncpy(p, q, size); 224 } 225 226 __FORTIFY_INLINE char *strcat(char *p, const char *q) 227 { 228 size_t p_size = __builtin_object_size(p, 0); > 229 if (p_size == (size_t)-1) 230 return __builtin_strcat(p, q); 231 if (strlcat(p, q, p_size) >= p_size) 232 fortify_panic(__func__); 233 return p; 234 } 235 236 __FORTIFY_INLINE __kernel_size_t strlen(const char *p) 237 { 238 __kernel_size_t ret; 239 size_t p_size = __builtin_object_size(p, 0); > 240 if (p_size == (size_t)-1) 241 return __builtin_strlen(p); 242 ret = strnlen(p, p_size); > 243 if (p_size <= ret) 244 fortify_panic(__func__); 245 return ret; 246 } 247 248 extern __kernel_size_t __real_strnlen(const char *, __kernel_size_t) __RENAME(strnlen); 249 __FORTIFY_INLINE __kernel_size_t strnlen(const char *p, __kernel_size_t maxlen) 250 { 251 size_t p_size = __builtin_object_size(p, 0); 252 __kernel_size_t ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size); > 253 if (p_size <= ret && maxlen != ret) 254 fortify_panic(__func__); 255 return ret; 256 } 257 258 /* defined after fortified strlen to reuse it */ 259 extern size_t __real_strlcpy(char *, const char *, size_t) __RENAME(strlcpy); 260 __FORTIFY_INLINE size_t strlcpy(char *p, const char *q, size_t size) 261 { 262 size_t ret; 263 size_t p_size = __builtin_object_size(p, 0); 264 size_t q_size = __builtin_object_size(q, 0); > 265 if (p_size == (size_t)-1 && q_size == (size_t)-1) 266 return __real_strlcpy(p, q, size); 267 ret = strlen(q); 268 if (size) { 269 size_t len = (ret >= size) ? size - 1 : ret; > 270 if (__builtin_constant_p(len) && len >= p_size) 271 __write_overflow(); 272 if (len >= p_size) 273 fortify_panic(__func__); 274 __builtin_memcpy(p, q, len); 275 p[len] = '\0'; 276 } 277 return ret; 278 } 279 280 /* defined after fortified strlen and strnlen to reuse them */ 281 __FORTIFY_INLINE char *strncat(char *p, const char *q, __kernel_size_t count) 282 { 283 size_t p_len, copy_len; 284 size_t p_size = __builtin_object_size(p, 0); 285 size_t q_size = __builtin_object_size(q, 0); > 286 if (p_size == (size_t)-1 && q_size == (size_t)-1) 287 return __builtin_strncat(p, q, count); 288 p_len = strlen(p); 289 copy_len = strnlen(q, count); 290 if (p_size < p_len + copy_len + 1) 291 fortify_panic(__func__); 292 __builtin_memcpy(p + p_len, q, copy_len); 293 p[p_len + copy_len] = '\0'; 294 return p; 295 } 296 297 __FORTIFY_INLINE void *memset(void *p, int c, __kernel_size_t size) 298 { 299 size_t p_size = __builtin_object_size(p, 0); > 300 if (__builtin_constant_p(size) && p_size < size) 301 __write_overflow(); 302 if (p_size < size) 303 fortify_panic(__func__); 304 return __builtin_memset(p, c, size); 305 } 306 307 __FORTIFY_INLINE void *memcpy(void *p, const void *q, __kernel_size_t size) 308 { 309 size_t p_size = __builtin_object_size(p, 0); 310 size_t q_size = __builtin_object_size(q, 0); > 311 if (__builtin_constant_p(size)) { > 312 if (p_size < size) 313 __write_overflow(); 314 if (q_size < size) 315 __read_overflow2(); 316 } 317 if (p_size < size || q_size < size) 318 fortify_panic(__func__); 319 return __builtin_memcpy(p, q, size); 320 } 321 322 __FORTIFY_INLINE void *memmove(void *p, const void *q, __kernel_size_t size) 323 { 324 size_t p_size = __builtin_object_size(p, 0); 325 size_t q_size = __builtin_object_size(q, 0); > 326 if (__builtin_constant_p(size)) { 327 if (p_size < size) 328 __write_overflow(); 329 if (q_size < size) 330 __read_overflow2(); 331 } 332 if (p_size < size || q_size < size) 333 fortify_panic(__func__); 334 return __builtin_memmove(p, q, size); 335 } 336 337 extern void *__real_memscan(void *, int, __kernel_size_t) __RENAME(memscan); 338 __FORTIFY_INLINE void *memscan(void *p, int c, __kernel_size_t size) 339 { 340 size_t p_size = __builtin_object_size(p, 0); > 341 if (__builtin_constant_p(size) && p_size < size) 342 __read_overflow(); 343 if (p_size < size) 344 fortify_panic(__func__); 345 return __real_memscan(p, c, size); 346 } 347 348 __FORTIFY_INLINE int memcmp(const void *p, const void *q, __kernel_size_t size) 349 { 350 size_t p_size = __builtin_object_size(p, 0); 351 size_t q_size = __builtin_object_size(q, 0); > 352 if (__builtin_constant_p(size)) { 353 if (p_size < size) 354 __read_overflow(); > 355 if (q_size < size) 356 __read_overflow2(); 357 } 358 if (p_size < size || q_size < size) 359 fortify_panic(__func__); 360 return __builtin_memcmp(p, q, size); 361 } 362 363 __FORTIFY_INLINE void *memchr(const void *p, int c, __kernel_size_t size) 364 { 365 size_t p_size = __builtin_object_size(p, 0); > 366 if (__builtin_constant_p(size) && p_size < size) 367 __read_overflow(); 368 if (p_size < size) 369 fortify_panic(__func__); 370 return __builtin_memchr(p, c, size); 371 } 372 373 void *__real_memchr_inv(const void *s, int c, size_t n) __RENAME(memchr_inv); 374 __FORTIFY_INLINE void *memchr_inv(const void *p, int c, size_t size) 375 { 376 size_t p_size = __builtin_object_size(p, 0); > 377 if (__builtin_constant_p(size) && p_size < size) 378 __read_overflow(); 379 if (p_size < size) 380 fortify_panic(__func__); 381 return __real_memchr_inv(p, c, size); 382 } 383 384 extern void *__real_kmemdup(const void *src, size_t len, gfp_t gfp) __RENAME(kmemdup); 385 __FORTIFY_INLINE void *kmemdup(const void *p, size_t size, gfp_t gfp) 386 { 387 size_t p_size = __builtin_object_size(p, 0); > 388 if (__builtin_constant_p(size) && p_size < size) 389 __read_overflow(); 390 if (p_size < size) 391 fortify_panic(__func__); 392 return __real_kmemdup(p, size, gfp); 393 } 394 #endif 395 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --8t9RHnE3ZwKMSgU+ Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICIMFwFkAAy5jb25maWcAjFzNd9u2st/3r9BJ3+LeRRvbcXPT844XEAlKiAiCBUDZ8obH sZXUp46cZ8lt89+/GYAUAXCo3i7aCjMA8TEfvxkM/OMPP87Y6+H5693h8f7u6en77Mt2t325 O2wfZp8fn7b/O8vVrFJ2xnNhfwbm8nH3+vfbvz+8b99fzi5/Pr/4+Wy22r7stk+z7Hn3+fHL K3R+fN798OMPmaoKsQC+ubBX3/ufN65r9Hv4ISpjdZNZoao255nKuR6IqrF1Y9tCacns1Zvt 0+f3lz/BTH56f/mm52E6W0LPwv+8enP3cv87zvbtvZvcvpt5+7D97FuOPUuVrXJet6apa6WD CRvLspXVLONjmpTN8MN9W0pWt7rKW1i0aaWori4+nGJgN1fvLmiGTMma2WGgiXEiNhju/H3P V3Get7lkLbLCMiwfJutoZuHIJa8WdjnQFrziWmTtvFmQja3mJbNizdtaicpybcZsy2suFstg q/S14bK9yZYLluctKxdKC7uU454ZK8Vcw2ThHEu2SfZ3yUyb1Y2bwg1FY9mSt6Wo4LTEbbDg JYP5Gm6buq25dmMwzVmyIz2Jyzn8KoQ2ts2WTbWa4KvZgtNsfkZiznXFnDzXyhgxL3nCYhpT czjGCfI1q2y7bOArtYQDW8KcKQ63eax0nLacDyy3CnYCDvndRdCtAWV2nUdzcfJtWlVbIWH7 ctBI2EtRLaY4c44CgdvASlChVM9bI+uprk2t1ZwHslOIm5YzXW7gdyt5IBv1wjLYG5DUNS/N 1WXfftR0OHEDNuHt0+Ont1+fH16ftvu3/9NUTHKUFM4Mf/tzovBC/9ZeKx0c2bwRZQ4L5y2/ 8d8zkbbbJQgMbkmh4F+tZQY7g6X7cbZwVvNptt8eXr8Ntg+2zra8WsPKcYoSDOGg7ZmGI3fq K+DY37yBYXqKb2stN3b2uJ/tng84cmCqWLkGtQOxwn5EM5yxVYnwr0AUedkubkVNU+ZAuaBJ 5a1kNOXmdqrHxPfLW7T+x7UGswqXmtLd3E4x4AxP0W9uiZ2M5joe8ZLoAiLHmhJ0UhmL8nX1 5l+7593238djMBuzFnUWDgi6DaItf2t4w4khvSCAwCu9aZkFfxMoZrFkVR6ahcZwMJDh8E6f iXHdrjudcxwwMRCQshdZkP/Z/vXT/vv+sP06iGxvhlE9nIKOLTSSzFJd0xReFDxz3oEVBbge sxrzocUDo4L89CBSLLQzmzQ5W4YyjC25kkxUVBsYYTCNsAsbkuoMWEwBhJGB6fPqHtk+UzNt eDft4/6HM3PDFYY6ZUQYRjUwNthsmy1zlVrVkCVnNtC4kLIGB5mjfywZup1NVhJn5MzYejjy 1MnieGBMK0v47oDYzrVieQYfOs0G+KRl+ceG5JMKjX3u8YeTPfv4dfuyp8TPimzVgs8C+QqG qlS7vEWzKJ1EHHceGsETC5WLjNhx30t47Tn28a1FU5ZTXQK7BRgGHIhx2+lgjps+eP639m7/ x+wA65jd7R5m+8PdYT+7u79/ft0dHndfkgU5tJFlqqmsl6fjbNZC24SMG0dMDaXLnSo90Nzk qK8ZB1MCHJa0heiyEAhG8umWpLNmZojj0Bw8aBagXPgB7hF2PYTIEYfrkzThd8fjwFTKcjjW gOLhKV9kc+fYI1rBKggFrt5fjhsBILAiQMCeAlrSn+txJ9xHVDbHvSc220EBwNTVRQBpxKoL K0YtbueH5lLhCAUYSVHYq/P/hO141gDTQ/oREdQa4PSqNazg6RjvIqPeQJzkAQqg3dxr4hTM qhqA+HNWsiob4zgHHudojWCYpsJAAeBjW5SNmQSHMMfziw+BbVpo1dSBHXGg2MloGL6Bf8sW aS+/gPBgCiZ0G9CIwwGNmejcDVqL3JDy39F1PoEVOnoBEnzLNc1SgwO2pIH3nXO+FhknZgU9 JxWznzjXxamRvas69jIKbUtHBH9BdV3ybOXCNLRjVunYFgKAAZ8GRoOclZcuhJLuGzTPxhQY BtSaZ2DhyfOK47h5ucJNcuBY52HwD7+ZhNG8owugrc4T2AoNPVodVDqfBoFAiwFg3EtRs85T qJplx8AIMYI7LUxGVBmJ6hLuOBwFc1XBilUeBkBet0V+HqRE0IXbEkxuxmsXR7pURNKnzky9 gglBWI4zCva6LoYfqdlOviQB1goQbh2JGMSTiOHaDkqckIFTHB4Bey9K4XDoZzYy2Iq+pY3g y9A6N6psAAPBikCvCI45xHzHREVgm5yJTX+3lRRhHBjYKV4WYMtitUm2m1yx+/4Eyihg5kHy gtcqXKQRi4qVRaAZbt/CBoe6isj0wUlTJ9CPuYziaSaC4IzlawFz7TqbcFCUBhfuFJRe15lo f2uEXgXnBp+ZM61FaPldMiXneSq0MHabYtA6Oz+77HFWl1isty+fn1++3u3utzP+53YHSIsB 5soQawGMHNBKPOJxFV2OAomwoHYtXaqCPLW19P1790Xa+S7h5lIHgw6UbE4rR9nMqRMpVZCm wd6wd3rB+wAzGntjLJfOxLcQ4ItCZC44olVNq0KU4OqJjzrb4bxBanWU7xZoSt+CuuElcKB9 bGQN4cecl9E0AVkC3l/xDRgD0Js0fTGIlc/8kDQ3G5czBtUHTUAHlCGqnQpwId4UmcAza6q4 RwJg8OwR1wFyBrR8zdIsiAAtRwAEk7MJaZWmqnyr5pYkgN2nO/hWiG/agjLjkRUaonfHulRq lRAxdwu/rVg0qiHiOAOHhNFPF8km24HZUrBeVhSb3uGOGQDqdIkJAjiC298AgsBo03kIl7pP 5qj5Aqx1lfs0encwLavThWYltTrgSwN0R1teg/px5oFNQpPiBiRgIBs3h9TJgmGDdtvoCsIA 2IPIYKXmiTiYJdM5om4HyyzPbIcHqEGI7/fGSHf7kjcyFUe3zZGixYfj5cUHC5msMbOe7qlv 9YnBCVqumomkc2fmRJ21PuvRZxwJXlXmAT+1EMMzZGjBotjRVi8AK9VlsxBVZLeD5inlBw63 gaiz7hASvBYTaZQW84A4VPzkKHieTckmwoMRN6iFoo3xEpMmsDkAUFL58FsrHIuXkEIjVk9P EbSf31hnIVZRdOfIE8mF1O6RiQXKClWY/+LdhQRGef8tX1s3qff3UowXG+CPSdk3qrBtDksI bI9UeVOCBUVbjsgMAR6xHH4D7gMBNmYqcfsI0+a6g2VScnxPNL6pSxjcB0izGvcaLv+IcYOb u6lBQhZiqI7s2BFwjuWj3vTXFrZMqV6wunRipNmd6S6FTzIcb0Cj3NtwiswsqYSVYeBvE2OP lgIAbnfr9S7IB/ildHSWdRMK427M4gzeviCzrMOs1t2tZ3j4UduQP0d25aIrVvbZf319Qyr4 FHOP24g5Dd7Uglu2QacAAE6T0u5eBzqeIY7Fq7AG9yWJOfz9VKbWP326228fZn94UP3t5fnz 45NPVQYWV627OZxah2Pr4aEP0GKx6BGIRyhLjsaATuRIDIVCuXVxk0GIfnU+jNrpPTFGbxFc 1rEEkNTUUViETppai6nOg0i4cvec8OEaDG5TncqnMasQ8mgZ3H+4VfjOYHXUdRW6OH/zPUHE L03RjqjVXRzljs3dAwws05S0s76mu47au+RXH4PVL8/32/3++WV2+P7NJ7s/b+8Ory/bIPDq b5kDeQ7xDN4FF5wB2uI+5ZSQMEPb0zFoiFAActxcgBGhUvxIlLXDJxFyADNSiNgqHYlYsgAq lkOAQdJxTHCqYJ7wov9UjI+cfrSyNnQ4gyxMDuN06UHKXCpTtHIe2Mq+hUj8ucQcyKH1uKAv xKAM4gawJgT4gEQWDQ9z6bBrDBHCuCXF3Mf2UM6Ok+kEyUsyhIDUMYWgA3609Tr9nUgMtIFn PosEwfEt15L+QPvL+cViHg9hvB8b5T3d8C4rQDqR1VoeN2u4FV7LU32OezQJpY4cSboevNpc KesTNIPFW30gBUrWhk5dSMxS0VfkEm0WMefjDV2YQeuFWmNysqun8ZcQ70OW8nyaZk1SCNJF G0ndF94MruMWKSohG+m8fQGhZbkJ7nmQwZ1AZktpAkPZ3Xsh2OYlD2NQHAcst9fScTNoZoox sDkDd8UaUptqbtNkSB4GhwsGByxUVBgG0Rc0b47Nw/dCQssrRFsAHDcnsIS5Fioq8PF9l7ys o8sWdhPpU+XKlQBDnv96kZoRI8kPOZoMDrJvwZxpVC9Rg8eQtXWRE6UZHXmtSlAJ5lIJad8T 3ZwixVLiAlrElYmYCdU3RvZXc60wV4xZ+LlWK1B+VDiMDqaNtoyNtPeFQSLy6/Pu8fD8Et31 hikD7xeaqssdT3JoVkf4acyRudI9aocCVudj1HWcvF/LD+8nnOb5+1FVJjd1IW5SHe1rCFou mzIJE8SHwIwBKAI1BJsRWbG+0a+Fwm9HDq+Mo2aMCJw9KqKEmTuj0Ag4g1I3Ig3I6uUGtifP dWvTWlRfLYp5JpLs7I3QYFDaxRzD2Mjt4b3qFEj2dSJg0TulTrHkkTwkeyO6s2J9RRAg3FH6 By1eu0LZajEBEBxJWfIFKEcHCDC6a/jV2d8P27uHs+Cfo1Kf+tQwT8mqhlGUNPnmxwHdNTzU 2mBDbgCpS06R1vAvDNDSPRs4XOK+9ROqW6sW3C6T+6p0tKkYES8qYj8cNbfO+40zE73LXDRp XWMuQE90Hg4cB0Wdk/f1gzg87av9Di6VxdQXZZjrEmBfbd0snVG/jObhd69nQ7Ng43V2X5jj Zoba3DX4SDyLNZ1qI2q0Tuiax0YKMwLBELIh0q8rE4hVX2/nJMOXGeX66vLs1yPimEhMDUUv VEKKlddsQ+E4klv6O7LkxH0O3C7rNr5NIFqSQV2JhINPwRaXnFV92wARJi60UZCGBBmxjtta qUBhb+dhBu72XQFmNfzOrRnfiiUo0ZXm9rckU9ExHBfXGlGFuw3wtSB4sx9+zF1KOEqfuDyV bfDBZV9VMfg+h9awmCnxAVjx0M4heMJ7W93UsYgiC2oionHZ68LA6LvH7GjM9BqzC9eIRocz sJrCiG7iPrMYj2OifRuCRwDHKWTpCL01dblknB3erZHywAtB3z76vDt91Xbbnp+dTZEufpkk vYt7RcOdBQbz9uo8dDUOPy41VsRFgRW/4XRI4yh4ZUCbykwzs3RXJxQ4AlMkECaCiECMe/b3 eef4gowZ4khXR3Wqv7tThP4Xkd/s7HMXOg3ppqNkBQz0PvpY8h/ZurzoOjeKpKO7zzYDTKtc wQNVNZ4wejwXGZvRWAmgD6xS7tJlsFwS06kcbxXL3LajClTnCkuYYo1VZ4kZ6XxX7AOPmajn v7YvM0Dfd1+2X7e7g8tFsawWs+dv+ORoH2YyuwQzJabdmwyMbctyzqLkVw1WteS8Hrd0+YkB p0tXGOVo9D28BAex4i5dQsmXjL4xSvHg+Pkaa4tyTyTH6OaW5mtkWiXUt7TaZlGrv3c9fvX6 Nx9FBHn2E3ntLMzs469egpxSmSEdG56xxHdBXZ4eu9R5lgzSlTv4ibjgxwRPr4ZMfNbfDi8m avX8+ACVC+NHm1gEmIJ1q9bguETOw5c48Uhgi6bLux0HS5cyZxZQ+CZtbayNLlKxcQ3fVklb warxiicS2khzaRPN4RCj6od+G3yOJEuegiVkEb026Iats9Y/OiD7jOYoaimm5jhhOZNZsMVC gyzRl7aOF5G/ZOVojKwxVoFCmfzkXYwfw5mbpgYgm6eLTmmE3J0QukxghQ+ZCwX3juoYJ5H8 1FVlmahG7f2WCZWmN7y+zGlM4PvGJZnkXkkIo9QJNsBzDdohLHq4BhTbqqqkMOeg1Kzmo1KW vr2rpog/gQTaTda2GCtvYCYF1lmCrEzVQ/U7C/9PKq4pxNVQ1z8rXrb/97rd3X+f7e/vnqL0 Tq9dcR7R6dtCrfHlDiYg7QQ5LXM/ElEd0yykI/ShD/b+h1pTsgtuGmbA/3FwLERxZcBTFc/j LqrKIQyoaKEhewANYfQInpzu5UBjYwVdVhpt8H+5Rf+8NZNbQjH2GzF56sOqJz9GLvIokZ9T iZw9vDz+GRU+DiFD3Rv3KJyoM5fkxw9O31J1DuQkE4AqnoN39jlyLSoalLpvXvqLDhlbFres /e93L9sHCrfFHwGfQ26JeHjaxnqZvvLp29z+lizPSecfcUlexR4JXQU+RDEDX6aaupywqP4A kG005/nrvl/s7F/gG2bbw/3P/w4Sx1lgLdF3+LRjhAehVUr/Y6IWN7plc6O4J24mbsyq+cVZ yX3lbkTiiLCi/Aw2stAdYQPgIJ0lU0Mu2ICPfOJ9g2MxNXUJ5Yasw4yga8nr0Tfa2k4M4OtM 4rxTvHOG9i5ulyZdOVK1f9jchyaI+Sd5jSVLfd3FZSbwzUOhsWKrilIvS3cTMbEwZpPjQ5Uq uXs4jG3pQoVaT4xU60TGambCZLkbPC3p7ZEHymwq1Pl2//hldw2aPENy9gz/Y16/fXt+gW3p QjZo//15f5jdP+8OL89PTxDADcbryMJ3D9+eH3eH0BDgdGCjXB57fBEDnfZ/PR7uf6dHDs/k Gu/MINS0PHzK5WuToqQUNHU1pxRulHlbzcPdwmRvvPsyExPPioAVvkYs46f7u5eH2aeXx4cv YT3FBi8gh4+5n626SFu0yNQynINvtrSsd0RlIAKeeCUDa88F9RjGmeWNKeY9VOJ/b+9fD3ef nrbu74TM3L3YYT97O+NfX5/uervedZ+LqpAWS+6SlLIlSfAjfXLhrjow1XNEB1i/t+SAzcki /W5Yk2lRR9bAY1HVUNC86yRFeH+NX47LcwV7d0Feh2E7Dp2635t3F5Tz8RsQ/mUG3zTaI7y4 bN5f+lSUjC9W/GvzUU9/V752Eq3Cx3mVA6juDKvt4a/nlz8QURCeGMDPilO71FQiylfib3BY jLah8D3MWk54TE67C2jHP82A2UvJ9Gpy4NoCECkZxOsF/YV+oHq5cREXoCNZJ/nmkNmXJ9Nx hJ146KNFvqAR7bpkVfvh7OKcBlQ5z6Y2oCwzupRD1BNliZaV9D7dXPxCf4LV9IOVeqmmpiU4 57ieXy4nj2T0aHNYbkZ/L6+wRN8o/NsV9A7D1jO8+FnTu4zPIJMnmeGUSlGtpuVT1uXEQxRD IUYd6pIu3Fvr8Mr0po6cSvc408mqFjRyCHi8LFNZS6RqfDVsNm38XGz+Wxlpd1uU6rr7YyOx os8O2/0hqfhcMqlZPjUzRofUQue0A5nTYmMsoCjpnxFQm3ot8I+0mHjnigVK2jktu2I+IvpV 9b122+3DfnZ4nn3azrY79FMP6KNmkmWOYfBNfQvG4a6U2T3Pdq81g8uCawGttNMsVmLi1SOe xq90djhjoqD7FPRdSG3Ack1chOB3REHTymvbVEk976B6+Ack8MqRpIJcQphXTugHfhQ8DGoX dQXANq76tONIckEcXyt+HAQ03/75eL+d5TE0dH9U5/G+a56pbwmqaPxTvbT2KWoGobPL4CUx zMfKukjeB/q2VmKpEZUishDgs9I/DOnPQ/vPFEJLlxNzfzJgoBegg4pFf8DsyCqqrsg6gDw3 VrMjRzDh4zj+udBxscfZkwxt0d1t0M6iRBOB8KAHNyduqHIt1qTWdmS+1jzZTmzHOt6uL1h3 qSaSPoBfghJVWgyHKsXuGpgCfCEXBmnJ367RfBHdvvrfrQj/vkPXJmX4OrZnDP9SDYIq96e4 cvwTDUVcDAinyKuMH29gjgmAByfkEcaC/1RTL5OkjcIL+Il5WFe4BoZ0wt0hV385N+IKeJj+ j6f3E2z2oGHS/+Us97rWvtzt9h7Iz8q771FchSOoCFViC44nEBFjlSAzdqgh10y+1Uq+LZ7u 9hCx/f74bRyruZkXIl3yRw4oyZ3lxEoWGFzHZ90NhYChe6lh0mGR/P+MXUtz4ziS/is6bcwc aocP8aFDH0iIklgmSLZAWXRdFB6Xe9cxrnJFlXtn5t8vEgBJPBL0HLrayi9BJN4JIDPRdmCk 4a9GzlLyYf0wVDeb0WJrNDZXjGPV0WrQL4EAkS47XDO51vvhdAtX0WgV3dqls3CPITEiBGYt iPDFkVvKOkRoGJ8jraD6ZeyGtaoXh26GBdzc+pSvbs4QAoRP55jl3gTDQaz5Od5/LUJnEYpS 2buJ/k4ff/zQzmmF4iF6/eMT+FJYnb6DdX2EOoadidNVwRCBrvRTVpLbcRw9BTJOFsV46cFK FmyoDLI8vLwH90cLAc8FpwIauLyfPiPKzJ5f//gEhzGPL9+5rsWZ1ISnDXWzXJQkSegRmzVO lv1JkswOPOw51T2aevn1j0/d908EKt1RLowv7DtyjD1StOC4XBFi5zrRb4xiBlMTiym/SFTq Jg/GpxyEUefKaE6wr8DV3Qu4rS5AaHq0KJ0Y37xBhQ6zVhnTiZOTb83uutYMy4aAcqaeDRv+ M979GbYGASK3wwzxutbE1xKU5XA910OFycC7xBahk+KAscM/rKYIosVjcYU/1axOAnwjPTPR AVWuYVpsK9XHzNlSkmWYiIebKOL6FybNyZR/Avns68siGqHWj9j4a3reapv/kv+PNj2hm2/P 395+/htf9wWbmf/vwkp2WtjNCa+HtdujMt0updX1OeF2bYQXLDuB1aNuOzoxlFWptsxRYGPg nkbthR2AY3OpSkNj6bDoTbbVi3SoNwMJLwTt/E2QODu+H1Tw0eMONOHFmOfZDlvYJ44wyreO JGCWe9Nd+fu2N34oNZ/ysaks4yd3wfe3p7dX/RS+7ZWlkFwcX349abrwtA+oWq7/M4jjGjf3 QaRb8e+TKBlv+74zzX8WMqjx+A7mQumDfbuyHGOU9FYw9ErpVLSDvsazI1ytEK2ehvpAb6Zz hyBl4xga1wqE7eKIbQNsqeMbhaZj4PYIl8Sws9E2ynzT0RjzddHv2S4PoqLB1PqaNdEuCDSX akmJNIvMqZYHjiQJApSnMMsMr7sJEZnvAkzPOFGSxokRi2vPwjTHTzDv1XZZWpujLBdWqkub 24EVu22OmZsyQ0PQr4vE3tM4S4qgSzuzVFXx+YVufs13VnMCidyKIcLnZ4VLazesXSVOizHN s0QXRSG7mIzp2qe5nn3Ld6e+YvipEymzMBD9zynW8Pyvx1+b+vuv959/fhPRktR1+zts6aCo m1euo22+8oH48gP+1Is+gH6MVbc2QNW2WSQrXt+ffz5uDv2x2Pzx8vPbP+E+8OvbP7+/vj1+ 3chYzMswL+B4vQANvNd07MnauUZIN/1meKEOo0ZWXeqeknmWqb+/P79uaE3E1lvqfnox1ZdE QHP3Yo6R+uBJCBCa5r7rzSSTcF2vrhotwU5wMTpzWyCBe0ETFEJ5+d9+zI7a7P3x/ZlvQmZD 2b+QjtG/2sdrIDAirFatEOOYq3ytGQb++ntl/17cm6vzWURIIWBO+fDbvJhW5GTMZWRshKs/ 3rk5WBwu0/FR13uiOXI2y0JkmpFEIJD9fPzCCKun7cgy3OcWZTWYLBuzHtB8USIFqC4WkMwP FzNMjvwtT5WP1W/hEhNEIU13PMpKlo1aVdUmjHfbzV8OLz+fr/y/v7pSH+pzBefmxvGioNy6 k67+z+S2Y/oZREH4GOjAgF7UsunbVg3ISZvqcj/+fPfWZd32F90bDX7yaXLPbBqEhq5oY0Tp kgjcbvDMbbJ07LozFDGJUL4/rUeFzIdZr2Ad/gIB4v54NDQNlai7sArJZqLDeftl9KKMnKuq vY2/hUG0Xed5+C1Lc5Plc/eAZF3do8RysYCXde/sZ40Ed9VD2RV6XM2JwjUmglL7JMlzL7LD kOGuxHL4fQgDU33QoChMsXV85tiri7pzmifoJ5o7nuvaF+wNrgGIjuW5mpwZB1Kk2xBfmXWm fBvma5LIPomXguZxhJ04GBxxjFQvn0KyOMEahBKGUftzGIWoFG11HToszPTM0fWVcF5maHpW UHZB/bYWlqG7Flc98usCXVq8Aw00ug3dhZw4BYOvzTaI8Q42Dh/0Dgizf6uMwxxtxGIa9TRY mXJZUvSJcivaotGDuC9AvMeo+xqhkq48F7pQM3I8RNj6suDnuscTcuCGekUtLBfwFKbmlmpG he9wQTA9cOZhfH291u3evI2a4YHu8T3ZkomIs7/Oc4VYouhef2ahfPvZNEWLVK0w4O3OpQ8q Dc+kBYO4Hb5iXes9/7Em0JdT1Z4uBfLhfblDqMeCcnUJk3+4nEs4YDmMWG9iSRCGqJCwvuBe cTPL2BdYFwUyX5t9iLmSa63U3PH+wqf+0B1dwo8C60kKhtEul0ptJ70Q4QwIwhbX+t5Yx4t9 lme7Ncy85TPwgcIuQL8+MOALXzXqkdRGX9A5yksUBiE2m+tc5CEnAz2GYYDnQx6GgfX2aYLL 4C2HxLcffmGrPoGWZV/sghjf79psCb61N9ge2oI33Qc1cypoz061T+qqGmoPciwaUKirc63H JdBZDpfP9cAuOHjsun094ljd1LxVPeDx0n6pfFVY3Q2HKIyyD0pdNaZfl4l9VGfXgnT0ds0D c7S5LNapGMLHFYowzIMQLypXKhLp0ItmQikLw4/7Cx9hhwJeCOmx53QMTvHD0yZtNZrKnZHy LgsxE0tjHqlaaoaSMap9z/ckQzIGqS8P8fcZjnE/yEj8fa29LTzA3WQcJyPESfqw+uT881GX 2A95No7+CeLKVcpw9EkE521wDdkx/LbAKV3NlfkYz4mXSYzKzgtHQTCuzFSSY7sGZqvgrfZ3 lDO9oTYROg+rGyOsp4mxtSmUDWGE2vqaTPQweBYzNuZp4it7z9IkyDzz0pdqSKPI0yhfhKqF Y+fuROU6pqdWmrFhCS1pfE0Nt87OWFLtupFYSYswwbZ+aosbj4HjEjtt7ccsS3cxXyf6oXZE 4XC+i5Jb1xrbBQ3cZUtSW+unfBfniXGgytQXeCBMCR/7qLAzFRvNsqoMgzQNGupmUBtRVyLB oZ69XBNraPh8Wg5oVOSJpRZGV0MV2WJABAleLgU76Dh83rmSCbKSWwQJ8uYsPOto4X75oSpM Q0BJJjQMkAxFX4/C/NZfz7Jr+Ms69hGfUPrK+bbaLS7f8DHc13ILZoAX9CyrJ4ckSOP41puh 3GY0TzJsnVP4la71jnMH4dHgVsh8+VSySMVr7uxW1gJVQ8Gbv1wGbm5NFPuxibFRLcj4sK4p 4wXGXk+amraIjXggBtlcqyQEjlJ8E+9zlFLZ7qsC9iKs4X+VBbY0qhPDjqhp5cZ3kYUzQezP 91HKe46cIJxzSAGnyTqcafBiEUzrLX41c3r8+VVckNR/6zZwcmrcgBqLJnJrbHGIn7c6D7aR TeT/Wo/YCjIZ8ohkYWDT++Isj2O0Wz9BJ3XPsOVMwk1dctj+2Lm42iR164MwcxI14p+pBGdi cl+sssOe2SzhRLm1LElyvSwz0uDK6oxX9BIGd9g97cxyoFJbljdC//v48/HpHTzP7OvsYTCG 6L3Pj2bHZ7jhweg9KoQGkD01X4jILNIoWT/oPQs/CLNa4HnAwnhkiDx8gfMd3d6iGwt5Idbo dSzIjIJVp97rHloCE7kZDWWi3o5YSdvuS6cHyayZYTXBt4H7BteE+X6L4W436kVm6wpGt+mm FXa1z4E7GbdOma39fHl8dc1SVD1Pz9GaHZQDeZQE9oBRZO0xrMn81N+QIoG0rUC/dYB2wU4B dSZOYp3p/2zI47vH0kUgmNejztGebxdhMbzF0DNEu6XVzIJmMkVV/lCaA0MfMdLLdPWV9jxE eY6ZKehMTW96m+gYRR1wDA4+MqYO1L59/wREzit6krhfd+8YZWqoncYwOrMArSk9DHMzhBaH uaPSiN5vfmYUqQNGSDt63nqbOMK0Zhlqc6pY1Iz/eSiOIC2SjcUxCbmWr0oC7Cs5m77pCxXL wWXi1SsC2TnVe+4jpwI5bWmPOHJy5d2Y9zRbXpsL1B3LoGCZ5YYH9UQZZqV0rs0nFpvebeu+ N24VT/dEXfjqtQTUEX11FMI2guZgfxYi/Nzk08Rni7qH/yoVCVYH+LYDwgjeS0vpRa1bMHjh AL1Ukh8WV9JYMFgBm4uKJLEas8gTmPsGrxQENjCdfgR+ujrR/GaSDONTd2Yk1Bm1wk4vgBHr diHf18ZNkA5AM6BdRJMFja/Q3huGUud4lxom+EXfNzVB44PTqxUiBcJfo+YW7VGGXbSiGg3k CFJZhJrZxz+S6rLxPYI8o8ehmlPaSl+ddbS93HeDDbbMPLwhR5kBPvrIcc4DO9QhU2R7IwU5 YyYpgNzzuoD7jPHBTgMysyGOv/TR1nduWzXEjivLR4Rt2aaQsW6aB93siH/TtdaI7HhlUG9T NCVtYHCquEMFo1xjkEWT5zk2ygCEkFFi/jHS0Au2dgCi3NfM5+sBYNSITCJ6RnPsysWJEIo4 b7DAEuuXHYxiwz/C6f6IFIaQRVOHSZx4BBVoGtsSceIY28Xloz1LMBNcBeZhGJofqo1DeUFh +tG4pNDBzqmv6xHf5YgRIY4BPY7lUMc13zvtcHdxhacxepAnwV06miJa85kiWddC0owQ4jh6 GoIR6kYfER1avFa9+Ts41ylXm7984437+u/N87e/P3/9+vx18zfF9YnraeCD81ej+98IRI5R diMame+Y6mMrrArNqcoCMQt/i4U1BRqP0/4SqVc+UhYPfMNTo4eRnLOi1X1kJ4dSefg7x7BD dB5SrL93Ipj4phDfLMhOQM04K5w2wmuU429z4BC+Yf7OFWUO/U2Ox8evjz/esfgtohLqDqIo XKwTKECaFjubEELa9vUa8dbAoYoJnbuyGw6XL19uHdcYTGwowGzknlrUugUH59Lu73zymsyv RHG79//lJVvKqvVVs5y0GUlvxmQW/VMardxcJ2691htrnZ6JypzY25rSiN8+q0JYYK79gMWn w7LeE5rYChK5aBkM6169GVmB/3QjN8l5vmebp9cXaflsL3mQjDQisOmdpaxoULOvTT1Bw1Q3 wiWcmNSMMsvzP+DK/vj+9tNdlYaeS/v29A8bqETUgk1/egAbV7Bm9AYzeX/jYjxveFfjY+nr C/js8gEmvvrrv5eyg1BGFE/pC2hEcVU84DNhenPJNjZnSpFePP5s0RaXIunyIX1/vj3++MFn ZDEvIVO9lIbu0ddAJAhH/cZtgbwyuVqhTBBRkLexBVyTk/O95oFvgO24UzoDFQ9/Wl+6H/Mk mducN+QnVV4467XKrKcLgy1McrdtXjmSAAYRmXDPXJ2FJ7fkOWRhno92wwjxqZNRPeQZOhZl ExP8Ja0JjMMQ91IQDFcWpmSboyu4qJfnf/3g3dutmcUy1eojku7165GFBFtJNE75Akd29Siq 6e0vjUdJsUvi0ZFF0T0R3BQLXArZWQ19TaJcnMXLMXLYu7Vh9XPH8sZBE3dwWKukiX4u2i+3 YcAWFjkU+ni3jd0R0udZjKnwqmhwUZ2nTjIB7EL8zlXn8BZyMQA1ethk3WATzTPaibzbbd1F g6s0653RVtPlVe+Qj04nam51584qIjrf+lg+70kchbOqxNWLdZkMdUMB1/l6Ivz0zxe1E6KP v8yX0q+hCtEgLJW7UU8/IXsWbXdGBZpYjrWSzhJeKfZdfW1UMrLXx/8zI2NwdqnAiDDPaIeZ WZh10u9ygLgBvq8xeTCjboMjjK0K0RJj7Wpw6AYWBhCH3q/G8cdixx+JnaUBnnOWewGvSHnl 8VqemcrfoyzwvCwho7oX92hMfIHBcxumJ+xCFo/54ee/Klz8pe+bBze1pPsj6e8L9/msSXUo 9mQK5I4dkikjlCn5VBnyqh1i8JgvkirAF49eTlv210Q0HYumRHLaV6fnxvg1EOye02CIsKS+ WONw0HOEei7RaIwqNXSMUZ8wLcA8kbLB/XC78IaC5wBafT82Sw0GrFhFiHVzoU+ySssRl9+m TxYmZvUDlSsh6mMO/XCpmtuxuOiPZE8ZgNllFmzRtlEYvmZPTJPhCi08RvZTESdzlZU2OY9J 6NZNzXoQwwVEdw+MWXCClFSrAoHmgNrH6gy6N9JEt317Zv6BxCkaR0STONwmWYaWRZiXuQjv ctswGT2AuSrqUJSslQ04sjjxJE54va4kZrSMt0ghlKlUhnUm0f+giqLddm28n4ckiJFqOA+7 rdApFf10NeKRiJ/wcIVxRyCI6mCBbyEdVat9fOf7IOzKXXmal/VwOV7OmuW2Axn9b0b32TbE jK8Mhhz57J6GgekoZULYIbDJkfq+uvMAsS+7HdckVrMbsjFEXPcB2PoBT3YcSnELH40j8301 SxCAkSzFK/MuHyrULWVmCAPgwNIeChomJ++yuYQp6JuKUYKWlpW+964WFog9v84yjD02liZ8 z9IIjaAAMRGi1ZRV0/BhTtHE0vjPmu8xJqRJ6uSO719KF4AzgiA54EAeHY4YksRZwtAmYuRE 1yvv2CRh7rHo0Xii4CMervFgMbw0PHJll+cipu/FhJ3qUxqilxtzLZa00K95NXpfjQidZ2ZN mEuDJAEypuAcVvV/O8GQZy71M9kipeRD5BxGWNgPCAtoPY44Q2KNWJvnBMcO++pA+FoZ4kAU Jp7stlG0NvEIjq0/cbo+kCXP2mgDtSANUmS4CCREJm4BpDkmE0A7bO3XGNI0xj+aplg7CgAL 0iKAHdIfOBCHGdZGlPSxXOEsYCCGv8HMX7WHKCwp8fXghqboGtzQDN+wagz4RlxjWKtHDqMN 0FA8SswCx1gpcqT9ORWp3Ibu0Gmd03FlXWPA9G8NTqIYaQMBbLFxJQB0aPQkz2LUzV7n2EZI +dqByMOWmg16DMAZJwPv+0glApBlqDgc4lvQtWEOHLsAKb04Nd1ppe9NA4CZDyeDjhVh6kl9 jpMIGwkNjfhWKfVMONEuww5ZNI44D31zSWBa3GhYFGQJHuJaH9Pb7apKCFuyNEf0Wr412PKt JDK3XMh+F2BLEAARBnxp0jBABwA7DeH6kOYcq4oPx+N/uVlyMkH1yDU7hVkXolWYxWszSUVJ uA2QDs2BKAzQ6Y1D6TVCY3nNwlFGthlFetiE7JAGkVgZ7zK0wOSUpOOoAkKu1/UwsAzdDy9Z 0TRFhyvXLsMo3+dobIuFiYUB1tU5kOURtr3ilZbjO4K6LaJgt6Z0cYZx9CSNo9VuNZAMmViG EyXYqjrQnm/XPHS0MwgED1yrsViR31CW1WLc1wVEtcYVQw6meVogwBBGIdIJ74c8ihH6NY+z PNzjwM4LRD4AGVeCjnY8iYBqToYzbvo9MzZZngzIjC+htEX2LBxKo+yE7HMkUgnIlUqc1K42 njytXWUZ4Rj5P7Z3mseMeEXS++zhzDbcBWGILQ7L85gmAWyFzlwkcDFRpq6w8SwebtQIsjqx C/3P/30RYVS8jDWca9NCY+IwnvODV92utSfuF5biUNRnGWx9RQj7MUMZ3uMjYdRVRCOegfYE n5/S+UVBWdFyInxl0R7FP247OWVBcKsEWIHnd4ow2yH5ZCB8hDSF8cSRQMCDbj/wqbZjB9sO zmBYOtvSuTlHvA1GsEr5+c1wsVlshyTLlBy3L5IyktMql35Vs8Y3GX1jUwwr9ad/pXfQ2/eX p18b9vL68vT2fVM+Pv3jx+vjdy2gIdNNwOATrDeCg4uvklpE0tO+7qLGBMTJ5TaWL9s5zwvp me3rbuXTE2xR68Z8QorTVKQ9nqHwGMGeQHbZPEIpJtNUqCS0cKq3/Pn2+PXp7dvm14/np5c/ Xp42BS0L7dkwnsj6hCwtvF7nlNjAMTLvrRZ5KY9eUgGxQ1Mw3OxFT3qkBbkRio0ug826vZAY ar5G/3x9f/njz+9P4ukFJ4a6+gA97K0RCZSCxZl50ivexxUGMxG+TIlkxRDlmRtOVGPhAie7 QL+6Ewmtm7KFZt7kCWnn8Fsu0eQWMovLvBEh6jd58Al1Murk59rDTNQU36/PMH6AoWA8koEA mzays+NbjFjda+KmjgMR7zASPE+AedIeD8p+mML2/34pznezze9SDU1PlIGbRmCmxdsykUMN r0zBE8vt/ym7kubGcSX9VxR96o6YipYokaJn4h24SUKbWxGklr4wXDbL5WiX7ZHteO336wcJ EiSWhNxzqEX5JUDsSyKXaFcfULf3Y3l06zoV4WebT9NrPuwZxnWVoqyINS/2DLpmZ+MUlzwD 7Ptl5qO6YBNqjBRO9lCHx7xnjVfFgaq9KI5Uf2VS/au5mQFoEyDEK4zzyteItbc0GIUsTyUr ykNKzaukxqz6ARLvydK8FA4Reu+S08Ij6BY1dP6hUd9JJtb0aHa+/kI5cvY62Gr5I7d2fTSo A0NpEiErJyWrtTe6pVGyo5mLXvg5dn3y2TDQliS4zMu5BOHRnV9cXumJRkqkB0ZT/AQpvjsB HTXzFJr6dj7kkqquKng/BmkWWEwOS+ot5i5+7+lV+ywafMJBjaWOmFrgREffvke4f9/WqsWV ENHcnIUlnoxg8L2LpbyS31ElqoNTzc2HIWzBke/ZQmXDHHoCCRptZWOAN1+Z40apziFdOOvl pbGVZkt3uTTaKbNOS6HJrJ4RKvJnkQfWnYyXJfNX1mVWV9KcaGbzjbqbBg3lvbpS5KtVsoU7 j+VGlyUxCbg+GOYTfnu+efkBZ37DciDYSvcj9gM0Qr2VShL2ntPMZ0RK8IkG2J5gr5j9Lrit lUvBfhuwTsBDaALWO8xnF3qsW2NZ8Z39AHdspI0pUakxq1VzlKz2ZKyP95DhVLasppvB774E X2fUiM8n6JsQhTYhGEQj4XUnEHyL80vvvxZzSWQBDBAKr2U9HI+x9PDWaOtaq8k2yVp+VbAU V8FGBfbu6fb5rjvPns+zH93jS9cHepIO6pC8t4Rcz+eemm1vMZUu1OcBgeTHsq3ZifMK9WYA XFUQJ3oL9TQuOShrrRpsxG7LRv9WT21RoxsJj8i1JeXwrcvJt2Dkz0fLZjRKZQfB2a/B+93D 8yx6LoX/+t/Yj6fvD/fvZx59ThYYDPnBCRKdB4DnRbNPAuwAwxv2Sn2QFrQ2SMsduizojFFQ 1hCxg3u6R7MCi1iIWdSzWAvKeS+3HWfZ7kcT17vzz98fGG0Wd9/e7+/7WK46/0GUTAd466Ml Hox7cIcpgokehsiGPXcR/pFENUXzG1l7q/A4wAQuE/e0dJhZ8WC2yZ6th9zjC7fLwVRMtbrs wxTi1SX7QHZDAEz7bZLpX9pnh+3GNsvYFd9VX74GqofudQO49Mw0TYzJtvmg1hfObBtslXc4 IEakqhrafk0yYxJ/PVoivDIsLKKdrckG/w79siDRy6APTyrCqb083nzMypun7lFb23r5FJJ4 QpQ8iHDJPwv1qPe8IbhLbXJk/zmuFdsKQCFmFvtLucvwxZzkp7gyutUan4WDJJz8OvAibs43 P7vZt/fv39kyHusunTaSoG+M5Ao7jUQORfBNhZYXNdmcFFIsH+fZbx7Wc5/QcQVSM2V/NiRN KzbhDCAqyhMrSmAABDxjhylR5tWAVRDhgByTFN7RePBKpJUYH4RnRb8MAPplAGxfLqtiT+KE LTQ1/GxyiHmYwNkywT0UQb3ZwZZscwjuQwJMzCZKqcQjhSZONmwhZLnLEhF+5oiaUCszOz/1 hpHyl7MAhA1osFnosSC61iyJIQ1LMJwS1NLUJOUtUkuBPpTx9kN4LjBEfdBlfOIrGZaZo/9m PbUpIMZd1IeV1fv9FCaVY7PLYAxBhR/tAWLHFNb82MbIRxqt9a+xJkUNnQBi41ydICv5pRL6 aBto2Y3RCGwlpIuYi9pseM5GHnrYhtlA9mqBgKDeNATR2EMFMI4HWwHIGlXiYEia+HNX1WqC 7mI3LnbGhTUqwoIa8hGq2m6NJHa8T9MkJ01mjOkeBsftXxv8VjmxbT/BcUcl0CLawXQkmY3a k/HZNICizaXhWJ8WsqbBSLJkFNQn/XcbGSzjK1IaxSZ2NEj4t+hS+zks9spgDfYB+qgDGFEn OrgcXqpnCUG1qN3AFLMN9Twp2OJM9AJdn1BX7QxZxpujxgwkdgSPLF5zBIdNUgDFK4q4KDCh GoC17zlqI9bsKKG8WfHV6lpbANU0bP5k/U6szSqgthA2Fk6H2IFM4YkaqkQChLbPaNRs1PHA jnbalyC64PZYr1z0lMj7qKqbQEkGDlD7K67wf2qZ+Ambf3mRqeeMLGQNdzxiNP5ktjXGoUCt Ezms2H2a7pJEa/umaK8XV/MjSp2j1IU2qiHqsdasa1nANs4umI7SsWgsP5CjNKB0cAyGPcGN eciM2DeMIKjS54X8zEDKQ4aRx6er6blPwVAb7ollegJA0nP7hovJy8y/Wi3ag+ZiemKgwS6o 8PPWxHRB90UqTFz6PqptqvGs52jzTY8JSOas2b0lquSv8VyhnVb6rmvpg15MfrkR4WIg+4SW mm8S+SN5C2n1Zy3HH2o/YbK8nEgV2bvOfJ2WWDHD2FvIj0vSt6voGOXS7syOarRWXHbvYtld K7uQFeovsCRo2DGCrUEowA9/ylydsChtascSV5MWjbrk9V6TSYwF6dwRkxVM5i3sEORASyJn xa5D9uzCZ0YVoW0xTRbIHA8/BQgPMCVLDS1F5A7QkGL0YR4J3VkTcoExY9CTS4WAqIAt3EDS ZLhMTV3HA67qF88hKoSi/g807pl6F9B2Jx+TFF9ITa/XIo8AnjLPWQdHCUQfa20BBiE+cPcI WjbP76+8B55fQA4o3YggL6HIBTctQrViQ/AZeKpm23ihRjbkLVHjB9sBaw87wpqTUPwoL7jC lM8oWre7BpfKAydETILjyxbMKRnBIl3sR4nW0AfeA2Gw0SswAhYVEj5swcldNDm5M8IF8jy8 9XE+NzqyPcJYwanKy+xENbzrAJSg2XBqBQIP1nCtenEc8bqGQUKjXWIbzwlaGvFJS4mKIwS6 2JVmqcDgeeEdcWDpOSawYaOAZTYA6vgYSmEpejO1i5KMpv5ioadTOCo/8DwXolpYM4fKq4pT gkr1KQpE7lkgK6ZYqTB4hhCT0ePNK+KujE/lSGtZwxktH6ixxlVno1OovKiT/57xatdsq2XX obvupXu6e509P/UBW7+9v83C9Jo7yKXx7OfNh/CNdfP4+jz71s2euu6uu/ufGXi/knPadY8v s+/P59nP53M3e3j6/ixSQu3IzxsQnUte25U2zuLItwhJGExK21srT8ubNVZ9EE9AgYZWHvFt EG8TYz5wKG7A37Dmvrj3XPN488aq+nO2fXzvZunNxxQeOON9mQUQhlnSWeQZgilkkacnbeE8 REv9+0Brm9TixW3kuFA5juOV49A/rVy/hs2o/jQ7ZmQsB4zqIJ90jNL2j783d/fd2+/x+83j F7ZsdrzdZufuf98fzl2/F/UsYg8Gz2tsGHbcVdudPpD4h9j+RModvFfaG8eZWsAsPraR9mks vkxGBngwuYYYPjRhk7/YGBshmOdDOA1LJtwHhOxZRCLi6+TaW7CbsDH4xzQ8nrTNy7fM2Q8W gxfhlFtunOG8byzHtIbStYPdWfgCIuLJqeuycKaeWxyIS0zTRRLLor/2Xs4hIFUUhPpQGH2U Xy8XCw/FwiS9Jvqpbij6brlaWMrEjzu7BPXhK7HFZEt6qU+i38TlD5UQOu9yTtGpfx7NfLSs SVYmWxTZ1DG4+S5QcE+o+h4rYaQMMPdsMkeFl4UNwwu1FXBbY4/ncsl9CAxmyYWBLupNTR5W XCaFlpGUB1u1G+wZXGIQwaDKOECzHnBL9iJ1VuKP3AhrQwMHV82yMeMyCCu3bS1DmcNLlQae xdUnVQceVD3Dlt/h809+/Sc85DOe1ZVtVKhMKSb5k7lTavlWERKIBVGjaBbVbdMPeQQE8SWO FHS9duZ2bOGazn01Hl91rCSjx0a/f2FsebDPAtzKUuIqU2c5x9W2Ja6iJp7vYsImielrpMSa lxG2u8EdHAVpGZX+0cWxYINvIACwJozjxLx+iD0qqargQCq20lPs9VPmPWVhkaIfqvFhw18h /wjkeNoSemR7X4HX9nAwJBZDE5eqnpgMZTnJE3yoQLLIku4I9nVtZlv2D4TuwiK3H2NE69Bm gUr/5R6ubdtCU8ZrfzNfo05J5I15eB4bTz+qBMVyDEoyYrGDGFAHe73lV7+4qc3huqf6pl2R QtObAWqabIvaatfIOaxXW3FwiE7ryDPuKdHJ8BUpnxdjIYVTEvEjBcTjtVUW5O0xO2ymwcno J0LZP/utbc9JtRNyDU+5CQ82qHhY4MUrhlDnWpJEF20lO3CDyG/tG3IETTT9GA5C3o2x+J8Y p22jSv7kTXE0RiIIaNi/jrs4Yg6WOQslEfxn6cqm9DKy8mT/DrxhIFIYa1DwXqbpffXXkqCg WhjDcXCXPz5eH25vHvubLi6cKHfStTYvSk48RgnZq+Xonagq/iPE1WIpv1c18t3coOnv0xKy BwsLc9DJ6UC9BtUxMRkp/g2IYBBD1D0HQQeJSJs3EOR1swG9FEdqze788PKjO7P2nGSF+lIh BF2Nxdkg/1ylw/JKMEitNInRMXDWR71tsv2FjABcarOK5nrkdM4JHzTGcxhHF3IPsth1l14j 62YBne0gjrM2MhvIeng1ncM3lsBtcd3YV96tM7fKUZosO5k375SEY/RmTURpyuk2bFdqU+3k 20wXX5UVpeoDcYML//r/6syCiuY9gn2x1VVBYEWY2C8FI1ce4R7EFKbkHzK1tAlpYj84jrxV Hlu0/dUsUU1bhWXDOqmltsYbOgHPfXPhFUhimjptWg6e/81VHx9hUf3gQQfqj5fuS2Sus/Wp lI05+c+2idQgXPDbMPfT30f484hNUp6WpO0X6CnZAduLMtXnH/tpFZCBWXQ7hKWT2IetqJec ZtHvNP4dOD9/SYHENN4pJmuCpFmyMXLFTp07rLg9v7W1pCzTeoOG64JKkA0brbGedxSuUS8R gIF/ERojBdo3Ie5BH8CG7iK1Yg0rHfGqIp1rFU4gcN810hID0GgmfFCNgu5IaIs0AxxZrZgj ZElG2XkeC5MHj43wDDd9nD/KcY0QjNZyy285c46FFRyscjh/7g5wRsm3iflUy1jNucLTczWS uZFtr12CFFugvW84NRGYeTrWRH1MAjPVQLfpFXAe3VC9LwXYGuIv9iOOKrUMqOuOvouQvF0X dX8zoUutl4DomdUDlQ/UUFOgim2kIPqe2SdRmuwhGAQab2lqSlW/ZKR7qCyPw4O9G2hbqGva iKLW5Rw1tYpGsr3tFQ2lfhjH7ERiNt5g401XjuXpq2+veumizuz6Z+4oAPtP7YN1GrlXi6NZ 8sGq+cLQd92/zVTCmvnC1ONPf98eH57++nXxG9/Yqm3IcZbmHSIpzCh4nGCnXtgpx9hhoAZS 70i+zX7TJm/IQx5rNZtCNslUsOgxSp2TaO2HR7TM9fnh/t5cLwalAXOYCG0CHr7I3leCrWBL 1q7AjpQKW1brFRHILmFbZZgEtQWX1WDxIkQlJodWWDTHBTIkND344sFb7eHlDR7cXmdvfdNN 3Zp3b98fHiGY2C23IZv9Ci38dnO+7970Ph3bkV3LKVHUS9XSB6ydAwtYQtxSueLwQgKeSUhK asz0JIkDiGlZgHoKjapGOolzCFF0BDqSU1VHrRLOCQjg087zF76JaPsdkHYR22dPOFHoSv5y frud/yIzMLAu5M1fItpTKVIqRpg9CEMgRTQFrGwt2vRhpSy15gxlVSgNPwKsCOis4KWo9vyc Z6pYOREvlbF3i1RBGLp/JrJy94QcfVkTVtBjuljO13oRJ8R0rWVjjNjgbNDgEzKj7OxOpbeH uEYxT73VCsSqICkYwAPtlSrbkyDwanE5seriQgFkjxYqsDaBirrREq8DoenCsXjnU3lQN8SC 5cgYkKJy76QOMhg4MPdsiBXwESBbLWofb2SOQLderF/4delcX54LSEQmk0VzZSAQyk6uV/PA BDbZciEH4hi7i02UBU531XgzcgrU+75gSLLl3MFGxt73Va+NY6ndzJj9EKLQOvt5kNY8hjiG Yv0Cfrgcf7pqxHSpvftKve4s0EgYUxVY1a4iNHWPmSuIqjSjFs3IJMoK2wo7rA+O76HrhrtA ewsQFzseykuOD34eM6IG6VEZPlsTPf/qM5a1418aNsCx8l1LEdjid6EMfR1g+wFPE7i0R2Lk G5nBiZXHwdraWc1XaDFt536FAVm6aH29WNcBtsyu/BrrcKAv0bYCxMXct44MNPMcrGLh15U/ R+hV6UZzZK2B8Y6sHLpTEZnuIvySyQGfEc9PX+Bw+slE6b0qGfMM7g60e3pllw10EYizYFBy ngoy0RBz/Anb44q9IGo2DJMZsU3yrWJ1DLTBvoiLKvIkVQuhhf0cFMgZILs0GahFUMeyPulX dpUHESPLJdtmNQZI3zrA5yLDs9JAR8aOSNHLi8Z6R31IV8khCz3lUVsfW/V7WaC5IRmbp60C EktZhs3G1C3nmcKbzJQDPXCqlGUkfTBojtP74EADByqpqt+7i1erNeqinmRQl4gQ1e6wHCzw 5Z+j7sNcI1cFL7KrknshFbsyUxrINvo9ym3OBfbLeFhvFP0qUrSRHBEZCCXMiW2SK1EyAYiz JJuASWAL4RMT9NUF4ocmVVTI5+pmCJZomGQBkCf1UWOtGkVMDhEYN2zRmUgwEdreESNVqVMg wv3DmQ0EbBEYPCTgksgBDMEbjaxLMNBJXja1Qc0yuYklovAe0E7LxmAScXt+fn3+/jbbfbx0 5y/72f179/qGGsWcyqTC7z89BM7ESs34lGdw7J6E+ATJFywTh1oizQAo99qzr6Od1Ax9qug6 yZW5wMgbfN+EBHD57MsKGn2Wr7E/8O4pzCTVT27zWnFfxGnsll/zQvaeg6TZTYo6DYFJTVFn crQXoLAxABlMNZIxNr5Y96nE3oszOymwWSY/7QO2g0iJ5T7LGjMNwrkvZUZaB1siew1mK28S K28vPcX6CDLCvXCFrYUtJX8m7XX4L2e+8i+wsduYzDk3PpkRGon5hvbywEdogLGpTLASGHN3 wHzHddVnhQEIYvaX8PWLowFkvJjLGmomrETpQWDVyA1h8HCpucnpHTGhscHnXC6w46iXcoNh uUBVn00+Vz6EmbASxHGEwU8z8dit24atj0trOl9zg6WiV4sFGuNPZ8I+Dcc+slgv8KYZUIt7 XIMN1/gz2LAwdDqThw2ufT/i5R1CYFmZRoCwTtaNAhSWMnKWnmXD0hm9JT6BBpw4DtopI4wq pw1cEazNkbU+cUDnvqUicb2co0+PAj/l/HFwMUcG4pYtP7sSXQ3ZyeB4cUqSqGwzttLhb7Bj yb9yx6m6MxWV648Kb9vrhP2vGZ7e9awjbjjJmubyyjGyXWj9niUOrF/J/kH6DM8gS1YX654l 0EhG1XPSeq4srpHpSE8C3Zvj9PX8iBSMIWkQlpE+/BE+aB30IVRhyZCRW9Wx65iTl3pyGMhx M5SVcqas2ZlPOS4MCFfzGbc7c1pc+Whw9ClfloGHLd6MHjdYi/XAJkCttxQeSrYZNhj22bU/ v7R/sX16ZRQINm98R5e9A4k50/+rPGogyyK+xliaX5yuCRsEr2+DSeB4/u8dFN7edo/d+fln 9yZTn24en+/B9uvu4f7h7eYRHptYMjXEehCzBV45H/SUlmyCCFSwwYWl6kJFzl1k/e3hy93D ueu9wePfqddL2SJoIAyudvpD/M3LzS3L7um2+wfFXrhzrdgLF1cVZtB65RlViHmB2T/9Z+jH 09uP7vVhbEAB3H+wa83t80vHkoIYZWTIu7d/P5//4m3x8Z/u/F8z8vOlu+Plj9BCu1eTUCd9 uP/xJmU5MNU0df5e/y24glsehrZ76s73HzPewzACSCRnm6x9eegOBLlpq+71+REuTbZ25Vzi jXf2BYba0x3rYh5FYmzJ3v8J+vrPoON2Ej2/dDd/vb/AN17BRPH1petuf0jyi/5m0Lu5Hev6 dHd+flAMFAO6yxJc+41YXqU2pErALGBQ3cNEN1tZTLJl97NyG4CcQZqC1ams2a3/OiGqXVFO 2MWPsmmBKfwoQSzgl6rxGZCsjfor31RBRsuT+lBUmFLQLs7YmiH7UANK36+SzCaDpQ9tjGu6 nqPvJtsqOSkqxQOhTahjEqFx+oAhY84CMryJ6bh8tZmIRRkq1hUC0cKXCzIoDhtEU0d9LC93 6hirKtYCVB/xBVVx+TWWRlZMEUQaY+kHTT2jfbSe+X8pMY6Z9XqLdVRiCnVH3xv9CEgyGemt P6l28QZfGin0RsDGusVVLQT7/QynWeHbbNE3zR+kps2lPAQLD9CEPxXuyguevHYQw8g0Axrx MsgDWuTgMc1eCFCouS6D2K7ZOIbgjYMS/1AviM6SPC0O9ta+WFYuijlkeAlY2f+Psmdrbhvn 9a9k9mm/mbO7vibxQx90oW3VukWkEqcvmjT1tp6t44zjzLc9v/4AJCWRFOj2zOxOagC8igQB EASAb1YXh6E9EkPRVMtNktIz1lKtfSOR3Yiy8lKmjWgtZGqk6ZJ+YaTN8rkAEXzS3LvufA4d OjWxe5bT31/R3IeCZvm6qYufpcwiX0gEjIFWCes9NQ8yXsP5dGGqW5I7T54B+SanWWU17Qau elV5wrdoR7cMmEqkwmTSS/teevb8ZNiJ5zvyulJCXlVMm7AWwpe0UdNRRHZjcDwKbM6cyizd duyJOjQBjf5pZigUZwyirkJ0dNw2nqS9Scpg58YZZUrACQis2HjRGo4y1rVnazASV1A80aUo 8dGKqTTpJEF9WPq+Vo1KS+p6ocXCZxDFoNgmjKX7ORm5syVMN2jxhVN1UxthtqRFFnBQMwOJ xVbwsiJHXCd7Hw8HEN2j78fnf1TIVxRte4GtL9HfZpoaVovkyXxK5vU0aKI4Yjcj1yjZYTka LJqInHyjoUlWcvuC38Dm258UVyc7VbTc0lHnTJIkmlL67fqBlwlw/6ifVjmf/Ph+otJjQV3s HjYM6JPGzRJAQ9gPLbRnKCLDPZbQrICvlaslsO2fEGSi9qSCbilERr/8YZkm4GQkAXRFDs1I r2VkOx2mglVBkwGNR6LPstqb86LaHY7n3evp+Ew4srCsEEz72inq18PbV/K2vMy4vgNeyRd+ VUl42hTR1e/8x9t5d7gqYFd827/+p0//Ftvqd5cfjh8jVzXf/5ltHbjBVvNt0vAqoNgi5rES lm0QIZ/ICNilFPuWFbtrR69/Xq2O0OjL0W5XI1UGSBnpoynymGUBGcfTpC5ZhRwT34f2H9ki QOmdA9uh0eh07OSJtEoHnCf3zB3E4CVLP14lMvS1sS0el20F7N8z5kPUYaLi4RdQ5DIdI771 JkbfUmzLya0V+lgjvFKNxndC0HS2oF4qazIjTZdbA2bWns4pL6GewEnmZSKsfF49wnZU1PBK 3C5upsEAzrP53PSC0eD2baqh8sI2rAyNKzGRCd5Ay7edFKyJQhu8kWHCAWmDtUczHohEXeqf 5mM+o8yAlNfAyziu6o5kYnAjvPVvAwBSIo/C95XTtjhNHWbB2PaSDLNoPB8N9Zp2YwTqTWb3 c2ofdjHIhjGZlFpiTAfGzZbHC+enre9uttHHzXg0NjN1wRE3td5IBTcz0xaqAU6qIwBe229V AHQ7I33AALOYz8fDdGYK7i1h9nIbzUam6ysAri2TLRcbEFcmNiAMpPHw/2cnnSwMezX8XiyM o07nk7QSoCmuYcPW2xszirzyYbZJUhFNlNefCbBTriPDmF6TyeOC7eLabCKLyulsYkxAHtQ3 llcbF9ux+fgdU7rF0eh2HNkwlebN6mubFSxzodcIXZUWuM/lpytR8394/Q7HqnFoRt92B/l4 nrvG0UCkAWzYtVbGLVUhuPNmILv/dLugDP+SD2jpu1XvnQTCQ4q23+v9l9avDm3zSoDuu4ol M97nge9tsZyXbUGqEKaAtQrRON1PLby/v9jLFb4nRmWJm9vuNNWLG9b5k1rx9DKfj+wLboBM SYcwQMxmlkF/Pl9M8KENZw50avDeCD2wApNlXE+mprsALOC5lUcvKmc30hG/uwf58n44/NAi VbtolhgAb/fy/KMz5P8vWrLjmP9Vpmm3tKQ8vkJz+tP5ePor3r+dT/vP7zqFk3JM/vb0tvsj BcLdl6v0eHy9+h1q+M/V310Lb0YLv3Jb0HH81di8TVe/XXNuVtbTkUohR0vJah2sHquimQbb hLocTcRqqi6a1FLdPX0/fzO2Uws9na+qp/PuKju+7M/2TluymePTi5LIiI4Uo1GTrsH3w/7L /vzDmIN+QWUTJyVAe26thX3EreMImqM27lrwycTgceq3vV/WoOYYJDy5sQ4K/D3pZiiBBXHG l3aH3dPb+2l32L2cr95hUqyuh1miPxhtbM+219Sppb9YyrPrmG8HO1rDTRbh3g3Zhrkg9Vjt 4o9xw6ekC0qQwiYbWfeiQRnzxdRjt5XIBR01fT2+se/eEHLr8UzJppPxLWkQyKZW5C34PZ1Y Ci9Arq/ndPxxkzHrYOhVQS2VVTkJSvjSwWhkiJIdh+XpZDEaW6K9jZtQL4wkamxHv//Ig/Fk TGvWVVmN6PfDbWNu+P5UVOp+3Nx+M487Q1GiI4qdURs6MxkhlGo0GYO6YY1ZbKZTX8LUiE9n Y9rRQ+JuPOYEPTS80ZyTsorE3FrfHECz+ZTqdM3n49uJ4YtwH+UpTogBYRkIHmYY//v0Wond ykP16evL7qxk8yF7Djag/hgcItiMFgtTktISexaschLoiMLBCraiHWVgOp/YYd80C5Clfcy8 u3jIormlzjkIk4HI9Oyv33f/GidU8vL8ff8yGP2v3fxiR9eVNg8plcfD6WS4jqouBa13Cdys eP9Ho9U7FEepas/W1+MZ+PK+V656bYjDZybFYZAe5laG2zI1Tyq3ahi96b2fZuViPOpP0vK0 e8PzgVg9YTm6HmXWU4kwAwWA3lQm/woDMq3NurSfhmVlOh7PPVlQAAmrzVSE+NxWA+RvZ4kC bHrzwT2QZPgyGuoKK2I+I6d9DdrQtUX5qQyA3Q+9MORR94I+Dc6SLE/Hf/cHFCLwbvTL/k05 hgwmPk1ivBNLBGvuTaWmWtriC98u6CQ3SNmJyWJ3eEXZ0P7G5mXGYnQ9pvwmRVZaqVPlb2Ny BSxt0+NJ/p5YHue58CTOzRiGl6FMf+YFNfxQ+8cG6WVmA93E3ArG+RDi+j72cOJSx6KSYSY8 b9QQD2oiPSTENCozTLu7MF0lpkoItk1efRgbG6nE8NH07MCKZUI6eFZFmtqejAoXiPWN55We xIesShPP62dJsGJZktPXtYogybZ0mhWFTstofOvJB6coMsZ9768lvky4CKK1xw6paHgRoY/L JQqRTT2yi8KjsfoCXiQ6O/wFmk+P+d2lKtiqCpqwzKirm6Ud+Ad+Nstgw5xX9AYWjpB7J0g2 gh8qZBQM7wooszuS9Bd4ig+tH6/4++c3eRvQs502C5vlYhJGWbPB/OMYjtBGwQ+8Wmomt3km gw5ae8pEYllqXwBNBFuq1JGIDLC8zVDBDN1aDVRCnRtI095kY8NuebZ9zAs+k4H1nH5RdNvx 5Ffo5pP5sD6DSgAOhGlDeJI3CzB441hSF+hBaX3jLBq625S7Ez40lsfHQWm6w8TpVWDwPrGu 8xhtVWkXa6t3TmtZUh5XRWLxbw1qwgRLe+/d44BSVPJ76yUPF9YFJfxUgfWoAwxwvKgrzGSs gr9b1bQ4M0KKe8O+Hkya5BdWimsjo0G/pRyuooryZDi/SzNAM/wAVs5FH1Klr7FHORlrDAIe 2c5o0he+TNnWlkpVb/ang0xZSl0AxXQSky5zLnySLKD4kXR8qkIzH3EUh4H1fDUxs+7CT/dw lqAIQ5Mj/85Zkxd5w5YJcLY01e5x/YfCZCNNEi4xoiqdce+hiZYrtxETauT97epdFcUqZWQe +n6alol8k1bCcYkuwZyYZrH7enq6+rudbMc4t0cfUMlBzSfBEYybNQ8FGoRlQBpzhTQYKhIz OBrPS9kWr4btoIItrAnx4h10YTIVbgJjRLz1HA2vPNGB8NGDxxiIuXQFtUI3L7mbKzl2AYkC DMIsLQOFIKf5ri4EfUZLTCQocSmoRbHkMyvc5RKadUIvRgCiLAf3IOAEj1bpHgYHc5xgUuUm TqxhGCTI6oYRo6Kn5292yJwll197yJzfdu9fjrBwvu8GC0RGL7DEWQRs3PsiCUXpg5wgicW3 pJi6KrHcRSUKtl4aV+azyg2rcrNVZ0eBYG/PrQT0y5U2lEiabSAEHQxrXa+YSEPPg1ONbdwn se3HlX8wXKbVL/nCUQbufQR+mlH7Qrsem1T9QPPU/tG+r/zw2/7teHs7X/wx/s1ER0XM5ETP TKXSwtxMrWssG3dDqwoW0e2c1qcdIkqwcEjmni7ezn2dvzWN9w5m7MVMvAO+JY1iDsnsQvFf ma9ryu3AIVl4Or+YXntbX5CvAJziE1/FM1+Tt2Z8KMQkvMCl1tx6Cownc99XAdTY7b8MYeDp eNvUoFCL8K2qFj+lu+4Z0ZwGX9PgGxq8oMFjT1fGg+XUYagrGSTYFMltU9nVSVjtVoXhMECt 8iSlaCkiBrIaLRj3JCCV1qRRrCOpikBY2SE7zCNmJDcjMrSYVcBoeMXYZghOIoy4HxOIvE7E ECyHTnZJ1NUmkcFaDUQtlp3VabM7vey+X317ev5n//LVeAxUod9tUt0t02DFjah7stTraf9y /keZxw67t6/DMCEyePJGOu31jWsdAV9mpOyepR1bv+nkIhVuY0gxM2ybGJdD1w/CcECLNG2K SzpQTHQ8vMK5/8d5f9hdgcDw/M+bHM2zgp+MARneaxhlPsmXHr+rHF8RNCDKYqyHEoSXQDBa yNekWc0FCAGM9P9aVkGmarPiDXBRJSXwErS32Q7EFQtiWS0gqUuMvJZpzmRCElOwwekuHnLT HD6Mpw8aXIweS7K3LiEHOS1B766EZxhTwLwnsDFqduy0ejJd6gMGn1BDLgtpxzeFShNuKpho f7sP0AyrxWTnWy0L1D4fWLCRrlZ0mE2Z7h0lLTNaiwHsYjuor/Zh9O+YonLDtaseoEAno9So u5Hd4Xj6cRXvPr9//WptN/kV2FawnJMjQbyMy0GJmVgWZgdfmpg6hA0HFa/hwCWEFVfMofnE Knpx972AdUY/6FEkVQEfIxjEkLRoivAjrAs+HKVGwFymy1+pAVYGY+6Utzh5Y3ShEc/DN5uo imq59n2NwLKCVWW8Vyep9H5veVm3fqSbvF4ooO+nsFCH/W0xFyZd7YSaOzK6Q3VPsYUuWbGm UTGxhr3QCO+EKQdM4I7m+aRXjdp6sFtKk6P0Y5fdR8VumRYPA+ZCI2Vx2XmcH4ctdYMChc16 DoG/vUPgaxWXSd3O4R69Qlec91d1NKyfXr6alz+gstclFBXwiU3VjhdL4UWigddBSt/mixSG lReOPnwYnZlkpQ6x+1Ma5JU165dfT2n02VubS+PWpnoLCiPwERFw65RQDLRDyb1Z1LATJiOi 2x2Zf2Q2SdeV7kM/3HXhbUiOiYXgXCqK0joKDbA7PIVsO951W2ZgdjPcKCBKCg4MA5tbLElR qv3L8tgrDagViq1vGCsVm1eXmOhV1h0oV7+/ve5f0NPs7X+uDu/n3b87+Mfu/Pznn38a4Z01 qxYggQi2tcLvqZ3QvyWxN3lH7nCHhweFazhsUrTVeYcgLWVOhKmygv09tIEhAAQpGyBjww87 oGm9zbYBpVMmKyRK4/EXlEl39tDmENkF2JKYV8p3yPWToasyDDiWVO2IMhJJ8H91ilxg7Jqi wdedAWlsU3Twf59wyZ4AK0O8ZtsJCeYrFyLtioklsSlEVLEY9CkQizrXVThPSfFHrgBAGlNl TLIl5sKJjBzTN/uId8oaGDyHYLLTtNvJk7FVsrLeiCCI3XF3f+tFf6cFzEqeb5bNE5pZA7NK 1QEmWHsVTOmVevoaVlVwGiT5RyU0W2JaRpPRuizD6G4/L9BK15I3k80ugyRVQt9A9rRpVLaS u5p5HpVKoiVuip93gNA+UpjBPHoUhcEM0L5t7BtDQ+3mtVSf0zp+YZkt61w1dBm7qoJyTdO0 uuXSWS4EsnlIxFpGt3XbUehMio5AEBVV7JCgYVkuVaSU6s+gEthe5rMX9e5S16aqdphPJR0Z nH6rrkQ2y6+QI7pPXeSrJ0nvRNcD8XcrMFYgannupBlVyZX0AITmheqgvvaK261IEw4/9nLA PJ2vTLmMVXcg0yz7RpxTeViwt4o/wJL016y/rf5+fPAJeA6i8LoYfpsW0cnMw3liTYhpEtc6 pqmatt42YuLktR6tEbQEQQ5sAu0UuiSZaa8jhrXYkg2/yRCjO0PMr5R3LsxvDU2GTK02T2iF nxG030AEcBaUvtMCo4oSm0EGiDFnfg0noZlxxPwgcmc2IXCodRZUlgZnLvyOgHZEMSh9fe6v dOTQ2D2m7A1KeYVCuYXpgahJaq+71TH8/iItX2L3dlYHcV83Zs7Egx8E/oqaMknAnRQcYc+H Qejx97wKBajsvq8hDTw4qo7I0OmkBHc9o6Qq7NGabeM6s4Q71VMhp3bN0tIXblPSbYBQeJ4H SwJpcVz6JiRMhLVgJLCuzXt4CapALV0LO3296r+TUwtFoiRmTbGOkvF0MZNxmlG9pgVBjFhd +qOZ6nyo6qZ9MEf1wIzabg+WufKXtGvAIY1WHjhl0N3WFw+JY+gxkqMY2vsqtpKb4e9LZoo6 5EGuDFkYYxVYklm6syW2hHnR5LUnFomkuGwSQceYJuHq0DK9AllQpY+tEdryisKYOFrKlgqr GRbBLOWpKw5XngIqSWscRnZbpcBl7zwe6xGErkbJYHFRw5JU5ilHzMW74bQ27xDUa3lHJtZP 6IXtwSs/dMdkh+c2PsnCtSfjDDWj7e2oV61dHMz/mMap9dvnd7WxeAh+mBr+LC0WmyNXhkHh seB3FN6t01HI5ge2EKuLZu+0qibvONDW4YkQXAbevY6JuzPcHKDEJ7kjIKjqpdh4QaPMs+SS ERaXl5bSS0NlU0FYkFHb2Yz47vn9hO7Ug1uiDTOzK+EvDHZR2ho+8m04j1DwBArk5vSchLoK 8iisOQo5uj3jIkb62GgMURDATbyGKWWVvGOwjTcsqqtEPGJcdy59SeGs8ShlLS3lRKdRlh8N 7BL04lEOdJahQMis0azKipipU+0naOk89eG3v94+71/+en/bnQ7HL7s/vu2+v+5Ov7nrsh+T +VLSxRrh8FW8uvZTR6cfr+fj1fPxtLs6nq5UI0bYERXcLkhXgRnE2wJPhnDLAG8Ah6RhuomS cm3OiYsZFtJH7xA4JK0sraeDkYSdvX/QdW9PAl/vN2U5pAbgsAbcP0R3rJihChYPB80iApgF ebAi+qThlpeJRtWc1Ivsgk2ccHkvIs1tg+pXy/HkNqvTAQIPdBJI9aSUf/19wVugu5rVbFCj /DNcd1kHd5sKarEGhuJvCwa7adwt28Z7TLJhW6u0ZroA8tx2kwXv52/4ZOj56bz7csVennHT oZvsf/fnb1fB29vxeS9R8dP5abD5IjPjdduQnU66pVwH8N9kVBbp43g6otw02t6zOzN3fLea 1gEcQJ0/eyifQCP3eRv2ypRrWpgYzlNErBRmRvDQsLR6GMBKqpEtUSFw/YdKSvPqTfHT27eu 24NJopO0tFwkC4gmqX7cK8r2aRgoZlRjVTQlH2FZeOVaTX3Qio4eZaJhllJq1wFSjEexzHVC 1KtwurC/iRXJa9sF5kVIicPMvNNuxnhGdCeLLyxVUCLXAQZLtN9BtHwyi8cTOimeQUE+Tu7x k/n1oKcAnlohsfXGWQdjEthwztmUQkHtfuR8POmQbs9ltRmlXdmVZyFdGOv+eXFPryjwcARi VY0XQ9qHUtXgdkqupkYuOYxZLZf90NVn//rNjn3WChDDjQ8wFftqCPasQES1TQ+ReR0mRCtV NKwoBA1zmRCbo0U0wwTRLoXq46XVi7la0zQJLjABTeEbcIeHkcPAg/vtr1NO/KToCdWOb4gb cgYJvdw6F8PFKKGXisX29WYPnTYsZsQM24RL+Xd4oKyDT4QMy4OUB5MRtd0U5qfttUf0hdP7 p3VwxoiusapUAc4GXVMYYDNs8gt1K+ILM26QeNeHYAHRE/FQ4LL3t64JfCurRfsatdDN9CF4 9HfCGCHpbIivt/dmwJ1uZS3xdmsov3wqiMZuZ/T7tq7Qxc0P6PUwLXj19PLleLjK3w+fd6c2 QA3VVcwC3UQlpQLFVYjGwrymMaQUpDCO1dPEReKCDoEUgyo/JkKwCo0bRUl9K3lniGZSbPbS THWEXCtkv0QMM/NLdKi6XhAZ8UzTviNuFesHolzAH7OMoelBmiukQekHgSzrMNU0vA5tsu18 tGgihkaHBP1W9Vsrw7azifhN557bYdX6xgg2f0t15E2mln/bf31RD9mla6111a/eepgWmcq6 +hviuWFt0Fi2FVVg9ndQfkAhs3d9mI0W14bdpcjjoHokOtPbbVR1YSqD4PLOBOUzam/uLU1K u80lnwLXSq4JwiTHHqjLhQ9dEJ7Pp6fTj6vT8f28fzG1pTARFcPkJ5YRvzen93jKNUJ2wnRS be9ZuajyqHzEdHFZ+3KMIElZ7sHmTDS1SMy7zhaFbwbx6kFdkgzxmP4oKazLkxblBRvrG0eN j86irNxGa+WhU7GlQ4HmfEzh0r7XTGwVPAKtGHiHBRpf2xSd9mPAElE3dikrrpDUp4z7KmM7 SwxsRxY++tQNg4Q+YSVBUD2o9e+UDBPa6hE5GlNExwhIk/CCshlZYYuCOka7L86zst62X4q+ AgzyuMj+r68rSnIQhKF32tkLoFDLDgqFdqbjD/e/xeZF1yYK+9kEpWCTYN9LIjamMcNK08MH 6tDI0kvApEjJ02rgAVLrWvLvpvy9QixXtUkQ05vL2NWcHd7Jtt6HeNM5k+960ylk8VE/76/m i9c+Ak1BxvNS6jD+XGSnzq/HPtRp9ampGEjx1dTQTl5Nk3lCujNGdmA4xhDVEUxKcVdpbYNM IVCYsLjeWP/ecGI26ZitNGlTShw9+Tt2jNkojkyBY5EZ75sIyNQJ9QcIqFs6AWhdUEModmr+ /3UW7qQDM8GTYtG0GFDUhLNIrxmE1ni7MT1CaWpW38s+pA8PUb2w4/N/trUEpIKK24cVDTCE gPZS0m6tlZWS8gP/yoj556TbTqEMQXYTxcqszmAFvNLQqyGOOgtNetzhvgs2z3jxGzpUCTCt QhQ+ePGW3l0ZwuQ84MYg7i17Ajn5IViXJEuHovTs6kLGuLFAfgHes+GNHnoBAA== --8t9RHnE3ZwKMSgU+-- -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org