From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B8A84C388F7 for ; Mon, 9 Nov 2020 12:08:55 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id CAC0B207BC for ; Mon, 9 Nov 2020 12:08:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CAC0B207BC Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 38A5C6B0068; Mon, 9 Nov 2020 07:08:54 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 339B16B006C; Mon, 9 Nov 2020 07:08:54 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1DC426B006E; Mon, 9 Nov 2020 07:08:54 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0087.hostedemail.com [216.40.44.87]) by kanga.kvack.org (Postfix) with ESMTP id B812F6B0068 for ; Mon, 9 Nov 2020 07:08:53 -0500 (EST) Received: from smtpin06.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with ESMTP id 422C3180AD807 for ; Mon, 9 Nov 2020 12:08:53 +0000 (UTC) X-FDA: 77464758546.06.thumb93_290ea21272ec Received: from filter.hostedemail.com (10.5.16.251.rfc1918.com [10.5.16.251]) by smtpin06.hostedemail.com (Postfix) with ESMTP id 2053B1003800C for ; Mon, 9 Nov 2020 12:08:53 +0000 (UTC) X-HE-Tag: thumb93_290ea21272ec X-Filterd-Recvd-Size: 118306 Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by imf13.hostedemail.com (Postfix) with ESMTP for ; Mon, 9 Nov 2020 12:08:51 +0000 (UTC) IronPort-SDR: 0kwrAoJwwPE9GqUpR4ItAGAxitz7705ToT+0HNNKOahnmaJb4VsWcsLwBocFjktWCo0BGm4XMQ on7EMeHflu/Q== X-IronPort-AV: E=McAfee;i="6000,8403,9799"; a="166279273" X-IronPort-AV: E=Sophos;i="5.77,463,1596524400"; d="gz'50?scan'50,208,50";a="166279273" X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga007.fm.intel.com ([10.253.24.52]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Nov 2020 04:08:49 -0800 IronPort-SDR: 4eYD7vkPtMo/kVfnuvMQSZpadXOvr1KQQhMjR3N5oOFHATMLE6VurnxHg6xXAvFA7nV5z2SXBo bhtMs4LVoXNA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.77,463,1596524400"; d="gz'50?scan'50,208,50";a="307960902" Received: from lkp-server01.sh.intel.com (HELO d0be80f1a028) ([10.239.97.150]) by fmsmga007.fm.intel.com with ESMTP; 09 Nov 2020 04:08:46 -0800 Received: from kbuild by d0be80f1a028 with local (Exim 4.92) (envelope-from ) id 1kc5yX-00009V-O2; Mon, 09 Nov 2020 12:08:45 +0000 Date: Mon, 9 Nov 2020 20:07:42 +0800 From: kernel test robot To: Luben Tuikov Cc: kbuild-all@lists.01.org, Linux Memory Management List , Daniel Vetter Subject: [linux-next:master 3872/4770] drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c:482:5: warning: no previous prototype for 'amdgpu_info_ioctl' Message-ID: <202011092023.l9hvrGQn-lkp@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="pf9I7BMVVzbSWLtt" Content-Disposition: inline User-Agent: Mutt/1.10.1 (2018-07-13) X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: --pf9I7BMVVzbSWLtt Content-Type: text/plain; charset=us-ascii Content-Disposition: inline tree: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master head: 2ad4382198191b634e69a370d041928484ef0bf8 commit: 5088d6572e8ff6c25433858a4e701aa0fd9364c0 [3872/4770] drm/amdgpu: Make struct drm_driver const config: alpha-allyesconfig (attached as .config) compiler: alpha-linux-gcc (GCC) 9.3.0 reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/commit/?id=5088d6572e8ff6c25433858a4e701aa0fd9364c0 git remote add linux-next https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git git fetch --no-tags linux-next master git checkout 5088d6572e8ff6c25433858a4e701aa0fd9364c0 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=alpha If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): >> drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c:482:5: warning: no previous prototype for 'amdgpu_info_ioctl' [-Wmissing-prototypes] 482 | int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) | ^~~~~~~~~~~~~~~~~ In file included from drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c:29: drivers/gpu/drm/amd/amdgpu/amdgpu.h:198:19: warning: 'no_system_mem_limit' defined but not used [-Wunused-const-variable=] 198 | static const bool no_system_mem_limit; | ^~~~~~~~~~~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/amdgpu.h:197:19: warning: 'debug_evictions' defined but not used [-Wunused-const-variable=] 197 | static const bool debug_evictions; /* = false */ | ^~~~~~~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/amdgpu.h:196:18: warning: 'sched_policy' defined but not used [-Wunused-const-variable=] 196 | static const int sched_policy = KFD_SCHED_POLICY_HWS; | ^~~~~~~~~~~~ In file included from drivers/gpu/drm/amd/amdgpu/../display/dc/dc_types.h:33, from drivers/gpu/drm/amd/amdgpu/../display/dc/dm_services_types.h:30, from drivers/gpu/drm/amd/amdgpu/../include/dm_pp_interface.h:26, from drivers/gpu/drm/amd/amdgpu/amdgpu.h:67, from drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c:29: drivers/gpu/drm/amd/amdgpu/../display/include/fixed31_32.h:76:32: warning: 'dc_fixpt_ln2_div_2' defined but not used [-Wunused-const-variable=] 76 | static const struct fixed31_32 dc_fixpt_ln2_div_2 = { 1488522236LL }; | ^~~~~~~~~~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/../display/include/fixed31_32.h:75:32: warning: 'dc_fixpt_ln2' defined but not used [-Wunused-const-variable=] 75 | static const struct fixed31_32 dc_fixpt_ln2 = { 2977044471LL }; | ^~~~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/../display/include/fixed31_32.h:74:32: warning: 'dc_fixpt_e' defined but not used [-Wunused-const-variable=] 74 | static const struct fixed31_32 dc_fixpt_e = { 11674931555LL }; | ^~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/../display/include/fixed31_32.h:73:32: warning: 'dc_fixpt_two_pi' defined but not used [-Wunused-const-variable=] 73 | static const struct fixed31_32 dc_fixpt_two_pi = { 26986075409LL }; | ^~~~~~~~~~~~~~~ drivers/gpu/drm/amd/amdgpu/../display/include/fixed31_32.h:72:32: warning: 'dc_fixpt_pi' defined but not used [-Wunused-const-variable=] 72 | static const struct fixed31_32 dc_fixpt_pi = { 13493037705LL }; | ^~~~~~~~~~~ vim +/amdgpu_info_ioctl +482 drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c 466 467 /* 468 * Userspace get information ioctl 469 */ 470 /** 471 * amdgpu_info_ioctl - answer a device specific request. 472 * 473 * @adev: amdgpu device pointer 474 * @data: request object 475 * @filp: drm filp 476 * 477 * This function is used to pass device specific parameters to the userspace 478 * drivers. Examples include: pci device id, pipeline parms, tiling params, 479 * etc. (all asics). 480 * Returns 0 on success, -EINVAL on failure. 481 */ > 482 int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) 483 { 484 struct amdgpu_device *adev = drm_to_adev(dev); 485 struct drm_amdgpu_info *info = data; 486 struct amdgpu_mode_info *minfo = &adev->mode_info; 487 void __user *out = (void __user *)(uintptr_t)info->return_pointer; 488 uint32_t size = info->return_size; 489 struct drm_crtc *crtc; 490 uint32_t ui32 = 0; 491 uint64_t ui64 = 0; 492 int i, found; 493 int ui32_size = sizeof(ui32); 494 495 if (!info->return_size || !info->return_pointer) 496 return -EINVAL; 497 498 switch (info->query) { 499 case AMDGPU_INFO_ACCEL_WORKING: 500 ui32 = adev->accel_working; 501 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 502 case AMDGPU_INFO_CRTC_FROM_ID: 503 for (i = 0, found = 0; i < adev->mode_info.num_crtc; i++) { 504 crtc = (struct drm_crtc *)minfo->crtcs[i]; 505 if (crtc && crtc->base.id == info->mode_crtc.id) { 506 struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc); 507 ui32 = amdgpu_crtc->crtc_id; 508 found = 1; 509 break; 510 } 511 } 512 if (!found) { 513 DRM_DEBUG_KMS("unknown crtc id %d\n", info->mode_crtc.id); 514 return -EINVAL; 515 } 516 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 517 case AMDGPU_INFO_HW_IP_INFO: { 518 struct drm_amdgpu_info_hw_ip ip = {}; 519 int ret; 520 521 ret = amdgpu_hw_ip_info(adev, info, &ip); 522 if (ret) 523 return ret; 524 525 ret = copy_to_user(out, &ip, min((size_t)size, sizeof(ip))); 526 return ret ? -EFAULT : 0; 527 } 528 case AMDGPU_INFO_HW_IP_COUNT: { 529 enum amd_ip_block_type type; 530 uint32_t count = 0; 531 532 switch (info->query_hw_ip.type) { 533 case AMDGPU_HW_IP_GFX: 534 type = AMD_IP_BLOCK_TYPE_GFX; 535 break; 536 case AMDGPU_HW_IP_COMPUTE: 537 type = AMD_IP_BLOCK_TYPE_GFX; 538 break; 539 case AMDGPU_HW_IP_DMA: 540 type = AMD_IP_BLOCK_TYPE_SDMA; 541 break; 542 case AMDGPU_HW_IP_UVD: 543 type = AMD_IP_BLOCK_TYPE_UVD; 544 break; 545 case AMDGPU_HW_IP_VCE: 546 type = AMD_IP_BLOCK_TYPE_VCE; 547 break; 548 case AMDGPU_HW_IP_UVD_ENC: 549 type = AMD_IP_BLOCK_TYPE_UVD; 550 break; 551 case AMDGPU_HW_IP_VCN_DEC: 552 case AMDGPU_HW_IP_VCN_ENC: 553 type = AMD_IP_BLOCK_TYPE_VCN; 554 break; 555 case AMDGPU_HW_IP_VCN_JPEG: 556 type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ? 557 AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN; 558 break; 559 default: 560 return -EINVAL; 561 } 562 563 for (i = 0; i < adev->num_ip_blocks; i++) 564 if (adev->ip_blocks[i].version->type == type && 565 adev->ip_blocks[i].status.valid && 566 count < AMDGPU_HW_IP_INSTANCE_MAX_COUNT) 567 count++; 568 569 return copy_to_user(out, &count, min(size, 4u)) ? -EFAULT : 0; 570 } 571 case AMDGPU_INFO_TIMESTAMP: 572 ui64 = amdgpu_gfx_get_gpu_clock_counter(adev); 573 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 574 case AMDGPU_INFO_FW_VERSION: { 575 struct drm_amdgpu_info_firmware fw_info; 576 int ret; 577 578 /* We only support one instance of each IP block right now. */ 579 if (info->query_fw.ip_instance != 0) 580 return -EINVAL; 581 582 ret = amdgpu_firmware_info(&fw_info, &info->query_fw, adev); 583 if (ret) 584 return ret; 585 586 return copy_to_user(out, &fw_info, 587 min((size_t)size, sizeof(fw_info))) ? -EFAULT : 0; 588 } 589 case AMDGPU_INFO_NUM_BYTES_MOVED: 590 ui64 = atomic64_read(&adev->num_bytes_moved); 591 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 592 case AMDGPU_INFO_NUM_EVICTIONS: 593 ui64 = atomic64_read(&adev->num_evictions); 594 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 595 case AMDGPU_INFO_NUM_VRAM_CPU_PAGE_FAULTS: 596 ui64 = atomic64_read(&adev->num_vram_cpu_page_faults); 597 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 598 case AMDGPU_INFO_VRAM_USAGE: 599 ui64 = amdgpu_vram_mgr_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM)); 600 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 601 case AMDGPU_INFO_VIS_VRAM_USAGE: 602 ui64 = amdgpu_vram_mgr_vis_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM)); 603 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 604 case AMDGPU_INFO_GTT_USAGE: 605 ui64 = amdgpu_gtt_mgr_usage(ttm_manager_type(&adev->mman.bdev, TTM_PL_TT)); 606 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 607 case AMDGPU_INFO_GDS_CONFIG: { 608 struct drm_amdgpu_info_gds gds_info; 609 610 memset(&gds_info, 0, sizeof(gds_info)); 611 gds_info.compute_partition_size = adev->gds.gds_size; 612 gds_info.gds_total_size = adev->gds.gds_size; 613 gds_info.gws_per_compute_partition = adev->gds.gws_size; 614 gds_info.oa_per_compute_partition = adev->gds.oa_size; 615 return copy_to_user(out, &gds_info, 616 min((size_t)size, sizeof(gds_info))) ? -EFAULT : 0; 617 } 618 case AMDGPU_INFO_VRAM_GTT: { 619 struct drm_amdgpu_info_vram_gtt vram_gtt; 620 621 vram_gtt.vram_size = adev->gmc.real_vram_size - 622 atomic64_read(&adev->vram_pin_size) - 623 AMDGPU_VM_RESERVED_VRAM; 624 vram_gtt.vram_cpu_accessible_size = 625 min(adev->gmc.visible_vram_size - 626 atomic64_read(&adev->visible_pin_size), 627 vram_gtt.vram_size); 628 vram_gtt.gtt_size = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT)->size; 629 vram_gtt.gtt_size *= PAGE_SIZE; 630 vram_gtt.gtt_size -= atomic64_read(&adev->gart_pin_size); 631 return copy_to_user(out, &vram_gtt, 632 min((size_t)size, sizeof(vram_gtt))) ? -EFAULT : 0; 633 } 634 case AMDGPU_INFO_MEMORY: { 635 struct drm_amdgpu_memory_info mem; 636 struct ttm_resource_manager *vram_man = 637 ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM); 638 struct ttm_resource_manager *gtt_man = 639 ttm_manager_type(&adev->mman.bdev, TTM_PL_TT); 640 memset(&mem, 0, sizeof(mem)); 641 mem.vram.total_heap_size = adev->gmc.real_vram_size; 642 mem.vram.usable_heap_size = adev->gmc.real_vram_size - 643 atomic64_read(&adev->vram_pin_size) - 644 AMDGPU_VM_RESERVED_VRAM; 645 mem.vram.heap_usage = 646 amdgpu_vram_mgr_usage(vram_man); 647 mem.vram.max_allocation = mem.vram.usable_heap_size * 3 / 4; 648 649 mem.cpu_accessible_vram.total_heap_size = 650 adev->gmc.visible_vram_size; 651 mem.cpu_accessible_vram.usable_heap_size = 652 min(adev->gmc.visible_vram_size - 653 atomic64_read(&adev->visible_pin_size), 654 mem.vram.usable_heap_size); 655 mem.cpu_accessible_vram.heap_usage = 656 amdgpu_vram_mgr_vis_usage(vram_man); 657 mem.cpu_accessible_vram.max_allocation = 658 mem.cpu_accessible_vram.usable_heap_size * 3 / 4; 659 660 mem.gtt.total_heap_size = gtt_man->size; 661 mem.gtt.total_heap_size *= PAGE_SIZE; 662 mem.gtt.usable_heap_size = mem.gtt.total_heap_size - 663 atomic64_read(&adev->gart_pin_size); 664 mem.gtt.heap_usage = 665 amdgpu_gtt_mgr_usage(gtt_man); 666 mem.gtt.max_allocation = mem.gtt.usable_heap_size * 3 / 4; 667 668 return copy_to_user(out, &mem, 669 min((size_t)size, sizeof(mem))) 670 ? -EFAULT : 0; 671 } 672 case AMDGPU_INFO_READ_MMR_REG: { 673 unsigned n, alloc_size; 674 uint32_t *regs; 675 unsigned se_num = (info->read_mmr_reg.instance >> 676 AMDGPU_INFO_MMR_SE_INDEX_SHIFT) & 677 AMDGPU_INFO_MMR_SE_INDEX_MASK; 678 unsigned sh_num = (info->read_mmr_reg.instance >> 679 AMDGPU_INFO_MMR_SH_INDEX_SHIFT) & 680 AMDGPU_INFO_MMR_SH_INDEX_MASK; 681 682 /* set full masks if the userspace set all bits 683 * in the bitfields */ 684 if (se_num == AMDGPU_INFO_MMR_SE_INDEX_MASK) 685 se_num = 0xffffffff; 686 else if (se_num >= AMDGPU_GFX_MAX_SE) 687 return -EINVAL; 688 if (sh_num == AMDGPU_INFO_MMR_SH_INDEX_MASK) 689 sh_num = 0xffffffff; 690 else if (sh_num >= AMDGPU_GFX_MAX_SH_PER_SE) 691 return -EINVAL; 692 693 if (info->read_mmr_reg.count > 128) 694 return -EINVAL; 695 696 regs = kmalloc_array(info->read_mmr_reg.count, sizeof(*regs), GFP_KERNEL); 697 if (!regs) 698 return -ENOMEM; 699 alloc_size = info->read_mmr_reg.count * sizeof(*regs); 700 701 amdgpu_gfx_off_ctrl(adev, false); 702 for (i = 0; i < info->read_mmr_reg.count; i++) { 703 if (amdgpu_asic_read_register(adev, se_num, sh_num, 704 info->read_mmr_reg.dword_offset + i, 705 ®s[i])) { 706 DRM_DEBUG_KMS("unallowed offset %#x\n", 707 info->read_mmr_reg.dword_offset + i); 708 kfree(regs); 709 amdgpu_gfx_off_ctrl(adev, true); 710 return -EFAULT; 711 } 712 } 713 amdgpu_gfx_off_ctrl(adev, true); 714 n = copy_to_user(out, regs, min(size, alloc_size)); 715 kfree(regs); 716 return n ? -EFAULT : 0; 717 } 718 case AMDGPU_INFO_DEV_INFO: { 719 struct drm_amdgpu_info_device dev_info; 720 uint64_t vm_size; 721 722 memset(&dev_info, 0, sizeof(dev_info)); 723 dev_info.device_id = dev->pdev->device; 724 dev_info.chip_rev = adev->rev_id; 725 dev_info.external_rev = adev->external_rev_id; 726 dev_info.pci_rev = dev->pdev->revision; 727 dev_info.family = adev->family; 728 dev_info.num_shader_engines = adev->gfx.config.max_shader_engines; 729 dev_info.num_shader_arrays_per_engine = adev->gfx.config.max_sh_per_se; 730 /* return all clocks in KHz */ 731 dev_info.gpu_counter_freq = amdgpu_asic_get_xclk(adev) * 10; 732 if (adev->pm.dpm_enabled) { 733 dev_info.max_engine_clock = amdgpu_dpm_get_sclk(adev, false) * 10; 734 dev_info.max_memory_clock = amdgpu_dpm_get_mclk(adev, false) * 10; 735 } else { 736 dev_info.max_engine_clock = adev->clock.default_sclk * 10; 737 dev_info.max_memory_clock = adev->clock.default_mclk * 10; 738 } 739 dev_info.enabled_rb_pipes_mask = adev->gfx.config.backend_enable_mask; 740 dev_info.num_rb_pipes = adev->gfx.config.max_backends_per_se * 741 adev->gfx.config.max_shader_engines; 742 dev_info.num_hw_gfx_contexts = adev->gfx.config.max_hw_contexts; 743 dev_info._pad = 0; 744 dev_info.ids_flags = 0; 745 if (adev->flags & AMD_IS_APU) 746 dev_info.ids_flags |= AMDGPU_IDS_FLAGS_FUSION; 747 if (amdgpu_mcbp || amdgpu_sriov_vf(adev)) 748 dev_info.ids_flags |= AMDGPU_IDS_FLAGS_PREEMPTION; 749 if (amdgpu_is_tmz(adev)) 750 dev_info.ids_flags |= AMDGPU_IDS_FLAGS_TMZ; 751 752 vm_size = adev->vm_manager.max_pfn * AMDGPU_GPU_PAGE_SIZE; 753 vm_size -= AMDGPU_VA_RESERVED_SIZE; 754 755 /* Older VCE FW versions are buggy and can handle only 40bits */ 756 if (adev->vce.fw_version && 757 adev->vce.fw_version < AMDGPU_VCE_FW_53_45) 758 vm_size = min(vm_size, 1ULL << 40); 759 760 dev_info.virtual_address_offset = AMDGPU_VA_RESERVED_SIZE; 761 dev_info.virtual_address_max = 762 min(vm_size, AMDGPU_GMC_HOLE_START); 763 764 if (vm_size > AMDGPU_GMC_HOLE_START) { 765 dev_info.high_va_offset = AMDGPU_GMC_HOLE_END; 766 dev_info.high_va_max = AMDGPU_GMC_HOLE_END | vm_size; 767 } 768 dev_info.virtual_address_alignment = max((int)PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE); 769 dev_info.pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE; 770 dev_info.gart_page_size = AMDGPU_GPU_PAGE_SIZE; 771 dev_info.cu_active_number = adev->gfx.cu_info.number; 772 dev_info.cu_ao_mask = adev->gfx.cu_info.ao_cu_mask; 773 dev_info.ce_ram_size = adev->gfx.ce_ram_size; 774 memcpy(&dev_info.cu_ao_bitmap[0], &adev->gfx.cu_info.ao_cu_bitmap[0], 775 sizeof(adev->gfx.cu_info.ao_cu_bitmap)); 776 memcpy(&dev_info.cu_bitmap[0], &adev->gfx.cu_info.bitmap[0], 777 sizeof(adev->gfx.cu_info.bitmap)); 778 dev_info.vram_type = adev->gmc.vram_type; 779 dev_info.vram_bit_width = adev->gmc.vram_width; 780 dev_info.vce_harvest_config = adev->vce.harvest_config; 781 dev_info.gc_double_offchip_lds_buf = 782 adev->gfx.config.double_offchip_lds_buf; 783 dev_info.wave_front_size = adev->gfx.cu_info.wave_front_size; 784 dev_info.num_shader_visible_vgprs = adev->gfx.config.max_gprs; 785 dev_info.num_cu_per_sh = adev->gfx.config.max_cu_per_sh; 786 dev_info.num_tcc_blocks = adev->gfx.config.max_texture_channel_caches; 787 dev_info.gs_vgt_table_depth = adev->gfx.config.gs_vgt_table_depth; 788 dev_info.gs_prim_buffer_depth = adev->gfx.config.gs_prim_buffer_depth; 789 dev_info.max_gs_waves_per_vgt = adev->gfx.config.max_gs_threads; 790 791 if (adev->family >= AMDGPU_FAMILY_NV) 792 dev_info.pa_sc_tile_steering_override = 793 adev->gfx.config.pa_sc_tile_steering_override; 794 795 dev_info.tcc_disabled_mask = adev->gfx.config.tcc_disabled_mask; 796 797 return copy_to_user(out, &dev_info, 798 min((size_t)size, sizeof(dev_info))) ? -EFAULT : 0; 799 } 800 case AMDGPU_INFO_VCE_CLOCK_TABLE: { 801 unsigned i; 802 struct drm_amdgpu_info_vce_clock_table vce_clk_table = {}; 803 struct amd_vce_state *vce_state; 804 805 for (i = 0; i < AMDGPU_VCE_CLOCK_TABLE_ENTRIES; i++) { 806 vce_state = amdgpu_dpm_get_vce_clock_state(adev, i); 807 if (vce_state) { 808 vce_clk_table.entries[i].sclk = vce_state->sclk; 809 vce_clk_table.entries[i].mclk = vce_state->mclk; 810 vce_clk_table.entries[i].eclk = vce_state->evclk; 811 vce_clk_table.num_valid_entries++; 812 } 813 } 814 815 return copy_to_user(out, &vce_clk_table, 816 min((size_t)size, sizeof(vce_clk_table))) ? -EFAULT : 0; 817 } 818 case AMDGPU_INFO_VBIOS: { 819 uint32_t bios_size = adev->bios_size; 820 821 switch (info->vbios_info.type) { 822 case AMDGPU_INFO_VBIOS_SIZE: 823 return copy_to_user(out, &bios_size, 824 min((size_t)size, sizeof(bios_size))) 825 ? -EFAULT : 0; 826 case AMDGPU_INFO_VBIOS_IMAGE: { 827 uint8_t *bios; 828 uint32_t bios_offset = info->vbios_info.offset; 829 830 if (bios_offset >= bios_size) 831 return -EINVAL; 832 833 bios = adev->bios + bios_offset; 834 return copy_to_user(out, bios, 835 min((size_t)size, (size_t)(bios_size - bios_offset))) 836 ? -EFAULT : 0; 837 } 838 default: 839 DRM_DEBUG_KMS("Invalid request %d\n", 840 info->vbios_info.type); 841 return -EINVAL; 842 } 843 } 844 case AMDGPU_INFO_NUM_HANDLES: { 845 struct drm_amdgpu_info_num_handles handle; 846 847 switch (info->query_hw_ip.type) { 848 case AMDGPU_HW_IP_UVD: 849 /* Starting Polaris, we support unlimited UVD handles */ 850 if (adev->asic_type < CHIP_POLARIS10) { 851 handle.uvd_max_handles = adev->uvd.max_handles; 852 handle.uvd_used_handles = amdgpu_uvd_used_handles(adev); 853 854 return copy_to_user(out, &handle, 855 min((size_t)size, sizeof(handle))) ? -EFAULT : 0; 856 } else { 857 return -ENODATA; 858 } 859 860 break; 861 default: 862 return -EINVAL; 863 } 864 } 865 case AMDGPU_INFO_SENSOR: { 866 if (!adev->pm.dpm_enabled) 867 return -ENOENT; 868 869 switch (info->sensor_info.type) { 870 case AMDGPU_INFO_SENSOR_GFX_SCLK: 871 /* get sclk in Mhz */ 872 if (amdgpu_dpm_read_sensor(adev, 873 AMDGPU_PP_SENSOR_GFX_SCLK, 874 (void *)&ui32, &ui32_size)) { 875 return -EINVAL; 876 } 877 ui32 /= 100; 878 break; 879 case AMDGPU_INFO_SENSOR_GFX_MCLK: 880 /* get mclk in Mhz */ 881 if (amdgpu_dpm_read_sensor(adev, 882 AMDGPU_PP_SENSOR_GFX_MCLK, 883 (void *)&ui32, &ui32_size)) { 884 return -EINVAL; 885 } 886 ui32 /= 100; 887 break; 888 case AMDGPU_INFO_SENSOR_GPU_TEMP: 889 /* get temperature in millidegrees C */ 890 if (amdgpu_dpm_read_sensor(adev, 891 AMDGPU_PP_SENSOR_GPU_TEMP, 892 (void *)&ui32, &ui32_size)) { 893 return -EINVAL; 894 } 895 break; 896 case AMDGPU_INFO_SENSOR_GPU_LOAD: 897 /* get GPU load */ 898 if (amdgpu_dpm_read_sensor(adev, 899 AMDGPU_PP_SENSOR_GPU_LOAD, 900 (void *)&ui32, &ui32_size)) { 901 return -EINVAL; 902 } 903 break; 904 case AMDGPU_INFO_SENSOR_GPU_AVG_POWER: 905 /* get average GPU power */ 906 if (amdgpu_dpm_read_sensor(adev, 907 AMDGPU_PP_SENSOR_GPU_POWER, 908 (void *)&ui32, &ui32_size)) { 909 return -EINVAL; 910 } 911 ui32 >>= 8; 912 break; 913 case AMDGPU_INFO_SENSOR_VDDNB: 914 /* get VDDNB in millivolts */ 915 if (amdgpu_dpm_read_sensor(adev, 916 AMDGPU_PP_SENSOR_VDDNB, 917 (void *)&ui32, &ui32_size)) { 918 return -EINVAL; 919 } 920 break; 921 case AMDGPU_INFO_SENSOR_VDDGFX: 922 /* get VDDGFX in millivolts */ 923 if (amdgpu_dpm_read_sensor(adev, 924 AMDGPU_PP_SENSOR_VDDGFX, 925 (void *)&ui32, &ui32_size)) { 926 return -EINVAL; 927 } 928 break; 929 case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_SCLK: 930 /* get stable pstate sclk in Mhz */ 931 if (amdgpu_dpm_read_sensor(adev, 932 AMDGPU_PP_SENSOR_STABLE_PSTATE_SCLK, 933 (void *)&ui32, &ui32_size)) { 934 return -EINVAL; 935 } 936 ui32 /= 100; 937 break; 938 case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_MCLK: 939 /* get stable pstate mclk in Mhz */ 940 if (amdgpu_dpm_read_sensor(adev, 941 AMDGPU_PP_SENSOR_STABLE_PSTATE_MCLK, 942 (void *)&ui32, &ui32_size)) { 943 return -EINVAL; 944 } 945 ui32 /= 100; 946 break; 947 default: 948 DRM_DEBUG_KMS("Invalid request %d\n", 949 info->sensor_info.type); 950 return -EINVAL; 951 } 952 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 953 } 954 case AMDGPU_INFO_VRAM_LOST_COUNTER: 955 ui32 = atomic_read(&adev->vram_lost_counter); 956 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 957 case AMDGPU_INFO_RAS_ENABLED_FEATURES: { 958 struct amdgpu_ras *ras = amdgpu_ras_get_context(adev); 959 uint64_t ras_mask; 960 961 if (!ras) 962 return -EINVAL; 963 ras_mask = (uint64_t)ras->supported << 32 | ras->features; 964 965 return copy_to_user(out, &ras_mask, 966 min_t(u64, size, sizeof(ras_mask))) ? 967 -EFAULT : 0; 968 } 969 default: 970 DRM_DEBUG_KMS("Invalid request %d\n", info->query); 971 return -EINVAL; 972 } 973 return 0; 974 } 975 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --pf9I7BMVVzbSWLtt Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICOUVqV8AAy5jb25maWcAlFxLd9s4st73r9BJNjOL7vGrddP3Hi9AEpTQ4isAKFnZ8CiO kvi0Y+fY8sxkfv2tAl8oAKQz2cT8vgIIFIBCVQHU21/eLtjL6fHb4XR3e7i//7H4cnw4Ph1O x0+Lz3f3x/9bJOWiKPWCJ0L/BsLZ3cPLv/9xuP/+9bD4/bfzs9/Ofn26vVhsjk8Px/tF/Pjw +e7LC5S/e3z45e0vcVmkYtXEcbPlUomyaDS/0ddvTPlf77GuX7/c3i7+torjvy/++O3yt7M3 ViGhGiCuf/TQaqzo+o+zy7OznsiSAb+4vDoz/4Z6MlasBvrMqn7NVMNU3qxKXY4vsQhRZKLg FlUWSss61qVUIyrk+2ZXyg0g0OW3i5XR4P3i+Xh6+T4qQRRCN7zYNkxCg0Uu9PXlxVhzXomM g3qUHmvOyphlfcvfDJqJagEdVizTFpjwlNWZNq8JwOtS6YLl/PrN3x4eH45/HwTUjlXjG9Ve bUUVewD+H+tsxKtSiZsmf1/zmodRr8iO6XjdOCViWSrV5Dwv5b5hWrN4PZK14pmIxmdWwywc H9dsy0GbUKkh8H0syxzxETWDA4O1eH75+Pzj+XT8Ng7OihdcitiMZSXLyGqhTal1ubPr16WB WZqi2vfhQqL4k8cahzBIx2tR0cmUlDkTBcWUyENCzVpwiSrYUzZlSvNSjDQoq0gybs/bvhG5 ElhmkvDaY7c+4VG9SrHWt4vjw6fF42dHxW6hGCb1hm95oVU/Jvru2/HpOTQsWsSbpiw46N0a 96Js1h9wyeRGp28X/Xz40FTwjjIR8eLuefHweMI1SEsJUIJTkzWhxGrdSK7gvXmrqqFTXhuH KS85zysNVdmWokfjsi5038+4qv+hD89/LU5Q2eIAFT+fDqfnxeH29vHl4XT38MXpORRoWGzq EMVqrD1SCc7SmMPSAV5PM832ciQ1UxulmVYUgjHM2N6pyBA3AUyUwSZVSpCHwfAkQrEo44mt zJ9QxGAfQAVClRnrFpBRpIzrhQrMFlB6A9zYEHho+A1MCqsXikiYMg6EajJFuzkboDyoTngI 15LFgTbBKGTZOIMtpuAcTDtfxVEm7K0AuZQVZa2vl1c+2GScpdcXlFDaneDmDWUcoVonmwor gCVNHtkjRjVON6JIFBeWjsSm/cNHzMy04TW8iJikrMRKU7CzItXX5/9j4zgTcnZj8xfjchOF 3sCWmHK3jst2yqjbr8dPL/fHp8Xn4+H08nR8NnDXvQDruANQ//nFO2vfWsmyrqymV2zF2+XO 5YjCxhavnEdny22xDfxnLeNs073BfWOzk0LziMUbj1Hx2iyzDk2ZkE2QiVPVRLAd7ESird1W 6gnxFq1EojxQJjnzwBTW1AdbCzB0ittmBycCVtgxXg0J34qYezBIU4vUN43L1AOjysfMbmWZ gjLeDBTTVk/QVVIVLAir0bVWTWH7feAW2c/QE0kA7KD9XHBNnkHN8aYqYWrhpgNOpdVjMwbG w3CmAfgzMHwJhx0mZtoeJ5dpthfW4KKNpxMMlGy8RWnVYZ5ZDvWospYwBKMnKZNm9cF2VQCI ALggSPbBnhAA3Hxw+NJ5viLPH5S2mhOVJe6h1JzAiiwr2KHFB96kpTSjX8qcFWbGDN6AK6bg j4Bb4HqpxqmsYlVtoGbYdrBqq0H2pHJ3lhz2O4GzwBqTFdc5bpuec9qOlgenrZ/mutSDQ0IM ntUue1rzLAWl2bNpuj9MgXZq0oIaYjTnEaayVX1Vko6IVcGy1Bo101gbMO6eDag1MXdMWJMC HIxaEt+CJVuheK8rSwtQScSkFLbGNyiyz5WPNETRA2pUgMtDiy0nI+2PDg5uXsJWn0gQlpQw /g7pdh7xJLGXaDu5QLQZPOB+hBCEWpptDm+0t8kqPj+76j2fLs6ujk+fH5++HR5ujwv+z+MD +E4MdrIYvSdwU0eXKPguYwVDbxz2w598TV/hNm/f0e9/1rtUVkee2UWs2wrNKrCdIIyEmW4i E08Pi1llLAotXqiJipVhMYYvlLBDd26p3RjgcMdCf6uRsPrKfIpdM5mAS0gmcp2mELeb3d+o kYEdd7qKnkvFpBaMrn/Nc7PtYHJCpCJmNEiETTIVWbsShpGhyYVhhWTV2jK7y6vIjpPz3HL2 hjiMQWgtYZ9o3f9R4AMEMg3Z1od4TzFKVCuNvj04n1sO6/JyaA4G3iYy7+etMo6jmxIxzba8 7GEcW4JlYMXs4XT4m2yGhK1jcz7Dsy2DEAb24BmZmEUQTmZcz8gk1cXyaobn0fkr/PKqmm8G iCxfoas5Xqz4nBqzm/kWZvviZobOmYTRnxMQMMdn+Q1TcwIFuEEiq9WcSIke27waixJcZ7bh MyJga2dVUV1sZljJdmuRzNUvwVoIVsxJvDIY6jUeF+QcDzZsrg+gICbnBkODDuc6sIOQMBUy 5GqB/bC2+daYNMx2LXpLs97BpF1bJqxb07Lc8MLkndCpGuntimGG09q+TVowZ/ven2vSxM5q 5pYfW0gThljZWFM4EQoetVjBTtXwAvXqtmenRUHyUglXXdw5hK5g2yNoWZMbb99qMsFxCzwn mazLi6CSgZkYf2AgQp2iLn5fBkYEy5xdXF3/cKo5OwsKX6PwoEOJatnamxOx8oO3Uef53qTO S6NBkiM/PN1+vTsdbzHm/vXT8TtUBG7G4vE7HiBYfkwsmVo7Ti0Ejk1quRplu2FaEmbsfbif ZTALTD6w0WtMeTjl8AAAfL0u/a7IdtqsmF5jtFeix7By550pX+SiTUjEeXUTr1eOzA62HxNC gmeATliX5adt2AoIymkWEFvvSEEr2zpVxWN0JKy2lkmdwaREPw/DAvRz6RqMakXXYJkkmAoA t545WesSTx3EStXwnsJOELQu2+UFeB3G+Xe6Clrq8qEkJYA4B3sYC3Qd05TkgWBJWC7lkCpe xeX214+H5+OnxV+tj/r96fHz3T3JnaJQs+Gy4BlxnebKuv7VKxNziFg1RH0QINl5AhNQKHSq x9OmdhxQe42JVbU3RC6AcjFms+yJ2VF1EYTbEgM5LGlrFgfNQ984GfendND2gAEYO+G9uuuY nbOxGBJDWThsRudOQy3q4iJs6Byp38O+EZW6fPczdf1+fjHbbcwErq/fPH89nL9xWFwDkit/ GHuiT564rx74mw/T78bIYgeOklJoAYbkVCPyqpR2aFcXsNJhle7zqMy8xqg23Z2Ba2ynlCJc bjQ3hIdaGM04yxkpFSsBduR9TY4qx4xlI3d4yODnmiK1CoLkiG9MTGm+kuRMzaMafX7m0xi/ JD4MNr7UOqPnKB4Hutk5ncoTPARuzbSk3C4Ka0DgeQUv4v0EG5eu6qCmJn/vtgzDdNss2mio nzj0ZWVHmYi2p9iwV8dyX1GLHqSbFIa+yzAbo1sdnk53aPcW+sf3o51dwKDWFGHJFvNvVnsY bNbFKDFJNHGds4JN85yr8maaFrGaJlmSzrBVueNS83haQoIPKOyXi5tQl0qVBnuawx4aJDST IkTkLA7CKilViMDjPvBTNxmLuG1iRQENVXUUKIJnadCt5ubdMlRjDSV3TPJQtVmSh4og7GZ4 VsHu1ZmWYQ2qOjhXIBbJgxrkafAFeFth+S7EWMt4oIZN353g9vLI30P0IOiSAQw9M5O1bG8V lOMRkrU+QE6UbSY/AQeTXiaxyM0+sk1LD0epbRHS901vP5wDGqScA47xMJ60bFy49LiDqeKc zIHWJqhKFMafsLeH8XTHdJ3/+3j7cjp8vD+aC0MLkzA8WUqIRJHmGr1Pa/iylPry+ISRQjWc G6O36p0PdnWpWIrKuwiCZ6OuJAVhnV513qonyfN3Sw+EHTemjcQ22vqd6r7RTX789vj0Y5Ef Hg5fjt+CgY0dZVo6hv3DhJOYJgWrYEereEBsThoqcAxMyGnNqfYejX1g3q+MKgPnvNLGszbh 7pVTKMINnxiXFmgV5oQCIczkQCVHj4TssmAFJXOLY5cbN9O93kMskiSy0W4KM4IowHYuTWCk S4xeaGBWlBoiIHIgoCzF9rMrB52imTSvu746+2M5NC3jsJMxWGH2lIf20lPbmJx7gpFyLOAA 2RsQgmBbmRrTAx+6age30ACDV1jK8SIFx1kRyqtMFmkP216v+t1VONkwU3HYnZ4rsI7/uyJ4 EvhfdPb6zf1/Ht9QqQ9VWWZjhVGd+OpwZC5TiHJnGuqIq/bsZLKdRPz6zX8+vnxy2thXZS8P U8p6bBveP5kmWs/KPTHqkSE/D5O9IktykKCeukmGmGWMl0E2pMg6B0MkpLRPN1KJSdctj8mZ R8UlRvfOTaMVHsmDk7nOWXe001nQaSM5mjw7ycbxjuOKxloI8gAG9lpIbt8YUJuo4TfgnPdJ HWOoi+PpX49Pf909fPEtNNi5jd2A9hkMN7O0g24TfYJNKncQWkTb8Rk8eJceENOlBdyk9tEt PjVlmtJUgEFZtiodiB5LGwjjKJmy2HkD+o3gGmfCDl8M0RpyTxzGWShN/PC2FWsHgKDVbUKF C5mO2YbvPWDi1RwdFB3btSaVudVBbptYoDMGgkwtUbUba8wURfvopgEfi1zvAS4VEawWwd35 3leGu7RZhZQzNXUSzL6FM3BdgjjAxBlTSiSEqYrKfW6SdeyDeKXCRyWTzjCISnjICp00ntc3 LtHouijsUGGQD1URSZiynpLzrnPOpbiBCQnPabgSucqb7XkItO6sqD16OOVGcOW2dasFheok 3NO0rD1g1Iqi842sCwOQddEj/tLuGWfKi7axdCEZ0KwRt72GCYL+0mjgRSEY9RCAJduFYIRg 2igtS2tlY9Xw5yqQOhioiNy97NG4DuM7eMWuLEMVrYnGRlhN4PvITpMP+JavmArg5hTEBfHq CD00Gqgs9NItL8oAvOf2fBlgkUGEVopQa5I43Ks4WYV0HEnbKerdkSh4h7pn+yHwiqGig97T IICqnZUwSn5FoihnBfqZMCtk1DQrAQqb5UF1s7x02unQ/RBcv7l9+Xh3+8Yemjz5naTZwRgt 6VO3F+HJShpiYO2lpUO09+Fwr24S17IsPbu09A3TctoyLSdM09K3TdiUXFRuhwQ5mjJFJy3Y 0kexCmKxDaKE9pFmSe48IlpgIG7Cab2vuEMG30U2N4OQbaBHwoVnNi5sYh1hot6F/X1wAF+p 0N/22vfw1bLJdsEWGg6c9TiEk2uQ7ZyrskBNMFJuarLyNy+DOTtHi9Fp32KbGj+kwg+l6IaN n2BB6+IuvrB240pXnc+U7v0i1XpvTjnAf8tplAQSqciIwzdAgW0rkiKB0Mku1X728fh0xAjj 89396fg09Y3cWHMouuko1KcoNiEqZbnI9l0jZgRcR4/W7HwF4vPO51u+QFaGNDjQpbJmToH3 VIvCBJsENff9HUewg6EiCJRCr8Cq+u9tAi9onIlhU/60sVk8aVETHN5kT6dI9+IlIXHOkeyk x5oZOcGbZeVUrbE1uoSdLa7CDHXILULFeqII+HqZ0HyiGSxnRcImyNStc2DWlxeXE5SQ8QQT CBsIDzMhEiW9o09HuZhUZ1VNtlWxYqr3SkwV0l7fdWDx2nB4Poz0mmdV2BL1EqushvCJVlAw 7zk0Zgi7LUbMHQzE3E4j5nUXQT/50hE5U2BGJEuChgQCMph5N3tSzN3VBsgJ4UfcsxMp6LLO ye0ZxGj7QA140u55OEbS/binBYui/ZiXwNQKIuDLoBooYjTmNJk5pbwtFrAy+pN4gYi5htpA JfnGxbzxT+5qoMU8xWrv5AQxcyOCKtA+zu+AQGU0mYVIm6JxeqacbmlvbujwjEnqKjgHpvB0 l4RxaL2Pt9Okza56M3DkQvP7ZpjLxju4MYdHz4vbx28f7x6OnxbfHvGw7jnkGdxodxOzKZyK M3T7nRV55+nw9OV4mnqVZnKF6Qr60XVIxFxhVHX+ilTIBfOl5nthSYV8PV/wlaYnKg76Q6PE OnuFf70RmFc3H8XMi2W2NxkUCPtWo8BMU6ghCZQt8EulV3RRpK82oUgnXURLqHR9voAQJnzJ HaOgkL/JBPUyt+OMcvDCVwRcQxOSkSSnHhL5qakLwU4eDgOIDAT1SkuzKZPF/e1wuv06Y0fw xxjw9JPGuwEhEuwFePdD1ZBIVquJOGqUAX+fF1MD2csURbTXfEoro5QTdk5JObtyWGpmqEah uQndSVX1LO+47QEBvn1d1TMGrRXgcTHPq/nyuOO/rrdpd3UUmR+fwNmQL+Lcvg7KbOdnS3ah 59+S8WJln9CERF7VB0mkBPlX5lib4Cnl/GuKdCqAH0SoSxXgd8UrA+ceDoZE1ns1EaaPMhv9 qu1xXVZfYn6X6GQ4y6ack14ifs32OCFyQMD1XwMimhxiTkiYDO0rUjKcqRpFZnePToTc7Q0I 1JeYMRx/tmMukdVXI6pGOYeqyuzAN9cXvy8dNBLoczTkB3AcxslA2iRdDR2H5ilUYYfTdUa5 ufrMrabJWpEtAr0eXur3wVCTBFQ2W+ccMcdNdxFIQS8DdKz58tUd0q1yHr0TCsScO1EtCOEP DqDCn+9oL0+ChV6cng4Pz98fn074Ucbp8fbxfnH/ePi0+Hi4Pzzc4sWM55fvyFs/qGWqa7NU 2jnpHog6mSCYs9PZ3CTB1mG8sw1jd577O5duc6V0a9j5UBZ7Qj5ET3cQKbepV1PkF0TMe2Xi 9Ux5SO7L8MSFivdEEWo9rQuYdcNkeGeVyWfK5G0ZUST8hs6gw/fv93e3xhgtvh7vv/tlU+0N a5HG7sRuKt7luLq6//cnkvcpnupJZg5DrB+0ALzdFXy8jSQCeJfWcvAxLeMRmNHwUZN1maic ngHQZIZbJFS7ScS7lSDmCU40uk0kFnmFH0sJP8fopWMRpEljGCvARRW4+QF4F96swzhxgW1C Vu6Bj81qnblEWHyITWlyjZB+0qqlSZxOSoSCWCLgRvBOY9xAue9ascqmauziNjFVaUCRfWDq 60qynQtBHFzTj3xaHOZWeFzZ1AgBMXZlvP0+s3i71f3P5c+t73EdL+mSGtbxMrTUXNxexw7R rTQH7dYxrZwuWMqFqpl6ab9oyc69nFpYy6mVZRG8FsurCQ4N5ASFSYwJap1NENju9guBCYF8 qpGhSWTTeoJQ0q8xkCXsmIl3TBoHmw1Zh2V4uS4Da2s5tbiWARNjvzdsY2yJwnx4Ya2wuQUU 3B+X/daa8PjhePqJ5QeChUktNivJojrrfmNlaMRrFfnL0jsmT3V/fp9z95CkI/yzkva35ryq yJklJfs7AmnDI3eBdRwQeNRJbnpYlPbmFSHJ2FrMu7OL5jLIsLwk30RajL3DW7iYgpdB3EmO WAwNxizCSw1YnNLh128zVkx1Q/Iq2wfJZEph2LYmTPlbqd28qQpJ5tzCnZx6FNrgaGqwvVUZ j3dm2tUEwCKORfI8tYy6ihoUuggEZwN5OQFPldGpjBvyGS9hvI/SJps6dqT7Bar14fYv8m1/ X3G4TqeUVYhmb/CpSaIVnpzGdt6nJfr7f+ZasLkEhRfyru0fmpqSw0/ag5cCJ0vgD8eGfrMK 5f0WTLHdp/T2DGnfSG5VSfsnHOGBxs0IOCOsyY9B4xPYR6iTxtUGN58Plw5IX890Th7Av7Rt SY/gD0OIOHeYjNzDQCSvSkaRSF4s312FMJgD7rqiiV988r/YMqj9G7oGEG45bueHiYFaESOa +xbVswliBWGRKsqSXkbrWLRy3Q4QoskL2p8hMYecNIf6/5xdWXPbuLL+K655uHXvQ060WF4e 8gBuEiJuJiiJnheWJ1ES1XHslO3MnPn3Bw1w6QaaytRNVWzz+0AQOxpAo5sF9NS4hmlifsdT orpdLuc8F1Rh5itsOQHOvAoDNDEpgkOs1cG9itBTk/mIJ5ms3vLEVv3OE1WdXrYTsRVhnBLT 1Ii7Cyde0lV4u5wteVJ9FPP5bMWTWqiQKW7Dpjk4lTZi7XqP2wMiMkJY+cp99m67pHgvST8g dVJRi3SLI9i3oizTmMJpXZLrtNh+Ljy1kbjHpgAMVsMRT04k1ohu6ulHMF+Al77NApVgKko0 NZWbgmT2Sq+lSiw6dIA/GPREvglZ0Fxy4BmQfenpJmY3RckTdGmGmawIZEqEe8xCzZHhAZNk 6O6JtSbiRq9joopPzvrcmzBacynFsfKFg0PQ9SEXwlWAjuMY2vPqksPaPO3+MIZaJZQ/to2B QrpHN4jymoeebd1v2tnW3sk3Iszdz+PPo5ZA3nd374kI04Vuw+DOi6Ld1AEDJir0UTKb9mBZ YVuqPWoOD5mvVY7GiQFVwiRBJczrdXyXMmiQ+GAYKB+MayZkLfg8rNnERsrX9wZc/46Z4omq iimdO/6LahvwRLgptrEP33FlFBaRe10MYDDZwDOh4OLmot5smOIrJfs2j7MXaU0s6W7N1RcT dLSo6l2ASe7O36+BAjgboi+lXwXSmTsbRNGUOKyWDJPC2MvHM5jlulx++O3Hl9OX5/bLw+vb b51a/+PD6+vpS3fkQLt3mDoFpQFvq7uD69AeZniEGewufTw5+Jg9qe2nTQu4ZtE71O8v5mNq X/LoFZMCYiWpRxk9IJtvR39oiMJRMzC42Wgj9sKAiQ3MYXBgHm6R7UZEhe7V4g43KkQsQ4oR 4c6e0EgYd0YcEYpcRiwjS+XeZx+Y2i8Q4ahzAGA1MGIfX5PQa2G1+AM/INzkd4dTwJXIypSJ 2EsagK5KoU1a7KqL2oilWxkG3QZ88NDVJrWpLt1+BSjd+OlRr9WZaDltLsvU9L4cSmFWMAUl E6aUrG62f4PdfoCrLrcd6mjNJ700doQ/H3UEO4rUYW/vgJkSJM5uFKJGEuUKHBIUKTFxHmh5 QxhLXxzW/zlB4qt9CI/IXtmI5yELZ/T2B47IldVdjmWM9fGRKfQadK8Xm2SoQSC9PoOJfUPa IHknzmNsV37vmSfY87YJBjgtipI6/LDGp7ioKMEtyc1VEfeundutANHr7oKG8ZcVBtVjA3Mn Psf6Axvlil2mcFwNsTZdwgkE6CAR6q6qK/rUqixyEJ0IB8k2zv39PMReiuCpLeIMbIO19vAD NbsKL06rxLhTwnlsyOLVWt+Cb9AeigjPaoNZYoM/G3XfUpcKARarjSOCuopF5tkghBjMUWC/ xY6NmVy8HV/fvIVHua3tFZhh49QL7hDYKMpQnyKrRDTaPysfPv37+HZRPXw+PQ8KPEj1WJD1 ODzprp8JMK+/pyNgha3vV9b+hfmEaP61WF08dYn9fPzz9Ol48fnl9Ce1uLaVWJy9Kkm/Ccq7 GOz2jojC7gX1g2sMH6C6amIt8eMR5F53rBbcvSRRw+IbBte1N2L3IsOVcDZ3Q2PCY4x+oKd+ AAR4lw2AtRPg4/x2eUshqYpReUkDF5H9euSWLQTee2nYNx6kUg8i3RmAUKQhaP7AhXQ8ogAn 6ts5RZI09j+zrjzoo8h/b6X+a0nx7V5ArZShjLGDDpPYXX4pKdSA1wX6vdKKdE4eJiDGzwri QudrYXh9PWMgai59hPnIZSLht5u7zE9idiaJlqv1j8tm1VCujMWWL8GPYj6bOVmIM+Vn1YJZ KJ2MJTfzq9l8qsr4ZEwkLmRx/5Nl2vixdDnxS74n+FKrlf7pJF8VSe017A5sw+H2F/Q3VcqL EzhU+fLw6ej0t41czudORWRhuVhNgF799zBcY7XbhaM6r//tIU07FUym6QZ2d3UAv259UEUA Lii6ZkJ21e3hWRgIHzXV6qE729ZJBp2M0DEJLOlaq1vKfc8ZBIehHIufcE4fRxVBqgRkLgZq a2LLWL+bx6UH6Pz65/sdZVVNGTbMahrTRkYOoMgjXuHpR2+L0wSJ6DuZSuhiFw7PPakbNIXT hHqxRWAbh1jRFDPWJYNpgMHjz+Pb8/Pbt8lpHrQN8hqLY1BIoVPuNeXJeQwUSiiDmjQiBBrX a56lexzA/dxAkBMmTLgJMoSKsLxo0Z2oag4D0YLMpIjaXLJwEKqSJUS9WXrpNEzqpdLAy4Os Ypbxq2L8uldGBmdKwuBMFdnErq+ahmWyau8XapgtZksvfFDqQdxHE6YJRHU696tqGXpYuotD UXktZL8hJoOZZALQenXvV4puTF4ojXkt5E6PMWRNZBNSmQXPMLJN9qxBNE/0kqTCp3Q94pxF jbDxbqwXqVjuHlhn7V01W3yrXgfb4hYyscwBFciK+kiAtpiSneseobsdh9hcjMYN10DUE6mB VHnvBZJYak3WcO6DT8DN+dLc2KIBr3B+WJhd4rQo9cx2EFWu537FBArjqh78f7VFvuMCgcV9 nUXjbg8sEcbrKGCCgaMP6/rCBoHNKC46nb9KjEHA7sDo6hF9VD/EabpLhV7TSGLMhAQCvyKN 0duo2FLoNtq5130ruUO5VJFeIu6cezkDfSA1TWA48SMvpTJwKq9HrN6Kfquc5EKykeyQ9VZy pNPwu0PDuY8Y77LYzMZAVCFYKIY+kfLsYMz4n4T68Nv309Pr28vxsf329psXMIvxfs0AUzFg gL06w/Go3oAs3Soi7+pw+Y4h88KaHmeo3mHSRMm2WZpNk6r2LDSPFVBPUuAqeYqTgfLUpQay nKayMj3D6Rlgmt0cMs+HLalB0Bv2Bl0aIlTTJWECnEl6HaXTpK1X3wMkqYPu1ltjvLGO7nEO Eu4H/k0euwiNb8EPN8MMkmwlFlDss9NOO1DmJban06Hr0t1Cvy3d59G8P4VdI99CJvSJCwEv O/sfMnFWL3G5oQqUPQKqUXrl4EbbszDc89v1eUKu1YAq3loS/QcAcyyndACY/fdBKnEAunHf VZvIaAh1u5APLxfJ6fgI/kK/f//51N/N+l8d9P86+QNbJ0hgpy25vr2eCSdamVEAhvY53nAA MMFLng5o5cIphDJfXV4yEBtyuWQgWnEjzEawYIotk2FVUH9jBPZjosJjj/gJsaj/QYDZSP2a VvVirn+7NdChfizgYt5rBgabCsu0rqZk2qEFmViWyaHKVyzIffN2ZbQk0K72P2qXfSQldyJK Dv98q4c9Qs8gI51/x6/AuiqMeIX95YJ/hr1IZQSuWRvXrIDlM+UoZ+jhhZoWM0bcqRX5RMi0 IENEXG9qME+fD4bJrP71xP6vUSeNyd6Y/wSbahwMA+pOaKG0wOqShjLurEasc9iI2oP1a0Yg 96GNikxI4nwdmprrvxl2CGH0IG4jNkUN6i7mDQhAgwtcYh3QLXoo3sYhFuNMUFVmPsJpzAyc 8UmkdBGw+iw0GMjG/yjw6CCd0YIxaY9KJ+ltWTtJb4MDLd1MSQ8wvjltXficcQbYO5dyqgoW Ny7mTHoAgSUH8Ftg/XGaTRqnyutdQBFzfOaCxFS7abKhoPkdrmhkO9qAWlnsnS9UTkGUwh70 kaownhb1wBCDdbmpeoAwE83DcOBQcrKyTYiJyuYCxtUCfnCuPscuwfeTcJJRm3KQAfTzxafn p7eX58fH44u/jWdqQlTRnqg7mBTaM5g2PziFn9T6J5n8AQWHcMKJoQpFxUDgJ9btuQbHC0CI E8J5B+gDMTqt9lPNZyV0xoK2gTgYyO9Y+2Wr4swFoevXxLGp+ZyA/WG3MCzox2zyUm92eQRn LXF2hvV6iC43PRmFG1lOwGxR91zsvmXuldSx2xDgfoCqne4LfonWylRMN2W9nr4+HR5ejqbN GUMlyrUXYQe6gxN/dOCSqVG3PUSVuG4aDvMj6AkvkzpeOEPi0YmEGMpNTdzc54UzhsmsuXJe V2UsqvnSTXcq7nXrCUUZT+F+d5BO24nNnqPbzvTIE4n2xq1FLZSWceimrkO5fPeUV4Jms5mc axt4KytnyolNkluv7Whho3BDmvFjfns5AXMJHDgvhbtclhvpig0D7L8giJvac23ZehV7/kOP o6dHoI/n2jrcEdjH0pF/BpjL1cB1rXT00jP9UXto+PD5+PTpaOlxzH/1zbaY74QiiolDL4xy Cespr/B6gulWmDoXJ9vBPl4v5jEDMZ3d4jHxC/fr8hicD/KT5DCBxk+ffzyfnmgJagEoKgvi fRyjrcUSV8jRslB3Nkc+P3xi+OjrX6e3T99+OXmrQ6fJZb1okkinoxhjoGcn7jm9fTYukNsQ u7qA16wI3yX43aeHl88Xf7ycPn/Fewr3cONjfM08tsXCRfQ8XmxcEHsSsAhMzSC/eSELtZEB Tnd0db1AWjbyZjG7XZDn5RVawdYhFSRMrkFvl7Q/yDRcFjUWwrCimiglOSHqgLZWUjdMHzee Dnpr08uZS3eiddW0ddM67oWHKDIojjXZqB0458hniHaXuSrwPQdOwXIfNs6N29DunZmarh5+ nD6DS0vbtrw2ibK+um6YD5WqbRgcwl/d8OG1SLbwmaoxzBK3+onUjQ7vT5+6VfVF4XoZ21lv 567ZRAK3xlPUeEyjC6bOStzJe0SP48QOvm4zeSTSgsiblY07kVVmPL4GO5kON5iS08v3v2AO Aitc2JRScjAdkpzP9ZDZdoh0RNjVpzlo6j+CUj++tTMac07OWRq7JvbCIRfcQ5W42ejfOojc 7Jpgn54dZX1t89wUahRJKkl2Vwb1kipWLmo0HuwLekmbFVgJUi/Y7wqF3FyggQJeE3aP375s R4nvfQD7Us/FzuvdmgUMkbb7XaofhLlESFxfKb26JtsjVbwmVoXscyvC22sPJPtvHaZSmTER 0n3AAct88DD3oCwjA1738erOj1D3g4gqLvRMiFXe+yiWTPpLvUjdY50eGP3URrdm09QTUuma SoxQ0VsBHprixAhgNV5+vvo74qLz0Qee74qqTYkqxbwll1oN0KCyy4qmxtdMQFZv40CioSzb SMd/qgV82wo4ecMcXOS56/ixgp0Zx+fFOlfOE2ixSHwQYcCs3vKEklXCM7ug8YisjshD5yjm u+vJ/MfDyyvVHNZhRXVtHEQrGkUQZld6CcVR2K20QxUJh1rdBr1U0yNlTZTwR7KuGopDYytV ysWnGyF49DtHWWMlxsWv8eT8bj4ZgV6kmP01vQ6PznwHtuGiIk+JOqFftqbId/pPvXowNu0v hA5ag6XHR7vnnj787VVCkG71oOlWgeODuiYHIu5TW2FrSJSvkoi+rlQSYSXwjNKmKslNdVNT qiZKJaaWiIPgrj6ts3Fw2SwU8glUiex9VWTvk8eHVy0jfzv9YHTZoX0lkkb5MY7i0JENAddj uysydu+bmy7g+avI3carybxwHRD3TKAlgvs6NtlidxL7gOlEQCfYOi6yuK7uaRpghA1Evm0P Mqo37fwsuzjLXp5lb85/9+osvVz4JSfnDMaFu2QwJzXEJecQCHY6iI7LUKNZpNxxDnAt5gkf 3dXSac8V3skzQOEAIlDWWsEo3E63WLsr8fDjB1wV6UBwhG5DPXzS04bbrAs4VGt6x8Ru59rc q8zrSxb0nJBgTue/qj/M/nMzM/+4IGmcf2AJqG1T2R8WHF0k/Cdh4vVKryeZLVpMr+NM5nKC K/Uiwzgnp2NMuFrMwsgpmzyuDeHMfGq1mjkY2ba3AF1zj1gr9GLzXi8knNqxG3D7Sg8dTuJg H6Wi91p+1SpM01HHxy/vYJ/gwThA0VFN3++Bz2ThauV0Pou1oJUkG5Zy1VY0E4laJClxYEPg 9lBJ64iXeC2hYbyum4WbcrHcLlbOkGK2YvX04lSAUvVi5fRPlXo9tNx4kP7vYvq5rYtapFa/ Bvu171gt86vYsvPFDY7OTLELKz/ZTfXT67/fFU/vQqivqUNhUxhFuMa25axHBL1UyT7ML320 /nA5NpBf173VJtHrV/pRQBzNTjOS5jEwLNjVpK1WPoR3rINJJTK1y9c86bWDnlg0MDGvveoz ZByGsIm2ERm9BjURQDcfJ23gc9fPMH41MLdZu+2Tv95r4ezh8fH4aIr04osdzcf9SaaQI52P VDIfsIQ/pmAyqhlOlyNctKsFwxV69FtM4F1epqhhB8MNACaECgbv5GqGCUUScwmvs5gLnolq H6cco9KwTctwuWga7r2zLBx9TdStXpJcXjdNzgxftkiaXCgGX+sF9lR7SfQKQyYhw+yTq/mM apSNWWg4VA+MSRq6crRtGGIvc7bJ1E1zm0eJ28QN9/H3y+ubGUNIsA4lQ2jtE69dzs6Qi1Uw 0arsFyfIxOuINtu7vOFyBidRq9klw9AztLFU8R0SVNbu0GTLjZ5+j6mps+Wi1eXJ9SfnGAy1 EMl1Ff/mG+orzlnO2F30ZCOGQ9rs9PqJDi/KNxo3vAs/iObfwDjb9WPDkmpb5PQ8miHtMonx 33oubGQ2Fme/DrqR6/Npa4OgZiYg2GXq+qUpLN1i9RT5VU+K/gkaHuGxsMW9M6i9wQRqYk5L nZuL/7G/Fxda2Lv4fvz+/PI3L22ZYDStd2AqY1htDp/4dcRehl0JsgONWuulccuql9l4cxL2 4rQgFUd0JgTcnvYmDgp6hPq3u4zeBT7QHtK23uiK3hR6FnFkJxMgiIPuqv1i5nJgPshbtAAB bjm5rzlbGgBv7su4orppQRbq6fIKWxuLapRHvC4pEjhkrummrwZFmuqXsAGuAkyIixqcTBNQ S6jpPU9ti+AjAaL7XGQypF/qOgrGyLZsYbShybN+IdazJ4xImUuATjPBQIGRXNA3OmWZ7nR1 rzgIuy708scU0BKltw5zNxTHsI7JFEQYPTzJc96hZkeJ5ubm+vbKJ7RYfumjeeEkNy/Jw3Ct wly/GI9GfVsMUgnycpBu6fX8DmjznW43Abbf6DKtvX9itSElHsb7kOQ+ckQWyjpnMhrMO5S9 WKqxi2+nr9/ePR7/1I/+sbN5rS0jNyZdPAyW+FDtQ2s2GYMnGs8lZ/eeqLE32Q4MynDrgfRS cAdGCps16cBE1gsOXHpgTPZBEBjeMLDTBk2sFbYJOIDlwQO3gQx9sMZn5B1Y5HgbYgSv/LYB OhhKgawjy04CHvYWf9fLJWYvsX91R8aKHgVDOTwKV6Ts1ZTxJknPW7vF/LtRFaA2BU+/bvI5 fqUH1ZYDmxsfJOtEBHbJn19xnLfaN30NjL2E0d7tgj3cHV6psUgofXC01QUoT8DBIrF23Jkc YseJiiuKSpmqtsv6fRb7ykuAOkv7oXD3xGUZBLSO8QTx0Af45kBNHwGWiEBLj8pFQwcgVrEt YpwfsCBo+yotN+x4ljYszPif7fHpd2zKRqkOl98gZPtHiSrOlRakwJfXMt3PFvgObrRarJo2 KrFePgLpmS4myAFutMuyezrXlxuR13jEtzuHmdSrCTxy1DLJnOo2kF7fYpPmobpdLtQlthNi luOtwsZR9UokLdQOLspqqaKz7NALU2UrUzRLmzPRsNCrUbJ2NzCIc/QedBmp25vZQuDbGlKl i9sZNuVsETwG9mVfa2a1YohgMycWYHrcfPEW31jfZOHVcoWmh0jNr27wdGFcL2JldxDlJOjN heWy0wpDX6pcpfdBgYwKkZ0Ks4oSbGAlA0WiqlZYuXRfihzPFUYq38htfO/ceFt0Ipld7cR6 NZH5Kx2L63peIJFoBFcemMZrgV1TdnAmmqubaz/47TLEKrMD2jSXPiyjur253ZQxznDHxfF8 Ztb342KMZmnId3A9nzmt3WLuFb8R1EsetcuGEzxTYvXxPw+vFxJu9P78fnx6e714/fbwcvyM HOk9wkLwsx4PTj/gz7FUazgpwmn9f0TGjSx0RCAMHUSsMrqqRYmP9OP8cBe7z8PGQxtXVQHa MiHMQffjWpza5jJtUqS6gJ19yb6tTsGkdW5EIHLRChRyB/bfcKGRkXZ8Ua9BJPGeg2Tcx+PD q16bH48X0fMnU9LmGPz96fMR/v/r5fXNnJCA+7r3p6cvzxfPT0YSNVIwluG1UNXoubulZgcA tga1FAX11I2rBiC3p/QzLHBK4K1ZQNaR+9wyYdzvoDjxpDtIV3G6lYwEBcEZwcHAwzVw0xyY SHWomui1m0IRatvKgmxIGsEfNFaSoVNBUcPplJY4+477/o+fX7+c/kvZuzU5biNrgH+lIjZi z0zsmTAvIkVthB8okpLYxVuRlMSqF0a5u8buOO2u3urqM/b++kUCvCATCdn7YHfp+0DcLwkg kfkHrXzjnmARao1zMi1j3L4LcKlQdDj8rD2b0bLC6FDrcSa4YadXbKDHU7dITW/+qD4c9jU2 WjIx1lKB+kCo65KSzKNMzFycJSE62F6IIneDwWeIMt1uuC+SMg03DN63OZiGYz54jLwk3DFp JF2Abkp13GfwU9P7IbN7+SAf7DK9t0tcz2EiavKcyWjeR+7WY3HPZbIvcSaeqou2Gzdgkk0T zxHNMNYF0+ILW2VXpiiX6z0zxLpcqi8xRJHsnIyrrb4thVhk4pc8Fg01cG0utrFh4khxT46K +v23lzfbuFC7idf3l/9bbNbFLCrmZxFcTLbPX76/3r29/D8/Pr+Jmffby8fPz1/u/ke5Cfrl Vewu4T7s95d3bF5qysJGalIyNQA9mO2oaZ943pbZ1p36MAidvUk8pGHAxXQuRfnZniGH3Fwr XdLl842pMU0AOSLzxW2cwyzdo0NVZBVVfqMS0JH1jbCOkvlTZmbKxd37n99e7v4hRIb/+e+7 9+dvL/99l6T/EiLRP8167vQt6qlVWM/0r5YJd2Qw/c5GZnTZFhA8kfr0SGFR4kV9PKILWYl2 0jol6N+iEvezlPSdVL08rjYrW+zwWDiX/+eYLu6seJHvu5j/gDYioPJNX6erLyuqbZYU1st5 UjpSRVdlm0Pb+wCOXTFLSGoOEmPLqvqH495XgRhmwzL7avCsxCDqttZnpswjQee+5F9HMe0M ckSQiE5NR2tOhN6hWWpGzaqP8aMWhZ1iN/Do5xLdeAy63TgUjRMmp3GebFG2JgAWTPkUeDJv qNnHn0PAsXuvzN2OZfdzoOlLzUHU5kO9BzGTmA6chWT1s/ElmIRShkvgcTR2sDZle0ezvfvL bO/+Otu7m9ne3cj27m9le7ch2QaAbt1UJ8rVgCNwebFgbCSKAem1yGhuysu5NObtBs5rappv uOrsHo2OCi9rWwJmIkFPv5UT2wS5aAgB4aifdi+EfrC9gnFe7OuBYei+YyGYehGiF4t6UCvS itARqTHpX93iPWbCLOHF6QOt0POhOyV01CkQC70zMabXBOzus6T8ytggLJ8mYMnnBj9HbQ+B H+kucG88Z1yofUf7HKD0dfGaReLkb5ov+7ymC4rYgIhFVN9MqKUPFFbIy0XVLI/t3oR0V3z5 Xj8xlT/1qR7/Uo1aGekDNM0BxmqUloPv7lza3Adqz0JHmYaemdxYRY5pTwWT+U1OlbSBH9FZ P28MGaHKkWGqGYyRTQQlnDU0/byknSZ/kk/xG13/eSU6eAmV9HSO6PqMLmXdYxn4SSTmQrqc rQxsFKcLYlBlk0cXri3sZNquj4+ddudBQsEQlyHCjS1EaVZWQ8sjkOW5DsXxSy8JP8h+DSfE PCEmHNoUD0WMjvv7pATMQ2u3BrKLAURChJmHLMW/DrT283Lr0tykib8L/qCrAVTZbrsh8DXd ujva2lzumpITUJoycvQTezU1HHBtSJBaXFNS4CkrurzmxvYsftpeDc8i1+8En0czxau8+hCr vRClVLsasOploGL9O64dOsbT09imMS2wQE9iiF1NOCuZsHFxjg3ZnGz8FrkESf5wb0cercfy gTM5KAQQna5hSlphItE2q9HmRHvj/p/P77/dfX39+q/ucLj7+vz++X9fViPc2h4JooiRGTkJ Sd+G2VhIO0dFnmiHvcsnzCoo4bwcCJJkl5hAxPKKxB5qdBsuE6IK+hIUSOKGSJiXmZLvs5nS dHmh315IaD3rgxr6SKvu44/v76+/34kJk6u2JhXbR7xDh0gfOvQYT6U9kJT3pX52IBA+AzKY 9hIRmhodX8nYhTxiInDONJq5A4ZOGzN+4QhQpIM3GbRvXAhQUQCuXfKO9lRsDWhuGAPpKHK5 EuRc0Aa+5LSwl7wXi9x67v9361mOS6RrrZAypYhUrByTg4H3uiCmsF60nAk2Uai/kJcoPWZV IDkwXUCfBUMKPjZYJUyiYnlvCUQPWhfQyCaAg1dxqM+CuD9Kgp6vriBNzTjolaih8S3RKusT BoWlxfcoSk9sJSpGDx5pChUStlkGdXhrVA/MD+iwV6LgrwftARWaJgShx9cTeKII6Oy11xob bZuGVRgZEeQ0mGk1Q6L0QL8xRphErnm1r1dt2Sav//X69cufdJSRoSX7t4NFdtXwRCdONTHT EKrRaOnqpqcxmmp/ABprlvr8YGMeUhpv+4R9rei1MV6K/Vwj82vzfz9/+fLL88f/ufvp7svL r88fGS1ftdJRc2aAGnt15gZBx8pUWuRLsx5ZRxQwPJLWR3yZyoM3x0BcEzEDbdDbqpRTASon TS2U+zEpzh32nkF0nNRvulJN6HSEbBzVTLQyzNBmx7wTuwleOSwt5SOVnrv2TJGJAZqI/PKg S8hzGKVJLGakKj5m7Qg/0NE1fJmDvnaONP5TaRhSDMwerICkSGYU3BlsiueNriAvULn/R0hX xU13qjHYn3L5HPmSC+m9orkhdT4jY1c+IFSqyZuBM12TOZVP2nBk2M6JQMDbpS4bCUiI9NKw SNegfZ9g8C5GAE9Zi2ud6W46Oure2xDR9RbiRBjihQyQMwkCBwG4waTlBQQdihj5ohQQPIHr OWh+HAcGWqWV7i4/csGQBhC0P/GXONWtbLuO5BgeqtDUn+B1/IpMem5EHUzsjHOiLw/YQWwT 9BEBWIN3yABBO2ur7+xP0VDqk1FqpZvuM0goHVXXFJr0t2+M8Idzh6YC9RvrykyYnvgcTD9l mDDmZHNikILDhCHPlDO2XG8pvYcsy+5cf7e5+8fh89vLVfz3T/M28ZC3GTalMiNjjbY9Cyyq w2Ng9AJgResO2ZO4man5a2VaHav5lTlx+0hUScVKiWckUF1cf0Jmjmd0h7NAdFLOHs5CXH8y fDLqnYh6U+8zXeluRuRx2Lhv6zjFTk5xgBbs2bRif1xZQ8RVWlsTiJM+v2TQ+6mn5jUMmFPa x0WM33TFCfazC0Cvv3fJGwgwFn5HMfQbfUP8plJfqfu4zc76Y/cjemQbJ50+GYHwXVddTax1 T5j5XkVw2O2m9I8pELgV7lvxB2rXfm8Y8m/BtEdPf4PdNPrAemJak0FuS1HlCGa8yP7b1l2H nHZdOBVslJWqoI5fx4vuDVy6iEVB4GlzVoIBghWL2wTFqn6PYofgmqATmCDyUDlhiV7IGavL nfPHHzZcn+TnmHOxJnDhxe5F364SAp/KUxLtDCiZoLOycjKzRUE8mQCELsQBEH1e1ywEKKtM gE42MyxtSO/PrT5LzJyEoQO64fUGG90iN7dIz0q2NxNtbyXa3kq0NROFNUP5isL4U9wzCFeP VZ6AsRAWlK8PxWjI7Wye9tut6PA4hEQ9XT9bR7lsLFybgFJRYWH5DMXlPu66OK1bG84learb /Ekf9xrIZjGmv7lQYu+aiVGS8agsgHGLjUL0cPsO1oHWyx7EqzQdlGmS2imzVJSY/vXLTOWn hQ5eiSIfjRI56cKkRJaLitlIxvvb519+vL98mu0+xm8ff/v8/vLx/ccb57ow0LX6Aqk0bdgO BLyUxjQ5AswdcETXxnueALeBxMV32sVgRWDsDp5JkAcoMxpXff4wHoXIz7Blv0VHggt+iaIs dEKOgpM1+Sj6vnvinJWboXab7fZvBCGeQKzBsDMSLli03QV/I4glJll2dMtnUOOxqIW4xbTC GqTpuQoH59SHrMi52IHrhGRcUN8lwMbtzvddEwc3t2hWIwSfj5nsY6aLzeSlMLmHJNYNhc8w +Hjos3tsKmeJT5QMOuLO11/dcCzfBVCIMqU+ntJuOb0XIlKy9bmmIwH4pqeBtBO+1dT335w8 lu0GOC9HAplZgktWwczvI7sSWaFVlp8E6NhZ3WYKVL/8XdFIs2R8qVt0998/NqfakDNVDuI0 bvoMvR2TgLTSdUD7SP2rY6YzWe/67sCHLOJEHhDp161FniBHlCh8n6F1L8mQeoj6PdYlmF3N j2I11JcR9WSl7yy5LmO0pmZVzDQW+kB/glemkQs+GXWhnuy/GpBF0R3CdG1dJmgLVeW6ZWkR 8zgcdaOAMzKmCdmXkkvRBRovHl8EsfcV64EuHjzgQ089sO4aR/wYM7F7IxvzGdaqEQKZTib0 eKGSaySDF0j+Klz8K8M/0askSz87t7V+wqh+j9U+ihyH/ULt4vXxt9edjokfyvMJeBjOCnRU PnFQMbd4DUhKaCQ9SDXo/rZRH5f92qe/6VNZqUhLfgrhAvm92R9RS8mfkJmYYoy22mPXZyW2 yCDSIL+MBAE7FNLvUX04wCEFIVGPlgh9AoyaCMzW6OFjNqBp3CbWk4FfUuo8XcW0VjaEQU2l 9r7FkKWxGFmo+lCCl/ys1dbsfgXmJt2agY5fLPj+OPBEqxMqRby2F/nDGVuVnxGUmJ5vpaqj RTvp7vQuh43ukYF9BttwGG5sDceaQiuh53pGscPFCVT+Rw1FR/VbvRSaI9VfAi+fN12WjNSJ qfbJrNrM1mHetsj5bxft/nDob2ZIZQ28WcULCIq3S7Sy4HVPDyfGZK4PBKUAwyxlyQD+gPTb BttKl5IjurE/F/pknmae6+hKBxMghKhi3e+Rj+TPsbzmBoT0/RRWoTeJKybGrJDjxRRI7urS bDNoa+h8uRrpOvlpuXMdbZoVkQZeiLzsyOV5yNuEnsbOFYPf06SFp+u6iLGKBYAZIUXUIgRP ZegtXObhhUH+NiZ7hYp/GMw3MCmWtAbc3T+e4us9n68nvHyr32PVdNOdZQkXkJmtAx3iVkiO jzzXZhm4+NPvJPT+BibtDsi3BCDNA5GbAZQzMsGPeVwhRRUICBlNGAhNjCtqpqRwMd3CTSWy ar2QDzUvwx7OH/K+Oxvd7FBePrgRL78c6/qoV9Dxwk8+oDsO4rNWWad8CE6pN+LFSr5sOGQE a5wNnn9OuesPLv226kiNnHSr1ECLzdMBI7hrCMTHv8ZTUujPESWGFog11OVAUGu/O53ja5az VB55Ad0YzhTYuND6OlLLzrDuhvypv1Q+7tEPOlQFpGc/H1B4LOfLn0YEpuSvILlqEZAmJQAj 3AZlf+PQyGMUieDRb316O5Suc68XVUvmQ8n3WNPq5iXcGOtgecEdroQ7Fd1c4qVBBkfhJxaG miF2wwjH2t3rPQ5+GeqNgIFsjrUK7x89/It+VyewT+0HbyzRC5oV18dHlYJn526+3ZKaFOh2 c/1Mlx5XVG8R0NQjzgMnxJRk5zYQDRBX6KVPMYiZoDIA3DUkSMz3AkTNNM/BiBsegQfm58EI RhoKgh2aY8x8SfMYQB7jFnm1n9B2wLZPAcaOd1RIqguh0hIyX4zUoQAVk7yBTbkyKmpi8qbO KQFlo6NSEhwmouZgGQcSZlUODUR8b4LgAqzPshabLy4GgRvtM2F0WtIYEDTLuKActtkhIXS6 pyBV/aSOFnzwDLwRe+tW32xh3GiIDgTGKqcZPGjXU/rQyJNW74z3XRTprz3ht35lqn6LCNE3 T+KjwT785nNobVWpEi/6oB+3z4hSyqHmzAU7eBtBa1+IIb0VM6k9SeyOVJ4212LkwTNfWdl4 b2XyfMyPuiNd+OU6RyTaxUXFZ6qKe5wlE+giP/L4AxvxJ9hv1C/DPX3JuAx6NuDX7McJXg3h izscbVtXNVq9DshLfTPGTTOdaph4vJe3jpggE6SenF5a+cjhb8nXka8bZphfzwz43p8aq5wA akCpgss6VMfePVG3nbzbYb2Cc9Hrq841jZw/fL6QlzzVzxzlq5QUn5w2ib209T3KzGlEUpOI p+a3xk2c3Gf95PQOeSsvYcVdgccM/IcdqILOHE1WdaCgo0k6tW03/kDeTz4UsY+ukh4KfLqn ftODswlFc9mEmedjg5jjcZy6cp74MRb6+SoANLlMP1aDAOabNXJKA0hd85taULDCxjMfkniL OtkE4GuYGTzH+jGj8oKFdiRtaesqSDe+DZ0NP3lM11UrF7n+Tlf5gN+9XrwJGJGl7RmU2h39 Ncd6yjMbubpjSUDle5t2ehiv5Tdyw50lv1WG3z+fsGjbxpc9/6XYreqZor+1oIarhE7uM2wH VF2WPfBEXQiRrIiR4Q70dvCQjKXuC0cCSQp2TyqMko66BDRtfRzgdafodhWH4eT0vOboJqZL dp5Db1mXoHr9590OPd7NO3fH9zW4vdQClsmOOC1WDxMBT3SPo1mTJ/iBsIho5+o3axLZWBbI rk5AgU0/o+8qcIuXYUB8QlXylih6KTho4fsSTlzwrkphXVYclN82yphHn+kVcHhGBl4TUWyK Mp42KFisjHjJV3DePESOfpCnYLGmuNFgwKbP8hnvzKiJTwYFqhmpP6ETH0WZF18KF42BtzQT rL9BmaFSvzKcQOyjYAEjA8xL3UDthEkbntjZ8tw2Fhm10zUcT0KweSwzXYJWiofr7ySGB+JI mDnzET9WdYPeNEE3GAp85LRi1hz22emMLJKS33pQZLh0dmZB1hSNwGcPgkga2M+cHqGTG4QZ UonLSOtUUvrY6PEN8JpZ9G5K/BjbE7qWWCByqAz4RUjrCVLW1yK+5k9o1VS/x2uAJpkF9SW6 GHeecOlqUvomZN3LaaHyygxnhoqrRz5HpoLGVAxl1nSlJjOn8UAbdCKKQnQN28UdPerXbgA8 3YzDIdUfdaXZAU0r8JNaLbjXNw1iQkCOU+s4bc9VhdflGRMbuVZsA1r80Fse2O/JO7LTI76P kIBukeOKNIMLIbP1bX6EF0eIOORDlmKoOyyvxMs8vxOc1b8XqCegb+VMOh6Hgigmp/DACCGT OgJB1T5lj9H5gp6gSRlsXHgfSFDl/JOA0s4RBaNNFLkmumWCjsnjsRK91sChdWjlJ3kSp6Ro 02UdBmHaMQqWJ01BUyqGngSSE/twjR9JQDAK1LuO6yakZdTpKw+KjTsh5GGIiSklOgvcuwwD 23oMV/ICLyaxg+ePHrTPaOXHfeT4BHswY53V0AgohWcCTgs16fWgaYaRPnMd/Sk2nKyK5s4T EmHawFmFZ4J9ErkuE3YTMWC45cAdBmc1NQRO091RjFavPaL3NFM73nfRbhfo2h5KXZXcbUsQ OTSpD2RJnL9DXrIlKOSCTU4woqQkMeUQhiaa9/sYHUlKFB6SgdFCBj/DwR4lqDaGBImLJIC4 OzFJ4GNK6dX+gkwNKwwOyEQ905TKekD7Vwmqs3uaTvOwcdydiQppdkPQSRNkmZMFdlf++PL+ +duXlz+wA6Cp/cbyPJitCug8Qbse7QtzAGudTzxTm0vc8oFkkQ366oZDiJWyzVb3HUlnXVoE Nw6N/ogDkOKxUo4nZi/GZgxLcKSC0DT4x7jvYEkhoFjPhaicYfCQF2hzD1jZNCSULDxZk5um Rk8cAECf9Tj9uvAIspiv1CD5bhmpvneoqF1xSjAnvbCCWQd93ElC2lEjmHxVBn9pJ4ViDChV WaqHD0QS6zfsgNzHV7S1A6zJjnF3Jp+2fRG5upX9FfQwCGfcaEsHoPgPH0xO2QQ5wt0ONmI3 utsoNtkkTaTuDMuMmb7r0YkqYQh1H23ngSj3OcOk5S7UH2zNeNfuto7D4hGLi2lqG9Aqm5kd yxyL0HOYmqlApoiYREBU2ZtwmXTbyGfCtxVcf2L7RnqVdOd9Jw9usTlIMwjmwHdlGYQ+6TRx 5W09kos9MWMuw7WlGLpnUiFZI+ZKL4oi0rkTDx34zHl7is8t7d8yz0Pk+a4zGiMCyPu4KHOm wh+EfHO9xiSfp642gwpRMHAH0mGgoppTbYyOvDkZ+ejyrG2lNRSMX4qQ61fJaedxePyQuK6W jSva58Kj3EJMQeM17XCYVQO9RGcz4nfkuUgh+GS8OkER6AWDwMbLp5O0GTpfvsNDcwmIPbW+ QWfDJVmr3Gygs0cRNLgnP5lkA3KtoiCITdRmLLZ+BU5+dz+erhShRddRJk3BpYfJ+MXBiH7f J3U2gCs0rNkrWRqY5l1A8WlvpMan1PVS3lf/dn2eGCH6Ybfjsg5Vnh9yfdGaSNEwiZHL9nCf 4zd5sn5U/cpHwuhEdC5anZVMeceqnpyFGA2jL3YLZCv96dpWRrtMbaYurvWztSRui52re5eZ EdjBdwxsJLswV90dzoKa+QnvC/p77JDMP4Foop8ws9sBKgYPNcIZt0HgaXeE11ysNK5jAGPe ScVWk+AqGCkhqd+jvqGZINp/AaMdGDCj2ADSYsuAVZ0YoFkXC2pmm2n8+QO+51+Tyg/1JXsC +ATce/rbLLDLVIzLFsO1FMPlioFnZOSAmfyUryoopO6z6XfbMAkc4vVFT4h7w+GjH/S1g0A6 PTYZRMz0nQw4Soe8kl9OOHEI9hB0DSK+5RziCd7+lsT/i7ckPumgc6nwzaSMxwBOj+PRhCoT KhoTO5Fs4LkIEDKtAEStLm18w4fNDN2qkzXErZqZQhkZm3AzexNhyyQ2Qadlg1TsGlr2mEYe AqQZ6TZaKGBtXWdNwwg2B2qT8tzrhhAB6fDbHoEcWARMPPVwepLaybI77s8HhiZdb4bRiFzj SvIMw1L3BolOgKZ7DdDHM3kCEect+YXMO+hfEo3evLl66JZjAuC+OUcWOGeCdAmAPRqBZ4sA CDDdVxNbK4pRti6Tc61vE2YSXSnOIMlMke9z3d+n+m1k+UpHmkA2O/2loQD83QYAeRDz+T9f 4OfdT/AXhLxLX3758euvn7/+eld/A6dXukOlKz94MH5Arin+TgJaPFfkAXoCyOgWaHop0e+S /JZf7cFAz3SIoxlRul1A+aVZvhXGxbMXhnbNFpkxhX2w3lHUbzCYUV6REgUhxuqCfAFOdKO/ iZwxfYmfMH3sgAZnZvyW5udKA1WG3w7XEZ7bIotmImkjqr5MDayCJ8mFAcMCYGJSFrDApjZo LZq3Tmo8JTXBxtg4AWYEwmpvAkC3kBOwGDqnWwPgcfeUFaj7Add7gqEKLwayEPl0fYMZwTld 0IQLiufoFdZLsqDm1KJwUdknBgYbgdD9blDWKJcA+CgdRpP+AmoCSDFmFK8pM0piLHQLBajG DdWPUgiVjnvGAFWCBgi3q4RwqoCQPAvoD8cjarUTaHz8h2N0UQWfKUCy9ofHf+gZ4UhMjk9C uAEbkxuQcJ43XvGtiQBDXx0jyRsYJpbQP1MAV+gOpYOazVSYFvvBBF+GzwhphBXW+/+CnsQs Vu9hUm75tMWuBh3nt7036MmK3xvHQfOGgAIDCl0aJjI/U5D4y0c2LBAT2JjA/g1y46ayh/pf 2299AsDXPGTJ3sQw2ZuZrc8zXMYnxhLbubqv6mtFKTzSVozoZqgmvE3QlplxWiUDk+oc1lzA NZK+VdYoPNVohLH9njgy46LuSxVd5bVK5FBgawBGNgo4PyJQ5O68JDOgzoRSAm09PzahPf0w ijIzLgpFnkvjgnydEYSlyQmg7axA0sisHDgnYsx1U0k4XB235vqtB4QehuFsIqKTw9GwfvrT 9lf9GkL+JGuVwkipABKV5O05MDFAkXuaKIR0zZAQp5G4jNREIVYurGuGNap6AQ+W/V6rK6uL H+NOV5Ntu5wZO+BpBS0VgOCml84GdeFET1NvxuSKDbCr3yo4TgQxaEnSou4R7nqBS3/TbxWG Vz4BoqPCAmvDXgvcddRvGrHC6JIqlsTVyTM2Q62X4+kx1aVZmLqfUmyIEn67bns1kVvTmtQb yyrd7MFDX+EDjwkgIuO0cWjjx8TcToj9cKBnTnweOSIzYCmEu6RV95j4igtMzY3TZCP3mNfP ZTzcgSncLy/fv9/t316fP/3yLLaMsx/q/2OtWLASnINAUerVvaLk7FNn1OMm5d0xWjelf5n6 EpleCNgiwjVdd3Hd1VNOUnfx+kuUWsrT61edWGyke5+NqLQ14Ckt9Nfk4hc2MToj5Ck6oOQE SGKHlgBIq0Mig4dsZeVixHWP+n1hXA3ovNl3HPTaQ3+2KgRFrUsc4hYrY4ABgHOSkFKCUasx 7bww8HRl7kKfmOEX2IX+efV1lxZadRZxsyeaCKJgoAyyAmBwGbqo2HkaWhkad4jvs2LPUnEf he3B06/pOdacQLVQpQiy+bDho0gSD/kiQbGj/qwz6WHr6Q8v9QjjCF0aGdTtvCYtUm7QKDLK LyU8qNOEVpHZDb4gr6RxYfQVzAuHOC9qZNEx79IK/wKTushMZZNTh2ZLMLEDStMiw8JkieOU P0WXayhUuHW+6PL+DtDdb89vn/7zzFm6VJ+cDgl+vTujUr+JwfFuVqLxpTy0ef9Ecan4d4gH isPhQIV15CR+DUP9VYwCRSV/QCb1VEbQEJyibWIT63T7IJV+Xih+jM2+uDeRZTlS1te/fvvx bvXhnFfNWbc+Dz/pwaXEDoexzMoC+dpRDNi0Ri8IFNw1Yv7J7kt0sCyZMu7bfJgYmcfz95e3 LzDVL/6ovpMsjmV97jImmRkfmy7WFWII2yVtllXj8LPreJvbYR5/3oYRDvKhfmSSzi4saNR9 quo+pT1YfXCfPe5rZA9+RsTUkrBog10mYUaXuwmz45j+fs+l/dC7TsAlAsSWJzw35IikaLot eg22UNJKETzTCKOAoYt7PnPKIBVDYG1PBMt+mnGx9UkcbnQXlToTbVyuQlUf5rJcRr6uOIAI nyPEurr1A65tSl3wW9GmFWInQ3TVpRuba4uccixslV17fc5aiLrJKpCdubSaMgdHl1xBjTeY a23XRXrI4d0nuAzhou36+hpfYy6bnRwR4AqdI88V3yFEYvIrNsJS131d8PyhQ2721voQE9OG 7Qy+GELcF33pjX19Tk58zffXYuP43MgYLIMP3iGMGVcascbCkwOG2etam2tn6e9lI7ITo7ba wE8xhXoMNMaF/sBoxfePKQfDu3Lxry7qrqSQSOMGK1Ux5NiVSK1/DWL4e1spEEnuie/flc3A vDSy5mpy9mS7DK5p9WrU0pUtn7OpHuoETrX4ZNnUuqzNkQEQicZNU2QyIcrAsyLkV1XByWOs ++dVIJSTPBlA+E2Oza3oTEgdb8ptnw9GEaBb7EujHhLXdZrY6EiXTsw6sVECos2vamzpNUz2 VxLL7/OyDgp+mgg1I/B+V2SYI/QTpxXVV2oNzRk0qfe6NYoFPx48LifHVr9NQPBYsswZzHKX us+shZNXushc0EJ1eZpd8+nlBiX7ki1gTry2EgLXOSU9Xft5IcXOoc1rLg9lfJTWoLi8g5ut uuUSk9Qe2VBZOVCO5ct7zVPxg2GeTll1OnPtl+53XGvEZZbUXKb7c7uvj218GLiu0wWOrku8 ECCKntl2H9AwQvB4ONgYLOtrzVDci54iJD0uE00nv0UHcAzJJ9sMLdeXDl0eh8YQ7UGvXnei JX8rJfgkS+KUp/IGXSVo1LHXj2k04hRXV/SkS+Pu9+IHyxivRCZOTeOiGpO63BiFgolc7Ta0 D1cQFG8aUKlE2gkaH0VNGYXOwLNx2m2jTWgjt5Hu48Dgdrc4PMUyPOoSmLd92IotmXsjYtCt HEtdFZqlx963FesMxlCGJG95fn/2XEf31mqQnqVS4Ka3rsQymFSRr+8TUKDHKOnL2NUPnUz+ 6LpWvu+7hvqsMwNYa3DirU2jeGovjwvxF0ls7Gmk8c7xN3ZOfz6FOFi/dWU6nTzFZdOdcluu s6y35EYM2iK2jB7FGXIYCjLAMayluQwjqjp5rOs0tyR8Egtw1vBcXuSiG1o+JM8fdaoLu8dt 6Foyc66ebFV33x8817MMqAytwpixNJWcCMdr5DiWzKgA1g4mNsmuG9k+FhvlwNogZdm5rqXr ibnjADpEeWMLQIRuVO/lEJ6Lse8sec6rbMgt9VHeb11Llz/1SWNdGLJKyLWVZS7M0n489MHg WOb+Mj/WljlQ/t3mx5Mlavn3Nbdkq8/HuPT9YLBXxjnZixnQ0kS3Zudr2ksLB9aucS0j5MQD c7vtcIPTvdFQztY+krOsFvIpW102dZf3lqFVDt1YtNblsEQ3QriTu/42upHwrVlNyipx9SG3 tC/wfmnn8v4GmUlR1s7fmGiATssE+o1t/ZPJtzfGoQyQUvURIxNgqEmIZH8R0bFGPu4p/SHu kNcZoypsE6AkPct6JK+bH8GcY34r7l4IOckmQLsqGujGnCPjiLvHGzUg/857z9a/+24T2Qax aEK5alpSF7TnOMMNKUOFsEzEirQMDUVaVquJHHNbzhrkMlJn2nLsLSJ4lxcZ2n0grrNPV13v op0v5sqDNUF8jokobMoCU61N7hTUQeyhfLvQ1g1RGNjao+nCwNlappunrA89z9KJnsipARIk 6yLft/l4OQSWbLf1qZykckv8+UMX2Cb9J1ADz817orwzjkjnTdZYV+hcV2NtpNgMuRsjEYXi noEY1BATIz0nxmDYDJ+aTrTc/Yj+S8a0Yvdi16FX43RD5Q+OqMAe3QZMV3lJ19y3BlpGu41r 3CwsJJgquohWi/HzkolWFwiWr+HuYyv6EV+Nit35U+kZOtp5gfXbaLfb2j5Vaynkiq+Jsoyj jVl38iJpL8T0zCippNIsqVMLJ6uIMglMPvZsxEKyauEsT/efsdwbdmJFn2iDHfoPO6MxwBBw GZuhHzOiOzxlrnQdIxLwVV1AU1uqthXSgL1Actrw3OhGkYfGE+OqyYzsTPcoNyKfArA1LUgw ssqTZ/YevImLMu7s6TWJmKVCX3Sj8sxwEXJ5N8HX0tJ/gGHz1t5H4BuRHT+yY7V1H7ePYGmb 63tqd80PEslZBhBwoc9zSuQeuRoxr/vjdCh8bjaUMD8dKoqZD/NStEdi1LaY8r1wZ46uMsYb dQRzSYMcKU8vC/HXPjZrs714sCZY5mNJh8FtemujpZknOUiZOm/jC6g82nujEHO280xscD1M xC5tzbbM6bGPhFDFSAQ1hULKPUEOus/MGaEiocS9FG7UOn25UOH1I+8J8Sii36ROyMZAYooE RphgeU54mpWM8p/qO9CP0ZQ0SPbjNjnBPvokWgsapDFkXvlzzCNH1wlToPg/vi5TcBO36Bp4 QpMc3ccqVEhHDIqUFBU0uZRkAgsIlKOMD9qECx03XII1WEGPG12FayoiiKJcPEoFQ8fPpOLg pgRXz4yMVRcEEYMXGwbMyrPr3LsMcyjVCdKicso1/MyxelOyuyS/Pb89f3x/eTP1YpGZq4uu dl2L7l5kcElddYW0MNLpIecAK3a6mtil1+BxD4ZL9RuLc5UPO7G09rrR2vmVtgUUscF5khcs jrGLVAjD8uH65AVRFrp7efv8/MVUw5suOrK4LR4TZNJaEZGnS1EaKGSlpgUvb2CevSEVoodr qoYn3DAInHi8CBk5RnomeqADXHne85xRvyh7ZWzJj65vqBPZoK8XKCFL5kp5rLPnyaqV5uW7 nzcc24pWy8vsVpBs6LMqzVJL2nElOkDdWiuuPjOz1cyCJ5zKxknFyfGCjePrIfZ1YqlcqEPY IodJoM/YepDTeR/yTHeCt8Z5+2DrcH2W9Ha+7SyZSq/YVq1ekqT0Ij9Aqof4U0tavRdFlm8M a+A6KcZ4c8ozS0eD+2x0hoTj7Wz9MLd0kj47tmal1AfdUrqcHqrXr/+CL+6+q3kCZktT23T6 nphL0VHrmFRsk5plU4yYeWOzt5mqh4Swpme6GEC4Gnej2UURb4zLmbWlKnatPrakr+NmMfKS xazxA2edqiHLBTq3JoQ12iXAMme5tOAnIZ+a86aC1888nrc2kqKtJZp4bio/dTDOfI8ZZytl TRjLzBpo/eKDbp5gwqR1fhiwdsZe9PyQX2yw9StQdMvN6U/B1q8emHSSpBrMdVnB9kwnbph3 24GeAlP6xodoa2KwaJsysWKZ3GdtGjP5maxv23D7ZKSE6w99fGQXOcL/3XhWye6xiZm5egp+ K0kZjZgt1MJOpx890D4+py2cBblu4DnOjZDWyeQwhENoTlbg94jN40zYp7+hE4In9+nCWL+d rEo3HZ82pu05AMXMvxfCbIKWWZzaxN76ghMzn2oqOmG2jWd8ILB1qvTpXAnPu4qGzdlKWTMj g+TVocgGexQrf2NmrIQMV/Vjmh/zRGwhTEnFDGKfMHohTTIDXsL2JoKDftcPzO+a1hR0ALyR AeTjREftyV+y/ZnvIoqyfVhfTalIYNbwYlLjMHvG8mKfxXDc2dETC8qO/ASCw6zpLLtmsk2k nyd9WxAl3omqRFx9XKXoJYx0AdXjXUjymBRxqmvGJY9PxCwGGDZXlrUKrC88xMqENMrAY5Xg 0+8Z0dUsZ2w86sfE+mNu+qpreQaBDgV0VAkuZnNV41GXFqr6qUa+Bs9FgSNVjgLb+owMfyu0 Q0U7XZLp+aXRAvAECql4a7hsN5EkbgooQtOKer7nsOmF73KuIFE93YIRFJoGvamCJ8qoo80V 35Q5aGymBTrwBhR2JuSht8Jj8Eknn6SwTNdjJ6OSUh4HlNr0Ab94BFpvfgUI+YtA1xg87NQ0 ZnnMWx9o6PukG/elbqxTbaYBlwEQWTXSU4iFnT7d9wwnkP2N0p2uYwuOBEsGAoEKTu7KjGX3 8UZ3S7YSqi05BnYlbaX7ZF45MgGvBHGCtRLUqYL2id5RVzgbHivdmN3KQP1yONy99XXFVdiY iLGi96OVGcCYtb6dTnv9+Sa88ciVTdDJ2wC89L/7aD9tXOYk/XwJTJ+UcTVu0MXHiurqAF3S euhmppnNXv+MnBZYMrKUI7ugziB+3yMAnszTWQcMAkg8u3T68aP4TWaZRPzX8D1Rh2W4vKMK Jgo1g2GthxUckxapHkwMPIEh5xY6Zb4J1tnqfKl7SjKx8bFcRDFBJXx4ZDLc+/5T423sDNFE oSyqBiEkF49oDZgRYptigeuD3lPMk/G1B6gGa89CdtvXdQ9ny6uTEJFH5m0yup4T1SiftIk6 qjEMCnf62Y/ETiIoep0rQOVmRHklWR2SyMST3z5/Y3MgpPS9urwQURZFVum+eqdIiUSzosiv yQwXfbLxdRXNmWiSeBdsXBvxB0PkFazMJqGclmhgmt0MXxZD0hSp3pY3a0j//pQVTdbKCwMc MXkxJiuzONb7vDfBRh4IL31huZjZ//iuNcs0L96JmAX+2+v397uPr1/f316/fIE+ZzywlpHn bqBvBRYw9BlwoGCZboPQwCLkOUDWQj4Ep9TDYI40liXSITUdgTR5PmwwVEkFKRKXck0sOtWZ 1HLeBcEuMMAQ2clQ2C4k/RG58JsApW6/Dss/v7+//H73i6jwqYLv/vG7qPkvf969/P7Ly6dP L5/ufppC/ev1678+in7yT9oGPVr3JEbcKqn5deeayNgVcNOaDaKX5eBsOiYdOB4GWozpWN4A qa78DN/XFY0BDBX3ewwmMOWZg33yxkhHXJcfK2n9FK9IhJSls7KmR1IawEjX3HcDnB2QHCWh o+eQoZiV2YWGktIRqUqzDuQUqYyN5tWHLOlpBk758VTE+H2hHBHlkQJijmyMyT+vG3RUB9iH p802It38PivVTKZhRZPobyvlrIfFRwn1YUBTkEYk6ZR8CTeDEXAgU90km2OwJg/tJYZNZABy JT1czI6WntCUopuSz5uKpNoMsQFw/U6eOie0QzGn1AC3eU5aqL33ScKdn3gbl85DJ7ER3+cF SbzLS6RZrbD2QBB0giORnv4WHf2w4cAtBc++QzN3rkKxOfOupLRC1H44iy0S6bzyfmzcNyVp AvOWTkdHUigwhhT3Ro1cS1K0ybMaqWTqZlRiRUuBZkc7Y5vEiwCW/SGktq/PX2DK/0ktr8+f nr+925bVNK/hYfiZjtK0qMj80cTkGlkmXe/r/nB+ehprvGOGUsZg/OBCOnqfV4/kDbdcrsSi MJtPkQWp339TAstUCm3dwiVYRR4y0PKOjJbJGgP4Tq8yMjIP8ghgVRqxyS6k3+1Xm2MSMcfi tOgRu80rAxYXzxUVpZRpNW69ARwELQ5XYhoqhJFvXz+FRbcsjWFxEqAyxi7mJZYtm1vx8658 /g79K1klOMNEDnxFpQeJtTukUiix/qQ/XlXBSnBs6iM/ZCosvoGWkBA1zh0+tZ2Dghm/1Cg2 ePKFf8WmADk+BsyQQDQQawsonNxDreB46oyEQWR5MFHqlFKC5x5Od4pHDCdi91UlGQvyhWWu 0mXLz5IIwa/k1lVhWHdGYcQdsQL3vcthYCoILZeSQnOObBBiH0i+Re9yCsCliFFOgNkKkNqZ 3UFMOkbccOcJNyPGN+SoWyBC3BH/HnKKkhg/kAtSARUluFUqSOGLJoo27tj2CVM6pLUygWyB zdIqx5virySxEAdKEPFJYVh8Utg9mNUnNSikpfGge2JfULOJpuvqriM5qNUyQUDRX7wNzVif MwMIgo6uoztpknCbI90CAYlq8T0GGrsHEqcQtTyauMLMwTB7+iWoCHcgkJH1hzP5itMtELCQ yEKjMrrEjcSG0SElAkGty+sDRY1QJyM7hnYCYHLdKntva6SPr+UmBJtPkSi5jJshpim7HrrH hoD4ndQEhRQyRT3ZbYecdDcp/KGnxQvqOWKmKGJaVwtH7puAMmQ7idZNUuSHA1ydE2YYyGLH aIYJdADrzgQiAqPE6LwCuoNdLP45NEcyjz+JCmKqHOCyGY8mE5erGims+9rJkqkiBlW9ntNB +Obt9f314+uXSWAg4oH4Dx30yQmirpt9nCiXhauoJeutyEJvcJiuyfVWuOrg8O5RSDeldNLX 1kSQmNww6mCZ419iXJXyaRScLq7USV+ixA904Kk01btcO/H6Ph+JSfjL55evuuY6RADHoGuU jW7HS/zAhiIFMEdiNguEFj0xq/rxXt7/4IgmSqoOs4yxC9C4aZFcMvHry9eXt+f31zfz6K9v RBZfP/4Pk8FeTN0BWBkvat2iE8bHFHlLxtyDmOg13ShwaB5uHOy7nHwixL7OSqIxSz9M+8hr dHuAZgB597TewhhlX76kp7ryqXOezMR4bOszavq8QifTWng4DD6cxWdYHxtiEn/xSSBC7SiM LM1ZiTt/q9sZXnB49bVjcCGVi+6xYZgyNcF96Ub6gdCMp3EEmtvnhvlGPnRismSo4c5EmTSe 3zkRvqAwWDQNUtZkurw6opvwGR/cwGFyAW+FuczJN5MeUwfqNZuJGzrDMyEfnplwnWSFblxs wa9Me4NdDgbdsuiOQ+lBMcbHI9c1JorJ/EyFTN+BzZnLNbixl1uqDk6TiZA/c8njsaKu7WeO Di2FNZaYqs6zRdPwxD5rC91Whz76mCpWwcf9cZMw7WocZC4dSj9W1EAv4AN7W66/6pouSz6b h8gJuZYFImKIvHnYOC4zgeS2qCSx5YnQcZkRKrIaeR7Tc4AIQ6ZigdixBDhNd5keBV8MXK5k VK4l8d3WRuxsUe2sXzAlf0i6jcPEJDcZUqDBNkYx3+1tfJdsXW667tKSrU+BRxum1kS+0UN3 DVfPj6T00Aq54vvz97tvn79+fH9j3jItE59Y3DpuqhR7nebAlUPiluErSFhRLSx8R25ddKqN 4u12t2PKvLJMw2ifcivBzG6ZAbN+euvLHVfdGuveSpXpYeun/i3yVrTIYSTD3sxweDPmm43D deCV5ebbhd3cIP2Yadf2KWYyKtBbOdzczsOtWtvcjPdWU21u9cpNcjNH2a3G2HA1sLJ7tn4q yzfdaes5lmIAxy0cC2cZPILbsvLXzFnqFDjfnt422Nq5yNKIkmNm+onz41v5tNfL1rPmUypQ LJsW25RrzJH0tdVMUN08jMMB/y2Oaz55J8mJM8bR2EKg4ykdFQvYLmIXKnxSheDDxmN6zkRx nWq6vNww7ThR1q9O7CCVVNm4XI/q8zGv06zQjbPPnHnCRJmxSJkqX1ghLt+iuyJllgb9a6ab r/TQMVWu5Uy3LsvQLjNHaDQ3pPW0/VnMKF8+fX7uX/7HLmdkedVjZdRFArOAIycfAF7W6J5A p5q4zZmRAwewDlNUeVTPdBaJM/2r7COX2xMB7jEdC9J12VKEW27lBpyTTwDfsfGDu08+PyEb PnK3bHkjN7LgnCAg8ICVy/vQl/lcNepsHYN+WtTJqYqPMTPQStCaZLZdQkDfFtyGQhJcO0mC WzckwQl/imCq4AK+r6qeOe7oy+ayZTf72cM5l6a+dFVtEJHRpdUEjIe465u4P41FXub9z4G7 PH6qD0Swnj/J2wd8l6JOpszAcJire2BSyp7oTHmBxotL0OkgjKBtdkTXlBKUjj6cVQX15ffX tz/vfn/+9u3l0x2EMGcK+d1WrErkllTi9GJcgeS4RAPHjik8uTVXuRfh91nbPsJV6kCLYerL LfBw7KiGneKoMp2qUHoHrVDjnllZ1rrGDY0gy6lCkIJLCiDDDEpTrYd/HF03SW9ORttK0S1T hafiSrOQ17TWwP1BcqEVY5wxzih+mKy6zz4Ku62BZtUTmm8V2hC3LQolt7EKHGimkCqbstsC VxWW2kanQKr7JEZ1o5dqatDFZRyknpgP6v2ZcuT2cAJrWp6ugksEpOuscDOXYvoYB+RxZh76 iX63K0Fi9GDFXF2UVjCxh6lA4ypPwqb0pMzCDVEQEOyapFi/RaIDdM6xo6OAXucpsKAd8IkG ict0PMgrCm2Fsk5Jiz6wRF/++Pb89ZM5VRkeqHQUW96YmIrm83gdkVqWNnXSipaoZ/RyhTKp ST16n4afUFv4LU1VWXajsfRNnniRMZ+IDqJOtZF2FalDtRwc0r9Rtx5NYDIQSSfcdOsEHm0H gboRg4pCuuWVrnfULPsK0u6KFXAk9CGunsa+LwhMlXOn6c7f6duUCYy2RlMBGIQ0eSoTLb0A 34NocGC0KbkbmeaxoA8imrGu8KLELAQxz6oan3qMUihjj2DqQmBS1ZxjJpOJHByFZj8U8M7s hwqmzdQ/lIOZIPVXNaMhejymJjVq1lvNX8Qk9wIaFX+dz6jXOcgcB9Ozj/wvxgd9lqEavBj2 Bw6jVVEWYtU+0X6RmIjYIKfiD5dWG7yQUpR+OjItf2JBlxWiPaozirMoPNwsppAG3ZAmIO3D 7IwqV9OmUSWJ76NbUpX9vKs7ujgNLfitoEOgrIdeOmVZn32buVaOHbv97dIgBd4lOuYz3NTH o1j1sb3ZKWfJva4JddXdUbujWutlztx//efzpKNrqJWIkEp9Vbr508WOlUk7b6NvkjATeRyD RC39A/dacgSWNVe8OyKlY6YoehG7L8//+4JLNym3nLIWpzspt6C3mwsM5dLvgzERWQmxGYpT 0MaxhNBtjeNPQwvhWb6IrNnzHRvh2ghbrnxfiJyJjbRUA7rB1wn0fAUTlpxFmX4Thxl3y/SL qf3nL+TDc9Emne5WSQNNFQ2Ng40c3vtRFm3zdPKYlXnFvXtHgVCPpwz82SMFbT0E6NQJukfK mnoApbhwq+jyLd5fZLHoE28XWOoHDn3QIZrG3cy8+aJcZ+k2xeT+ItMtfXGjk/rOoM3gca6Y R1Nd700lwXIoKwnW7azgWfitz7pz0+ia6TpKHxUg7nQtUX2kseK15WDayMdpMu5j0IHX0pkt h5NvJrPGMFehRUTBTGDQKcIoKBxSbEqe8doF6nlHeDsrRHtHv4KcP4mTPtptgthkEmxqeYGv nqMfA844zCj6RYWORzacyZDEPRMvsmM9ZhffZMBUrIkaSkczQT22zHi378x6Q2AZV7EBzp/v H6BrMvFOBNblouQpfbCTaT+eRQcULY8ddC9VBq6vuCom+6u5UAJHygxaeIQvnUcaTGf6DsFn w+q4cwIqtuaHc1aMx/isv26fIwLfS1sk+hOG6Q+S8VwmW7OR9hK5wJkLYx8js7F1M8Z20NUN 5vBkgMxw3jWQZZOQc4Iu6s6EsR2aCdiN6idvOq6fgcw4XtzWdGW3ZaLp/ZArGFTtJtgyCSsD p/UUJNTfrWsfk/0vZnZMBUyuFGwEU9Ky8dCd0YwrfaByvzcpMZo2bsC0uyR2TIaB8AImW0Bs 9SsPjQhsaYiNOp9GgBQ8lpmn3PsbJm21h+eimrbxW7P/ymGn5IoNM+XOFqOYjt8Hjs80WNuL NYMpv3zIKPZWuhbsUiCxduvC8DohGMv6/Mk56VzHYWYw4/RpJXa7HbLEXgV9CN4g8KRElnf5 U2wVUwpNzx3VNY+yQ/v8/vl/Xzgz1WBuvgNPKz56sbHiGysecXgJbittRGAjQhuxsxC+JQ1X nwA0YuchAz8L0W8H10L4NmJjJ9hcCUJXpEbE1hbVlqsrrKe6wgl5TjYTQz4e4op5j7F8iW/F FrwfGiY+eGnY6ObbCTHGRdyWnckn4n9xDotPW5usNIHUZ8is3Ex16KxyhV22wJNTjxibQ9Y4 plLz4H6My71JdE0sllATP4ByZnDgicg7HDkm8LcBUzHHjsnp7IWHLcah7/rs3INcxURXBG6E LeouhOewhBB/YxZmeqy6Iowrkznlp9D1mZbK92WcMekKvMkGBoeLQzzNLVQfMWP7Q7Jhciom ztb1uK4jtsNZrItzC2FqFyyUXIOYrqAIJlcTQc3yYhI/CNPJHZfxPhGSANPpgfBcPncbz2Nq RxKW8my80JK4FzKJSwek3LQHROiETCKScZmJXRIhs6oAsWNqWR7vbrkSKobrkIIJ2blDEj6f rTDkOpkkAlsa9gxzrVsmjc8unGUxtNmRH3V9EgbM4lxm1cFz92ViG0lluw2Qfue68iQDMyiL MmQCw8NrFuXDct2t5FZrgTJ9oCgjNrWITS1iU+Pmj6JkB1u548ZNuWNT2wWez7SDJDbciJUE k8UmibY+N/6A2HhM9qs+UQfWedfXzNRVJb0YUkyugdhyjSKIbeQwpQdi5zDlNF7CLEQX+9wc XCfJ2ET85Ci53djtmSm6TpgP5L0z0oAvibnWKRwPg9DohRb50+MqaA8OFw5M9sSaNiaHQ8Ok klddcxa77KZj2dYPPG7wCwK/0lmJpgs2DvdJV4SR67M93QscrqRyyWHHnCJW33ZsED/iFp9p /uemJznNc3kXjOfYZm3BcKufmlK58Q7MZsOJ/bBBDyNuoWlEeblxOWRiyWJiErvXjbPhViDB BH64ZdaTc5LuHIeJDAiPI4a0yVwukacidLkPwGkeu2LoKmyWxaEzLvIX5tRzLS1gru8K2P+D hRMuNDXXt4jtZSYWcqY7Z0JM3nCLmCA810KEcA7MpF52yWZb3mC45UBxe59b6bvkFITSVULJ 1zLw3IQuCZ8ZpV3fd+wI6Moy5OQssZi7XpRG/D692yKVF0Rsub2kqLyInaOqGD1R1nFuURC4 z052fbJlZov+VCacjNWXjcutUhJnGl/iTIEFzs6jgLO5LJvAZeK/5HEYhcxW6tK7HicgX/rI 404xrpG/3frMJhKIyGXGJRA7K+HZCKYQEme6ksJhSgElZZYvxBzcM2ubosKKL5AYAidmJ62Y jKWIDo2Oc/1EmrsfS9cZGYFYSk663cwJGKusx7ZIZkLepHbYS+XMZWXWHrMKHMhNt46jfDEy lt3PDg3M52TUzcrM2LXN+3gvveTlDZNumikDk8f6IvKXNeM175T3gRsBD3AeIz2D3X3+fvf1 9f3u+8v77U/AMyGciiToE/IBjtvMLM0kQ4O1rhGb7NLpNRsrnzRnszHT7HJoswd7K2fluSAX 4zOF9cqljSsjGrDIyYFRWZr4vW9iszKeyUibGybcNVncMvC5ipj8zXaTGCbhopGo6MBMTu/z 9v5a1ylTyfWsMqOjk4U5M7Q0KsHURH+vgUqp9uv7y5c7MFv4O3KwKMk4afI7MbT9jTMwYRZd j9vhVp+WXFIynv3b6/Onj6+/M4lMWQcrCFvXNcs0mUdgCKUPwn4h9kw83ukNtuTcmj2Z+f7l j+fvonTf399+/C4N2FhL0edjVyfMUGH6FdgDY/oIwBseZiohbeNt4HFl+utcK43A59+///j6 q71I03tHJgXbp0uhxdxTm1nWdSdIZ3348fxFNMONbiLv+HpYlbRRvtgJgNNvdXqu59Ma6xzB 0+Dtwq2Z0+UBHjODtMwgvj+J0QqHUGd5X2DwprOOGSFGNRe4qq/xY637Dl8o5Z9EWrsfswoW tpQJVTdZJe1MQSSOQc+Pk2TtX5/fP/726fXXu+bt5f3z7y+vP97vjq+ipr6+Iv3F+eOmzaaY YUFhEscBhCxRrNaybIGqWn/cYgslnaroazMXUF90IVpmuf2rz+Z0cP2kym2vaU+0PvRMIyNY S0mbmdSVJvPtdBVjIQILEfo2gotKqUrfhpVr6rzK+yQu9BVnOSQ1I4DHQ064Yxg5MwzceFDK UDwROAwxeV4ziac8l07NTWb2dc7kuBAxpfrN3LSLZ8Iu1l8HLvW4K3deyGUYbE61JZxQWMgu LndclOpN04ZhZsuqJnPoRXEcl0tqsp7NdZQrAyqjpwwhzVqacFMNG8fhu7S0Z88wQrhre46Y L/KZUpyrgfti9l3E9L1JQ4iJS2xKfdC5anuuO6vXWCyx9dik4AKDr7RFZGX8N5WDhzuhQLbn osGgmEXOXMT1AP7zcCfO2wNIJVyJ4TUgVyRpedzE5VKLIlcGW4/Dfs/OAEByeJrHfXbP9Y7F a5/JTe8Z2XFTxN2W6znK2A6tOwW2TzHCp4esXD3BG0WXYRYRgUm6T12XH8kgPTBDRtpgYoj5 BTRX8CIvt67jkhZPAuhbqBOFvuNk3R6j6sUUqR31nASDQnbeyPFEQCmaU1A+4LWjVPdWcFvH j2inPzZCQMR9rYFykYJJfwkhBYXUE3ukVs5lodeg2h518b9+ef7+8mld3ZPnt0+62aaE6b85 GD7V3+WqhOanRH8ZZc7FKuJQRnvnxy1/EQ3oWjHRdKKRm7rr8j1y0qi/7IQgHbb9DtAebEMi k9IQVZKfaql2zEQ5sySejS9fMu3bPD0aH4C7r5sxzgFIftO8vvHZTGNUuQWDzEj3yfynOBDL YeVK0WFjJi6ASSCjRiWqipHkljgWnoM7/fm7hNfs80SJTrtU3on1YAlSk8ISrDhwrpQyTsak rCysWWXIIKy00/vvH18/vn9+/Tp59DL3e+UhJXsjQEzFdYl2/lY/Ip4x9NxEmsWlb11lyLj3 oq3DpcbY7lc42O4Hy+yJPpJW6lQkuu7RSnQlgUX1BDtHP+eXqPl2VsZBVK9XDN8Fy7qbvEsg gxNA0GetK2ZGMuFI0UZGTs2CLKDPgREH7hwO9Ggr5olPGlEqvg8MGJCPpy2UkfsJN0pLNdxm LGTi1RU6Jgxp0UsMvV8GBB7a3+/9nU9CTkctBXbPDcxRSEvXur0nqm6ycRLXH2jPmUCz0DNh tjFRqpbYIDLTxrQPCwE1EEKvgZ/ycCPWXGyMcSKCYCDEqQfvLbhhARM5Q9emIKDm+kNZAJCf M0gif+hCj1SCfCWelHWKvPQKgr4TB0w+DXAcDgwYMKQD0NSbn1DyTnxFaT9RqP5eekV3PoNG GxONdo6ZBXiNxIA7LqSucC/BPkSqNDNmfDwfBKxw9iSdCzY4YGJC6JmuhsMeByPmM40ZwWqe C4pXoek9OTPHiyY1BhFjelTmanlurYNEWV5i9IW/BO8jh1TxtLsliWcJk80u32zDgSVEl87U UKBD21RFkGgZOC4DkSqT+P1jJDo3mcWU4j6poHg/BEYFx3vftYF1TzrDbOpAnU735eePb68v X14+vr+9fv388fud5OVdw9u/n9lTOAhAtKIkpCbD9fj678eN8qd8eLUJWfLpK0rAevBO4Pti 7uu7xJgvqWUKheHXPVMsRUkGgjx1ERuAEcu8sisTaxPwNMR19Icp6hmJroijkC3p1KbJiBWl 67b5AGXOOjG1ocHI2IYWCS2/YYtiQZEpCg31eNQcGwtjrJSCEeuBrlownxyZo29m4jNaayaj FswH18L1tj5DFKUf0HmEM+khcWoARILE5oacX7ERIJmOqaYtBS1q70UDzcqbCV4w1O1UyDKX AVI1mTHahNJox5bBIgPb0AWbqjWsmJn7CTcyT1UgVoyNAxnBVhPYdRMZ60N9KpWFHLrKzAx+ 04S/oYzyS1M0xFfGSkmio4w8xDKCH2h9UfNQUmRarrZWfD5HN3sx0hb5mbr9tW36lnhNPckF omdHK3HIh0x09bro0buENQB4iD/HBTzj6c6o3tYwoBQhdSJuhhIS4BHNR4jCYiShQl08WznY 0Eb6bIgpvNfVuDTw9WGhMZX4p2EZtc9lKbkks8w00ou0dm/xooPBG3o2CNmdY0bfo2sM2emu jLlh1jg6mBCFRxOhbBEa+/CVJPKsRqitN9uJyd4VMwFbF3RbipnQ+o2+RUWM57JNLRm2nQ5x FfgBnwfJIbM/K4cFyhVX+0U7cwl8Nj61neSYvCvEpprNICh0e1uXHUZi0Q355mCWSY0U8tuW zb9k2BaRr7r5pIichBm+1g0hClMR29ELJTfYqFD39rBS5v4Wc0Fk+4xsgCkX2Lgo3LCZlFRo /WrHz7DGNphQ/KCT1JYdQcYWmlJs5ZubfMrtbKlt8XsSynl8nNN5D16jMb+N+CQFFe34FJPG FQ3Hc02wcfm8NFEU8E0qGH49LZuH7c7SffrQ5ycqaicHMwHfMOScAzP8xEbPQVaG7sE0Zp9b iCQWyzybjm2FMU9DNO5wfsosq3lzETM1X1hJ8aWV1I6ndAtjKyxvi9umPFnJrkwhgJ1Hzu0I CdvfC3qNtAbQX2j09Tk5dUmbwaVgj314al/Q0xqNwmc2GkFPbjRKCO8s3m8ih+219AhJZ8oL PwY6r2xiPjqgOn58dEEZbUO241JDDRpjHAJpXHEUezu+s6kNyb6uscdmGuDSZof9+WAP0Fwt X5NdjU7Jjdh4KUtWCutEgZyQlQgEFXkbdkaS1LbiKHis5IY+W0XmKQzmPMvso05b+NnMPLWh HL/QmCc4hHPtZcBnPAbHjgXF8dVpHu4QbseLqeZBD+LI0Y3GUXs7K2WaUF65C36xsRL0xAEz /HxOTy4Qg84TyIxXxPtcN2/T0jNiASDL8EWuGxPcNweJSGtpHvoqzRKB6UcGeTtW2UIgXEyV Fjxk8Q8XPp6urh55Iq4ea545xW3DMmUCl2opyw0l/02uzLxwJSlLk5D1dMkT3WaEwOI+Fw1V 1rrzTxFHVuHfp3wITqlnZMDMURtfadHOuvoGhOuzMclxpg9w7HKPvwQFLIz0OER1vtQ9CdNm aRv3Pq54/ZgMfvdtFpdPemcT6DWv9nWVGlnLj3XbFOejUYzjOdaPGwXU9yIQ+Rzb4JLVdKS/ jVoD7GRClb4ln7APFxODzmmC0P1MFLqrmZ8kYLAQdZ3ZlTAKKBVvaQ0qK8kDwuB9qg6JCPXL AGglUI/ESNbm6KHNDI19G1ddmfc9HXIkJ1J5FyU67OthTC8pCvaE89rXWm0mxuUWIFXd5wc0 /wLa6K4mpeKghPV5bQo2CnkPdvrVB+4DOJdCPoJlJk5bXz96khg9twFQaTLGNYceXS82KGKO DTKgvFAJ6ashhO7bRAHIvxNAxGsAiL7NueiyCFiMt3FeiX6a1lfMqaowqgHBYg4pUPvP7D5t L2N87usuK7Jk0XWTTmfmc9z3P7/ploCnqo9LqTvCJysGf1Efx/5iCwDqoD10TmuINgaj2LZi pa2Nmn1w2Hhpa3PlsJ8dXOT5w0ueZjVRtVGVoCxHFXrNppf9PAZkVV4+f3p53RSfv/744+71 G5yPa3WpYr5sCq1brBi+l9BwaLdMtJs+dys6Ti/0KF0R6hi9zCu5iaqO+lqnQvTnSi+HTOhD k4nJNisagzkhL3cSKrPSA9OtqKIkI5XNxkJkICmQDoxirxWy8iqzI/YM8KKIQVPQaaPlA+JS xkVR0xqbP4G2yo96i3Mto/X+1WO62W60+aHV7Z1DLLwPZ+h2qsGUNumXl+fvL/BuRfa3357f 4RmTyNrzL19ePplZaF/+nx8v39/vRBTw3iUbRJPkZVaJQaS/6LNmXQZKP//6+f35y11/MYsE /bZEQiYglW70WAaJB9HJ4qYHodINdWpyYa86WYc/SzPwEd5l0kW4WB47sCh1xGHORbb03aVA TJb1GQq/e5zu9e/+/fnL+8ubqMbn73ffpSIA/P1+918HSdz9rn/8X9ozP1DUHbMMq9Cq5oQp eJ021MOhl18+Pv8+zRlYgXcaU6S7E0Isac25H7MLGjEQ6Ng1CVkWyiDUD+ZkdvqLE+pXG/LT AvkWXGIb91n1wOECyGgcimhy3WvmSqR90qEjjZXK+rrsOEIIsVmTs+l8yOCtzweWKjzHCfZJ ypH3Ikrd9bTG1FVO608xZdyy2SvbHVg0ZL+prpHDZry+BLqhLkToFo8IMbLfNHHi6UfciNn6 tO01ymUbqcuQ4QaNqHYiJf2yjHJsYYVElA97K8M2H/wPuXKnFJ9BSQV2KrRTfKmACq1puYGl Mh52llwAkVgY31J9/b3jsn1CMC7yiahTYoBHfP2dK7HxYvtyH7rs2OxrZF9SJ84N2mFq1CUK fLbrXRIHeVHSGDH2So4YcvAYfy/2QOyofUp8Opk118QAqHwzw+xkOs22YiYjhXhqfey3VU2o 99dsb+S+8zz9nk7FKYj+Mq8E8dfnL6+/wiIFTkiMBUF90VxawRqS3gRTh4KYRPIFoaA68oMh KZ5SEYKCsrOFjmF4B7EUPtZbR5+adHREW3/EFHWMjlnoZ7JenXFWENUq8qdP66p/o0Ljs4Mu /XWUFaonqjXqKhk839V7A4LtH4xx0cU2jmmzvgzRcbqOsnFNlIqKynBs1UhJSm+TCaDDZoHz vS+S0I/SZypGGi/aB1Ie4ZKYqVE+tX60h2BSE5Sz5RI8l/2ItBpnIhnYgkp42oKaLDzRHbjU xYb0YuKXZuvotgh13GPiOTZR092beFVfxGw64glgJuXZGIOnfS/kn7NJ1EL612WzpcUOO8dh cqtw4zRzppukv2wCj2HSq4eU+5Y6FrJXe3wcezbXl8DlGjJ+EiLslil+lpyqvItt1XNhMCiR aympz+HVY5cxBYzPYcj1Lcirw+Q1yULPZ8JniavbZl26g5DGmXYqyswLuGTLoXBdtzuYTNsX XjQMTGcQ/3b3zFh7Sl3kxgtw2dPG/Tk90o2dYlL9ZKkrO5VASwbG3ku86YFUY042lOVmnrhT 3UrbR/03TGn/eEYLwD9vTf9Z6UXmnK1QdvqfKG6enShmyp6YdjEX0b3++/0/z28vIlv//vxV bCzfnj99fuUzKntS3naN1jyAneLkvj1grOxyDwnL03mW2JGSfee0yX/+9v5DZOP7j2/fXt/e ae10dVGH2Hp7H3uD68KzDGOZuQYROs+Z0NBYXQGTt3pmTn56XqQgS57yS2/IZoCJHtK0WRL3 WTrmddIXhhwkQ3ENd9izsZ6yIT+Xk/soC1m3uSkClYPRA9Led6X8Zy3yT7/9+cvb5083Sp4M rlGVgFkFiAi9qlOHqtJz85gY5RHhA2R8EMGWJCImP5EtP4LYF6LP7nP9LY/GMgNH4sqCjVgt fScw+pcMcYMqm8w4x9z30YbMswIyp4Eujreub8Q7wWwxZ86U9maGKeVM8TKyZM2BldR70Zi4 R2kiL3h5jD+JHobev8hp87J1XWfMyXmzgjlsrLuU1Jac+8k1zUrwgXMWjumyoOAGnq7fWBIa IzrCcguG2Oz2NZEDwKEFlXaa3qWA/uwirvq8YwqvCIyd6qahJ/vggIp8mqb0PbyOwrSuBgHm uzIH158k9qw/N6CvwHS0vDn7oiH0OlBXJMtpLMH7LA62SDFF3ajkmy09oqBY7iUGtn5NTxco tt7AEGKOVsfWaEOSqbKN6NFR2u1b+mkZD7n8y4jzFLf3LEiOAu4z1KZS2IpBVK7IaUkZ75BO 1lrN+hBH8Dj0yIagyoSYFbZOeDK/OYjF1Whg7p2QYtRzIw6N9AlxU0yMkLGnZ/xGb8n1+VBB YH6op2Dbt+heW0dHKaT4zr850ijWBM8ffSS9+gl2BUZfl+j0SeBgUiz26BRLR6dPNh95sq33 RuWWeVs3SYkU9FTzHdzwgPQXNbg1my9rWyHZJAbenjujeiVoKV//2JxqXWJB8PTReiWD2fIs elebPfwcbYWQicM81UXf5sZYn2AVsbc20Hy9BSdIYicKNzqLrTmwxwcvgOTViu2+E+SbjWss 2f2F3rwkj0Is7LrxkLflFdlLna/2PDKXrzizAZB4KQZ2Q+VLyaBbQjM+2+2iZ72RJMd2dKm7 sQiyV7hSmNiEFni8aKsx7Ny6PK5EL057Fm8TDpXpmqeQ8pq2b/QciTllmeeNKWVq5viQjUmS G+JUWTaT/oCR0KJZYEYmbaFZ4DERm6fWPL/T2N5gZ4NllyY/jGneifI83gyTiIX2bPQ20fzh RtR/goyCzJQfBDYmDMSsmx/sSe4zW7bgmbDokmDW8NIeDFlhpSlDXVpNXegEgc3GMKDybNSi NHfKgnwvbobY2/5BUakGKVq+M3qR0hJOk9LY9szmvpLMyOesk6Msb2zG3Ih2ZWxn4UEj5p3S 3AsIXMhuOXQqS6zyu7HIe6OrzKnKALcy1ajZiO9wcbnxt4PoIAeDUmYTeXQaJGYVTzQe4Dpz 6Y1qkNaQIUKWuORGfSoLOXlnxDQTRvuKFtzIamaIkCV6geriFsxSi1aKZZKqU2OuAcvVl7Rm 8WYwDk8Wq3cfmP3qQl4aczTNXJnaI72Asqo5hS66NqAc2haxOTVqemnj0TPHvEZzGdf50rxd AmuGGeiLtEbW8eDDlm3mMZ2Pe5jaOOJ0MXfmCrYtT0CnWdGz30liLNkiLrTqHLYJ5pA2xuHK zH0wm3X5LDHKN1OXjolxtkfeHs1rIFgOjBZWKD/Nygn1klVnU88LvkpLLg2zpWBEdeSyxr7u S923CLR8sAegtP1LYUFOG4I7zJJkWSY/gfG3OxHp3bNxGiJlFpBS0eE0DHip4GdJ5cJM6Jf8 khujQ4JYz1InQAsqzS7dz+HGSMArzW/IGJbn7Ww2gREfrTfLh89vL1fx390/8izL7lx/t/mn 5XBISMlZSu+wJlDdjv9s6jvqNsMV9Pz14+cvX57f/mSstqlzyL6P5dZMWVps78S+fpb4n3+8 v/5rUbn65c+7/4oFogAz5v8yDojbSedRXQb/gIP1Ty8fXz+JwP999+3t9ePL9++vb99FVJ/u fv/8B8rdvIsg1jomOI23G99YrQS8izbmjWwau7vd1tyiZHG4cQNzmADuGdGUXeNvzPvepPN9 xzx+7QJ/Y6gZAFr4njlai4vvOXGeeL4h/p1F7v2NUdZrGSGXZiuq+/WbumzjbbuyMY9V4WnH vj+Mils9CfytppKt2qbdEtC4tIjjMJAn00vMKPiqUWuNIk4v4IHUkDIkbAiqAG8io5gAh45x bjvB3LwAVGTW+QRzX+z7yDXqXYCBscMTYGiA953jesaBc1lEochjyJ9Eu0a1KNjs5/CUfLsx qmvGufL0lyZwN8yuXsCBOcLgAt0xx+PVi8x676875GRdQ416AdQs56UZfI8ZoPGw8+RjOq1n QYd9Rv2Z6aZb15wd5IWLnEywjjHbf1++3ojbbFgJR8bold16y/d2c6wD7JutKuEdCweuIadM MD8Idn60M+aj+D6KmD526iLlz43U1lIzWm19/l3MKP/7Ag4v7j7+9vmbUW3nJg03ju8aE6Ui 5Mgn6ZhxrqvOTyrIx1cRRsxjYNWGTRYmrG3gnTpjMrTGoC6R0/bu/cdXsWKSaEFWAnd+qvVW o2YkvFqvP3//+CIW1K8vrz++3/328uWbGd9S11vfHEFl4CF3q9MibL46EKIK7HlTOWBXEcKe vsxf8vz7y9vz3feXr2IhsCpxNX1ewbONwki0zOOm4ZhTHpizJBhYd42pQ6LGNAtoYKzAgG7Z GJhKKgefjdc3VQXrixeaMgaggREDoObqJVEu3i0Xb8CmJlAmBoEac019wY5717DmTCNRNt4d g269wJhPBIpMpywoW4otm4ctWw8Rs5bWlx0b744tsetHZje5dGHoGd2k7Hel4xilk7ApdwLs mnOrgBv0wHmBez7u3nW5uC8OG/eFz8mFyUnXOr7TJL5RKVVdV47LUmVQ1qbqRpvG+BZlgj8E m8pMNrgPY3MfD6gxewl0kyVHU0YN7oN9bJyrqumEolkfZfdGE3dBsvVLtGbwk5mc5wqBmZul eUkMIrPw8f3WN0dNet1tzRkMUFMPR6CRsx0vCXKJhHKi9o9fnr//Zp17U7D3YlQsGCs0tYDB mpK8fVhSw3Grda3Jby5Ex84NQ7SIGF9oW1HgzL1uMqReFDnwdHna/ZNNLfoM713nR25qffrx /f3198//7wsoXcjV1djryvCTFda1QnQOtoqRhwwLYjZCq4dBIuOcRry6HSrC7iLdYTci5d2z 7UtJWr4suxzNM4jrPWzJnHChpZSS860c8i5NONe35OWhd5FGsM4N5HUL5gLHVLGbuY2VK4dC fBh0t9it+dRUsclm00WOrQZA1gsNXS+9D7iWwhwSB03zBufd4CzZmVK0fJnZa+iQCIHKVntR 1Hagx26pof4c76zdrss9N7B017zfub6lS7Zi2rW1yFD4jqvrX6K+VbqpK6poY6kEye9FaTZo eWDmEn2S+f4iDzIPb69f38Uny5NFaTnz+7vYcz6/fbr7x/fndyFRf35/+efdv7WgUzak4lC/ d6KdJjdOYGioXMProZ3zBwNSXTEBhq7LBA2RZCAVpURf12cBiUVR2vnKrzBXqI/wpvXu/7oT 87HYCr2/fQbFXkvx0nYg2vPzRJh4KVFlg64REv2vsoqizdbjwCV7AvpX93fqWmzoN4ZinQR1 wz0yhd53SaJPhWgR3VX1CtLWC04uOj2cG8rTlTTndna4dvbMHiGblOsRjlG/kRP5ZqU7yMzQ HNSj+uyXrHOHHf1+Gp+pa2RXUapqzVRF/AMNH5t9W30ecuCWay5aEaLn0F7cd2LdIOFEtzby X+6jMKZJq/qSq/XSxfq7f/ydHt81EbLbumCDURDPeB+jQI/pTz5VlmwHMnwKsfWL6PsAWY4N SboaerPbiS4fMF3eD0ijzg+M9jycGPAWYBZtDHRndi9VAjJw5HMRkrEsYadMPzR6kJA3PYfa eAB041IFUflMgz4QUaDHgnDiw0xrNP/wXmI8EH1R9cIDHtfXpG3VMyTjg0l01ntpMs3P1v4J 4zuiA0PVssf2Hjo3qvlpOyca951Is3p9e//tLhZ7qs8fn7/+dP/69vL89a5fx8tPiVw10v5i zZnolp5DH3PVbYA9ys+gSxtgn4h9Dp0ii2Pa+z6NdEIDFtVNzSnYQ48olyHpkDk6PkeB53HY aNzjTfhlUzARu8u8k3fp3594drT9xICK+PnOczqUBF4+/8//X+n2CdhC5pbojb+8LJmfOWoR 3r1+/fLnJFv91BQFjhUdE67rDLwqdOj0qlG7ZTB0WTIbzpj3tHf/Flt9KS0YQoq/Gx4/kHav 9iePdhHAdgbW0JqXGKkSMG28oX1OgvRrBZJhBxtPn/bMLjoWRi8WIF0M434vpDo6j4nxHYYB ERPzQex+A9JdpcjvGX1Jvs4jmTrV7bnzyRiKu6Tu6YPEU1YoTW0lWCtV09Wrxz+yKnA8z/2n bv/EOJaZp0HHkJgadC5hk9uV6/DX1y/f797hZud/X768frv7+vIfq0R7LstHNROTcwrzpl1G fnx7/vYbuC0x3hLFR20FFD/GuGhOMVWBPcZj3O4NQCotHJuzbrYFNJry5nyhLivStkQ/lMZb us85tCNoKvJ1HsbkFLfoLb7kQFcFPEYfQP8Bc/dlZ9gamvHDnqUO0g5SVoIxRfSYayXrS9Yq zV131Xte6SKL78fm9NiNXZmRQsMD9lHs/FJGAXkqKLoEA6zvSSSXNi7ZvIuQLH7MylG6BbRU hY2D77oTKIVx7IVkq0tO2fLqHhQ4plu3OzHj8Qd48BW84EhOQhQLcWzqZUeBnjrNeDU08rhq p1+zG2SALgJvZUgJEW3JPH0XkZ7SQrcWs0CiaurreK7SrG3PpKOUcZGbmrayvmux84/1nOkJ 6yHbOM1oB1SYdD7R9KQ94jI96qpjKzbS8TTBSX7P4jeiH4/gNHjVmlNVlzR3/1D6GslrM+tp /FP8+Prvz7/+eHsGnX1cqSK2MZbabGs9/K1YpqX8+7cvz3/eZV9//fz15a/SSROjJAITjahr 02lEh5w/3UxL/7qqz5cs1hpgAsSEcIyTxzHpB9OC3BxGadwFLDz7mf/Z5+myZBJVlJibT7iM Mw+2JIv8eCIz5uVIp6zLvW5+CRClhbksmm2fkBGjAgQb35eWUSvuc/CMS2eUibnk6WLULJtu 7qUKxf7t86df6fCcPjLWjAk/pSVPKGdkSk778cu/zFV9DYp0XTU8bxoWx0reGtHWPZjoZbku iQtLhSB9VzkNTIqdK7qoeiojFfkwphybpBVPpFdSUzpjLsoLm1dVbfuyuKQdA7fHPYfei21P yDTXOS3IKKWrfHmMjx6SC6GKpPYnLdXC4LwB/DCQdPZ1ciJhwDEQvPGi02wTV1mx7jPUhNE8 f335QjqUDChEJ1CkbTshYRQZE5Mo4rkbnxynH/syaIKx6v0g2IVc0H2djacc/Eh4211qC9Ff XMe9nsXwL9hYzOpQOL2mWpmsyNN4vE/9oHeR/L2E+P8ou7Jet3El/VcOMMDM0x1oteUB+oGW KFuxtiPKtpwXId2d7htMOhkkadz5+VNFrSyWfDIP3Tmur0hxKZJVXKpSmXVZ2V8w5nhWeEdh bCqt2R6iPPXpA4wqL0gybyd8h61Jhg8gLvDPwXDFyjBkhyhyY5YFBDYHXbJ29of3a49uC8u7 JOvzFkpTSMc83Fl4Lll5Gtd3aATnsE+cgG1YKRIsUt5eIK+z7wa7+xt88Mlz4kaGjbd0yHgT Pk8OTsCWLAfw6PjhK9/cCJ+CcM92GbrxLvPICaJzbmx4LBzVTb8h0BLpsgVYsex2e49t4hXP wXFZkdTvp7u+yEXqhPu7DNnyVHlWyK5HdQz+LK8gcRXL12RK6peeVYthtw5ssSqV4H8gsa0X Rvs+9Ft2WMD/Bfqoi/vbrXOd1PGDkpeTjegSPOsjQScSTbHbuwe2tiuWyJrxRpaqPFZ9g46P Ep/lmJ9h7BJ3l7zBIv2zYOVoxbLz3zmdwwqUwVW89S1kMd2Hb7NZ673FFkXCAZVOoRui1GHb c80tBF88mV2qPvDvt9Q9sQzaz3z+CkLTuKrb+NDApBx/f9sn9zeYAr91c7nBlLUNekfsVbvf /wwL3y9rluhwY3nwYraIu8ALxKV+xhHuQnEpOI42wXvlIIt3dealsa3xbrzjRS2MTrY6I0fg F60U2xz1yeXno7a55o9xCd3399fuxI79W6bA3q86HFwH8/Br5oHZpZYgL11dO2EYe3tjf4cs /IYuQf05LKvzhBi6w7IFxeq8oMYxGm98hj7FcIpoT9M1eVqsgIQ+TqkSmuMrZZhZ8vawozM/ Kgc9fW+CehfaNaC7ge7aJnWHwaNOsj9GoXPz+5Qsc+U939jcQYO9bks/2Fndh+ZuX6toZy/3 M0RXQZWheGeREUpsALKD6WBtJHp+QIk6RDLXae05K0GdOsc7H5rFdTyStK3UOTuK8Vr7znuK Pk+7f4pGz9D1RTCNwuKT1gEdH/g+q9yF0CPRzk5QJ66nTI9oqH1P9oUou53xuoSie8OHjoEm 1PBeJ9t5JFPc1bFujhOABtSlsLWrpodQcU7qKAx2T6D+3d5z6S4dZ1aMxF6cj1xhJjjz1DPY KqdpfllzjT1RGC1Q0A0yfG8qcPcSpgl2fwo52pu0iXlytIl2M2TozyaLWSJuDBODyieK/i0O LMJGy8i2FLfsxhJhhMqmENRybOL6REpQdMoipKSmcdY0YJC9yoIkPhWud/XXEw3GDEPk3EV+ uE9sAG0Tby3ha8APXB4I1gN0AooMlk3/tbWRRtbC2K+dAFjuQy4rVAP8kKwJde7SEQeSYemd oIHbC2raVNRMHxwF9KeUyGQRJ3SSzRJFeuX9o3zF0Dy1upLOGXbXSAYJ/UjjemTGLKgaYDy+ 16KXUQ5xE3RBkN0QDQMDRknFmwtgfKBbfe2o/vWaNRdFWxD9A5WJdlQy3LH99uGvjy+//v3H Hx+/vSR0Vzo99nGRgLmzKkt6HKKiPNak1d/jcYM+fDBSJevtUfh9rKoWT+iZSBz43RQfgOZ5 Y/hJH4G4qh/wDWEBICEnecwzO0kjb32ddTJH1/X98dGaVVIPxX8OAfZzCPCfgy6S2ansZZlk oiR1bs8L/d9eVgj8MwAYI+HL1x8v3z/+MDjgMy0oCzYTqYXhIgbbXaZgF2r3hGYFbicBAmHQ ChFjIC4zA2YHF1mBbzyuMdlxrwnbBIb8iRWzf3749vvghZJuhWJf6SnQyLAuPPob+iqtcF0Z tUyzu/NamS8DtWSYv+MHWMvmKe+aakmraMzf8RAiw+QBlRD6piUfVq1JaU+mJF1xEBiU01HS 3+g24Zdg3Qq3xmyWCiwGPAo1G0+5iQ63ahYU/VaYQxr3wgVDMp9ULWTycn8BeGlpspuwCFbe mmjnrMl8vpnxekZLMHRLx5BgFQNlpATbgwUfqs1er5LDThyRFn3KR9ykOeTp6dpMsms/kDca cADtxhHtw1hyZtJGRqJ90N99bLFgABvZgCZlHElOGJWmx8a3lE9+WsOKrnQzyWqdkSzimIiu sZwOv3ufjGtNW1sY6dFcdYffMKPgAoBO1eJUWSjGLC5qWF6PuP9rNmMpK1gMMrPMl0djzrm+ oS+MBKZOmkxb4FZVSbUOdo+0FuxPs5VbsCYlmYQMd4J6CjXTxKIp6Co/0kBxEKB93LSOO69H BhhfVVsV/JJ0LyIjIIYmtWi/N3ShqjthXB5EVpd25BkWHmh+iYJpNk9bkAUOCUPbEoHxY/p7 PMVs5OneZFQ1KIxgH5qi4ivpSOP0CCemI2jtXRuEpAKnKk/SbH1Yiku0iMgMjQdAV2FmWUjc S6sKMkkdQQJI6pGmHZKeSDNNGJWuY1OJRJ2lJEOYHMwgSeHdzT1pkr1LliN05GVTpms0jMo3 4OUV77eo5Qx6SanDDmVcIkONNxLYEybB0q2UMQbAgskga17R/3S7+YX1PrKBwFIQb0CDpUm8 d40cwcxhQeE2NOSrki3E2A4zEBjIfYouMCXG77784vA551LWvUhb4MKKwWBRcnYEjHzpcdiR 1Efo43n6FNfK0PGGTFFbSSCzqhb+jpOUiYHuKNkM9g7SzBNP25B9cuMaYME3WnVhmCMDMlyD /cWLwogp6PBiE85P9RlWlVqtD9XmXZg3m3fKFf0Tmt6pJgob8W8GjcMQpM4b3ufbWl1FSJt7 y0tKzoLUMnH88Nt/f/705z9/vPz7C8zWU4BC62ognqkNQcWGULbL1xDJg9RxvMBr1wcMGiiU F/mndL26aHp780Pn9WZSh+2QziYauypIbJPKCwqTdjudvMD3RGCSJ89QJlUUyt8d0tP6ptlY YFhJLimtyLCFY9IqdB3ohauWnzWsjbZa8MErnbk+LuilTbz1O4cFwbezPovU94IjJ+LgrN+w mcj6hcWC4AWCw3pbaoG03697vvbxuIA0qPWqukkdhutONKDICClHoD0LRVFdQCr2Y3Wchs6O byUhWm8jS3yA7Dtsb2rowCJ1FIZsKQDZr99XrcqHuzsN+yF1eURuwPeKHUZ9VS3l79fbcwti BpRdFe8G/bHPaw47JjvX4b/TxF1clhzUgFXVKza/QVzm2eiNOWdKD3MaLunULR2/pzEuDOPN 7S/fv37++PL7uC0++g6zQyectENeVRlvrxOGONyxHsmodFyLUv0SOTzeVHf1izdf30tB/QYl Jk3xWRrNmQFh1mgHAycrRPN4zqsvkRlXk/kcx+2lVlxkNbgiXG6iP2+uecar1uGb8Vev71j0 piPzFQDtu77NsULi/Np669MyjSUYRXlG5vJZ99WnRKq6lqt5SP/sK0X975v0HiOB5CJbTZbK yAV426xYL8BIquPCIvQyT2xiJuPD2qkH0pNCyPKEtpiVz/meyNokKflqrRxIb8S9yNa6IxLR 2tVOrKs0xQvlJvrOcKY+UcZYdsbteTW0Ed51N4n6aiZCdlW3iBhNAWrLgEzLnhuGuBXrVRdI dGjaJmB+eEazjbGowXgzQxfrjzdV3KckJxgIx0pJayvBxLKyJW1I7JWZNCWy6901V2tfSPde m/dgtWcJGcS6BAXMf7RhFIb6LWOGPExCG9x2V2GKsennK8UWA4pbL2/GTsUa20phCRFCYC7b aYr6GjhufxUN+URV535vbH2P1IClal78DM9vI7fOzkfEhz2926A7l7rR1ES7ucH0qMhY5ivd 1uJGSWp9A2BosyYTeX91d+Ha/cfSakTMQPYLUXpdwFSqru7o60Dc5FNwlgRnzXTHaMq0rTBW GTGNB3IEVhSd0I7uzqYaISF0YRK7RxI3cncWn2sE6RmaXhnbUJr2vnV3a8tjJHr+elmaiR5J HhdZ5HsRQ/Qppwo832Vo5DNSubsosmjGvpJur9h8Do2001VpmyKLLbrs2kYW0qLDRElaHH05 3y0hmMn4/p+uFu/f08bC0abW9wAHYgu2W8f2zYRxzaQxn5QTQ2NYYmWLFKWIu2RI9tDX4hhb QqpiUZMMsFFSvEdFZ/TMlsjoYEmkb0lkrgKrZ2H6D4OQtAusB1lXczR9qEeUCHGNIpdmCzQq 0kijwivupCthMPiW3B9bw2HATNLv3+K8ompGLBzXIT0U65hEpP+7x0mWzJSu6faQiuxhtqPD Z6D1pbzbk06swtAevkALyT2cYXXuUlLeRDS5oM0Kuo5Fy8XDZhxSB0zqgEtNiDDZkpmwyAhB xufKJzpGVibZqeJotL4DNXnH81qTycBMyLD2u87FZYn2UBwBmkepXH/vcESasXIPvj2jHnYs bfZSbSMkxBMiaRHRNVaTpshXeDmCqDnnQd6G25tfv/zHD3zh/efHH/iU98Pvv7/8+venzz/+ 8enLyx+fvv2Fx+vDE3BMNppdK0+dY35kqINV4Brb+DORigtO63nUOTyVZHupmpPr0XzzKicC lne7YBdISyWXqm0qn6dyzQ5WhaXylYUXkimjjrszUXWbDJaMhJpGhfQ9i3TYMaSQ8Omr+7fs SOtkHdEN6pyIPDrfjERuYtZHRJUiknXrPI+U4lGkw9yoZeec/EO/faTSIKi4ieUMWCbKRnVv 22TG6ERyIwcClw8ajEfJpVow3QK/uJRBB+yzwnVPqNa34dMYfvKyBdNoyyaqslMh2IoO+I1O kwtkHiiYGL3mQtCqlJ2gArLCYQWka7KJUomlqL16rTi0y7DtBjGDXhJh2ZCT4cBLZTmIPaiC 0CWG88dZKO1vNtLOEgr/pM+LGpqPazxQZjcyrFFGQNOAEr6Xq8gI86ymP8lJMMYE6hh7T9Fd AtHu/dhzfZ7at6LBAJTHrMWIa78E6MxkzWiEKh4J9H6vQcbH1XO8M/vkZ+K9CpeuRJqsOu9h k2ORidcNMjcVD1m5npfb9B3Gd7DJ5ywVdHfqGCeepdvqYNRZKXc2ua4SlnhmyC0Ii3kUPSE3 AUYymY+xzHer3BPVFoPE2mmruvWLBS1gyrw4M+dYGRc4dUPIY3Xc+DaGgTdcChloK8AGKTbA omqvNmT3Qx0XMZ0Zbl0NGrqkZkyihTBOyaioYoswbBQc6WyIyLQAPdnjRLZpn9JG2qquYHKn W1f4UWuHaSD2otN357dBVSeZXa2VowEGiN+Dfr733EPRHfCwDy9anjdZmxYdXjM8w8me1Ygz GZp9EzLC5piQUpupAHqWKcJMxgd3QEVxOHnOEKfDMkKnPAA9OHRjaZ1FF76Rg968SLbbpKDL 0gKyPV1kl6bSW7ctmV2L+FxP6eBHvIFqEWnpzoOBNtTijQsPJGO7UPHjVNIxAol2vr7Lo/r7 OVOtNcXL+oAMlsgkEiadUl/Utr62wobhNsaOj8dQKWhWpN8+fvz+24fPH1/i+jp7BB39Gi2s YxRNJsl/mfqn0lvo+CC9YWYIRJRgBiwCxSvTWjqvK/Q83f6aclMbuW2MboTkdhGyOM3otvSU iq+SfiATF/bomUAs/ZXaxcXUlaRLxuMr0s6f/rPoXn79+uHb71xzY2ZS2duQE6ZObR5aq+6M breT0OIqmmS7YpkRgeepaBn1Bzk/ZzsP44hTqX33PtgHDj9+LllzuVcVs/6sEXSXIBLh750+ odqcLvuJJepSZXSveoVVVCuawPmB1CaHbuXNzAd0O3uYEPDdZDXswoKZA4sQJ4pawVWqxeUy lzdq7AxrdJ2NjIUZI93M5SJlcRTMejul3U6KzoD6FF+wJPkD34me+lIU1HRe+I/JXa+UofM0 24ltv7Xojmx4/fEu860yFu2lP7bxTc2epwSK7Xrgib8+f/3z028v//P5ww/4/dd3c8xBVaqy FxnRtEZyd9JvGjaxJkmaLbCtnoFJgS9SoNesAz+TSQuJrfMZTFQSDdASxAUdzsntOWHFgbL8 LAfEtz8PizwH4Rf7a5vldFNpQLVBe8qvbJVP3RvFPrmegLYXzKmewYCmL1UGtEhppvYwXFxc 3FO9LVfGpzrFq9UaYOfw0WZlU+ElLJua13jlLK6vW5B9E87Es/o1cnZMIwywQNg6dUFdqWUz Hfl7ddyoAn+AiCAY8rs3UWrgLZhIn0EwwTIqwgLr0wxmRhs5qBAvUANDY3hPxadUmykBelIq RmwU6ON0d1N3RVJEQWjTbR9RFOEV2hm1xq6BbigaM45x0CLnwKgpi8un1gwgNDNcQPmJxtfU zC7gyOMfDv2puVp3gqZ2GXx7EGB0+GHbq5MnEKZaI8S21pyuSC76UUXE1JgyHQ703B+ZCtG0 9NiSJt5o9VXGvCmuavlQ1hb6YIofZVNUDaMbHGHZZaqcV/dccC0+vITE91xMAcrqblOrpKky JifRlInImdJOjdEWHtQ3tHZb1zwCdBa13dwjV5ElArncaHF5zCvwzccvH79/+I7od1ttV+cA tGxmPKO7MV6r3szcyjtruE4HKrfVaGK9vYk2M1ytA3FEqvSJwomodaI7AaiN8kjFlR/oo5fC prLOYhYOKEeFbyCstylrtrJilnsCPs9BtU0Wt704Zn18luxyMJeYh2ChjeX8MX0w8qTS+n4Y rKMbXWDcLoN1eqNqA9vwZWCC3laZfa/M5JalOOZyemYDehTU9yf45yfkbWNpo2YCLEiao/lm uuS1ORvZiqycdvFb2fHcfBbaVcVTSUWOzdTavngjvebZFusB3xwP4xELKMi9rLf7cPxKC+rR yPuMb0tHQg4w8aBz0AHOM0mfuDbQ2eJ6nsnExsOFbBqoi8yT59ksfBtTSl3leCR9kc/zWfh4 /ATrUpm9nc/Cx+OxKMuqfDufhW8Dr9JUyp/IZ+bbkIn4JzIZmba+UMj2J+C3yjmx5fVzzjY7 yebtDGc2Hpb55Qz60tv5rBh5hnfol+QnCrTw8fh4yLk5NofzzO2FDnGR38VDzRM06L+5u82d Z+UFBrOSpicQe8rQGvJ4EPZmkq6VJb2mOaiQ3M4hUtGDC9do7Xy5QbXFp9++fdUx2799/YI3 +xW+pHoBvjEwsvVUY8mmwJAmnKk0QLxePqTitvQXOElVYpx3/z/KOew1ff78r09fMIaupdWR ilzLIOPuGQMQvQXwRtC1DJ03GALuyEyTOTtCf1AkWkzxyXUhTPfcT+pqGRXy1DAipMmeo08W t1HQx7dBtrMncMM60rAPnz1fmf3jCX2Ss/s0LcL2WZYBb+ftRvqa9OXZp5NCbFZrMKIZK2hA 8YAu9J+gRhB0ih6sW2cLCtpyoXLrGH1hEHkc7uh9lwXe3h9Y6rXfkpL1BtoSYdswqNqP/wvm VPbl+49vf2M87i27rQV9CxqYN5vRQd4z8LqAQxAP66OJyNbFYs57EnHLyjhD91j2NyawiJ/C t5gTEHydvCGZGiriI5fpiA3bPxutO5xevfzr049//nRLY75+397zwKHXcefPiqNEjp3DibTm sG9vIaSd9PXyZszmPy0UNLdrmdXnzHpws0J6wVndM5onLrNuz3DdKWZczDDYI4JdEoCpy2Dl 7vgJZcQGs3/jbGHFtzFbdm1an4T5hfcW9/vO4mi5/ULtgxH/rpe3mlgz28nUvPeT50PlmRra T4CXHaPsvXVXGoE7GFXXI5MXAMJ+toJZoQdTZ6sDth4MaSxxI/oAZKRbDx4Wun0nbYUZ7kDW GLfPKJK973OSJxJx5c5bJsz198wyoJE9vYa2IN0msnuCbFVpRDcaA1H6EGCNPMs1epbrgVtk JuR5uu1v7h2HGeAacV3mXH9C+jOzSTqDW5+7ReyI0ADfZLeIW/ZhOLguffKhgUvg0qtAE52t ziUI6HvYkR76zIY/0und1ZG+ozczJ3rA1QzpXMMDnT4jGOihH3Hj9RKGbPlRpfG4Am3pOsfE i9gUx7ZXMbOExHUsmDkpfnWcg39j+j9uKjAY460pKVZ+mHMlGwCmZAPA9MYAMN03AEw74uud nOsQDdD3T/9H2bU1uW0r6b+iOk85D6cikiIl7VYewIskRLyZIHXxC2tiK85UxmPvzLg2+feL Bi8CGo1J7Ys9+j4QBBqNJq7dGkGr+kA6s3MVgDJt6l4aWceVH5FVXPn4dsqMO+qxfqcaa4dJ Au5yIVRvJJw5Bh41pgKC6igK35L4Ovfo+q9zfNtkJmilkMTGRVDj/oEgmzcMcrJ6F3+5IvVL EmufsGTjaSRHZwHWD+P36LXz4ZxQM3W4lCi4wl3pidYfDqmSeEBVU/l5IWRPTwZGp1dkrTKx 9qiOInGf0iw4uUYdGHCdaBtwWq1Hjuwo+7aIqI/bIWXUDQ+Nos71qf5AWUkV3ghCE1HmjQsG W6TEDDgvVtsVNe/Oq+RQsj1reny2F9gCrk4Q5Rvmyvga8Z2hetPIEEqgmCBcu15k3bibmZAa BCgmIgZRijB8CiGGOuUwMK7cyGHqxNBKNLMiJcZWA+uUH76Ef68vRcAJDS/qz+BrynFsQU8D FwNaRuyf1EnhRdRgF4g1vnSsEbQEFLklrMRIvPsU3fuA3FDHhkbCnSWQriyD5ZJQcUVQ8h4J 57sU6XyXlDDRASbGnaliXbmG3tKncw09/y8n4XybIsmXwfkXyp42eWRduB/xYEV1+ab110Sv ljA1Mpbwlnpr6y2peafCqRM+CqeOJrVegN03zDj9YonTfbtpw9Ajqwa4Q6xtGFGfL8BJsTpW X51Hm+BgrCOfkOjYgFO6r3DCFirc8V58QXrCqXGta/V1PLHrlN2G+IYOOK3jI+dovzV1yl3B zidoLZSw+wlSXBKmn3Afvxd8taZsorqqSq40TQwtm5md92KsBCpMDZP/whY6sdKnHQNyHY9x HCgThU92RCBCaogKRESteowErTMTSQtAFKuQGlmIlpHDXsCpT7bEQ5/oXXAOf7uOyPOtvBfk PhQTfkjNQRUROYi15ehnIqjOJ4lwSVlfINbYc8JMYM8TIxGtqHlbK6cOK2pK0e7YdrOmiPwU +EvGE2o5QyPpttQTkJpwT0BVfCIDz3KcY9CWKySL/ofiqSTvF5BayR1IOcGgVlTGJ9Pk4pE7 dSJgvr+mNtLEMO13MNSSmXN7xbmr0qXMC6gpniJWxMsVQa0/y1HtNqAWAxRBZXXOPZ8a05+L 5ZKaOJ8Lzw+XfXYizPy5sC8jj7hP46HlP2rGiY7sOm8KLlApqyPxFZ3/JnTkE1J9S+FE+7hO G8OeL/UZBJyaWSmcsOjU5c4Zd+RDLQmoPWhHOak5MuCUWVQ4YRwAp8YdEt9QE9YBp+3AyJEG QO2W0+Uid9GpC7QTTnVEwKlFG8CpMaDCaXlvqQ8R4NTUXuGOcq5pvZBzZgfuKD+1dqFOZjvq tXWUc+t4L3XCW+GO8lAXKRRO6/WWmvSci+2SmqUDTtdru6aGVK5zFgqn6ivYZkONAj7m0ipT mvJRbQpvoxq7oAEyL1ab0LHgsqbmJIqgJhNqZYSaNRSJF6wplSlyP/Io21a0UUDNkxROvRpw qqxtRM6fStZtQqoTlpRftZmg5DcQRB0GgmjwtmaRnLYyw5W8uStuPDIM81135jTaJIZx/75h 9YG69nstIeaVcZdZ8/gw+CTiqX2c7aBf2JA/+lgdM7gq9zHlvj0YbMO0OVRnPXv3TjOcE/x+ +/T48KRebB0QgPRsBTGczTxYknQqtDKGG71uM9TvdgitjUgaM8QbBAr9nr9COvBPg6SR5Uf9 PuSAtVVtvTfm+zgrLTg5QLhojHH5C4NVIxguZFJ1e4awgiUsz9HTdVOl/JhdUZWwkyGF1b6n GyiFyZq3HPxHxkujIynyivx+AChVYV+VEIb7jt8xSwxZIWwsZyVGMuNi5IBVCPgo64n1roh5 g5Vx16Cs9nnV8Ao3+6Ey/VYNv63S7qtqLzvmgRWGr2OgTvzEct3TiUrfRpsAJZQFJ1T7eEX6 2iUQPjUxwTPLjdslw4uzs/J+hl59bZA3YkB5wlL0IiMIDwC/srhB6tKeeXnADXXMSsGldcDv yBPlihaBWYqBsjqhVoUa28ZgQnvdpaFByB+1JpUZ15sPwKYr4jyrWepb1F6O3yzwfMggiiHW AhV9qpA6lGE8h7BBGLzuciZQnZps6CcoLYet/2rXIhiu0TRY34subzmhSWXLMdDorrQAqhpT 28F4sBICrMreoTWUBlpSqLNSyqBsMdqy/FoiK11LW2eEN9PAXo9pqeNEoDOdduZn+tDTmQSb 1lpaHxU1PcFPgNf+C24zmRT3nqZKEoZKKE24JV7r6qoCjQ+ACr2OpawCrMIRfwS3GSssSCpr BjckEdGVdY4NXlNgU9VkWcmE/qGYIbtUcLH11+pq5quj1iPyy4J6u7RkIsNmAYJx7wuMNZ1o sR91HbXe1sEopa/1qHgK9ncfswaV48ys782Z86LCdvHCpcKbEGRmymBCrBJ9vKZyrIJ7vJA2 FAIidTGJD+Hexl9ooJLXqEkL+VH3fU8fgVKDLzUq60RMDwUHv3BWz9KAMcUQdmB+E85QvUXO x+m3wBHS4S1zBjjtkMHz2+1pwcXBkY26CiNpKzP6udkHov4erVrVIeFm8Fez2tZloo7wn66c 5WXK8+jeRLu85qb3teH5skTxXZRnwQY+bEz0h8QUvpnMuKionitLaZXh0io4TlbxJ+bBf/H4 +un29PTwfPv241U12eg1ymz/0X08RCkTXKDq7mS2EBpOmUPD1qhHHREflHRbdS047ZI2t7IF MoXTFyD6y+hDx+gWo1yFEuxe9nkJ2K3B5LxBDurlxwm8a0EodF+nh5a6d4Fvr28QOeXt5dvT ExVCTTVQtL4sl1Y79BfQFhpN471x5m8mrOaaUCnOMjO2J+6s5fDj/nZu+Hqf8UKPdXFHT1nc Efh4nV2DM4DjJims7EkwIyWh0AZCT8t27NuWYNsW1FTI+RH1rCUshe5ETqDFJaHL1Jd1Uqz1 BXeDhclA6eCkFpGCUVxLlQ0YcKhHUPoIcAazy7WsBFWdkwkmpYDQwop0vJdWk+rS+d7yUNvN w0XtedGFJoLIt4md7KRwe8ki5FApWPmeTVSkYlTvCLhyCvjOBIlvRCk02LyGDZ+Lg7UbZ6bU XRYHN17KcbCWnt6Lis11RalC5VKFqdUrq9Wr91u9I+XegTdiCxX5xiOaboalPlQUlaDCNhsW ReF2bWc1mjb4+2B/z9Q74kR3zjehlvgABP8DyBOD9RLdxg+BEhfJ08Prq70Cpb4ZCRKfihaU Ic08pyhVW8yLXKUcLP7XQsmmreTELlt8vn2Xg43XBfhoTARf/PbjbRHnR/gi9yJdfH34e/Lk +PD0+m3x223xfLt9vn3+78Xr7WbkdLg9fVc3nb5+e7ktHp9//2aWfkyHmmgAsWsLnbJ8dRvP sZbtWEyTOzkvMIbMOslFamzN6Zz8m7U0JdK0WW7dnL6LonO/dkUtDpUjV5azLmU0V5UZmj3r 7BE8FNLUuBQmbQlLHBKSuth3ceSHSBAdM1STf3348vj8ZQydh7SySJMNFqRaIMCNxmvkRmvA TpQNuOPKiYz4ZUOQpZyQyN7tmdShQmM2SN6lCcYIlUvSUgQE1O9Zus/weFox1ttGHH8VBpQX yOAXbRf8ogXRnjCVrx4+204xlIkIsT2nSDs5Nm2MAIB3zq59oSxXqlyTmq9TxLsFgn/eL5Aa dWsFUspVj/7rFvunH7dF/vC3HpJifqyV/0RL/CUdchS1IODuEloqqf6BFeZBL4eJhjK8BZM2 6/Pt/maVVs50ZN/T167VC89JYCNqyoTFpoh3xaZSvCs2leIfxDZMBhaCmiKr56sCj/EVTH3J hzIzLFQFw4o9uEYnqLtzQ4IEB0coZPjM4c6jwA+W0ZawT4jXt8SrxLN/+Pzl9vZz+uPh6T8v EGsSWnfxcvufH48QAwXafEgyX9B9U1+22/PDb0+3z+NNUfNFco7J60PWsNzdUr6rxw054LHR 8ITdDxVuxfabGXCBdJQWVogMVuZ2dlNNEdWhzFXK0YQD/N/xNGM02mNLeWcIUzdRVt1mphCF g7Fs4cxYcSMMFjl4mGYC62hJgvS8Aa57DjU1mnp+RlZVtaOz604ph95rpSVSWr0Y9FBpHznY 64QwjtWpz7aK0UdhdqhXjSPlOXJUzxwpxuWEO3aRzTHw9OPKGof3IfViHoxLYRpzPvA2O2TW uGtg4cIC7LZmeWavpUx513LSd6GpcShUbEg6K+oMjz4HZtemEKMETywG8sSN1U6N4bUeE0Mn 6PSZVCJnvSbSGlNMZdx4vn6ByKTCgBbJXg4cHY3E6zONdx2Jw4ehZiVEeHiPp7lc0LU6VjE4 E0tomRRJ23euWhewAUIzlVg7etXAeSG44HY2BaTZrBzPXzrncyU7FQ4B1LkfLAOSqloebUJa ZT8krKMb9oO0M7DWS3f3Oqk3FzxHGTnDkS0ipFjSFK9+zTYkaxoGTp5yY+tdT3It4oq2XA6t Tq5x1pgBhTX2Im2TNbMbDcnZIWkI/ojX0CaqKHmJB/jaY4njuQvseMgBNV0QLg6xNV6aBCI6 z5p+jg3Y0mrd1el6s1uuA/qxaSQxf1vMVXTyI5MVPEIvk5CPzDpLu9ZWtpPANjPP9lVrbqkr GH+AJ2ucXNdJhOdbV9jIRS3LU7SLDaAyzeaxDFVYOD+Tyo9urvucV2hf7Hi/Y6JNDhBaCVWI C/nfaY9N2AT3lg7kqFpyYFYm2YnHDWvxd4FXZ9bI0RiCTR+VSvwHIYcTau1oxy9th+bLY2Sg HTLQV5kOrxx/VEK6oOaFJW75vx96F7xmJXgCfwQhNkcTs4r0M6VKBODTTQo6a4iqSClXwjj+ otqnxd0Wdo6JFY7kAmemTKzL2D7PrCwuHSzYFLry13/8/fr46eFpmFTS2l8ftLJNsxubKat6 eEuScW25mxVBEF6mSFqQwuJkNiYO2cAWWn8yttdadjhVZsoZGsai8dUOmz0NLoOlh7UK/FQZ dVDCy2tuI+pcjvnhGi+bDxkYO6cOqRrVI5ZKxkEyMdcZGXK2oz8lO0OO9/BMniZBzr06CegT 7LQMVnZFH3e7HUTdvqezh9Z37bq9PH7/4/YiJXHflTOVi1zfn3YmrEnWvrGxaaEaocYitf3Q nUa9GFz8r/Hy08nOAbAAf+hLYu1OofJxtbaP8oCCI8sTp8n4MnMNg1y3gMT2lnGRhmEQWSWW X27fX/skaEbTmYkN+obuqyMyNdneX9JqPPiwQhVWO0tEwzJl3vqTtUWsArqPk1Ozj5G6ZVrd WIU0FMaROKVf9h7Brod46ujlk25jNIOPLwaRn+8xU+L5XV/F+DO060u7RJkN1YfKGoDJhJld my4WdsKmlJ98DBYQR4LcdthZ9mLXdyzxKAyGNSy5EpRvYafEKgNPOcYO+JjKjt7J2fUtFtTw Jy78hJKtMpOWasyM3WwzZbXezFiNqDNkM80JiNa6P4ybfGYoFZlJd1vPSXayG/R4fqKxTqlS uoFIUknMNL6TtHVEIy1l0XPF+qZxpEZpfJsY46VxQfT7y+3Tt6/fv73ePi8+fXv+/fHLj5cH 4uiNeTpNGTrTSoy20hScBpICy1p8+KA9UMoCsKUne1tXh/dZXb0rE5gJunG7IBpHmZo7S661 uZVzlMgQ6hXXh+rNoCv0GMvR4ukQDJP4WMDI9sgZBqWZ6As8mhpO8ZIgJZCJSqxxjq3PeziF NLj7tdChTkfHyuqYhhLTvj9nsRHdVA2O2PkuO+Oj+8/qPw/Mr7V+mV39lJ1JD5w+Y/oAZgCb 1lt73gHDcIdIX7/WcoChBbcy38H4Tr8pOsBdYqymyV99kuxxqkMaCBH4vv3CWshx2+aCcQE7 cJ7h/HIgVFylurjfogFZtn9/v/0nWRQ/nt4evz/d/rq9/JzetF8L8b+Pb5/+sI9JjrLo5MSJ B6qCYeDjlvr/5o6LxZ7ebi/PD2+3RQG7QtbEcChEWvcsb83TGwNTnjgEUL6zVOkcLzF0UU4p enHmRuS8otBUqz43IvvQZxQo0s16s7ZhtJovH+1jCDBFQNPZx3lnXagQ0UyfCULicWI/7JcW yc8i/RlS/vOZRHgYTfkAEqlxSmiGevl2WOEXwjiReedr/Ji0s9XBlJmWOm93BUVAxIaGCX3d yCTViN1FGueyDCqDvxxcek4K4WRFzRp9TfZOwi2YMslIajhzRVGqJOb+2p1MqxOZH9pWuxMi IMttBgbS5H5hp8BF+GRO5uk6483m9O1OxfIjdTSc7t65HfyvL5LeqYLncca6llS/uqlQTaeo fxQKAU+tBtcofTCkqOpida2xmggdfE2jLnCOBdJJWOUnxWZsuaoezHdyQI4et44KAriv8nTH xQFlW1v9deh6CdlPzWgNqgCF8gLTZDZsZWCbBpnjVYAi2HrItTimFm+70gY0idce0o2TtOci texIIiXUFX176Mo0a5AS6P55ht+UxZFonHcZCjIzMvj8xQgfeLDebpKTcTpt5I6B/VbLmCqT yFHnPHXyc4oy7CyT1IFMI/lpQinHM3iECR4JY+1SlaIrLyht8sEy/AfxAalEJQ48ZvaLxmDY qE+1R0oBL1lZ0dbdOAhzx1kR6Q5NVCc851TK+ci/aZeyQrTc+MqOiLkrU9y+fnv5W7w9fvrT HnjMj3Sl2nBrMtEVeo+R/aqyvuZiRqw3/PMHenqjMhD6mH9mflUn+co+0AeFM9sYi3x3mNQW zBoqA5dAzPtw6gqFCuNOYT26q6gxauaRVLluHBUdN7B1UsLO0+EMuxPlPptD98oUdpOox2zH 7wpmrPV83dfCgJZyVB5uGYYbrsf5GjARRKvQSnn2l7rnhaHkENRd95NyR0OMIi/OA9Ysl97K 0z3SKTzLvdBfBobrmuHqStc0XKhtUVzAvAjCAKdXoE+BuCoSNPxkz+DWxxIGdOlhFKZKPs5V HbW/4KRJFUtV6z90cUYzjX5KQxFSeFu7JiOKbj8pioDyOtiusKgBDK161+HSKrUEw8vFuq41 c75HgZacJRjZ79uES/txOZXAWiRBw9HoXQwhLu+IUpIAKgrwA+C0yLuAB7S2w50bOzRSILgU tnJRfoZxBVOWeP5KLHVfMENJzgVCmmzf5eZG7dCrUn+ztATXBuEWi5ilIHhcWMvhiEJLgbMs s/YS6zfvRqPAE/xsm7AoXK4xmifh1rO0p2CX9TqyRDjAVhUkbDqemTtu+BcCq9a3zESRlTvf i/WBk8KPbepHW1xjLgJvlwfeFpd5JHyrMiLx17IrxHk7LzDc7fQQDObp8fnPn7x/q8l3s48V //i6+PH8GZYC7Guli5/ut3f/jSx9DNvZWE/k2DOx+qH8Iiwty1vklybDDQoh7HGOcLvy2mKb 1HIp+M7R78FAEs0UGQ5Uh2xqEXlLq5fy2jLaYl8Eg1e4WbLty+OXL/YncLzJiDvrdMGx5YVV yYmr5PfWuPZgsCkXRwdVtKmDOcjpYhsbJwUNnriPb/BGzHKDYUnLT7y9OmjCws0VGa+i3q9t Pn5/g9PEr4u3QaZ3rSxvb78/wgLRuMS4+AlE//bw8uX2hlVyFnHDSsGz0lknVhjuuw2yZobX DYOTZmi4IU0/CO51sDLO0jJX/Ie1Gx7z3JAg87yrHHoxnoOnIHMrXfbPhz9/fAc5vMI57dfv t9unP7S4PHXGjp3ufnQAxiVfIw7SxCjfQiwpWyOQoMUaAVFNVoXzdLJdWreNi41L4aLSLGnz 4zusGYAWs7K8Xx3kO9kes6u7ovk7D5rOPRBXH6vOybaXunFXBDa9fzEv/lMaMD3dtBDaW5sn ACC/sKto421sBk0XADokckp5pcHx2vkv/3p5+7T8l55AwFkgfXKsge6n0GInQOWpyOZ9Ngks Hp9lx//9wbhFBQl52e7gDTtUVIWbK1MzbHRcHe07noF/rdyk0+ZkrOaCKwMokzXvmRLbUx+D oQgWx+HHTL9FdWey6uOWwi9kTtYN7vkBEax1b2gTngov0IdJJt4n0np2uncrndc/oyben/UA oxoXrYkyHK7FJoyI2uNR9oTLEVhkuHbUiM2Wqo4idN9uBrGl32GO8jRCjgp1d78T0xw3SyKn RoRJQNWbi9zz/4+xq2tyE0m2f6Vjn/ZG3NkRIAF6mAcESGJaBTSF1Op5IbxtjbdjbLej3RM7 c3/9zawCVFmVIL+4rXOS+v6uzCzuC01w1dUzTORnwJn81emWeiklxIIrdcUEk8wkETOEWHpt zFWUwvlmsski2KQwxbJ5CPx7F3Zc6I6pSg4ikcwHeGNHnkMgzNpjwgImXixM96pj9aarls07 EqHHdF4JW/z1InGJraDPAo0hQWfnEgX4KuaSBPJcY89FsPCZJt2cAOdaLuAB0wqbU0weJBsz thIMmMFAEo+rl7qYHz6xZawnWtJ6YsBZTA1sTBkgvmTCV/jEQLjmh5pw7XGjwJo8wXetk+VE XYUeW7c4aiwnBz8mx9AJfY/r6iKto7VVFMw7j1g1H2CFcXOGy2Tgc81C493+kezFaPKmWt86 ZdsZMmOAVAVyNonJod4zHQwq0+dGbsBXHlM5iK/4xhLGq26biOLAT46hOk0ZtTMIs2YN5AyR yI9XN2WWPyATUxkuFLYe/eWC62rW6RHBua4GODdbyPbei9qEa9vLuOXqB/GAm70BXzEjrJAi 9LmsbR6WMdd3mnqVcr0WGyDTOfVpHI+vGHl9JsPg9BbX6Co4NbPrwcDjFj6/PZUPonbx/rXB ofO8fv0JNvI3uo4Uaz9k4nAuP0ei2Nl3B+OMJtEcUKCvhoaZG9TV7wTcnZo2dTl6HXWdUhnR vF4HXKmfmqXH4ain0EDmuQJGTiaCaWuO8toYTRuvuKDksQyZUrQu/8aFx3m5DrgmfmIS2Ygk S8i109gQbKWIsYZa+B+7ukir/XrhBdyaR7ZcY6OXKNfZx6M6FwOh3/bjVv3WvYRB0PPOMWIR szFY6hlj6ssTsyq0dQ1GvPWJu+8rHgbs/qCNQm7pfsaGwow8UcANPFDC3BSb8mXctJlHjoiv nbnXyxn9Q8vL1++vb/NDgOGkEI8pmTbvqDxk+Bbe4I/OwexdvsGcyGUvupXIbIcpiXwqU+gI XV4qF3J4C1nmB0cRDB93z8tdYRYzYqeiaY/Kjlp9R1PYVcalP16y4lv3ckeuqpNzYalKoCqN 3CRdk5iamX2PMZ/bwRiwoZubIMRk4nlnG6MDQ/bIRKzHNHqTjoNsTpB9IQsqU4gdOp2xQO1i ETDzvZsereouIdL3gXWBn26taAdNIXzQkSiWDPjZVjipu9pSVqrxXXITgZ5DVHbOkiaj3NTb vpyuYI0ehQlwsApNdbAJiDhZ16igknWTWd/qy1SrttQA5C+6pN5QcU14C6uIobdZguMj84KG POJWkapRhgbRPx+vlwhdRgv8N6tYRHvf7aUDpQ8EUiqse2w4ndiZlrxXgrRjTKOly9SjrhhR gECNHzswBFDK9OAqj1Z1bK2GNZh4USnVSPJuk5hmdD1qfJsmjZVYw2LMrvLCTjGOMWTR0qrG qtZmMIY05tiXfn65fH3nxj47TGo6eh36hiFpCHJz3LqOQFWgaB1o5PpRoUYL0x+TOOA3zJOn vCurttg+OZzMD1tMmHSYfU7845ioOiNWB77jCbeV7rEwjmfHSHmfLenoei9hNRPbv5VHrF8W fwVRbBGWI1EcKBOZFoXlg7r1wntzRd57PMB7IlNLRf0c3SEsLLipVKGvKKy1anDVK4mtg2Y3 6GRz4P7xj+tGDw2ylSvtA8xhW3YvaIqUzE7Q4C3dICtbvaDROoh1G2oqmspzCNT94rhoHiiR iVywRGLaCCAg8yatiHMxDDctGIMRIFA5wBJtjsR0CSCxDc23P05btCuGlGwzCloiZVVUQhwt lAxVAwJzmNnZRxim1bMFC3IZMULDZcl1Rm4eus1TrRS1khLagTEf4uIG1mTFiVw1I0oyoX6j 7sHRAWkuRswxNuqpU1YnrrwwLYt6cJMcDpW5v+vxoqzNq7AhbYJLsFKCFegkPe+cBWYvpNZO 0EDzrDdINiRoYuEXqvsbJbtNT6bS5+G8sr4ZoY7Y0Z2UhXlRtaaVqAabwnQFf6IeoLSIVQ8K Y4KXxDJFYydJdBl7kGZTYWp66T1dX+uydxX9/Pb6/fX397v9398ubz+d7j79efn+bhiXjCPx LdEhzl2TPxHz/B7oclOJR7bJjpRO3RRS+FStEZYQuWnbp3/bW4gR1ToEavYpfsu7+80v/mIZ z4iJ5GxKLixRUcjU7VA9uanKzAHpVNyDjkecHpcS+ndZO3ghk8lY6/RAXogzYHMwM+GQhc3L hSscm9tbE2YDic3tzQiLgEsKPnUKhVlU/mKBOZwQgA1/EM7zYcDy0P+JH00TdjOVJSmLSi8U bvECDssDLlb1BYdyaUHhCTxccslp/XjBpAZgpg0o2C14Ba94OGJhU5N0gAXsfBK3CW8PK6bF JDiDF5Xnd277QK4omqpjiq1QRkr+4j51qDQ849li5RCiTkOuuWUPnu+MJF0JTNvBdmvl1kLP uVEoQjBxD4QXuiMBcIdkU6dsq4FOkrifAJolbAcUXOwAH7kCQf3th8DB5YodCYrJoSb2Vyu6 IhjLFv55TNp0n1XuMKzYBAP2yI2hS6+YrmDSTAsx6ZCr9ZEOz24rvtL+fNLoq6MOHXj+LL1i Oq1Bn9mkHbCsQ6IEQLnoHEx+BwM0VxqKW3vMYHHluPjwALfwiKGPzbElMHBu67tyXDp7LpwM s8uYlk6mFLahGlPKLA9Tyhxf+JMTGpLMVJriU07pZMr1fMJFmbXUnGCAn0p10OEtmLazg1XK vmbWSbDDObsJL9LaNkcfk/WwqZIm87kk/NrwhXSPaolHajk/lIJ6t0TNbtPcFJO5w6ZmxPRH gvtK5EsuPwK9nz84MIzb4cp3J0aFM4WPOFHxMvCIx/W8wJVlqUZkrsVohpsGmjZbMZ1Rhsxw L4gTg2vQsHWCuYebYdJiei0KZa6WP8SOkbRwhihVM+si6LLTLPbp5QSvS4/n1BbRZR6OiX5Y LnmoOV4d3U1kMmvX3KK4VF+F3EgPeHZ0K17D6D5vgpLFTrit9yTuY67Tw+zsdiqcsvl5nFmE 3Ou/RAuUGVnnRlW+2rkNTcZkbajM2bXTxIct30ea6tiSXWXTwi5l7R+v2r+AYJat37BHfqpb aD2pqKe49r6Y5B5zSmGkOUVgWtxIA4ojzze2/g3spuLcSCj+ghWD9QZG08JCzizjKm3zqtSu p+jBQRuG0By+kN8h/NbKq0V19/29f5dgvP1TVPL8fPl8eXv9cnknd4JJVkBv9011rx5Sd7fj QYH1vQ7z64fPr5/QUfjHl08v7x8+o8oyRGrHEJGtJvzWrsauYc+FY8Y00P9++enjy9vlGY+P J+Jso4BGqgBqtj2A+ulxOzm3ItMu0T98+/AMYl+fLz9QDmSHAr+jZWhGfDswfeqvUgN/NC3/ /vr+n8v3FxLVOjbXwur30oxqMgz9JMrl/b+vb3+okvj7/y5v/3tXfPl2+agSlrJZW62DwAz/ B0Pom+Y7NFX48vL26e871cCwARepGUEexebY2AP01fgBlP27A2PTnQpfa6Bfvr9+Rtupm/Xn S8/3SMu99e34ph3TMYdwt5tOish+bSQXZ3JJqQ7W9FsNxmhQZDnsyg+HfAeb7+zU2tRePZHJ o+gMIxYTXFOl9+hd3qbhmzER2qTnX+K8+jn8OboTl48vH+7kn/92n0S5fktPPAc46vGxvOZC pV/3ukSZebegGbyUW9rgkC/2C0tFxwC7NM8a4p1UuRM9mYO4FQF6IR0KKfn68e315aN57bcn J+rEBzP86O/M1AUaHZp0QHa7UCv8awiHNu92mYB92fk6VWyLJkd/1I5vqO1j2z7hsWnXVi16 31aPy4RLl1dvnms6GG/UBmURx9uZ7Lb1LsH7LaNplwVkDZ27GPFvuta0rNG/u2QnPD9c3nfb g8NtsjAMlqaBQk/szzDQLTYlT0QZi6+CCZyRh6XV2jO1Hg08MJfsBF/x+HJC3nwOwMCX8RQe OnidZjAUugXUJHEcucmRYbbwEzd4wD3PZ/C8hiULE87e8xZuaqTMPD9eszhR4yY4Hw7RWDPx FYO3URSsnLam8Hh9cnBYZz6Re9ABP8jYX7ileUy90HOjBZgoiQ9wnYF4xITzqIwKK/OdRaEu edBLXZmX5o27cG6TFCJhv55ZmBqSLCwrhG9BZBK9lxFRFxwueuzebcJKASatyJA6CGD/b0y3 9AMB45F4TEydkYEh7vAG0LJeHWHztPIKVvWGuMkfGOt18wFGZ8gO6HotH/PUFNkuz6g76YGk FrEDSsp4TM0jUy6SLWeycB1A6phsRM3btrGemnRvFDUquKnWQbV2eo8y3QmmMOMYRZaZ62xG z3cOTILAy3JTe6JYqmVi/yLR9z8u78ZiYZzlLGb4+lwcUGMOW87WKCHlSEi5tDZv2/cCHY9g 1iV9thcK4twz6kSvqWD51NAPlSIH6WL3sDUmB0490NHyG1BSWwNIu1kPUr2rg6kf8rg1VoDo Nn1fBGG0oPUra6GeklWU0a+3GaAhPuyJEsZWc3Dx0NOn0MyVq/g5zu51UZvHTHvo0/n4gqV5 xDKqpFOAZn8Am1rIHSMr923twqRYBxAqq61cGFVaSIsYCDWQbMwFyMCcNkwK1b301s1gr0FL fFiPFLVZHWDLTaaCoTLrDEcxovVhULYqlsgPh6SszszrodrZQrev2vpAPAxq3BxWqkOdklpS wLnyzLXBFSOi++SUd6lpJw0/UK8Fhl1imT4IQhXlNRnpU+XQwQpkxK72F3qP/fl19A2lHFwk jYCd1++XtwtuJz/CvvWTqf1WpOQ4DsKTdUz3bT8YpBnGXmZ8Yl2DUUrC8mzFcpY9qcFA1yQ+ ZQxKpqKYIOoJoliRBaVFrSYp697ZYJaTTLRgmY3w4pin0izNowVfesgRs16Tk3r8rVkWdaZl whfILhdFyVO2n0szc76oJbl0A7B9PISLJZ8xVFqGv7u8pN88VI05tyJ0kN7CjxPo0oes2LGh WeYFBnOo0n2Z7JKGZW0jWZMyVx8GXp3LiS9OKV8XQtS+vUA0az+LvPjMt+dtcYaFlHUXjqWn nEdLClaPUKv0hnlAIxZd22hSJjDWbopWdo8NFDeApR/vyXk1pjgp7vEZJqu6N63XpekR64kn MvMxFEXAaijyvC471S5B1k092IXEpslEu11Cbnp6irr8NIrWct45yKdPu/IoXXzf+C5YSjfd 1HHTAMqGYg30pU3eNE8TwxIsZlZemJ6CBd99FL+eosJw8qtwYgxifUjSQZe4f25yfHUIl1bG aqs9blhhg5hM26bCx3SMafmcOtOoPpQTDFYyWM1gD8O0WXz9dPn68nwnX1PmpauiRBVdSMDO da9kcrYVl835q800Gc18GE9wZ4+ssykVBwzVQsfT5Xg9b+XyzlSJ+3xrW/Terfog+RWIOpVs L39gBNcyNUfEfHxUlyFbP1rw066mYDwk/llcgULsbkjgAecNkX2xvSGRt/sbEpusviEB88IN iV0wK2Hd1FLqVgJA4kZZgcSv9e5GaYGQ2O7SLT85DxKztQYCt+oERfJyRiSMwokZWFF6Dp7/ HN1i3ZDYpfkNibmcKoHZMlcSJ3VedCue7a1gRFEXi+RHhDY/IOT9SEjej4Tk/0hI/mxIET/7 aepGFYDAjSpAiXq2nkHiRlsBifkmrUVuNGnMzFzfUhKzo0gYraMZ6kZZgcCNsgKJW/lEkdl8 Uqthh5ofapXE7HCtJGYLCSSmGhRSNxOwnk9A7AVTQ1PshVPVg9R8spXEbP0oidkWpCVmGoES mK/i2IuCGepG8PH0t3Fwa9hWMrNdUUncKCSUqI/qwJJfn1pCUwuUUSjJDrfDKcs5mRu1Ft8u 1pu1hiKzHTO2dZIpdW2d06dHZDlorBh7Kxp9wvTl8+snWJJ+6x3c6BNvN9bkvNPtgVr8kajn wx2yoox1d5k09oAKamqRpmyOkbaEk1VAdrsKVOmsU4mOWGLiJWmkpcgwIoYB1DhfTuoHWG+k XbyIlxQVwoELgJNaSroBH9FwYSo+F33Iy4W5jRxQXjZemG7DED2wqJY175+hJDRKdn8jSgrp ipqeP66oHcLBRTMtuw5NKxBEDy4KIeiydALW0dnZ6IXZ3K3XPBqyQdhwLxxbaH1k8SGQ2GxE sq9TIxloz1XIGuDIM3eVgO848KAsLXGIYz9RqXFgAZ84oL5Bc6ShGmC0xsQvVxRWLc+sBcxQ e0STQponxB9CCZvT2spsH4obtC5FGx6S6BB9kTm4Kh2HuMr7pqbSUKceBzqSOoWOrIZt6THh tvxI0C/wHgxf3cIxhhzDaZ8FWzJk3ONwcU6t07He6p+CuchP1nFX81tiHQw2kVz7xLICwTiJ gmTpguRA5QrasSgw4MAVB0ZsoE5KFbph0ZQNIedko5gD1wy45gJdc2GuuQJYc+W35gqAjG4G ykYVsiGwRbiOWZTPF5+yxJYFJNxRcyWcM/fQXmxRdE6xy0u/S+sdTwUT1FFu4Cv1rJnMrQPr wcEFfIlDm312S1hyE2uw0Mv4hZOEperRVNjWr/qg/6pwyd79DQKw1JIqiNQ8j1TOV7wF+6Xm /GluGfC3jZjOYluccg7rtsfVctHVjWnPobzCsPEgIdN1HC6miCBhoqfqhiOk60xyDCRI2H6E XDaeZddmlnR86ZFAxanbeqm3WEiHWi2KLsFK5HAP7+OmiIal9uEU7MovVUiuvJuBECQDz4Fj gP2AhQMejoOWw/es9ClwyytG23Sfg5ulm5U1RunCKE1Bo7O1aE/nXEi573whetgJPEi/gvtH WRclfT7pill+bQyCbhQMgr6AZxLkATSToJ7Q9jIX3bH3rGdspeTrn2/P3NOU+M4CcfKlkbqp zBduClgtBB3NKJTI5pBpiqCySa0byUGpyXrVYbh+s/HelaIDD44UHeJRadBZ6LZtRbOAFm/h xblGV1QWqhShQxvFW1ALajInvbpzuSB0rb20YK35bIHaF6KNlnUqIjelva/Crm1Tm+qdUzpf 6DrJNmeMBQcysy8cahl5nhNN0h4SGTnFdJY2VDeFSHwn8dBCm9wp+1LlH/WnknoimXUh2yTd WzfayGhfYwejT8GUeIqEUvcmb6UlrUCHQkVrQ5ZqiwpVT7f0Pn/wzGm3B7zbhy24UwjoBcxu ADh78Vn8FXdPNHly3/e8VHCoaI+mv8N+CVFBiTDCrVm/eZ8JyHrhlvXZdIsXB9gIRRMzmLkB 70HzzRMdBZoo4CMIaevmWbboodKsjxQKwHOb/XgvycMQPnEZM+AEVE/MKTsCiCNc4h2rdQZk DYjjh0lx2FTmcQVabBBkUBzrxP5IWmICI0OAHbZ5hJZDPxrtGig8eFQkoL4Dd0C8MbfAPrWW ixV98ITnS4VZ4Dja1llqB4Hu60T2YMF6FSDkjqLYpKmgigziMSJSvqDg31NiY4mpzKAheax7 RzBaqxXNjF6e7xR5V3/4dFFP3txJ+2HnIZKu3rXo9tKNfmBwS36LHl2zzcipsUbeFDCDuqrk 3sgWDdPRmRxg7aUHTxjafVMdd8ZBYLXtLB9c6s3XScx5WWQ0vKFf9CtKC+03HDOoHX5RI3gS ptEtFFgnSQgD0ntk6rK22xRlBn1cMkJZIVXB986/Nk9DERnJD9a4IHx0soW4Wz7YGyxIN/Ae 6y3evry+X769vT4zPmJzUbW59bjKiHUpUakdhq5TfYQ5hT4V3CqVxF+IsZwTrU7Oty/fPzEp oarB6qfS6rWxa1QE1sff+HzZNEOPqB1WEiMtg5amYb3GR5ds1/ySfI0Vh3YaaIc11AYM5F8/ Pr68XVzPuKPssODWH1Tp3T/l39/fL1/uqq936X9evv0PPhL0/PI79NDMsvvtrwfkK+MQWBvP pUl5Mk+9ehRvQPJEHskLxf3jz5CytChNLfzrK88jc7VaY9KgE4dPG33k0wbhOOqY+jdOwzhD H1hCllVVO0ztJ8Mn12S5sV/n9rWnUmBaooyg3I5OPTdvrx8+Pr9+4fMwbBssqxMMQz1USkw8 EbSf9+mlxgDGtLPxatvdc/3z9u1y+f78Acbnh9e34oFP3MOxSFPHoTKexcpD9UgR6uHgaE6W Dzl69KULz92RuAitkwQPaIZnzq5GwjeSOhqYTreQwYaVWI66geCW6a+/+GD67dSD2Ll7rLIm CWaC6V8Yvt7/Mb2sX6FYo3S5bRJy+YmoOsF+bMiTzHp4IxeYiA03o1dfflwq/r+1L2tyG+fV vj+/oitX51RlZmx5aftiLmRJtpXWFkl2u/tG1dPtSVyTXk4v75ucX/8BJCUBINXJW/VVZbEe gBTFBQRJEFDl+/x28w06y0Av1SdzMEFgwJCQ9D4tCUHCN9R/rkarVSygJAnkSWMRYmTCpGA+ OBTlM95acVL48WAHFaENWhiX162kdpxDIqMKtiq/q0oLr7CwykovxZ9CL4OsqoRkMrosG7zO 5qC92jqIKNHvZECnPjRSdELWNjSBp27mkQumm/mE2ck78LqxE527mefunOfuTDwnunDnce6G fQtO8xV3mtwxT915TJ3fMnWWjh7lEDRwZxw5v5sd5xCYnud0ivCGbsUR9TgEJTqm2+t5MLxl X+1dWMPCfRgcs6fzpYGLtNFvrCxSfxktyHdFInafDiB3Sj/lBW1dru/zpPY3kSNhyzT5GRMR YDu1sdRN+EpoHk7fTg8Dc4bxub5Xe7LduHakoC+8rtlk8mtqXJsB1mK0X5dRZ99tHs82j8D4 8EiLZ0jNJt+jP1z49ibPwggFPJmWCRPIYdwR8FkIEcaACkjl7wfIGNG3KvzB1LC60SctrOSh rFZcGJmuYS50mg8mdNzPGCTqzclhEnQci9jXbBPtWTRZBrcFy3K61HCyFAVdf3GWbhyG65iO hzroY2BF319vHx/McsCuJc3c+GHQfGKXnFtCGV+zOyEGX1f+ckpFpMH5hWUDpv5hPJ2dn7sI kwn1SNXjIpo2JSymTgIPwWhweWWphetsxmwBDK4nZDz+R9e+FrmsF8vziV0bVTqbUfesBkbf K84KAUJgX24FPSKn8TPDkO1Aqx3bEIRYINGI6k9G7wdNeU0vY9fjJgHFuSbqBJ72RGnMjjsa Dqgtkk1BX9lBclMj3cMz9lB2RRpVeNzgzaK6CdYcj9ckX32Po8miVK786SXF0F9g5IywZF/S bgGXBXMtr7fI12ng8SpqN7lT1sI43GZTD6N6WDhMHvSQKqZtGqP7cuFLvMeaYOWEeXAVhstl FKFuL9XaZ5fKl13gPfaGxWBA2ISSdng7R6r+yfbW+jQWq3prheK9Y/EoS3VpO6PXsDPHvmit pPwl32JEOWmhJYUOCYufagDpq0uD7Bb5KvXZLSx4no6sZyvNVN7QX6UBSBYVrTtxozIPQmE5 hb7HQgH5E3plFDpKGdK7rhpYCoAaEpFYTfp11FeNamVzuVxTpVP/i0MVLsWj8E6gIO6b4BB8 uhiPxkRkp8GEuUSFxSIovzML4Bm1IHshgtxIMvUXUxp4EIDlbDZuuG8Fg0qAFvIQQNPOGDBn 3hOrwOeuWKv6YjGhF4wQWPmz/2++7xrlARKjkNR04zg8Hy3H5YwhY+qQFp+XbFCce3PhRW85 Fs+Cn1pOwvP0nKefj6xnEO+gxKFze3QqlgyQxcCEaX8unhcNLxq77YfPoujnVG9Ah4GLc/a8 9Dh9OV3yZxoczQ+X0zlLH6vL2KAwEVDvC3IMN/hsBKYefxZ6gnIovNHBxhYLjuGhlbqIy+EA zWtG4m0q+huHQn+JkmZTcDTJRHGibB8leYFBNOooYE5r2lUbZcdT8KREDZLBOMGnB2/G0W0M 2hvpqtsDi1bQHgKwNOjUTdSujvYtsQBvhlsgxgEUYB140/OxAKhnBQVQi2MNkI6AOi0LkIzA mAXc1MiCAx51n4AAi56NLh6YE6g0KCYe9RKMwJTe/kFgyZKY66J4lQiUboyExNsryprrsaw9 vede+SVHCw8v6zAs83fnLGICmmZwFq11y56mlOs9dhR5SVhv8KnIjM0htxMpjTwewPcDOMA0 DKwycLwqc17SMsPA26IuunWVrA4dm5Uzq7isAlK9Ff2y6h0JOiOgRqqrgM5HHS6hcK0swB3M miKTwKhlkLLoCkaLsQOjplItNq1G1EObhsfeeLKwwNECPU3YvIuKRf418HzMHU4rGDKgtws0 dr6kCzONLSbUTYjB5gtZqAqGF/MvjGgKS8yDVSt1EkxndCya0PAwBBknOuWYWEJzv56rgHzM 7SNoxsp3IsfN9o4Zg/+5n9r18+PD61n0cEePGUBXKyNQQPgZiJ3CHNs9fTv9fRLKxGJCZ9pt Gky9GcusT6VN574e70+36N9VRQWleaFxVFNsjW5JZzwkRNe5RVml0Xwxks9SMVYY99MUVCyy Sex/5mOjSNF7B90dDcKJ9KylMfYyDUlvlljsuFQ+NDcFVVmroqKP++uFUhp6sxpZWbTluNOn ShTOwfEusUlAq/ezTdJtiW1Pd23oVvQVGzze3z8+9M1FVgF6ZcdlsSD3a7fu49z50yKmVVc6 Xcv6rLkq2nSyTGqhWBWkSrBQ4sN7Bu0oq9/9tDJmyWpRGDeN9TNBMy1kPCbr4Qoj90aPN7ey PhvNmQo+m8xH/JnrsbOpN+bP07l4ZnrqbLb0ShGO0qACmAhgxMs196alVMNnzAeVfrZ5lnPp M3l2PpuJ5wV/no/FMy/M+fmIl1Zq9xPuXXzB4h+FRV5j5CaCVNMpXQq1SiJjAuVuzFaRqO3N 6fSYzr0Je/YPszFX/mYLj+tt6M+EA0uPLQ7VLO7bU74V/7TW4agWHsxtMwnPZudjiZ2znQKD zenSVE9g+u3Ekfc7XbtzCn/3dn//wxxK8BEc7tL0qon2zE2VGkr63EDRhyl6I0gOesrQbWIx Z9isQKqY6+fj/74dH25/dM7I/w8+4SwMqz+KJGnNWbTto7JGu3l9fP4jPL28Pp/+ekPn7Mz/ +cxj/sjfTadyLr7evBx/S4DteHeWPD4+nf03vPd/zv7uyvVCykXftYbVERMLAKj27d7+n+bd pvtJnTDZ9uXH8+PL7ePT8ezFmuzVptuIyy6ExhMHNJeQx4Xgoay8pUSmM6YZbMZz61lqCgpj 8ml98CsPlmOUr8d4eoKzPMhUqFYOdLssLXaTES2oAZxzjE6N/kbdJEjzHhkKZZHrzUQ7n7JG r914Wis43nx7/Uq0txZ9fj0rb16PZ+njw+mVt/U6mk6ZvFUAvbXrHyYjuehFxGMKg+slhEjL pUv1dn+6O73+cHS/1JvQJUO4ramo2+K6hC6XAfBGA3ug210ah3FNAwTXlUeluH7mTWow3lHq HU1Wxeds6xCfPdZW1gcaL1sga0/QhPfHm5e35+P9EfT4N6gwa/yxnWkDzW3ofGZBXOuOxdiK HWMrdoytvFowJ3ktIseVQfkmcXqYsy2ffRMH6dSbc1ddPSqGFKVwpQ0oMArnahSyExpKkHm1 BJf+l1TpPKwOQ7hzrLe0d/Jr4gmbd99pd5oBtmDDovFQtJ8cVV9KTl++vrrE9yfo/0w98MMd bmXR3pNM2JiBZxA2dMu5CKslc7anEGZ341fnE4++Z7Uds8gU+Myuw4LyM6Ze6RFg11phJc8i x6WgUs/485xu6tPVkvLUize5SGtuCs8vRnQPQyPwraMRPUn7XM1hyPsJEcDdkqJKYAaju3yc 4lHPEIiMqVZIT2Ro7gTnRf5U+WOPKnJlUY5mTPi0y8J0MqNByJO6ZMGokj208ZQGuwLRPeWR 0AxC1h1Z7nMn+3mBAelIvgUU0BtxrIrHY1oWfGbmTvXFZEJ7HIyV3T6uvJkDEgv3DmYDrg6q yZQ6nVUAPRls66mGRpnRPVgFLARwTpMCMJ3RyAG7ajZeeDQseJAlvCo1wnyeR6naW5IItQ7b J3PmDuIaqtvTh6Cd9OAjXduQ3nx5OL7qMyaHDLjgDjnUM50pLkZLtqNsjihTf5M5QeeBpiLw wzp/A4LHPRcjd1TnaVRHJdez0mAy85jXSC1LVf5upakt03tkh07V9ohtGsyYjYkgiA4oiOyT W2KZTpiWxHF3hoYmAhA5m1Y3+tu319PTt+N3bpGM2zE7tjnFGI3icfvt9DDUX+iOUBYkceZo JsKjjQCaMq/9WseiIROd4z2qBPXz6csXXI/8hrGNHu5g9flw5F+xLc2FPpc1Ad6lLMtdUbvJ 7WXJd3LQLO8w1DiDYDSIgfTop921Xeb+NDNJP4BqDIvtO/j75e0b/H56fDmp6GBWM6hZaNoU ecVH/8+zYGu7p8dXUC9ODgOLmUeFXIihqPnR1Gwq90BYFBkN0F2RoJiyqRGB8URsk8wkMGbK R10kcj0x8CnOz4Qqp+pzkhZL4xR2MDudRC/kn48vqJE5hOiqGM1HKbF/WqWFx7VrfJayUWGW bthqKSufRtgKky3MB9TMsqgmAwK0KKOKKhAFbbs4KMZimVYkY+bYST0LiwuNcRleJBOesJrx A0v1LDLSGM8IsMm5GEK1/AyKOrVtTeFT/4ytWbeFN5qThNeFD1rl3AJ49i0opK/VH3pd+wHj sdndpJosJ+xcxWY2Pe3x++kel4Q4lO9OLzp0ny0FUIfkilwc+iX8W0cNdS6UrsZMey542Ms1 Rgykqm9VrplvqMOSa2SHJXOWjuxkZKN6M2GLiH0ymySjdo1EavDd7/yPo+jx3SOMqscH90/y 0pPP8f4J9/KcA12J3ZEPE0tEfWTjFvFyweVjnDYYZDPNtY24c5zyXNLksBzNqZ6qEXY0m8Ia ZS6eycipYeah/UE9U2UUt2TGixkLD+n65E7Hp7fG4AHGasyBOKw5UF3GdbCtqTUrwtjnipz2 O0TrPE8EX0SvF5hXiovcKmXpZ5W5Id12szQyMXlUU8Lj2er5dPfFYeuMrIG/HAcHeqkC0RoW JNMFx9b+RcRyfbx5vnNlGiM3rGRnlHvI3hp50cCdjEvqaQEeZMAXhISlLULK8tcBNdskCAM7 1852yIa503+D8oACCozKhF71UJi8ZIhg60RDoNLcGcGoWLKLi4gZbxMc3MYrGpESoTjdSOAw thBqomMgUClE7maMczApJku6CtCYPj6qgtoioJ0RB5VNjYDqC+X9TjJKD+8KPYhuoEyvw1S6 HAFKAf16vhANxvxZIMCveCnEGE4z9xWKYMXsVF1T3uxRoPB8pbDEWwRFEgoUTWUkVEomepdG A8ypTwcx3ycGLWQ50BkNh9TdDQHFUeAXFrYtrVFUXyYW0CSR+ATtwYZj110Iorj8fHb79fTU el4lU035mde5DyMhpoqUH6KHDODrsU/KfYpP2dpWhUVRgMwFHbYdEV5mo+iOUJDatlTZ0Wlm usClKy0LjaLACG3220UlsgG2zsEUfEVIA6XhWAV6VUdssYVoVqc0hHrrbAEyC/J0FWc0AazZ sg1atxUBhh4LBihslksxlKH6gn7xKtutK1DhBxc8MJy2A6qLIPb4sh/tSyBBHtQ+u7+A4UEC RwQ5TfHrLb1CacBDNaZHHRqVUtqgUk4z2NgSSSqPUqUxtMW0MFh7J83mUuKJn9XxZwvVIlTC QlYSsA0LWVrFR8NDiTkcJmmCvjyb09UFIRTM/k/hPDqWwdRptIWiOEqL8cyqmioPMG6tBXNv fRrsooVIgu1/jePNJtlZZbq+ymhgKO3jrQ1D4wwr0xJNMBq9KtleYbzkF3WzsBdUGD+qhHHO Y1b2oApIAKtVSka4nT7xYlRebzhRRKVCHvQxZ2WiHYyxwIUGRic97hdrf3iuNOjPBfAJJ6iO t1gpt5cOSrM5JMO0sef/lDgBkRNHLg702f0eTX0hMpj4U5yvdfIAr9hyig7V5MhaB1zildM5 o1N+P63q1IGbHB/ZE0SFZpXneDWi2M4hUwIwH+Vf0qfXHDrYakXzAXb2nXO4vCzZZUxKtDtL S6lgbJX+AM1P9jknqRttKmqSXcQ0PoCIHOicxpuVlci4vnLgKLNxnnNkBeumOMtyR9tocdzs y4OHju+s2jL0EuZunlh785qcz9S9xWRX4eav3SfUxONqNE2w60TdF4R8oTS7mspaSl0c8Eut t4Fu23iLDBYGFZ3QGcmuAiTZ5UiLiQNFH3bWaxHdsdWZAQ+V3Y3UDQw7Y78otnkWoYf1OTvz RmoeREmOhodlGInXKCXAzs/4HPuMrukHqNjWngP/TLcietSuN4XjQN1WA4QqK6pmHaV1zjah RGLZVISkmmwoc9db4ZPRl779yaWv/C3ZeOfi2BZP/U1q9XQYDZDV0NqGsrNyul1/nB5WsS0E OhZ7YHYkEfMVaUbxDQsZn5sQldgZJtsvbO/HWj29I1hfWM2KvTceOSjmYi1SLDHfaTB2Mkqa DJDskvcriW0g2gjNeXH9OZ5AMaFKLBWho08H6PF2Ojp3KBFqMYoBdrdXonXUWnO8nDaFt+MU fY/ZyitMF2NXn/bT+WzqlAqfzr1x1FzG1z2stgnMYoLLaVAxMfSyqM8aXjdmHucVGjebNI65 u28kaHX/IorSlQ/Nm6aBi67cA8MUlQ8R7YTmpgRqrilz9sa10C4JupFg6/aU3rWGB+wgHNBO N7Vqe3zGECdq9/leW6XZK3J09hCk7AzzvXSdCk5dDkDtTvlT69OwuSzjOhK0C+jDdbv3aS6C 3D0/nu5IqbKwzJk3MQ0o94DoeZS5FmU0OqJFKn1uW/354a/Tw93x+ePXf5sf/3q4078+DL/P 6eixLXibLIlX2T6MaUjKVXKBL24K5m0JQ8RTD+fwHCR+LDhqotGxh3wt81NvVREaezD0D6B4 xnvubPlAU4lMlKMnvjurQbUlEVu8COdBTn3eGy8H0XpH7fY1e7s6itA9opVZS2XZaRLewBTv QZ1EvERP7mtX3uq+XBVS/zjdpCNy6XBHOVARF+Uw+SsRiVHeyRs6We2sDG2gLr+qdQzoTFJl +wqqaVPQlTKGDa8Kq07NTT6Rj3Lp2mLaEvXy7PX55lYd10nhwP0N16mOHo9XMuLARUBnwDUn CIt4hKp8VwYRcXFn07YwTdWryGeOf1Gu1lsb4UKwQzdO3sqJwqTvyrd25dseVfSmrnYNton4 1gg+NemmtDdNJAVd9xMxpt0GFyiHxMUJi6T8FTsybhnFUbKkBzTyckfECWvoW8yc5s4VxO1U mta2tNQPtofcc1BXZRxu7I9cl1F0HVlUU4AC5bvlukrlV0abmG46gfR04goM14mNNOs0cqMN c4TIKLKgjDj07sZf7xwo6+KsXdJCtgzd5YWHJouU35Imy8OIU1JfrXS5Bx9C0LfQbBz+Fa5u CIk7IUVSxeIfKGQVoTsXDubUI2IddRIKfhKfYv0BL4E78blL6hh6wKE3Eya2YA5nkzu8N7s5 X3qkAg1Yjaf0/B9RXlGImMAHLsszq3AFzB0FGV5VzJxtw5Ny1cVfUiVxyjbeETBOKJnrxB7P NqGgKdsx+J1FQe1GcSYfprAY2zYxe4/4eYCoippjvDYW7HGHPGxO6GzWgqyWhNbejZHQx9Pn iMqxGtf8fhgyX1Sdz/ga1GbQsmvuu5c7mM/RCheX8dR5q0KNj+fe1oqfi+vbWqdvxzOt3NOT ch8NW+oIOj/6EGFn5mvlV5uq/tGh9hqqmBmgOfg19b/fwkVexdCPg8QmVVGwK9m1EKBMZOaT 4Vwmg7lMZS7T4Vym7+Qi7AEU1q8byCs+rUKPP8m08JJ0FcBkw04Q4gqXCqy0HQiswYUDV45J uCdTkpFsCEpyVAAl25XwSZTtkzuTT4OJRSUoRjRXxcgZJN+DeA8+Gx/9zX7K8c+7nO58HtxF Qpiar+BznsEUDVpqUNIJhVDKqPDjkpPEFyDkV1BldbP22dkirDP5yDCACmCDsQLDhAxaULAE e4s0uUeX1x3cuWtszNawgwfr1spSfQFOjBfsFIMSaTlWteyRLeKq546meqsJtcK6QcdR7nDX GgbPlRw9mkXUtAZ1Xbtyi9YNLCnjNXlVFieyVtee+BgFYD252OTgaWHHh7cku98riq4O+xUq lkKcfYK5hyteJjvcg0dTSycxuc5d4NQGr6s6dKYv6VLnOs8iWT0VX5sPiU0cmlzGaqRZ6SBU Bc0zxoAXehSQacvPQnTacjVAh7yiLCivClFRFAadfFMN0WI9qNUz48FuwxqshRwy2xBWuxhU ugwdg2U+TtHsrVles34YSiDWgLBIW/uSr0WUY7hK+QBMY9UZqMdtLgDVI2jXtdqNV8rNmjl1 LUoADdulX2asljUsvluDdRnRXY11CrJ4LAFPpGLuIv1dna8rPhlrjPc5qBYGBGyzQAdpsFOw fppDQyX+FZeoHQbSIoxL1PdCKt9dDH5y6V9B+fKEOdQnrLgX53wzrAGzXH2gk5pGUD15cdUu CYKb2680cMS6EuqBAaRUb2E8nsw3zNlyS7L6sYbzFcqdJolZQCok4RCsXJjMilDo+/s7+/qj 9AeGv5V5+ke4D5XqaWmecZUv8eCVaRh5ElPTpGtgovRduNb8/Rvdb9GXFPLqD5im/4gO+G9W u8uxFpNBWkE6huwlCz63kXECWNAWPiyxp5NzFz3OMQBKBV/14fTyuFjMlr+NP7gYd/WarPRU mYUeO5Dt2+vfiy7HrBbDSwGiGRVWXrIVw3t1pXfyX45vd49nf7vqUCml7BgLgQvhNAgxtL2h QkKBWH+wkAHlgHov0tFrtnESltTTxUVUZvRVYqu4Tgvr0TWJaYKY8TUY4yYF9ZiSRukalrNl xKIP6P/a6u5PLux66vKJq0DNdxg8LkqpsCr9bCNnYz90A7rpWmwtmCI15bkh3Nqt/A2bA7Yi PTwXoGJyHVAWTQFSZZMFsZYPUj1rEZPTyMLVyY30qdtTgWJpgZpa7dLULy3YbvEOdy5sWsXa sbpBElHX8IYun6g1yzW7Sa4xpshpSF26s8DdKtaHYvytKXTPJgPt7ez0cvbwiLdSX//LwQJT f26K7cyiiq9ZFk6mtb/PdyUU2fEyKJ9o4xaBrrpH1/ShriMHA6uEDuXV1cNModWwj1VGYrnJ NKKhO9xuzL7Qu3obZbA49bnWGcA0xzQU9ayVXRZdyxBSWtrq886vtkxiGUSrvu2039U+J2vF xFH5HRvuOKcFtKbxTmZnZDjUxqSzwZ2cqH8Gxe69V4s67nDejB3MFisEzR3o4dqVb+Wq2Waq TjdXKhb0deRgiNJVFIaRK+269Dcpuvk32hZmMOlmfrk1kcYZSAmmZqZSfhYC+JwdpjY0d0NW iDyZvUZWfnCB7savdCekrS4ZoDM629zKKK+3jrbWbCDgVjwUbwHqH5vd1TPqJwluJ7ai0WKA 1n6POH2XuA2GyYupN0zEjjNMHSTIryHB/rp6dHxXy+asd8en/iI/+fpfSUEr5Ff4WR25Ergr rauTD3fHv7/dvB4/WIzijNXgPFigAdmCpi1YntmpmeVCj+FfFMkfZCmQdoFR/9QIn08d5NQ/ wErQRwt5z0Eu3k9tPlNygKq351OknDL13CONVGxZEJVy6dwiQ5zWtnyLuzZ1WppjM7wlXdNb Mx3a2aqiFp/EaVz/Oe5WGlF9mZcXbqU3k0sV3HHxxPNEPvNiK2zKn6tLemahOah3c4NQU7is nW5htZ7vakGRok9xJ7BUIinu5fsadYkBpxZfb0iFJqjSnx/+OT4/HL/9/vj85YOVKo0xWDVT PwytbRh444pai5V5XjeZrEhrPwFB3Dhpw5xmIoFcIyJkgp3uwsJWtIAh5E/QeFbjhLIFQ1cT hrINQ1XJAlLNIBtIUaqgip2EtpWcROwDesusqWgYmpY4VOHQQOhxHxYeOakBpQyKR6trwoc7 a9LyD1vtspLal+nnZkMnKYPhFB5s/SyjZTQ0PhQAgW/CTJqLcjWzuNv2jjP16RHup6I1rP1O uS8UFVu+h6cB0QUN6hI/LWmozoOYZY8Ku9oY8wTo48Zd/wEyuIbiuYx8kOaXzRY0QEHaFQHk IEAhRRWmPkFgslI6TBZSH7uEO9C0ubGcpg6Vw65PRHH4EygPfb5nIPcQ7IL6rrw7vgYqknmV XhYsQ/UoEivM1cyaYE8xGXXLBQ+9UmFvmiG53XVrptS7BaOcD1OoGyZGWVDPaYLiDVKGcxsq wWI++B7qtE9QBktA/WoJynSQMlhq6rBcUJYDlOVkKM1ysEaXk6HvYaFCeAnOxffEVY69o1kM JBh7g+8Hkqhqvwri2J3/2A17bnjihgfKPnPDczd87oaXA+UeKMp4oCxjUZiLPF40pQPbcSz1 A1wp+pkNB1FSU0vNHoeZd0cd8XSUMgcNyJnXVRkniSu3jR+58TKiF/5bOIZSsdCKHSHbxfXA tzmLVO/Ki5jOI0jge/ns6B8epPzdZXHAzOIM0GQY4DGJr7UCSWy/DV+cN5fs8jSz8dHe4I+3 b8/oB+bxCZ1VkT17PvPgEyx+Pu+iqm6ENMeQvzHo7lmNbGWc0VPXlZVVXeJ6IBSoOZq1cHhq wm2Tw0t8sYOKJHUiajbkqBrSqglhGlXqMm5dxtSuzJ5iuiS40lJqzjbPLxx5rl3vMQuZYUpz WNMAqx258Kmxb1KlGASrwI2kxsfQg/PZbDJvyVu0o976ZRhlUFF4XoxHhkqpCXiIE4vpHVKz hgxWLO6kzYMysSpoD1emOoHiwJ1gHfv5J2T9uR/+ePnr9PDH28vx+f7x7vjb1+O3J3Kvoasb 6NEw3g6OWjOUZgXKDYa2ctVsy2O01vc4IhVq6R0Ofx/Ig1aLRxl1wBBBM3O0m9tF/YmFxVzF IXQypWLCEIF8l++xetB96QakN5vb7ClrQY6jnW+22Tk/UdGhl8I6iJs1cg6/KKIs1DYOiase 6jzNr/JBgto+QcuFoobBXpdXf3qj6eJd5l0Y1w2aJY1H3nSIM0/jmpg/JTl65xguRaf6d0Yb UV2zA68uBXyxD33XlVlLEmsEN53sCg7yCZE/wGAMnly1Lxj1QV70Lie74yS5sB6ZxxJJgUZc 52XgGldXPg2r2fcjf43ODeiVKZIpLIfzywwl4E/ITeSXCZFnyqRIEfHoN0oaVSx1APYn2Ycd YOts0pxbnwOJFDXEoyCYfnnSduq1Td06qLcTchH96ipNI5yuxEzYs5AZtGRdt2fBGxYY//k9 HjW+CIHFQk196EN+hSOlCMomDg8wCikVW6LcacOQrr6QgL7VcFfcVStAzjYdh0xZxZufpW7t G7osPpzub3576DfKKJMafNXWH8sXSQaQp87md/HOxt6v8V4Wv8xapZOffK+SMx9evt6M2Zeq XWFYSINue8Ubr4z80EmA4V/6MTWhUmiJXnneYVfy8v0clX4YQ4dZx2V66Zc4WVFV0Ml7ER0w itLPGVUct1/KUpfxPU6H2sDo8C5IzYnDgw6Ird6rbfJqNcLNsZmZZkDegjTLs5CZHWDaVQLT K1pdubNGcdscZtT9N8KItNrU8fX2j3+OP17++I4gDIjf6TVR9mWmYHEmRn432IfFDzCB+r+L tPxVdSh1+H3KHhrcGGvW1W5HZT4SokNd+kaxUNtnlUgYhk7cURkID1fG8V/3rDLa8eTQMbvh afNgOZ0j2WLVWsav8bYT8a9xh37gkBE4XX7ASDh3j/9++Pjj5v7m47fHm7un08PHl5u/j8B5 uvt4eng9fsFV3seX47fTw9v3jy/3N7f/fHx9vH/88fjx5unpBhTx549/Pf39QS8LL9QJxNnX m+e7o/KS2i8P9YWlI/D/ODs9nDBiwun/bni0HuxeqC+jYskO5xRBWebCzNp9Y57ZHHiRjjP0 95fcL2/Jw2XvIpXJRW/78gOMUnWKQDdEq6tMhoLSWBqlAV1YafTAYu8pqPgsERiM4RwEVpDv JanuViyQDtcRPEi5xYRltrjUWhp1cW1q+fzj6fXx7Pbx+Xj2+Hyml1t9a2lmtJb2WZQ/Cns2 DhOME7RZq4sgLrZUKxcEO4nYe+9Bm7WkErPHnIy2Kt4WfLAk/lDhL4rC5r6gl+faHPAo3GZN /czfOPI1uJ2A24dz7q47iMsThmuzHnuLdJdYhGyXuEH79YWwlTew+s/RE5StVGDharlxL8Ao 28RZd5eyePvr2+n2NxDiZ7eq5355vnn6+sPqsGVl9fgmtHtNFNiliAInYxk6sqxSuy5AJu8j bzYbL9tC+2+vX9Fv+e3N6/HuLHpQJUf37/8+vX49819eHm9PihTevN5YnxJQF3ptmzmwYOvD H28EKs4VjwDSDcBNXI1puJP2K6LP8d7xyVsfJO6+/YqVCqqGmzIvdhlXdj0G65WN1XYvDRx9 MgrstAk1XTVY7nhH4SrMwfESUFAuS98ek9l2uArD2M/qnV35aMnZ1dT25uXrUEWlvl24rQs8 uD5jrzlbP/rHl1f7DWUw8RytgbD9koNTmILaeRF5dtVq3K5JyLwej8J4bXdUZ/6D9ZuGUwfm 4Iuhcyp/bfaXlmno6uQIM5+KHezN5i544tncZsFoga4s9HrQBU9sMHVgeI1mldsTWL0px0s7 Y7Wm7Kb109NXdlO8kwF26wHW1I7JPdutYgd3GdhtBIrR5Tp29iRNsIwU2p7jp1GSxLZkDdQd /aFEVW33CUTtVggdH7x2z1YXW//aobdUflL5jr7QyluHOI0cuURlwTwcdi1v12Yd2fVRX+bO CjZ4X1W6+R/vnzAQAtO8uxpZJ/wygpGv1JbWYIup3c+YJW6Pbe2RaExudcSAm4e7x/uz7O3+ r+NzG5rTVTw/q+ImKFyaW1iucPcy27kpTjGqKS4hpCiuCQkJFvgprusIfVSW7MCEqF+NS0Nu Ce4idNRBLbjjcNUHJUL339tTWcfh1Mg7apQp/TBfoRWio2uI4w2icrfXyela4tvpr+cbWIQ9 P769nh4ckyDGwnMJIoW7xIsKnqfnntaJ7Xs8Tpoeru8m1yxuUqfUvZ8D1f1ssksYId7Oh6C2 4hHO+D2W914/OK/2X/eOfohMA3PZ1la90CMLLNUv4yxz9FvlMSwO8kMQORYRSDW+DZ3jHMjV zO7N6pUqhMLQCoJwOKq6p9aulujJlaMX9NTYoV71VNeSguXsjabu3AM2J/n7eJcKrOfN4ppF HbRITZBls9nBzZL60E0H2iUP6ijP6sPgq03JmEEvIX8ObPlh8GEx1zEMVDzSjJDStm3dXpib qX2Rc/tsIMnWd+yhyfJdqtPHJMr+BGXLyZSng306Tjd1FAzMRkA37pCGuq4dg4K2yjZKqtie wZGm70G7h5m/jnCMuvMM2EVuQlFejKtooKenSb6JA3TB/TO6ZfdIS+bRPQm+96wcrTqJxW6V GJ5qtxpkq4vUzaO2i4OoNKYjkeXZprgIqgXej9sjFfOQHG3erpTn7enrABW3QDBxj5td+SLS RubqzmJ/y0zPuxic9m+1vfBy9jd6uzx9edCRg26/Hm//OT18IS6jurMS9Z4Pt5D45Q9MAWzN P8cfvz8d73t7C2V4P3zAYdMrcn/CUPWOPqlUK73FoW0ZpqMlNWbQJyQ/Lcw7hyYWh9Jh1LV2 KHV/M/wXKtTEFRtSdfQuLt3dbZFmBTMX6KrUIgj9Tfhlo27y0qtEvnBtsQLZHkEXoEd0rVd/ WC9mAVrslMopM+1blAVk1wA1w4gFdUwNOIK8DJlL6BIvTma7dBXR4xdtfsV82rShBoJYOoLC IDDGlSkZmnjGiFcMgrQ4BFt9ul5GbEMhAIEU12xSCsZzzmFvQwRNXO8anorvhMCjw0DO4CBM otXVgk85hDIdmGIUi19eiuNqwQHt6Zx0gjlTgrlKHJzTjrOyN3wCsvshd3igi4V56vxi9y04 RPXVTo7jPU3U/vla8lqruQJ1X9xD1JWz+ybf0BU+5HaWz31tT8Eu/sN1w/yr6efmsJhbmPJr XNi8sU+bzYA+Ne3rsXoLg8giVDAr2Pmugk8Wxpuu/6BmwxQzQlgBwXNSkmt6PkQI9CIt488H 8KkT51dvW9HgsEwEdSNsYA2apzzGSo+iLehigARvHCJBKiopZDJKWwVktNQwMVURCicX1lxQ 9/wEX6VOeE3tl1bcS466S4RndRz2qyoPQOuL96D5lqXPbDWVjz3qsFdDyvkZE7mIszNAeOCe ljJVI5oAMwTzPatoSEDjU9wKkHIbaWiQ2tTNfLqi1gOhMlMJEl/d5dxGPMiHSocBN7gSyOCG XvSsNonuNkTaKXdZDqupoNih57ImX6/VaTOjNCWrn/AznbqSfMWfHLIyS/jFnqTcSdPnILlu ap9khbGvYPFNXpUWMb/tbn9GGKeMBR7WNLYjOvlGX6xVTW1H1rCCsy+LIVoJpsX3hYXQ4aCg +XcaQFZB59/pPQAFoW/+xJGhD1pE5sDxQnwz/e542UhA49H3sUxd7TJHSQEde989T8Awtsbz 7xMJz2mZ8IZukdDeW6ELexoJU/X2LEeCOhwjLRml0iNuBSOB9TK06KBG0vnqk7+hvbtGZdXp p93SM7s8kzBdX7YLgc68odX5Ffr0fHp4/UdHc70/vnyx7fmVo6+LhjsSMSBeJmMrdnNXGdZw CdpGd8fm54Mcn3fomWna15VeAVk5dBzKfsi8P8QLmGQ8XGV+Glu3CBksLDJg1bdCs68mKkvg imjFDtZNt41++nb87fV0bzT/F8V6q/FnuybNZkK6w9ML7oZzXcK7lR81bt0MrQ5r/god19Mb zmikpzc86KyxjdCEGf0MgVCjosQIS+0dEL0FpX4dcPNjRlEFQfeVVzIPbca63mWBcZQHQqmZ 0NNAyqcvRKILWxWgsl9C/WrVqYpW5wGn27YDh8e/3r58Qfuc+OHl9fnt/vhAQ4SnPm4fwFqO BjAkYGcbpFvjT5AeLi4d68+dg4kDWOGtlgwWKh8+iI+vrOpoL5CKDaqOilYYiiFFJ8EDhl0s pwE/PbtVRcWIesTAu4XEVvCisJIoepKi6gl6BlY53vet90vtwb9fG0HLWjEvo4ZhXWZE/qA4 AD0pyrj7Sp0HUsWsLwjtsLMseFTGRR5XOXdeyHEl0pV/0UGO64iFfVev107xrI5gYIfSwOlr puhxmvIKPZgzv03EaRgcbMsOezhdO+axHVVzLlGf3fCpkt2qZaVTHcLikMgIJGXot0N5T9hB MoaGhPdGhKDUKam9aIso+weuZXWk0hJQABYbWIlurFLBbI3uQ7mlq+lTWpShrkv3QdSurap4 3V9Ud4mvI6X36nWktEHs+7mokq0OW6qNOJDpLH98evl4ljze/vP2pMXk9ubhC52gfQzaiq7C mNbOYHOvaMyJ2JPQfUFnn48bKzvcgKmhpdkFlnxdDxI7q2jKpt7wKzxd0Yikwzc0W4xVVYOa 7hBzl59hjoKZKqQmEEpc6aypvHq/GvVtRpiE7t5w5nEIIN0j5UUbBXJ/2Qpre3pvNOrImzc6 NsNFFBVaCum9QzSn6iXrf788nR7QxAo+4f7t9fj9CD+Or7e///77//QF1bnh+m4HC8vIHm/w Bu5xxPR4N3t5WTG3Khpt/U6rk2kjxeiOC158gd6BCxWxD3F5qd/kEH5VsB5IFFShzvPSj+uu EXrd9z+op64cqNzA1NDsMrTGgGbU+17ySy+0wBuAQQdLIr8PNaN7mfbAcnZ383pzhpPhLe4L v8gm4q5SjWxxgXR9qxF9b5XJfy1wm9CvfVRuy13r21iMgIGy8fyDMjL3k6r2y2DWcA0Ld3vh FIPRiF34cAp0uz2UCgWu0mc7ceWNWa4l80uMUPTZdniG5VJ3eaWbla6W+HfyagF5o1XaslVm GVm7pwYlBfeuabSGUntWZ4NOLeSk80kCGgXPuFjpfen56PencvvZ018GL4fZi3KoBrz59vT1 xtWE+kKGXkuRhWxSbP3WnQ/UPAiUfiLr1OF6G6VMqZdvoYvO+vjyiuMTxW7w+K/j882XI7kx vmNzrb5eaIKsSZj3D41FB1U1TprqN1xEtUMIl3x56XKbnq+Vif0wN8ksqnX4mXe5hh20+3FS JXQjCBGtYAq1VuThuKCtkqb+RdReuBekOO+GECesUSwPv8le1eg3pYH9IqMMgQoU5HvT/+lu eAmqJR4TYZtgl+cWW8lFWLPt0Ur7lQalge5VKRxvuoMyWwiYc+LtdF0InHSkdFHbrBKk27/C LQLdhhU0ozpzK3W/ztM4mE8dMx69zsEp6iu20QHd+Mhv05tA+kp8ZRMrdq1EHxcDXFNjEIWq Ib8WoNyS0qs/dgVLQQex16xA9Ei+Zr7NFVziAVPNr9HrD2QHTwqKQ18WU2yK6f5wkfY13BYc NV8OwmpAjR+OKqs2NWpEFsVaIngMvM3VQmff09Yxxi4EweI4qFXp2juMsnWEf2rIAuRFEkrh p/mcwk6fWjsJ5IBY0NBHgKuD7cTWmelCyvWCOqjntXGRwlzJIbzF5EMbyY4gNi7bjFFrjK0x HKUOVF3hKvgtdOCU+57vzS1M11PBDvAOTx7s0G8eyVbrgqtYy+3KkX27X/r/AHCFN7OpTAQA --pf9I7BMVVzbSWLtt--