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=-7.3 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,SPF_HELO_NONE,SPF_PASS, 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 1EB8EC32771 for ; Mon, 27 Jan 2020 03:53:07 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id BEBD62067C for ; Mon, 27 Jan 2020 03:53:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727166AbgA0DxA (ORCPT ); Sun, 26 Jan 2020 22:53:00 -0500 Received: from mga11.intel.com ([192.55.52.93]:2381 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726545AbgA0Dw7 (ORCPT ); Sun, 26 Jan 2020 22:52:59 -0500 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga102.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 26 Jan 2020 19:52:56 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,368,1574150400"; d="gz'50?scan'50,208,50";a="427167481" Received: from lkp-server01.sh.intel.com (HELO lkp-server01) ([10.239.97.150]) by fmsmga005.fm.intel.com with ESMTP; 26 Jan 2020 19:52:54 -0800 Received: from kbuild by lkp-server01 with local (Exim 4.89) (envelope-from ) id 1ivvSI-0003iF-Dj; Mon, 27 Jan 2020 11:52:54 +0800 Date: Mon, 27 Jan 2020 11:52:02 +0800 From: kbuild test robot To: Christoph Hellwig Cc: kbuild-all@lists.01.org, linux-kernel@vger.kernel.org, Paul Walmsley , Anup Patel Subject: mm/hugetlb.c:4904:36: error: 'PTRS_PER_PTE' undeclared; did you mean 'PTRS_PER_P4D'? Message-ID: <202001271155.deicELaC%lkp@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="zr5pbx2z7ygcviri" Content-Disposition: inline User-Agent: NeoMutt/20170113 (1.7.2) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --zr5pbx2z7ygcviri Content-Type: text/plain; charset=us-ascii Content-Disposition: inline tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master head: d5226fa6dbae0569ee43ecfc08bdcd6770fc4755 commit: 6bd33e1ece528f67646db33bf97406b747dafda0 riscv: add nommu support date: 2 months ago config: riscv-randconfig-a001-20200127 (attached as .config) compiler: riscv64-linux-gcc (GCC) 7.5.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross git checkout 6bd33e1ece528f67646db33bf97406b747dafda0 # save the attached .config to linux build tree GCC_VERSION=7.5.0 make.cross ARCH=riscv If you fix the issue, kindly add following tag Reported-by: kbuild test robot All error/warnings (new ones prefixed by >>): from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/seqlock.h:36, from include/linux/time.h:6, from include/linux/stat.h:19, from include/linux/module.h:10, from init/main.c:17: include/linux/highmem.h: In function 'kmap_to_page': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/highmem.h:75:9: note: in expansion of macro 'virt_to_page' return virt_to_page(addr); ^~~~~~~~~~~~ include/linux/scatterlist.h: In function 'sg_set_buf': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/scatterlist.h:145:18: note: in expansion of macro 'virt_to_page' sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf)); ^~~~~~~~~~~~ In file included from arch/riscv/include/asm/page.h:12:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/seqlock.h:36, from include/linux/time.h:6, from include/linux/stat.h:19, from include/linux/module.h:10, from init/main.c:17: include/linux/scatterlist.h: In function 'sg_phys': include/asm-generic/memory_model.h:55:54: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __page_to_pfn(page) (unsigned long)((page) - vmemmap) ^ include/linux/pfn.h:21:36: note: in definition of macro 'PFN_PHYS' #define PFN_PHYS(x) ((phys_addr_t)(x) << PAGE_SHIFT) ^ arch/riscv/include/asm/page.h:115:29: note: in expansion of macro 'pfn_to_phys' #define page_to_phys(page) (pfn_to_phys(page_to_pfn(page))) ^~~~~~~~~~~ include/asm-generic/memory_model.h:81:21: note: in expansion of macro '__page_to_pfn' #define page_to_pfn __page_to_pfn ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:115:41: note: in expansion of macro 'page_to_pfn' #define page_to_phys(page) (pfn_to_phys(page_to_pfn(page))) ^~~~~~~~~~~ include/linux/scatterlist.h:224:9: note: in expansion of macro 'page_to_phys' return page_to_phys(sg_page(sg)) + sg->offset; ^~~~~~~~~~~~ In file included from arch/riscv/include/asm/page.h:131:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/seqlock.h:36, from include/linux/time.h:6, from include/linux/stat.h:19, from include/linux/module.h:10, from init/main.c:17: include/linux/scatterlist.h: In function 'sg_page_iter_page': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ include/linux/mm.h:213:26: note: in expansion of macro 'pfn_to_page' #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n)) ^~~~~~~~~~~ include/linux/scatterlist.h:384:9: note: in expansion of macro 'nth_page' return nth_page(sg_page(piter->sg), piter->sg_pgoffset); ^~~~~~~~ In file included from include/linux/kernel.h:11:0, from include/linux/list.h:9, from include/linux/module.h:9, from init/main.c:17: init/main.c: In function 'start_kernel': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if_var' #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) ^~~~ >> init/main.c:735:2: note: in expansion of macro 'if' if (initrd_start && !initrd_below_start_ok && ^~ include/asm-generic/memory_model.h:81:21: note: in expansion of macro '__page_to_pfn' #define page_to_pfn __page_to_pfn ^~~~~~~~~~~~~ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ >> init/main.c:736:18: note: in expansion of macro 'virt_to_page' page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) { ^~~~~~~~~~~~ -- return pte_wrprotect(pte); ^~~~~~~~~~~~~~~~~~ include/asm-generic/hugetlb.h: In function 'huge_ptep_set_wrprotect': include/asm-generic/hugetlb.h:109:2: error: implicit declaration of function 'ptep_set_wrprotect'; did you mean 'huge_ptep_set_wrprotect'? [-Werror=implicit-function-declaration] ptep_set_wrprotect(mm, addr, ptep); ^~~~~~~~~~~~~~~~~~ huge_ptep_set_wrprotect include/asm-generic/hugetlb.h: In function 'huge_ptep_set_access_flags': include/asm-generic/hugetlb.h:118:9: error: implicit declaration of function 'ptep_set_access_flags'; did you mean 'huge_ptep_set_access_flags'? [-Werror=implicit-function-declaration] return ptep_set_access_flags(vma, addr, ptep, pte, dirty); ^~~~~~~~~~~~~~~~~~~~~ huge_ptep_set_access_flags In file included from arch/riscv/include/asm/page.h:131:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/mmzone.h:8, from include/linux/gfp.h:6, from include/linux/slab.h:15, from kernel/fork.c:16: include/linux/scatterlist.h: In function 'sg_set_buf': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/scatterlist.h:145:18: note: in expansion of macro 'virt_to_page' sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf)); ^~~~~~~~~~~~ In file included from arch/riscv/include/asm/page.h:12:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/mmzone.h:8, from include/linux/gfp.h:6, from include/linux/slab.h:15, from kernel/fork.c:16: include/linux/scatterlist.h: In function 'sg_phys': include/asm-generic/memory_model.h:55:54: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __page_to_pfn(page) (unsigned long)((page) - vmemmap) ^ include/linux/pfn.h:21:36: note: in definition of macro 'PFN_PHYS' #define PFN_PHYS(x) ((phys_addr_t)(x) << PAGE_SHIFT) ^ arch/riscv/include/asm/page.h:115:29: note: in expansion of macro 'pfn_to_phys' #define page_to_phys(page) (pfn_to_phys(page_to_pfn(page))) ^~~~~~~~~~~ include/asm-generic/memory_model.h:81:21: note: in expansion of macro '__page_to_pfn' #define page_to_pfn __page_to_pfn ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:115:41: note: in expansion of macro 'page_to_pfn' #define page_to_phys(page) (pfn_to_phys(page_to_pfn(page))) ^~~~~~~~~~~ include/linux/scatterlist.h:224:9: note: in expansion of macro 'page_to_phys' return page_to_phys(sg_page(sg)) + sg->offset; ^~~~~~~~~~~~ In file included from arch/riscv/include/asm/page.h:131:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/spinlock.h:51, from include/linux/mmzone.h:8, from include/linux/gfp.h:6, from include/linux/slab.h:15, from kernel/fork.c:16: include/linux/scatterlist.h: In function 'sg_page_iter_page': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ include/linux/mm.h:213:26: note: in expansion of macro 'pfn_to_page' #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n)) ^~~~~~~~~~~ include/linux/scatterlist.h:384:9: note: in expansion of macro 'nth_page' return nth_page(sg_page(piter->sg), piter->sg_pgoffset); ^~~~~~~~ kernel/fork.c: In function 'free_thread_stack': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ >> kernel/fork.c:297:15: note: in expansion of macro 'virt_to_page' __free_pages(virt_to_page(tsk->stack), THREAD_SIZE_ORDER); ^~~~~~~~~~~~ kernel/fork.c: In function 'account_kernel_stack': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ kernel/fork.c:392:29: note: in expansion of macro 'virt_to_page' struct page *first_page = virt_to_page(stack); ^~~~~~~~~~~~ include/linux/dma-mapping.h: In function 'dma_map_single_attrs': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/dma-mapping.h:587:33: note: in expansion of macro 'virt_to_page' return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr), ^~~~~~~~~~~~ In file included from include/linux/dax.h:6:0, from include/linux/mempolicy.h:11, from kernel/fork.c:34: include/linux/mm.h: In function 'lowmem_page_address': include/linux/mm.h:1322:1: warning: control reaches end of non-void function [-Wreturn-type] } ^ cc1: some warnings being treated as errors -- In file included from arch/riscv/include/asm/page.h:131:0, from arch/riscv/include/asm/thread_info.h:11, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/radix-tree.h:14, from include/linux/idr.h:15, from include/linux/kernfs.h:13, from include/linux/sysfs.h:16, from include/linux/kobject.h:20, from include/linux/device.h:16, from kernel/iomem.c:2: include/linux/mm.h: In function 'virt_to_head_page': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'mem_map'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/mm.h:751:22: note: in expansion of macro 'virt_to_page' struct page *page = virt_to_page(x); ^~~~~~~~~~~~ include/asm-generic/memory_model.h:54:29: note: each undeclared identifier is reported only once for each function it appears in #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:112:30: note: in expansion of macro 'pfn_to_page' #define virt_to_page(vaddr) (pfn_to_page(virt_to_pfn(vaddr))) ^~~~~~~~~~~ include/linux/mm.h:751:22: note: in expansion of macro 'virt_to_page' struct page *page = virt_to_page(x); ^~~~~~~~~~~~ In file included from arch/riscv/include/asm/thread_info.h:11:0, from include/linux/thread_info.h:38, from include/asm-generic/preempt.h:5, from ./arch/riscv/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/radix-tree.h:14, from include/linux/idr.h:15, from include/linux/kernfs.h:13, from include/linux/sysfs.h:16, from include/linux/kobject.h:20, from include/linux/device.h:16, from kernel/iomem.c:2: include/linux/mm.h: In function 'lowmem_page_address': include/asm-generic/memory_model.h:55:54: error: 'vmemmap' undeclared (first use in this function); did you mean 'mem_map'? #define __page_to_pfn(page) (unsigned long)((page) - vmemmap) ^ arch/riscv/include/asm/page.h:104:45: note: in definition of macro '__va' #define __va(x) ((void *)((unsigned long) (x) + va_pa_offset)) ^ arch/riscv/include/asm/page.h:107:27: note: in expansion of macro 'PFN_PHYS' #define pfn_to_phys(pfn) (PFN_PHYS(pfn)) ^~~~~~~~ arch/riscv/include/asm/page.h:110:32: note: in expansion of macro 'pfn_to_phys' #define pfn_to_virt(pfn) (__va(pfn_to_phys(pfn))) ^~~~~~~~~~~ arch/riscv/include/asm/page.h:113:29: note: in expansion of macro 'pfn_to_virt' #define page_to_virt(page) (pfn_to_virt(page_to_pfn(page))) ^~~~~~~~~~~ include/asm-generic/memory_model.h:81:21: note: in expansion of macro '__page_to_pfn' #define page_to_pfn __page_to_pfn ^~~~~~~~~~~~~ arch/riscv/include/asm/page.h:113:41: note: in expansion of macro 'page_to_pfn' #define page_to_virt(page) (pfn_to_virt(page_to_pfn(page))) ^~~~~~~~~~~ include/linux/mm.h:1321:9: note: in expansion of macro 'page_to_virt' return page_to_virt(page); ^~~~~~~~~~~~ In file included from include/linux/ioport.h:13:0, from include/linux/device.h:15, from kernel/iomem.c:2: kernel/iomem.c: In function 'try_ram_remap': include/asm-generic/memory_model.h:54:29: error: 'vmemmap' undeclared (first use in this function); did you mean 'vm_mmap'? #define __pfn_to_page(pfn) (vmemmap + (pfn)) ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if_var' #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) ^~~~ >> kernel/iomem.c:36:2: note: in expansion of macro 'if' if (pfn_valid(pfn) && !PageHighMem(pfn_to_page(pfn)) && ^~ include/asm-generic/memory_model.h:82:21: note: in expansion of macro '__pfn_to_page' #define pfn_to_page __pfn_to_page ^~~~~~~~~~~~~ >> kernel/iomem.c:36:37: note: in expansion of macro 'pfn_to_page' if (pfn_valid(pfn) && !PageHighMem(pfn_to_page(pfn)) && ^~~~~~~~~~~ .. vim +4904 mm/hugetlb.c 3212b535f200c8 Steve Capper 2013-04-23 4878 3212b535f200c8 Steve Capper 2013-04-23 4879 /* 3212b535f200c8 Steve Capper 2013-04-23 4880 * unmap huge page backed by shared pte. 3212b535f200c8 Steve Capper 2013-04-23 4881 * 3212b535f200c8 Steve Capper 2013-04-23 4882 * Hugetlb pte page is ref counted at the time of mapping. If pte is shared 3212b535f200c8 Steve Capper 2013-04-23 4883 * indicated by page_count > 1, unmap is achieved by clearing pud and 3212b535f200c8 Steve Capper 2013-04-23 4884 * decrementing the ref count. If count == 1, the pte page is not shared. 3212b535f200c8 Steve Capper 2013-04-23 4885 * ddeaab32a89f04 Mike Kravetz 2019-01-08 4886 * called with page table lock held. 3212b535f200c8 Steve Capper 2013-04-23 4887 * 3212b535f200c8 Steve Capper 2013-04-23 4888 * returns: 1 successfully unmapped a shared pte page 3212b535f200c8 Steve Capper 2013-04-23 4889 * 0 the underlying pte page is not shared, or it is the last user 3212b535f200c8 Steve Capper 2013-04-23 4890 */ 3212b535f200c8 Steve Capper 2013-04-23 4891 int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep) 3212b535f200c8 Steve Capper 2013-04-23 4892 { 3212b535f200c8 Steve Capper 2013-04-23 4893 pgd_t *pgd = pgd_offset(mm, *addr); c2febafc67734a Kirill A. Shutemov 2017-03-09 4894 p4d_t *p4d = p4d_offset(pgd, *addr); c2febafc67734a Kirill A. Shutemov 2017-03-09 4895 pud_t *pud = pud_offset(p4d, *addr); 3212b535f200c8 Steve Capper 2013-04-23 4896 3212b535f200c8 Steve Capper 2013-04-23 @4897 BUG_ON(page_count(virt_to_page(ptep)) == 0); 3212b535f200c8 Steve Capper 2013-04-23 4898 if (page_count(virt_to_page(ptep)) == 1) 3212b535f200c8 Steve Capper 2013-04-23 4899 return 0; 3212b535f200c8 Steve Capper 2013-04-23 4900 3212b535f200c8 Steve Capper 2013-04-23 4901 pud_clear(pud); 3212b535f200c8 Steve Capper 2013-04-23 4902 put_page(virt_to_page(ptep)); dc6c9a35b66b52 Kirill A. Shutemov 2015-02-11 4903 mm_dec_nr_pmds(mm); 3212b535f200c8 Steve Capper 2013-04-23 @4904 *addr = ALIGN(*addr, HPAGE_SIZE * PTRS_PER_PTE) - HPAGE_SIZE; 3212b535f200c8 Steve Capper 2013-04-23 4905 return 1; 3212b535f200c8 Steve Capper 2013-04-23 4906 } 9e5fc74c302505 Steve Capper 2013-04-30 4907 #define want_pmd_share() (1) 9e5fc74c302505 Steve Capper 2013-04-30 4908 #else /* !CONFIG_ARCH_WANT_HUGE_PMD_SHARE */ 9e5fc74c302505 Steve Capper 2013-04-30 4909 pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud) 9e5fc74c302505 Steve Capper 2013-04-30 4910 { 9e5fc74c302505 Steve Capper 2013-04-30 4911 return NULL; 9e5fc74c302505 Steve Capper 2013-04-30 4912 } e81f2d22370f82 Zhang Zhen 2015-06-24 4913 :::::: The code at line 4904 was first introduced by commit :::::: 3212b535f200c85b5a67cbfaea18431da71b5c72 mm: hugetlb: Copy huge_pmd_share from x86 to mm. :::::: TO: Steve Capper :::::: CC: Steve Capper --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org Intel Corporation --zr5pbx2z7ygcviri Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICNJWLl4AAy5jb25maWcAnFzrb9u4sv++f4WRBS724KB7HOfR5l7kA0VRNteSqJKU7eQL kU3crrF5wXF2t//9maFepES5xS2KNpoZ8Tmc+c1wlJ9/+nlC3g8vT3eH3f3d4+O3ydft83Z/ d9g+TL7sHrf/N4nFJBd6wmKufwXhdPf8/s9/9ru3+78mF7+e/zr9sL+/nCy3++ft44S+PH/Z fX2H13cvzz/9/BP8/RmIT6/Q0v5/J/aty/MPj9jGh6/395Nf5pT+a/Lx14tfpyBLRZ7wuaHU cGWAc/2tIcGDWTGpuMivP04vptNWNiX5vGVNnSYWRBmiMjMXWnQNOQyepzxnA9aayNxk5CZi psx5zjUnKb9lsScYc0WilP2IsMiVliXVQqqOyuVnsxZy2VH0QjISw6ASAf8YTRQy7QLO7Y48 Tt62h/fXbpkiKZYsNyI3KiucpmEUhuUrQ+TcpDzj+vpshtvQjCcrOIxcM6Unu7fJ88sBG+4E FjAMJgf8mpsKStJmuU9OQmRDSnfFo5KnsVEk1Y58zBJSptoshNI5ydj1yS/PL8/bf51041A3 asULGhhDIRTfmOxzyUpn+1wqvkx1Csy2uVKxlEeB1kgJmt01syArBktHFxUDGyJp2vF7VLtB sJuTt/ff3769HbZP3QbNWc4kp3az1UKsHXV2OHTBC18xYpERnvs0xbOQkFlwJnG0N8PGM8VR cpQx6EcVRCpWv9MunDvWmEXlPFG+3myfHyYvX3qLEJppBjvOYYHzOGVyOCwKSrRkK5Zr1Sys 3j1t92+htV3cmgLeEjGn7mBzgRwOHQR127LDWs/nCyOZMppnoMbBGQ5G071eSMayQkMHebjn RmAl0jLXRN6E9LqScVS6fokKeGdAxhNYrxMtyv/ou7c/JwcY4uQOhvt2uDu8Te7u71/enw+7 56/dymlOlwZeMITadnk+dw6riqF5QZlSyNfu2vZ5ZnUWnCqaLqWJVqEpKu7MA/SwMQS1QY1t h/V6/8Cs7OwlLSdqqCLN6gG76xMeDNuA6jjrqTwJDa/1STijYTswyTRFg5qJ3OfkjIHJY3Ma pVxpn5eQXJT6+vJ8SDQpI8n16WW3lsiLhBgx1bYrQSPczqDG+ivTmo9l9YNjUJbtmgnqkitn oK6fOkOPFj0Be8YTfT2bdovNc70EM5+wnszpWf+gK7qA5bHHvVFgdf/H9uEdQMLky/bu8L7f vllyPY0AtzXHaKlVWRRCagW+T5/OPjnOdy5FWTh+tyBzVh0n1wJlLKPz3qNZwn/OwUiXdWv9 1s1acs0iQpcDjp1oR00Il8bndG45USYCy7jmsV4EDo7UJthm3VPBYzUgyjgjXh8VOQEFv2Uy 0EktsCjnTKdR4NWYrTgNG7haAjQRbcN441GRDAZq3YpzHgVdtiyiScdBqABeCkyQ59ph53MV HBUAiB6rgwMSOG4zsIZjzeRMh5uBzaDLQoDeofMAjOcAkkrNEQw1euNiG9jvmIGJokSzOLTh LCU3vv7B6lt0J539t88kg9aUKCVlDsaSsZnfutgCCBEQZh4lvc2IR9jc9vii93zuIWEBjigD yGsSIdElw38ZySnztKcnpuCHwJRb0OY9g7mmzHo7MM2EOgvsqVLfqFuwgbvsrTsodgbG3NQA LjwIXMwW4Ll7hqMZfzOpkE0fkVaAwvXeaCldfOyoPksTME+uFkUEIFlSuhA0KTXb9B5Be3sY tiLTrNjQhdtDIdy2FJ/nJE0cjbLjdQkWkrkEwh2V4MKU0sMQJF5xxZqFcmYOBjUiUnLX9C5R 5CZTQ4rxYHdLteuBh0Pzla8LZoDVkfgbREMkXZMbZVwvDUNhcexaUrtoqMCmxaCdaaCn03N3 y613qoPeYrv/8rJ/unu+307YX9tnQCgE/BZFjAJ4sQJodTtd80F//YMtNkNeZVVjjUdzVlGl ZdTa1U6HkVq5t0rPRR4yahAiEg3x5dJ/l4TCJ2zSFxNR0Ibi+9C3BAdcg75gayCEDgpxk5Fw oETWH0THXxAZA6YImU+1KJMEwlzr8EEpID4F6+w2lWWksJy1H7qHbYJmmfVFmGrgCYfWKvjt AHyR8BQOQuB9a7esl1AuvvXj+kb48jxy41HJFV05hwvxjh26zMGcQyhqMojhTj8dEyCb69m5 16DJTCZi5q9HGRj6LQQ0BnDEmeM1VsS2e3121cGqinJx6QEtkSSK6evpP5+m1R9vkAmcYdBF w3JE/r0pVrHoOJulDCIQ4At5Y6eS9iTWBM6FRZwkdRBNt6Mdaqy5iXt8NOA5u22NmBsgIBkC WpjAXA35Dcz1DLtDbK2XsSrhHds2FgZdjCRAAzgrHg5oBVSZDamLNYM41g0V59rmqVKwE2CK z2q0/UJhjx+393WarsNd4A+Syq524NsTtu8Xj3cHNFCTw7fXrWvf7MrL1dmMhxItFfPynHvY wG4e7GQMJzFkjFo+yZ11AGoJ81KgBXAQXSdDNsXiRqHmzOaeZXI4ECTMR6xUVoQOcAmnoF7k 3tE0ELgah5gUpbt6/lK5bsMJdBoPdGtOp1N3yECZXUzDCYtbczYdZUE708A8FrfXwBn4my6q wvFFL/DSyytutzM4msU2XXpy0r3uSVaa8fI3RGngue6+bp/AcQ3bKRy1LbI+9AcKwAfEj/HQ e8XAXRNNF7EIWVng0tRzWevPcMTWAPRZAiabo6cMuJ5ur8YG72Vh7/b3f+wOcBxgxT48bF/h 5eBEu0SiNRgLIZbDAwvqZrNVdfq3n4ZU1kzXeVXV41aTHaAXyeZ9SUu3EY+1ayYu3YRxnfe2 LPBimmGu2mayes2sOEShfuYIJxIyvGhSYUNi8MNE9tuBKTVGnlF0pv1jrXCwFgujqXRGmqI3 wlB7DZ7fmaX1mRa5utsvWWLHaeFz8KRgCsKFUGqA8eZUrD78fve2fZj8WR2W1/3Ll92jl1JD IbNkMne9kCXaaEibc/PRc/xHGm21OS3nmN8VSlN6ffL13/8+GSKH7+iikzzIMBpgzpJZHK0y xMvT3up7RrOyszAPiokdEoJHtUyZI39goqtXW6bbcqPYwb1pLLyk7b3CyC42knx+jI2oFmL0 o51VcDDjSqFut9kGwzOLFEJ5hBxUFdT8JouEF+vUimyziSmcfTdxFNWpr/ZxaeTnCqU2Suyw FFUcdPlzydxUYpMQiNQ8SAT8EMoeaDaXXAcSCwj0vP1pGGCZhNZ9ZOuJ1b7BWMwmR8XWUQjy d5k1iCUBGLGc9obXcqlQejhEhFRJaG/s4sHmiIK0VzXF3f6ww9Mx0eCQ/eCMSM1tnqFxQSFd V7FQnagTUCbcI3depdejO7oMHBTl/myBhobWjbGRbP1mddskuoSo42/gPS6qnFMMrqS+2+w0 vGMvb6Jg+q/hR4l3AQSPptkBKxC+/vFG1XoElZ9288A4yyqKKsC0oUlwj4F1CeiJsoyLddRM l/2zvX8/3P3+uLUX0hMbGR+ciUc8TzINx0Ry9/Kkba7mY7jhLKlH7ObakY1I47AqVzK3KHRM wLq+2PTFfCGwNbTLrmPqp3bO7cKOzd8uTrZ9etl/m2RHAFc4VGoH20RhGclLEkyItZFYJeIE SQ2n79+rrtDaMvfeyonpNmAXXTvXsVbwD0av/bBvIDHs1JpVAC4xPLl8VaSADgpt2YBf1PWV /ePkpXC8ERpg90hjtAC2IJZG96PyXEC4bOqsARh5ntk0pVLXp60I3gEB8rKIaemsEU0ZWBcC J6mj3RZCeNtyG5Uh83N7loBagsK4KSXsYOzCbY4pdzCpi4zI0FkrNKtgGEldpRvXq2567s4u I9xTljc41Spnvj38/bL/E1BNIAwAEOe2UD2bmJN5dxzAXmw867GBU571KPUr3fVjGlqHTSK9 RBI+W0gcPMGWa2PzhIzcd1gRVUYQYaSc3ozLZHyOgfyRRmDruNKcjt89LFnovngTF/auhGkH eDjE3mryasucu5EqSU5JsNID2G0oBtZf+5l04CY8Qs1no7rXdFBgfIOnWfVasM3WMsS/9hqK AQqMhArdG4BIkbs1FPbZxAta9DpEciSELsa6QgFJZJiPO8ELfow5l5ixycpNYJiVBOYScta7 WcjB8oslZ+MawIuVDiVVkFfGTqsOPRHlgNCNwN8MZJORHUAeAOFxJi8QXId2Brn9oVmiVU2f pGnRkP3mcX7IGB+AJOvvSCAXdkZpKcJnFXuHH+fHwF8rQ8vIjVqbIoaGf31y//777v7Ebz2L L3ohSqt3q0tfUVeX9ZFDJ5qMKCsIVbdqaDtMTMJoBWd/eWxrL4/u7WVgc/0xZLy4HNn6y4Cy 23fCumxZiuuBONDMpQztiGXnMYAo6/f1TcFcO7C6HGofEr2T0VDCokctGI6tjDDGG7t+xhbs Vo7Ol80vTboeWSjLBd8dKoPrBKqLUNdepCRi4WAZmFh4iJlThAQjJqXQBZZWQhyc3PSatm8D NLKRKpj+rBgLDUE44akeiwiLI0ywUjGlo2Za0RETLuPwRuhwJSFAX3d28AizHjHwyEzJSHkX MiM5u/x0HmSnMx0yj0oXnXuOJI/nrP9s+DyD+eZCFNUla7d+FX8FYzLVSoYvnyw6tiZQkd5W Iinwhm3y03R2+tnFVR3VzFcjHtKRyXoyramkCEOcditKbe9CFaepY2nhYebvGElDOryZXTgv kcK7CCgWAnoMTuAyFeuChC5FOWMMZ3Zx7g6+o5o8rX+wlQhwNnIdjKecVyqc1m05nPNhF7g4 gbC7WT0aupSNc4X1KAJLch2NAi0lNrvhpgEbWvPjCNPNwzr0uBc/d5w8dODcN6ta0pG3LTds Nzohe4f9PSHMvo9ZKFGwfKXWXNNQzdVqAK5XYWRd5WtC8j5jUCuIlprnywHsyYpgEFOVIS1c 7ViosAG1WmMnFrPVSFPpGWicQpQBMn3TkFPFgy3X2TjrJSQX35OpvEjId9tTvzFRqW6MX5QS fR4WcfgEwHGMZHXCsRdvTg7bt7rk1ZtRsdRzlo+uViwFYDQBIb3oLWkdEw+a7zHcONfZIJJJ Evvr1KwScVQBHhDGOrkgIETU809ImgcvSYHx2+nV2VWzFECYxNu/dvfbSbzf/dUrQ0HxFSXh tbDMzTGuSo9xe/rW42GytqoiDFfABAbunOqw0SYJ6JH0HbzLXNIs6Hx9FarJGNXK+hakJq25 ZCnmdrrNSuZoqJ3UZmX9T+1nE/3KikYaJ85SgTkh/G4EjFLYeLXylIH5aIpNjMjLYAliI41X BDBSW9KFMTubx9FwyPZqrbqrqkQwuRCYWhvUFGFmY7wHY5YxcWoihpNas00o3VD7vtOBNzy1 eSrpXhI2DEmx+AU3Mg1zmzn8kNT1ydPu+e2w3z6aPw4nA0EAuwvPRjeMlI2AzlYi8NlEoHWF JTO1twoMtDo7ACvK4ChyUeXWj4+kTqIcca/diNLsh+QgBPgRsYUeSvVlsJS9VxDQ8nik1LAk oGUX6ofmVKTfHwUWvy2OdJUt1lnxQ72BxmByh/5AnyhKFTnWLYqEptkX1HGqRpcRdwvO0wKr YWwdbnf7u+ZYKPbNe6y1zpYPXX9y4qxkyYNFsOhJrwoP4cBzd6PludyrY8tICQ9nPigrFib8 LVeeOJcp8ADAas4BhvvEnHIPYFckvJQKN2m5JZHab2Zhm3EIahHbWKUGI3f7SbLbPmLd5tPT +/Pu3n4VOfkFRP81ebA+zkmIYwNaJh+vPk5Jf3SKZ2HYArwkHslHAq/IL87PDZ+FPWMtcXbW l3D4GadS2MqUpyAZX+2x5CodUprl8zq3jPG+lZ6dwv+kt8g1ddiz0vXODmhjsrjlPdXYFEH1 qMjHBnuWrGV+0eulIoa6v7pYJLaXFkP+kLo4QawiYM1GPnPDnGwSSjk5iaYexa+mj2GBeldU AOnh6HkF3TbIwEu1THk2KyE8FatgNG+zEazD9PasDJCqK+xdkPcf6m8YVZDoVOx1y0Y5Q2gS BbEUvpypXhdjn0siDxHXslcqzo8YNeQqXYZrD5HJRRg9Iw/CrXEe6QVZXQAiNNYSoZTLr6oh gHb/8nzYvzzi11UP7QZU0cLdwxZL0EFq64jhF5Cvry/7g1c8AesKGhOznDJbtBRG999r0Z9U ouHf05EqRxTAjppdHhNiZoN12ZvB5OPt2+7r8/pub8cDxw5+UCMzi9emwJqA4cxcRWFK5MF5 H+2qLRQJb0a7Uez54fVl99wfnGF5bAuJgz17L7ZNvf29O9z/Ed56X1fXdRZBMzra/nhr3VGh RPrX1jSjPJR8REE4nG29Dv1wf7d/mPy+3z189et1bjDDFs4Ck4L3Qu6uhHN3XxuaiWgvpds3 y6oYcMHSImi+IILTWeFnrRqaybCEMBhpkjwmqfALcgpZ9ZVwmUE4yKoP5QdjTnb7p79RcR5f 4PDsO+OYrG09nhe7NiRbfh/jR5hOgdIGYou2N+c7se4tWyJazT3UqMMGE5+m9TePndlvJcO1 drXK9GfUJuNt8R2WnHllMO0q29SB5KuRK4M2tyBHLmMqAQzQ62Yg/s3ATYUu+lCIVNC9Ei2k iJzkfFuGX5RNOqNbMQirvfqT6tmigD5NuZ9t1bS1EwPXJKyIGrbnftsfZ6QpOIJdT/zLemQm 1jLbUuTgroycjaoi/P3NAaxdaCI2eiSPDogV78yKzPQcbVc77rTpYHsBWIT2MnDNmufKL03V oaxirJ1VFt69mEiwYkSP/GYL4GItFF7muQ0YRmR6E2YtRfSbR8BiIS9RBDRvm+DZK5wRWOIM x2oF+1YVUrmjRQyVkvB9dUEk4phQjr0q3PQS63UtZ16mKT6Ec+a1EDo8pWA8mhdns83mqHAJ oz4qkAoRDlAagVhGI3V2zaC/w1fL7/A3n47yJQnPgMZSZJg1pvEq3AN+D4Z7ZNhI8Uqd///e in9vBaTaDOFLvsqYg1caSA7U5gvS4UriK8GAAd8K1uG4AgmJwOa5+N9S/V/AgSRN5LxvGJo4 xx11VcK4e7sfhsOK5UpIBXG+OktX05kTgJL4YnaxMQB6vASjQx4NeV2ZcLgPbie76f8KlGJB ci3CWqJ5ktkFD131UXV1NlPnUydRDGY4FarEPC0ce+s43OscMOtp6K6AFLG6+jSdETf+4iqd XU2nZ33KbOqU5tULqYFzcTHtlrFhRIvTjx8DL9ger6ZORmiR0cuzC+dDwFidXn6aOb8cAmwk zMgwWpyZiubVOY2dNBfFjv9iogrGGxUnLPhbgVYFyd2qHDqzOeinuoyYgQvPnNCl2Q9Lh6M8 c75r74gXA2LK5oTedJOuyRnZXH76eDGgX53RjVfd09I3m/NQ4UzN57E2n64WBVObwRAYg6Do /NotEvZn5xix6OPpdKCf1S/X2f5z9zbhmPJ+f7IfGb/9AbDsYXLY3z2/YTuTx93zdvIAB3T3 ij+6zl9jIBs84v+PdkOn3k/OeBwvn0Kw9IEgyC7SZrP582H7OMkgKPyfyX77aH+bWbfzPRFE IhXqaXiK8iRAXoEn86idnRdFH+j0Olm8vB16zXVMihFOYAij8i+v+xcwl/+l7Mma3LaZfN9f MY9J1ZeNSOqgHvwAkZREiyA5BCVR86KaxLObqc+OXePJrvPvtxvgAYANMpsqx1Z34yCORjfQ x/evbw/iHb5ON9T9KSoE/1m7TOn7rvW7M9qfGKfh60DYvT5S/C2JjoXOvdCYHeYjwkgQEX1X IUmqWjROiiPbsZzdWUouLuO0aEdKpC1kvLul7wwvNK+kiqXxHWU5LagNUmkMEMvEelQMCWnf 6i0oBsy573t1VXam7YV0+Xz4CZb5v//18P787eVfD1H8C2zTnzXfhU5G0UO6HCsFI3xdAEoG bumKHIhqoqPV5/4I0udOYiIMVsdG0Ql0kqw4HFzmFJJA4EOv1J1G20GOTt1xge/WNMF+pyYG BIwWbH5FKv9PFRAY4I8ogfAs3cFfow9HlLxMov1/FU1V9tUO3tHWJ/2HOVZX9XKim/VJTO2y bZNYNFGeMG5RU9UcdoGinyZazhHt8safoNkl/gSyXZXB9d7Af3J3uVs6loK+sJFYqGPbONSN jgDmyY1neHc0gWbRdPdYGm0mO4AE2xmC7XKKgF8mv4BfznxipqRpMqyLCYoq4g6LILX1oXmf xnOQayRzzJOry06mp1FC0DTN9JeWdTBH4E8SCM6qunycGK7zXhyjyeUIyhm9D1UXbpUjSECL pXsHLGZPqx+q3yCkurExbwJv6030et9GfnSdn5LoEDs0UsU6y4lxlU5NtFlXh2euO3n1gXUy sQPEja+CKARe4buJHuGUSSMM0zDRzmPG7lMDjfgZ1peVUxXEUbBd/ZjYbPgl2w1t8isprvHG 21K+IKr+UXgeKVHwGTZV8nCx8Cb4+d4eFx07folXJ8UxyURaQMGCDM0l+2sLEvHxXsUsGkNB jRXXMTjh0ejkBTDLztaxoB+ulmhn3L4QPeWaJNWdTjqMq5BscYJxDgwwWs8wzVwWQDgRC4MI Id4YMiZartYGrL9dMRqQhkeaMrlTj67W7/FKaeGtHOc2Cukv2bh8Xqj198sBZ94VOyuTlez1 m+iOWHm0o4MoOySVDKtgGDFZdCoKxcjUCeuHJVhWqdCNZAFcYgQA4CsYwEMFBNT7e0bjrrQk XXYAHVW3sraKiJyV4ljQFw2Ar4/IYavikqJHI21Yj1W3s6UXVTMj+CNdREaLtJ7WAQwqrNVF GezC1T+eVhV5SQ44XH1G3U9JVQxLCkv3a/FvCgqc0/qmAUVencvpNcIUIeSshyuIuTxY7JmT T2B0jfuMnZKb0W+MvVXfrDoUUMXlut0rEJ2lfRPtajXQ75PI6J165rTqxkimcsIoY4GYa/EU zPGSwRSodyV5MaruZ3WX1QiqkluDKgPIfZolqTaHCCul1qoFZi3KndxWsg3DSUGpHMSlbEuw P+MqH99eJEny4AXb5cNP+9e3lyv8+Zl6+9+nVYI2snTdLfKeF+JGcvnJZvqr5qQevbPl3VDq jLHIY5d6Ku92SUzyeJbB39y29A45QfotJo5rTc4idIihFb3Sibo0Lgy+Ol7oYT6QDkbQA5GY 9/NJDf8SRUY+e55zY1me8/tFDnJVCFCd6ZYvM48fLlebPONk9EFs8FIZD3eg1Vi19CIAbx9o jZdBCXZONmJd+nfr5GVfPmnYJHfjQLKHo41eRIhP43qz8Ve04CsJaPUYUXtY6P5i4XY/O7pR MN3F+HJSGlgOd7KW8U/8+v397fW3v/BKUCgDD6ZFGzIMRjorl39YpL8+rI9oh16bOxpOhLio 7kFkRn68FJVLr6hv5bFwryVVH4tZWZt7oQWhOFLtU/IFR68AJBuD1SS1F3guR++uUMYieeAb J4vI0qgQLg+fvmidmCEmWZS4dMf2Erwm/eP1Sjl7MitNctZPxFxZIz4Q/Aw9z3O+fZa4ZwN/ pk5gvHmdMnIJMN3oX4djdwtrx2euXZXRqhIiXDsm81yjPDfdZ5DKDEFOQe75LgzJiHxa4V1V sNha9bslrV3uIo6HgSP+TN7QgxG5lk+dHoqcjuaPlTnUeRkV1TZC0AvOLCj4YLQYNL43p3Q6 rUxrYmhZyJO24HqhS3o2xrU+nnM0VIIBuZe0mblOcpkn2R0czEmjqRw0qn/odO24UHo82/Zs I6TVR2IQlIavj0Kn9Nf0FunR9Mro0fQSHdCzPQMBtTB5UkraWWtFYNWlubHTDgkHDYPkZYME OMvk4pG4BGKQ5RJOlGpfhoaGMp82+RCwGjC8xHR9CShcMsT3sDESf7bvyVObS2YYSAm556Vo dXP0Sr7bjGNc06EoDpmxyQ6knZxW5Gg0fCy9OXZ3PLNrkpIMPg39VdPQKNC4jPeUhG4IwQub ziE9pY5YsAB3bPy0cRUBhKMRxLiqW7p6BghXGUdcoj33FvTSSw808//IZ6aWs+qSmMHw+YW7 GJI4HeieidNtRhrg0ArLC2Ph86xZ3l3PEVmzGtk26FhxnUTvKV9avT9pVJmr7STCcEkfroha 0YxUoaBFOiTHSTxBraMXcbo/xWiP55EfflzTF+WAbPwlYGk0jPZmGcwINbJVAdyV3JD8Vhnx nPG3t3AsgX3CsnymuZzVbWMDF1YgWo0UYRD6M7wG/onJogzBV/iOBXxpDjMbAv5ZFXlhRpvN 9zOHRG5+U3qHdv5/bDkMtgvzdPJP86smv4B8YByVMiRrnNCWfkPB4mT0GOiLmWO5jeKW5Ic0 N2PlHEHzgJVLDvgtQcvvfTqjwZVJLjAhgPGaXsyKCuotSS/0mLHA9c77mDmFZKizSfK7C/1I 3vjpHTmjaQw35NDHiG3gXLKNETU8mntZ8X96bMVnl0wVG59erRfLmb1SJahMGtJM6AVbx4UJ ouqC3khV6K23c43l+CRNcpYKg2ZUJEowDoKU+XaG56utjBIlk+SRrrLIWLWHP8amFq73QfS8 xOmcWbMizZjJdaKtvwi8uVLG3oGfW9eDayq87cyECi6MNZCUaeR8wAXarec5FD5ELud4rSgi 2JVJQ1/riFoeJ8bn1RwW+D+YunNucpSyvPGE0WcqLg+HZXqEAUkct3h5SiXB0Dtxy4tS3EwH oGt0b7IDHaVLK1snx3NtsFQFmSlllkjvUQliDQbgEo4QX3VGRjDS6ryY5wH8vFdHV/AAxGLc iiitqSiUWrXX9Ck3Y0wqyP26ci24nsCVzGAfxw47wbR0ME0UTadSlcHYWe7jQ1Ep8aHAtt2u OH0bW5YOmxFLTZRXo2j3+cv3108vD2ex6y0Dkerl5RPm2P36JjFdcBn26fnb+8vb2JLxajGS LijJ/RpTF4lIPlx9couhAyT0PYoLGeVq49ayj4rguDU7rmi9Q2Kc5iqA3TrLrU/0Cr+m2dr3 6AUDxVwa0DXKg3VDyZ/mZ3NT6JeAmUL05Z3jSm0ZTNhP7dCEy3XiI3JPMxq9N92NCoEaKdBp efVduxNxvgt3zZbb9cqFC7ZLJ+6a7immZ3ezgtPT4PgFGnnTzCCpuMPtr1wt27hbNLpKBV8t Z7pDqMDAQpKqdliodUhpSIA+lzS3wYFwPGrwaxZSz8FGrxIQ7K2tzevN+ofjOkHifDduEbhx 3opSivTeVMy+BatqvyFvZ4xiY3mzqrPQC6mCgJEewoYFryTf+g5u32LFJDZ2Yzd+wCaxjgsf 9RFhMtnuBBYYtLPdaxjOjaowxAb4ed+Sj1V6IdPiPLp6/uzsmdLJNfN8xx0Iohw6F6BCJ8rh WqX34ekW6yqEjpLPS0lu3hQ/1jnyUOnoSK/3PmjR1RV6RebCsfmYPPGvr5w1D2jF8Pnl+/eH 3dvX50+/YfLiwcdNOST9KWP662LB+1eo5qWtARHEI+ts9drgzQSy7J/O6YCWe3ZKMsc150DF 6nBd7f3AcUgMhByolh+Xs3RR5K/8WSoW7ze+4yZOr4yFLjlB71pU+Qta2NOoJhYDb/Ct03Vr AKKoM4IPmpYQ0VKG9kVMyvIXQ9KAn/fS8jJtfYa+/fXu9I5J8/KsqWnypwxnZsP2e/RONmPg KQwGblTOxgZYZWs4KTf44WMkjrO6ShvEjbp7/v7y9hkX8ysmuvyvZ8MltC1dYMIdaPELDcfA OOfG7k+PFSDfJ/m9+eAthpSINM3tw2YdmiQfi5vlWa3gyYWOstlh0Xrziz4jrog3qsApue0K VhnP7R0MVj4tGmoE5cq1g0yikHaMtoioK5yBpD7t6H4+1t7CkbvOoNnM0vie43a7p4nbKKrV OqSFzp4yO50cztY9yaF0XAwbFHLlO4Ly9oR1xNZLbz1LFC69malQm2bm23gY+DQXMmiCGRo4 YDbBajtD5EhXMRCUlec73kM6mjy51g65vKfBGL0oBMw0114JzhDVxZVdHREVBqpzPrtICmBf 9Lv3MK/cv9fFOTpa2TvGlE09217ESs9zCEk90S6iT5lhTmpMJJXSDETjgk5WBgwQsw0Y0noH u7OcZWRmxoEi0Pz4B2icEtCo2FVGJLwec9j7lGY04Ku0JCpEMKxKCnNOYS/zQjsLe5xURFlE oUQaJ9cUrTuIOmseRwQ4lW8vVDsqT54f+OQ3XzFxth2Y2Cbi7CBfUKepZEq7wuHaZFLtXCn3 BjLMAkmGShpG4prG8IMYjKdjkh/PjBgNJlYLPbxuj8AT2IoM1OOakkxP2ONLgRStX/m4+IAG eWf6q8umcryldxR7kbI1ZZak9pFMJmFoWwpyB6kf7fwiRzYPnSotQW2eozqyHNQAmi1qZKdd zegFoRGVyYEJMm5eSySSCtNhXVlUcDNMvvpoZIZKuHIOjMyHZglvYVjycL1o7kVueARo2B5p FWXxxluOpEEFNQMyGRgjLFOLwUtAZMPyK8Yft+PMW1HacisDBs3ivjvXte7Z0n6y4KBOYrbn ohrXyyMv2ITBvbxWqrh76DjIEXqEDwU+lD4bS6xShNklSenSOwaqOImKmE4YOBDJDxg3E5Uw YnTfLUpWpzIeV504lLpOMgbGlLeUzi6dmvrjdtwbCW4FN5kJb6IlmTiYuxJ3KZpbIq+8Jigi 7i0o+Vlhq+RwznDa8TEL2IY9dXUp1ivfC4cBHH9Tfc3wTVdNgLOlM6nqldE+XG2InVqdwsUK W6UTj2nzXhU1q25oZ1LEVoYwSRSz7WIdqM3prInFTRZQ21SC231qr5cW6Xo578afBXQq7LZ7 1cVHzqLGX9gTINHr1TR6M0ZXPF12rik6yAhcIiHWYaRgnDo4JGqvB/vpIJLvGk+qCuPR0neL pLeZQjpuc1okLfcq5MrQv9QT2PPbJxnvL/21eLADP7Q913/i/9vIPX3lClFGaSkoGzKFztId oI2nZQmv2JXsscK2pvNWxXbLwudW2nCzkiq6k22zcjfVZaVJCi2m0tkakgPjSRtL34LccwHa uRaTsINnS8NyswMn/OwtTvSa6In2cJZaJO3FIzWNQxwZ4ppJOZn88fz2/Du+aI5CfNWmK9+F Gl3M8LgF/lebL+7q+UyCnZMGgkiuwpnErrAQefFUuMzK7gfhCPiFIRTd6YoUWhiRYmTYvVr3 881kyjJ0RDZzZsfJxQoDCJCTFWNPxVJ5eXt9/qzdEJufLqMWRrqw0SJCf7UggdBSWYHgWcuM yXWbyNMeUkm5R6WIUsF0oki5mTnaMsLraAgjwLOOSBpWufrDkxzkJIpp6lR5JaOQiw9LClth Qnue9CRkQzLHaey49dEJmSgx/esFa5sljt3sqe9d7YehwypHkRV7GaEYE86P1kr+9c9fsBqA yEUjHxsIR862Ks6agLaqNgia0UTh12ZprfmvW4hhDjyLwjwsNaC2jux+fhRkXheFFOk+vYyr VOCJSkUU5Y3DwKOj8Nap2LjCvCii9lT5WLODvQZIQjO9wBiHYy5z0I9Wr060Y+cYk81+8LyV v1iMepXum3WznpjZNsZeKVSH7NEz0c4trhy3RkMCZ2Tk9D3ViGCRqE/1RnVUpessBeReZPes JDs+oJydliRpvs+Sxl3FgHfWE6HxG8NIBekhjYC/V6N5RX715AUrPQGAxc/tElFdZVJaIAYW 3yxGYXaHQxZNHPKaYtfHSxffePiK1mu3+7pB4i15ircJcaZTS6iMjN7GZTDgGI/xLl38TYOT HodxG8jYCpJGmXANeZitzuje7woAm3vU0JVhDjTyWlJ1BPW8Yr836tpNtH28gkCZx6apTw+U WTFBgLOO7BFZG4ZFE3FZWaJbKFVMprdV86RlR2oUPLmID/5q3csfEfwpXZ0rqeplkVRYPLiF 6kEHFJm6HBlWWAsG3cZpKaXToD1MnuiSiY7Nz5eitpHKIsvoyAU+BQN0NDeig3UQPJX+kupl h3Ok8hiRGTdBMNZ2WivgiNnNFeN6LPxq6lI7I9VZ1DLgmwqdPn7BhX6OH26NmysYNnm9DyNb mGCMw24maJTQIxDT75WA5eeme6vkf31+f/32+eUHfAH2I/rj9RvZGWDbO6XLQN1ZluR6ItO2 UsW9CKhq0OghIrI6WgYLMrVwS1FGbLtaeuM6FeIHgUhzZKRjRJUc7D7INN5diYle8KyJyizW efnkuOnl22D6qAeYEye4yoGgD3F2KHZ6HsQOWMoUOf1i6fU0DFVqBT0toweoGeB/YDjS6fQP qvrUWwUOO74Ov6afE3t8M4Hn8WZFP4+2aHQxd+LTka6qI0XkSHoNyDJNG/oaQzIh+RbjuIdE vPSogaV7dpKIFJTzrXvkAL922cwo9HZNC5iIvjgCRbQ44Is0H/n7+/vLl4ffMPS+mvCHn77A Svj898PLl99ePqFB8q8t1S+gM/wO6/Znc6NHsC6JnRwnmHVQprFog9vQyE5FcRKIjF0Sm2Hp FZDeTkiU8OTim/WO+yl5lMoJmOYfZaYBc0MV8qnZLAQbzNHx6hQ0JkSkHKNMGDAlNX9oQ8Qm P+BA+BNEPUD9qnbjc2v0PVLmZesq0D/InoejtftrVgiQr3i3/Yv3PxTHaevVJtqI+uviEtYa tPIU6ShqliSwDVHtXJ0qDJjTKXMgQc42Q+I6dvUjUysXkDHx9PMdn/6sxHkIUklyLZi8pVE3 MWX6wJ+/4wRGA0cl0q7KALdSW6M7cmeNioKr/OfMBoH171hu9YyIhqC+odsvjoYwnxkqMmaI bUCMNAx8DAXFhw6Wj9gClmGa3+xCZcN80tIekejZZbuxIhw06xD44oLU8RDf6fRGKd6kjpm9 N7a/nQSO0kFpyKdb/sjL++FRDU0/weXb1/evv3/93M60fuFWyklTJmlGQ0NILjrjCNLUWbL2 m4U5rd32skFSuaDgKhQHKm11VWQ6helIexTUNJalmcFsMpdmXpdIMTpfEPb751cV790WEbHK KEvRy/UkFaRh1WkoeSlq96TF2UZZfZv/jXlrnt+/vo2FnbqEHn39/d9Ef+AjvFUYYpA9acyi W+S27kFohpgn9bWoTtLbCvstasZL1FhbS13gt8C8P71irhzg6LK17/+p89pxJ/o+tLLocK/f 5hRqEXeZQ1vPbJfmXLds1OhRDt2foVh7a6s1Af+im1AI7Z4ZWSoh7g6z0faLiWDjU1u0J+Bm qq8WzKPSD8SCNnTriASMLnk/1BM03mphRAjoMTXfU9u6w8tHTW3hteAiSjLd8qfvLqpjbAyP xHKTeSsHInQhttoex8UMS2wEAMlE1DLMYpZyEPVXnt9RFPuON1tF0uqxZaXGRI6JVUBxCzZk SNSh0gBw0Uss/OXL17e/H748f/sGAqLciSNJRZbbLJvGylUl4erQ016qpKbYnl0mNL6ycmc8 XyEUL//pdyspz9X418Jh561/J3lFbtBVxMAds2tsj9AuXItNY3WeJ/mT528sqGCcrWIflkOx O9u4tLArgWmCn/oGkmDnqaVGGGPJtkHGOiXUPWu9QiChLz++Aa8bz2ZrIjzqCYtzKtKBGj/M kzgaLLmcFqOKJNx3fpPU4oNmtBhaOK5894Qr0wZn3XWZRn7oLfQBIwZELf99/A8Gyl9Y88iq 9KnI7VW/izeLlR+OPmoXb1cbj1+pWxlJkJXBdhlYtWVluAkaa7gRuFqvRpNgsrN2GMR6tQjX FNj3xlMvEVuPekDQ8f64oLJScc/XlYfb7ZIU54nx7xNZjubFGtXa5VjULpL0LmNnOUy0O6JE Ufn0jYGyg4mjwLf95rUcmdQHoFw5ubCAn3rr5Xg3YYT4Ee+Rm8yziaMgCEPr6AFOJApRWRU0 FfOW0rxkeJMYd9CsHYSns3b0yMyF8tO8X/73tVUuB4G5H7Gr1+pU0qy9IN3SepJY+MvQWFE6 zrtSvHygMK8ABrg4pPqNHdFf/TvE5+f/ebE/oRXJ0fWU7kIrm6Oq+GUExs/SxRETEToR6C8Z 25k3DRovmOqOrGX9f4xdWXPbuLL+K6rzcGqm6kwV9+UhDxRESUy4haBk2S8qj6M4riR2ynbu Pb6//qIBLlga9OTFUX+NlVgaQC+W7D1f6+cJYqITOviV5KhfC5XDt5Ts+2ciu3tUQUt3gCCI AnHi2AAXB5LcCWyIGyNDZRgSk6wHz0jn7KiepDgRAjxixz+B0kPbltdmKkG3+mJvN5lgVHaS QcrJNuS8zno2znHDAx7elKdG4SHppHeLMsEjAvh6h83PibAPP2aTkT5Jg1DaCUeEa4eaZPhO kSIuyAhqF6wwuNak2KllZCjzHRM0j75ZH7qWLgTHdgviVMzo+p6RF8pYf/YgwgxWvwGyvEvp XPvNZzmTsVKbLMWVkKde4AxY+Wz/cGPcOZDG4pk9xBFP3pPGGjEkSR3fBEBKYaLyG0ZPEpOu yuVz9rzbkWx6Pwpdky7iPnCL/pMbRGGEdSPspXGUYuuo0q40tjQ4TUyAfbrADRVxVoFQNz4y hxfGWGUBitU3GpMjZB8BGcPV2g9irEaDBBgvrg+77LDL4Z3OSwP8HWbk7PrQsVidjSV2PVsj llpxINR1HM/8pKNILb3QV/wAJf88H4uNThruosXpWShK3b6yExKmVDfExNzEvivtExI9sNIT jF65jufagNAGRDYgVZVlJQjdkyWOlIkDWK59fHItgG8DAtfB6wGQJWKNzBPZVHAlnhjXXpI5 sO6jfoxVmpI4Qr8D199DG9Of2qUu3dDIQ0qCUKmei2VYhJ/Y8R1XXhQc29hl4tfWzBSAxNvu MCT045CawGhOkm0IVpltz6TjQ5/hES9Grl0ZugmtzNwZ4DkowDb0DCV7WDWGZzrcXmRk2hf7 yPWXhkOxrrIcqQ2jt/kJocNlj7p4TFCfxCb1IwnQ+jPZqnM91FPaHMi0zrNdbuYp1lNkDHMg RcYWaEq4ITKKAfDcEKshh9BbXIUjsCe2qBHKHEiVYNtl/3AgciKk3Rxx0RWOQxHmC0XmSGNL Wt/FL7IllghdHjjgpxYAHxMcQoUzhSNFhpmoaoourhVpfcdbWpF6EoUBmjSvt567rogY9O+s vcSq8Dp88sqiCDIzLK7dDPaRIVxhyzmjot+U0ZcGQ1kl2PSpEh/PzOJMQGKIF0vDvxijL867 KkX7IQ09HxExOBCgO4uAMJlqWqdIEvsRWkuAAg8XAEeeuifi/qOgPRqNamIkPZumSLMAiGN0 kWEQO+stSwTAkzqY866JoyVVfELWen5BnEpzu+UqVyYfTgbZysOGJttbzmS7bZE0RU3bQwfR F1G080PPIiJ0fuJES80supaGEGfezJaWUcL2fHyAeOzsjqnYKXtOnKCJBTQbMS7PlZ74ibs0 FocNABniDPGcGNvgxMKY4JuGHwQBvmSyI1pk8X0yffZTzjadpfWKHZECdhj2zLIZEvpRjGwP B7JJHQetFEC4u62R46ZkFULT0n2/2LUMx3YxRvb/i5IJOgwRnTZdyq1yN8bHWs4kz8DBjtQS h+c66FLMoOjKc5Z2OXBOG8QV1swBSZFPJbC1j+26lOzD6HQanAdacM+W0EfOarTvKTqOaVVF mOjDdl3XSzaJi87AbEPjxFva8DhHjJ1vWIcm2Jgo6sxzkJELdGwZZXTfsmr1JF5asvp9RUJk O+6rlh1oLXRkC+F0tH8YEtgCpUosFic1I8uxyKIkssStHnl613vngHvsE2/xLH6V+HHs77CG AJTYYgJLPFrcYIzD25g9yAF03nFkacIzhpKtvz2ynwkoqpHTKYPYxNkjJ1qB5Byar6tBxMhQ D6yDcYf0bjBQNGOGiVw3V9l1I5vCT5AwbhHB1/MaPFpsEC5wR8R1gSATycJqYjDitguvgLev d9++PN2v2ufL68PPy9Pv19Xu6X8uz49P8kXTlEvb5UMh511zROqhMrAOlLTabUx107Ryx9r4 2gz3qo/xb3KhTjvl/6Y12ObqjDbbHvmAClkqSL6lHG78lmx7Br8DU/4/FcBDChbP0MtkME/b 80CmJCsl1a35JGVmAEohTpQiVRms6Uzgpig6eH0ykUFpBmvXlUycuqqrwz5yF7sKjp3+6SRX fUqelUUVu457vtrgdqxF5DtOTtc6w9z4c+bx5B9+Ts/2f/19+3L5Mg8Rcvv8RXldBUN/glV5 HrqbHlcFp+CopqG0WGvmnRS7YluTKpPZJbL6izsf5goDOPeEY2TaEI0srLkQfrotM7rHucHD /JlUtQVVHkgEMugyz8Y8X38/3oGy4mirb9x0V9uNtnQCRXrCm1+8gE79GHUjPoKyeAyOxyZd mTcto6z3ktgxFMNlFu6AB7SWwc32TxPal2RD1HqzXghTR5ZbOHXUtTFqcWo9x/YEBwy6Es1M U117SHRFxZr37qQ/qJTNyegzzoTKuoUTMTX6UpDxgzP/BrAE+hav0yw9wKFndawisWgdZbLY miMWYbU1YsU2aK7sroD3K3H9k/5JB6LuTkWG7F91X0RMCOR9IydmxyC2E9KCYIcWAFmOQtlt SlK2jGoxOwLMZpIEtfiY1Tdsdje2uFrA8ymvWImWZghHWFpvCWKIECNVi1YM2ZMbhDF+6TMw xHFk8S06M6C3nDMs65vNVFUCnehJgHX/ACepEyONSFLPNvLGd1u9AvzNViX2kXIs5LRxn5cL zW+4xSEafxmmI1dy0CrJxBrcdgzAlmxDNhXw21Se2lQ2k1H+2GqUSMI+TGx9CbrRWvsHyUHt AJoTZHugRRBHJyOsOYeq0HIE4+in64SNOOw6VCSWncFl61PoOEbE72wNzioW4rxBRuycZ9tX Bn1bpUF9wU7Ivh+ezj0lmb6rDKqYGm1QW1DKZfmU1cKHzsoqQ/3ptTRyHVVZQOhqoldSAopP WiNm5U61UpyOqhtMsOdqIx9aoimbSmRF3VTKxOwQoCeRbeiO+qVIZqBVilLNnXdCFOOuAWEr pO8q/XpVBo5vFT1G/2r6sIPswKd97C8JLWXlh76xsPXED5PUvgP3n6tTgqukAnw8JSH+MsGL bMi+znYZdh/PhZxBL/kNIaqG5TKgGf1PcoZFJ5b3ThW6lvv7EUZHswDNVZrTEoMWOIYExKi+ a+z4GMuSkAMsobMgNwidZXXsdc2+gvMpRDTQ1tMB0dW/xfoEwodNkOaGLR90+3KbKD+mnO7l 52rM/gY1K8cZ2BYn8FvUlD08TiMM4LjiINyc0INiyTXzgA8z7j92kYtJITu2FCinVRms8IjZ Gk+kSgAzCmeWxBKfRuWCk817bJvQT7GbVomlZn9arMv0g9CMmOcTCdPVmhSIjy+055YsCWYu TfVSGhmaaK4hviWNp6r+aJjFEeE86rI69EPLojazWT2zS440uSz/j5iOoc3N4cRY0DL1HUyW VHgiL3YzfBSCrBC/Vx/OhAlBMksSe+g4GbZlCxKG2Kc09mwVUo1+JExsXMsVZTxRHOEZwAEj TLAHR4UniYIUqxuHIstAG44D73Q150IFTo1HFv11CJ2U0tkGL9dQKbWxJagBtMQ0nGhVTwsq HifoTAUoSdG1qCKty+RCdOrDWUh2x60iHl7UeH5CmtluDzeWwN0S0zFJnMjB8uZQYodSyxjh 4VTBKHqxYHEYQvI2jkQSZBy6Zox6VZtZTkEqF0Uv0ySesEriyNKptNxBmMXlTqXswOVEGdYE BiVegK4k8KLtRj46brCziop6PqorpjKxkedjA8w82+hYYllsOOr6Fj+3KptN1dlgW5YBBFOw 0BcW6zmDydbV4/HFlMtUx0YzMIjIaBeZVncjC9FXF3KuZIGhLGRrnY6MXsIV+5cCQmUTzIG4 zNKR8H2W6D2Wj8d3C6JNff0uT1ZfL7o8Zyz7rGtHFrlfC1hE8/On9ea9Uk5Vu1xGIfTTsSI6 UlULifmnAN91ypfoiORg3VarfXEK9xuL2yNRpyXM6mdZ9MuBWmKJgYUUeK3E7qagu9UrXaD0 XZ5VN5ZQkFCbXdO15WG3UGSxOzCB3Yb2PUtaWLp3dOsxT4aiG0zaC/1jCeNXiyMniEYNDhyt aIEPIFaH07o5nTdHXCWAh4XkBmSN6nmUvwPtnm9/fXu4Q7x0HHcZOHKbp/VA4L4Gd+2BfnCj uZSNJaglo5837ZnkxCg6Y0lmN9DTcVYmCz7Srv7Ifn95eFqRp/b5iQEvT89/gnudrw/3v59v 4dyr5PCPEvAU2+fbn5fV37+/fgUnPVJlhupvtSEzlIAm4+nWt3fffzzcf3td/XtVko012BrD zqTMKB3mp/JuwLAy2DqOF3i9gwuJnKeiXuLvtuiRhDP0Rz90PksKA0AtyiL1vJNJ9GVTBSD2 m8YLKpV23O28wPeyQCVPHrGUXLOK+lG63ckmpkPNQ8f9tHV8vd37U+KH+O4LcNNXvueFmMsk mITcK5berwY+urn4aULmDd2MtWx7DNzzlS3O18yJxFzDeJJEt2tUQFQ/euaZnm3wZoBC+huW NybhmF3Uqu5IpayPrGVxia+2M9t6w8RAm8HY1MyOnEhdo1PsvYk08hkL2NgY2hxq1Wan3hhr 0L7YmHOTEedhw37Mpp9sq6l3ahxshms73QAcjGzmcScM/n9d7sDJL9TBeHkH/izoczW4DKeS 7oDdmHOsbWVVBE6iB6rV95wdIMyuJY91Xn4qar1Uss+7DovZIcCC/ZJ8r3Jic9hlnZ5PlYGu jDUjvllp+Vy3nRJqEoisz3dN3RVUEkpn2nm7Vdnzip63W70ueZnjHnY5eCOiCykpdnnFBAHs yZWjW9kjIFBYFmOAIJl6rX2jq6zsVV0soB6L/IoJqQV24cyLu2ZiUqFGgQF6AWpB6MzjKBoo B5CP2brT+r6/Kup9Vqu1/ZTX4JdJ8csL9JKMJugyMd/ohLo5Nnpby2ZXwGC3VK3KdgXhsejM 8VT2HRoGSaDXQoNGaRUXMHeKUSjwFqRrQN9M708mzLLZjwas4fCh7AvxlZWG1mowZCAxAcwS owvQNqtBt7FsLPEpOE/eZ+V1jYuQnAGcjJOFDMoMvMKxUYW9NHKOrmASnto3NCsgKLdG4yEW NSIYSpZKuAtO7pmIrvcGI+YlyLyWYI6c51Az0d2Od+jlDZ8dEFgso4WipTQRtZhucolV1vUf m2soVtk9JLotIhyfMsWxsWTN5jjN9fkAIeF32rLR78EP9OBoUlF9nen2FoDT/6tzS31tkSkK OO7pE+hU1JWtwjd51wz9MFBHirHCQtRtNn+MfUOo8p73qPNQvheVg7/B0csMsivO3oyV7Xo+ HYHz5GKDyhFGsimCjUSc9my6Pjd7UpzLou/L/JzXbDuSljnAh5OUPJqBDEHE+q7A9ROB4VCC 307LWAYG9t/aeNSQcK5tus/oeU82WumWFEKhUMRSZkw80McsaUz09tvby8Md6/Py9g33/lw3 Lc/wRPLiaG2ACP1m88O6UJKWTbbZ5bh+aX/d5vgrLiTsGvbJ6FXR2/SqKvTtlgkHPIip/Cw/ 0EyHK5ILPPr6cPcd660p9aGm2TYHly+HyqKOQtuuOa/B7yRWNSqgUWKUy92Dz+5lD7NTPfpi W7HMLNcDA9NHvgHWZ98SWWZi7ELUYrHOr7Ro4fBLHMaUU95EPfO9GT/rAdO6g1NCzYQ/CFpA mCCyy00RHo5jhvjM00snJDXjrPYdL0zxCx9RNKki38ONwmaGELv/Fe1TH1QFrXMcN3DdQOsh fuZ0NGZO9DBO3+SMZC8sEzH1Tka/iwcae7OENz3s83JY9Z8lSgL1J6NJjBgatWeH4tmAysRU u6GZjN0ETmhklpKEDpYTPGTaG17y07itJN4t4UkraqBqutYTFPl6ArZFul5AHdlEkQOzdoZK X2+8xDG+be+Hqa9lbXgdFJ9bf/vjVIhDHjqxlkNfkjB1T8iYEQ+gC33HhmX4X1vfzVqS+jcp qO9uS9+16D7JPJr3aG3ir74+Pa/+/vHw+P0P90++0XS79Wq4p/kNruowsWL1xyx//Smvm6Lr QYrF7zQ5LhQFrY0uT1oQCU4GVRhbEu7W+1oOlyU+C1caNMwO51kej7sDtLd/fri/N1dCEEx2 2nOMDIg4NbaajUwNW4r3Ta9XcED3OROQ13nW6+NqwKdrH0t60h4sKTPChOqivza6c2SwCE0K z2iZxJce3l8Pv17Bw/PL6lV02jxY6svr14cf4ML9jl8Zr/6Avn29fb6/vP6Jdy1E+mPHYhHc CG1eVuVqBHMFbnUjK5ytznstVostO7ixwh9o1L492DTMM0JysG0pmCyMO47jsXuKdVZjFyI5 W+wkWXmgdj05K76OgTCKCBJpT/qGXuPE8Wb3X8+vd86/pIcQxgKuz5kAjz+U9MTqQA+w+ii5 8WeE1cMjGwJfb7UnAWAt6n5rmvbpDEy0U1TDJ8D2CXkNu6PhIX46/0CtDFlnTCXp8WOIKgeN ULZehzc5xfbYmSVvblI88SlxsLvIiWHUdTOSbqjrO9gdtMwQB2ZbBJ2bkGFYFHsmfX9dJWHk Y/Uw5QKNAezhUu3FfIbsOkYyD64rqHDEZq1RFaIB40opC5l2NCQ+1hUFLV1PVu5XAc+aRPY2 NiInRg/NBNyZhqIGJAOKWY+C+JEtDf7tOIQaMUxdGLh9gn87jljsFEemWenSSL/+7HvYkW2a wqPuOpJ2VNxYSE6ZoJ/KPrJGYFv5rnxYmD44m4l4aQwJE4u6kZTYs6hbDix5xY5MS/O1OzIG ZFx1oIGFfHEaVmYr6IYtCskHKZSKuuKhnxH1zKgwBNgU4isQqlonMyDDG+gB0iJOj81GAV32 96+sLC4yrbo0ll03z18pCGWHtTM9cl0kf74GBOjoFYuaRRdqnl2eix6+plxIG6ehWiEeqKve DBYC02eE8BnvbmAbys6mHtaBQB98sWFLhyfc7JvjGsZkSjxjL21/3L6yM8PP9+rjegnyfRg9 dF3LmArDpS6DHSoJz9usKribXxS25BypurYYS+xZnFTJPME/4EkSVM1ZzsWyrXsB6oFpYhjt Oo2ktP/kxn2Gn9Hn6Zz0FlsYmcUSpE5mCVHF5ZGBVpEXIENx/TlQDuTTSGtDgs1ZGIDI1BRx hcaD29PjX+zw895SNxj7LzZs27P/4VZh86TVDGan/q+PFFmkNLvHqcHcvbxBHs0bp8d1enl8 YYdzdJ5twCh6VE4zaLpVioQcFVN2BkiqOzO3ETgLaJPByj6r67xUSz430qvGEEm5ojsITy57 VoDAXIymyPYQFiuHmuAHpT4vzwWDI9xAimsi74HhXO0q/O575sEVra54nZYwPVyejFvrPmA8 8IGxjkIiIsI8yUM2o9c1Ofens5bp3NNwwpH6dPpY5y7jWhNj7uvDdvX0C/S1ZF8hkPu2UKIt X3Gq9FIjEiufl/0GzyhbKFy87Q1PE1pBUkMOp01B2zLDHn9hKA3uFqRhNITy1X7DLdhBHi8D GfdaMYDrrCwb9X1/QIq6PWCC61hYhdWgAp3ECl5nc0kpVDwsPNw9P708fX1d7d9+XZ7/Oq7u f19eXpW3ttHa7B1W5bFVj4U7fq0+Yx9bmttsaOcb5blcUKzn9QkWlzr8yxY3oG37wXOCZIGN iT4yp6OxVgUl5kcdwHVTSw6TBiIfyjrnEKYRaVFBRx8d+HvMmAEpMDaVKfHC0KgPEM80M+if xF+4fVE27hLCm+GbCg09S4CuYx9FqoGWuKMomtXL6+39w+O9/tCY3d1dflyen35e1IB5GZtg buSpnt4Goh4iZtTvVLMS2T/e/ni6h0hsXx7uH14h/NrTIytfLyxOZImb/RaO4KSSmQxlKXap CLkSI/z3w19fHp4vwi4Trw64z1bqwwm6lvNINkxY1Zq9V65Yom9/3d4xtse7i7W35N7AIwgw IA4ieQ19P1+xpvOKsT8Cpm+Pr98uLw9Kp6QJf/mSasEoeDQga3bCgfvl9X+fnr/z/nn7v8vz f1bFz1+XL7yOxNLgMNVdLQxF/cPMhsHOPcdDMML7txUfpzAlCiI3M4+TULrgGgiDAbtUI0E2 bJOnyWArStxjXl6efsATyT/41h477+hh04ZS3stm0rZAFoBR2fH2++9fkIjldFm9/Lpc7r7J G4uFQ9szhDr7uG9lj1+enx6+KM2oN10D2nO0sU0WkUbPmAdNnz/Hjp637S4D/2+KskVd0GtK W9SgXjzSnEn56Xwq6xP85+qmU5RQr4qSgFmWJYZq1cibCfw6ExFLVCbVuVInTtsUlcW6HlCb 8XtbBOpwF0YBty/fL6+Ycr6GzBmdihLkYtZpxRZ7i9kW/0/akyw3jiN7769w1GkmontKpKjt 0AeKi8QSKdIEJcu+MNy2uq14ZcvPS0x7vv5lAlyQQNJVE+9SLmUmVgKJTCCXKA0xWzQZzTrD x3iUEkRNAuuiZXCDafOYprrfOBYsyjxOcCq06d1dcbYw0SH2KxDR+/IKEkLNMD87+Hcf6w9X DRpkAbUmuvobRAQSYRRKkXOwuU1UgoLRaTFWFZhtApSLwfKt0IKuPQW633vjGU+R5Jj8QsBM fHl/+3OuPYlcpivO2hPWJXwGdF0hCbvWGGUOF29RQot6WJd+Ybc7Lzg/PsLpEshkptIdApmj vhGxorUIuUtSbZ/YMYAocuHNqYjT4toYNbrg1OJEMhkP5CAxqCbcJSylcUi0dIrzuKsOSjIb DXQyCINoNuLvMgwyPoCRTiRc5ClBwU5V40tK+gFgJgufXXYfTNhP0wcdsHEqagRVQhDub/00 Xy2TStRXZZGCEp5u3fm6CChZl9fZgtXxbuKNYHkGiW4yOLAW+9Gur4Dbbk0jK7VYZSFxfn/h 4t/JZ3FyK6AgwHqWejwMYBR7hSL94urWGLOfpMvctmsoj4/nt+Pzy/mOvQ6STnv4tDhwUFuF VaXPj69/MVedBbAgbSD4U6bSMWGdWtu3RGrsTlP0urhKJPNQB//5/en+CnOk9Xc0CgEj+If4 eH07Pl7k8PUeTs//xEP/7vTn6U4zZ1MH/SMIuAAW54DLYc+hVTmUIu4Hi9lY5cT1cr69vzs/ DpVj8UriPBRf45fj8fXuFkSYy/NLcjlUyY9IlY3Cv7LDUAUWTiIv32+/Q9cG+87i++UlZAZ3 a00eTt9PT38bdfZHPwYu3Qc7XR/gSnSi3k99+rb+Ah1c93EZXXYXQ+onCZnbX1gppIqDm2RF GtWgtkcZb6agUxdRiS5svspDzFYoPRwEnJP8XZlG2UW9+SFl4QuR7JnLtWaUjGVnPyV1tI+2 3FVQdKiC3tYl+vsN5OrB6LuKWGYK/EZ8WRtELHw4iEcWnFq+NUAMtj/WLyZ6eBvYz0LQCBsN vKi2E2dit1pW88Vs7FtwkU1UxApN1pKI1jiZt/7NS+0lJtEHhBmAlrs4pnkVe2gdcNKmhkez 1TbmEal1g2JyTS4oEdxY5cDp2TWrYdV/9azdWhmLVLYqcFF3JK5OIq4Y19MG0RQYGFzfS7n4 OmXsBzc8DnPDM+JeYfzwkKLxAiGXoAGtqcWS2G/LzHf0JQu/XZf8DmBxSTOnlIea9WkYEsc1 9F1qZBD644EgR2EGCsWA0Kdw/BufxA2kNJffrGo6NkYljCXbHETIV745BN82zojNFJsFY1e3 N8gyf+bpm7sBmNcWLXhAzQUshu750ABzT7cYBsBiMnHM8JIKagJoSL1D4I1Yl2jATMmNKah3 YzMBR7WZjx02Iw9glv6EJAn//9xEwuG0klGZ08qnS33muJxegVeTU01Rwt8Lx/g9J7+9GaWf jujlJ/yukxhDs4G+54OKnRo96QmGdh6wdNoGaHO1Q1oh+Xfx98LA62cCXtHOZ0Y3FqwdAiK8 BSm6WGjmb4G8aXGa7HYtEF8oaxLFU8UVhhOCQKPtPkrzIuqShOo+WnNvrOlF68NMT2KmsmPQ ZpWdGW0Xc+Z4ej4OCdDjOksACTvrH5yRawAch8T5lZA5BRDTKlSrpw5hx5g3zGVN+RDj6WZh CFgYpaNtfeOo4bEcZuvvBrM3dVGY6mSoeE+y/zEJULA5KkIp3mR52MVB7ApXstRo7nC3OS1S 98ZoYZ7AvJ0G2HEdPUV1AxzNhTOyqnDcuRhNyFHXIKaOmLr8QSEpoDY2y49CzhaTkTVCMR+z FxYNcqon2m3akN4KZu9ULFzjS/T4Kg28iact6308dUZ0OzQ6w6FNPPnfPrHEL+ent4vo6V5j qXgOlhHw9CbUP61TK9FolM/fQd0wmPJ8PCWvGhqVkr8fjo/SgU3ZNehlq9QHaWvdeDzqc7bM oqn5ptSxKDFno3wl/iU9+rDapExQzF0V+oksCjHWtv/+Zr4g4UGtLivbjNN9a5uBd/bqCkXX E3kCfa4z0ef9kYFilVovirZcV6kuqIiiK6WujLRbWUqw3i3172hXTIpVRmd4HIkBbOCa+W6e qdTyg5V4q9YPf4hPSIoyjAs6HdHf85F+Ok4816G/PXIiw29yoE0mCxddJ0RESiHUAIwNwMij Z+hk6nrlYIRbOGicKe//BEfQVOd9WNV8av42QwIjdGG9WPZIFYpSJ5+x3nSImNIpm009+tsQ J8a6uSls6bluqBQWeYV+WNrpLzzP1WrMpu5Yt0KE03Li0BN3MnfN09Ob8UHmAbNwKduH1kdz l3qBKfBkoksDCjYjoRYb2NQhaq5isKFp/dO9kX6ylrtn+/v3x8eP5qqGbtlwl2XXoOqtoq2x VdXtisQPY5SSaCithEBTsbVnRNKhJljT8X/fj093H90773/QjSsMxdciTdurQnXrusIH0du3 88vX8PT69nL6472JEtWtC8ygad/WDpRTVqMPt6/H31IgO95fpOfz88U/oN1/XvzZ9etV6xd9 W41BYOQf0gEzc3SG/d820wel+nR6CF/76+Pl/Hp3fj5CX8yDTGrmI6rRKiCfX7nFTemGlvo9 y1JAXS+Fp2fyWGYrZ0p0c/xt6t8SZphGxAdfuJgJfiC4d7EbjwbDdjcHwOq6zJXibJ0NEoU2 zZ+g0XHPRFcrEKeJqjg88+o8Pt5+f3vQxIoW+vJ2Ud6+HS+y89PpjX6oOPI8wuskgBi7413c yAitaiJdlmuwTWtIvbeqr++Pp/vT24e2ovrVkLljVloN1xVVJdYoKo8G4ptUwmVzG6+rHcle mMxGown97ZKPYfVVsUHY+m/oJPp4vH19fzk+HkFifIexG3sZV7bHRlZtcFNm73gDEuAyS5ql /hma17432WFK9M49LvipXPC6ozZB0HsaHTUkHDSLPRXZNBQHdrV8MnX6lsGpoP5/OrQ/CJQ/ q4z+xfCnb2EtxnTZ+Cmc2SPO2NQvQrEYj3SpDCELwm7WzozqSwiZs0+j2dh15qRtBLEu84Ag 0ZDh91R3KMHfUz0B6Kpw/QKWqj8aMdkQE5G6i5Gu2VOMHh1eQhxX2wTfhA+KqW66XpSjiS6N 9nmAjSgDVWl61O+BbXhsBCHgKcCDjCQMCsZd9W5znzrZ5EUFH4u8VRfQcXeEUE6tTxyHRlpG CJ/mutqMx7qjDKzp3T4R+ix1IHr29GBy8VsFYuzp8RwkYEZksy63KHyRyZS7xpIY3UkfAbOZ SwDeZEw+wU5MnLnLvWjtg21qfgEFG/CK2EdZOh2x0Qb36ZTcod/A53Hbm/xm69NtqsyJb/96 Or6pW1FmA2/mixk5pSSE75y/GS0WrIbc3Mdn/ooEHdLAA6e+TmFmCPNXY2fgmj3LgvHEZe0l GgYpa1SSwCOH6uUIFt3LEdbWx+S4c49Jd9sgTK5uovnjo6UqszG5QaRwYydQXKv1tcbh3If/ pcs3+Pz9+LchGcuLhB1/qJAyzQl99/30ZC0s7Rhi8JKgDYxw8RvaJz7dgx70dDQ7gn4aZbkr Ku4BjB6H6PvNUzVd4RskQvjz+Q2OyRPzYDZxdd/dUDjEhRI1UE9XySVg7pgAXWkNMPnxnAIc PXY4AiYmwFE+pS0bKtKRSsZsSbXGUNhhwjRQSSrNioUZon6wZlVa6WEvx1cUMhjWsixG01G2 ogyhsCy624ktQI7gUeuCzU4OWqvj6Nmt5G8jUZKC0XRTRTp2jDSPYjLls2UCYjyzeIQRBVOH sldeCmNcy1QTPuv6unBHU22b3xQ+yDRTC0CZQQtsuWirwJrfpxfnntAwmFMQxHhhHk/6+ULK NYvg/PfpEWV49C29P70q03NrSUhJaKL75qVJ6JcY4S2q9/omWjrU+zRGG/cRuZsXZcx6N4oD NKHfyQKdJqft08k4ValE6Tx9OoSfs9/ueIYrFuTqEa25m7fNnzPiVnzy+PiMFyDs9gK2kmQq AXce5DsSazZLD4vR1NETYEkIeTbJitGI5GeQEM6tvAIOS8VACXEHYpyDJuvMJ1OeEzND0p6m Kt77ZZ9Fg9H6iisSGEgdTeXlxd3D6dkOJwyYYJ2QpI9+WscJG4yuSR9bXpLrMLPuXvqVZpFF mhBnxKTwg43Z+3ZZRyKqdJvqD4qpkjYHYpuheX19Id7/eJXmWv2ommDGNaD7KjRgnSUgz4QE vQyyeoP543Zi6cqS3WLBEm0661CzSaZwWVn/GTScSODk5vQ/JELnzCQ7zLNLbJk2miWHKOU6 i8ji4NfufJvVa5EEAygci76kZa/kI/NQwgHZrF8U63wb1VmYTacDFzRImAdRmuMjRRmacVJb NkI+kFYabdUGMpEGS3IUBctB31DEpcVARB2artJwyWjXunLIoE9yjQtGLwoky+0+TDIuGnPo a2/6bZAe/aeSxtprg/XVxdvL7Z08MOxQoaLimlAOujSwdwsb8NHs0CoeuAnNxE6/f2mrqmj2 ihZuuTn2N1X2aNpa0T2F3oFIh+WihP0/lIUSy9TZquyIhXWhalAEe24BdVTNQ+5QJUkQeUO3 Vx1R5gfrQ+5S3Vpil2USrrSIaE2f4jKKbiIL2/SlKGVCFDyeSqO+MlolehS1PDbgdARhzGfj iAVr1ISBoKHRg2zW1HqY5Oo7fERfzRauZsrYAIXj6UmnEEpjLyJEWtibiSCN1jqWldV5ofFV keSa8T7+wvPCivsv0iTjzxGpK8H/t1GgeXIH6ExDzSXjKqsvd34YmpFbW0Gf2qSql54TOoBJ hqZN2N5H0Q3ENlC9CnR40Q4vACV5RlMrR4fKrdkQXYAZG/5AEgA8UyTwAYJUswNqUCIKdiVG odMxnqpFb9JD0986zkvZPt+4N9yWZ7RFqx7yh/62DDXRFX+Z4ROg1mwZwE4jSeISmETA6Dal HRBIgw0DR98DjP2W673TqqoPflVxtqPfVEuP+m99ErrKvmlTwG5AJBicCixc+VWC0Wq1cR3a 1rtaEHK5yys+8MFB790gRckHa0BUvpWu9iIo2eDXh1jYzmEI9AXMZFXHfsXmaFjFwiUfLA8a yKMJqXM3IN7eHQIniNsYiqBxTvPFJs1J93Q0u7GWVWlNcwv7wWx2ZHLdSf6yGlwAHXG522KW LqCTjvi8vK6omUOW4NW8/6C5KK73IOLGXECIbZKaXyJ2remQIJx/fgabEmoTET7q/swstlSf bh9JpKb5kz4o38LtN2DwiR54aYh1YcCDWFCWpWAqijUcQGxjSRphmuqNigih6XTbEA31rgnF wHlcgxJQXhfY0SEK/GwV99lisc0r+KLahZsJSBRAOnWQb+IrBFOrZCw6rQSg6y4GllXHZzzk HlKUgG9KXPnl1hg4qdHg8wpYgYREGo+zqt5zt00K4xoVBJX2af1dlcfCI0xHwQgoluceWQAB gLhnBRWRhO6LHD5Q6l8bK7KJWXD3oAf3iYU6yEj8HQmyGZtFsYaDIV+VPh/bt6UaZhYtRb7E nQGai+B5hqTCpctrbc2Y1PjC38o8+4oZ3FDysQSfROQLUBKNCfuWp0nEuf7cAD39DrswNua1 7wfftrrBzcVXOIa+biu+X51XtXapCWV4prI3fbB/5OQ84OJ8ej3P55PFb84XjnBXxdrF27Yy RA4JsE5dCS2v2PkZmAN1NfJ6fL8/X/zJzY2UkvTtIQF4taJvLQkM1kkalpHGYtF3XC/bKrjN z/VuBWxkyYDqgiRqB+U4DuugjEBq1vZum0hilaz8bYX3NaSU+tPu7v6ewR5t1w5GzZFr/VpU UaYLJyVG7Te+gh8arKMBwDfQrVmMUpHk8KRcB4KRCmEEFVpbRy9AVPKSATFB9ZMTa/rJaFse Ig2As+i9Vr/VCYixD/pvCkqRWJOv3EDUgWexOIoOkxLYD3cX3ZKhEpwVNeZqSvmKGgqpuLIz wlKiSxnGq/u0wJAO0BHcKDMQu2R6w96w9+icmbHDDVvXjaj4C+OOwsMcH/uldDG/4Q/jjjbK lhGosdyje/9tSn+VRXB4N8cRVPr7uGOBB2PdZ8kW5CjjHMyGlta6MIpfbg+esUkANLUWawMc PtPK4UYLOC1LsnwUBDluiso4Lgx8ahosi5+soyI3pS3aYyth6NbBTzQ399y+uQ8DiStiGKsh 7Nb7QbSnzc/1oaVmKiW9+XGtVo1foJ0vFtFW5PrLTAOnnv4NEJiTdgt0LfbGytlZy6LngGU+ jAQx9yovN/qZwClMevxF+NGPyz7kEd1KCbWnv48SzGwYM5sMYOa6j7GBIVf7Bo4zMjJIhjpj ZP40cJycbpC4gxWPBzEenWwNMxnETAcxi8EBLMbTHw1goVv/GoWJ+RTFeawNGenXzDP7BdIw rqWaj2RHSjvuhH+JMamGvpAvgiShH6Bt3hnqF5tMScOP6Uy1YI9vZsJTT3nwzJzrFjE00d1o xgOj9PiGnIk5/E2ezGvewqZD7wZ6gcFM4czyt2aliAgiEFK4x9WeAJTvXZmbY5e4MverxOcS u3Qk12WSpknAtb3yo/TTtjED4YZOEYIT6LS/DRnEdpdUNlgOPvG39CMgptqVm0SsaZFGK+oN X1Je+91tE1zlrCJE7uSVq9fx7v0FzResCK2bSM/dgb/qMrrcRaLqxNr2HIpKARo0SkxAVoKs qhWsMN1hFBrVNVc9Fhx+1eG6zqFKmReVHGTtfVgdgqYg37qrMuHlZ+buvYWxElJXdXPosc22 B+IhHkiU3lEWfsWmQcXgXKADh9EWRo4XUUFeXNcYIjZo/Fk7SoNI75BdQwxVYG4e3gzKIkcO KAp2g8hb90CSZrCK1lFa6E80LFoO9/cvX1//OD19fX89vjye74+/PRy/Px9fvjCzI2B/bU17 QYsoGxpPR1LlWX7NJ77paPyi8KGrrBrT0qS5HxaJprqbGFiucV4GEUNx7Wc+u1gwa6CIKjOj pd0CqJT51RYt8wde6Fb0xaoDYfCBrQ+8gkb/6NC+uM6yCLeI3GSf1S5TCBHhNmGjPkd7kgEW ftaoI4IEudsNjFTShKFSJrlOtLc+/e7WPftgWn7/gl5d9+d/P/36cft4++v38+398+np19fb P49Qz+n+V0zy8xdysS+KqW2OL0/H7xcPty/3R2l11jO3X/ocjBenpxP6O5z+c0v9ykChq3Cl B5t6m2+N2U0w/ZTaslo+KnboLTE+dQ/Stu++fJda9PCIOtdak5G3oznkpbq50O9qZPht6pys YFmUBcW1CT3ovEmBiksTgmG/p8CVg1y7IZFsPm/tOoKXj+e388Xd+eV4cX65UCyin3hFDJO7 8nXDSwJ2bXjkhyzQJl2mmyAp1jpHMzF2obWvH8Ua0CYtSUDsDsYSaiql0fXBnvhDvd8UhU29 0W0F2hpQ/bRJQRDxV0y9DdwusBPD1Bhz01+mkXrMs6hWsePOs11qIba7lAcSZaKByz/cLU47 0F21jvRg8g2cBq1vgF2SAXUj/P7H99Pdb/9z/Li4k+v1r5fb54cPa5mWwreqD+2VEgV2L6Ig XDODioIyFITvKnOs97cHtJ++u3073l9ET7JXGBf636e3hwv/9fV8d5Ko8Pbt1upmEGTWgFdB ZvUpWINU57ujIk+vG38es39+tEown8rwtIvoMrF2P4xr7QMz3LczvJRuuiglvNrdXdrTFcRL G1bZCzBglltEzeQaaGq+FFB0HnOv/Q2y4Lp4qIQ1y3DqXpW+vQm3626OzSI+5qqudvYXwzR+ 3fytb18fhqYv8+3OrTnggRvGXlG2tv/H1ze7hTIYu8w3QrDV7cOB5Z5AXDmjMIlt7sDSf7Im s5CN39oiJzaXSmA1SnNRov21mzoLnYGcwRoF6xLd493JlOkpIMbuJwXF2nes3qJLJSBUjRb9 AHji2F8CwGObNhszcyDw5XmZszkbGi66Ko2Y+w3iqpg4dqqm4PT8QMzmtMH5kb1nFczmPqIe eONoKba7ZcI/6PTtlYHHdBzBn1UNEtRVnAhOq2vXtJ9FaZrYZ0Lgo8rc5n61DjLAspGBe/TU +pg4kDASTHWGgTFFxvIvM7WbtX/jf3KaCj8Vvp4EyTgz7IUVRaG9BKOywFiDFjzzrAqqyLfo QPuOE4Y7NPA+K/UvTXTrZ3RiOTUxccx5ki8fn6wV/Y2qgc09ThThH7t65Npmlvhm0PazvH26 Pz9ebN8f/zi+tLEriD7SrW6R1EGBMqY5M2G5XLXpaRjM2kh0RHD+Z4taknBHLSIs4LcEM9ZG /1fZsezGbQN/xcipBdrATl0nOfigB3dXXUmUKcm79kVIDNc1UruBH0Dy950ZktLwtU0PgbOc EUUNyeE8OZiWwHUIJjNOMcHeAuKS9gztU9LvjKHc6CMfjDrBoT2eCqhjIr+NmfQgu5A+4hJU 48ZcQJmGaukwXJ0Wjkz++DQe3ciQQdNUcj8VbYv12Q/MJ+D61Y0YCI0We+cuTQYsCgxIWgIA HPPCNFx1rjJpgd2Y1wanH3ODNn8DQxy6hmPFwi1/P/44FQKGv6oK9FvOEcSLU25b9B8w9uoS 4didxok55AD1vQk6EEEwsoaiuoC9OPHU1RqtaZ3QTnwKJcTheHFrmunglQp/kuT+TBXOn+/v HnUa081ftzdfQJVf9rl2snGLqXKCIUJ4f/7mjQcV+wEj/hciBc8HGNrDfXr88cwxUMm2zNSV P5y4OUv3nNdUH7wf4sg2WukHaGKHnFctjoFi6Vbn86USn58+PX0/evrn9eX+kQvB2gTBTRO2 ZcpBGwQ+6Jp2MccqHpeXw4YSWLmJ0c9mRrUCY5Qq7vgspCp5dpG2Xmd1+DAWhbJR7vMeK2Bz Ae/k2644OXMxQoG5mKphnBwDQvHbO+/nXC3NFRYIAvtS5FcpaZehpEQjQsnULnWSIjyv3BGe eeJXET89C1ZNGcSdUOsoWIyYr2aQOdOSnE+4ytpSNowqkXfHYw+wVUfQuO0YA4OnQu1stWst oenW5RYOHkTxnbfGenZjJZz2+EjiYRHUHMPfX2Oz/3va84vhTBuloXUhbpVxh7RpzFQTaxs2 Y5MHAKzCE/abF38EbV65wfmDpvV1xTYTA+QAeBeF1NdNFgVQDFIMXybaeXVzgeVkZC3dEres Fd1eHxIg6JXf+9v3sqiAiVwKoJ3KmDSFQX/AQHgGnW7COO3JYSzYXvIvpahBrNSYlaWahuns 1NmdJd1lXNQZhaBsSJTju4ee7NIV/fp1rS3jrMsLzgNrmbu/Fu40N7e1iZq3O72+nobMMeJU 6gJNArHMiqarnLuJuI9k4SYrXnkeK01h8hiovYzMPSZfSjb4ES/n7vvAQk6OglJ0knXZA1m9 RCb0VbbrKN9hafLeweZ6M6y4QK1fn+4fX77orPOH2+e70IFLh+aWSpo4Z55uLvCq6HgBLIo9 mmq5ruEErGc79fskxsVYieH8dJ4DI1IFPcwYWJHLDoQKMbEFc9VmTVWwAF9DnOQHz9re/d+3 v77cPxgx4plQb3T7U0genQHjyvNLG6yIciyEUziKQfuuruIh4wyp3GVqFT86GVY+rKIo6zLH vKOqi+okoiUTezOibcFN8lqprBGUcqDraDpLsAPWgsm2TTzmS4GKRB1nUXekzRriVNkIzHcH BtTCTojuSdnBGsR6nRVmUzkire6w1+kpGILcZEPhmMZ9GH0Y5mXFEjaIv+2ydjBE6CTlaPQ+ cUx7OLnk5p12IttS0YUgRHapVvRjq23eEtm6oshxxWRT1ji7B/W8nh9/O1mGxvFAR6miKWV6 /LpgWfhdGNwdKCfG51jefn69u3M0EQqRAj0B7yvmh5nuDKGWzXvvmUF2gR6Ih8R3yF3rKF2k icmql62XSeRCplaajLF4sKmLfC1UrGzIMmJMCQu/RSeHRKNF6jG3SE5pXwKk01fMaifP8ogs 8gDWZTzERANb2TSjyXiO+9Rp0qkuCrmh2XFakFiwzYB+TEI2UN1MIzw/CbzTy0rxeoOHCnkJ qiKVISiC/b3Rl2FotwJ2coRXo75+1btm8+nxjjFm9FWP3XJl/3KqytWQBOKRggUQGo7WwRop fgQH85JHcX7CCY1vmDYjLKAh62Ml8HYXwGuAJZXSOahSH8jXJ74SmJqMp9M5cDO0YxeIp7oc h6W5h1Og9BPJdKN7xlEbrVEfTy9M0ZbzieItO3zpVogurjKb/QRSbdPNBWWQDMu6Ofrp+ev9 I3r/nn85enh9uf12C/+5fbl5+/btz/7RjNLsOIi9U1perydTCc5vT6CrXe/ks+jWbJAoZ/Q1 fJAPM4mK2uw4Vxv/zlfoBKsP5UqvdvRup0fhqt1WvvsfxLAd6j0F+wd0SR5XR5NFQPZyPBqB /U5jiwZ4mFKt74YzudXMLTmL8O9SqFz2Inw2mS1nFoAPd6duHXZI+ZdVqpi2xilAHgNtBM6+ MLVQFWPsEItPECBTkbDJt4kggD8S+QREAZFgIkFn3oLvTrxOlJcSymDigqeu2TudnPG79AIe o2USRdJISDydlgtnNdpoY4O21J2EUlKxZODlCp0mjsQCU8VAVuYE1jwkL984Mho0iLTF1SDZ nmtlp4nmBEBSqchWC3+HoWuVdZsEjt4+Dd1pQbFJvD4woWA6H00nYpJg6ESvYqd4N9Xk7TXd ceGyIVLx/LJfdHc64TuiL/wZcNr6XYVirT981hXp1DtA5Lq94bOoCidH7rzPGiD9FxnEqR87 U+7eTqb94mV63fmIy17LuPSl8bG4Q3UBB/BqGYr/9KEX6LMqRLBzuoMlFunZrAQz27FRmbnu 26zrN1yb9wBWM/AmRPefA8eF2aS6xrUnwzowQbGFCRJqhKyFDZeh7V0/GXXtzsiwhC1a5KWH CErHfpKgmFeHm5+KxvkLwhB1yIBvdgHbnPGWFbrY4WMckq35xV7PeTRD+M+XspVINoYUV9ff IEDMQusZOXXYrkG51tJ45fEABUwFDgHqWNc1bx0OXW/LIS7Gk1+JPCW9TNxXQShJaG5PfxI0 0kRQOQZzHIBzG2QSi7RlJNDhznRSaRquRa6z04QVzGKxaNL0ikLqbMS+HJvuAPm00U2HqUf3 vMHq0aT34D29BcAgY95UAhun1IPTaAx/flfQTNXT00NNBlATdE9G4DQcL15YwSGRxlDoIRlQ Jz9ATy8WwIVWZSwkXK/kbePRgZzulLjg0acLKIZOw40kW8GlI0xUoIkA4Q6yDOpiVakGZF/h 9WwS9f25GIkbpBcDZTiQc9XtbtvIMugMrcFw3hxcg+RkTJgLbSc+ggEDxIivy84nq8NUZkOG bke86jh1Y0qfYYWWuFg95n00AYTa4TSp1m1jzf9+ELo2RP8L8llDa2meAQA= --zr5pbx2z7ygcviri--