Received: by 2002:ac0:a5a7:0:0:0:0:0 with SMTP id m36-v6csp896925imm; Wed, 11 Jul 2018 12:59:36 -0700 (PDT) X-Google-Smtp-Source: AAOMgpf6AkgKhdq6wZf4hSbRKCeFHQbe5uqJgW2v46j4mhG5e5XyBvh65HRWUDNR/Ualqxpzo8+A X-Received: by 2002:a63:6e07:: with SMTP id j7-v6mr23155pgc.251.1531339176719; Wed, 11 Jul 2018 12:59:36 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1531339176; cv=none; d=google.com; s=arc-20160816; b=GNxhlpLjtCqTpG3bhpWDpwF23Sv4FXYxdjoj+yzfZTffoq2rcQdZP4sDC0eJlPBEzU lDwbz52Yi3cxUmAkxmhANYJdTXIQDG54Ob0Ll1chZGM2bkX5K5zmc6IcBLiJcxKW+8rs 8mLqwdURKJftBsKrM2vQaLuL3w6qSefIpgEKDc4CBPaiC48GclFOUOLgHtI89bIDrVpq 3OoclF0J8fHoxSOWEFoWjjYGT9/ZOcJY5i5drT4aMMGJGZPu3XzUBp8Xpd56i1wk4QVZ eQG+dWPhqiN+cuL8cMCPrgkBhgTCO4jodhlEZ8V/6CLsOyY+SM98SBeJJAGVZjZ6UL+I ajuQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:user-agent:in-reply-to :content-disposition:mime-version:references:message-id:subject:cc :to:from:date:arc-authentication-results; bh=rthi2Au7MHy/kltcF4e2AJdXIZHxTC2y9VspbgdMPN4=; b=1JTQ2RsbqRZ+P6fBb7JWCHz1mDhrAPxtt2Hp5+Nn86UFYDMqNeDmfYnU9vBw3LmJNY IwR9ho47a9p4IV1BIn4NbnEIbUnS9vDOH2pYwjZlLwZyXoUCuxLfWLtM6PhSOYR+JzkN CAtlNCIq4Ruu6O7UUf6uN4NsUWWkRxarLSr3ekS36PFyY2/pN6Hdo9ZdzO3mkC213D1+ l8A/7JvJGHOmzAm708tEQro6N56FxyTBSJwUoCnqdbCYwLh4ct4oLp4uQesXzeipRPjn 4kklh6akrIv2Dn2dZ3R6Gk+nMgAkxCA8schZlhaPQ46oFBVBnFY+wzO+fjmx3ljZlLNL /eZQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=intel.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id r6-v6si18449956pgp.426.2018.07.11.12.59.21; Wed, 11 Jul 2018 12:59:36 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389372AbeGKTJA (ORCPT + 99 others); Wed, 11 Jul 2018 15:09:00 -0400 Received: from mga18.intel.com ([134.134.136.126]:8808 "EHLO mga18.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732979AbeGKTJA (ORCPT ); Wed, 11 Jul 2018 15:09:00 -0400 X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False Received: from orsmga006.jf.intel.com ([10.7.209.51]) by orsmga106.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Jul 2018 12:03:19 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.51,338,1526367600"; d="gz'50?scan'50,208,50";a="56911605" Received: from bee.sh.intel.com (HELO bee) ([10.239.97.14]) by orsmga006.jf.intel.com with ESMTP; 11 Jul 2018 12:03:15 -0700 Received: from kbuild by bee with local (Exim 4.84_2) (envelope-from ) id 1fdKOQ-000Y0J-Fv; Thu, 12 Jul 2018 03:03:14 +0800 Date: Thu, 12 Jul 2018 03:02:54 +0800 From: kbuild test robot To: Baoquan He Cc: kbuild-all@01.org, Chao Fan , akpm@linux-foundation.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, x86@kernel.org, yasu.isimatu@gmail.com, keescook@chromium.org, indou.takao@jp.fujitsu.com, caoj.fnst@cn.fujitsu.com, douly.fnst@cn.fujitsu.com, mhocko@suse.com, vbabka@suse.cz, mgorman@techsingularity.net Subject: Re: [PATCH v3] mm, page_alloc: find movable zone after kernel text Message-ID: <201807120110.U0IOvBn5%fengguang.wu@intel.com> References: <20180711124008.GF2070@MiWiFi-R3L-srv> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="xHFwDpU9dbj6ez1V" Content-Disposition: inline In-Reply-To: <20180711124008.GF2070@MiWiFi-R3L-srv> User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: lkp@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --xHFwDpU9dbj6ez1V Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Baoquan, I love your patch! Perhaps something to improve: [auto build test WARNING on linus/master] [also build test WARNING on v4.18-rc4 next-20180711] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Baoquan-He/mm-page_alloc-find-movable-zone-after-kernel-text/20180711-234359 config: x86_64-randconfig-x007-201827 (attached as .config) compiler: gcc-7 (Debian 7.3.0-16) 7.3.0 reproduce: # save the attached .config to linux build tree make ARCH=x86_64 All warnings (new ones prefixed by >>): In file included from include/asm-generic/bug.h:5:0, from arch/x86/include/asm/bug.h:83, from include/linux/bug.h:5, from include/linux/mmdebug.h:5, from include/linux/mm.h:9, from mm/page_alloc.c:18: mm/page_alloc.c: In function 'find_zone_movable_pfns_for_nodes': include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/compiler.h:58:30: note: in definition of macro '__trace_if' if (__builtin_constant_p(!!(cond)) ? !!(cond) : \ ^~~~ mm/page_alloc.c:6689:4: note: in expansion of macro 'if' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~ >> mm/page_alloc.c:6689:8: note: in expansion of macro 'pfn_to_nid' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~~~~~ mm/page_alloc.c:6689:19: note: in expansion of macro 'PFN_UP' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/compiler.h:58:42: note: in definition of macro '__trace_if' if (__builtin_constant_p(!!(cond)) ? !!(cond) : \ ^~~~ mm/page_alloc.c:6689:4: note: in expansion of macro 'if' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~ >> mm/page_alloc.c:6689:8: note: in expansion of macro 'pfn_to_nid' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~~~~~ mm/page_alloc.c:6689:19: note: in expansion of macro 'PFN_UP' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/compiler.h:69:16: note: in definition of macro '__trace_if' ______r = !!(cond); \ ^~~~ mm/page_alloc.c:6689:4: note: in expansion of macro 'if' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~ >> mm/page_alloc.c:6689:8: note: in expansion of macro 'pfn_to_nid' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~~~~~ mm/page_alloc.c:6689:19: note: in expansion of macro 'PFN_UP' if (pfn_to_nid(PFN_UP(_etext)) == i) ^~~~~~ In file included from include/asm-generic/bug.h:18:0, from arch/x86/include/asm/bug.h:83, from include/linux/bug.h:5, from include/linux/mmdebug.h:5, from include/linux/mm.h:9, from mm/page_alloc.c:18: include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:812:40: note: in definition of macro '__typecheck' (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:836:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:852:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ mm/page_alloc.c:6690:21: note: in expansion of macro 'max' real_startpfn = max(usable_startpfn, ^~~ mm/page_alloc.c:6691:7: note: in expansion of macro 'PFN_UP' PFN_UP(_etext)) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:820:48: note: in definition of macro '__is_constexpr' (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) ^ include/linux/kernel.h:826:25: note: in expansion of macro '__no_side_effects' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~~~~~~~ include/linux/kernel.h:836:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:852:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ mm/page_alloc.c:6690:21: note: in expansion of macro 'max' real_startpfn = max(usable_startpfn, ^~~ mm/page_alloc.c:6691:7: note: in expansion of macro 'PFN_UP' PFN_UP(_etext)) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:828:34: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:852:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ mm/page_alloc.c:6690:21: note: in expansion of macro 'max' real_startpfn = max(usable_startpfn, ^~~ mm/page_alloc.c:6691:7: note: in expansion of macro 'PFN_UP' PFN_UP(_etext)) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:828:46: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:852:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ mm/page_alloc.c:6690:21: note: in expansion of macro 'max' real_startpfn = max(usable_startpfn, ^~~ mm/page_alloc.c:6691:7: note: in expansion of macro 'PFN_UP' PFN_UP(_etext)) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:832:10: note: in definition of macro '__cmp_once' typeof(y) unique_y = (y); \ ^ include/linux/kernel.h:852:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ mm/page_alloc.c:6690:21: note: in expansion of macro 'max' real_startpfn = max(usable_startpfn, ^~~ mm/page_alloc.c:6691:7: note: in expansion of macro 'PFN_UP' PFN_UP(_etext)) ^~~~~~ include/linux/pfn.h:19:40: error: invalid operands to binary >> (have 'char *' and 'int') #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT) ~~~~~~~~~~~~~~~~~~~ ^ include/linux/kernel.h:832:25: note: in definition of macro '__cmp_once' typeof(y) unique_y = (y); \ vim +/pfn_to_nid +6689 mm/page_alloc.c 6540 6541 /* 6542 * Find the PFN the Movable zone begins in each node. Kernel memory 6543 * is spread evenly between nodes as long as the nodes have enough 6544 * memory. When they don't, some nodes will have more kernelcore than 6545 * others 6546 */ 6547 static void __init find_zone_movable_pfns_for_nodes(void) 6548 { 6549 int i, nid; 6550 unsigned long usable_startpfn, real_startpfn; 6551 unsigned long kernelcore_node, kernelcore_remaining; 6552 /* save the state before borrow the nodemask */ 6553 nodemask_t saved_node_state = node_states[N_MEMORY]; 6554 unsigned long totalpages = early_calculate_totalpages(); 6555 int usable_nodes = nodes_weight(node_states[N_MEMORY]); 6556 struct memblock_region *r; 6557 6558 /* Need to find movable_zone earlier when movable_node is specified. */ 6559 find_usable_zone_for_movable(); 6560 6561 /* 6562 * If movable_node is specified, ignore kernelcore and movablecore 6563 * options. 6564 */ 6565 if (movable_node_is_enabled()) { 6566 for_each_memblock(memory, r) { 6567 if (!memblock_is_hotpluggable(r)) 6568 continue; 6569 6570 nid = r->nid; 6571 6572 usable_startpfn = PFN_DOWN(r->base); 6573 zone_movable_pfn[nid] = zone_movable_pfn[nid] ? 6574 min(usable_startpfn, zone_movable_pfn[nid]) : 6575 usable_startpfn; 6576 } 6577 6578 goto out2; 6579 } 6580 6581 /* 6582 * If kernelcore=mirror is specified, ignore movablecore option 6583 */ 6584 if (mirrored_kernelcore) { 6585 bool mem_below_4gb_not_mirrored = false; 6586 6587 for_each_memblock(memory, r) { 6588 if (memblock_is_mirror(r)) 6589 continue; 6590 6591 nid = r->nid; 6592 6593 usable_startpfn = memblock_region_memory_base_pfn(r); 6594 6595 if (usable_startpfn < 0x100000) { 6596 mem_below_4gb_not_mirrored = true; 6597 continue; 6598 } 6599 6600 zone_movable_pfn[nid] = zone_movable_pfn[nid] ? 6601 min(usable_startpfn, zone_movable_pfn[nid]) : 6602 usable_startpfn; 6603 } 6604 6605 if (mem_below_4gb_not_mirrored) 6606 pr_warn("This configuration results in unmirrored kernel memory."); 6607 6608 goto out2; 6609 } 6610 6611 /* 6612 * If kernelcore=nn% or movablecore=nn% was specified, calculate the 6613 * amount of necessary memory. 6614 */ 6615 if (required_kernelcore_percent) 6616 required_kernelcore = (totalpages * 100 * required_kernelcore_percent) / 6617 10000UL; 6618 if (required_movablecore_percent) 6619 required_movablecore = (totalpages * 100 * required_movablecore_percent) / 6620 10000UL; 6621 6622 /* 6623 * If movablecore= was specified, calculate what size of 6624 * kernelcore that corresponds so that memory usable for 6625 * any allocation type is evenly spread. If both kernelcore 6626 * and movablecore are specified, then the value of kernelcore 6627 * will be used for required_kernelcore if it's greater than 6628 * what movablecore would have allowed. 6629 */ 6630 if (required_movablecore) { 6631 unsigned long corepages; 6632 6633 /* 6634 * Round-up so that ZONE_MOVABLE is at least as large as what 6635 * was requested by the user 6636 */ 6637 required_movablecore = 6638 roundup(required_movablecore, MAX_ORDER_NR_PAGES); 6639 required_movablecore = min(totalpages, required_movablecore); 6640 corepages = totalpages - required_movablecore; 6641 6642 required_kernelcore = max(required_kernelcore, corepages); 6643 } 6644 6645 /* 6646 * If kernelcore was not specified or kernelcore size is larger 6647 * than totalpages, there is no ZONE_MOVABLE. 6648 */ 6649 if (!required_kernelcore || required_kernelcore >= totalpages) 6650 goto out; 6651 6652 /* usable_startpfn is the lowest possible pfn ZONE_MOVABLE can be at */ 6653 usable_startpfn = arch_zone_lowest_possible_pfn[movable_zone]; 6654 6655 restart: 6656 /* Spread kernelcore memory as evenly as possible throughout nodes */ 6657 kernelcore_node = required_kernelcore / usable_nodes; 6658 for_each_node_state(nid, N_MEMORY) { 6659 unsigned long start_pfn, end_pfn; 6660 6661 /* 6662 * Recalculate kernelcore_node if the division per node 6663 * now exceeds what is necessary to satisfy the requested 6664 * amount of memory for the kernel 6665 */ 6666 if (required_kernelcore < kernelcore_node) 6667 kernelcore_node = required_kernelcore / usable_nodes; 6668 6669 /* 6670 * As the map is walked, we track how much memory is usable 6671 * by the kernel using kernelcore_remaining. When it is 6672 * 0, the rest of the node is usable by ZONE_MOVABLE 6673 */ 6674 kernelcore_remaining = kernelcore_node; 6675 6676 /* Go through each range of PFNs within this node */ 6677 for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) { 6678 unsigned long size_pages; 6679 6680 start_pfn = max(start_pfn, zone_movable_pfn[nid]); 6681 if (start_pfn >= end_pfn) 6682 continue; 6683 6684 /* 6685 * KASLR may put kernel near tail of node memory, 6686 * start after kernel on that node to find PFN 6687 * which zone begins. 6688 */ > 6689 if (pfn_to_nid(PFN_UP(_etext)) == i) 6690 real_startpfn = max(usable_startpfn, 6691 PFN_UP(_etext)) 6692 else 6693 real_startpfn = usable_startpfn; 6694 /* Account for what is only usable for kernelcore */ 6695 if (start_pfn < real_startpfn) { 6696 unsigned long kernel_pages; 6697 kernel_pages = min(end_pfn, real_startpfn) 6698 - start_pfn; 6699 6700 kernelcore_remaining -= min(kernel_pages, 6701 kernelcore_remaining); 6702 required_kernelcore -= min(kernel_pages, 6703 required_kernelcore); 6704 6705 /* Continue if range is now fully accounted */ 6706 if (end_pfn <= real_startpfn) { 6707 6708 /* 6709 * Push zone_movable_pfn to the end so 6710 * that if we have to rebalance 6711 * kernelcore across nodes, we will 6712 * not double account here 6713 */ 6714 zone_movable_pfn[nid] = end_pfn; 6715 continue; 6716 } 6717 start_pfn = real_startpfn; 6718 } 6719 6720 /* 6721 * The usable PFN range for ZONE_MOVABLE is from 6722 * start_pfn->end_pfn. Calculate size_pages as the 6723 * number of pages used as kernelcore 6724 */ 6725 size_pages = end_pfn - start_pfn; 6726 if (size_pages > kernelcore_remaining) 6727 size_pages = kernelcore_remaining; 6728 zone_movable_pfn[nid] = start_pfn + size_pages; 6729 6730 /* 6731 * Some kernelcore has been met, update counts and 6732 * break if the kernelcore for this node has been 6733 * satisfied 6734 */ 6735 required_kernelcore -= min(required_kernelcore, 6736 size_pages); 6737 kernelcore_remaining -= size_pages; 6738 if (!kernelcore_remaining) 6739 break; 6740 } 6741 } 6742 6743 /* 6744 * If there is still required_kernelcore, we do another pass with one 6745 * less node in the count. This will push zone_movable_pfn[nid] further 6746 * along on the nodes that still have memory until kernelcore is 6747 * satisfied 6748 */ 6749 usable_nodes--; 6750 if (usable_nodes && required_kernelcore > usable_nodes) 6751 goto restart; 6752 6753 out2: 6754 /* Align start of ZONE_MOVABLE on all nids to MAX_ORDER_NR_PAGES */ 6755 for (nid = 0; nid < MAX_NUMNODES; nid++) 6756 zone_movable_pfn[nid] = 6757 roundup(zone_movable_pfn[nid], MAX_ORDER_NR_PAGES); 6758 6759 out: 6760 /* restore the node_state */ 6761 node_states[N_MEMORY] = saved_node_state; 6762 } 6763 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --xHFwDpU9dbj6ez1V Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICLErRlsAAy5jb25maWcAlDzZcuO2su/5CpXzktSpSbzFmdxbfgBJUMKIC0KAWvyC8tia iSsee45snyR/f7sbpAiAoObcVCox0U0sjd67qe+/+37G3l6fv9y+PtzdPj7+M/u8e9rtb193 97NPD4+7/51l9ayq9YxnQv8EyMXD09vfP//9/spcXc4ufzp7/9Ppu/3d5Wy52z/tHmfp89On h89vMMHD89N3338H/34Pg1++wlz7/5l9vrt79+vsh2z38eH2afbrTxfw9tnVj/YvwE3rKhdz mDoR+vqf/nFDq3nPw4OolG7aVIu6MhlP64w3A7ButWy1yeumZPr6ZPf46eryHWz+3dXlSY/D mnQBb+b28frkdn/3Bx7w5zs6y0t3WHO/+2RHDm8WdbrMuDSqlbJunA0rzdKlbljKx7CybIcH WrssmTRNlRk4tDKlqK7P3x9DYJvri/M4QlqXkulhool5PDSY7uyqx5vzijciNUIxk5Vs2GkP SNp5dNA0vGBarLiRtag0b9QYbbHmYr7Q4fHZ1iwYvpiaPEsHaLNWvDSbdDFnWWZYMa8boRfl eN6UFSJpmOZwjQXbBvMvmDKpbGmDmxiMpQtuClHBZYkbHsHIRQEHMnIum9rZPW1acd1KIwGM a7CGOzSrOM8OIF4m8JSLRmmTLtpqOYEn2ZzH0ex+RMKbihG7y1opkRThllWrJIdbngCvWaXN ooVVZJkZtYA9xzCIuKwgTF0kA8pNDZQC3rg4d15rQT3Qy6O9EPsrU0stSiBvBgILtBbVfAoz 48hOSAZWgISFasCoUk692sIFJdzhvFxsDGdNsYVnU3KHd7JtxUrgHbnYKgEMBGyoHFrLuWZA OlPwFS/U9WU/nqJomHnqbAsezAr4HW7k+tfTi9PTA27BqvkBdBgWze9mXTfOYkkrigzIww3f 2GWVpzL0AtgKCZfX8B+j7U5Jtc5JWz/OXnavb18HBQoE1oZXK6APqCkgvEaVAZq42xnIv4Bl NFd69vAye3p+xRkcvcaKft8nJ7FhuHFdB6KwBMbkhZnfCBmHJAA5j4OKG1fZuJDNzdQbE+sX N2gqDmd1duUeNYTT3o4h4A6PwTc3EUp6ex3PeBl5BSwRawuQ0FppYFF+ffLD0/PT7seT4X21 VSsh0+huQOiB58vfW97yKELagFpAWaibrWEaLNUiitcqDlo1skGS9YD0JIYEgL0BlxSBaoiP gqLRnsagQd1w3rM3yMrs5e3jyz8vr7svA3sfrBSIEon82CYgSC3qdRzC85ynZK1Yngei3+Oh DgU1hfjxSUoxb0gRx8HpwpUDHMnqkonKH1OijCGBngftC1TdTqzNdAP3TBqS6bqJYzVc8WZl jUUJnpG/EnhFKehjq108hawkaxSfPjmp6NzRsym6QqpuYUJ7qVkd6ncXJWOaxV9egSnP0JIX DA3gNi0id0uqcjXiqYM7gPOB3q50xAdxgCZpapalsNBxNHCkDMs+tFG8skazg1vueVY/fNnt X2Jsq0W6NGA9gS+dqaraLG5QJZfESQcBhEHwCUSdibik2/dEVvCIkFpg3hJ9/Feiky3AMUN2 Ido2ysWxLrxsf9a3L3/OXuF0s9un+9nL6+3ry+z27u757en14enzcMyVaLT1htK0bivtsVYE iMR0d4kcRlc8oET3nKgMpT/loM8ANWbJ0FSCM+4yAg5ZP5Fechcm0GZiKtyzUHXRSzyRpUnb mRpftAQVVkptAOzOD49g4eFSY/Mri9xvBWYIh/AsxhvCCeF4RTGwjwMht1LxeZoUwuVd+J8G R8NggLK0l+N4Bj7MKonIdmmBOk2QLoEnA3FFde44SGLZhVajEbq+YbiocYYc9LbI9fX5qTuO 5IdQxYGfnQ/khohjaRTLeTDH2YVnplqIFa1/BS5/ZoV8ypes2pKZhIEPl46dVfKQE1R0ME1b YVwFPrLJi1ZNesCwx7Pz947cTyzgjx/8AV7hzjPnGudN3Url3h5Y9TQuKxbZnvsYghSZOgZv sgkvqIPnwLc3vDmG0gUUcRQJboc+uoOMr0Q64dpYDJgklOHRMXmTH4Mn8iiY7F9M64K/BrYz 5d6ttMhN8TPBaZspGFzFFKjiegpkORu9c9pqHGercoyzQE2B8+AzRC/efiCdFKgzVxRXNA4P 0jMrYTZrv51oocn6SGDQf9nYzR5AfggAA67nT/A6ePb8fIjC+hgTlRZdMaZ9qqj6CrH9yB9d C+16qxU4UKICD0qFSKDQUy7Jw6KET+AYy1TJJWwGzAbuxqGozIcHaxScHBEIvEDecFYDoUE/ 1QxuT3CfHWDqxnGvEZQOIV+wKiNfK4gkxv6Ap3SdiNkq4aoUrjlw9BovcjAvjb+GT57IMgkD R7TzY/q9tmCigkeQFmclWbv4SswrVuQO29KhaOCwE/L18pgoqIVNHBxQmaijRGbZSsBmOyLH aAYTJaxpBF3swLkLni4pa4YeGDjzMYZd4pTb0uG/fsR4TvAwmoCzAqRBQfBs9AGDSNun7TzO NCPfGpmR7JBLxkOCbDgXvFml/TX3sqq4E0fY9E43NpAfs2NZVBVZOYLlTejTy/Ts9LJ3xboE tNztPz3vv9w+3e1m/D+7J/BRGXirKXqp4JY7Ppo342EjXfYJgXBmsyopxIpsa1Xatw35qDbf 6SVYMMHaLGMMVbDEE9+ijVtDVdRTAJYA0Zs5792DiWXIHqP3ZxqQ79pjY/C9clEEzvXB/QRV RizpkJsuoravOdfbj6DoW8kaYB/aUkIol3BXHMEfh8hpybegs0ApYBLKYbQwhUerQrwuUoHU bkGUQZ7RxqXo+QfciHeGTigEDRAfrFmYiRLAmeitRTK5y+jKy4brKADMR/wFOwpxnsljFiFv K1us4E0DhkdUH3jqJxEIzdOjQ46FZlzU9TIAgltGvruYt3UbCXsV3AOGil20H5Fh0L9a5Nve kI8RwDHr0kbRjdkcpa3FmPVCaO5HHQe/WR1yrxRv2TeCKRs+Bw1WZbaS0l21YTKkia9aaCgt Qtos1iCInFkVG8BKsQFWGsCKlg6QyEsDPmibCmIeoJJweTzUT5GrW7Amw1iDXEcN9935J7FJ Iuv32qjpyJG1ZcjXRN2YtFkyQbBmA5/cJtf8u7XsZuOntJRYcQmJakdtCngCltWtV2wY9qV4 igqxq6M4mmBiXBbtHFNgtdJpen3y+V//OvEmxYy7xfGUrjM8ZUaIfij7dAdOLJVaFvfAcNeV 6xROvBu8BPxcVyH9LPMLvYBj2TvMG4wVQlKOI3MXPJ078VTcOH0yoUkqzPPxrhqEBZf/Fs/I NovhUlUJTGaUO1Wda5PBEUL9UdZZhyF5CsLlZAQA1BagTFGto/+I3krkuHwjNCpcSqgieSPq i14nI+i5+sP+vCpraH9wgajq9N8aCreReZ2q69QkLkpkqg5M6Oi9jflHbntNrIsQahmvy7B6 FgervUkbKNhusYvzBM8ODBUjGl72geQHSRxGY/WDg0HRYJl0Xw1p1htXpiZB4euWRSZwGizr t5WX5evHKKoYJTrnab169/H2ZXc/+9N6lF/3z58eHm2G09E19arb3rEjElrvH3kONUhyiYGL e4fkkCv0OK9PnaSOlYFYONFJByULC3AKWi/cTtDkxCI35uffmarOHAesogItbESCsmqrYzky pmu0403plFnoVPZlkMh6Xbma3Zb0J4C40hTs4NxRYSsjNCobDCjTkPDlZh1/dTQ+8Fof1ZiE 5/g/tMZ+RcXBpdjJrBsmJY8YGVZNG6Iuf9YHNXL/fLd7eXnez17/+Wrz7p92t69v+50TyfQF eUd8XP8Ay+Y5Z+C9cJugcnkEgZtzkPtYiIPAUlItyLOzdZHlQsXLhugu18g/USh2hoA8Z7F4 BVcD48erDLshRgkTBK/swbzdH90NItg1SxHPew4YhVTxlBqisHLYUyQF2R+vVrkpE0eJ9iM2 rvRPcxCjrhibM1G0fn7EZvNAyLR1GPrmmph/swVmWwkFLsi89UIquECGroMX/HVj41TmGOUg UbFL80s38GjkKk5FAi1WsSQPwpT1+yn/4dCJV11I7pYblxB8B4fEIQdxfIojFaUQta8LHCb5 ADezqFGD0KrxeltS19prMSmX791JSqnihbwSFUu896BEDRuFHAqQsp2QJWIUzFl2HU5h1QRx ijMPeBW+X5CiQ7fCZ10khQT1ZXNXqg3kVKugbaeLEYImPqyervyRUlSibEvycnMIEovt9dWl i0B3nOqiVF4OrasDov/NCz5ZwAORs+dytHI3DBI+HkzB62WtG+xJrsMkR+bGe3MGDCRqr8sP zAEMbw/DQ5rIBfQVHpNsY1kdhyc2oAZjPEgNZAq93Dkaqjl2EsaBoGSvfzkbAbtlHZJ3EGfE qiRVuu2ONFSm4xHMCtf+PdnKKIZWca3TIazqAgQViBNNPROOo+G6l3pfz+VwjFjRsQ04UtT9 oKfnG97UmDTFmkDS1EtQPyjXGFlE1R+ybMrDWWAI65AFn7M0doAOJ2TFfthjxX4Q3Xq1AGM3 BtkcUiCCC3BQ4OSr3sGw/oSTHf3y/PTw+rz3SvduGqOT/2qUsx/hgKMTLzuMUVPM/sVMp4tK xrZeuzJmrX/nWfGyLcII5r2nsMErBYUAum+K+CqYG5hcZOE1/kLdf8f8e9D3IEtps3W5Ebfv A4YSgQ8Ce0RNSHGJD71XeDGWvMR6sb+4P9K1TbJUigBCBS1s9gF3G/nF9BWuodCItWggd9Ti 0cu+3ejCePQY7TFZpD31AO7VTQAnBd47RehkOyIiChSqoveDMJpt+fXp3/e72/tT558hxXRk smEnJataFoM4xMJuCirMScx1+7VAm8ewi0jsunLVkEOPDYRqbiA9gFbwH7zbkGQDBhUijN2t NLqec7yzI3ONt5f4wZw3TEcy49d6R2Pehm23mQBxbLLIxB0l3HYZt0cBYYtaY64uVreQBbi7 UtOmyPhcestaCvVoqCq0vzolLoKceqRXz53skNj6Bp5eyBgKNhEblmWN0eG3C9b3rDG94uym bN1E8tAYqmLecd8BQvxhm9Gy5vry9LdA7CbDCZ/ykTBjsQZ5UlTj/hB3niayhUPrVCxLyIo1 28bMZhS7tPXTgPC2YoB096s5kZFgUmohJ+/Wc7kKzioajTd4+O0t3eiNrGtHO9wkbvrz5iL3 rPKNKvvG9cEQdu3kcIMyHnz0b1F5zHEnO+mjJva+euW4njznTcMPdRciJDZluItT3YcgfV75 mEmz2QSKcMcZFGUbBVdgFfKCuYUKW2U2fbPdEKdgNw2Yu0XJosXQw7pSc5sAZoFHRCGGSSCS xgxM00pf9hAFXTSM3sqexwdE+7qPbttiMWW2Rsd2UE26iUXWtMVx/ZRCeLiNI+EXuE+lCFIx XTpCbsK5OkBvRCg1hAfAQmmUV3kuYurTFlU88b4xZ6ensZzBjTn/5TRAvfBRg1ni01zDNG5/ +4bHQ12CYL1nqjedqQWVt2IeYv+lBvBYo8Hmn/mmvuHUC92ZzyEh1ef8Kb16bF4qLMO85960 naHq+hyH5OqB5RyEOOFsWmIKrUOysULo43onCVEmY6i0zCiDC3uM++XgB2Gpt8j0kZYgsv4F uKcy6NLvJRa/ykK1EiZMO1vpG3onwaz6nhTrXpLfQc63DVGe/9rtZxCi3H7efdk9vVLSE53X 2fNX/KjwxU3Dd586xXbffSeF2Y+iSJiX15WlUQXncjzip05hFDvpxrhrtuRBrtgd7T65AQZ1 TIALn8fSrdJvzygn2wwBZKvcB+T17zZgcholjgQUqVvmobigYy0SHjWUEtxbLfHTva7yg69I 91M9GgFW0uB92o1QnKeczx+HGAhx6WjzaCLTziXTxuggeqCdSjGeDbM/ubIrT83Y8JWpV2At RcbdT+P8mUA7dR83TM3DwmMnTEMksg1HW609LxIHV7B2HYzlrBrtQrN4stqSLl7VIRilzRoO 3OB1xvQ0shkyG4NPgkU2InoqZQo8nUy9E4xPqMxgHTafN8B2up68si6HEcwexLu0v1bpGuRF gUKj5qSTk7G2soRFzdRK8OCz8JAhLMKw05ciU4HtWlPiRpV9JvySlksqUYfZKCsGSdz023cn WrldkpQQJNZH0MB3bPEjIOxQWYPvbOqqiGWsBrlnko86k/rxrvXFXwIBcbsodT6W2UAeNxDc TdQnsPRYQ7Q9By/pCCHo76g8o9cFujRI56pc9LYIk+v5fvfvt93T3T+zl7vbRy9b1kubnzcm +ZvXK/y4DtPRegI8/uLnAEYBneqPtxh9TIgTTXQ6f+MlpDvWXP77V7AUQN3tE8n10Qt1lUG4 UmXRM7qIAOs+VPv/7IeSzK0WMefFo7RDoOhWJukRQzxQYeJanUPHb3046gTK4VwuG34K2XB2 v3/4j9fROgQRstfwXoAhUyoX4TrTdc7OihxFAp+LZ2DrbX2kEVU9JVyXtpYG/mZ/lpc/bve7 e8eXi85rbc3h8OL+ceeLnW+k+hEiXwF+adBg7YJLXrXRk1nShd/T0R6St5d+x7MfQNXPdq93 P/3opM1TRyWiKchE42Xkcaws7YM/unH7t+hV+v7TSxbhH1gNOztdeB4iYKdVcn5aYGeD8MNr F4ujC5a0E5+Z4NZULJJECM2rwlWPFI1TtCk2k9HFAehBT8yudJuEc2P3uZ5oiKYacirwS5S8 wV65qOuPszC/T1xQc0mBTaSxSxBUhvS30UyRRDIlsmDyrudyiJU7s468EjITjt09P73unx8f IdIZxNiy++39DqszgLVz0PB70q9fn/evPV62e3n4/LQGYaIJ02f4Q/koOM6f7r8+Pzy9ukET 7hgoRyn06O5e/np4vfsjvklvFrWGfwVEh3oi3u8ay2KtEvYHRvyWMypeJC5tMcHsPpepYP5V 4QjcLstMKiY+HIM5gk10R313d7u/n33cP9x/dhtqtlj1dVehAVPHPlyyoEak9WL8ho7xUAeq FYSojiMrs6tfz3/z8nbvz09/i61pyYLxv+2lHyZpgJyZqEcDlKsnR6du9fWFE5b2CJ2wNhuj N4byyPH2nn4+rAtV86DPJ0Tye16GpdoSkzGRjRvME3o+UQ8ocU8mBdEf3WNz+/XhXtQzZdl2 ZBf7KbQSv/y6iawpldlExhH/6n1sM/jGnFfxno0eqdkQ0sW0Gd2qPBmdhv+9u3t7vf34uKMf YJpRvfb1ZfbzjH95e7wNzGYiqrzU2Nw67B8e/A9wqHENs2rDx6RFDuEDxDnuz/R0c6m0EW45 sxsuhdvUgVN2begDv7KL86E2O+ESbNyfjbEtpuEzFd9bLFliQq7kYUkf1T/yXy2dzVfkZxMF q93rX8/7P9FHGrkZ4Lgtudcbhc8gHszNUFVi4z/1CEO9I/p91yb3OtbgiX62yHPEcBB9yDhb IFS1icEeOr91wMexRai4s2wnQc2gQDnE9onfjy751t1XN3R84kwahb+LoKMa3V7BwA7Slkvx BxbixkHiJ3PolWeGui5iiQBAkpX7Oxr0bLJFKoPFcJiyslOLIULDmjgczy/kxG/EWOAcpQj4 ezNBUVhCt1XFg28zK2Drein49Ke8Qq50PERGaF7H/dUONiwbXwCvxbB4eyTBuJqgmN0ayuTE bQ/HdQctf2JS11bkvJ8yCjGOT5BwHr7rS6rdRSpH8kmANrOA6eM1bP0NDITCreNXHXFxxNXh z/mBl2P1zh4nbRPX6vXquIdfn9y9fXy4O/FnL7NflIjlgYFvrnwhWF11koRdCPFP2AnJfvuM 6sFkE7lGPP3VMca5Oso5VxHW8fdQCnk1wVhX32aiq29w0dWYjYL9DXAiWfc5+Mh2+ZteRV06 Aqmg6tqNmasmxhIErsgtwwKI3ko+etue6wgF+24Um7c/gkgnnIYrPr8yxfpb6xEaOGgTv0fD NcVBce2Iv3iGtUksA3tW20gt8afSlBL51oPQK3KxJb8V7Nn/MfYsS27jSP5KnTamDxsjknpQ hz6AICXBRZAsApKoujA8dk24ImrsDld5tz9/kAApAmBC8sHdpczEg3gkEvkCb7xkJYrGhI6h /cmaG0jFNHNKg0eFoIFjpA2kx5BePq7xQiPdyHEJlhuG8VNAlaQqfHIl9+IJNwCZtfE6XaLo MpZYM0JaZ2nWstwO+jK/e7ZXkqKo6rqZh45pliiILzkoENqLk/qkPl3E0RPSl7ygnshgIGFh oCztbDEljd3RIiWuAuniFVYZaeyr5qH2OrMu63NDMDmWFUUBH7Wy3JknWF+Vwx86rQMDAdY2 YliURpiyG1Wby+ACMobWDY6C7tOvl18vSsz9p/jy7eXrL1c5PVD3NHty9xsADzJDgDtbwh+h Zgl7wMGt14NqfvTkrw3AtOixOGLVNWhemdihNcniKcBhDDrbzauimZgDlTSXz6G5mDMogKv/ F8g45G2LDMMTPjz0UD8W2Dc97bDtcS02OC3Oiu2eDO5G2R029wdkiBpWIEBjt581jJiWjWbo 7fP7++u/X7+M2X+tcrT05kABfCXACJaUVXnR+U0DSrMGnOONJLtzYEAAeXSunwYwhmJPCqMB 7rsszXsjTuELw0iACTnXvpY6Q+GsHJ0l7/FHrtlh5aC+wIk3knDw5sA9PvRtgLveHhNsCPO0 84haSIqHJEwEVXaRs9U/4NRg3y7MC0nQPkG4NDYQJJD/acQzVHN83TZsZ+3fnDpK6ryCuFJR QypUpI5MMUwCPpqOSnmCjn+ebpbts5IEyucEszJbBBUNlOTBq7hd/dz94UpWN0V1MhpfpAun QTcwjdwI8W5t4BPLaozeRSAmUhAyWfU4u7SNx2fjsxmA9Hvh6GA0DDgJ7gppsmtZe+Dgxhrp VaIHwdNGOhRlAnlF4Sp2i6qiqOmltVVb7U7nN3QiRdy8b0NaMi1Nt4HsRBaNkbZDG6CFJHvi 0rtJlLIn+4c20rQF4b12OvcOQeBCgwuUq5J7+Hh5//AiqXWnH+W+wG9dWrpsa3ULrivm+YpM 5hbCW5KHPhyV4TKHbWSQq6fIAxcJNZn45UljAjcChRuz24TwyFYz5sa3Xy8fP358fHv4+vJ/ r19e5iptVdiLHVKQA2WZPIrM+7ARbFzZ5g5zKG1G8bBDm6aV2CEyUojcjfwy8CNBk18OhSiP F0k3+6iGRIs5dId+ai7L6EavEjqrpzwWg5XJq+p0oLhWTqF5e8IvygpH5CHB5QayU7urDWRu VshHivn/B3bambVFaTIgTWt9t4frQzRbUlfE95eXr+8PHz8e/vXy8PIdzAxfwcTwMFw8ommN jRA498GD6qDzb+pEeZb96MwUFONgu0fm5DvQv/V2cSwqBsyq5ohvk4Fg3zDMiAzcYdu43Gfb DOfIDOzY2geYZ6OihLmioPod9MPUSFWPYvBuDb23NGnRHHovm/bE4XaoM6gg6piaCUxsh3Mi THkzyiuQSHkIgxhAe4jcLUr/rFTfAYfrBISnGcBdd4aAGBJwpvS0AwUcDJ8mtp8b9pW7Jm6d s/71ywB+qOduvUeTWe1QlA0qY6n+SN64gd4jTB0UxwpfS2ohVzkpa9Ro2bSm0R1rufaE07ls xy/Zvf78z/+Dsf3tx+evLz+nXbI7a+OzPRQQ5UWu9Vi+iFdak8zJfJ79DSiBGmzjwIxpjUo4 asEghhnkjON53jJcUh3QxaktxLwYHFxDWSXu8hr1jLKi0PXxEkjGDujTsYQHJTJWMslsn/G2 2DsxLeZ3z+wUwgPsHM1AnDvm7qGsnbgcTIX6lYscEgPv3MhtNU9FRYtr7s6ru485ea0jV/2v GmNpr0MF3qxD1Cq64rjEj9p6h02m52bdUOD5ruo7BFDETr8GqFpFjARic68F9XUH2xEThTjq VORYs5NThociXZputus5IorT5Rxa1cNHjHDb6qdNfnpZcnXiDTEHY4aUjx9ffrzZNt6qGVzc jex54oXvGsNf37/Mp1gUlahb8N4XSXlaxHaup3wVr7o+b+zIWws4LNdpDx05v8A6xNSHGe+J sLRJzYFUsrYAYg8+SdQaJcl23EurqUGbrrP2BKNim8RiuYjsvqgFXirBr4XHalqI60LTo6ld UzoCG2lysVUSAAkZFkUZbxeLBPtCjYqdyKJxcKXCrVZ4pMxIkx2izQaLkhkJdN+2tlB44HSd rCzlTi6idWr9BonV3Nr6nSDbZer2riWY6GW7SvVuokrwh1AisLD6QGM/1sFA1GpQ1ZO2jyP3 w43DR6G4CLf8u8Zp03AlTcbWOhiAJl5jBlai2DrdrGbwbUK79QyqZOU+3R6awvmGbBMtvJVm YL6kNAHVahbq6AHL2XVfype/P78/sO/vHz9//UenYR08Pz9+fv7+Dl/68Pb6XV1t1E58/Qv+ tAUACb6BN+Yfdqh7QhAw9RA44hvHEmhi6hyv9CtQ/UMNkCNado78dTJywYkjTn3s+8fL2wNn 9OF/Hn6+vOn30zyPvYkEzhcj/NjfPOYpor7HnCYSlO3cguOQKMQQXawJT3WD0im4TTb15vDj /WOi9pAUHORcpO4J1ot51fTHX9cEVuJDDcoDn+K6/kFrwf+whMPrxoJUW5o/Xj9oPloAReWR 85MrgKjfU+Ymk3O1LSgIr5fpTaaCHmpkaw+OvdNxfkUoboIxUZ2QML8KEgK0O8Mdfra/Adkb z+hJADwKz/xsRrQoioco2S4f/qEE0Zez+veHVeFUXF0J4VqIdG1EqXNWWIxDXfLUuqsh6lKL eu5zAoSCPxeHzEeZxLQo5vLDaOEr972cIVmt39JBmb4+KlFM8XQkJQs9J6BdPwqC6ylU18H2 iBsluxBGlRIBT1bVmvpL1AFNkBKOFAVuGj7ijSl4f9KDpV9kClR8KiTugjHoSkOtViUPRcW0 1Cs0IiTHVoEGB+cIsDJgSB9s2gTXogC2qMI4WLFG9REkeVb/CSIrBoFugdgiqY+/zSZe4U6c QEB4pg42kgeUjkByqFv2HBpnaCNsu4c0gvFigc+6rjuMUsuwRt7oIYoxT8cr4rOtdRNS4jOp kQKCzspgWBCQHAQ+ZxppVuWsa/mrkgNe//ULjsXBTZf8/PLt9ePlCyQznCs4dW6Tyvb+4rmv 0VHXLjU3fUK9vObGJTyhqw1uKJwI0i2+tZTMVnT4pr00hxp1brV6RHLSyMKN5jMgHbu+wzm0 XcG+cPlnIaMkCvkdjoVKQlumGnEc0UXJ1GEacgK9FpVF7YWhqq0Z0FMaSUuiwfR2pZw81xU6 ZSbB1VQjz9MoivoQq2uAYSX4Rh0ms+I0xNQhqKDbZ/d6q86aSrrBBeQp4Mhsl2sp/omwgGuP kZYhZuPqrB1EiAuUUWh67q2To5KB3O/UkL7K0hTN72AVNk+muRsuW+L7LKs6/HtpaGlJtq8D DvNQGb4lFQbNyOh0mnoxvVmF5XnRp7Gi9AIFlViASXtWC5Sc2NEZFHk4VqDIq+AlQdwT0yY5 3SfJ9gGWZNG0e2zyTe/A0c7uYcmejiwPqtXHLzsUpXAtOQOol/iivaLxibyi8UUzoU+Yjszu mRLGnX75HAspAm8cVM7ap10PjyDhkikuJ1kV5i6XNz7RuIOfXWpQpk8NlTFuMBJqagMvGFn1 QcyF6y6TFfHdvhfP7guVFmp3/MSkOCKn6o6fPkXpHQ5zcLPPNHjyGbvAkZztqHILxdJ4ZQfn 2KjBAjotALwhAC8s7Qf8LPzf/eFseyKwfeb8UGjnfT0A5dRZSQoU2MVMHT+YogFOJatK+Dlr RwP9lgYgbk9iy8W99dIRR4st4oDp/NTt8ePnE6o5sZrgpD0V7itV/MRDJnrxGGhHPF5CnkFj Q6oVUtXO6udlt+wD/gQKt9LX0xBWnG+ig95lY38Ybd1V+SjSdBl4WlihVpGqFlfRP4pnVbTz o0jxRmtRcHwL8UvrajHU72gRGPFdQcrqzv6uiBwamzifAeFXUZEmaXyHBag/27qqeYF+QoV/ WZpsFwiTIl3wVlzEj/5w+qWbwPXY7s5JHZzOljRv6XoC7Lxg/eiMGiTnCB1ZQ2SaCbJ0+KkS rBXnRj/hUoBBcMfuCK1PZb13s408lSTpOlzAeCqDAttTGVhGqjEI1g6WC/oDjz08khK8v5w+ KgD4/eFVtvzutLW5883terG8syohlF0WzllNApEBaZRsA3oQQMkaZ31tGq239zpRFYIIdAe0 4CnXoihBuBIfHAdeoQ+Ou6tUFMUTXmVdquur+ucmqd/hM6LgYLum965QgpVuzK+g23iRYG48 TinncqV+bgOJ6xQq2t6ZaMEFRTiJ4HQb0S3OvYuG0SjUpqpvG0X4htLI5T2OKGoKSsVO4lMh NdN3hkByrbG9O71H951p0jQXXgTMxLCEClzJRsGLMKDAqxiaM9jqxKWqG3FxHQ/OtO/KvbfD 52VlcThKh5EayJ1SbglIc6LOehLQu8oSdRu06ju5J4D62beH0MMXgD1B8jcmsfRKVrVn9ly5 MSEG0p9XocV2JUjuCdoda3FtGSDiBjf07vIcn2R1fWjCcasi89NFThKIyQ5wCj3k2xwuIW+p pgzE6DZN4LFb/DoG5mDjWzpTeANKXQlxpgbIR3VbCaiqAN0UeyIC2VYGv8k0CljAJzzOcwCv VuYmDZzVgFf/QvIPoA8CP4kAx5oDzj7OHosenQ/7c47pFoF80oZyc4RiOHlwz9bDrURr8rCa SW9opdz2jLVRlvoKwY4aBQTledv6qFYwL/8LGKLxddoywdH4LrvS6f6EIQslfQbHtCWur56D u8ozGFIwHGG7PdhwGaB/vuS2uGKjtJa1qCosiUtLLnRu1Si0k+rD+RX8TP8xz+3wBzizvr+8 PHx8G6kQy8f5TiCfxQcGnBZftXnzmmvIdQaASwau4hrUJ30gJHdQ2GV1KcPmO92yYPjJq53s BxdMXAcgcsSK/P2vXx9Bc7R2wbU9J9TP0V3Xge12kNq1dN5eNRiIGHB8YQ3YJKZ/dJz8DIYT 2bJuwOg+Ht9ffr5BxtdXeK73358d/6yhEJijkWZGOLjOHrsgVqj7uZra7s9oES9v01z+3KxT l+RTfUGaLk4o0PjLWGM/84d1CjwWl6x28h2NEMVDm9UqdXLReDjsDjGRyMcMq/ZJRovNAkXE 0RpD5EP0TbtOVwi6fMQbAvdttPOA0OsGvRBeySQl62W0RqtQuHQZpbeKm3WGli55msSYD5tD kSTIRylWs0lWW7RajuZdmdBNG8URUmdVnJ20sVcEhF6BXkogOOSmN+FkfSZngpt8J6pjpSbu 5gzwuJf1kR5M3hgf3Q0rbF41aKb6ApPop9GQjzqbp6PjnHYkxrjHzQgpLKzjbIT0pCJlvccQ idPNCZ5jYsUVTeusJUh1+12MNb9vbc26A+45ijnCyya8lmjntIhB0IcZrjSC5cUZ4mZbpHrJ XdXHVLNWXN2q9wwPu7tez1ccJ3utfr3ZL8iVWbcZWoFGZng06kQEcXr4Z51Zrn4gmOdDUR2O 2Izl2Rbtyp7wggZcOaYGj+rY3rdkh2lIp7UkVosoQtqG0+OIzn/X2C/LOmB14IYw7vF8xTWd bZQ2e0WnCHFWl4FosV9NAiVo4hqLhjWO5Gih9tIWmy3EgVRK8NqjuMdM/UAxw/1phjPO7GpB KgF+Ofs+4E3m3LYKTkBw1W+K1g09sPFp2vB0vXBOCRtP8k26wf1FHDK4fPQcNUk7dEd17rGO shbvTnaMo0WUhHoDpjt4qIPRKl0tVne7RS8plXwfRZiCwCWUUjQzBz6EhMUYU58TLn2/dYTC 8563SXKyXawwI5BDdKlI42rDbPSB8EYccLcbm64o7CuNg9mTEqLf9BIMNVN0NMFfyLCpEOOq jd7Xdc4w9uJ8kGL29pMENo6VLHbiJW2kWIvLZh3hyP2xeg5MVPEod3EUbwJYTzvg4jAPA5tC b+j+nC4WgX4ZghtrREliUZQuMI2xQ0YVY7ZNwQ6SiyhaBnBFuYPX3lgTItA/AvNRFZ3tuuaU e9xEceirlMQXjmVzhhjS3stVt8BSTdiE+u8WIoxCbeq/z6j9yCFjPeFJsuqGpz7x/mv2dm/y c5luus515rcJtDau5k0tmAyyJE6jZJPit3G/MrOVf4u0IZXaq79FmuA3dZ+MSSzMZNZFLWeE PlYfubBVf6OmnFOYomhxqzLWasjvfUBuVEi/Razj/9SRPas+RF/LurnV00+QUSHgO+aPYYmr OWd0MSb4+1TPFzBPs+BaN7MGmfyWKy82IEiv+cLv9ZGIy++Mof6bqbt7UG5Qa0EfYvd4sqKL F4vuxtFtKAL80CADp0XLexkQwgQrC1sQdnEizCWEjGI7tY+L47tgg126XoU+ohHr1WITOEmf C7mO4ySA1NeqwOfXB27EO7v0cN9lArkFj6JpX1fqzhy8DisJNVrOFF8G6o6cwWScRKuFDy2S bjF7vWZU13WbzXqbgMlQotd10qXbeDXvp09n2HXfnFvT0i1aTtLlChOqhu9TTNp1uDHwfRNj Lp4jktWQFrKxr5UWKi8gs1Y7r5XIUgkCmaxCyVYNEdMh0zLwqvdV3aefXjWUtwg7+Qm/eIxq 1zO8k3OzjkuhrQLBAaE8Wmznn9sWe0jnDC56esrDs9A1sVqgjesrMVzNziV4WvQnlrXhKTmi CuiG7tLVZnbba848MH2A0Q1hKwKyctfwqDTExMIEB3tjbh1mIftNAG6d4DiSd2Wy7JCFYxCB W5OhYVyoDz76dVJOEkdsdcDYzgbbxWOWe7YLty11joMKQZTqr4zMxlHUdOACPWlbcpl/Ud6e YmBKZmXc2g+acr36bcoNRjnQtZz5F0oNctMFAETwzIPsFskcYo5DDx7nQ6ipT2+rdQZI7EOS xQyytIfPwFbOpV0bCQ6ff37VSSbYP+sHsM44selOL5FcAR6F/tmzdLGMfaD6r5tEwICpTGO6 iRY+vCGto9UfoJQ1YlZ1yTIE2hIny50BDnEkihyZ5qENEXPngeihZEt7pBVjSxDOfeoYEnZA 3edHa4+wvhKrFWZQuBKUFke6Agt+jBaPEYLZ8VTfbY1F8tvnn5+/fMCrGn4CAimdfXbClEiQ jn6b9o28WCLN8H5fCKg2jLpH/hmv1u4kkHJ4RKLKSYtnqqjq5zrk19nvReDWA9k0lMCGHjiK KzkPa6vfjwZgYmZffr5+fptHhA391Q/hUls2GRBpvFqgQNVA04KPf5HrvNe1/biOTWcyTvgD pFE70MBjH2MTURMfGuiE/Wid06r9dpCNmHlp203hTNQm4fpajPmd21RV20NKLuuNbRvbqlXD eHElQRsqOjhfAm/ROUNwvkvSyjhFowtsotJ53ND5ZpaHRozXHZkx3OrH9/8FrILoRafjJpG4 6qEiGIaSSezePVC4B5MFtBaHX+unwCYa0ILSqgu4No0U0ZqJTcAjaCAauO0nSfZ+DrYA6V2y NuD2adBtgwu/A3onSjWR99qARfwcJVj65oECZBznbXULTmVbAk/1+bwCgRtOJbEdrRG2XFk2 853dNI7B/3CigwOJC3PyEAHAyUA2AHD3EhPdTW+EnLOGM7Cw5CUqxx7OyJvVV6B59JDVPODb ORFqz6db9Q/RnDOw5x9pI/wY4fFAObXE6W6bbNeYpxRpGghrvZ4ZxoHo4Qtysk4r6lJR7byA ipWQARAyoC6NoH0tNcFRV3F1pY89ab8ZXePQceXnUGz1oUHd19UE780L6N4zlZKqfw3HRt4B azomfE2Ogc7JlBx9daCbNoyFZApSFahPt01WHU+1o0IAZGUnGAcA2hLWgkPQBWJ7AEdb7MgD zEkNC1gBuwv2aUImyXMTL0NmraLULxk6YosrRHesLC92hhVV0dzLyslZA48twmCNr5halzAF 1c4RajBqF+w/mqRh8H6r44KkgFx7QZl8V7/ePl7/env5W+0N6Bf99voXdtANxULpFkd0Keky WbhvjwyohpLtaolHhro0f9+kUQNyE8/LjjYl+rKGohgy50FKOndM1KXQPiz0ai/3dcbkHNjo qLvrXF5vZ5Bd591/au9B1azg3yCZDvpwnlM5i1bJym9RAdeJP6Ya3OGWDY3n+Wa1voWG0PrA MLHUNrlpiLDNWAbCvbFpGOuWLqjS+s4YBfZiuU29j/0vZVfS5TaOpP9KHrsPNS2SIkUd5gCR lAQnNxOkFl/0suwsl994e2l7purfTwTABUtA2X1wPiu+QGBlYAtECA47rG1sVxbISUQe9Slw m1zsJCdOHikpRF0Jyx6SEeQJw1ApOasIj074+f794+fzl4ff0R+gSvrwjy/Qw5//fnj+8vvz hw/PHx7+NXL9BmvJ9/BZ/dPs6wzG22T+ppHzQvBDLf1J2VftFjz5LvLUUufUdxKIFVVxCm3R dz7txjIwk52dsbkIdh9WysmFRgMdyOtZ6xR/wVz8FdbVAP1LfR9PH56+//R9Fzlv0FR4CC2p eVlbQ2txg2jUbfIlWOLBiKeSXbNr+v3w7t2tEaavV0R7htZqJ19r97y+js5dZQ2bn38qjTpW TxspZtVGdWVpbWUa58YvwtZFJyzO91FKL6vKYZzvk1cu2bxvWBcW1HGvsPiCxoqWujQTrf4C 9SjMH8Z8ps67hB4JdfYPK8mfP6HTOP1LRRE4z1FrdtMdOvx0nxEoPd2KSbQ7N2MyWCKiE9jH abFlyBzBEqM20aWYWFw3nQs2KoO5PB/RHe7Tz29ujNe2b6G0397/jw2MNvHjMxk0l6494ZJ0 4/inDx8+ock8fJBS6o//0urOa9wtaQXmdaVbUSMD/E873Bp9uy7A3FZq7IwiyfEzYjg9UQ05 olXWhpFYpWYpEBGXIDZNtSZkx659x/j9bGFB3XXXEy/oE4lZFiwWfZdTsyhW101dskfPS6aJ rcgZBiH3xGgeufKihj3ka1keiorX/NUsy+LMxW7oPIGap5Yc6o6LwgkGPPUyDFYVjNsk3PZM 9C2+11F+/uMg1DluowNWKxHsh02fE2qkmNOjTI+xUeeVdPX85dvL3w9fnr5/hwlXTmDETK7y rfKWPlFQ93pn1tKX8xLGIzc/Oo94/4ws+bjpgUnSymt9cdrYZKl2aSI29CGOYijqd0G48WVb wfZkaK12PF3SOJ61DaiQ38ZWxCsGqyX1dMFqjdPxbZ0WTl0QkxFuA8reSGeB5FZ59psgTS8W URW/sqi8Tzf2qCBaFmhRQPrGkvCZ1+h80BJ0FkGSycLNaz3ZGM9/fQdt6jYH8f5Cp9uOfq1+ w3cCnpeQC4PHu5G61MANU+Sto7oktVu1b3kWpvI6R31F+/x+JdWdp1NHXH35ci7baLuOrIy7 LO7j1KYqa4o0ochb/RJNkdWd8XLAw1/pILXPsaTs+vRiN0tV3nhztIgyCLwa0k79ASsUGFJn UarKeRaFwbzwRQsgX3HPhm/mc4BnfM46Jfjt/z6NO83qCXYX1mO2YAotgw9bGnrgLEy5CNfk +3eTRXeWrCPBuaIAfRkzFld8fvrfZ7ukas2K3tAohTkzCONOaCZjwVaxD0i9AL50zNFpvocj iHxJEw8QelKk3uJFgQ/wZR5FsCfIfKCnthv9oZYBpF7AHoNLbYoV+TTVYAk0vSyNT27sJGwS 7CSNQNsLEf/2rHNAMbRtaRzO6XRvFI42Z4pxkTfZIU3k5bQPgxq0doy0EdyxHgb2lXwJMGGq ve8kntudTJqSsWl0Bu0jnOhCD1+IO6ADNopOrFjNFqKT8+5tuPE5d5kz95nZTwxoY71RKtlJ PGKvJlcqcjlcH+syNTh1Lj+ycNFiDm47yK5eRZTYsk035nLJYfEchizCZbuSwvssSmKqO7WS SWs5T5m3qQtAR62D+OIBTF9HOhTG96uJPJuIfiWi8cQpOU3MQ67aResNVQY1t5OJp/4/sOFQ YKuF23XgjvGuj1cR0VRdv13HmoK13KPJn7cTz23SeAiiNhvqrvfpJyx0qY3DHFRgx/vhMHSU 5xKHRyvrjOWbtf6CwKCnFL0KVvorUBOIfUDiA7YeIKLz2IbrFQX0m0vgAdZ+wJhSDCjxXQRr PPejPUgOqj1EtklCMufHtC/IkJQzQ7BCDlfonlVBfLSnlCXyRFsWosqowqDDE4reFkVOtk5/ aSkNMuG5SEJCIEa2oIZNXpSwn9f3UTOirBlZThSbx4/o6ZpoB9iqreI9DaTh/kAhcbSJhQtM Br9kCfawhavIBjqUcZAKMibawhGuBFHlA0zTjJS5SWiDMwUf+TEJIqLVeRxTvYvnrPQ4Mvev E/VNtg6pYsFw64KQ9Am1BL2oC3YoqNRKr9IK3uDZetxVLTwwAdG3dzpPGNAmGRpHGLqVl8Ca +JAlkBDNqwBisON6IlklhCyJBFuqmSSUUJZ9Osd240mbwGd3P22SRL6Mk4RcHxkcMdECEvAW KQo2r3RplbXR6m65+0w9gXCTFvU+DHZVpibV+6OiSuhLyoVhQ7lZ0GBqXFQbsuZAv9eLZZVS Y6lKiVkbqGTG1MdbVuYaTKPf61uAyYy3cRiRDS+h9b0+UxwxqUmydBMl9wcF8qw9a+OJp+4z tW3nwoq7ajNmPXxUEVUWhDab+3oJeGDHdH+NgDzbFe0xeqnTPo23tO5qK+smy0orjn1AjAIg 06sLAKK/7svL6ITq4vvepF/B/joiBl8Bk+h6RQwkAMLAAyTncEVoT/RAuN5Ud5Atob4Vtou2 ROlE34tNTNe5qkC13V3fZUGY5im9SBbBKiAHOkCwX76nBxg0QEotlXjNwhWpqRG50BaoM0MU UjL7bEN+zP2xysj3SzND1cLinUyKyD2tKRmIVgP6mup3pNMjGh0UZu3wyqIZuJI0Ya7gUx+E 9Bbg1Kch6ctzYjin0WYTHai0CKUBdUWoc2yD3C2QBEIfQHwskk6OM4XAvsB/n6mxlps07u/p GsWT1MT6GaAk3ByJNbdCiuOeKuAFb6acM2Sfxcv8caD1mXMWRmxSHlcetxE4OTDtzngkYJCT nqMrEuFiRVXAxr7GdwmYdbPH8Lolu94qsYTjmpit3f5EPndcugS59R1viTzyYs+Gsr8dmhOU pWhvZy7Mp+ME457xTsUJpW0LiSQySKt0YfNvJxmPS8uyyRg9q06pzDK5lXy1csiwY/VB/rlb wP+gLv9ZHTAwAeu5GVpGxbmTQrKSVbRp+yVNbu0jHthW7SSOtlWR0vC1Wt4LinP5FoA1Wq8u aAvx8sV4YqJLQxZKjln67KgN/+UknfXZMW+oU2qB7gQaIfjOeCEidsYP6IHOCASKqTKO7iTp 1BNqE9Ee+m6qicHKPufNnWQTbFF5WdQWbQwcDKWTrx9ocSaTodkW1HNEu8sqRohFsvnrpuqT cZ17OcHWOXzZSByGmJNwqQB9to48Yl8yQftW0GWg1+NbVlFm1Qab5UhPYaStk7T5/ePX1/do 8zO5fXRu+6t9bpmGI4WJaGNO5+ifTV13k2cUMhHrw3RjBw9FBEoZb1cXM0gD0vNtvAmq88kn Ub4qtoqmXhobhtSyEsqYzs5isrGjzbp1jsWG2qw0Hp6Rd+8zqoedRYnjcZvlsGZGqKXwBCaE KNMoeKQG5JJSgoa1JFLw9O1yuZBEu5Swcbm1TPCM3s0jDCloy2sUq/Tj24F1j7O56ZJx2Waj eYxGsKw6Fo2ODfyK0pd9kB3787/LmKMR592yj8/LjAZfELlsejW9EzgU0DesfgdfeOMLgoI8 jzDdlfRLOoTlRZnPp/aM+8YXda8pRwK7BOt4QxkWjbB1jzVT07UzNNV93B1ZeDFLJtreTaRf l0linxj7UEmbzqts+Sfeor9d3xtXZOmKfvCCbbaP4TOkdmIy7Wz9oROtGy1Jmy1jDPECtY83 5gwy8PUmubzCU8WkAyyJPV5T6GJLLdgxD9juEq9WTi56iqvI9AU50gxXUMb5PqKzgZBRVryZ TamN+yiwrAY7ScvKilHbKrx7DFax6bdP3kcG9IcyuXXxZe/YKS1U8/RvoqfW7ZXJwGVtI/r2 fRadJq8wbMktmAaHRIGB6k6UgIAOiYzZvT+X61Xk7fvJg4e9TENx5zIIN9H9sVlWUez9eiYT RSMFk3FV2Z1p+1yl65XTH0CNAsfLhsMSr15j2W7p08ZOGiu1vpaaHaYsbb74ULEiqC/Anl8K aIim7NX9jsOATyYH+ZS4FoPxDHDhwR2c3MDd5YJJ4JCaz2gMEGcI+lx4YWNZn6bkiZ7Gk8eR rrM1pGaWly8NU0vI+5KdtamGycXh3eTaWtTtIGsxZyKJH4no4gAWkt+txRKQg4LVcRSbn8aC erZFCwMX5TbSbdMMKAk3AaMlw8eaeNSVxgR6fUNNNxYL2WTSMIfsAERissxobxOnW0+R0Rhn Q1kjLzy4yonThBaAS4xkTflQt3iSlV8ALGxeFbClh5ezxDEga/mlYeMa3tbLJoflGJHkSbeh RwCss8j3gyZLSJdvWqQRgtv98M4TsFFjOqXpSr8XtqDUD209PdWeKXuCBZdRxsaXTETycQl3 V4S99FsQdyG2YDAvx0ESefphWubczRiZwsg3RtUaJqQ3djab5yGCzZbST09tNtI0zGIKIl+z WMsbA3OWMguqVgiUQdu43l5EIqVuer7nxqxpswHBiGJR8s48FGr3knaDXV5B3Qh32eRazthi cox/OEPUqaMceJpbOp2ekPQ3p4yki6a+kv7tMGJcfW3ulwIPo1tSbgULj8ddTmKXik7Dlame UxbZTCeeeQKoyPg30iy4Md2HyHOvw8vT9z8/vSce+LGD1nfwA18NJGuT5ASVRaLg1M4DEeXk YqqR3P8feuNd6unAYDVLPzpCTJx5j+/RGmo6z/VHt/ADXRDzW66/rERqDlUZLq4XAIlJS8iq oqiiKPdoEm1ij5UYH9Dr9UBkv0O3KvOpPlkn5Csblt+gk3JY2XbVmZFLZWTse6tcJ+u3gKbB S7z5mc7z1/ffPjy/PHx7efjz+fN3+B8+ujYO8TGdcoqwWZEukScGwctA7/+JXl/aWw8Ls63+ UskB45XdPB3LaccYCMJYO7SDnURRoSR3U90y/uhJiav+tqev8DS2A+t61el7N8QSy9qHf7Bf Hz59e8i+tS/f3j//+PHt5Z/w4+sfnz7+ennCE2S7hUEwnoU5wvJPP75/fvr7ofj68dPX59dl 5Jlbnip/KD/9/vL08vfDy7dfP0GOdmINo1xoJ4jyp7xyNFTqSB4HuLd56mY4FYyy+JX9vdWt QibKjZXtcdY/dr9Ijoy1/dAVt6LrGn/fSNbXOlAyHU6unvvw8uVfnwB8yJ9///URGvuj8xFg 0rNTBpvD2pbOdHG+7Ysa1LpSFs3uTZHpfnRdRuWoJmeUtPGp55BRAhY95FagbM63sjiBZpVu 5eQrSkodWzmddiWrH2/FCT5KS8ccCkfrnA/7i527ooLSy7wf9aFihlXoSEsIWuQQh7x0PmpB PcKViv/ADqEtIeNdN4jb26IaTODtpTQJuyY7CqeCyskU6AdPpu3oWtf4sNunr8+fHYUrWUED inaHb6thltJ8HnvE7zqeH6zOUXJmxMiZTzHBHnYvnz58fHYKoaL+8Av852KHSBzZjoKZDqsw 3ZELDn+sk2M5QfH6mne0swXEL97KKe+LZj59vrdmlC4IUztP6GqPTMGtz89YfkgOdmJ0kzYd eh+Q8/bt7cC7R0sUvs+eHYbJht2/PH15fvj91x9/wCyb274q90ZEn2mel7M+Ufr97pZVGDxM KxvQ5Jr7apBy/QgZfu+aBsOXCl3hakLh356XZQeqyQGypr1CmZgDcAxctCu5mURcBS0LAVIW ArqspTl2GBG84If6VtSwWKUGyZRjo5uwYAMUe/iCivymX5wBHXTrsLPyhwWk8Tof24tlj+UY 4mGh4oZkXNSZufW8lKXHGEtkx/85uT1yro6xMaUCMgS2VWi1BFCgXfews8D4mjXsdOj5GOVd QXuEdAwVgFlnjg0GKzhoXLOqvBK93RnQTuRjdYAGHFs2O5Bo7nqtH9ZhrxzMLiHitGFHBfl0 Bavno+LI+xqj4ycvxjdr+s4BsLJIVzFpH40DQb4YtsqhiLC5KMui5gN1QKJxYZSpt4P5IY/Y gRZMn+JjFeWK2ZCkSOa1xUKmR/cIWgsZHCD91VKwM3ER5Rlrpi9eRbmRMdhG7GA3KxLJXHQm QZ0lIX3S5AazJPrbc8RZlun+hBDgwv59i8zrk4ka0Oba+FmQvrZwHBcNaEFu9tjj1QzIBKQo JwOnoeimyZsmsL/DPk0851WoumCRAFOaT1U8WmopsoRnrKuscN1aS1QiG/Z2h8KKjWaHpQN0 f782FoOyxeS9zUKT/j53tGN2/F4KDDPSVHa/o28Q2iwZNT4GNRbHorC1nuBVW3oruNHP1OZh eiuznNraIDkrmRBE3G5Hhs5I5TF6UjGOzmaQPqBdcPuSZkEI64IFlA/37gpuq3S7Dm7nssgp 6YIdmRlWQBOet2nqeRdu8OjRVheIfnE+J/Reimm9hpc2K0Z2KEJbWnTZpnHsexg+V3w8tL5f u+lWzu1s22Rtyf0Uh6tNSRmcL0y7PAn0SDJall12yWpt9oBZHs8BtCF3zM1zfNgdUMdsohn0 D1H+vDXCdppq0m/oVbxkXDfXNKTUue2zFUltZia4Hc+5HsoNSaJ463w9SO/YuYIVg0mE8uCJ nF5NJFf8UnQIkr07luRVXFbAy4Fh99CuCvRo0/kFjerk1pQ5fIak5zjMrmuy216YlTuh3Y4o JOjH0JWziVlLgZk0JbJbC+t66Yba62VCZqhcn1hi0cbzsBv2ThcOeCbSET07VNXVw40d4qbA Tr8VJ9PKVsPs2ozBzO/0rOvv8pj/Jo8ANY/7ODjRuQZGjS8bPC99V/x3stZx5QvREC6DhQ4+ K7eJY2ABaa404+ISXinRGeOMdra0JA3CkJqoJ4YEdqvWlyWjlfI9y5yRsctyz4ZkSoe72sQV 1zY5VX4gH8kXLSPeN3VhRecYkRPrOLsQIzfz7CHkEGk8XtoBu6TUnkgipltyNUBgY+9cqRwN 1ws8X5yW9F1RH/qjgao4IOPvwUm7LAtUJIjvz+/RKz9m7Gw+kZ+t+yIzc8Cl7zAFY5wrq4Bu IA+EEMO1gZMAiWT8QomqCLVmigG/FE+CXVE+8tpqrKJvWhXf1xCk/BN6BGVHDr+upiSYkATT Y8kiEZRmzjHMlMUr78+cPNswCKg5XoJXUALCkgPdeWik90D9JGmiGWGLkb2ohEtTgUMNSpFZ PusllZq2JfLOiMKkhlG1411uyzjsSQ9UCB2b0ohtrH47pT00zaEsMJqsMatLqE/SqLOzhKL5 IytKhiu1JEVkyPAkMzNzObNSmU7pOV+76YmNRuWZOvY2cqNDVyDyhhnhzZHUn3l9NMO6qirV gsOHTR6JI0OZWZ4zJLHIbULdnBqLBhV2P+iJesvfeAD40Rr2ZDOy3xOFRLQbql1ZtCwPra8P wcN2vfInPcNGq3RHstz/ynD1Nv0qH4CY1K5QH4rFy/EtQrPvLTLq4c4e5RgYiVthZ5Fe6yGM FaHjB5ME04sZqE1qC1bjk6ay8VhJS557IWkVQ8/Q16VncLSgumAn6WStyLAvvZ/OOP4hJWBE 9FdkZI6aBCWkons6Gh2WlpUnVqzqRkiX+z4qWLJmzCkpqGk6lJACKzHUVm8Jpe2XqRstOMzx aeaA/mY80f4k3hessrLocVDD5FtYOh5K05aDRewqa4gd8JKHCf0yYiY5X4qoWNe/aa6j3KVa Gp3+/KRa4qfGblLQiaIoqEWVRI+gr6z69sduEL29nNepxKw84Prl1pIHdko7Z42Vz5lzDO5o Ei8cPiJb+Luia7DmHtnvrjksYGyFod7o3o7DjqRnUBs0ZpO/nMVK2bqWAOi4klznqfWxpcRb nTByKPuTJWgCJUxGaOCLWcfXn8+fH7g4WtyLaZK0qwEGTEU0EGbdHDN+w3sMmKDVlYtZNOfy aIwrbTwwllsXjKx3ZOJ2zMzamWyGs32Zrq5BM2bFrS7Ok/XSVMPq04/3z58/P319/vbrh2zk b9/RHsK4wJThmsenwnhNwz1mC5Lv9Y23bJSefvg7YrfzEXRRyclL54lnV0qdK/pxmBlCUN3i OewBfbUBwTbIMpgrcs2AyNlp3rPsnh3be8jzBn8Zthh5I1sib+T2jkEmTTaX1WrsWqNwFxw/ QPeUsBhhO5mkd3hFCa1z630NKdn6HsfGZNFko86AmrIkwi/IvrlgCOFj64xT6SsxSC4usIf+ hDQu0Cy1I6j2YzYDE4Kas83kZPkHT4uKMg2COz3RpSxJ4u3GLe+ZrMXxzAhilltPhSeqEM4g R7J0HFpZc/3/N/ZlzW3cysJ/hZWnnKqbRCJFS/5u5WEWkJxwNs8iUn6ZkiXGZlnbJak68b// uhuYGSwNOlUnR2Z3A4O10Wj0Mqw9+Tg+iZ7uj0fOrZz4Q8TdPoiV2BnHqDNxZrejyVxTqRxO l/83oXFrChApxeRx97Z7eTxOXl8mdVQnky/vp0mYrikhWh1Pnu9/9FkE7p+Or5Mvu8nLbve4 e/zfCeYJ0Gta7Z7eJn+/HibPr4fdZP/y92tfEvucPN+jzZGbxJK2ehzd6E8hAEtKS5sqYbfc pI3wDjlK/ecNg8zh4AOJ7dJEKfd0feCwQBtzL2YSaekKqf0077H+3DyC3S9IxDKIl+IM+yPG jV48lZXSTYa4fro/wWA/T5ZP77tJev9jd+iHO6M1lgUwEY87fV1RlRh/ushTTl1AX9xEM7MX CGF7QYif9IJo/m0vJA+e1Jw0QRU5TA+gUxfSt1ba994/ft2d/ojf759+A16/o1GZHHb/974/ 7OTpKkl6UQJzYMAy31HSjEfnyMX64bxNSrj8eIJMDHRsx53KXHYpC3tUywMB2retMQd8LVDq 1/XddHitkhLTNvNQ7rMDzlr+PBEOspeKAvCaL1wDK6BB9rC9tq6vp7ypAvEaytbI1moKTZ7q RZaw4RwVTo+VSkw4bpt26xw54rb2pBujEycp5h6naykDLYvGE1Ka8Pbho5Rp8Pc6Mj3HJNaJ lW5ORExaBi9+0eBbQcqaHNEQoFozhulMgzuzXSBxwp/bpbXAUqv5sEpBzKUc64afIzWu2AQV jJcFtm07pXiDocDpXF0kW7SW9TQ4qfHCv9iYVd5BAWcixWcaga1vRaCMBn+n88utJW+uapCm 4R+z+cWMx1x9uLiyv0f5JGEcMQSy8ErR0SooakNLSfPQWAIRXdsthQ4V36Lq2v50K4JlKqAS 70LYwv9Z+GFvld9+HPcP90/ynHG163SurLQW50UpK41Ecmu2T+YZMdLq9QxjpscgG49IDjac wkYfFE492nm7qleBJnwevxGXlLtu69/F5G30ajFlsEpO6vI268J2sUDTuqk2xrvD/u3b7gCj PF5LbP7Vi+TnGPSystGMOGzdTrfB9NrZHtnt2e8gesbr/giN3+HDNCI6jKOztQdZPJ/PPpwj yUUznV77P0H4Gz8nXhZrPoYD8Ybl9MK3Q+lFlruMyH+yy6S5K/Xsd/SzayIj9SrBFshWzPh+ EtFGrNuHqonc3m6MlCLNj7fdb5GezPOPeKen9qz/uz89fONUKLJSSr6ZzKhB85l/oFHCqZXa BS/GvpMNxBSlXDZ5U1omduo4q3bl9qSt2k1o/MB7mwnA650JSS6vbi40y/fMtN/GaFVOFuuR tD+VpIidRX/U8R9Y5IwmYRS8s8grziGujo3GDiBT4EVwlUTFym75SG9Hm2FIyrRZ8KcA0mzC 2hP0BEcgWWTdGXwdy+axKZORIAqv9YjwCMJAknWc6RHSCdyGswuLtK1XTrdb6FTyAZYIG+4C B0wE9DjnjGT0yRnzpqhXSRi4tJluL5KJDIMVGg8iPcwXW4syktWn/cN3JqRWX7bN62AhMN1J mw3ODHrRn+qshqpoprLabXT3F70a5d1Md1YbsNXcdOweEeMwMgONOkzU7Y01kqaP7Pr06kZo 5w9zRkRhhVJcjnLvaoMiUb40NfY0OEDqjieV10zkdHBQthaEYo1cuMAPV1MLOPitmy2VybY4 EZLQVkArqh2D3FwxwLn9ybScz8lf39Q7Dzg9ruwInDHAD1On4WjMx9rUqFkSt5hqLEmt2qi/ c3tgFdSx3huQvhgRRODNJiOL6xmlCKKHTbHWTTz1BYcmvIrwVV9NPVc0OTTNbP6Re7eRC0EG SXC+3UQBesL7q23SaP7x0pNZZ1iNcy5StPywFrDKWv+kePvytH/5/uvlf+j0r5Yh4aGud8wp xtnHTH4dX7z+Y+2gEG8rmdNJfyLtHg2TY00X+iw6FeVJdH0Tbtk93Rz2X7+6m1q9HLgspX9S 8JsfGmQF8JVVwZ3zBtlKgDAQCj15uoFnX5cNioh1lTNIgqhJbpPmzvMNhn30qP7xhzgDDd3+ 7YQ6q+PkJMdvnPt8d/p7/4SZlB/IwXbyKw7z6f7wdXeyJ34YTLi414lhRGh2LoDBDrx9LwOY 4Z/1HkR0K4Yi+iJg3M0khUFhpzKB/8/hmM65RSjiIIK7coGvXTXcgzUpkVDOux5CLRrpijfk FNVRlu5XwTAgAQY00PshG4IBA3ytFNdzPaoNwZKb6cfruQMFUejCqTyZ+XiYRIvZ5ZQ1RCT0 dnbj1jjnA2BI5LWpj1clLnQpTcEuXdj1jOlBLf02/X2o1zyvJGSZx2zMjCbqDCc3BGAs/A83 lzcKM1SEOJJHmIriLBjfZYcSI9Qj66Hi3fF+RKtfkS8Nf0aEDYG6QMDJRVqbWDMrLgpgVQBS 3TLOjG2n3rsByi42hS6CJtZfsChwzQpLddkyaziE1poNNihyIgcpODd6qoQhS6/qtpP1DkMV DZm7+27WdzmI4tvObEAWWJEnhhHtqmA0DgBw2C609/L+coeVoqpnrKHeEFSrMjKGNWi3Su/J dK8MjBTs9HNI431hgauCvjw3wVKohUO9rg0fXIklP9Ye98svPRJjdlgWUS0b2QtXVm/YPdZ9 GxbbZWsMpPTq1itUft4gbbTO6s72D4fX4+vfp8nqx9vu8Nvt5Ov77njidAiru1JUt04N291L L7M4lh5oRxyi8bgu7SKQWDmMzFI3OEIEBRi5baKVWWBh7FkkhEVdBo3EsTyFPnNXq2YnNRsE AYngP9TzuQ5ZiFzm9oFGUDhKG2orWcYzFdebpGjSEKntwuVtBKXGD3qaVcJcR5nVHMVBRh1H EyyTnFNDUAR19fLeMXwvQG+DTVKJVHh8QJBiFfN2Zmj+3KVB2RR8/HaViyxMCr5uhS9ufOFs iaAKGz7IzKL9K2mA95xpQU9CmQI40TDIkrToqsU6SQ3nmWUZd2URrUWDIfh4K7tSulj6kGeH NauTc+0GbhHUaIx4jogWf3qOgowEz+Dxxa8M4nMkeI1YI40n5PGQMi0Oyto9v4DdpMXGv3p+ svbKpNtkvO4L7f2aoDrbdqX5CRs1w2epVkF5phlRVp6LLh2tGsobMFvwgo86rvMGJKtpd2sH brToyKb91nJrtWhufdtCfarkpB+VuCCzY5qh62rVaEefskFVo+vOaxGs4SaReBKhqMKfPMF3 6fWxW2YtLwfKL1Sed2h110c70ehMHIHy1rmqWFXgKCSeSa3bCt2A8JCfdWHbNL7EZ4qOIzI/ 1uZJg58z9HDpduDOZxratFVI+eE7T3I1EEMC9EHj9if2Em9O49RGq6rIxPBhK2AS4gqOq9sU Jb58CbZwE2bcaTjE2G8MVtuD0/JcIZiJpnCKYaw5fIA472CfwTES5AU/2H116RpPchBS1q3u XIGRfgGH/m8gCOrRAkl9h7heSo1en59fX0D2fX34LsNn/Pf18F0XnsYyMGnzGZ852KDRNYoa JoojcX1hxDHVsTU6q3URO3+AV5GcPaUt1+vxSNvUZQLcPDJMymX3qMv16/uByy4BlYIwh7fg uZ7cN12HaWxDUTUZFtpVuYw0Wb6/LBkUCTS91VQA0j5o97I77B8mhJyU9193pERxrZBk6aS4 NW8JWSwxTler3fPrafd2eH3grFEqgZbe6KfqFnx7Pn51B6cq4eqnXWvxJ90HjAstQekKtyRz AwBwl2Qic0V/clnGk9ZpFDoG/lr/OJ52z5MClu63/dt/JkdUKf4Ngze+RMiIbM9Pr18BXL9G Wj8IFR5e7x8fXp853P73bMvBP73fP0ERu8zQZnyZ6qdzu3/av/zDU24TGJJtdxsZ5hElybuL SnxiBkps8ezoKxf/nB5g3yr7TeahT5JTXGkzYL1N4T3WFX6QAmZXHzmvS0WGKT1negTkEW5F AdYRVh4Ghaqam4/XMy5khyKos/n8YupU2Rt1cIiIzbMCS7/y6PY8o5I3noiYcDzxL8fGowH8 sNV5CGLahmCZhICXFQgtE3b8hMB/gCANPYlQJlHp01B9osCUTBBSDAeHpvtwqOfVn5faWJVo /sf3vhJoLQU/mqpIUzO0O9lRJU5yhoX5pgw/4T6zFrA1mPoR28CFM9GDlSAQc62JTggzLxVi xmij0vJzdQcs9suROMrYXeXTa1oThVHWrTG8PxpjmSj4gdYr3fQmz8j2yoPCkiaqFz0VZpxB yjQWcCdiFmlqRfjhpG0BkCWbyL7uDmjkev/ygNanL/vTK6P7qAJtdcIPDDI8ApoVMGY0a0qH gyt4eTy87h+1pZLHVZEYuiEF6sIES9tCrCKKTS9xFG7igHPJy2G7DeHeVpvJ6XD/gDbdjPKn 9liaKTl1xa2pcmmerPIIL7HZ/nwRWKrLllVPHt1yM0dUQ5TAUb0iD4SyIiV+C3cNTulDhSux tBLTgZyO+iJSFVm7UBO4CzY5aJpkhgUcAuSpjTkj+yFe7A/PFEvNeegXsabogR9dobvNDdH1 YLqMANRKS6JHf4ziMLAU3AnrNQVwm4cSKArwVIlWqInNgeuLRQKMI01R0DZug+heANfHBRpw slqsxaaLFsvhI+MUa/A+LCA72srhmgsiTOPZ7L4e7id/96Mq5YNeyFjsQeiT7EhX3EfQNdFt iipWT1PaMGMa9hrDR0YaFxRblC7NHvSwLkShuCvYGzfqiDvEy9B6I1eBTYxv3XcGBb8Z4DjL o+qutMMtD/ghguI43xLE3kcJ0z/f9nUEThRGBVEDhNbxaJQOTTAG4VNbNJx0EbRNsaivjFgu EtZZ66DFMAHc0BW3osKkoHoVIwzdpxOM0tjFiSEscyRBugkozGJqaaPcMshTt576cpyKrde/ TaPcwjBTf9270v3DNzNo6aKm5egeMMfd++MrrOynnbOCxzg54xGHoLUnJQ0hUTjQlTwERPU7 euUlhh03oWD7p3ElNHFiLarciMBjso4mK52f3G6SiG3QNLoXdrsUTRrqFSgQtVE7o4XM2CeM KE+Dy+YyWQZ5k0RWKfnHWX6wpuUTEnSlERnP8HPRAK9Y++h6Kv2lD370b/l//rI/vt7czD/+ dvmLjsYHZhr9Kz3Tt4G59mOu5x7MzfzCi5l6Mf7ajNQdJs6TYN4i4rOxW0Tco69FMvM1UQ/f bmG83frw4Uy3uBwwBsnHmb/4x/m/GJWPrG2ZSXL10d/Ea+5NGElAbsGl1t14y15O/00DgYrT TiFNUEdJYo5r/9VLHjy1G9MjOGssHX/lK8iHp9QpuPu1jneWdY/wTf7Qx5mn797GXnIpgZBg XSQ3XWUXIyhvw45ofH+Hexjr29PjI5E2ZmjFEQOyeltxj8sDSVUETWJGfRlwd1WSpgl34ehJ loFI9RvbAK+EHl6nBycR+inF3MeSvE34k9YYh8TzQNcTNW21TjxmqUjTNgteqxOnruPMend4 2T1Nvt0/fJfB9vsjDcPSd3DjX6TBsrbVkW+H/cvp++T+5XHy+Lw7fnVNGWT8OrJ1M86suiDp cCmD3/cnyvV4FpItgUtxNXaDjA5U/ZRmnbsHqFgChkd99Pr8BsLHb6f9824CUsvD9yN14UHC D24vpEdNki80vdEIQ3msjYQx1xq2LlPPdGtEMdwBFnxWvmUcoklBUrKZAURO2eKhONoXYNhG EB/0+5bEZ23dyBQGmihcBZks+ef04upGvw/D14Afoh6KFQlARompWqAxb5ktuXfeZXD352UO 4sLFJmcvr73nkiYqwZdEVQ9Nt8auBikYg76DuJNhfnL2JdckkUOFTsWavNegduo2SJPYSemu 2lRUsA82IljjjcFjK0lxklB4rD7pqv8BOFhBykn58+KfS45K+o3aKw1l1DFhgbS0N9Jj6AMs tg3GstJVZrIWxJJZhxfRr5h+x/0wKi6LBB/w9TA+Jhyu1ZhryTAStSgwHIw7wkRUCd4kQ5JU BUxP4HNH9GXy0MF8Ng6DYgH8/Ge1S9vd2l8JitU/raSKWlrfvrbCQoswPw4GpdIvtSaVNV2X zhZJAzbyFL4AqpUFN48UVrbbnR7j7YrcOK1pE6aCkWYuBKOM0qWQQVUhAyyXdO4w1yFFMsSg tlquEN6GS7U+8N6EWQpqh2M+NDZm0Th01H+8Hy/gAs6wJx3tq4m6tA5qUzIhAKeA6AcArsSa s2oUERDKAFid2qW2yU1q/AV9Bz7fZiA4oaEX0/gVKvptQYE4ziR9ffj+/iaPzdX9y1fj4o9R 3lDx02L4iQYWKWudhhp2RSVT6+CeggHLDLMMjYqrS2syIuFmDfylCeo1S7T5BMwfjoC44IzK yLACDoauMLJWGGA8I1oxxuWQSGx50WqmlBQHx4nTS0AlRIyDhVDK8MTrZKmQ3GYij+VQeVc1 NmQtRGnwZ7Wmga1l5SC54QSOp8fk1+Pb/gVfu4//M3l+P+3+2cE/dqeH33//Xbe4L3qnMbTL c83TywrWuqYV1IthF+02VQ3IJY3YCodd90/yNtxDvtlIDDC7YlMGemRW9aVNLTKnGDXMOg0R ZsSsHkkZcG+8nwq+CA5TUCbDsVNbowLLmXJpmebCY3ecHHamPG5JMITUFxeJOtBB9NYTIhax yoJz5oxdy3Pl5xQdWrgFtf+shP/GgNTmyCTcAVwmnSdcl1oTS7dMn9eSNYknigiEc2BxIFAN Ecvg3GUFJ1q9VaQ9OPDTg+c2HBELJ/QDIvQinOQMJHi0wHzBtPSMY3ppVYITyU4BYsUnxpzf 3A+flMBa0UGmtxE/viqaMpXHUyP6h1f+HqnGVyZ7A+b1l5SmOXU9SbYDha5xT1IUQgztOMCk xOfYGJs0C9wHHrTxPTbqwUCcQkfz6I63/cInA20DuXwNA0QQSlfr4tG9aHP58fPYZRWUK56m v6Au+r3rR3abpFnh015tf0eiMxIUgSAqqtgiQRU5Lbgxy5xdCWyS6s4CRqo2WbXFhSh9c2e1 WzYlMnl3hWxQRpHQLqZoCEr0xmGBqxFuL8qH3hk0h75/g/cQMom1rBZ759A3fdrLBB2pwIxl Z/ilB2gQiBaqPH8nlhWdI5FywBmC1QbWOENg9LpfB7UzlXUOsi7wBb1/FmoQi+sNa3AgvxBi BJ2VciOxHgcNHD3A8kyuJ8Cwk8iiYlVSsLYzPXGaDmTMR70jI2Ure/JbqDYUal5HMCZBtmEW 5XhCGbuXm5N+gakuGIurn7AmgPOkdI6T8aEnSwrfB/o9YDyrrzDcpeacqs8ecYYuBFa5yowk Q9oONtDjuaQR/LTNsmsCZGlsGj0/nWm9HFnHWRuP6yQWFIrxcvbxipys8D7Hiy7ooYbphT3n ZgX8DQ5jajMNmciNY5NiOVGk0Lpgg24QQW0lFgrHMwUkOa9MEDbAACwhg8Im4gjpuNHchOTO D1dsEli9RSuxjdtMm37Zzobmy8mZR8g1YBszjRrBSdXKq2cIHyZNxjMGxLatHlCXQNy9mRAV 5rcl3xZvt2TU8XG3JJjNItHWrq9kb2/hfFS+InubTxpmTasnMnO+SCUDUggqqODIrNrSViTW AWas8ioUpBpgGRtyEv4+pwRoQ7jxS31b8lmoe3zPwkJLpeASs5MpyYI0WeaZz1dD0uRtyg2Y pqNBG6wuqUnK25gaclyDUaNoOMV2UKV3vX6/1WPoovdXnx8HHwF0w3a9FA/t4nBpqBjsD3Xb OOQegsjprMHdZHmZjAjnXqpnRC1aWNC9TtW6x6CBQNp6HnOkLbePc9HiGU4BV95JCvk6QmGS uovtzcWop7BxMEOXPE6t/ymPxZP8z5neYoXFz3n6NFAIPkbPQNH6HncGCvq8NvTqaqA3UW+d up7S81FQBR7jiKgM3DEfbWJge2e4i5IcpByfiZP8EknWZ/B5lpxP5o0LTF1v2HcH6YWDZ4IT 7zXfSGPKojKeTQe4fAOic9+UjqQd/e7h/bA//XBfxMzMK/hLOa0aR7SM9I1yPlDgkcMPdaiq 8AgLbY0ioE3Q715pQqYIDN4p7rp4hUlLZRIRrnQtorZKGiDMRE32xsSVNL2KInAhhr1QX42y qDEGAW+5dJjhw3ka2NfnkSFalXRbPqnLQGcquogPkNlyLmK602JaX3m/NoNZOkRnULp1pJeG XJ1L87BZABNCM7u6aCtWOEXlA0WfFBXGnpayiKHQctGyy7/8cfyyf/nj/bg7YHjc377tnt52 h1+YkYRdleQed7yRKAsiXl88kMDOKu7Y5Ho9RVACK8n0UXZQxHGI4dhaZJfUlm94ip7V/ZuG uTEoPSRdUMOYs2/NvhLqtb5ma78LMs6QEhnOUu2skef3wK4G6SPwBE4dqTAVm8FxEvZbQn+L gh8dWuh1i9qUSQkRx9J+z3rbkyeK039WAWfRGiFbbKweLAHZWNHrKKPDj7fT6+QBo5O/HiZy iWu+Z0QMm3sZ6FE3DPDUhRuPjRrQJQ3TdURRo/0Yt9DKyAWkAV3SytD5DDCW0H2K7pvubUng a/26LF3qdVm6NeBxxjSnDhxY7HZaRAwwC3LYJW6bFNz9mGnLbFJjwnE6VKxnBUW1XFxOb2Tm TBOBMjsLdD9f0l8HjGfTp1boSbIVhv64KyzzwIO2WQk9pomC10nmEi+BY6oLK8pD7oj3AWuk u8n76dvu5bR/uD/tHifi5QG3E0gwk//uT98mwfH4+rAnVHx/une2VaSnMe2/HxmWLj3lKoD/ TS/KIr27nF1wBnHDNlsmtZWv20JxdymdZDp3u92XhX/UOYiRteC2var/p0TwhXM0wPHa+oPl YWuiqKC/H0QGTbng60YMzfQZtGoZ2wAiCG7ZGNn94hKf9CDPw35dBSDGDw5fIXn+onRxdFdH 6C7ZaBG6sMbdvBGzVUXklk2rDdPHMmIvpgq7NdWPPW8Td5vKVMtIj6j74zdfB7PA7eGKA265 sbiVlNJaYP91dzy5X6ii2TTi9hMhpOMVfyvT6H5KAAOWAg/0DxlQNZcXcbJgWJnCqDpcfsAe dj0f8CLoLvfhilvAMWf7PCDdKrMEFi3GIkm4kayyGHaDv0bEf+B2MiCADZwtOJu6+7deBZdM bQiGLVsLziR6pEHGQ1RcvfPL6YBk6884HZlZeebuMVUzj+F4rSzAN+Jc9zKu4c2yuvx4hk9t yvmly4Fp1XW0Ijvg0rRPBpGRIrK72zkQLs8BWNcwgiOAhwXqorQvWsi8DRPmK1XErfQwLTYL y3KZp3CCydp4T2Mx2mOaJq6o1iN+VlCdgnCU/HvKqZ8UbW/7njicCrC82b9OoDXlDDsDSnfZ EvRcV2LBHRwAnXUiFj/96qIXE52jZxV8DjjfyX5jBGkdMKykF6q8CF9H0MaFAValERfUhJM8 4a9Q0pwZPI1k6mfudcbbdvfoUnhUED23EHwW7B69Kc5vKEXg20892tNHE93NNvpLiEVjDNVg bn/YHY8gfhtBY/pltkDjjHO9Sz/zcRYU+ubqrCSQfj6zdgG5ciWYz3UzxGis7l8eX58n+fvz l91Bxl+5P8mu2DywTrqo5C62cRUOL4oMhhWtJMZSA+k4EC/9/UIKp8q/EkxfjtpoQ+enXTa7 wIzAZ6GoPf6PDmS17/Y9UHCjNCBZNQUdfKYHRo/hRGWMC1AGsR3WxyWKIvfur+Bd7DaDMs2V Z0vJn76SZc2X/BS4LErBu3h183H+T8SJeT1JNNt6QnXbhB+m/4qu/+Ytl6yW+/jt4lzz4Ks/ q2kI8KNQQX2XZQL18aTKp1ccDlm2Yapo6jY0ybbzi49dJFAVnaBjDD74GEqVch3V14O70YCV jGp3OGHAoPvT7kghy4/7ry/3p/eD8hoyrAel/6z+WlEZdkouvkbl36gvlXixbTAuxNhin2K6 yOOgurO/x1PLqsdkpwyxIqVHhLWuLlWG9MlnxzHmFnOqdRiWplZZaVUwaqbeMMmxtdKEoB/f dP/lcH/4MTm8vp/2L/pFNEyaSmAwWG0q5SOO7hfTm37VTZVH+FRRFZmlM9NJUpF7sLlourZJ dLOoHkWGBYukkvYNLr6MEnyf1Q1sepQFpldxDAoQZeU2WkkD4EosLAp8N1+gwEg50Ms0Mdlo BCwG2LgBuvxgUrhXWmhM03ZmqdnU+sn6xigMbDAR3vHuhAaJT8whkqDaWCvawBsDHMm7w/hL 8xhPk5DTIETcdXe7tQ9RaQKt9Zcp9Rk+gadNavjigyBCsVcyynGnw0GK6Fg4S4/yBUNOYI5+ +xnB9m+lBh1fiSWUQgJ54j8qksSKvW3jA0/cxhHdrNqMD3KlaGpgpawRhUSH0V9Od6yQ2cM4 dMvPScki0s9G1O0Rsf3soS888Ct3+zIPp2iYWgvcphysW5t2VgM8zFjwotbghrmXzvTiZCtN wIgfFFWs84OgrosoAcZI9kNVYLzk1siBRGaD0DrEsghEUx19JHOBPifSaA645lJ/ZiYcxWEP SmlAbjEwsrSL46pr4A5gbGnEqMAlhoeNCietAZap7ZYhbWDsR2LpODS8FWqIsu0qM5rQJ/3k SAvDzAp/n2MHeWrG9IjSz/ikrwFgYkw1HIyAzxwYlYGcUjIrEyMXAMbCwkhOtWGYPZwSMqBi kjOoEs2ujJfB0WJMxb0hcyPLF88hyiJM8qRNDNrKxqIsDKcftJvMgR9YHpHKyJAb1v8P9LJu vZqVAQA= --xHFwDpU9dbj6ez1V--