From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752349AbdHSX2P (ORCPT ); Sat, 19 Aug 2017 19:28:15 -0400 Received: from mga11.intel.com ([192.55.52.93]:59285 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752025AbdHSX2O (ORCPT ); Sat, 19 Aug 2017 19:28:14 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.41,399,1498546800"; d="gz'50?scan'50,208,50";a="302206620" Date: Sun, 20 Aug 2017 07:27:46 +0800 From: kbuild test robot To: Al Viro Cc: kbuild-all@01.org, linux-kernel@vger.kernel.org Subject: fs/binfmt_flat.c:828:9: error: void value not ignored as it ought to be Message-ID: <201708200743.fQ3pQK7z%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="zhXaljGHf11kAtnf" Content-Disposition: inline User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: fengguang.wu@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --zhXaljGHf11kAtnf Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Al, FYI, the error/warning still remains. tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master head: 58d4e450a490d5f02183f6834c12550ba26d3b47 commit: 468138d78510688fb5476f98d23f11ac6a63229a binfmt_flat: flat_{get,put}_addr_from_rp() should be able to fail date: 7 weeks ago config: m32r-mappi.nommu_defconfig (attached as .config) compiler: m32r-linux-gcc (GCC) 6.2.0 reproduce: wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross git checkout 468138d78510688fb5476f98d23f11ac6a63229a # save the attached .config to linux build tree make.cross ARCH=m32r All errors (new ones prefixed by >>): In file included from include/linux/kernel.h:13:0, from fs/binfmt_flat.c:20: fs/binfmt_flat.c: In function 'load_flat_file': include/linux/kern_levels.h:4:18: warning: format '%ld' expects argument of type 'long int', but argument 2 has type 'u32 {aka unsigned int}' [-Wformat=] #define KERN_SOH "\001" /* ASCII Start Of Header */ ^ include/linux/printk.h:136:11: note: in definition of macro 'no_printk' printk(fmt, ##__VA_ARGS__); \ ^~~ include/linux/kern_levels.h:14:20: note: in expansion of macro 'KERN_SOH' #define KERN_DEBUG KERN_SOH "7" /* debug-level messages */ ^~~~~~~~ include/linux/printk.h:339:12: note: in expansion of macro 'KERN_DEBUG' no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) ^~~~~~~~~~ fs/binfmt_flat.c:577:3: note: in expansion of macro 'pr_debug' pr_debug("Allocated data+bss+stack (%ld bytes): %lx\n", ^~~~~~~~ >> fs/binfmt_flat.c:828:9: error: void value not ignored as it ought to be ret = flat_put_addr_at_rp(rp, addr, relval); ^ vim +828 fs/binfmt_flat.c 506 507 /* 508 * Check initial limits. This avoids letting people circumvent 509 * size limits imposed on them by creating programs with large 510 * arrays in the data or bss. 511 */ 512 rlim = rlimit(RLIMIT_DATA); 513 if (rlim >= RLIM_INFINITY) 514 rlim = ~0; 515 if (data_len + bss_len > rlim) { 516 ret = -ENOMEM; 517 goto err; 518 } 519 520 /* Flush all traces of the currently running executable */ 521 if (id == 0) { 522 ret = flush_old_exec(bprm); 523 if (ret) 524 goto err; 525 526 /* OK, This is the point of no return */ 527 set_personality(PER_LINUX_32BIT); 528 setup_new_exec(bprm); 529 } 530 531 /* 532 * calculate the extra space we need to map in 533 */ 534 extra = max_t(unsigned long, bss_len + stack_len, 535 relocs * sizeof(unsigned long)); 536 537 /* 538 * there are a couple of cases here, the separate code/data 539 * case, and then the fully copied to RAM case which lumps 540 * it all together. 541 */ 542 if (!IS_ENABLED(CONFIG_MMU) && !(flags & (FLAT_FLAG_RAM|FLAT_FLAG_GZIP))) { 543 /* 544 * this should give us a ROM ptr, but if it doesn't we don't 545 * really care 546 */ 547 pr_debug("ROM mapping of file (we hope)\n"); 548 549 textpos = vm_mmap(bprm->file, 0, text_len, PROT_READ|PROT_EXEC, 550 MAP_PRIVATE|MAP_EXECUTABLE, 0); 551 if (!textpos || IS_ERR_VALUE(textpos)) { 552 ret = textpos; 553 if (!textpos) 554 ret = -ENOMEM; 555 pr_err("Unable to mmap process text, errno %d\n", ret); 556 goto err; 557 } 558 559 len = data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long); 560 len = PAGE_ALIGN(len); 561 realdatastart = vm_mmap(NULL, 0, len, 562 PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE, 0); 563 564 if (realdatastart == 0 || IS_ERR_VALUE(realdatastart)) { 565 ret = realdatastart; 566 if (!realdatastart) 567 ret = -ENOMEM; 568 pr_err("Unable to allocate RAM for process data, " 569 "errno %d\n", ret); 570 vm_munmap(textpos, text_len); 571 goto err; 572 } 573 datapos = ALIGN(realdatastart + 574 MAX_SHARED_LIBS * sizeof(unsigned long), 575 FLAT_DATA_ALIGN); 576 577 pr_debug("Allocated data+bss+stack (%ld bytes): %lx\n", 578 data_len + bss_len + stack_len, datapos); 579 580 fpos = ntohl(hdr->data_start); 581 #ifdef CONFIG_BINFMT_ZFLAT 582 if (flags & FLAT_FLAG_GZDATA) { 583 result = decompress_exec(bprm, fpos, (char *)datapos, 584 full_data, 0); 585 } else 586 #endif 587 { 588 result = read_code(bprm->file, datapos, fpos, 589 full_data); 590 } 591 if (IS_ERR_VALUE(result)) { 592 ret = result; 593 pr_err("Unable to read data+bss, errno %d\n", ret); 594 vm_munmap(textpos, text_len); 595 vm_munmap(realdatastart, len); 596 goto err; 597 } 598 599 reloc = (u32 __user *) 600 (datapos + (ntohl(hdr->reloc_start) - text_len)); 601 memp = realdatastart; 602 memp_size = len; 603 } else { 604 605 len = text_len + data_len + extra + MAX_SHARED_LIBS * sizeof(u32); 606 len = PAGE_ALIGN(len); 607 textpos = vm_mmap(NULL, 0, len, 608 PROT_READ | PROT_EXEC | PROT_WRITE, MAP_PRIVATE, 0); 609 610 if (!textpos || IS_ERR_VALUE(textpos)) { 611 ret = textpos; 612 if (!textpos) 613 ret = -ENOMEM; 614 pr_err("Unable to allocate RAM for process text/data, " 615 "errno %d\n", ret); 616 goto err; 617 } 618 619 realdatastart = textpos + ntohl(hdr->data_start); 620 datapos = ALIGN(realdatastart + 621 MAX_SHARED_LIBS * sizeof(u32), 622 FLAT_DATA_ALIGN); 623 624 reloc = (u32 __user *) 625 (datapos + (ntohl(hdr->reloc_start) - text_len)); 626 memp = textpos; 627 memp_size = len; 628 #ifdef CONFIG_BINFMT_ZFLAT 629 /* 630 * load it all in and treat it like a RAM load from now on 631 */ 632 if (flags & FLAT_FLAG_GZIP) { 633 #ifndef CONFIG_MMU 634 result = decompress_exec(bprm, sizeof(struct flat_hdr), 635 (((char *)textpos) + sizeof(struct flat_hdr)), 636 (text_len + full_data 637 - sizeof(struct flat_hdr)), 638 0); 639 memmove((void *) datapos, (void *) realdatastart, 640 full_data); 641 #else 642 /* 643 * This is used on MMU systems mainly for testing. 644 * Let's use a kernel buffer to simplify things. 645 */ 646 long unz_text_len = text_len - sizeof(struct flat_hdr); 647 long unz_len = unz_text_len + full_data; 648 char *unz_data = vmalloc(unz_len); 649 if (!unz_data) { 650 result = -ENOMEM; 651 } else { 652 result = decompress_exec(bprm, sizeof(struct flat_hdr), 653 unz_data, unz_len, 0); 654 if (result == 0 && 655 (copy_to_user((void __user *)textpos + sizeof(struct flat_hdr), 656 unz_data, unz_text_len) || 657 copy_to_user((void __user *)datapos, 658 unz_data + unz_text_len, full_data))) 659 result = -EFAULT; 660 vfree(unz_data); 661 } 662 #endif 663 } else if (flags & FLAT_FLAG_GZDATA) { 664 result = read_code(bprm->file, textpos, 0, text_len); 665 if (!IS_ERR_VALUE(result)) { 666 #ifndef CONFIG_MMU 667 result = decompress_exec(bprm, text_len, (char *) datapos, 668 full_data, 0); 669 #else 670 char *unz_data = vmalloc(full_data); 671 if (!unz_data) { 672 result = -ENOMEM; 673 } else { 674 result = decompress_exec(bprm, text_len, 675 unz_data, full_data, 0); 676 if (result == 0 && 677 copy_to_user((void __user *)datapos, 678 unz_data, full_data)) 679 result = -EFAULT; 680 vfree(unz_data); 681 } 682 #endif 683 } 684 } else 685 #endif /* CONFIG_BINFMT_ZFLAT */ 686 { 687 result = read_code(bprm->file, textpos, 0, text_len); 688 if (!IS_ERR_VALUE(result)) 689 result = read_code(bprm->file, datapos, 690 ntohl(hdr->data_start), 691 full_data); 692 } 693 if (IS_ERR_VALUE(result)) { 694 ret = result; 695 pr_err("Unable to read code+data+bss, errno %d\n", ret); 696 vm_munmap(textpos, text_len + data_len + extra + 697 MAX_SHARED_LIBS * sizeof(u32)); 698 goto err; 699 } 700 } 701 702 start_code = textpos + sizeof(struct flat_hdr); 703 end_code = textpos + text_len; 704 text_len -= sizeof(struct flat_hdr); /* the real code len */ 705 706 /* The main program needs a little extra setup in the task structure */ 707 if (id == 0) { 708 current->mm->start_code = start_code; 709 current->mm->end_code = end_code; 710 current->mm->start_data = datapos; 711 current->mm->end_data = datapos + data_len; 712 /* 713 * set up the brk stuff, uses any slack left in data/bss/stack 714 * allocation. We put the brk after the bss (between the bss 715 * and stack) like other platforms. 716 * Userspace code relies on the stack pointer starting out at 717 * an address right at the end of a page. 718 */ 719 current->mm->start_brk = datapos + data_len + bss_len; 720 current->mm->brk = (current->mm->start_brk + 3) & ~3; 721 #ifndef CONFIG_MMU 722 current->mm->context.end_brk = memp + memp_size - stack_len; 723 #endif 724 } 725 726 if (flags & FLAT_FLAG_KTRACE) { 727 pr_info("Mapping is %lx, Entry point is %x, data_start is %x\n", 728 textpos, 0x00ffffff&ntohl(hdr->entry), ntohl(hdr->data_start)); 729 pr_info("%s %s: TEXT=%lx-%lx DATA=%lx-%lx BSS=%lx-%lx\n", 730 id ? "Lib" : "Load", bprm->filename, 731 start_code, end_code, datapos, datapos + data_len, 732 datapos + data_len, (datapos + data_len + bss_len + 3) & ~3); 733 } 734 735 /* Store the current module values into the global library structure */ 736 libinfo->lib_list[id].start_code = start_code; 737 libinfo->lib_list[id].start_data = datapos; 738 libinfo->lib_list[id].start_brk = datapos + data_len + bss_len; 739 libinfo->lib_list[id].text_len = text_len; 740 libinfo->lib_list[id].loaded = 1; 741 libinfo->lib_list[id].entry = (0x00ffffff & ntohl(hdr->entry)) + textpos; 742 libinfo->lib_list[id].build_date = ntohl(hdr->build_date); 743 744 /* 745 * We just load the allocations into some temporary memory to 746 * help simplify all this mumbo jumbo 747 * 748 * We've got two different sections of relocation entries. 749 * The first is the GOT which resides at the beginning of the data segment 750 * and is terminated with a -1. This one can be relocated in place. 751 * The second is the extra relocation entries tacked after the image's 752 * data segment. These require a little more processing as the entry is 753 * really an offset into the image which contains an offset into the 754 * image. 755 */ 756 if (flags & FLAT_FLAG_GOTPIC) { 757 for (rp = (u32 __user *)datapos; ; rp++) { 758 u32 addr, rp_val; 759 if (get_user(rp_val, rp)) 760 return -EFAULT; 761 if (rp_val == 0xffffffff) 762 break; 763 if (rp_val) { 764 addr = calc_reloc(rp_val, libinfo, id, 0); 765 if (addr == RELOC_FAILED) { 766 ret = -ENOEXEC; 767 goto err; 768 } 769 if (put_user(addr, rp)) 770 return -EFAULT; 771 } 772 } 773 } 774 775 /* 776 * Now run through the relocation entries. 777 * We've got to be careful here as C++ produces relocatable zero 778 * entries in the constructor and destructor tables which are then 779 * tested for being not zero (which will always occur unless we're 780 * based from address zero). This causes an endless loop as __start 781 * is at zero. The solution used is to not relocate zero addresses. 782 * This has the negative side effect of not allowing a global data 783 * reference to be statically initialised to _stext (I've moved 784 * __start to address 4 so that is okay). 785 */ 786 if (rev > OLD_FLAT_VERSION) { 787 u32 __maybe_unused persistent = 0; 788 for (i = 0; i < relocs; i++) { 789 u32 addr, relval; 790 791 /* 792 * Get the address of the pointer to be 793 * relocated (of course, the address has to be 794 * relocated first). 795 */ 796 if (get_user(relval, reloc + i)) 797 return -EFAULT; 798 relval = ntohl(relval); 799 if (flat_set_persistent(relval, &persistent)) 800 continue; 801 addr = flat_get_relocate_addr(relval); 802 rp = (u32 __user *)calc_reloc(addr, libinfo, id, 1); 803 if (rp == (u32 __user *)RELOC_FAILED) { 804 ret = -ENOEXEC; 805 goto err; 806 } 807 808 /* Get the pointer's value. */ 809 ret = flat_get_addr_from_rp(rp, relval, flags, 810 &addr, &persistent); 811 if (unlikely(ret)) 812 goto err; 813 814 if (addr != 0) { 815 /* 816 * Do the relocation. PIC relocs in the data section are 817 * already in target order 818 */ 819 if ((flags & FLAT_FLAG_GOTPIC) == 0) 820 addr = ntohl(addr); 821 addr = calc_reloc(addr, libinfo, id, 0); 822 if (addr == RELOC_FAILED) { 823 ret = -ENOEXEC; 824 goto err; 825 } 826 827 /* Write back the relocated pointer. */ > 828 ret = flat_put_addr_at_rp(rp, addr, relval); 829 if (unlikely(ret)) 830 goto err; 831 } 832 } 833 } else { 834 for (i = 0; i < relocs; i++) { 835 u32 relval; 836 if (get_user(relval, reloc + i)) 837 return -EFAULT; 838 relval = ntohl(relval); 839 old_reloc(relval); 840 } 841 } 842 843 flush_icache_range(start_code, end_code); 844 845 /* zero the BSS, BRK and stack areas */ 846 if (clear_user((void __user *)(datapos + data_len), bss_len + 847 (memp + memp_size - stack_len - /* end brk */ 848 libinfo->lib_list[id].start_brk) + /* start brk */ 849 stack_len)) 850 return -EFAULT; 851 852 return 0; 853 err: 854 return ret; 855 } 856 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --zhXaljGHf11kAtnf Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICK7ImFkAAy5jb25maWcAjFzrc9u2sv9+/gpOej+0M6eNLT/izJ18AEFQQkUSDADq4S8c RVYaTR3JV5JP2//+7oKkBUoL5XSmiY1dvPfx28UyP/3rp4i9HrbfF4f1cvH8/E/0x2qz2i0O q6fo6/p59b9RoqJC2Ugk0v4GzNl68/r3++83g110+9v14LerX3fL62i82m1WzxHfbr6u/3iF 7uvt5l8//YurIpXDOr8Z6E//dL8NRSG05LU0rE5ydiQ8qkL0WwpVS1UqbeucldD8U3QkAGO0 3keb7SHarw5dj9Hjp+urq+63RKTtT5k09tO798/rL++/b59en1f79/9TFSwXtRaZYEa8/23p Fv+u6yv153qq9BimhZ38FA3duTzjZK8vx73FWo1FUauiNnl5XLkspK1FMamZxslzaT/dDDoi 18qYmqu8lJn49O7dcV9tW22FscTuMsVZNhHaSFVgP6K5ZpVVx3WM2ETUY6ELkdXDR1nSlBgo A5qUPfoX0h/pbdn+MP6yTxlwMGJbcE2symw9UsbinXx69/Nmu1n94h2MmZuJLDk5eKmMnNX5 50pUghg9HbEigXP21lsZkcmYHIxVIOg+xV0+CEO0f/2y/2d/WH0/Xv6bKIOslFrFgpByIJmR mh4pTPMRrsAAj7UyFypNjbCdnPGyem8X+z+jw/r7KlpsnqL9YXHYR4vlcvu6Oaw3fxznt5KP a+hQM85VVVhZDI/zxCbBRXEBsgZ06x/AKa2e3JCnYZkZG8usOTsRzavInJ9IqYXIS1sD2Z8P fq3FrBSakmrTMHdTwghdU38dOArRHceGNWYZak8OivGPTymESGojhjx2JsAfEydCFqsZpwQn rmSW1LEsBtxT7HHzgz9S1+aOlFRbHCwFOZCp/XR9ezwsWdhxbVgqTnluPJsw1KoqDXk/fCT4 uFQwDNgxY5UWJBsqlSlhl/QoBoZJnOFwU9E8c5Ma0FS4YM6sSEgmsKVsTlLibAydJ84u6oQ4 I85rVYI2yEdRp0rXICvwV84K3tPcUzYDP1AiNTfcZp7OFWAZZaESYTwFKdPjL410Hn/PwSBJ 0FLtz25AY3MQRTc+SBw9M5xTS+/1dUu60LMxY2gQtOkZV2A389xQXZwAeTuqPP0XWQoaoT2b FIOfq9Oqv660smJG3pkoFb1FOSxYliaezuKi/QYxEYV1DUcJKNMLm2fSc1osmUhYacvt3Vgu 8phpLfu3Ao0iSQIiWfLrq9sz69XilXK1+7rdfV9slqtI/Ge1ATPLwOByNLSr3f5o1iZ5s6Xa mdnmgjyXzSzgAO8eTMbi3t1nFe1tTKZCBBbXKVgotFq1Bg+mcpIxB2RUwympaV0VqF2SZaAT 9GHAiVqR1wmzrAa8IFMJugyggT45rVKZgUuhYBYiBNVw9PTTEe5vY0A/sI5hgXaFo5uh7hwd 4ZTBqYJnr0um4c47cNNXeTDvYOa0soKDjSOGylVSZeBRQWGd3KMhOl5HObQsBlSVwR2COA1O luvWMWJmRB4DwtS4AjdZSspsgfMFMCpSOEqJAgK+/Ow83AQTvCi3ERp3IA+aNgW61eElPaU1 M8TcIalwJ9gmLAKAif2v5vDYmyM+ZW+gMVeTX78s9hAz/Nko1stuC9FDg1XOR0T+VrxEfWIP +ifXoSgA+6BoI6HhiCmLBNoii1SdmDqTow2+OhES/3raTYEn4eiCGeWZWp6qQHqwc0OmVVQl rVjT7rcdBzDPG4YPnEnHKYeXyGiR9InKeahH5rBYUJSkHgfcigteEFCBSzIyznwXArGGZ+iy OGFpz8q3fj429BI9egiBH6GCFUMt7WVAgUEjfezIwfMELJhojIsOsk1jWmWQhgelSpadSX25 2B3WGOhG9p+X1d6XdJjOSutuMpkghCHlyiTKHFk955nKXnMTgajILL+tMHT1HZNUDXgrlPKj z7Y1Eczt/5zC08/+tXURWNfhQpAW6IkLuNCrnffTu+XX/3uLW/PPF1bqEcfzuO/xO0Kcfibm RD/obt2UsnCK6UT2iHjArT72paG50N12udrvt7voABfqQq+vq8XhdbfyDrzMmMtGlNIf0rVW Rk9oT+r63Aw+XF1VtKA5DlWa8iKdjc3NgJbi47LoAPxIpwO9bokAlirKwvKRLNst9Hxz23x9 RU/r6JNE8Atk3HYA2lDhns3iGrwAgEDjpVTQS2OayctiuPySKRuvf9pegd+UxlTi7BbRQYHp uZL9YJNkuv5vmAaSDFsRU3AnmndXzX89NF0nciIT8el68OCdF6CNTFoLRl4UiWQFZVZErvQc kQaEM1d/X50M3pEBIzqq6FGdi06kgV+tHAIvzMN6DsAnHltT3C+GVzh+m6zrYk8MwF00VcKy uxCs7+ZjpSx2RB/uWCgfX8LO69LikeFBmE8f3X/eoY/mANOSRNe2gaDEKBOpbW0Vnr6fZgRR q1vw3HhIMUPQ+um6twuIEN0VjPOeDmQCTDwDg0SKwmOpFO3NH+OK8gtSs9y7vq+9C2qI3eVd Pfg0PTVwhh1kQuN3avkajhkfDeGYwMMPFfjXER1YvKE1manhoK5uaBU+Zbu/JbbUrWk0FXI4 8qLsjgBxnow1swIcQcbmXiTl7LzK4epTjelal+zoe4Mu5wQxPn0FHcNEZRC9MT0nltjyeEFD 28lFfL6sgAB3WZrGb8Sv+2j7gkhgH/1ccvnvqOQ5l+zfkQBb8+8o5/AH/PQLcLsOyWq//mMz XexWwCkh3IQfzOvLy3Z36FiwXWyeXrbrzaGHLLhE1XenQO2Cc6a9OLxZyOnvDunWXJoOXJT8 1+Vi9xR92a2f/vC9HZpUHLRjFH+vlq+HxZfnlXsdiFz0fPA6IAzPLVyblv5hts1oJnposWl+ xHYagLXDjZgGMQiyNVGWCjjPdpAcLBfl2RQMXeU9i/WWjC1Wh7+2uz8hkOlu2EMCEMqJ3naa FjCRjIqZAZbMeklo+D3EO0t1z8bg7xjc0s7fUU0Vg3JkktN42fHkcohKdmEQy6w0VnI6eICT gbCRUh9Z9I8CYQHafM4MfSnA0GHjWsPNCSqsB6ay8HGt+71ORrw8mQyb0YvQSKJl0EzTdNyX LOUl4lCjbcorOlhueGpbFRBSB1IvBYiaGstADrYZYWJlkFolFydAllTRcARvp2aB/AbSRACC yWZZGFGG6U5yLqzMMZ3Tz4bIET9YzQqDT37+W1qfw40UJMdCnPZFJTtpsrzsmvvrxFM+Vco+ h2bTH3AgFYTFWK1oZcTZ4cfhpfDwjYdXsfQeILqIqqNDSPX6Zb181x89T+5CWQKQsvuQBOGD J0S8PGeaTlPh9koLM2fMGJnS2+sGAkDmwCxYlbw8SST6zKnMbMC0gVIlnAe12vCAxuskkP4I PSIyS8OgbBCYIdYyGVJA1TkjJwaG9d6smyZysEnGivrhanD9mSRDAAW96fVlgdhKloG8nmUZ fbezwR09BSvpTE05UqFlSSEE7ufuNihGDtrR2+WBzBBcEnM5FZKsSlFMzFRaTlu6iVHon4P2 N5PFOKzZeZnRPUeGFl23R7eaRNALRo7sBsIlYzHgu8BVcENln505mmEwM0ff7xnF+HN2gmGi w2p/OMnIOm0eW0DhAViVa5ZIRcfujO4kdULLeCDHxlLYgg5pZVqPOa2YYF0FxELnmb2WPpVY 2WF6wSZPhyiU17SYy/iM2BxW12uzWj3to8M2+rKKVhtEwU+IgKOcccfg4ea2BQGVe1qAllkb tx1nnEpopc1XOpaBHDDe2UfaJHEmU5ogylEdyrcWaaCswoDVzgIPyggLUpqWTS9ggcRARHUa K3fBoFaw0ubBr281xQR1k0p2sLl782k5OpFPVv9ZL1dRslv/p8mWHit41su2OVKngL5qnvhG IiuFV6/UawZ5s6NeyQ5MbfMypfLocPlFwjLlpzUhrHTDpVLnU4hqmioDL5MyddGZv4A3Vlm0 jzb+szUApjeO3sLeRnKBQ7f+lGVZfPII1Smbe0XEpLoXE3n7jCv4U8tJwFW3DGKiAxC3YcDS pnaYWotcTWgpcmwMUDPvmF2BTQBbm3o0h91NpFH04t4SDWWFS5ShUgh8aGqjzbhKUyJLjNH+ k5OvXsof/irOXiePzsPSnk7R+gpGDSEwlTVsnj2oJ5eiyjL8hTa+LROHG27KZMKDg9j4jwl+ K0SQRZsReSAG1/PSquzkJeCMLdExBXjf9hEn55NrlpON7WKu7ymas7e3Vx/vvWtKtMrR5/Fk Ql8Jvo0rlDdhaRjxNkNMD1BMclH3baoTlHy9X1KSY0QBUmuwRPEmm1wNApioyvM5VpORVFHw TJkKbIRBLQgW+sCp0A5icCpvTbpHgNLl0f4tN3Wc0FHqjzd8dn/Wza7+Xuwjudkfdq/fXVXF /ttiB87ysFts9jhU9LzerKInOJH1C/7YmWj2fFjtFlFaDln0db37/hfmyJ62f22et4unqKnc 7Hjl5rB6jnLJnUo2Rr2jGQ6e8Lx5ApJ53nocaLTdH4JEjhkyYpog//bl7UHJHBaHVZQvNos/ Vngi0c9cmfyXUw+F63sb7njWfBSAYLPMPXQHiSytOuupSspDuVgFnxn8MLiffm83CvizkV1P GjqpAiLG3r1MM5MJqJLVoYozQyc63Fgnpb19YgvUQ7pLm1/K3sBArSfopf66mqmjvqsiCQWv TitpjfxcuUKccGxgRUAZATxiPEjHMLMQBXpB4B6aDX4yKgzmTiu9+hGCcrWVhdXwQ2BDAPlC 7fXEnaqreQ6sYBKytUWWB6qTmD4NiRuVQQh8NDNPff1K1mCS1l9esbrd/LU+LL9FbLf8tj6s lvjM67F3t2hHCLhsX0IAwCVK1zfgSHvp3ya5fsPvPtBR75Hh4WMgmmuHZhnjWlrQfH8ChmkS VltDoWe/d84e/YKCHikhllzkPCRW0KGeDWPRmArBqRS6Pz6IfWH9JwefqPkptO8olVaaKg13 ogMg9qQMFIQ9vryQWAP2Pbmg+Ja+l5jniA/p+DQ5IZxPJR7xHZvccVr9Lq2piCNP88nv1w+z yyPjU1dGDiwfBnezGUnKmZ6Ifo1nPslDYXyO2snqOL+8EnBoWvTGHJuHh7vrOifLOb2eBQN5 zSW5VPhRq0LlgqQ+3Hy8Ik6OzUJXVYjB1dXVJdUrg3k00HSydttbD1p0xM7+mj5DQy1AHC93 1SBehhlymxqzUpokQQRuqqKXpDZOGU/sJdFTiM/0kCpjOs2Yps/c5KanoybnH6/pHEV7pI6D f6STkDjcx+vrH4i5sSheqjevzeFQf7zPScDUTOXjyYtU01JP764DIvLGcNNnOB98JjVt+pEw IIGWv9t5AWBs3styJFNez7LhiRx5+EWqNmwNJGLnoexOWQbq+bP+c5fzj4h/f92vn1ZRZeIO 6Dmu1eqpTXYhpUspsqfFCwD2c0g4BXfSP/wmGVdPE+p0kP3NFSS5FV6JYY9m+/7Qjpqkwo+G tLlvRn2S5yYIKsdiF5p0YppPSdrInrXET5sYVSDndzxaboooEsmCJ6NZm/+iaAKBQ4hoJE0w lm63Af7HecIMoROazfn550PCpU+j6RozoD+fP7P/gmnW/WoVHb51XEdwdhSrUA7aJDQBYvOz pcjNy+shGNzIoqz6L9vYUKcpVjploSrbhgmBcyir33AYl74e5yz0vIpMObNazk6Z3Nqr/Wr3 jIWKa/xg4eviJLXQ9ldY7XtxHb+r+WUGMfkR/UQNvaM9y8ae9B2LeayYpvMe3hYurx+rFuio sGFxnwAEHqsaBlXxkQGYE3gNaVdyUkVyjHhzeetix3Orutg9uUSGfK8ilC4vwDBC+1++uF/x z/YF3EsSIQGMfGkCntYxaDa9QG3jh8tDADUPfULQDqN5cIzKsdApWJYLMsvEvy12iyX6kWN2 rAsf7dw/hQmFxLGO5uNDXdq5h68yMWR8Hmxs04aDu/v+5liGVWRN3j4gkEU9NHTc7r4jrA39 UgHq01RM+g8HY2g6z7WsduvFM2Xu2hUC9L8661VsN786wr7p7jw3kbhrx6iYtpm0ZKFlw9H/ dMxrxFQA5hLOiK5YzJyKs0fwep6ux3BezAJIpeFohfd3y4a4+P+C9YdsmtbklpyarM7KHw3i PmaoAsUGIGjNJ3q0QSlzWTcfJ1MPmKNp+91XD0d0jU2VsFQnEnQ0Rzcf+6WYbaEf+uRoSWic 95pScPcUHigCwwpDfIa/DcVaR4ZbmgGM7OCWDipk2UFFeldYexN+grIc/i8JFz/glC5gM7m+ MpCchAsjCaN+NrM5aogDiDnL8hwMYVv7zy5sd3uvV0O1ZbR83i7/JIezZX199/DQlJKHYFYb HyBQCNbmeHhr8fTkPmwBM+Im3v/mTzkspQpFG1P6ab1UUwEwfEJfakPVwgTcc0M3VVlmVOnh aJr3Pxh0DRAZ0va7oTZvkZi3ObekiwNYXtr+Ni81zJQi9IVly5J+uH64uqNf93yeh0FKZ5Y7 JmkfPlxkAGh8/fEyS8kfPtzcB3TR47kdXB6nsLzGhChgoNBD5xsrt/f3D/S3Jj7Phw90zVHH gwmE2w85LVZ9pvjmB8dg+OjufjYj3j/PWCf2OlQm0rFMH27uBx9Gl6+4YRIBLneWjE68TxkW DikqtDUm9r/Ma0DDdrNe7iOzfl4vt5soXiz/fIHAYNUTX0PlTGOes7Ph4t128bTcfo/2L6vl +ut6GbE8Zv5g2O1MdfLX58P66+tm6T6La0MqQpHyNDmDykcFtfgxsJGclh7sOxZ5mQU+tgRy bu9DsoBkk99d0XfL4tnd1VV4aa73HD+ACZKtrFl+c3M3q63hLAnkc5AxD+BkLYZVxoKVBJgG cMaQgtLD3eLlGwoC4SoSfe4YGS+jn9nr03ob8e3b92+/nP1DPv4gGIUQX6Q7rnS3+L6Kvrx+ /QrYIjnHFmmosI+PM/wypM54Qm3uGAEMGdaoB+pAANQnZ2sagSM4C+uhsecyZILVhQAb566w rBgGHqSAMRRjVSNJPTPi0G31yZuyolKBc8UOhHZgD3aLjz+hJdSM60AluqOWobotR60wIRQk xyIby0A9IJA52CxNP3k2ZAm/XaA7+Q2T5+Evl5EOhz9UhZaBZACyiBw8K21vHTkTPPBPKTjy 48n3DT3qUOSxDMSFjp7q8NAwsEsxhBnm4V1NIaYJlNW4iec6/A85IIPER7Qg1U5lMQrk0pql FxDWDu2FCTLuYFqYLgo1oQ2eI6uhvCjxORtKHk4DNSzzNAv9Mw6OAV8ZjEr/v7FraW4cx8H3 /RWuPc1UbT/spDPOoQ/Uw7YSvUJJtpOLKp14E1eP45Tt1Gz+/QKkJEsUQLtqptImIL4JAiT4 gXlEhBwJnt1aZoB61GIfxph5w4E0EGs+bQwiNRUxqgRhYpliqZ+L8D7mF38KCxCkKE8PBd7k x9wbH8UjWc9UJGcisDWjurXi6ag9sz4ciiP3/RANbMaPSfEUcRoyhjfSJWer4XLBQz5QMXhB lEVg998k99Yi8sAyo2G5ZpyVoOgzWWS59v1mmQrcbco0o1UhLRhs4mwZxBFfxQdfJtYG4pk+ LBl+1Ws9t5wx8DZquwnJC7EClNhk5gbd98wtr1ugV4pAN7F5cDpzO1t40dVu9fE4pFF+IJie vn7uEfJwED5+4kFIfx/G0sBMJlsWJ6miL10/oM/FkToV3pRwUlHFb/9RKtLfWOynMs0RRuKL y9WkCNOAPWkqFvQARBGjgMIuyZ6Xx/4CxDXzgEaj+QROEHLIHBL0d/U8iKR6kSD8b7V3TiSc YtJ6aNk5kioRLYauUrH0gizloMfUk299aNQvc77eQWlUn+NnQQI92FXTK1fOp912v/3vYTCD Mdt9mQ9ePlb7A6V1a79kNAZSMWXU1hz2trh/e9LcG2Tv6zd1AESZUiIInaSPySNXm+1hhR6I 1FfoeJ37Jlyd/vB9s38xF0wGjH9kCutvkLwN3Nf1+59H29DwYmyMx2zrmhmtv0ZLI/3YD0W8 DHgfVahDyWytSHpgjII0wjPaifQZz9llzppzCiqBJAWM7ZYuKD8aAUYTaC/qDUgsfw5b+eCT YXZVqyOxU553k6g/hii12uCMDXPtBs+JNTwVTJeiHI3jCE81mZchbS6QTfRVkONG5W0SC8XB l4hao8vcf0ZuX6a3Mds227f1Ybuj1p0U/cUu3p532/Vzmw3MWJkwJ4UeowKhgzf3JolOV84C Zdek1PYyOjp3jO0WEMBxiJGr92kWUO2eMI61oFH1s8An/HqStH0el/mo7KKYVUnlEj16iQkO 9Iv+J5hUoRoKlzY4a67MdwsT6unIctnP+/KsvC+5vLtMfqxeLnD2k+Lh/ExuHG/Urhv+Zpmh NpGjnj91fKV9sGcl0Ca0GLjhSUueNJ1kI47m5Jbi4iC0fDoZ8V9yQ9L0I2pz5lDqNA0sxnip K5w4pHfwbSO8pM0RzMagt+tDD21Dj5M8mLTgRjwzIdAJpYkEOhGaQPbDXZEwjuiK4ub0hEUA 1kl2yfYuPnRjaPhgBfQfg6zlwuPTq3EIl/Ve4Gmy90Um0Td8GIOS4SgYjnIsS66vrr5ztSi8 CVUDL8m+TUT+Lc65fDUUGpPrHL5l52rem416k9ivPp63CqOkJ99Q69ECpZ3QIMYedyZMdmdB 6Emfmj34FK+djUJ+7RwqFqD8h2BDcIqf/tNrQd0pQaaVXo3a2ck6kSKe+vxKFJ6FNuFpMysJ bUVWpFhq4/Aky1cuKIIMKbsrRDbj5otFKEYBgq6cIKLLcjCnILaO/R9ZOirlaXfx8tJKveKp 0lZoyoM/I3Q6u2K5yVdfE3fnX01UX3V/z0fG74uOq79KYbdqRWaQAnAHX5CukzJJ8jLurjn4 SR3CT5VrTooOE63HhbhlmD+hHt2GmKDiYKXItOsjrVL6m/5xJuPza26WB5xoc1P2m8QT/Orm RrQNpAw/aiCRn/9e77fj8Y/rL8PW42FkgGJ8lF3l5QV9mdZh+ussJua6t8M0/kFfVRtMtNVh MJ1V3BkVHzPX5wYTfa1oMJ1T8Sv6xM9gYpZMl+mcLrhiEGG6TNenma4vzsjp+pwBvmYA57pM l2fUacw8x0Im0Ghw7pfj09kMR+dUG7j4SSAyN2AAnlp14b+vOfieqTn46VNznO4TfuLUHPxY 1xz80qo5+AFs+uN0Y4anWzPkm3ObBOOSeahZk2lgLSTjOxXYmxlNoeZwfURDO8ES534h6ZOl hkkmoJ2cKuxeBmF4orip8E+ySJ+556k5AmiXiBlP2ZonLgLmwVa7+041Ki/kbcDc7iFPkU86 q/hfLaD/18en3xr7RqW+79Zvh9/q0P15s9q/UGfOVXAO9JEjdlNXe7LivaXCl212078a9d3P MhQIPY7LlmKMGkxVkGfGztCV2W7ewYj5ooLBgCH39Huvqv2k03dUzbVvG2KpUka4wnMtF0LG rWgeLUARTY8KBGrB6CItHBIFwIlf/hx+H7WagQjxKQi3qDQBxVtnHMJTGQvGebqCJIcMnIQB WtLtIpWbmY9AJ1lTY+ObzHcVGjeYVJEw4KHqNhgsuoeSOOw4oHcwSG2VVJjwC1/c1qCxtMWB l9qooEsKx1pn1SC+6JuH1Wa7+xx4q18fLy8GmpPaf/xljpf1zFGWzhIZEeyFOd3FbKCJWRKz z95VNolzA51mGyvE5beRMRpCWWScfay55vSE0UQN3Sv9KYuur/kq2GPE+KWmD75tbtUJj1Mm oQraRFW5JtuaNjOgOvRJCA7bINw+/f541+t49vj20lm8aIQUKeTSj3XRKgKJ5ayIdWQkkmlx R/oQtoY5hrkHMz6hD9069HIuwsI/hlLQRBW8qsiPyTWWu45Dc5QPKtkUSF1yL8qU8bWeK2CS 6zVu6Xqs1a3vm4CDqpOx64+LZ/DHvrpZ2/9nsPk4rP63gn+sDk9fv379sy9Ra0Rl2zTDYDpW +CORJxGu+RBqaGGrTjMx6giIpnCCcEh0turcFGZKjugvZty442xY6Lo1mVnKvtUL275O4H9Y BU6StbHB+xSzWYG15DQ4xcGElaiFQR5MAp/BHKlcvqXv+YhQ0N1k9NWnWzCSVcKSN8OPHSeo Dl2DocRsO8PJMVIZgGSxc3DZtFgQ5EpHRKtX6GhoZGKGPOtQ/bvMcpqh+xHEi97kJL+9VfNB zVDYlxRUGq2+VQNX+lKqB7Q3ejcmmauAEhSPHkWMkgfaUt7HO1SgYiqiUsY5mCoWloqOqtUz LwwzxA+Uo6LLsXQ1S+YKbN7GBrMBx5Kla2FydWlf1apJM3+JiG6WNoMSF08rmDjmPRPy3QJj ntA3o4pB6bOMwzvSnSDn3rsqelEw97GKKhFNUb3ltLSVcwLU43/LPN9ThSNUnpukDG6vqn9q aVyNxGcpoafom+MA9p2L3qLMYTpqXrGO4eUmUhb8xaUGcGTOCevgW2A4OZmIMYoVIsjRyjly EMKm8cXSrxvB1tYggsqgqB4zPn3s1odPyk5hm1jf2JYeGFHKDUKFoLLyWom0zYCb2UxI2A5A v8CBx3FXDXDxXrFzlWOy0cXpoUMehKLWS4lU7LUMO7ZTEADPNbUV6FUD7NV96+4+3w9bMAV3 q8F2N3hd/f2ugMM6zBjlQaStN/ud5FE/HSypnxsisc/qhLdukM582SfhCiQT+6wynvbKgzSS sbGhexVka3KbpkQjEdC8c21fl8HgM1dkjxYrFdV3PcqyrKiRiMHOkb2qV+lUbUzAf/JDjMii LGulIhK5TCfD0TgqqBv5igPXfa9emNjvObwUUoF2iYLUH1p011U+zSKKfObHtGVasZgbnfbt +Ti8rt4wiDWCe/lvT7g40J/mn/XhdSD2++3TWpG8x8NjWwrVlWdghutOtJPdmYD/Rt/TJLwf Xnynjxor3sy/67qMmrNoJsBMncOAaG865fm32T4beKNVwY61q9yc1kUbMnf1WlWFtt4rcihp C7gipyfqtrQXDrvDQhKQF7PH/SvfHTQSUy2AgArd2qvIiYrOjUwrKLkX0C970taV7sXIJReH y1xoHBny4XePQ3CupiGr2tSdfsYEjDz6tLwh278OYIL6If61scnIA7FzioO5VTtyjH7QdwxH jouRNY9sJob8jAAqlEDMCSD8GFrHCzjoe4laSk3lkEHFqmVpahShJ/T6/bWDQdjswZRwh1TO KbbmiAsnsK400OKsEwIMuMWEO3mvZ6+I/DBkHlQ0PFlunVrIYB1uj1FmK/JE/bUKlZl4YKJ0 1sMqwkzYp1Qt7O1Cnnn60dBlasQy7W9z1t7MF4k5KM2NwW613xsPN5sexCBKjDtSJdYfGLRZ TR5fWid1+GCdS0CeET7nj2/P280g/tj8Wu00Tnvv5WkznbOgdFNJhiWuGykdPPGNi55Soyhq G+gvJU0z5GufpZfnTYDvRjEkIdgFhChRJiWe452S3Q1jVmmzZzFL5oze5EMd3rI1Lqge8ecK BcUVCLRd9T9kBcuwP4buanfA1wCgZO0VUBzGOFPRM/W9lXEU4wSxkPfEYYE+p13/2j3uPge7 7cdh/dZGBHKCHBH0ZdYPO62s0SOdaGzt/q4C/eRB2yOmJgVJtyNc0AxhgMmec4dXJrN1C4fc 86Jk8rowLABIII91ugxh4PrO/Zj4VFO4xahYhFzwsgA5HObeFqj0xX4YOFoD4j6jNQJReBhx GMevCqdeDQd9uKbenjPd03AtHzBsjoVUOu4NeSyQlQpW5zg31AlH1AKaxCgBGPAW/ZU7h9yQ rp4b0Vcq3l0bzDVEZ/r+BKzP9DpDmkiP6QzPYwInybuSRXXOqnCaHJENWXkMCo7gKSKgDoUy fcAH9f8/QxaQN12IAAA= --zhXaljGHf11kAtnf--