From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751298AbdHFAKv (ORCPT ); Sat, 5 Aug 2017 20:10:51 -0400 Received: from mga03.intel.com ([134.134.136.65]:28211 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751214AbdHFAKt (ORCPT ); Sat, 5 Aug 2017 20:10:49 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.41,328,1498546800"; d="gz'50?scan'50,208,50";a="136026672" Date: Sun, 6 Aug 2017 08:10:14 +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: <201708060802.rd2XKXZT%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="lrZ03NoBR/3+SXJZ" 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 --lrZ03NoBR/3+SXJZ 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: 0fdd951c9bef93637d5af036851e7a5632fbd6c3 commit: 468138d78510688fb5476f98d23f11ac6a63229a binfmt_flat: flat_{get,put}_addr_from_rp() should be able to fail date: 5 weeks ago config: m32r-oaks32r_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 --lrZ03NoBR/3+SXJZ Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICL9bhlkAAy5jb25maWcAjFzbc9s2s3/vX8FJz0M787XxPc6cyQMIghIqgmAAUBe/cBRZ bjR1JB9J/tr892cXJC1SWijNTFMbu7jv5beLZX7+6eeIve433+b71WL+/Pw9+nO5Xm7n++Vj 9LR6Xv5vlOgo1y4SiXS/A3O2Wr/+8/7b9dU2uvn98ur3i9+2i8totNyul88R36yfVn++QvfV Zv3Tzz9xnadyUKnrK/Ppe/vbQOTCSF5Jy6pEsQPhQeei35LrSupCG1cpVkDzz9GBAIzRahet N/tot9y3PYYPny4vLtrfEpE2P2XSuk/v3j+vvrz/tnl8fV7u3v9PmTMlKiMywax4//vCL/5d 21eaz9VEmxFMCzv5ORr4c3nGyV5fDnuLjR6JvNJ5ZVVxWLnMpatEPq6YwcmVdJ+ur1oiN9ra imtVyEx8evfusK+mrXLCOmJ3meYsGwtjpc6xH9FcsdLpwzqGbCyqkTC5yKrBgyxoSgyUK5qU PXQvpD/S27K7w3SXfcyAgxHbgmtiZeaqobYO7+TTu1/Wm/Xy187B2Jkdy4KTgxfaymmlPpei FMTo6ZDlCZxzZ72lFZmMycFYCYLepfjLB2GIdq9fdt93++W3w+W/iTLISmF0LAgpB5Id6smB wgwf4gos8DgnldBpaoVr5YwX5Xs33/0V7VffltF8/Rjt9vP9LpovFpvX9X61/vMwv5N8VEGH inGuy9zJfHCYJ7YJLooLkDWgu+4BHNOq8TV5Go7ZkXXM2ZMTMbyM7OmJFEYIVbgKyN354NdK TAthKKm2NXM7JYzQNvXXgaMQ3XFsWGOWofYoUIzvXUouRFJZMeCxNwHdMXEiZHGGcUFuPy5l llSxzK9oyZOj+gdSVbF7CncvU/fp8uZwQDJ3o8qyVBzzXHfswMDosrDkpHwo+KjQMAzYLuu0 odeOimQL2Bk9ioVhEm8s/FQ0z8ymFrQTLpUzJxKSCewnm9Gnl42g89jbQpMQZ8R5pQvQAPkg qlSbCuQD/qdYznvaesxm4QdKjGaWu6yjZzlYQ5nrRNiOUhTp4ZdaIg+/KzBCEjTTdGe3oKUK xM+PD1JGzwzn1NB7ff2SzvSsTRcaAWN7BhXY7UxZqosXoM6Oyo7OiywFLTAdOxSDb6vSsr+u tHRiSt6ZKDS9RTnIWZYmHT3FRXcbxFjkzjccJKBIz2yeyY6jYslYwkob7s6NKaFiZozs3wo0 iiQJiGTBLy9uTixWg1GK5fZps/02Xy+Wkfjvcg2mlYGR5Whcl9vdwZSNVb2lypvW+oI6bpo5 8P2de7AZi3t3n5W0h7GZDhFYXKVgldBSVQa8llYkowI0VMEp6UlV5qhdkmWgE/RhwIk6oaqE OVYBRpCpBF0GoECfnNGpzMCNUNAKUYGuOXr66Ql3NzEgHljHIEe7wtG1UHeOzm/C4FTBm1cF M3DnLaDpqzyYdDBzRjvBwcYRQymdlBl4UVBYL/doiA7XUQwciwFJZXCHIE5XR8v16xgyO6Tt OkDTuATXWEjKbIHDBQAqUjhKiQIC/vvkPPwEY7wovxEaayAPmjYNutViJDOhNTPE3KKncCfY JiwCwIj7V3N02OsjPmav4TDX49++zHcQJ/xVK9bLdgMRQ41PTkdE/ka8RHVkD/on1yInAPig aENh4IgpiwTaIvNUH5k6q9AGXxwJSfd6mk2BJ+HoghnlmRqeMkd6sHNNplVUJ41Y0+63GQdw zhtuD5xJy9lHGcdktEjmSOU6SEcqWCwoSlKNAm7FBywIosAlWRlnXRcC8UXH0GVxwtKelW/8 fGzpJXboIdR9gApODIx05wEFBor0sSMHVwlYMFEbFxNkm8S0yiAND0oXLDuR+mK+3a8wuI3c 95flrivpMJ2Tzt9kMkYIQ8qVTbQ9sHacZyp7zXXUoSO7+LrEcLXrmKSuwVuudTfibFoTwfz+ Tyk8/dy9tjbqajucCcwCPXEBZ3o18356t3j6v7dYVX0+s9IOcTSL+x6/JcTpZ2JO9IP+1m0h c6+YXmQPiAfc6kNfGuoL3W4Wy91us432cKE+3Hpazvev26PLzZjPQfT9QZ9cWjMOU9X11YeL i5KWOc+hC1uUlKWrqWxk6zQKsSg66D7Q6eCuXReApcC6+FAWzcopP9hQLy+uer4bm8eJ4PSq PBn3Shkh8LuK2iV6ELANF7IfAZJMl/+G6UqSsSQ6fe5l57r504O7VSLHMhGfLq/uOxsCOJBJ 58AKizyRLKf0XihtZggFIN64+Ofi8sL/OSYDiEPqxX2P6n1oIi386uQAeGEe1rPQXeKhNcX9 YvyD4zcZtDY4xKjYhzsFLLuNkfp+ONbaYUd0sp6FcsIF7LwqHB4ZHoT99NH/6Rz6cAY4KklM 5WqMSIwylsZVTuPpd3N/SpVVg25rFyamiCo/XfZ2ASGcv4KR6glhJsAGM7AYpCg8FFrT7vYh LinDLQ1Th+u7eOpdUE1sL6++3LccxMTCGbaYBq3TsWmqOaZ8OIBjAhc80OAAhzTyf4NTMtOD q6q8pnXsmO3uhthSu6bhRMjBsBMGtwQIxGRsIPAHSw0xfifU8YZYK7j61GAO1Wcj+ua6TQRB EE5fQcsw1hmEV8zMKMtX83RQfdPJh2RdWQEBbtMotWGPX3fR5gVd9S76peDyP1HBFZfsP5EA K/OfSHH4C376Fbh9h2S5W/25nsy3S+CUEA/CD/b15WWz3bcs2C7Wjy+b1Xrf8w5cour7UwgE pJz1MyC+u/hnuXjdz788L32uPfJx6b7j6RHgKgfnbWT3FJpm1O8eDqubH7CdhjbNcENm4P6C bHX8ogM+oRlEgcmhfIKGoUvVMzVvqc18uf97s/0LQoT2ajqJQwiSRG87dQvYNkZFo+Dwp72U Lvwe4p2mpmcc8HcMG2lw6Km2jEGqM8lpJOp5lBygdpwZxEGkbZ3kNCyHk4GAjJJ7mfePAv0s GmvOLH0pwNCizsrAzQkqYAamIu8iRv97lQx5cTQZNqP5p9OCDYNhhqbjvmQhzxEHBo2KKukw tOapXJlDsBpIauQganokA9nNeoSxo+EaUsvk7ATIkmoaR+DtVCyQOUCasIGDq5eFsVqY7iXn zMo80yn9ZAiFjt8Zllt8QOu+TPU5/EhBcizEcV9UsqMmx4u2ub9OPOVjpexzGDb5AQdSQVis M5pWRpwdfhycC7zeeHgZS95BTk2s0tIhWHn9slq864+ukttQ/A1SdheSIHw+hFiSK2boBBBu r3Awc8Yg6E7p7bUDAZLyKBSsiiqOUnRd5lRmLmDaQKkSzoNabXlA400SSCyEnuSYo/FLdhWY ITYyGVAI0zsjLwaW9V6A6yZysHHG8ur+4uryM0mG0AR60+vLAlGLLAIZM8cy+m6nV7f0FKyg cyDFUIeWJYUQuJ/bm6AYeUxGb5cHci5wScxnK0iyLkQ+thPpOG3pxlajfw7aX4jGR2HNVkVG 9xxaWnT9Hv1qEkEvGDmya4hzrMNI7QxXzi2V1/XmaIpRyAx9f8coxp+zIwwT7Ze7/VGu02vz yAF8DsAqZVgiNR0VM7qTNAkt44HsFUthCyaklWk14rRignUVEMSc5swa+kRinYTtRYk8HaBQ XtJiLuMTYn1Yba/1cvm4i/ab6MsyWq4RBT8iAo4U456hUz/StCCg8kl7aJk2AddhxomEVtp8 pSMZyK7inX2kTRJnMqUJohhWoUxmngaKFCxY7SzwVIuwIKVp2eQMFkgshELHQW4bxRkNK62f 0vpWU4xRN6ksBZv515SGoxX5ZPnf1WIZJdvVf+s85KEeZrVomiN9DOjL+vFsKLJCdKp/es0g b27YK4CBqZ0qUipDDZefJyzT3YQhxIN+uFQaNYGopn6x7yX+Jj7HTwp1/YSGGeVO2NJZSlzC 30aOA960YRBjE0ChNQPW8jTDVEYoPaYv2rMxALa8ZfYVJQH4a6vhDA5wLK2mF/cWxBclLlGG 6gDwlaUJCOMyTYkUKUbSj14EeilR+F9+8jR3sO+OdkaaVimwO4hSqYxcnfOn3hvyMsvwF9o+ NkwcbriuCwkPDhLSzaR3WyHIy5tswz0xuJkVTmdHafATtsTEFCZ920ecnE5umCIbm8Vc3lE0 bxJvLj7eda4pMVqhW+LJmL4SfBjWKG/C0Z7+bYaYHiAfK1H1zZ4XFLXaLSjJsSIHqbVYk3ed jS+uArClVGqG5VMkVeQ807YEjbeoBcEqFzgV2oZfHctbnZERoHQq2r3lfQ4Tekr18ZpP7066 ueU/810k17v99vWbLynYfZ1vwZ/tt/P1DoeKnlfrZfQIJ7J6wR9bK8qe98vtPEqLAYueVttv f2P+6XHz9/p5M3+M6lLFlleu98vnSEnuVbK2uy3NcnBWp81jkMzT1sNAw81uHyTy+faRmibI v3l5e02x+/l+Gan5ev7nEk8k+oVrq349diK4vrfhDmfNhwGUNM38K2+QyNKytZ66oJyIDycw hd+NVPup7WajABFr2e1IQytVQMTwuJfFZTIBVXImVG5l6VyEH+uolrVPbLB0SHdp80vZGxio 8QS97FxbMHTQd50nofjSayWtkZ9LX4UShu9OBJQR8B2GbHSYMQ1RoBfE1qHZ4Cerw3jruMyp D+K1LybMnYEfAhsCVBZqr8b+VH2Rb2AF45CtzbMjT1XrBULRgy157CtRsgK7s/ryijXb9u/V fvE1YtvF19V+ucCHzA57e1VuiHUgri8GAKQSbQAUMW6kAx3sygTDnAKrnKWgZre3Yg/dd+0u CQQkd5LRRMOPcWpLKY02VNWwP2RAdkfVgiAW8fk1xgYAIWCCnszf0KF1zBUiKTrYSo4Ip1OJ B3zuJHeMLyYZTbm/up1OSZJiZiz6tXxqrEJBpUJBZFWszi8SbLcRvTFH9v7+9rJSZNlep2fO QCCUJJcKPxqdayVI6v31x4v+hV9d9B+ZD4bFDTX11NAZDU0PgrzuiJ+hoRIgDee7Grhdyyy5 SIMZDkOSIJqzZd5LeNrpIBbHIIroKcRnekidMZPCf/SJWWV7KmIV/3hJx7vI+vGyTyQGdHjx ujemU3BgP97DOKDFE/lw9HJRt1ST28vA7b4xXJM1Bt31znLw6bNePJtMeDXNBke33HGDUjfR TyDlNgvF8UURqInO+g8b3gIjjPptt3pcRqWNW7zguZbLxyatgZQ2ecQe5y+A+06RxQScXf/4 6rRLNUkoNIPsb3YyUU50yrR6NNc35m5Yx6Y/GtKpronqkjo2lKByrEegSUdm75hkrOxZIvwk hFGlIt2OB6tIEUUiWfBkDGsyHRRNoNcLEa2kCdbR7S7A/zBLvPmp4w+fB4smK0xl/XL6Xvor 5st2y2W0/9pyHbz7QWpCyUSb0ASI4E5kWq5fXvdBCCzzouw/UWJDlaZYa5KFChFrJoRXofRs zWF9HnKkWOidDJkUc0ZOj5n82svdcvuMtVwrrOl+mh8FoE1/jQWRZ9fxh56dZxDjH9GPtKxz tCdptaO+IzGL9VHZALWF8+vH52c6dqhZfJV04NWhZtAlH1pACIG0drOSo3KAQ1yk5I2PME6N JoSXPtyV73WE0tVBqBDUdz8O8L/i381TZieVgASw4YWl321qBsMmZ6gNtj0/BFBVqMq6Gcbw 4BilZ6ETdUwJMhfBv8638wW6iUMOpQ0y3Kx7CmMKhWJBxMf7qnCzDrjJxIDxWbCxSS5d3d71 N8cyrOOpE7ABgcyrgaWjO/95VWXplDOoT12z1s0Aj6DpNCJfblfzZ8rcNSsE1Hxx0ivfrH/z hF3d3TtmIr3TjFEyA8G2I0vdao7+1zWdxqqJOE+IWNAI29dBQqfn8Xos5/k0AERqjkZ4/3Bs gIv/F6w/ZDO0Jjfk1GZVVvxoEF/vXQZejUHQ6q+YaINSKFnV32xSSfvhpPk0pgcT2sa6TlPq Iwk6mKPrj3d0pOcLEcLJfsfhv4Jwk1eckicZ+GLQBiqILWyaJAz7eaO6Dq2w1JxFcfqZJrY1 X3RvtrtOr5rqimjxvFn8RQ7niury9v6+Log9TZXWUKWB0Ohsg4UKHcwyf3z09fOgin7i3e/d KQeF1CFAPqHfGQs9EYBUx7So1VQjbMDF1XRbFkVG1WENJ6r/XZJvgPCHtoE1tX71wbj/1BrN 92C9aBtW58SZLUToQ66GJf1weX9xS7+jdHnur1I6h9cySXf/4SwDwMvLj+dZCn7/4fqODu26 PDdX58fJHa8wKwU4IvSk9MbK3d3dPV3S3uX58IEuwGh5MEq++aBoseozxdc/OAbLh7d30ynx 0nTCOnaXoTfzlmVyf3139WF4/oprJhHg8mfJ6BTnhGEVhaaiP2vj7gdAtePdrFeLXWRXz6vF Zh3F88VfLwCulz3xtVTOLeaKnQwXbzfzx8XmW7R7WS5WT6tFxFTMuoNhtxPVUa/P+9XT63rh v75pwhJCkVSanMDNg4I6/ObQSk5LD/YdCVVkgW+6gKzcXUgWkGzV7QV9tyye3l5chJfme8+w jD9IdrJi6vr6dlo5yyH6DjOqANY0YlBmLPhmi5GyN4YUHB1s5y9fURAIV5GYU8fIeBH9wl4f V5uIb94+s/n15N8I6Q6CSJ748NVzpdv5t2X05fXpCRBxcvqqmIaqnPgow/r2KuMJtbkDih4w LNgNvLgDMD4t4B6CIzgJjaGx5zJkgqVWAL1mvsomHwRS/8AYilPKoaQedHDo5p3/TVlRqcC5 YgdCO7AHu8HkfmgJFeMmUJbrqUWoiMVTS8yZBMmxyEYyUBwFZA42y9CPSzVZwm9n6F5+w+RZ +ANJpMPhD3RuZCCgRhahwLPS9taTM8EDX2x78sNRsXePOhAqloHYytNTEx4aBvZhephhFt7V BOKCQAGDn3hmwt+LI4PER5gg1U1kPgzko+ql5xAaDtyZCTLuYVqYLnI9pg2eJ+uBPCvxig0k D6dSapZZmoW+FvcMmEq3Og18UYEcGtObZyTAV/ifv8Y8UNCONDBrgg6okFqwHCFBps+IWCEc y2Z5WPkLUECwomF6xvDNNA998OB5TLBMD8mWyXPbaJ5dwnREz8HXcs/hhMgwSA1UjHieMi+y QPCKdBOK1VBdMFEGECNsiKyC2PkPPTs7hZNnJBrU1YaiBE8fmtK6uhA2yFSit6kKS0Oh2jCc M2dTmavwEh+E0Wc3iGlvUJmw1tc4txoG/hUN724yssajBBCrh1z2v8rslCACvQEC/ca3z+aG vOfCyz66rVPM0EY9xmN78fX7Dv81tSibf8f03akfxtkgTKYzabrw9CkXks4tI3XAkoE4RWl+ +s3fHiI947TffWiOX6v/xkMrKbNCBrM15YS+gP9v7Eqa29hx8H1+hWpO71VNFsmOIx9yYG9W x72Z3W0puXQ5tsZWZWS5JLlm8u8HIHtlA5Sq3itHBJorSIIg+CGOGQUUdknW5pz4S1iumdcE GjQkdMKIAwCQoL+rtxIk1YsF4emoXSRi4ZRB79VZp9ihwyWCUtBVKldemGccwpF6uKqNRuMy 7zd7KI3qc/wsTKEHh2p67TT3uN8ddv8+ThYwZvsP95Pn9/XhSGnd2gMUDwOZuGHU1gL2tmR8 A9Ha3vO3zasyAFFHKRFGTjqG/pDr7e64Rl8v6it0cS3QWW7sECjftodnc8LkwPhXrmDEJunr xH3ZvP3dnQ0Nf7H28JjvXDOjzcd4ZaR3/VAmq5D3BoQ6VMzWiqSfzKEgi9HOGUif8VFcFexx Tj34Jkkhc3bLlpQbh4BDE2gvyiE+kd+mvXzw/SQ7q5VJ7JSPUxCPxxBXrT7uW8vcOBxzyxpa BbOVqGbzJEarJuMm3+eCtYm+TnHcuLpNE6E4+BJRa3SZO8TYHa/pfWio7e51c9ztqXknxXiy i9en/W7z1GeDY6xMGUuhx6hA6ErLPdCg09V9ejU8UurzMrqUDg7bvefM3RAj1+jTPKTaHTAu jKBRjbPA98xaSPqOZ6tiVg3BkuqkaoW+k9w0uqgCWoyBdsnRpA9nOQlZM/TvPGnFk26CfMbR nMJSXBJGlk+DGf8lUDROnHApfyx/hZqM2as6TWP3ML6wCooJ6QPYyBgv+QqEozDo/fr4iXJ9 D0mv+iBP0iIMeoABnpkQ6oTKBNsLhCaQ/XBXpoy7q6K4BW15QIzDIGfFJMAXLwwN3eJh7zfI ek48PL4YBqh89BRHk70PMo0/ofs9zopuUnRzOE+vr64+c7UovYCqgZfmnwJRfEoKLl+NNsTk eg/fsrJajKRRL5CH9fvTToEVjOY27vh6bvcTWlDGblXGZHcRRp70KelBiLJ+NgpccWBQK0Hx jUB/5pQe/WfUgqZTwlwrfBoYb5B1KkVy4/MzUXgWWsDTFlYSnpPYJcVSG4cnWb5yQQliSPld KfIFJy+WRTEOEX3hBBG9RUFTJkByuv6PLR2V8bS7ZHVppV7xVGkrNOPxVRGRmJ2xnPA1V6RD +WuI6qvh7/uZ8fti4DWrUsx9YUhmngwjYOmS9KyTaVpUyXDOwU/KAH2jXDsyvHDvPWHCLcP8 CfUYNsTE6gUNXWZDB1eVMnZU7CQZ32FyUh5yS5ubsd+knuBnNzeifaxS+NEgCnz75+awm8+/ XH+Y9p43IgMU4+PaVV1e0BdJA6avZzExV50DpvkX+prWYKI1boPprOLOqPicuTo2mOgrNYPp nIpf0dYug4mZMkOmc7rgioGGGDJdn2a6vjgjp+tzBviagYwaMl2eUaf5V76fQKNB2a/mp7OZ zs6pNnDxQiByN2SQXnp14b9vOPieaTh48Wk4TvcJLzgNBz/WDQc/tRoOfgDb/jjdmOnp1kz5 5tym4bxinoM1ZBphB8n4EAH2ZkZTaDhcH2GRTrDAEbmUtFWlZZIpaCenCvshwyg6UdyN8E+y SJ+542g4QmiXSBhPy4YnKUP6umnQfacaVZTyNmRutpCnLILBLP5HD0v75eHxtwbBUKlv+83r 8bcyOD9t14dnyt5a49+jfxixm7raExLv7BRwc7ubfm3Vdz/PcUEYcVz2FGPUYOqCPBOeXldm t32DQ8wHFWMBDnKPvw+q2o86fU/VXPt1IRoidQhXiIzVUsikB5jfaQY1PS4RsQEB/DuShtDD L79NP896zUAQ5gwWt7gyMXt7Ng7hqYwF43xbo/5CBk7KIK7odpHKzcJH5IS8rbHxTe67CvAW jlSxMHBimjYYLLqH0iQaODAPUARtlVSwy0tf3Dawj/SJAy90UUGXFFSszkojYTduE/F6u9v/ mXjrX+/Pzwasi9p//FWBF9WMOVdniYwIKcFYNjEbaGKeJuzjWpVN6nyHTrONFUJf28gIOF6V OXc+1lz3tMBoogbflP4NC2Ct+WrgUkTppMQHH1v36oTmlCBSsVCoKjdkW9MWBiCAtoTgsE2i 3ePv9zc9jxcPr8+DyYuHkDKDXMZw8r0ikFgtykQHHCGZlnek/1xvmBOQPZD4lDa6DejVvYhK v0Mr10QVE6YsuuQGLlmHeujWB5VsLkhD8ih4i/G1lhU4kus5bul6rNWt75vIY6qTseu7yTP5 61DfKh3+Ndm+H9f/W8M/1sfHjx8//j1eURtMVJuYYbwKK8iKKNIY53wENbSw1dZMBPaHpSkK EHSFzlbZTUFSCsSYMMMxddKw1HVrM7OUfasntn2ewP8wC5w076P7jilms0JryVl4ioNBbm8W gyIMQp9BNqjdnaXv+fi6e7jJ6Gs/t2RWVglT3ozq0wmojg6BEXpsO8PJMVIZwMpi5+Cy6bEg lI4ONNTM0NnUyISNJKQCIN3lFmuG7kdYXvQmJ/ntrZYHJaGwLynMJFp9qweu8qVU7yu/692Y ZK4x2ykePYoYfAq0pWIMfKagi1TQkpxzrlQsLBWdNOtnQhjJgx8oRwVtYulKSu4VXLSNDaQB x5Kl68Xk6tI+q1WTFv4KcaMsbQYlLrmp8a6Y9zDIdwuMRUrfCioGpc8yzt5Id8KCey+p6GXJ 3EUqqkRYNfUW0NJWzgFOj/8t8/xLFZ6jupZmDICnqn9maVw5UuPNXobTm4t+kIypHPWqRAfB cVMpy9HdVbfsKJw2xgrYRK+BY5GTiwTDwCAKFa16IwexlLReRvrtG5ykNRCZOi7UT90e3/eb 4x/qFMI2ETTtEiNnVB4ckdQFv4rhYuW1EukTAW5VCyFhsQftAYcVR1U1wMVbw8FFjclGF6eH DnkQcVZPFFJt1ytU105B4Lg21F50RA3S1fStu//zdtzBQW+/nuz2k5f1f94U+NCAGVHYQUXo sh8kz8bpcE76tiUSx6xOdOuG2cKXYxLOr1EumDhmlcnNiBPSSMb2hDyqIFuT2ywjGom4xcNI D3UZDAxrTfboRaOm+q5HnRtraiwSOMXIUdXrdKo2Jq43+SFGTFDnZqUAErncBNPZPC6p+/aa A+f9qF6YOO45vPJR0SmJgtQfemFuqnyaRZTFwk/oc2fNYm5j2mvl/fiyfsXIr4gd5L8+4uRA T5H/bo4vE3E47B43iuQ9HB/6q1BTeQZNtOlEO9ldCPhv9jlLox/Ti8+0IbHmzf27oTOkKUUL AYfQexgQ7SemfNq2uycDs7Au2LF2lcs4orRk7mK1rgp9Nq/JkaTPtzU5O1G3lb1w2B2WkgBE WDwcXvjuoEFymgUIqNCto4qcqOi9kWmNVPUM2iNVBeleMC9m+xwnGIrpZ4/DbK0lktVhmv4/ QxZjjzaLt2T71yHIqh/hXxubjD1YgU5xMNdnHcfsC32Z0HFczKx55Asx5YUDqFACIR5A+DK1 jhdw0BcQzYJ1I6fX1hyWmVGEFqzN28sA7azdjql1HlI5z8+GIymd0DrpQKGzCgSc1JYBZ2Jv pFfEfhQxrwZanrywihYyWIfbY/Tamhyov9b1ZSF+MhHvmmEVUS7sItWs+/b1nnnf0NJlZsQF HO941t4slqk5KO3VwH59OBivE9sexLApjN9RvcL/ZMArNXl+aRXq6KdVloC8IByrH16fdttJ 8r79td7XkcrN55WtOOdh5WaSDPHZNFI6aNpNypF+oyhqRxhPJU0z1tcxyyjP7yE+jvTREzn7 QSwl6uyIBrtTa3fLmNeK7VnMkjHGm3yozlt2ySXVI/69gstwBeL21v0PWcE0HI+hu94f0eUd 9K2DAgzDcEQqEp2+oDJsLk6YCPmDsApog+zm1/5h/2ey370fN6996BgnLBAzW+bjEK7qYNrR icY2Pt4qtEcR9l1f2njn6bAjXFASYYCZLnan3HrlVtbdHAoqyoqy1ClFwajDxYw05QwZotD1 nR9z4lNN4ealYhFyyS8LyOEwd7VApS/zo9CxakUurRyo+PV6KOsoxfXI0AY19daa6Z6Wa/UT Y2ZYSJXjfieNBXmloFg6MVF2j7iHHoj44xhHEn2UB4ZtSFfPa+hrFO+uj50ZofP4WBYbO95g SFPpMZ3heUzUFHlXsXixeR0EjyOygea6WLsIFiJCylSUa6Me1P//yRE6s6iDAAA= --lrZ03NoBR/3+SXJZ--